xemacs-beta: src/window.c comparison

comparison src/window.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	966663fcf606
children	ca9a9ec9c1c1

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 #include "glyphs.h"
 #include "redisplay.h"
 #include "window.h"
 #include "commands.h"
-Lisp_Object Qwindowp, Qwindow_live_p;
+Lisp_Object Qwindowp, Qwindow_live_p, Qwindow_configurationp;
-Lisp_Object Qwindow_configurationp;
+Lisp_Object Qscroll_up, Qscroll_down, Qdisplay_buffer;
-Lisp_Object Qscroll_up;
-Lisp_Object Qscroll_down;
-Lisp_Object Qdisplay_buffer;
 #ifdef MEMORY_USAGE_STATS
-Lisp_Object Qface_cache;
+Lisp_Object Qface_cache, Qglyph_cache, Qline_start_cache, Qother_redisplay;
-Lisp_Object Qglyph_cache;
-Lisp_Object Qline_start_cache;
 #ifdef HAVE_SCROLLBARS
 Lisp_Object Qscrollbar_instances;
 #endif
-Lisp_Object Qother_redisplay;
 #endif
+EXFUN (Fnext_window, 4);
 static int window_pixel_width_to_char_width (struct window *w,
 					     int pixel_width,
 					     int include_margins_p);
 static int window_char_width_to_pixel_width (struct window *w,
 					       int include_gutters_p);
 static void change_window_height (struct window *w, int delta, int widthflag,
 int inpixels);
 static int window_displayed_pixel_height (struct window *);
 /* Thickness of shadow border around 3d modelines. */
 Lisp_Object Vmodeline_shadow_thickness;
 /* Whether a modeline should be displayed. */
 Lisp_Object Vhas_modeline_p;
 (w)->last_facechange[DESIRED_DISP] = Qzero;	\
 (w)->last_facechange[CMOTION_DISP] = Qzero;	\
 } while (0)
-static Lisp_Object mark_window (Lisp_Object, void (*) (Lisp_Object));
-static void print_window (Lisp_Object, Lisp_Object, int);
-static void finalize_window (void *header, int for_disksave);
-DEFINE_LRECORD_IMPLEMENTATION ("window", window,
-mark_window, print_window, finalize_window,
-			       0, 0, struct window);
 #define MARK_DISP_VARIABLE(field)		\
 ((markobj) (window->field[CURRENT_DISP]));	\
 ((markobj) (window->field[DESIRED_DISP]));	\
 ((markobj) (window->field[CMOTION_DISP]));
 Dynarr_free (w->glyph_cachels);
 w->glyph_cachels = 0;
 }
 }
+DEFINE_LRECORD_IMPLEMENTATION ("window", window,
+mark_window, print_window, finalize_window,
+			       0, 0, struct window);
 #define INIT_DISP_VARIABLE(field, initialization)	\
 p->field[CURRENT_DISP] = initialization;		\
 p->field[DESIRED_DISP] = initialization;		\
 p->field[CMOTION_DISP] = initialization;
 here because the window must have its frame pointer set or
 reset_face_cachels will fail. */
 Lisp_Object
 allocate_window (void)
 {
-Lisp_Object val = Qnil;
+Lisp_Object val;
 struct window *p = alloc_lcrecord_type (struct window, lrecord_window);
 zero_lcrecord (p);
 XSETWINDOW (val, p);
 #ifdef HAVE_TOOLBARS
 p->toolbar_size[0] = Qnil;
 p->toolbar_size[1] = Qnil;
 p->toolbar_size[2] = Qnil;
 p->toolbar_size[3] = Qnil;
+p->toolbar_buttons_captioned_p = Qnil;
 #endif
 p->minimum_line_ascent = Qnil;
 p->minimum_line_descent = Qnil;
 p->use_left_overflow = Qnil;
 p->use_right_overflow = Qnil;
 #ifdef HAVE_MENUBARS
 p->menubar_visible_p = Qnil;
-#endif
-#ifdef HAVE_TOOLBARS
-p->toolbar_buttons_captioned_p = Qnil;
 #endif
 p->text_cursor_visible_p = Qnil;
 /* end cached specifier values. */
 p->dedicated = Qnil;
 if (NILP (win))
 {
 if (mir)
 	{
 	  free_window_mirror (mir);
-	  mir = 0;
+	  mir = NULL;
 	}
 return mir;
 }
 else
 if (!mir)
 redisplay structures. */
 static struct window_mirror *
 find_window_mirror_internal (Lisp_Object win, struct window_mirror *rmir,
 			    struct window *w)
 {
-struct window_mirror *retval;
 for (; !NILP (win); win = XWINDOW (win)->next, rmir = rmir->next)
 {
 if (w == XWINDOW (win))
 	return rmir;
-if (!NILP (XWINDOW (win)->vchild) &&
-	  (retval = find_window_mirror_internal (XWINDOW (win)->vchild,
+if (!NILP (XWINDOW (win)->vchild))
-						 rmir->vchild, w)))
+	{
-	return retval;
+	  struct window_mirror *retval =
-if (!NILP (XWINDOW (win)->hchild) &&
+	    find_window_mirror_internal (XWINDOW (win)->vchild,
-	  (retval = find_window_mirror_internal (XWINDOW (win)->hchild,
+					 rmir->vchild, w);
-						 rmir->hchild, w)))
+	  if (retval) return retval;
-	return retval;
+	}
+if (!NILP (XWINDOW (win)->hchild))
+	{
+	  struct window_mirror *retval =
+	    find_window_mirror_internal (XWINDOW (win)->hchild,
+					 rmir->hchild, w);
+	  if (retval) return retval;
+	}
 }
 return 0;
 }
 /* Free a given mirror structure along with all of its children as
 well as their associated display structures. */
 void
 free_window_mirror (struct window_mirror *mir)
 {
-struct window_mirror *p;
-p = mir;
 while (mir)
 {
+struct window_mirror *prev = mir;
 if (mir->hchild) free_window_mirror (mir->hchild);
 if (mir->vchild) free_window_mirror (mir->vchild);
 #ifdef HAVE_SCROLLBARS
 release_window_mirror_scrollbars (mir);
 #endif
 free_display_structs (mir);
 mir = mir->next;
-xfree (p);
+xfree (prev);
-p = mir;
 }
 }
 /* Given a mirror structure, return the window it mirrors.  Calls
 real_window_internal to do most of the work. */
 Lisp_Object
 real_window (struct window_mirror *mir, int no_abort)
 {
-Lisp_Object retval;
+Lisp_Object retval = real_window_internal (mir->frame->root_window,
+					     mir->frame->root_mirror, mir);
-retval = real_window_internal (mir->frame->root_window,
-				 mir->frame->root_mirror, mir);
 if (NILP (retval) && !no_abort)
 abort ();
 return retval;
 }
 Given a pixel position relative to a frame, find the window at that
 position.
 ****************************************************************************/
 struct window *
-find_window_by_pixel_pos (unsigned int pix_x, unsigned int pix_y,
+find_window_by_pixel_pos (int pix_x, int pix_y, Lisp_Object win)
-			  Lisp_Object win)
+{
-{
-struct window *w;
 if (NILP (win))
 return 0;
 for (; !NILP (win); win = XWINDOW (win)->next)
 {
-if (!NILP (XWINDOW (win)->vchild) &&
+struct window *w;
-	  (w = find_window_by_pixel_pos (pix_x, pix_y, XWINDOW (win)->vchild)))
-	return w;
+if (!NILP (XWINDOW (win)->vchild))
-if (!NILP (XWINDOW (win)->hchild) &&
+	{
-	  (w = find_window_by_pixel_pos (pix_x, pix_y, XWINDOW (win)->hchild)))
+	  w = find_window_by_pixel_pos (pix_x, pix_y, XWINDOW (win)->vchild);
-	return w;
+	  if (w) return w;
+	}
+if (!NILP (XWINDOW (win)->hchild))
+	{
+	  w = find_window_by_pixel_pos (pix_x, pix_y, XWINDOW (win)->hchild);
+	  if (w) return w;
+	}
 w = XWINDOW (win);
 if (pix_x >= WINDOW_LEFT (w)
 	  && pix_x <= WINDOW_RIGHT (w)
 	  && pix_y >= WINDOW_TOP (w)
 	  && pix_y <= WINDOW_BOTTOM (w))
 	return w;
 }
-return 0;
+return NULL;
 }
 /* Return a pointer to the display structures for the given window. */
 display_line_dynarr *
 window_display_lines (struct window *w, int which)
 {
 struct buffer *b;
 int window_cwidth = window_char_width (w, 1);
 int margin_cwidth;
 int font_width;
-Lisp_Object window = Qnil;
+Lisp_Object window;
 /* We might be getting called on a non-leaf. */
 if (NILP (w->buffer))
 return 0;
 is a console, the selected frame on that console's selected device will
 be used.  Otherwise, the selected frame is used.
 */
 (con_dev_or_frame))
 {
-struct frame *f;
 if (NILP (con_dev_or_frame) && NILP (Fselected_device (Qnil)))
 return Qnil; /* happens at startup */
-f = decode_frame_or_selected (con_dev_or_frame);
+{
-return FRAME_SELECTED_WINDOW (f);
+struct frame *f = decode_frame_or_selected (con_dev_or_frame);
+return FRAME_SELECTED_WINDOW (f);
+}
 }
 DEFUN ("minibuffer-window", Fminibuffer_window, 0, 1, 0, /*
 Return the window used now for minibuffers.
 If the optional argument CON-DEV-OR-FRAME is specified and is a frame, return
 is a console, the selected frame on that console's selected device will
 be used.  Otherwise, the selected frame is used.
 */
 (con_dev_or_frame))
 {
-struct frame *f = decode_frame_or_selected (con_dev_or_frame);
+return FRAME_MINIBUF_WINDOW (decode_frame_or_selected (con_dev_or_frame));
-return FRAME_MINIBUF_WINDOW (f);
 }
 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, 1, 1, 0, /*
 Return non-nil if WINDOW is a minibuffer window.
 */
 POS defaults to point in WINDOW's buffer; WINDOW, to the selected window.
 */
 (pos, window))
 {
 struct window *w = decode_window (window);
-Bufpos top;
+Bufpos top = marker_position (w->start[CURRENT_DISP]);
 Bufpos posint;
-struct buffer *buf;
+struct buffer *buf = XBUFFER (w->buffer);
-top = marker_position (w->start[CURRENT_DISP]);
-buf = XBUFFER (w->buffer);
 if (NILP (pos))
 posint = BUF_PT (buf);
 else
 {
 /* w->start can be out of range.  If it is, do something reasonable.  */
 if (top < BUF_BEGV (buf) || top > BUF_ZV (buf))
 return Qnil;
-if (point_would_be_visible (w, top, posint))
+return point_would_be_visible (w, top, posint) ? Qt : Qnil;
-return Qt;
-else
-return Qnil;
 }
 struct window *
 decode_window (Lisp_Object window)
 }
 DEFUN ("window-displayed-height", Fwindow_displayed_height, 0, 1, 0, /*
 Return the number of lines currently displayed in WINDOW.
 This counts the actual number of lines displayed in WINDOW
-(as opposed to `window-height').  The modeline and horizontal
+\(as opposed to `window-height').  The modeline and horizontal
 scrollbar do not count as lines.  If there is some blank space
 between the end of the buffer and the end of the window, this
 function pretends that there are lines of text in the default
 font there.
 */
 }
 DEFUN ("window-displayed-pixel-height", Fwindow_displayed_pixel_height, 0, 1, 0, /*
 Return the height in pixels of the buffer-displaying portion of WINDOW.
 Unlike `window-pixel-height', the space occupied by the gutters
-(modeline, horizontal scrollbar, ...) is not counted.
+\(modeline, horizontal scrollbar, ...) is not counted.
 */
 (window))
 {
 return make_int (window_displayed_pixel_height (decode_window (window)));
 }
 return make_int (decode_window (window)->hscroll);
 }
 #ifdef MODELINE_IS_SCROLLABLE
 DEFUN ("modeline-hscroll", Fmodeline_hscroll, 0, 1, 0, /*
 Return the number of columns by which WINDOW's modeline is scrolled from
 left margin. If the window has no modeline, return nil.
 */
 (window))
 {
 struct window *w;
 w = decode_window (window);
 return (WINDOW_HAS_MODELINE_P (w)) ? make_int (w->modeline_hscroll) : Qnil;
 }
-#endif
+DEFUN ("set-modeline-hscroll", Fset_modeline_hscroll, 2, 2, 0, /*
+Set number of columns WINDOW's modeline is scrolled from left margin to NCOL.
+NCOL should be zero or positive. If NCOL is negative, it will be forced to 0.
+If the window has no modeline, do nothing and return nil.
+*/
+(window, ncol))
+{
+struct window *w;
+int ncols;
+w = decode_window (window);
+if (WINDOW_HAS_MODELINE_P (w))
+{
+CHECK_INT (ncol);
+ncols = XINT (ncol);
+if (ncols < 0) ncols = 0;
+if (w->modeline_hscroll != ncols)
+	MARK_MODELINE_CHANGED;
+w->modeline_hscroll = ncols;
+return ncol;
+}
+return Qnil;
+}
+#endif /* MODELINE_IS_SCROLLABLE */
 DEFUN ("set-window-hscroll", Fset_window_hscroll, 2, 2, 0, /*
 Set number of columns WINDOW is scrolled from left margin to NCOL.
 NCOL should be zero or positive.
 */
 if (w->hscroll != ncols)
 MARK_CLIP_CHANGED;	/* FSF marks differently but we aren't FSF. */
 w->hscroll = ncols;
 return ncol;
 }
-#ifdef MODELINE_IS_SCROLLABLE
-DEFUN ("set-modeline-hscroll", Fset_modeline_hscroll, 2, 2, 0, /*
-Set number of columns WINDOW's modeline is scrolled from left margin to NCOL.
-NCOL should be zero or positive. If NCOL is negative, it will be forced to 0.
-If the window has no modeline, do nothing and return nil.
-*/
-(window, ncol))
-{
-struct window *w;
-int ncols;
-w = decode_window (window);
-if (WINDOW_HAS_MODELINE_P (w))
-{
-CHECK_INT (ncol);
-ncols = XINT (ncol);
-if (ncols < 0) ncols = 0;
-if (w->modeline_hscroll != ncols)
-	MARK_MODELINE_CHANGED;
-w->modeline_hscroll = ncols;
-return ncol;
-}
-return Qnil;
-}
-#endif
 #if 0 /* bogus crock */
 xxDEFUN ("window-redisplay-end-trigger",
 	 Fwindow_redisplay_end_trigger, 0, 1, 0, /*
 nothing else changes in the meantime.  This function is potentially much
 slower with this flag set.
 */
 (window, guarantee))
 {
-Lisp_Object value;
 struct window *w = decode_window (window);
-Lisp_Object buf;
 if (NILP (guarantee))
 {
-buf = w->buffer;
+Lisp_Object buf = w->buffer;
 CHECK_BUFFER (buf);
+return make_int (BUF_Z (XBUFFER (buf)) - w->window_end_pos[CURRENT_DISP]);
-XSETINT (value, BUF_Z (XBUFFER (buf)) - w->window_end_pos[CURRENT_DISP]);
-return value;
 }
 else
 {
 Bufpos startp = marker_position (w->start[CURRENT_DISP]);
 return make_int (end_of_last_line (w, startp));
 The second argument is the new value for the dedication flag;
 non-nil means yes.
 */
 (window, arg))
 {
-REGISTER struct window *w = decode_window (window);
+struct window *w = decode_window (window);
 w->dedicated = NILP (arg) ? Qnil : Qt;
 return w->dedicated;
 }
 frame_arg = frames;
 DEVICE_LOOP_NO_BREAK (devcons, concons)
 {
 Lisp_Object device = XCAR (devcons);
-Lisp_Object the_frame = Qnil;
+Lisp_Object the_frame;
 if (frame)
 	XSETFRAME (the_frame, frame);
 else
 	the_frame = DEVICE_SELECTED_FRAME (XDEVICE (device));
 /* #### This is very likely incorrect and instead the char_to_pixel_
 functions should be called. */
 default_face_height_and_width (window, &defheight, &defwidth);
 line_size = (set_height ? defheight : defwidth);
+check_min_window_sizes ();
 minsize = (set_height ? window_min_height : window_min_width);
 minsize *= line_size;
-check_min_window_sizes ();
 if (!nodelete
 && !TOP_LEVEL_WINDOW_P (w)
 && new_pixsize < minsize)
 {
 BUF_SAVE_MODIFF (XBUFFER (buf)) = BUF_MODIFF (b);
 widen_buffer (b, 0);
 BUF_SET_PT (b, BUF_BEG (b));
-if (!EQ (Vtemp_buffer_show_function, Qnil))
+if (!NILP (Vtemp_buffer_show_function))
 call1 (Vtemp_buffer_show_function, buf);
 else
 {
 window = display_buffer (buf, Qnil, same_frame);
 }
 static void
 make_dummy_parent (Lisp_Object window)
 {
-Lisp_Object new = Qnil;
+Lisp_Object new;
 struct window *o = XWINDOW (window);
 struct window *p = alloc_lcrecord_type (struct window, lrecord_window);
 XSETWINDOW (new, p);
 copy_lcrecord (p, o);
 /* It's the calling function's responsibility to check these values
 and make sure they're not out of range.
 #### We need to go through the calling functions and actually
 do this. */
-if (char_height < 0)
+return max (0, char_height);
-return 0;
-else
-return char_height;
 }
 static int
 window_char_height_to_pixel_height (struct window *w, int char_height,
 				    int include_gutters_p)
 /* It's the calling function's responsibility to check these values
 and make sure they're not out of range.
 #### We need to go through the calling functions and actually
 do this. */
-if (pixel_height < 0)
+return max (0, pixel_height);
-return 0;
-else
-return pixel_height;
 }
 /* Return number of default lines of text can fit in the window W.
 If INCLUDE_GUTTERS_P is 1, include "gutter" space (modeline plus
 horizontal scrollbar) in the space that is used for the calculation.
 return num_lines;
 }
 /*
 * Return height in pixels of buffer-displaying portion of window w.
 * Does not include the gutters (modeline, scrollbars, ...)
 */
 int
 window_displayed_pixel_height (struct window *w)
 {
 /* It's the calling function's responsibility to check these values
 and make sure they're not out of range.
 #### We need to go through the calling functions and actually
 do this. */
-if (char_width < 0)
+return max (0, char_width);
-return 0;
-else
-return char_width;
 }
 static int
 window_char_width_to_pixel_width (struct window *w, int char_width,
 				  int include_margins_p)
 /* It's the calling function's responsibility to check these values
 and make sure they're not out of range.
 #### We need to go through the calling functions and actually
 do this. */
-if (pixel_width < 0)
+return max (0, pixel_width);
-return 0;
-else
-return pixel_width;
 }
 /* This returns the usable space which doesn't include space needed by
 scrollbars or divider lines. */
 int
 static void
 change_window_height (struct window *win, int delta, int widthflag,
 int inpixels)
 {
 Lisp_Object parent;
-Lisp_Object window = Qnil;
+Lisp_Object window;
 struct window *w;
 struct frame *f;
 int *sizep;
 int (*sizefun) (Lisp_Object) = (widthflag
 				  ? window_pixel_width
 w = XWINDOW (window);
 b = XBUFFER (w->buffer);
 opoint = BUF_PT (b);
-if (NILP (n) || CONSP (n))
+if (LISTP (n))
 {
 struct frame *f = XFRAME (w->frame);
 if (NILP (n))
 	{
 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)
 {
+int retval;
 struct window *w = XWINDOW (window);
 if (!NILP (w->vchild))
 	retval = map_windows_1 (w->vchild, mapfun, closure);
 else if (!NILP (w->hchild))
 	retval = map_windows_1 (w->hchild, mapfun, closure);
 else
 	retval = (mapfun) (w, closure);
 if (retval)
 	return retval;
 }
-return retval;
+return 0;
 }
 /* Map MAPFUN over the windows in F.  CLOSURE is passed to each
 invocation of MAPFUN.  If any invocation of MAPFUN returns
 non-zero, the mapping is halted.  Otherwise, map_windows() maps
 static void
 compute_window_usage (struct window *w, struct window_stats *stats,
 		      struct overhead_stats *ovstats)
 {
-memset (stats, 0, sizeof (*stats));
+xzero (*stats);
 stats->other += malloced_storage_size (w, sizeof (struct window), ovstats);
 stats->face += compute_face_cachel_usage (w->face_cachels, ovstats);
 stats->glyph += compute_glyph_cachel_usage (w->glyph_cachels, ovstats);
 stats->line_start +=
 compute_line_start_cache_dynarr_usage (w->line_start_cache, ovstats);
 compute_window_mirror_usage (find_window_mirror (w), stats, ovstats);
 }
 DEFUN ("window-memory-usage", Fwindow_memory_usage, 1, 1, 0, /*
 Return stats about the memory usage of window WINDOW.
-The values returned are in the form an alist of usage types and byte
+The values returned are in the form of an alist of usage types and byte
 counts.  The byte counts attempt to encompass all the memory used
 by the window (separate from the memory logically associated with a
 buffer or frame), including internal structures and any malloc()
 overhead associated with them.  In practice, the byte counts are
 underestimated because certain memory usage is very hard to determine
-(e.g. the amount of memory used inside the Xt library or inside the
+\(e.g. the amount of memory used inside the Xt library or inside the
 X server) and because there is other stuff that might logically
 be associated with a window, buffer, or frame (e.g. window configurations,
 glyphs) but should not obviously be included in the usage counts.
 Multiple slices of the total memory usage may be returned, separated
 */
 (window))
 {
 struct window_stats stats;
 struct overhead_stats ovstats;
+Lisp_Object val = Qnil;
 CHECK_WINDOW (window); /* dead windows should be allowed, no? */
-memset (&ovstats, 0, sizeof (ovstats));
+xzero (ovstats);
 compute_window_usage (XWINDOW (window), &stats, &ovstats);
-return nconc2 (
+val = acons (Qface_cache,          make_int (stats.face),              val);
+val = acons (Qglyph_cache,         make_int (stats.glyph),             val);
 #ifdef HAVE_SCROLLBARS
-		 list6
+val = acons (Qscrollbar_instances, make_int (stats.scrollbar),         val);
-#else
-		 list5
 #endif
-		 (Fcons (Qface_cache, make_int (stats.face)),
+val = acons (Qline_start_cache,    make_int (stats.line_start),        val);
-		  Fcons (Qglyph_cache, make_int (stats.glyph)),
+val = acons (Qother_redisplay,     make_int (stats.other_redisplay),   val);
-#ifdef HAVE_SCROLLBARS
+val = acons (Qother,               make_int (stats.other),             val);
-		  Fcons (Qscrollbar_instances, make_int (stats.scrollbar)),
+val = Fcons (Qnil, val);
-#endif
+val = acons (Qactually_requested,  make_int (ovstats.was_requested),   val);
-		  Fcons (Qline_start_cache, make_int (stats.line_start)),
+val = acons (Qmalloc_overhead,     make_int (ovstats.malloc_overhead), val);
-		  Fcons (Qother_redisplay, make_int (stats.other_redisplay)),
+val = acons (Qdynarr_overhead,     make_int (ovstats.dynarr_overhead), val);
-		  Fcons (Qother, make_int (stats.other))),
-		 list4 (Qnil,
+return Fnreverse (val);
-			Fcons (Qactually_requested,
-			       make_int (ovstats.was_requested)),
-			Fcons (Qmalloc_overhead,
-			       make_int (ovstats.malloc_overhead)),
-			Fcons (Qdynarr_overhead,
-			       make_int (ovstats.dynarr_overhead))));
 }
 #endif /* MEMORY_USAGE_STATS */
 int min_width, min_height;
 int saved_windows_count;
 /* Zero-sized arrays aren't ANSI C */
 struct saved_window saved_windows[1];
 };
 #define SAVED_WINDOW_N(conf, n) (&((conf)->saved_windows[(n)]))
-static Lisp_Object mark_window_config (Lisp_Object, void (*) (Lisp_Object));
-static void print_window_config (Lisp_Object, Lisp_Object, int);
-static unsigned int sizeof_window_config (CONST void *);
 #define XWINDOW_CONFIGURATION(x) XRECORD (x, window_configuration, struct window_config)
 #define XSETWINDOW_CONFIGURATION(x, p) XSETRECORD (x, p, window_configuration)
 #define WINDOW_CONFIGURATIONP(x) RECORDP (x, window_configuration)
 #define GC_WINDOW_CONFIGURATIONP(x) GC_RECORDP (x, window_configuration)
 #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))
 {
 struct window_config *config = XWINDOW_CONFIGURATION (obj);
 ((markobj) (s->dedicated));
 }
 return Qnil;
 }
-static int
+static size_t
 sizeof_window_config_for_n_windows (int n)
 {
 return (sizeof (struct window_config) +
 	  /* n - 1 because zero-sized arrays aren't ANSI C */
 	  (n - 1) *sizeof (struct saved_window));
 }
-static unsigned int
+static size_t
 sizeof_window_config (CONST void *h)
 {
 CONST struct window_config *c = (CONST struct window_config *) h;
 return sizeof_window_config_for_n_windows (c->saved_windows_count);
 }
 config->header.uid);
 write_c_string ("#<window-configuration ", printcharfun);
 sprintf (buf, "0x%x>", config->header.uid);
 write_c_string (buf, printcharfun);
 }
+DEFINE_LRECORD_SEQUENCE_IMPLEMENTATION ("window-configuration",
+					window_configuration,
+					mark_window_config,
+					print_window_config,
+					0, 0, 0, sizeof_window_config,
+					struct window_config);
 /* Returns a boolean indicating whether the two saved windows are
 identical. */
 static int
 saved_window_equal (struct saved_window *win1, struct saved_window *win2)
 return 1;
 }
 DEFUN ("window-configuration-p", Fwindow_configuration_p, 1, 1, 0, /*
-T if OBJECT is a window-configuration object.
+Return t if OBJECT is a window-configuration object.
 */
 (obj))
 {
 return WINDOW_CONFIGURATIONP (obj) ? Qt : Qnil;
 }
 W is actually the subwindow tree of the window in question. */
 void
 delete_all_subwindows (struct window *w)
 {
-if (!NILP (w->next))
+if (!NILP (w->next))   delete_all_subwindows (XWINDOW (w->next));
-delete_all_subwindows (XWINDOW (w->next));
+if (!NILP (w->vchild)) delete_all_subwindows (XWINDOW (w->vchild));
-if (!NILP (w->vchild))
+if (!NILP (w->hchild)) delete_all_subwindows (XWINDOW (w->hchild));
-delete_all_subwindows (XWINDOW (w->vchild));
-if (!NILP (w->hchild))
-delete_all_subwindows (XWINDOW (w->hchild));
 mark_window_as_deleted (w);
 }
 static int
 count_windows (struct window *window)
 {
-int count = 1;
+return 1 +
-if (!NILP (window->next))
+(!NILP (window->next)   ? count_windows (XWINDOW (window->next))   : 0) +
-count += count_windows (XWINDOW (window->next));
+(!NILP (window->vchild) ? count_windows (XWINDOW (window->vchild)) : 0) +
-if (!NILP (window->vchild))
+(!NILP (window->hchild) ? count_windows (XWINDOW (window->hchild)) : 0);
-count += count_windows (XWINDOW (window->vchild));
-if (!NILP (window->hchild))
-count += count_windows (XWINDOW (window->hchild));
-return count;
 }
 static int
 saved_window_index (Lisp_Object window, struct window_config *config, int lim)
 {
 int j;
 for (j = 0; j < lim; j++)
 {
 if (EQ (SAVED_WINDOW_N (config, j)->window, window))
 	return j;
-	}
+}
 abort ();
 return 0;	/* suppress compiler warning */
 }
 static int
 save_window_save (Lisp_Object window, struct window_config *config, int i)
 {
-struct saved_window *p;
 struct window *w;
 for (; !NILP (window); window = w->next)
 {
-p = SAVED_WINDOW_N (config, i);
+struct saved_window *p = SAVED_WINDOW_N (config, i);
 w = XWINDOW (window);
 i++;
 p->window = window;
 p->buffer = w->buffer;
 WINDOW_LEFT (p) = WINDOW_LEFT (w);
 WINDOW_TOP (p) = WINDOW_TOP (w);
 point and mark.  An exception is made for point in the current buffer:
 its value is -not- saved.
 */
 (frame))
 {
-Lisp_Object result = Qnil;
+Lisp_Object result;
-struct frame *f;
+struct frame *f = decode_frame (frame);
-int n_windows;
 struct window_config *config;
+int n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
-f = decode_frame (frame);
-n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
 if (n_windows <= countof (Vwindow_configuration_free_list))
-config =
+config = XWINDOW_CONFIGURATION (allocate_managed_lcrecord
-XWINDOW_CONFIGURATION (allocate_managed_lcrecord
+				    (Vwindow_configuration_free_list
-			     (Vwindow_configuration_free_list
+				     [n_windows - 1]));
-			      [n_windows - 1]));
 else
 /* More than ten windows; just allocate directly */
 config = (struct window_config *)
 alloc_lcrecord (sizeof_window_config_for_n_windows (n_windows),
 		      lrecord_window_configuration);
 problems purely on the C side.  That is where we need to call it so
 here it is. */
 static void
 debug_print_window (Lisp_Object window, int level)
 {
-Lisp_Object child;
+int i;
-int i = level;
+Lisp_Object child = Fwindow_first_vchild (window);
-child = Fwindow_first_vchild (window);
 if (NILP (child))
 child = Fwindow_first_hchild (window);
-while (i > 0)
+for (i = level; i > 0; i--)
-{
+putc ('\t', stderr);
-fprintf (stderr, "\t");
-i--;
+fputs ("#<window", stderr);
-}
+{
+Lisp_Object buffer = XWINDOW (window)->buffer;
-fprintf (stderr, "#<window");
+if (!NILP (buffer) && BUFFERP (buffer))
-if (!NILP (XWINDOW (window)->buffer) && BUFFERP (XWINDOW (window)->buffer))
+fprintf (stderr, " on %s", XSTRING_DATA (XBUFFER (buffer)->name));
-{
+}
-struct buffer *b = XBUFFER (XWINDOW (window)->buffer);
-fprintf (stderr, " on %s", XSTRING_DATA (b->name));
-}
 fprintf (stderr, " 0x%x>", XWINDOW (window)->header.uid);
 while (!NILP (child))
 {
 debug_print_window (child, level + 1);
 void debug_print_windows (struct frame *f);
 void
 debug_print_windows (struct frame *f)
 {
 debug_print_window (f->root_window, 0);
-fprintf (stderr, "\n");
+putc ('\n', stderr);
 }
 #endif /* DEBUG_XEMACS */
 /************************************************************************/
 DEFSUBR (Fwindow_pixel_height);
 DEFSUBR (Fwindow_pixel_width);
 DEFSUBR (Fwindow_hscroll);
 #ifdef MODELINE_IS_SCROLLABLE
 DEFSUBR (Fmodeline_hscroll);
+DEFSUBR (Fset_modeline_hscroll);
 #endif /* MODELINE_IS_SCROLLABLE */
 #if 0 /* bogus crock */
 DEFSUBR (Fwindow_redisplay_end_trigger);
 DEFSUBR (Fset_window_redisplay_end_trigger);
 #endif
 DEFSUBR (Fset_window_hscroll);
-#ifdef MODELINE_IS_SCROLLABLE
-DEFSUBR (Fset_modeline_hscroll);
-#endif /* MODELINE_IS_SCROLLABLE */
 DEFSUBR (Fwindow_pixel_edges);
 DEFSUBR (Fwindow_point);
 DEFSUBR (Fwindow_start);
 DEFSUBR (Fwindow_end);
 DEFSUBR (Fset_window_point);

Mercurial > hg > xemacs-beta

comparison src/window.c @ 272:c5d627a313b1 r21-0b34