xemacs-beta: src/window.c comparison

comparison src/window.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	8fc7fe29b841

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 #endif
 return window_right_toolbar_width (w);
 }
-DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0 /*
+DEFUN ("windowp", Fwindowp, 1, 1, 0, /*
 Return t if OBJ is a window.
-*/ )
+*/
-(obj)
+(obj))
-Lisp_Object obj;
 {
 return (WINDOWP (obj) ? Qt : Qnil);
 }
-DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0 /*
+DEFUN ("window-live-p", Fwindow_live_p, 1, 1, 0, /*
 Return t if OBJ is a window which is currently visible.
-*/ )
+*/
-(obj)
+(obj))
-Lisp_Object obj;
 {
 return (WINDOWP (obj) && WINDOW_LIVE_P (XWINDOW (obj)) ? Qt : Qnil);
 }
-DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 1, 0 /*
+DEFUN ("selected-window", Fselected_window, 0, 1, 0, /*
 Return the window that the cursor now appears in and commands apply to.
 If the optional argument CON-DEV-OR-FRAME is specified and is a frame, return
 the selected window used by that frame.  If CON-DEV-OR-FRAME is a device,
 then the selected frame on that device will be used.  If CON-DEV-OR-FRAME
 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)
+(con_dev_or_frame))
-Lisp_Object 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);
 }
-DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0 /*
+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
 the minibuffer window used by that frame.  If CON-DEV-OR-FRAME is a device,
 then the selected frame on that device will be used.  If CON-DEV-OR-FRAME
 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)
+(con_dev_or_frame))
-Lisp_Object con_dev_or_frame;
 {
 struct frame *f = decode_frame_or_selected (con_dev_or_frame);
 return FRAME_MINIBUF_WINDOW (f);
 }
-DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, Swindow_minibuffer_p, 1, 1, 0 /*
+DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p, 1, 1, 0, /*
 Return non-nil if WINDOW is a minibuffer window.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return (MINI_WINDOW_P (w) ? Qt : Qnil);
 }
-DEFUN ("window-first-hchild", Fwindow_first_hchild, Swindow_first_hchild,
+DEFUN ("window-first-hchild", Fwindow_first_hchild, 1, 1, 0, /*
-1, 1, 0 /*
 Return the first horizontal child of WINDOW, or nil.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return w->hchild;
 }
-DEFUN ("window-first-vchild", Fwindow_first_vchild, Swindow_first_vchild,
+DEFUN ("window-first-vchild", Fwindow_first_vchild, 1, 1, 0, /*
-1, 1, 0 /*
 Return the first vertical child of WINDOW, or nil.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return w->vchild;
 }
-DEFUN ("window-next-child", Fwindow_next_child, Swindow_next_child,
+DEFUN ("window-next-child", Fwindow_next_child, 1, 1, 0, /*
-1, 1, 0 /*
 Return the next window on the same level as WINDOW, or nil.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return w->next;
 }
-DEFUN ("window-previous-child", Fwindow_previous_child, Swindow_previous_child,
+DEFUN ("window-previous-child", Fwindow_previous_child, 1, 1, 0, /*
-1, 1, 0 /*
 Return the previous window on the same level as WINDOW, or nil.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return w->prev;
 }
-DEFUN ("window-parent", Fwindow_parent, Swindow_parent,
+DEFUN ("window-parent", Fwindow_parent, 1, 1, 0, /*
-1, 1, 0 /*
 Return the parent of WINDOW, or nil.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return w->parent;
 }
-DEFUN ("window-lowest-p", Fwindow_lowest_p, Swindow_lowest_p, 1, 1, 0 /*
+DEFUN ("window-lowest-p", Fwindow_lowest_p, 1, 1, 0, /*
 Return non-nil if WINDOW is along the bottom of its frame.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return window_is_lowest (w) ? Qt : Qnil;
 }
-DEFUN ("window-highest-p", Fwindow_highest_p, Swindow_highest_p, 1, 1, 0 /*
+DEFUN ("window-highest-p", Fwindow_highest_p, 1, 1, 0, /*
 Return non-nil if WINDOW is along the top of its frame.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return window_is_highest (w) ? Qt : Qnil;
 }
-DEFUN ("window-leftmost-p", Fwindow_leftmost_p, Swindow_leftmost_p, 1, 1, 0 /*
+DEFUN ("window-leftmost-p", Fwindow_leftmost_p, 1, 1, 0, /*
 Return non-nil if WINDOW is along the left edge of its frame.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return window_is_leftmost (w) ? Qt : Qnil;
 }
-DEFUN ("window-rightmost-p", Fwindow_rightmost_p, Swindow_rightmost_p,
+DEFUN ("window-rightmost-p", Fwindow_rightmost_p, 1, 1, 0, /*
-1, 1, 0 /*
 Return non-nil if WINDOW is along the right edge of its frame.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return window_is_rightmost (w) ? Qt : Qnil;
 }
-DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
+DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p, 0, 2, 0, /*
-Spos_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)
+(pos, window))
-Lisp_Object pos, window;
 {
 struct window *w;
 Bufpos top;
 Bufpos posint;
 struct buffer *buf;
 CHECK_LIVE_WINDOW (window);
 return XWINDOW (window);
 }
-DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0 /*
+DEFUN ("window-buffer", Fwindow_buffer, 0, 1, 0, /*
 Return the buffer that WINDOW is displaying.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 return decode_window (window)->buffer;
 }
-DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 0, 1, 0 /*
+DEFUN ("window-frame", Fwindow_frame, 0, 1, 0, /*
 Return the frame that window WINDOW is on.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 return decode_window (window)->frame;
 }
-DEFUN ("window-height", Fwindow_height, Swindow_height, 0, 1, 0 /*
+DEFUN ("window-height", Fwindow_height, 0, 1, 0, /*
 Return the number of default lines in WINDOW.
 This actually works by dividing the window's pixel height (including
 the modeline and horizontal scrollbar, if any) by the height of the
 default font; therefore, the number of displayed lines will probably
 be different.
 Use `window-height' to get consistent results in geometry calculations.
 Use `window-displayed-height' to get the actual number of lines
 currently displayed in a window.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 return make_int (window_char_height (decode_window (window), 1));
 }
-DEFUN ("window-displayed-height", Fwindow_displayed_height,
+DEFUN ("window-displayed-height", Fwindow_displayed_height, 0, 1, 0, /*
-Swindow_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
 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)
+(window))
-Lisp_Object window;
 {
 return make_int (window_displayed_height (decode_window (window)));
 }
-DEFUN ("window-pixel-height", Fwindow_pixel_height, Swindow_pixel_height,
+DEFUN ("window-pixel-height", Fwindow_pixel_height, 0, 1, 0, /*
-0, 1, 0 /*
 Return the height of WINDOW in pixels.  Defaults to current window.
 This includes the window's modeline and horizontal scrollbar (if any).
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 return (make_int (decode_window (window)->pixel_height));
 }
-DEFUN ("window-width", Fwindow_width, Swindow_width, 0, 1, 0 /*
+DEFUN ("window-width", Fwindow_width, 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)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return (make_int (window_char_width (w, 0)));
 }
-DEFUN ("window-pixel-width", Fwindow_pixel_width, Swindow_pixel_width,
+DEFUN ("window-pixel-width", Fwindow_pixel_width, 0, 1, 0, /*
-0, 1, 0 /*
 Return the width of WINDOW in pixels.  Defaults to current window.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 return (make_int (decode_window (window)->pixel_width));
 }
-DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0 /*
+DEFUN ("window-hscroll", Fwindow_hscroll, 0, 1, 0, /*
 Return the number of columns by which WINDOW is scrolled from left margin.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 return (make_int (decode_window (window)->hscroll));
 }
-DEFUN ("set-window-hscroll", Fset_window_hscroll, Sset_window_hscroll, 2, 2, 0 /*
+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.
-*/ )
+*/
-(window, ncol)
+(window, ncol))
-Lisp_Object window, ncol;
 {
 struct window *w;
 int ncols;
 CHECK_INT (ncol);
 return value;
 }
 #endif /* 0 */
-DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges,
+DEFUN ("window-pixel-edges", Fwindow_pixel_edges, 0, 1, 0, /*
-0, 1, 0 /*
 Return a list of the pixel edge coordinates of WINDOW.
 \(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
 The frame toolbars and menubars are considered to be outside of this area.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 struct frame *f = XFRAME (w->frame);
 int left, top;
 		make_int (top),
 		make_int (left + w->pixel_width),
 		make_int (top + w->pixel_height));
 }
-DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0 /*
+DEFUN ("window-point", Fwindow_point, 0, 1, 0, /*
 Return current value of point in WINDOW.
 For a nonselected window, this is the value point would have
 if that window were selected.
 Note that, when WINDOW is the selected window and its buffer
 is also currently selected, the value returned is the same as (point).
 It would be more strictly correct to return the `top-level' value
 of point, outside of any save-excursion forms.
 But that is hard to define.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 /* The special check for current buffer is necessary for this
 function to work as defined when called within an excursion. */
 && current_buffer == XBUFFER (w->buffer))
 return Fpoint (Qnil);
 return Fmarker_position (w->pointm[CURRENT_DISP]);
 }
-DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0 /*
+DEFUN ("window-start", Fwindow_start, 0, 1, 0, /*
 Return position at which display currently starts in WINDOW.
 This is updated by redisplay or by calling `set-window-start'.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 return Fmarker_position (decode_window (window)->start[CURRENT_DISP]);
 }
-DEFUN ("window-end", Fwindow_end, Swindow_end, 0, 2, 0 /*
+DEFUN ("window-end", Fwindow_end, 0, 2, 0, /*
 Return position at which display currently ends in WINDOW.
 This is updated by redisplay, when it runs to completion.
 Simply changing the buffer text or setting `window-start'
 does not update this value.
 If GUARANTEE is non-nil, then the return value is guaranteed to be
 the value of window-end at the end of the next full redisplay assuming
 nothing else changes in the meantime.  This function is potentially much
 slower with this flag set.
-*/ )
+*/
-(window, guarantee)
+(window, guarantee))
-Lisp_Object window, guarantee;
 {
 Lisp_Object value;
 struct window *w = decode_window (window);
 Lisp_Object buf;
 Bufpos startp = marker_position (w->start[CURRENT_DISP]);
 return (make_int (end_of_last_line (w, startp)));
 }
 }
-DEFUN ("set-window-point", Fset_window_point, Sset_window_point, 2, 2, 0 /*
+DEFUN ("set-window-point", Fset_window_point, 2, 2, 0, /*
 Make point value in WINDOW be at position POS in WINDOW's buffer.
-*/ )
+*/
-(window, pos)
+(window, pos))
-Lisp_Object window, pos;
 {
 struct window *w = decode_window (window);
 CHECK_INT_COERCE_MARKER (pos);
 if (w == XWINDOW (Fselected_window (Qnil)))
 MARK_POINT_CHANGED;
 return pos;
 }
-DEFUN ("set-window-start", Fset_window_start, Sset_window_start, 2, 3, 0 /*
+DEFUN ("set-window-start", Fset_window_start, 2, 3, 0, /*
 Make display in WINDOW start at position POS in WINDOW's buffer.
 Optional third arg NOFORCE non-nil inhibits next redisplay
 from overriding motion of point in order to display at this exact start.
-*/ )
+*/
-(window, pos, noforce)
+(window, pos, noforce))
-Lisp_Object window, pos, noforce;
 {
 struct window *w = decode_window (window);
 CHECK_INT_COERCE_MARKER (pos);
 set_marker_restricted (w->start[CURRENT_DISP], pos, w->buffer);
 MARK_WINDOWS_CHANGED (w);
 return pos;
 }
-DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
+DEFUN ("window-dedicated-p", Fwindow_dedicated_p, 1, 1, 0, /*
-1, 1, 0 /*
 Return WINDOW's dedicated object, usually t or nil.
 See also `set-window-dedicated-p'.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 return decode_window (window)->dedicated;
 }
-DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p,
+DEFUN ("set-window-dedicated-p", Fset_window_dedicated_p, 2, 2, 0, /*
-Sset_window_dedicated_p, 2, 2, 0 /*
 Control whether WINDOW is dedicated to the buffer it displays.
 If it is dedicated, Emacs will not automatically change
 which buffer appears in it.
 The second argument is the new value for the dedication flag;
 non-nil means yes.
-*/ )
+*/
-(window, arg)
+(window, arg))
-Lisp_Object window, arg;
 {
 register struct window *w = decode_window (window);
 if (NILP (arg))
 w->dedicated = Qnil;
 they don't sit around consuming excess space.  They will be
 reinitialized by the window-configuration code as necessary. */
 finalize_window ((void *) w, 0);
 }
-DEFUN ("delete-window", Fdelete_window, Sdelete_window, 0, 2, "" /*
+DEFUN ("delete-window", Fdelete_window, 0, 2, "", /*
 Remove WINDOW from the display.  Default is selected window.
 If window is the only one on the frame, the frame is destroyed.
 Normally, you cannot delete the last non-minibuffer-only frame (you must
 use `save-buffers-kill-emacs' or `kill-emacs').  However, if optional
 second argument FORCE is non-nil, you can delete the last frame. (This
 will automatically call `save-buffers-kill-emacs'.)
-*/ )
+*/
-(window, force)
+(window, force))
-Lisp_Object window, force;
 {
 /* This function can GC if this is the only window in the frame */
 struct window *w;
 Lisp_Object parent;
 struct window *par;
 f->mirror_dirty = 1;
 return Qnil;
 }
-DEFUN ("next-window", Fnext_window, Snext_window, 0, 4, 0 /*
+DEFUN ("next-window", Fnext_window, 0, 4, 0, /*
 Return next window after 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
 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)
+(window, minibuf, all_frames, console))
-Lisp_Object window, minibuf, all_frames, console;
 {
 Lisp_Object tem;
 Lisp_Object start_window;
 if (NILP (window))
 	 && ! EQ (window, start_window));
 return window;
 }
-DEFUN ("previous-window", Fprevious_window, Sprevious_window, 0, 4, 0 /*
+DEFUN ("previous-window", Fprevious_window, 0, 4, 0, /*
 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
 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)
+(window, minibuf, all_frames, console))
-Lisp_Object window, minibuf, all_frames, console;
 {
 Lisp_Object tem;
 Lisp_Object start_window;
 if (NILP (window))
 	 && ! EQ (window, start_window));
 return window;
 }
-DEFUN ("next-vertical-window", Fnext_vertical_window, Snext_vertical_window,
+DEFUN ("next-vertical-window", Fnext_vertical_window, 0, 1, 0, /*
-0, 1, 0 /*
 Return the next window which is vertically after WINDOW.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 Lisp_Object root;
 struct window *w = decode_window (window);
 XSETWINDOW (window, w);
 window = XWINDOW (window)->vchild;
 else
 return window;
 }
-DEFUN ("other-window", Fother_window, Sother_window, 1, 3, "p" /*
+DEFUN ("other-window", Fother_window, 1, 3, "p", /*
 Select the N'th different window on this frame.
 All windows on current frame are arranged in a cyclic order.
 This command selects the window N steps away in that order.
 A negative N moves in the opposite order.
 device.  If CONSOLE is a console type, return windows only on consoles
 of that type.  If CONSOLE is 'window-system, return any windows on any
 window-system consoles.  If CONSOLE is nil or omitted, return windows only
 on FRAME'S console, or on the selected console if FRAME is not a frame.
 Otherwise, all windows are considered.
-*/ )
+*/
-(n, frame, console)
+(n, frame, console))
-Lisp_Object n, frame, console;
 {
 int i;
 Lisp_Object w;
 CHECK_INT (n);
 }
 #endif
-DEFUN ("get-lru-window", Fget_lru_window, Sget_lru_window, 0, 2, 0 /*
+DEFUN ("get-lru-window", Fget_lru_window, 0, 2, 0, /*
 Return the window least recently selected or used for display.
 If optional argument FRAME is `visible', search all visible frames.
 If FRAME is 0, search all visible and iconified frames.
 If FRAME is t, search all frames.
 If FRAME is nil, search only the selected frame.
 device.  If CONSOLE is a console type, return windows only on consoles
 of that type.  If CONSOLE is 'window-system, return any windows on any
 window-system consoles.  If CONSOLE is nil or omitted, return windows only
 on FRAME'S console, or on the selected console if FRAME is not a frame.
 Otherwise, all windows are considered.
-*/ )
+*/
-(frame, console)
+(frame, console))
-Lisp_Object frame, console;
 {
 Lisp_Object w;
 /* First try for a non-dedicated window that is full-width */
 w = window_loop (GET_LRU_WINDOW, Qt, 0, frame, 0, console);
 if (!NILP (w) && !EQ (w, Fselected_window (Qnil)))
 #endif
 return (w);
 }
-DEFUN ("get-largest-window", Fget_largest_window, Sget_largest_window, 0, 2, 0 /*
+DEFUN ("get-largest-window", Fget_largest_window, 0, 2, 0, /*
 Return the window largest in area.
 If optional argument FRAME is `visible', search all visible frames.
 If FRAME is 0, search all visible and iconified frames.
 If FRAME is t, search all frames.
 If FRAME is nil, search only the selected frame.
 device.  If CONSOLE is a console type, return windows only on consoles
 of that type.  If CONSOLE is 'window-system, return any windows on any
 window-system consoles.  If CONSOLE is nil or omitted, return windows only
 on FRAME'S console, or on the selected console if FRAME is not a frame.
 Otherwise, all windows are considered.
-*/ )
+*/
-(frame, console)
+(frame, console))
-Lisp_Object frame, console;
 {
 /* Don't search dedicated windows because FSFmacs doesn't.
 This stuff is all black magic so don't try to apply common
 sense to it. */
 return window_loop (GET_LARGEST_WINDOW, Qnil, 0, frame, 0, console);
 }
-DEFUN ("get-buffer-window", Fget_buffer_window, Sget_buffer_window, 1, 3, 0 /*
+DEFUN ("get-buffer-window", Fget_buffer_window, 1, 3, 0, /*
 Return a window currently displaying BUFFER, or nil if none.
 If optional argument FRAME is `visible', search all visible frames.
 If optional argument FRAME is 0, search all visible and iconified frames.
 If FRAME is t, search all frames.
 If FRAME is nil, search only the selected frame.
 device.  If CONSOLE is a console type, return windows only on consoles
 of that type.  If CONSOLE is 'window-system, return any windows on any
 window-system consoles.  If CONSOLE is nil or omitted, return windows only
 on FRAME'S console, or on the selected console if FRAME is not a frame.
 Otherwise, all windows are considered.
-*/ )
+*/
-(buffer, frame, console)
+(buffer, frame, console))
-Lisp_Object buffer, frame, console;
 {
 buffer = Fget_buffer (buffer);
 if (BUFFERP (buffer))
 /* Search dedicated windows too. (Doesn't matter here anyway.) */
 return window_loop (GET_BUFFER_WINDOW, buffer, 1, frame, 1, console);
 /* These functions used to be `buffer-left-margin-pixel-width', etc.
 but there is no sensible way to implement those functions, since
 you can't in general derive a window from a buffer. */
-DEFUN ("window-left-margin-pixel-width", Fwindow_left_margin_pixel_width,
+DEFUN ("window-left-margin-pixel-width",
-Swindow_left_margin_pixel_width, 0, 1, 0 /*
+Fwindow_left_margin_pixel_width, 0, 1, 0, /*
 Return the width in pixels of the left outside margin of window WINDOW.
 If WINDOW is nil, the selected window is assumed.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return (make_int (window_left_margin_width (w)));
 }
-DEFUN ("window-right-margin-pixel-width", Fwindow_right_margin_pixel_width,
+DEFUN ("window-right-margin-pixel-width",
-Swindow_right_margin_pixel_width, 0, 1, 0 /*
+Fwindow_right_margin_pixel_width, 0, 1, 0, /*
 Return the width in pixels of the right outside margin of window WINDOW.
 If WINDOW is nil, the selected window is assumed.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 return (make_int (window_right_margin_width (w)));
 }
-DEFUN ("delete-other-windows", Fdelete_other_windows, Sdelete_other_windows,
+DEFUN ("delete-other-windows", Fdelete_other_windows, 0, 1, "", /*
-0, 1, "" /*
 Make WINDOW (or the selected window) fill its frame.
 Only the frame WINDOW is on is affected.
 This function tries to reduce display jumps
 by keeping the text previously visible in WINDOW
 in the same place on the frame.  Doing this depends on
 the value of (window-start WINDOW), so if calling this function
 in a program gives strange scrolling, make sure the window-start
 value is reasonable when this function is called.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w = decode_window (window);
 struct buffer *b = XBUFFER (w->buffer);
 Bufpos start_pos;
 int old_top = WINDOW_TOP (w);
 }
 return Qnil;
 }
-DEFUN ("delete-windows-on", Fdelete_windows_on, Sdelete_windows_on,
+DEFUN ("delete-windows-on", Fdelete_windows_on, 1, 3,
-1, 3, "bDelete windows on (buffer): " /*
+"bDelete windows on (buffer): ", /*
 Delete all windows showing BUFFER.
 Optional second argument FRAME controls which frames are affected.
 If nil or omitted, delete all windows showing BUFFER in any frame.
 If t, delete only windows showing BUFFER in the selected frame.
 If `visible', delete all windows showing BUFFER in any visible frame.
 device.  If CONSOLE is a console type, return windows only on consoles
 of that type.  If CONSOLE is 'window-system, return any windows on any
 window-system consoles.  If CONSOLE is nil or omitted, return windows only
 on FRAME'S console, or on the selected console if FRAME is not a frame.
 Otherwise, all windows are considered.
-*/ )
+*/
-(buffer, frame, console)
+(buffer, frame, console))
-Lisp_Object buffer, frame, console;
 {
 /* This function can GC */
 /* FRAME uses t and nil to mean the opposite of what window_loop
 expects. */
 if (!FRAMEP (frame))
 window_loop (DELETE_BUFFER_WINDOWS, buffer, 0, frame, 0, console);
 }
 return Qnil;
 }
-DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows,
+DEFUN ("replace-buffer-in-windows", Freplace_buffer_in_windows, 1, 1,
-Sreplace_buffer_in_windows,
+"bReplace buffer in windows: ", /*
-1, 1, "bReplace buffer in windows: " /*
 Replace BUFFER with some other buffer in all windows showing it.
-*/ )
+*/
-(buffer)
+(buffer))
-Lisp_Object buffer;
 {
 /* This function can GC */
 if (!NILP (buffer))
 {
 buffer = Fget_buffer (buffer);
 }
 static int window_select_count;
-DEFUN ("set-window-buffer", Fset_window_buffer, Sset_window_buffer, 2, 2, 0 /*
+DEFUN ("set-window-buffer", Fset_window_buffer, 2, 2, 0, /*
 Make WINDOW display BUFFER as its contents.
 BUFFER can be a buffer or buffer name.
-*/ )
+*/
-(window, buffer)
+(window, buffer))
-Lisp_Object window, buffer;
 {
 Lisp_Object tem;
 struct window *w = decode_window (window);
 buffer = Fget_buffer (buffer);
 #endif
 }
 return Qnil;
 }
-DEFUN ("select-window", Fselect_window, Sselect_window, 1, 1, 0 /*
+DEFUN ("select-window", Fselect_window, 1, 1, 0, /*
 Select WINDOW.  Most editing will apply to WINDOW's buffer.
 The main editor command loop selects the buffer of the selected window
 before each command.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window *w;
 Lisp_Object old_selected_window = Fselected_window (Qnil);
 CHECK_LIVE_WINDOW (window);
 p->pointm[CMOTION_DISP] = Qnil;
 p->sb_point = Qnil;
 p->buffer = Qnil;
 }
-DEFUN ("split-window", Fsplit_window, Ssplit_window, 0, 3, "" /*
+DEFUN ("split-window", Fsplit_window, 0, 3, "", /*
 Split WINDOW, putting SIZE lines in the first of the pair.
 WINDOW defaults to selected one and SIZE to half its size.
 If optional third arg HOR-FLAG is non-nil, split side by side
 and put SIZE columns in the first of the pair.
-*/ )
+*/
-(window, chsize, horflag)
+(window, chsize, horflag))
-Lisp_Object window, chsize, horflag;
 {
 Lisp_Object new;
 struct window *o, *p;
 struct frame *f;
 int size;
 Fset_window_buffer (new, o->buffer);
 return new;
 }
-DEFUN ("enlarge-window", Fenlarge_window, Senlarge_window, 1, 3, "_p" /*
+DEFUN ("enlarge-window", Fenlarge_window, 1, 3, "_p", /*
 Make the selected window ARG lines bigger.
 From program, optional second arg non-nil means grow sideways ARG columns,
 and optional third ARG specifies the window to change instead of the
 selected window.
-*/ )
+*/
-(n, side, window)
+(n, side, window))
-Lisp_Object n, side, window;
 {
 struct window *w = decode_window (window);
 CHECK_INT (n);
 change_window_height (w, XINT (n), !NILP (side));
 return Qnil;
 }
-DEFUN ("shrink-window", Fshrink_window, Sshrink_window, 1, 3, "_p" /*
+DEFUN ("shrink-window", Fshrink_window, 1, 3, "_p", /*
 Make the selected window ARG lines smaller.
 From program, optional second arg non-nil means shrink sideways ARG columns,
 and optional third ARG specifies the window to change instead of the
 selected window.
-*/ )
+*/
-(n, side, window)
+(n, side, window))
-Lisp_Object n, side, window;
 {
 struct window *w = decode_window (window);
 CHECK_INT (n);
 change_window_height (w, -XINT (n), !NILP (side));
 return Qnil;
 	}
 }
 }
-DEFUN ("scroll-up", Fscroll_up, Sscroll_up, 0, 1, "_P" /*
+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.
-*/ )
+*/
-(n)
+(n))
-Lisp_Object n;
 {
 window_scroll (Fselected_window (Qnil), n, 1, ERROR_ME);
 return Qnil;
 }
-DEFUN ("scroll-down", Fscroll_down, Sscroll_down, 0, 1, "_P" /*
+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.
-*/ )
+*/
-(n)
+(n))
-Lisp_Object n;
 {
 window_scroll (Fselected_window (Qnil), n, -1, ERROR_ME);
 return Qnil;
 }
-DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling, Sother_window_for_scrolling, 0, 0, 0 /*
+DEFUN ("other-window-for-scrolling", Fother_window_for_scrolling, 0, 0, 0, /*
 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.
-*/ )
+*/
-()
+())
 {
 Lisp_Object window;
 Lisp_Object selected_window = Fselected_window (Qnil);
 if (MINI_WINDOW_P (XWINDOW (selected_window))
 error ("There is no other window");
 return window;
 }
-DEFUN ("scroll-other-window", Fscroll_other_window, Sscroll_other_window, 0, 1, "_P" /*
+DEFUN ("scroll-other-window", Fscroll_other_window, 0, 1, "_P", /*
 Scroll next window upward ARG 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.
 When calling from a program, supply a number as argument or nil.
 If in the minibuffer, `minibuf-scroll-window' if non-nil
 specifies the window to scroll.
 If `other-window-scroll-buffer' is non-nil, scroll the window
 showing that buffer, popping the buffer up if necessary.
-*/ )
+*/
-(n)
+(n))
-Lisp_Object n;
 {
 window_scroll (Fother_window_for_scrolling (), n, 1, ERROR_ME);
 return Qnil;
 }
-DEFUN ("scroll-left", Fscroll_left, Sscroll_left, 0, 1, "_P" /*
+DEFUN ("scroll-left", Fscroll_left, 0, 1, "_P", /*
 Scroll selected window display ARG columns left.
 Default for ARG is window width minus 2.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 Lisp_Object window = Fselected_window (Qnil);
 struct window *w = XWINDOW (window);
 if (NILP (arg))
 return
 Fset_window_hscroll (window, make_int (w->hscroll + XINT (arg)));
 }
-DEFUN ("scroll-right", Fscroll_right, Sscroll_right, 0, 1, "_P" /*
+DEFUN ("scroll-right", Fscroll_right, 0, 1, "_P", /*
 Scroll selected window display ARG columns right.
 Default for ARG is window width minus 2.
-*/ )
+*/
-(arg)
+(arg))
-Lisp_Object arg;
 {
 Lisp_Object window = Fselected_window (Qnil);
 struct window *w = XWINDOW (window);
 if (NILP (arg))
 return
 Fset_window_hscroll (window, make_int (w->hscroll - XINT (arg)));
 }
-DEFUN ("recenter", Frecenter, Srecenter, 0, 2, "_P" /*
+DEFUN ("recenter", Frecenter, 0, 2, "_P", /*
 Center point in WINDOW and redisplay frame.  With ARG, put point on line ARG.
 The desired position of point is always relative to the window.
 Just C-u as prefix means put point in the center of the window.
 No arg (i.e., it is nil) erases the entire frame and then
 redraws with point in the center of the window.
 If WINDOW is nil, the selected window is used.
-*/ )
+*/
-(n, window)
+(n, window))
-Lisp_Object n, window;
 {
 struct window *w;
 struct buffer *b;
 Bufpos startp;
 Bufpos opoint;
 w->force_start = 1;
 MARK_WINDOWS_CHANGED (w);
 return Qnil;
 }
-DEFUN ("move-to-window-line", Fmove_to_window_line, Smove_to_window_line,
+DEFUN ("move-to-window-line", Fmove_to_window_line, 1, 2, "_P", /*
-1, 2, "_P" /*
 Position point relative to WINDOW.
 With no argument, position text at center of window.
 An argument specifies window line; zero means top of window,
 negative means relative to bottom of window.
 If WINDOW is nil, the selected window is used.
-*/ )
+*/
-(arg, window)
+(arg, window))
-Lisp_Object arg, window;
 {
 struct window *w;
 struct buffer *b;
 int height;
 Bufpos start, new_point;
 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, Swindow_memory_usage,
+DEFUN ("window-memory-usage", Fwindow_memory_usage, 1, 1, 0, /*
-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
 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()
 Multiple slices of the total memory usage may be returned, separated
 by a nil.  Each slice represents a particular view of the memory, a
 particular way of partitioning it into groups.  Within a slice, there
 is no overlap between the groups of memory, and each slice collectively
 represents all the memory concerned.
-*/ )
+*/
-(window)
+(window))
-Lisp_Object window;
 {
 struct window_stats stats;
 struct overhead_stats ovstats;
 CHECK_WINDOW (window); /* dead windows should be allowed, no? */
 }
 return 1;
 }
-DEFUN ("window-configuration-p", Fwindow_configuration_p,
+DEFUN ("window-configuration-p", Fwindow_configuration_p, 1, 1, 0, /*
-Swindow_configuration_p, 1, 1, 0 /*
 T if OBJECT is a window-configuration object.
-*/ )
+*/
-(obj)
+(obj))
-Lisp_Object obj;
 {
 return (WINDOW_CONFIGURATIONP (obj) ? Qt : Qnil);
 }
 /*
 			   window_config);
 return Qnil;
 }
-DEFUN ("set-window-configuration",
+DEFUN ("set-window-configuration", Fset_window_configuration, 1, 1, 0, /*
-Fset_window_configuration, Sset_window_configuration,
-1, 1, 0 /*
 Set the configuration of windows and buffers as specified by CONFIGURATION.
 CONFIGURATION must be a value previously returned
 by `current-window-configuration' (which see).
-*/ )
+*/
-(configuration)
+(configuration))
-Lisp_Object configuration;
 {
 struct window *w;
 struct window_config *config;
 struct saved_window *p;
 Lisp_Object new_current_buffer;
 redirection (see `redirect-frame-focus').
 */
 #endif
-DEFUN ("current-window-configuration",
+DEFUN ("current-window-configuration", Fcurrent_window_configuration, 0, 1, 0, /*
-	Fcurrent_window_configuration, Scurrent_window_configuration, 0, 1, 0 /*
 Return an object representing the current window configuration of FRAME.
 If FRAME is nil or omitted, use the selected frame.
 This describes the number of windows, their sizes and current buffers,
 and for each displayed buffer, where display starts, and the positions of
 point and mark.  An exception is made for point in the current buffer:
 its value is -not- saved.
-*/ )
+*/
-(frame)
+(frame))
-Lisp_Object frame;
 {
 Lisp_Object result = Qnil;
 struct frame *f;
 int n_windows;
 Lisp_Object val = Fset_window_configuration (window_config);
 free_window_configuration (window_config);
 return val;
 }
-DEFUN ("save-window-excursion", Fsave_window_excursion, Ssave_window_excursion,
+DEFUN ("save-window-excursion", Fsave_window_excursion, 0, UNEVALLED, 0, /*
-0, UNEVALLED, 0 /*
 Execute body, preserving window sizes and contents.
 Restores which buffer appears in which window, where display starts,
 as well as the current buffer.
 Does not restore the value of point in current buffer.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object val;
 int speccount = specpdl_depth ();
 #endif
 defsymbol (&Qother_redisplay, "other-redisplay");
 /* Qother in general.c */
 #endif
-defsubr (&Sselected_window);
+DEFSUBR (Fselected_window);
-defsubr (&Sminibuffer_window);
+DEFSUBR (Fminibuffer_window);
-defsubr (&Swindow_minibuffer_p);
+DEFSUBR (Fwindow_minibuffer_p);
-defsubr (&Swindowp);
+DEFSUBR (Fwindowp);
-defsubr (&Swindow_live_p);
+DEFSUBR (Fwindow_live_p);
-defsubr (&Swindow_first_hchild);
+DEFSUBR (Fwindow_first_hchild);
-defsubr (&Swindow_first_vchild);
+DEFSUBR (Fwindow_first_vchild);
-defsubr (&Swindow_next_child);
+DEFSUBR (Fwindow_next_child);
-defsubr (&Swindow_previous_child);
+DEFSUBR (Fwindow_previous_child);
-defsubr (&Swindow_parent);
+DEFSUBR (Fwindow_parent);
-defsubr (&Swindow_lowest_p);
+DEFSUBR (Fwindow_lowest_p);
-defsubr (&Swindow_highest_p);
+DEFSUBR (Fwindow_highest_p);
-defsubr (&Swindow_leftmost_p);
+DEFSUBR (Fwindow_leftmost_p);
-defsubr (&Swindow_rightmost_p);
+DEFSUBR (Fwindow_rightmost_p);
-defsubr (&Spos_visible_in_window_p);
+DEFSUBR (Fpos_visible_in_window_p);
-defsubr (&Swindow_buffer);
+DEFSUBR (Fwindow_buffer);
-defsubr (&Swindow_frame);
+DEFSUBR (Fwindow_frame);
-defsubr (&Swindow_height);
+DEFSUBR (Fwindow_height);
-defsubr (&Swindow_displayed_height);
+DEFSUBR (Fwindow_displayed_height);
-defsubr (&Swindow_width);
+DEFSUBR (Fwindow_width);
-defsubr (&Swindow_pixel_height);
+DEFSUBR (Fwindow_pixel_height);
-defsubr (&Swindow_pixel_width);
+DEFSUBR (Fwindow_pixel_width);
-defsubr (&Swindow_hscroll);
+DEFSUBR (Fwindow_hscroll);
 #if 0 /* bogus RMS crock */
-defsubr (&Swindow_redisplay_end_trigger);
+DEFSUBR (Fwindow_redisplay_end_trigger);
-defsubr (&Sset_window_redisplay_end_trigger);
+DEFSUBR (Fset_window_redisplay_end_trigger);
 #endif
-defsubr (&Sset_window_hscroll);
+DEFSUBR (Fset_window_hscroll);
-defsubr (&Swindow_pixel_edges);
+DEFSUBR (Fwindow_pixel_edges);
-defsubr (&Swindow_point);
+DEFSUBR (Fwindow_point);
-defsubr (&Swindow_start);
+DEFSUBR (Fwindow_start);
-defsubr (&Swindow_end);
+DEFSUBR (Fwindow_end);
-defsubr (&Sset_window_point);
+DEFSUBR (Fset_window_point);
-defsubr (&Sset_window_start);
+DEFSUBR (Fset_window_start);
-defsubr (&Swindow_dedicated_p);
+DEFSUBR (Fwindow_dedicated_p);
-defsubr (&Sset_window_dedicated_p);
+DEFSUBR (Fset_window_dedicated_p);
-defsubr (&Snext_window);
+DEFSUBR (Fnext_window);
-defsubr (&Sprevious_window);
+DEFSUBR (Fprevious_window);
-defsubr (&Snext_vertical_window);
+DEFSUBR (Fnext_vertical_window);
-defsubr (&Sother_window);
+DEFSUBR (Fother_window);
-defsubr (&Sget_lru_window);
+DEFSUBR (Fget_lru_window);
-defsubr (&Sget_largest_window);
+DEFSUBR (Fget_largest_window);
-defsubr (&Sget_buffer_window);
+DEFSUBR (Fget_buffer_window);
-defsubr (&Swindow_left_margin_pixel_width);
+DEFSUBR (Fwindow_left_margin_pixel_width);
-defsubr (&Swindow_right_margin_pixel_width);
+DEFSUBR (Fwindow_right_margin_pixel_width);
-defsubr (&Sdelete_other_windows);
+DEFSUBR (Fdelete_other_windows);
-defsubr (&Sdelete_windows_on);
+DEFSUBR (Fdelete_windows_on);
-defsubr (&Sreplace_buffer_in_windows);
+DEFSUBR (Freplace_buffer_in_windows);
-defsubr (&Sdelete_window);
+DEFSUBR (Fdelete_window);
-defsubr (&Sset_window_buffer);
+DEFSUBR (Fset_window_buffer);
-defsubr (&Sselect_window);
+DEFSUBR (Fselect_window);
-defsubr (&Ssplit_window);
+DEFSUBR (Fsplit_window);
-defsubr (&Senlarge_window);
+DEFSUBR (Fenlarge_window);
-defsubr (&Sshrink_window);
+DEFSUBR (Fshrink_window);
-defsubr (&Sscroll_up);
+DEFSUBR (Fscroll_up);
-defsubr (&Sscroll_down);
+DEFSUBR (Fscroll_down);
-defsubr (&Sscroll_left);
+DEFSUBR (Fscroll_left);
-defsubr (&Sscroll_right);
+DEFSUBR (Fscroll_right);
-defsubr (&Sother_window_for_scrolling);
+DEFSUBR (Fother_window_for_scrolling);
-defsubr (&Sscroll_other_window);
+DEFSUBR (Fscroll_other_window);
-defsubr (&Srecenter);
+DEFSUBR (Frecenter);
-defsubr (&Smove_to_window_line);
+DEFSUBR (Fmove_to_window_line);
 #ifdef MEMORY_USAGE_STATS
-defsubr (&Swindow_memory_usage);
+DEFSUBR (Fwindow_memory_usage);
 #endif
-defsubr (&Swindow_configuration_p);
+DEFSUBR (Fwindow_configuration_p);
-defsubr (&Sset_window_configuration);
+DEFSUBR (Fset_window_configuration);
-defsubr (&Scurrent_window_configuration);
+DEFSUBR (Fcurrent_window_configuration);
-defsubr (&Ssave_window_excursion);
+DEFSUBR (Fsave_window_excursion);
 }
 void
 vars_of_window (void)
 {

Mercurial > hg > xemacs-beta

comparison src/window.c @ 20:859a2309aef8 r19-15b93