xemacs-beta: src/window.c comparison

comparison src/window.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	8eaf7971accc
children	a2f645c6b9f8

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 Lisp_Object Qwindowp, Qwindow_live_p;
 Lisp_Object Qwindow_configurationp;
 Lisp_Object Qscroll_up;
 Lisp_Object Qscroll_down;
-Lisp_Object Qtemp_buffer_show_hook;
 Lisp_Object Qdisplay_buffer;
 #ifdef MEMORY_USAGE_STATS
 Lisp_Object Qface_cache;
 Lisp_Object Qglyph_cache;
 char buf[200];
 if (print_readably)
 error ("printing unreadable object #<window 0x%x>",
 XWINDOW (obj)->header.uid);
 write_c_string ("#<window", printcharfun);
 if (!NILP (XWINDOW (obj)->buffer))
 {
 Lisp_Object name = XBUFFER (XWINDOW (obj)->buffer)->name;
 write_c_string (" on ", printcharfun);
 reset_face_cachels will fail. */
 Lisp_Object
 allocate_window (void)
 {
 Lisp_Object val = Qnil;
-struct window *p = alloc_lcrecord (sizeof (struct window),
+struct window *p = alloc_lcrecord_type (struct window, lrecord_window);
-				     lrecord_window);
 zero_lcrecord (p);
 XSETWINDOW (val, p);
 p->dead = 0;
 p->frame = Qnil;
 p->mini_p = Qnil;
 p->next = Qnil;
 p->prev = Qnil;
 p->hchild = Qnil;
 p->vchild = Qnil;
 p->parent = Qnil;
 p->buffer = Qnil;
 INIT_DISP_VARIABLE (start, Fmake_marker ());
 INIT_DISP_VARIABLE (pointm, Fmake_marker ());
 p->sb_point = Fmake_marker ();
 p->use_time = Qzero;
 INIT_DISP_VARIABLE (last_modified, Qzero);
 INIT_DISP_VARIABLE (last_point, Fmake_marker ());
 INIT_DISP_VARIABLE (last_start, Fmake_marker ());
 INIT_DISP_VARIABLE (last_facechange, Qzero);
-p->face_cachels = Dynarr_new (struct face_cachel);
+p->face_cachels     = Dynarr_new (face_cachel);
-p->glyph_cachels = Dynarr_new (struct glyph_cachel);
+p->glyph_cachels    = Dynarr_new (glyph_cachel);
-p->line_start_cache = Dynarr_new (struct line_start_cache);
+p->line_start_cache = Dynarr_new (line_start_cache);
 p->line_cache_last_updated = Qzero;
 INIT_DISP_VARIABLE (last_point_x, 0);
 INIT_DISP_VARIABLE (last_point_y, 0);
 INIT_DISP_VARIABLE (window_end_pos, 0);
 p->redisplay_end_trigger = Qnil;
 /* Create a new window mirror structure and associated redisplay
 structs. */
 static struct window_mirror *
 new_window_mirror (struct frame *f)
 {
-struct window_mirror *t;
+struct window_mirror *t = xnew_and_zero (struct window_mirror);
-t = (struct window_mirror *)
-xmalloc (sizeof (struct window_mirror));
-memset (t, 0, sizeof (struct window_mirror));
 t->frame = f;
-t->current_display_lines = Dynarr_new (struct display_line);
+t->current_display_lines = Dynarr_new (display_line);
-t->desired_display_lines = Dynarr_new (struct display_line);
+t->desired_display_lines = Dynarr_new (display_line);
 t->buffer = NULL;
 #ifdef HAVE_SCROLLBARS
 t->scrollbar_vertical_instance = NULL;
 t->scrollbar_horizontal_instance = NULL;
 {
 /* The redisplay structures are big.  Leaving them around in
 non-leaf windows can add up to a lot of wasted space.  So
 don't do it. */
 free_display_structs (mir);
-mir->current_display_lines = Dynarr_new (struct display_line);
+mir->current_display_lines = Dynarr_new (display_line);
-mir->desired_display_lines = Dynarr_new (struct display_line);
+mir->desired_display_lines = Dynarr_new (display_line);
 #ifdef HAVE_SCROLLBARS
 update_window_scrollbars (XWINDOW (win), mir, 0, 0);
 #endif
 mir->buffer = NULL;
 }
 int
 window_bottom_gutter_height (struct window *w)
 {
 int other_height;
 if (!NILP (w->hchild) || !NILP (w->vchild))
 return 0;
 else
 other_height =
 VALUE should be a buffer position (typically a marker) or nil.
 If it is a buffer position, then if redisplay in WINDOW reaches a position
 beyond VALUE, the functions in `redisplay-end-trigger-functions' are called
 with two arguments: WINDOW, and the end trigger value.
 Afterwards the end-trigger value is reset to nil.
 */
 	 (window, value))
 {
 return (decode_window (window)->redisplay_end_trigger = value);
 }
 So, we check by scanning all the ancestors of the
 frame's selected window and comparing each one with
 WINDOW.  */
 {
 Lisp_Object pwindow;
 pwindow = FRAME_SELECTED_WINDOW (f);
 while (!NILP (pwindow))
 {
 	if (EQ (window, pwindow))
 	  break;
 	pwindow = XWINDOW (pwindow)->parent;
 if (EQ (window, pwindow))
 {
 	/* OK, we found it. */
 	Lisp_Object alternative;
 	alternative = Fnext_window (window, Qlambda, Qnil, Qnil);
 	/* If we're about to delete the selected window on the
 	   selected frame, then we should use Fselect_window to select
 	   the new window.  On the other hand, if we're about to
 	   delete the selected window on any other frame, we shouldn't do
 	   anything but set the frame's selected_window slot.  */
 unchain_marker (w->sb_point);
 /* This breaks set-window-configuration if windows in the saved
 	 configuration get deleted and multiple frames are in use. */
 /* w->buffer = Qnil; */
 }
 /* close up the hole in the sibling list */
 if (!NILP (w->next))
 XWINDOW (w->next)->prev = w->prev;
 if (!NILP (w->prev))
 XWINDOW (w->prev)->next = w->next;
 	   children.  */
 	sib = w->next;
 	WINDOW_TOP (XWINDOW (sib)) = WINDOW_TOP (w);
 	WINDOW_LEFT (XWINDOW (sib)) = WINDOW_LEFT (w);
 }
 /* Stretch that sibling.  */
 if (!NILP (par->vchild))
 set_window_pixheight
 	(sib, (WINDOW_HEIGHT (XWINDOW (sib)) + WINDOW_HEIGHT (w)), 1);
 if (!NILP (par->hchild))
 GET_BUFFER_MRU_WINDOW		/* Arg is buffer */
 };
 static Lisp_Object
 window_loop (enum window_loop type,
 Lisp_Object obj,
 int mini,
 Lisp_Object frames,
 	     int dedicated_too,
 	     Lisp_Object console)
 {
 Lisp_Object frame_arg = Qt;
 int count = 0;		/* for GET_BUFFER_WINDOW_COUNT */
 /* #### I think the change of "precomputing" last_window and next_window
 * ####  catch the lossage this is meant(?) to punt on...
 */
 int lose_lose = 0;
 Lisp_Object devcons, concons;
 /* FRAME_ARG is Qlambda to stick to one frame,
 Qvisible to consider all visible frames,
 or Qt otherwise.  */
 frame_arg = Qlambda;
 else if (ZEROP (frames))
 frame_arg = frames;
 else if (EQ (frames, Qvisible))
 frame_arg = frames;
 DEVICE_LOOP_NO_BREAK (devcons, concons)
 {
 Lisp_Object device = XCAR (devcons);
 Lisp_Object the_frame = Qnil;
 	  /* Pick the next window now, since some operations will delete
 	     the current window.  */
 	  next_window = Fnext_window (w, mini ? Qt : Qnil, frame_arg, Qt);
 	  /* #### Still needed ?? */
 	  /* Given the outstanding quality of the rest of this code,
 	     I feel no shame about putting this piece of shit in. */
 	  if (++lose_lose >= 500)
 	    return Qnil;
 	  /* Note that we do not pay attention here to whether
 			}
 		    }
 		  break;
 		}
 	      default:
 		abort ();
 	      }
 	  if (EQ (w, last_window))
 	    break;
 }
 int
 buffer_window_mru (struct window *w)
 {
 Lisp_Object window =
 window_loop (GET_BUFFER_MRU_WINDOW, w->buffer, 0, w->frame, 1, Qnil);
 if (NILP (window))
 return 0;
 else if (XWINDOW (window) == w)
 */
 (window))
 {
 struct window *w;
 Lisp_Object old_selected_window = Fselected_window (Qnil);
 CHECK_LIVE_WINDOW (window);
 w = XWINDOW (window);
 /* we have already caught dead-window errors */
 if (!NILP (w->hchild) || !NILP (w->vchild))
 MARK_WINDOWS_CHANGED (ow);
 }
 /* now select the window's frame */
 set_frame_selected_window (XFRAME (WINDOW_FRAME (w)), window);
 select_frame_1 (WINDOW_FRAME (w));
 /* also select the window's buffer */
 Frecord_buffer (w->buffer);
 Fset_buffer (w->buffer);
 w->hscroll = 0;
 set_marker_restricted (w->start[CURRENT_DISP], make_int (1), buf);
 set_marker_restricted (w->pointm[CURRENT_DISP], make_int (1), buf);
 set_marker_restricted (w->sb_point, make_int (1), buf);
 /* Run temp-buffer-show-hook, with the chosen window selected.  */
 if (!preparing_for_armageddon)
 	{
 	  Lisp_Object tem;
 	  tem = Fboundp (Qtemp_buffer_show_hook);
 	  if (!NILP (tem))
 static void
 make_dummy_parent (Lisp_Object window)
 {
 Lisp_Object new = Qnil;
 struct window *o = XWINDOW (window);
-struct window *p = alloc_lcrecord (sizeof (struct window),
+struct window *p = alloc_lcrecord_type (struct window, lrecord_window);
-				     lrecord_window);
 XSETWINDOW (new, p);
 copy_lcrecord (p, o);
 /* Don't copy the pointers to the line start cache or the face
 instances. */
-p->line_start_cache = Dynarr_new (struct line_start_cache);
+p->line_start_cache = Dynarr_new (line_start_cache);
-p->face_cachels = Dynarr_new (struct face_cachel);
+p->face_cachels     = Dynarr_new (face_cachel);
-p->glyph_cachels = Dynarr_new (struct glyph_cachel);
+p->glyph_cachels    = Dynarr_new (glyph_cachel);
 /* Put new into window structure in place of window */
 replace_window (window, new);
 o->next = Qnil;
 if (NILP (horflag))
 {
 if (size < window_min_height)
 	error ("Window height %d too small (after splitting)", size);
 if (size + window_min_height > window_char_height (o, 1))
 	error ("Window height %d too small (after splitting)",
 	       window_char_height (o, 1) - size);
 if (NILP (o->parent)
 	  || NILP (XWINDOW (o->parent)->vchild))
 	{
 	  make_dummy_parent (window);
 else
 {
 if (size < window_min_width)
 	error ("Window width %d too small (after splitting)", size);
 if (size + window_min_width > window_char_width (o, 0))
 	error ("Window width %d too small (after splitting)",
 	       window_char_width (o, 0) - size);
 if (NILP (o->parent)
 	  || NILP (XWINDOW (o->parent)->hchild))
 	{
 	  make_dummy_parent (window);
 p->parent = o->parent;
 p->buffer = Qt;
 reset_face_cachels (p);
 reset_glyph_cachels (p);
 /* Apportion the available frame space among the two new windows */
 if (!NILP (horflag))
 {
 {
 int avail_height;
 int defheight, defwidth;
 int char_height;
 Lisp_Object window;
 XSETWINDOW (window, w);
 avail_height = (pixel_height -
 		  (include_gutters_p ? 0 :
 		   window_top_gutter_height (w) +
 		   window_bottom_gutter_height (w)));
 default_face_height_and_width (window, &defheight, &defwidth);
 char_height = avail_height / defheight;
 /* It's the calling function's responsibility to check these values
 int avail_height;
 int defheight, defwidth;
 int pixel_height;
 Lisp_Object window;
 XSETWINDOW (window, w);
 default_face_height_and_width (window, &defheight, &defwidth);
 avail_height = char_height * defheight;
 pixel_height = (avail_height +
 		  (include_gutters_p ? 0 :
 {
 int avail_width;
 int char_width;
 int defheight, defwidth;
 Lisp_Object window;
 XSETWINDOW (window, w);
 avail_width = (pixel_width -
 		 window_left_gutter_width (w, 0) -
 		 window_right_gutter_width (w, 0) -
 		 (include_margins_p ? 0 : window_left_margin_width (w)) -
 		 (include_margins_p ? 0 : window_right_margin_width (w)));
 default_face_height_and_width (window, &defheight, &defwidth);
 char_width = (avail_width / defwidth);
 /* It's the calling function's responsibility to check these values
 and make sure they're not out of range.
 ? (*sizefun) (parent) - *sizep
 		: ((!NILP (w->next))
 ? (*sizefun) (w->next) - MINSIZE (w->next)
 : ((!NILP (w->prev))
 ? (*sizefun) (w->prev) - MINSIZE (w->prev)
 /* This is a frame with only one window,
 a minibuffer-only or a minibufferless frame.  */
 : (delta = 0))));
 if (delta > maxdelta)
 /* This case traps trying to make the minibuffer
 window_scroll (Fselected_window (Qnil), n, -1, errb);
 return Qnil;
 }
 DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling, 0, 0, 0, /*
-Return the other window for \"other window scroll\" commands.
+Return the other window for "other window scroll" commands.
 If in the minibuffer, `minibuffer-scroll-window' if non-nil
 specifies the window.
 If `other-window-scroll-buffer' is non-nil, a window
 showing that buffer is used.
 */
 startp = start_with_point_on_display_line (w, opoint, XINT (n));
 }
 Fset_marker (w->start[CURRENT_DISP], make_int (startp), w->buffer);
 w->start_at_line_beg = beginning_of_line_p (b, startp);
 w->force_start = 1;
 MARK_WINDOWS_CHANGED (w);
 return Qnil;
 }
 static int
 map_windows_1 (Lisp_Object window,
 	       int (*mapfun) (struct window *w, void *closure),
 	       void *closure)
 {
 int retval;
 for (; !NILP (window); window = XWINDOW (window)->next)
 {
 struct window *w = XWINDOW (window);
 if (!NILP (w->vchild))
 #define CHECK_WINDOW_CONFIGURATION(x) CHECK_RECORD (x, window_configuration)
 DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION ("window-configuration",
 					window_configuration,
 					mark_window_config,
 					print_window_config,
 					0, 0, 0, sizeof_window_config,
 					struct window_config);
 static Lisp_Object
 mark_window_config (Lisp_Object obj, void (*markobj) (Lisp_Object))
 }
 static unsigned int
 sizeof_window_config (CONST void *h)
 {
-CONST struct window_config *c = h;
+CONST struct window_config *c = (CONST struct window_config *) h;
 return sizeof_window_config_for_n_windows (c->saved_windows_count);
 }
 static void
 print_window_config (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 /* restore the frame characteristics */
 #ifdef ENERGIZE
 if (FRAME_X_P (f))
 	{
 	  Lisp_Object new_desired = config->p_sheet_buffer;
 	  if (BUFFERP (new_desired) &&
 	      !BUFFER_LIVE_P (XBUFFER (new_desired)))
 	    new_desired = Qnil;	/* the desired buffer was killed */
 	  /* need to restore the desired buffer */
 	  if (!EQ (new_desired, desired_psheet_buffer (f)))
 	    make_psheets_desired (f, new_desired);
 	}
 #endif
 new_current_buffer = config->current_buffer;
 if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer)))
 	new_current_buffer = Qnil;
 /*
 	  /* The window might be dead.  In this case, its redisplay
 	     structures were freed, so we need to reallocate them. */
 	  if (!w->face_cachels)
 	    {
-	      w->face_cachels = Dynarr_new (struct face_cachel);
+	      w->face_cachels = Dynarr_new (face_cachel);
 	      reset_face_cachels (w);
 	    }
 	  if (!w->glyph_cachels)
-	    w->glyph_cachels = Dynarr_new (struct glyph_cachel);
+	    w->glyph_cachels = Dynarr_new (glyph_cachel);
 	  if (!w->line_start_cache)
-	    w->line_start_cache = Dynarr_new (struct line_start_cache);
+	    w->line_start_cache = Dynarr_new (line_start_cache);
 	  w->dead = 0;
 	  if (p->parent_index >= 0)
 	    w->parent = SAVED_WINDOW_N (config, p->parent_index)->window;
 	  else
 XWINDOW_CONFIGURATION (allocate_managed_lcrecord
 			     (Vwindow_configuration_free_list
 			      [n_windows - 1]));
 else
 /* More than ten windows; just allocate directly */
-config = alloc_lcrecord (sizeof_window_config_for_n_windows (n_windows),
+config = (struct window_config *)
-			     lrecord_window_configuration);
+alloc_lcrecord (sizeof_window_config_for_n_windows (n_windows),
+		      lrecord_window_configuration);
 XSETWINDOW_CONFIGURATION (result, config);
 config->frame_width = FRAME_WIDTH (f);
 config->frame_height = FRAME_HEIGHT (f);
 config->current_window = FRAME_SELECTED_WINDOW (f);
 set_specifier_caching (Vmodeline_shadow_thickness,
 			 slot_offset (struct window,
 				      modeline_shadow_thickness),
 			 modeline_shadow_thickness_changed,
 			 0, 0);
 DEFVAR_SPECIFIER ("has-modeline-p", &Vhas_modeline_p /*
 *Whether the modeline should be displayed.
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vhas_modeline_p = Fmake_specifier (Qboolean);

Mercurial > hg > xemacs-beta

comparison src/window.c @ 185:3d6bfa290dbd r20-3b19