xemacs-beta: src/window.c comparison

comparison src/window.c @ 380:8626e4521993 r21-2-5

Import from CVS: tag r21-2-5

author	cvs
date	Mon, 13 Aug 2007 11:07:10 +0200
parents	a300bb07d72d
children	bbff43aa5eb7

comparison

equal deleted inserted replaced

-:76b7d63099ad
+:8626e4521993
 #include "frame.h"
 #include "objects.h"
 #include "glyphs.h"
 #include "redisplay.h"
 #include "window.h"
-#include "commands.h"
 Lisp_Object Qwindowp, Qwindow_live_p, Qwindow_configurationp;
 Lisp_Object Qscroll_up, Qscroll_down, Qdisplay_buffer;
 #ifdef MEMORY_USAGE_STATS
 (w)->last_facechange[CMOTION_DISP] = Qzero;	\
 } while (0)
 #define MARK_DISP_VARIABLE(field)		\
-((markobj) (window->field[CURRENT_DISP]));	\
+markobj (window->field[CURRENT_DISP]);	\
-((markobj) (window->field[DESIRED_DISP]));	\
+markobj (window->field[DESIRED_DISP]);	\
-((markobj) (window->field[CMOTION_DISP]));
+markobj (window->field[CMOTION_DISP]);
 static Lisp_Object
 mark_window (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 struct window *window = XWINDOW (obj);
-((markobj) (window->frame));
+markobj (window->frame);
-((markobj) (window->mini_p));
+markobj (window->mini_p);
-((markobj) (window->next));
+markobj (window->next);
-((markobj) (window->prev));
+markobj (window->prev);
-((markobj) (window->hchild));
+markobj (window->hchild);
-((markobj) (window->vchild));
+markobj (window->vchild);
-((markobj) (window->parent));
+markobj (window->parent);
-((markobj) (window->buffer));
+markobj (window->buffer);
 MARK_DISP_VARIABLE (start);
 MARK_DISP_VARIABLE (pointm);
-((markobj) (window->sb_point));	/* #### move to scrollbar.c? */
+markobj (window->sb_point);	/* #### move to scrollbar.c? */
-((markobj) (window->use_time));
+markobj (window->use_time);
 MARK_DISP_VARIABLE (last_modified);
 MARK_DISP_VARIABLE (last_point);
 MARK_DISP_VARIABLE (last_start);
 MARK_DISP_VARIABLE (last_facechange);
-((markobj) (window->line_cache_last_updated));
+markobj (window->line_cache_last_updated);
-((markobj) (window->redisplay_end_trigger));
+markobj (window->redisplay_end_trigger);
 mark_face_cachels (window->face_cachels, markobj);
 mark_glyph_cachels (window->glyph_cachels, markobj);
-#define WINDOW_SLOT(slot, compare) ((markobj) (window->slot))
+#define WINDOW_SLOT(slot, compare) ((void) (markobj (window->slot)))
 #include "winslots.h"
 return Qnil;
 }
 redisplay structures for. */
 static Lisp_Object
 real_window_internal (Lisp_Object win, struct window_mirror *rmir,
 		      struct window_mirror *mir)
 {
-Lisp_Object retval;
 for (; !NILP (win) && rmir ; win = XWINDOW (win)->next, rmir = rmir->next)
 {
 if (mir == rmir)
 	return win;
 if (!NILP (XWINDOW (win)->vchild))
 	{
-	  retval = real_window_internal (XWINDOW (win)->vchild, rmir->vchild,
+	  Lisp_Object retval =
-					 mir);
+	    real_window_internal (XWINDOW (win)->vchild, rmir->vchild, mir);
 	  if (!NILP (retval))
 	    return retval;
 	}
 if (!NILP (XWINDOW (win)->hchild))
 	{
-	  retval = real_window_internal (XWINDOW (win)->hchild, rmir->hchild,
+	  Lisp_Object retval =
-					 mir);
+	    real_window_internal (XWINDOW (win)->hchild, rmir->hchild, mir);
 	  if (!NILP (retval))
 	    return retval;
 	}
 }
 /* Always if draggable */
 if (!NILP (w->vertical_divider_always_visible_p))
 return 1;
 #ifdef HAVE_SCROLLBARS
-/* Our right scrollabr is enough to separate us at the right */
+/* Our right scrollbar is enough to separate us at the right */
 if (NILP (w->scrollbar_on_left_p)
 && !NILP (w->vertical_scrollbar_visible_p)
 && !ZEROP (w->scrollbar_width))
 return 0;
 #endif
 }
 /* Calculate width of vertical divider, including its shadows
 and spacing. The returned value is effectively the distance
 between adjacent window edges. This function does not check
-whether a windows needs vertival divider, so the returned
+whether a window needs a vertical divider, so the returned
 value is a "theoretical" one */
 int
 window_divider_width (struct window *w)
 {
 /* the shadow thickness can be negative. This means that the divider
 will have a depressed look */
 if (FRAME_WIN_P (XFRAME (WINDOW_FRAME (w))))
 return
 XINT (w->vertical_divider_line_width)
 + 2 * XINT (w->vertical_divider_spacing)
 + 2 * abs (XINT (w->vertical_divider_shadow_thickness));
 else
 return XINT (w->vertical_divider_line_width) == 0 ? 0 : 1;
 				   Dynarr_atp (dla, 0)->descent);
 	      else
 		/* This should be an abort except I'm not yet 100%
 confident that it won't ever get hit (though I
 haven't been able to trigger it).  It is extremely
-unlikely to cause any noticable problem and even if
+unlikely to cause any noticeable problem and even if
 it does it will be a minor display glitch. */
 		/* #### Bullshit alert.  It does get hit and it causes
 noticeable glitches.  real_current_modeline_height
 is a kludge to fix this for 19.14. */
 		modeline_height = real_current_modeline_height (w);
 int
 window_left_gutter_width (struct window *w, int modeline)
 {
 int gutter = window_left_toolbar_width (w);
 if (!NILP (w->hchild) || !NILP (w->vchild))
 return 0;
 #ifdef HAVE_SCROLLBARS
 }
 int
 window_right_gutter_width (struct window *w, int modeline)
 {
-int gutter = window_left_toolbar_width (w);
+int gutter = window_right_toolbar_width (w);
 if (!NILP (w->hchild) || !NILP (w->vchild))
 return 0;
 #ifdef HAVE_SCROLLBARS
 if (!modeline && NILP (w->scrollbar_on_left_p))
 DEFUN ("window-text-area-pixel-width",
 Fwindow_text_area_pixel_width, 0, 1, 0, /*
 Return the width in pixels of the text-displaying portion of WINDOW.
 Unlike `window-pixel-width', the space occupied by the vertical
 scrollbar or divider, if any, is not counted.
 */
 (window))
 {
 struct window *w = decode_window (window);
 			 make_int (XBUFFER (buffer)->last_window_start),
 			 buffer);
 Fset_marker (w->sb_point, w->start[CURRENT_DISP], buffer);
 /* set start_at_line_beg correctly. GE */
 w->start_at_line_beg = beginning_of_line_p (XBUFFER (buffer),
 					      marker_position (w->start[CURRENT_DISP]));
 w->force_start = 0;           /* Lucid fix */
 SET_LAST_MODIFIED (w, 1);
 SET_LAST_FACECHANGE (w);
 MARK_WINDOWS_CHANGED (w);
 recompute_all_cached_specifiers_in_window (w);
 return new;
 }
 DEFUN ("enlarge-window", Fenlarge_window, 1, 3, "_p", /*
-Make the selected window ARG lines bigger.
+Make the selected window N lines bigger.
-From program, optional second arg non-nil means grow sideways ARG columns,
+From program, optional second arg SIDE non-nil means grow sideways N columns,
-and optional third ARG specifies the window to change instead of the
+and optional third arg WINDOW specifies the window to change instead of the
 selected window.
 */
 (n, side, window))
 {
 struct window *w = decode_window (window);
 change_window_height (w, XINT (n), !NILP (side), /* inpixels */ 0);
 return Qnil;
 }
 DEFUN ("enlarge-window-pixels", Fenlarge_window_pixels, 1, 3, "_p", /*
-Make the selected window ARG pixels bigger.
+Make the selected window N pixels bigger.
-From program, optional second arg non-nil means grow sideways ARG pixels,
+From program, optional second arg SIDE non-nil means grow sideways N pixels,
-and optional third ARG specifies the window to change instead of the
+and optional third arg WINDOW specifies the window to change instead of the
 selected window.
 */
 (n, side, window))
 {
 struct window *w = decode_window (window);
 change_window_height (w, XINT (n), !NILP (side), /* inpixels */ 1);
 return Qnil;
 }
 DEFUN ("shrink-window", Fshrink_window, 1, 3, "_p", /*
-Make the selected window ARG lines smaller.
+Make the selected window N lines smaller.
-From program, optional second arg non-nil means shrink sideways ARG columns,
+From program, optional second arg SIDE non-nil means shrink sideways N columns,
-and optional third ARG specifies the window to change instead of the
+and optional third arg WINDOW specifies the window to change instead of the
 selected window.
 */
 (n, side, window))
 {
 CHECK_INT (n);
 /* inpixels */ 0);
 return Qnil;
 }
 DEFUN ("shrink-window-pixels", Fshrink_window_pixels, 1, 3, "_p", /*
-Make the selected window ARG pixels smaller.
+Make the selected window N pixels smaller.
-From program, optional second arg non-nil means shrink sideways ARG pixels,
+From program, optional second arg SIDE non-nil means shrink sideways N pixels,
-and optional third ARG specifies the window to change instead of the
+and optional third arg WINDOW specifies the window to change instead of the
 selected window.
 */
 (n, side, window))
 {
 CHECK_INT (n);
 	 keeping things consistent while not affecting siblings.  */
 CURSIZE (XWINDOW (parent)) = opht + delta1;
 (*setsizefun) (window, *sizep + delta1, 0);
 /* Squeeze out delta1 lines or columns from our parent,
-	 shriking this window and siblings proportionately.
+	 shrinking this window and siblings proportionately.
 	 This brings parent back to correct size.
 	 Delta1 was calculated so this makes this window the desired size,
 	 taking it all out of the siblings.  */
 (*setsizefun) (parent, opht, 0);
 }
 point = make_int (pos);
 }
 /* Always set force_start so that redisplay_window will run
-thw window-scroll-functions.  */
+the window-scroll-functions.  */
 w->force_start = 1;
 /* #### When the fuck does this happen?  I'm so glad that history has
 completely documented the behavior of the scrolling functions under
 all circumstances. */
 }
 }
 DEFUN ("scroll-up", Fscroll_up, 0, 1, "_P", /*
-Scroll text of current window upward ARG lines; or near full screen if no ARG.
+Scroll text of current window upward N lines; or near full screen if no arg.
 A near full screen is `next-screen-context-lines' less than a full screen.
-Negative ARG means scroll downward.
+Negative N means scroll downward.
-When calling from a program, supply a number as argument or nil.
+When calling from a program, supply an integer as argument or nil.
 On attempt to scroll past end of buffer, `end-of-buffer' is signaled.
 On attempt to scroll past beginning of buffer, `beginning-of-buffer' is
 signaled.
 */
 (n))
 window_scroll (Fselected_window (Qnil), n, 1, ERROR_ME);
 return Qnil;
 }
 DEFUN ("scroll-down", Fscroll_down, 0, 1, "_P", /*
-Scroll text of current window downward ARG lines; or near full screen if no ARG.
+Scroll text of current window downward N lines; or near full screen if no arg.
 A near full screen is `next-screen-context-lines' less than a full screen.
-Negative ARG means scroll upward.
+Negative N means scroll upward.
 When calling from a program, supply a number as argument or nil.
 On attempt to scroll past end of buffer, `end-of-buffer' is signaled.
 On attempt to scroll past beginning of buffer, `beginning-of-buffer' is
 signaled.
 */
 return window;
 }
 DEFUN ("scroll-other-window", Fscroll_other_window, 0, 1, "_P", /*
-Scroll next window upward ARG lines; or near full frame if no ARG.
+Scroll next window upward N lines; or near full frame if no arg.
 The next window is the one below the current one; or the one at the top
-if the current one is at the bottom.  Negative ARG means scroll downward.
+if the current one is at the bottom.  Negative N means scroll downward.
 When calling from a program, supply a number as argument or nil.
 If in the minibuffer, `minibuffer-scroll-window' if non-nil
 specifies the window to scroll.
 If `other-window-scroll-buffer' is non-nil, scroll the window
 window_scroll (Fother_window_for_scrolling (), n, 1, ERROR_ME);
 return Qnil;
 }
 DEFUN ("scroll-left", Fscroll_left, 0, 1, "_P", /*
-Scroll selected window display ARG columns left.
+Scroll selected window display N columns left.
-Default for ARG is window width minus 2.
+Default for N is window width minus 2.
 */
-(arg))
+(n))
 {
 Lisp_Object window = Fselected_window (Qnil);
 struct window *w = XWINDOW (window);
+int count = (NILP (n) ?
-if (NILP (arg))
+	       window_char_width (w, 0) - 2 :
-arg = make_int (window_char_width (w, 0) - 2);
+	       XINT (Fprefix_numeric_value (n)));
-else
-arg = Fprefix_numeric_value (arg);
+return Fset_window_hscroll (window, make_int (w->hscroll + count));
-return Fset_window_hscroll (window, make_int (w->hscroll + XINT (arg)));
 }
 DEFUN ("scroll-right", Fscroll_right, 0, 1, "_P", /*
-Scroll selected window display ARG columns right.
+Scroll selected window display N columns right.
-Default for ARG is window width minus 2.
+Default for N is window width minus 2.
 */
-(arg))
+(n))
 {
 Lisp_Object window = Fselected_window (Qnil);
 struct window *w = XWINDOW (window);
+int count = (NILP (n) ?
-if (NILP (arg))
+	       window_char_width (w, 0) - 2 :
-arg = make_int (window_char_width (w, 0) - 2);
+	       XINT (Fprefix_numeric_value (n)));
-else
-arg = Fprefix_numeric_value (arg);
+return Fset_window_hscroll (window, make_int (w->hscroll - count));
-return Fset_window_hscroll (window, make_int (w->hscroll - XINT (arg)));
 }
 DEFUN ("center-to-window-line", Fcenter_to_window_line, 0, 2, "_P", /*
 Center point in WINDOW.  With N, put point on line N.
 The desired position of point is always relative to the window.
 /* 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
 over all windows in F.
-If MAPFUN creates or deletes windows, the behaviour is undefined.  */
+If MAPFUN creates or deletes windows, the behavior is undefined.  */
 int
 map_windows (struct frame *f, int (*mapfun) (struct window *w, void *closure),
 	     void *closure)
 {
 FRAME_LOOP_NO_BREAK(frmcons, devcons, concons)
 	{
 	  int v = map_windows_1 (FRAME_ROOT_WINDOW (XFRAME (XCAR (frmcons))),
 				 mapfun, closure);
 	  if (v)
 	    return v;
 	}
 }
 return 0;
 w->shadow_thickness_changed = 1;
 MARK_WINDOWS_CHANGED (w);
 }
 static void
 vertical_divider_changed_in_window (Lisp_Object specifier,
 				    struct window *w,
 				    Lisp_Object oldval)
 {
 MARK_WINDOWS_CHANGED (w);
 MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (XFRAME (WINDOW_FRAME (w)));
 }
 static Lisp_Object
 mark_window_config (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 struct window_config *config = XWINDOW_CONFIGURATION (obj);
 int i;
-((markobj) (config->current_window));
+markobj (config->current_window);
-((markobj) (config->current_buffer));
+markobj (config->current_buffer);
-((markobj) (config->minibuffer_scroll_window));
+markobj (config->minibuffer_scroll_window);
-((markobj) (config->root_window));
+markobj (config->root_window);
 for (i = 0; i < config->saved_windows_count; i++)
 {
 struct saved_window *s = SAVED_WINDOW_N (config, i);
-((markobj) (s->window));
+markobj (s->window);
-((markobj) (s->buffer));
+markobj (s->buffer);
-((markobj) (s->start));
+markobj (s->start);
-((markobj) (s->pointm));
+markobj (s->pointm);
-((markobj) (s->sb_point));
+markobj (s->sb_point);
-((markobj) (s->mark));
+markobj (s->mark);
 #if 0
 /* #### This looked like this. I do not see why specifier cached
 	 values should not be marked, as such specifiers as toolbars
 	 might have GC-able instances. Freed configs are not marked,
 	 aren't they?  -- kkm */
-((markobj) (s->dedicated));
+markobj (s->dedicated);
 #else
-#define WINDOW_SLOT(slot, compare) ((markobj) (s->slot))
+#define WINDOW_SLOT(slot, compare) ((void) (markobj (s->slot)))
 #include "winslots.h"
 #endif
 }
 return Qnil;
 }
 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);
 				      vertical_divider_always_visible_p),
 			 vertical_divider_changed_in_window,
 			 0, 0);
 DEFVAR_SPECIFIER ("vertical-divider-shadow-thickness", &Vvertical_divider_shadow_thickness /*
 *How thick to draw 3D shadows around vertical dividers.
 This is a specifier; use `set-specifier' to change it.
 */ );
 Vvertical_divider_shadow_thickness = Fmake_specifier (Qinteger);
 set_specifier_fallback (Vvertical_divider_shadow_thickness,
 			  list1 (Fcons (Qnil, Qzero)));

Mercurial > hg > xemacs-beta

comparison src/window.c @ 380:8626e4521993 r21-2-5