xemacs-beta: src/window.c comparison

comparison src/window.c @ 70:131b0175ea99 r20-0b30

Import from CVS: tag r20-0b30

author	cvs
date	Mon, 13 Aug 2007 09:02:59 +0200
parents	e04119814345
children	0d2f883870bc

comparison

equal deleted inserted replaced

-:804d1389bcd6
+:131b0175ea99
 extern void energize_buffer_hidden_hook ();
 extern void energize_window_selected_hook ();
 extern void energize_window_deselected_hook ();
 extern Lisp_Object desired_psheet_buffer ();
 extern void make_psheets_desired ();
-#endif /* ENERGIZE */
+#endif
 /* Thickness of shadow border around 3d modelines. */
 Lisp_Object Vmodeline_shadow_thickness;
 /* Whether a modeline should be displayed. */
 Lisp_Object Vminibuf_scroll_window;
 /* Non-nil means this is the buffer whose window C-M-v should scroll.  */
 Lisp_Object Vother_window_scroll_buffer;
-/* Non-nil means it's the function to call to display temp buffers.  */
+/* Non-nil means it's function to call to display temp buffers.  */
 Lisp_Object Vtemp_buffer_show_function;
 Lisp_Object Vtemp_buffer_show_hook;
 /* If a window gets smaller than either of these, it is removed. */
 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)		\
+#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]));
 static Lisp_Object
 mark_window (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 ((markobj) (window->modeline_shadow_thickness));
 #ifdef HAVE_SCROLLBARS
 ((markobj) (window->scrollbar_width));
 ((markobj) (window->scrollbar_height));
 ((markobj) (window->scrollbar_pointer));
-#endif /* HAVE_SCROLLBARS */
+#endif
 ((markobj) (window->left_margin_width));
 ((markobj) (window->right_margin_width));
 #ifdef HAVE_TOOLBARS
 ((markobj) (window->toolbar[0]));
 ((markobj) (window->toolbar[1]));
 ((markobj) (window->toolbar_buttons_captioned_p));
 ((markobj) (window->default_toolbar));
 ((markobj) (window->default_toolbar_height));
 ((markobj) (window->default_toolbar_width));
 ((markobj) (window->default_toolbar_visible_p));
-#endif /* HAVE_TOOLBARS */
+#endif
 ((markobj) (window->minimum_line_ascent));
 ((markobj) (window->minimum_line_descent));
 ((markobj) (window->use_left_overflow));
 ((markobj) (window->use_right_overflow));
 #ifdef HAVE_MENUBARS
 ((markobj) (window->menubar_visible_p));
-#endif /* HAVE_MENUBARS */
+#endif
 ((markobj) (window->text_cursor_visible_p));
 /* End cached specifiers. */
 ((markobj) (window->dedicated));
 mark_face_cachels (window->face_cachels, markobj);
 mark_glyph_cachels (window->glyph_cachels, markobj);
 * It also becomes a convenient place to stick scrollbar instances
 * since they extrapolate out to having the same problem described for
 * the display structures.
 */
-/* Create a new window mirror structure and associated redisplay
+/* Create a new mindow mirror structure and associated redisplay
 structs. */
 static struct window_mirror *
 new_window_mirror (struct frame *f)
 {
 struct window_mirror *t;
 }
 else
 if (!mir)
 mir = new_window_mirror (XFRAME (XWINDOW (win)->frame));
-mir->next   = update_mirror_internal (XWINDOW (win)->next,   mir->next);
+mir->next = update_mirror_internal (XWINDOW (win)->next, mir->next);
 mir->hchild = update_mirror_internal (XWINDOW (win)->hchild, mir->hchild);
 mir->vchild = update_mirror_internal (XWINDOW (win)->vchild, mir->vchild);
 /*
 * If the redisplay structs are not empty and the mirror has
 t->buffer = b;
 }
-/* Determining a window's position based solely on its pixel
+/* Determining a windows position based solely on its pixel
 positioning doesn't work.  Instead, we do it the intelligent way,
 by checking its positioning in the window hierarchy. */
 int
 window_is_leftmost (struct window *w)
 {
 }
 else
 return 0;
 #else
 return (!window_is_leftmost (w));
-#endif /* HAVE_SCROLLBARS */
+#endif
 }
 int
 window_scrollbar_width (struct window *w)
 {
 return 0;
 return XINT (w->scrollbar_width);
 #else
 return 0;
-#endif /* HAVE_SCROLLBARS */
+#endif
 }
 /* Horizontal scrollbars are only active on windows with truncation
 turned on. */
 int
 return 0;
 return XINT (w->scrollbar_height);
 #else
 return 0;
-#endif /* HAVE_SCROLLBARS */
+#endif
 }
 int
 window_modeline_height (struct window *w)
 {
 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, 1, 1, 0, /*
 Return non-nil if WINDOW is a minibuffer window.
 */
 (window))
 {
-return (MINI_WINDOW_P (decode_window (window)) ? Qt : Qnil);
+struct window *w = decode_window (window);
+return (MINI_WINDOW_P (w) ? Qt : Qnil);
 }
 DEFUN ("window-first-hchild", Fwindow_first_hchild, 1, 1, 0, /*
 Return the first horizontal child of WINDOW, or nil.
 */
 (window))
 {
-return decode_window (window)->hchild;
+struct window *w = decode_window (window);
+return w->hchild;
 }
 DEFUN ("window-first-vchild", Fwindow_first_vchild, 1, 1, 0, /*
 Return the first vertical child of WINDOW, or nil.
 */
 (window))
 {
-return decode_window (window)->vchild;
+struct window *w = decode_window (window);
+return w->vchild;
 }
 DEFUN ("window-next-child", Fwindow_next_child, 1, 1, 0, /*
 Return the next window on the same level as WINDOW, or nil.
 */
 (window))
 {
-return decode_window (window)->next;
+struct window *w = decode_window (window);
+return w->next;
 }
 DEFUN ("window-previous-child", Fwindow_previous_child, 1, 1, 0, /*
 Return the previous window on the same level as WINDOW, or nil.
 */
 (window))
 {
-return decode_window (window)->prev;
+struct window *w = decode_window (window);
+return w->prev;
 }
 DEFUN ("window-parent", Fwindow_parent, 1, 1, 0, /*
 Return the parent of WINDOW, or nil.
 */
 (window))
 {
-return decode_window (window)->parent;
+struct window *w = decode_window (window);
+return w->parent;
 }
 DEFUN ("window-lowest-p", Fwindow_lowest_p, 1, 1, 0, /*
 Return non-nil if WINDOW is along the bottom of its frame.
 */
 (window))
 {
-return window_is_lowest (decode_window (window)) ? Qt : Qnil;
+struct window *w = decode_window (window);
+return window_is_lowest (w) ? Qt : Qnil;
 }
 DEFUN ("window-highest-p", Fwindow_highest_p, 1, 1, 0, /*
 Return non-nil if WINDOW is along the top of its frame.
 */
 (window))
 {
-return window_is_highest (decode_window (window)) ? Qt : Qnil;
+struct window *w = decode_window (window);
+return window_is_highest (w) ? Qt : Qnil;
 }
 DEFUN ("window-leftmost-p", Fwindow_leftmost_p, 1, 1, 0, /*
 Return non-nil if WINDOW is along the left edge of its frame.
 */
 (window))
 {
-return window_is_leftmost (decode_window (window)) ? Qt : Qnil;
+struct window *w = decode_window (window);
+return window_is_leftmost (w) ? Qt : Qnil;
 }
 DEFUN ("window-rightmost-p", Fwindow_rightmost_p, 1, 1, 0, /*
 Return non-nil if WINDOW is along the right edge of its frame.
 */
 (window))
 {
-return window_is_rightmost (decode_window (window)) ? Qt : Qnil;
+struct window *w = decode_window (window);
+return window_is_rightmost (w) ? Qt : Qnil;
 }
 DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p, 0, 2, 0, /*
 Return t if position POS is currently on the frame in WINDOW.
 Returns nil if that position is scrolled vertically out of view.
 POS defaults to point in WINDOW's buffer; WINDOW, to the selected window.
 */
 (pos, window))
 {
-struct window *w = decode_window (window);
+struct window *w;
 Bufpos top;
 Bufpos posint;
 struct buffer *buf;
+w = decode_window (window);
 top = marker_position (w->start[CURRENT_DISP]);
 buf = XBUFFER (w->buffer);
 if (NILP (pos))
 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.
 */
 (window))
 {
 return make_int (window_displayed_height (decode_window (window)));
 }
 DEFUN ("window-pixel-height", Fwindow_pixel_height, 0, 1, 0, /*
 Return the number of display columns in WINDOW.
 This is the width that is usable columns available for text in WINDOW.
 */
 (window))
 {
-return (make_int (window_char_width (decode_window (window), 0)));
+struct window *w = decode_window (window);
+return (make_int (window_char_width (w, 0)));
 }
 DEFUN ("window-pixel-width", Fwindow_pixel_width, 0, 1, 0, /*
 Return the width of WINDOW in pixels.  Defaults to current window.
 */
 return ncol;
 }
 #if 0 /* bogus RMS crock */
-xxDEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger, 0, 1, 0 /*
+xxDEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
+Swindow_redisplay_end_trigger, 0, 1, 0 /*
 Return WINDOW's redisplay end trigger value.
 See `set-window-redisplay-end-trigger' for more information.
-*/
+*/ )
-	 (window))
+(window)
+Lisp_Object window;
 {
 return decode_window (window)->redisplay_end_trigger;
 }
-xxDEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger, 2, 2, 0 /*
+xxDEFUN ("set-window-redisplay-end-trigger", Fset_window_redisplay_end_trigger,
+Sset_window_redisplay_end_trigger, 2, 2, 0 /*
 Set WINDOW's redisplay end trigger value to VALUE.
 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))
+(window, value)
-{
+register Lisp_Object window, value;
-return (decode_window (window)->redisplay_end_trigger = value);
+{
+register struct window *w;
+w = decode_window (window);
+w->redisplay_end_trigger = value;
+return value;
 }
 #endif /* 0 */
 DEFUN ("window-pixel-edges", Fwindow_pixel_edges, 0, 1, 0, /*
 If you use consistent values for MINIBUF, ALL-FRAMES, and CONSOLE, you
 can use `next-window' to iterate through the entire cycle of acceptable
 windows, eventually ending up back at the window you started with.
 `previous-window' traverses the same cycle, in the reverse order.
 */
 (window, minibuf, all_frames, console))
 {
 Lisp_Object tem;
 Lisp_Object start_window;
 if (NILP (window))
 return window;
 }
 DEFUN ("previous-window", Fprevious_window, 0, 4, 0, /*
-Return the window preceding WINDOW in canonical ordering of windows.
+Return the window preceeding WINDOW in canonical ordering of windows.
 If omitted, WINDOW defaults to the selected window.
 Optional second arg MINIBUF t means count the minibuffer window even
 if not active.  MINIBUF nil or omitted means count the minibuffer iff
 it is active.  MINIBUF neither t nor nil means not to count the
 If you use consistent values for MINIBUF, ALL-FRAMES, and CONSOLE, you
 can use `previous-window' to iterate through the entire cycle of acceptable
 windows, eventually ending up back at the window you started with.
 `next-window' traverses the same cycle, in the reverse order.
 */
 (window, minibuf, all_frames, console))
 {
 Lisp_Object tem;
 Lisp_Object start_window;
 if (NILP (window))
 	  else break;
 	  while (tem = XWINDOW (window)->next, !NILP (tem))
 	    window = tem;
 	}
 }
+/* "acceptable" is the correct spelling. */
 /* Which windows are acceptable?
 Exit the loop and accept this window if
 this isn't a minibuffer window,
 or we're accepting all minibuffer windows,
 or this is the active minibuffer and we are accepting that one, or
 	}
 }
 }
-extern int signal_error_on_buffer_boundary;
 DEFUN ("scroll-up", Fscroll_up, 0, 1, "_P", /*
 Scroll text of current window upward ARG 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.
 When calling from a program, supply a number as argument or nil.
-If `signal-error-on-buffer-boundary' is nil, the usual error and
-loss of zmacs region is suppressed when moving past end of buffer.
 */
 (n))
 {
-Error_behavior errb =
+window_scroll (Fselected_window (Qnil), n, 1, ERROR_ME);
-signal_error_on_buffer_boundary ? ERROR_ME : ERROR_ME_NOT;
-window_scroll (Fselected_window (Qnil), n, 1, errb);
 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.
 A near full screen is `next-screen-context-lines' less than a full screen.
 Negative ARG means scroll upward.
 When calling from a program, supply a number as argument or nil.
-If `signal-error-on-buffer-boundary' is nil, the usual error and
-loss of zmacs region is suppressed when moving past end of buffer.
 */
 (n))
 {
-Error_behavior errb =
+window_scroll (Fselected_window (Qnil), n, -1, ERROR_ME);
-signal_error_on_buffer_boundary ? ERROR_ME : ERROR_ME_NOT;
-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.

Mercurial > hg > xemacs-beta

comparison src/window.c @ 70:131b0175ea99 r20-0b30