This value is always the same as
FRAME_SELECTED_WINDOW (selected_frame). */
-
Lisp_Object selected_window;
/* A list of all windows for use by next_window and Fwindow_list.
Functions creating or deleting windows should invalidate this cache
by setting it to nil. */
-
Lisp_Object Vwindow_list;
/* The mini-buffer window of the selected frame.
Note that you cannot test for mini-bufferness of an arbitrary window
by comparing against this; but you can test for mini-bufferness of
the selected window. */
-
Lisp_Object minibuf_window;
/* Non-nil means it is the window whose mode line should be
shown as the selected window when the minibuffer is selected. */
-
Lisp_Object minibuf_selected_window;
/* Hook run at end of temp_output_buffer_show. */
-
static Lisp_Object Qtemp_buffer_show_hook;
/* Incremented for each window created. */
-
static int sequence_number;
/* Nonzero after init_window_once has finished. */
-
static int window_initialized;
/* Hook to run when window config changes. */
-
static Lisp_Object Qwindow_configuration_change_hook;
-/* Incremented by 1 whenever a window is deleted. */
+/* Incremented by 1 whenever a window is deleted. */
static int window_deletion_count;
/* Used by the function window_scroll_pixel_based */
-
static int window_scroll_pixel_based_preserve_x;
static int window_scroll_pixel_based_preserve_y;
/* Same for window_scroll_line_based. */
-
static int window_scroll_preserve_hpos;
static int window_scroll_preserve_vpos;
+\f
+static struct window *
+decode_window (register Lisp_Object window)
+{
+ if (NILP (window))
+ return XWINDOW (selected_window);
-#if 0 /* This isn't used anywhere. */
-/* Nonzero means we can split a frame even if it is "unsplittable". */
-static int inhibit_frame_unsplittable;
-#endif
+ CHECK_LIVE_WINDOW (window);
+ return XWINDOW (window);
+}
+
+static struct window *
+decode_any_window (register Lisp_Object window)
+{
+ if (NILP (window))
+ return XWINDOW (selected_window);
+
+ CHECK_WINDOW (window);
+ return XWINDOW (window);
+}
-\f
DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
- doc: /* Return t if OBJECT is a window. */)
+ doc: /* Return t if OBJECT is a window and nil otherwise. */)
(Lisp_Object object)
{
return WINDOWP (object) ? Qt : Qnil;
}
DEFUN ("window-live-p", Fwindow_live_p, Swindow_live_p, 1, 1, 0,
- doc: /* Return t if OBJECT is a window which is currently visible. */)
+ doc: /* Return t if OBJECT is a live window and nil otherwise.
+A live window is a window that displays a buffer. */)
(Lisp_Object object)
{
return WINDOW_LIVE_P (object) ? Qt : Qnil;
}
+\f
+/* Frames and windows. */
+DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
+ doc: /* Return the frame that window WINDOW is on.
+WINDOW can be any window and defaults to the selected one. */)
+ (Lisp_Object window)
+{
+ return decode_any_window (window)->frame;
+}
+
+DEFUN ("frame-root-window", Fframe_root_window, Sframe_root_window, 0, 1, 0,
+ doc: /* Return the root window of FRAME_OR_WINDOW.
+If omitted, FRAME_OR_WINDOW defaults to the currently selected frame.
+Else if FRAME_OR_WINDOW denotes any window, return the root window of
+that window's frame. If FRAME_OR_WINDOW denotes a live frame, return
+the root window of that frame. */)
+ (Lisp_Object frame_or_window)
+{
+ Lisp_Object window;
+
+ if (NILP (frame_or_window))
+ window = SELECTED_FRAME ()->root_window;
+ else if (WINDOWP (frame_or_window))
+ window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->root_window;
+ else
+ {
+ CHECK_LIVE_FRAME (frame_or_window);
+ window = XFRAME (frame_or_window)->root_window;
+ }
+
+ return window;
+}
+
+DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0,
+ doc: /* Return the window used now for minibuffers.
+If the optional argument FRAME is specified, return the minibuffer window
+used by that frame. */)
+ (Lisp_Object frame)
+{
+ if (NILP (frame))
+ frame = selected_frame;
+ CHECK_LIVE_FRAME (frame);
+ return FRAME_MINIBUF_WINDOW (XFRAME (frame));
+}
+
+DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p,
+ Swindow_minibuffer_p, 0, 1, 0,
+ doc: /* Return non-nil if WINDOW is a minibuffer window.
+WINDOW can be any window and defaults to the selected one. */)
+ (Lisp_Object window)
+{
+ return MINI_WINDOW_P (decode_any_window (window)) ? Qt : Qnil;
+}
+
+/* Don't move this to window.el - this must be a safe routine. */
+DEFUN ("frame-first-window", Fframe_first_window, Sframe_first_window, 0, 1, 0,
+ doc: /* Return the topmost, leftmost live window on FRAME_OR_WINDOW.
+If omitted, FRAME_OR_WINDOW defaults to the currently selected frame.
+Else if FRAME_OR_WINDOW denotes any window, return the first window of
+that window's frame. If FRAME_OR_WINDOW denotes a live frame, return
+the first window of that frame. */)
+ (Lisp_Object frame_or_window)
+{
+ Lisp_Object window;
+
+ if (NILP (frame_or_window))
+ window = SELECTED_FRAME ()->root_window;
+ else if (WINDOWP (frame_or_window))
+ window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->root_window;
+ else
+ {
+ CHECK_LIVE_FRAME (frame_or_window);
+ window = XFRAME (frame_or_window)->root_window;
+ }
+
+ while (NILP (XWINDOW (window)->buffer))
+ {
+ if (! NILP (XWINDOW (window)->hchild))
+ window = XWINDOW (window)->hchild;
+ else if (! NILP (XWINDOW (window)->vchild))
+ window = XWINDOW (window)->vchild;
+ else
+ abort ();
+ }
+
+ return window;
+}
+
+DEFUN ("frame-selected-window", Fframe_selected_window,
+ Sframe_selected_window, 0, 1, 0,
+ doc: /* Return the selected window of FRAME_OR_WINDOW.
+If omitted, FRAME_OR_WINDOW defaults to the currently selected frame.
+Else if FRAME_OR_WINDOW denotes any window, return the selected window
+of that window's frame. If FRAME_OR_WINDOW denotes a live frame, return
+the selected window of that frame. */)
+ (Lisp_Object frame_or_window)
+{
+ Lisp_Object window;
+
+ if (NILP (frame_or_window))
+ window = SELECTED_FRAME ()->selected_window;
+ else if (WINDOWP (frame_or_window))
+ window = XFRAME (WINDOW_FRAME (XWINDOW (frame_or_window)))->selected_window;
+ else
+ {
+ CHECK_LIVE_FRAME (frame_or_window);
+ window = XFRAME (frame_or_window)->selected_window;
+ }
+
+ return window;
+}
+
+DEFUN ("set-frame-selected-window", Fset_frame_selected_window,
+ Sset_frame_selected_window, 2, 3, 0,
+ doc: /* Set selected window of FRAME to WINDOW.
+FRAME must be a live frame and defaults to the selected one. If FRAME
+is the selected frame, this makes WINDOW the selected window. Optional
+argument NORECORD non-nil means to neither change the order of recently
+selected windows nor the buffer list. WINDOW must denote a live window.
+Return WINDOW. */)
+ (Lisp_Object frame, Lisp_Object window, Lisp_Object norecord)
+{
+ if (NILP (frame))
+ frame = selected_frame;
+
+ CHECK_LIVE_FRAME (frame);
+ CHECK_LIVE_WINDOW (window);
+
+ if (! EQ (frame, WINDOW_FRAME (XWINDOW (window))))
+ error ("In `set-frame-selected-window', WINDOW is not on FRAME");
+
+ if (EQ (frame, selected_frame))
+ return Fselect_window (window, norecord);
+ else
+ return XFRAME (frame)->selected_window = window;
+}
+
+DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
+ doc: /* Return the selected window.
+The selected window is the window in which the standard cursor for
+selected windows appears and to which many commands apply. */)
+ (void)
+{
+ return selected_window;
+}
+
+/* If select_window is called with inhibit_point_swap non-zero it will
+ not store point of the old selected window's buffer back into that
+ window's pointm slot. This is needed by Fset_window_configuration to
+ avoid that the display routine is called with selected_window set to
+ Qnil causing a subsequent crash. */
+static Lisp_Object
+select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
+{
+ register struct window *w;
+ register struct window *ow;
+ struct frame *sf;
+
+ CHECK_LIVE_WINDOW (window);
+
+ w = XWINDOW (window);
+ w->frozen_window_start_p = 0;
+
+ if (NILP (norecord))
+ {
+ ++window_select_count;
+ XSETFASTINT (w->use_time, window_select_count);
+ record_buffer (w->buffer);
+ }
+
+ if (EQ (window, selected_window) && !inhibit_point_swap)
+ return window;
+
+ sf = SELECTED_FRAME ();
+ if (XFRAME (WINDOW_FRAME (w)) != sf)
+ {
+ XFRAME (WINDOW_FRAME (w))->selected_window = window;
+ /* Use this rather than Fhandle_switch_frame
+ so that FRAME_FOCUS_FRAME is moved appropriately as we
+ move around in the state where a minibuffer in a separate
+ frame is active. */
+ Fselect_frame (WINDOW_FRAME (w), norecord);
+ /* Fselect_frame called us back so we've done all the work already. */
+ eassert (EQ (window, selected_window));
+ return window;
+ }
+ else
+ sf->selected_window = window;
+
+ /* Store the current buffer's actual point into the
+ old selected window. It belongs to that window,
+ and when the window is not selected, must be in the window. */
+ if (!inhibit_point_swap)
+ {
+ ow = XWINDOW (selected_window);
+ if (! NILP (ow->buffer))
+ set_marker_both (ow->pointm, ow->buffer,
+ BUF_PT (XBUFFER (ow->buffer)),
+ BUF_PT_BYTE (XBUFFER (ow->buffer)));
+ }
+
+ selected_window = window;
+
+ Fset_buffer (w->buffer);
+
+ BVAR (XBUFFER (w->buffer), last_selected_window) = window;
+
+ /* Go to the point recorded in the window.
+ This is important when the buffer is in more
+ than one window. It also matters when
+ redisplay_window has altered point after scrolling,
+ because it makes the change only in the window. */
+ {
+ register EMACS_INT new_point = marker_position (w->pointm);
+ if (new_point < BEGV)
+ SET_PT (BEGV);
+ else if (new_point > ZV)
+ SET_PT (ZV);
+ else
+ SET_PT (new_point);
+ }
+
+ windows_or_buffers_changed++;
+ return window;
+}
+
+DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
+ doc: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
+Also make WINDOW's buffer current and make WINDOW the frame's selected
+window. Return WINDOW.
+
+Optional second arg NORECORD non-nil means do not put this buffer at the
+front of the buffer list and do not make this window the most recently
+selected one.
+
+Note that the main editor command loop sets the current buffer to the
+buffer of the selected window before each command. */)
+ (register Lisp_Object window, Lisp_Object norecord)
+{
+ return select_window (window, norecord, 0);
+}
+\f
+DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
+ doc: /* Return the buffer that WINDOW is displaying.
+WINDOW can be any window and defaults to the selected one.
+If WINDOW is an internal window return nil. */)
+ (Lisp_Object window)
+{
+ return decode_any_window (window)->buffer;
+}
+DEFUN ("window-parent", Fwindow_parent, Swindow_parent, 0, 1, 0,
+ doc: /* Return WINDOW's parent window.
+WINDOW can be any window and defaults to the selected one.
+Return nil if WINDOW has no parent. */)
+ (Lisp_Object window)
+{
+ return decode_any_window (window)->parent;
+}
+
+DEFUN ("window-vchild", Fwindow_vchild, Swindow_vchild, 0, 1, 0,
+ doc: /* Return WINDOW's first vertical child window.
+WINDOW can be any window and defaults to the selected one.
+Return nil if WINDOW has no vertical child. */)
+ (Lisp_Object window)
+{
+ return decode_any_window (window)->vchild;
+}
+
+DEFUN ("window-hchild", Fwindow_hchild, Swindow_hchild, 0, 1, 0,
+ doc: /* Return WINDOW's first horizontal child window.
+WINDOW can be any window and defaults to the selected one.
+Return nil if WINDOW has no horizontal child. */)
+ (Lisp_Object window)
+{
+ return decode_any_window (window)->hchild;
+}
+
+DEFUN ("window-next", Fwindow_next, Swindow_next, 0, 1, 0,
+ doc: /* Return WINDOW's right sibling window.
+WINDOW can be any window and defaults to the selected one.
+Return nil if WINDOW has no right sibling. */)
+ (Lisp_Object window)
+{
+ return decode_any_window (window)->next;
+}
+
+DEFUN ("window-prev", Fwindow_prev, Swindow_prev, 0, 1, 0,
+ doc: /* Return WINDOW's left sibling window.
+WINDOW can be any window and defaults to the selected one.
+Return nil if WINDOW has no left sibling. */)
+ (Lisp_Object window)
+{
+ return decode_any_window (window)->prev;
+}
+\f
Lisp_Object
make_window (void)
{
return val;
}
-DEFUN ("selected-window", Fselected_window, Sselected_window, 0, 0, 0,
- doc: /* Return the window that the cursor now appears in and commands apply to. */)
- (void)
-{
- return selected_window;
-}
-
-DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0,
- doc: /* Return the window used now for minibuffers.
-If the optional argument FRAME is specified, return the minibuffer window
-used by that frame. */)
- (Lisp_Object frame)
-{
- if (NILP (frame))
- frame = selected_frame;
- CHECK_LIVE_FRAME (frame);
- return FRAME_MINIBUF_WINDOW (XFRAME (frame));
-}
-
-DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p,
- Swindow_minibuffer_p, 0, 1, 0,
- doc: /* Return non-nil if WINDOW is a minibuffer window.
-WINDOW defaults to the selected window. */)
- (Lisp_Object window)
-{
- struct window *w = decode_window (window);
- return MINI_WINDOW_P (w) ? Qt : Qnil;
-}
-
-
DEFUN ("pos-visible-in-window-p", Fpos_visible_in_window_p,
Spos_visible_in_window_p, 0, 3, 0,
doc: /* Return non-nil if position POS is currently on the frame in WINDOW.
make_number (row->y),
make_number (crop));
}
+\f
+DEFUN ("window-total-size", Fwindow_total_size, Swindow_total_size, 0, 2, 0,
+ doc: /* Return the total number of lines of WINDOW.
+WINDOW can be any window and defaults to the selected one. The return
+value includes WINDOW's mode line and header line, if any. If WINDOW
+is internal, the return value is the sum of the total number of lines
+of WINDOW's child windows if these are vertically combined and the
+height of WINDOW's first child otherwise.
+
+Optional argument HORIZONTAL non-nil means return the total number of
+columns of WINDOW. In this case the return value includes any vertical
+dividers or scrollbars of WINDOW. If WINDOW is internal, the return
+value is the sum of the total number of columns of WINDOW's child
+windows if they are horizontally combined and the width of WINDOW's
+first child otherwise. */)
+ (Lisp_Object window, Lisp_Object horizontal)
+{
+ if (NILP (horizontal))
+ return decode_any_window (window)->total_lines;
+ else
+ return decode_any_window (window)->total_cols;
+}
+DEFUN ("window-left-column", Fwindow_left_column, Swindow_left_column, 0, 1, 0,
+ doc: /* Return left column of WINDOW.
+WINDOW can be any window and defaults to the selected one. */)
+ (Lisp_Object window)
+{
+ return decode_any_window (window)->left_col;
+}
-\f
-static struct window *
-decode_window (register Lisp_Object window)
+DEFUN ("window-top-line", Fwindow_top_line, Swindow_top_line, 0, 1, 0,
+ doc: /* Return top line of WINDOW.
+WINDOW can be any window and defaults to the selected one. */)
+ (Lisp_Object window)
{
- if (NILP (window))
- return XWINDOW (selected_window);
+ return decode_any_window (window)->top_line;
+}
- CHECK_LIVE_WINDOW (window);
- return XWINDOW (window);
+/* Return the number of lines of W's body. Don't count any mode or
+ header line of W. */
+
+int
+window_body_lines (struct window *w)
+{
+ int height = XFASTINT (w->total_lines);
+
+ if (!MINI_WINDOW_P (w))
+ {
+ if (WINDOW_WANTS_MODELINE_P (w))
+ --height;
+ if (WINDOW_WANTS_HEADER_LINE_P (w))
+ --height;
+ }
+
+ return height;
}
-static struct window *
-decode_any_window (register Lisp_Object window)
+/* Return the number of columns of W's body. Don't count columns
+ occupied by the scroll bar or the vertical bar separating W from its
+ right sibling. On window-systems don't count fringes or display
+ margins either. */
+
+int
+window_body_cols (struct window *w)
{
- if (NILP (window))
- return XWINDOW (selected_window);
+ struct frame *f = XFRAME (WINDOW_FRAME (w));
+ int width = XINT (w->total_cols);
- CHECK_WINDOW (window);
- return XWINDOW (window);
+ if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
+ /* Scroll bars occupy a few columns. */
+ width -= WINDOW_CONFIG_SCROLL_BAR_COLS (w);
+ else if (!FRAME_WINDOW_P (f)
+ && !WINDOW_RIGHTMOST_P (w) && !WINDOW_FULL_WIDTH_P (w))
+ /* The column of `|' characters separating side-by-side windows
+ occupies one column only. */
+ width -= 1;
+
+ if (FRAME_WINDOW_P (f))
+ /* On window-systems, fringes and display margins cannot be
+ used for normal text. */
+ width -= (WINDOW_FRINGE_COLS (w)
+ + WINDOW_LEFT_MARGIN_COLS (w)
+ + WINDOW_RIGHT_MARGIN_COLS (w));
+
+ return width;
}
-DEFUN ("window-buffer", Fwindow_buffer, Swindow_buffer, 0, 1, 0,
- doc: /* Return the buffer that WINDOW is displaying.
-WINDOW defaults to the selected window. */)
- (Lisp_Object window)
+DEFUN ("window-body-size", Fwindow_body_size, Swindow_body_size, 0, 2, 0,
+ doc: /* Return the number of lines of WINDOW's body.
+WINDOW must be a live window and defaults to the selected one. The
+return value does not include WINDOW's mode line and header line, if
+any.
+
+Optional argument HORIZONTAL non-nil means return the number of columns
+of WINDOW's body. In this case, the return value does not include any
+vertical dividers or scroll bars owned by WINDOW. On a window-system
+the return value does not include the number of columns used for
+WINDOW's fringes or display margins either. */)
+ (Lisp_Object window, Lisp_Object horizontal)
{
- return decode_window (window)->buffer;
+ struct window *w = decode_any_window (window);
+
+ if (NILP (horizontal))
+ return make_number (window_body_lines (w));
+ else
+ return make_number (window_body_cols (w));
}
DEFUN ("window-height", Fwindow_height, Swindow_height, 0, 1, 0,
(let ((edges (window-edges))) (- (nth 2 edges) (nth 0 edges))). */)
(Lisp_Object window)
{
- return make_number (window_box_text_cols (decode_any_window (window)));
+ return make_number (window_body_cols (decode_any_window (window)));
}
DEFUN ("window-full-width-p", Fwindow_full_width_p, Swindow_full_width_p, 0, 1, 0,
}
+DEFUN ("window-list-1", Fwindow_list_1, Swindow_list_1, 0, 3, 0,
+ doc: /* Return a list of all live windows.
+WINDOW specifies the first window to list and defaults to the selected
+window.
+
+Optional argument MINIBUF nil or omitted means consider the minibuffer
+window only if the minibuffer is active. MINIBUF t means consider the
+minibuffer window even if the minibuffer is not active. Any other value
+means do not consider the minibuffer window even if the minibuffer is
+active.
+
+Optional argument ALL-FRAMES nil or omitted means consider all windows
+on WINDOW's frame, plus the minibuffer window if specified by the
+MINIBUF argument. If the minibuffer counts, consider all windows on all
+frames that share that minibuffer too. The following non-nil values of
+ALL-FRAMES have special meanings:
+
+- t means consider all windows on all existing frames.
+
+- `visible' means consider all windows on all visible frames.
+
+- 0 (the number zero) means consider all windows on all visible and
+ iconified frames.
+
+- A frame means consider all windows on that frame only.
+
+Anything else means consider all windows on WINDOW's frame and no
+others.
+
+If WINDOW is not on the list of windows returned, some other window will
+be listed first but no error is signalled. */)
+ (Lisp_Object window, Lisp_Object minibuf, Lisp_Object all_frames)
+{
+ return window_list_1 (window, minibuf, all_frames);
+}
+
+
DEFUN ("other-window", Fother_window, Sother_window, 1, 2, "p",
doc: /* Select another window in cyclic ordering of windows.
COUNT specifies the number of windows to skip, starting with the
}
-DEFUN ("window-list", Fwindow_list, Swindow_list, 0, 3, 0,
- doc: /* Return a list of windows on FRAME, starting with WINDOW.
-FRAME nil or omitted means use the selected frame.
-WINDOW nil or omitted means use the selected window.
-MINIBUF t means include the minibuffer window, even if it isn't active.
-MINIBUF nil or omitted means include the minibuffer window only
-if it's active.
-MINIBUF neither nil nor t means never include the minibuffer window. */)
- (Lisp_Object frame, Lisp_Object minibuf, Lisp_Object window)
-{
- if (NILP (window))
- window = FRAMEP (frame) ? XFRAME (frame)->selected_window : selected_window;
- CHECK_WINDOW (window);
- if (NILP (frame))
- frame = selected_frame;
-
- if (!EQ (frame, XWINDOW (window)->frame))
- error ("Window is on a different frame");
-
- return window_list_1 (window, minibuf, frame);
-}
-
-
/* Return a list of windows in cyclic ordering. Arguments are like
for `next-window'. */
}
+DEFUN ("window-list", Fwindow_list, Swindow_list, 0, 3, 0,
+ doc: /* Return a list of windows on FRAME, starting with WINDOW.
+FRAME nil or omitted means use the selected frame.
+WINDOW nil or omitted means use the selected window.
+MINIBUF t means include the minibuffer window, even if it isn't active.
+MINIBUF nil or omitted means include the minibuffer window only
+if it's active.
+MINIBUF neither nil nor t means never include the minibuffer window. */)
+ (Lisp_Object frame, Lisp_Object minibuf, Lisp_Object window)
+{
+ if (NILP (window))
+ window = FRAMEP (frame) ? XFRAME (frame)->selected_window : selected_window;
+ CHECK_WINDOW (window);
+ if (NILP (frame))
+ frame = selected_frame;
+
+ if (!EQ (frame, XWINDOW (window)->frame))
+ error ("Window is on a different frame");
+
+ return window_list_1 (window, minibuf, frame);
+}
+
+
\f
/* Look at all windows, performing an operation specified by TYPE
with argument OBJ.
Lisp_Object last_child;
int child_size;
- for (child = *forward; !NILP (child); child = c->next)
+ child = *forward;
+ do
{
c = XWINDOW (child);
last_child = child;
+ child = c->next;
}
+ while (!NILP (child));
child_size = WINDOW_TOTAL_SIZE (c, width_p);
size_window (last_child, size - old_size + child_size,
return Qnil;
}
-/* If select_window is called with inhibit_point_swap non-zero it will
- not store point of the old selected window's buffer back into that
- window's pointm slot. This is needed by Fset_window_configuration to
- avoid that the display routine is called with selected_window set to
- Qnil causing a subsequent crash. */
-
-static Lisp_Object
-select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
-{
- register struct window *w;
- register struct window *ow;
- struct frame *sf;
-
- CHECK_LIVE_WINDOW (window);
-
- w = XWINDOW (window);
- w->frozen_window_start_p = 0;
-
- if (NILP (norecord))
- {
- ++window_select_count;
- XSETFASTINT (w->use_time, window_select_count);
- record_buffer (w->buffer);
- }
-
- if (EQ (window, selected_window) && !inhibit_point_swap)
- return window;
-
- sf = SELECTED_FRAME ();
- if (XFRAME (WINDOW_FRAME (w)) != sf)
- {
- XFRAME (WINDOW_FRAME (w))->selected_window = window;
- /* Use this rather than Fhandle_switch_frame
- so that FRAME_FOCUS_FRAME is moved appropriately as we
- move around in the state where a minibuffer in a separate
- frame is active. */
- Fselect_frame (WINDOW_FRAME (w), norecord);
- /* Fselect_frame called us back so we've done all the work already. */
- eassert (EQ (window, selected_window));
- return window;
- }
- else
- sf->selected_window = window;
-
- /* Store the current buffer's actual point into the
- old selected window. It belongs to that window,
- and when the window is not selected, must be in the window. */
- if (!inhibit_point_swap)
- {
- ow = XWINDOW (selected_window);
- if (! NILP (ow->buffer))
- set_marker_both (ow->pointm, ow->buffer,
- BUF_PT (XBUFFER (ow->buffer)),
- BUF_PT_BYTE (XBUFFER (ow->buffer)));
- }
-
- selected_window = window;
-
- Fset_buffer (w->buffer);
-
- BVAR (XBUFFER (w->buffer), last_selected_window) = window;
-
- /* Go to the point recorded in the window.
- This is important when the buffer is in more
- than one window. It also matters when
- redisplay_window has altered point after scrolling,
- because it makes the change only in the window. */
- {
- register EMACS_INT new_point = marker_position (w->pointm);
- if (new_point < BEGV)
- SET_PT (BEGV);
- else if (new_point > ZV)
- SET_PT (ZV);
- else
- SET_PT (new_point);
- }
-
- windows_or_buffers_changed++;
- return window;
-}
-
-
-/* Note that selected_window can be nil when this is called from
- Fset_window_configuration. */
-
-DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
- doc: /* Select WINDOW. Most editing will apply to WINDOW's buffer.
-If WINDOW is not already selected, make WINDOW's buffer current
-and make WINDOW the frame's selected window. Return WINDOW.
-Optional second arg NORECORD non-nil means do not put this buffer
-at the front of the list of recently selected ones and do not
-make this window the most recently selected one.
-
-Note that the main editor command loop selects the buffer of the
-selected window before each command. */)
- (register Lisp_Object window, Lisp_Object norecord)
-{
- return select_window (window, norecord, 0);
-}
-
static Lisp_Object
select_window_norecord (Lisp_Object window)
{
return ht;
}
-
-
-/* Return the number of columns in W.
- Don't count columns occupied by scroll bars or the vertical bar
- separating W from the sibling to its right. */
-
-int
-window_box_text_cols (struct window *w)
-{
- struct frame *f = XFRAME (WINDOW_FRAME (w));
- int width = XINT (w->total_cols);
-
- if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
- /* Scroll bars occupy a few columns. */
- width -= WINDOW_CONFIG_SCROLL_BAR_COLS (w);
- else if (!FRAME_WINDOW_P (f)
- && !WINDOW_RIGHTMOST_P (w) && !WINDOW_FULL_WIDTH_P (w))
- /* The column of `|' characters separating side-by-side windows
- occupies one column only. */
- width -= 1;
-
- if (FRAME_WINDOW_P (f))
- /* On window-systems, fringes and display margins cannot be
- used for normal text. */
- width -= (WINDOW_FRINGE_COLS (w)
- + WINDOW_LEFT_MARGIN_COLS (w)
- + WINDOW_RIGHT_MARGIN_COLS (w));
-
- return width;
-}
-
\f
/************************************************************************
Window Scrolling
struct window *w = XWINDOW (selected_window);
if (NILP (arg))
- XSETFASTINT (arg, window_box_text_cols (w) - 2);
+ XSETFASTINT (arg, window_body_cols (w) - 2);
else
arg = Fprefix_numeric_value (arg);
struct window *w = XWINDOW (selected_window);
if (NILP (arg))
- XSETFASTINT (arg, window_box_text_cols (w) - 2);
+ XSETFASTINT (arg, window_body_cols (w) - 2);
else
arg = Fprefix_numeric_value (arg);
defsubr (&Swindow_minibuffer_p);
defsubr (&Swindowp);
defsubr (&Swindow_live_p);
+ defsubr (&Swindow_frame);
+ defsubr (&Sframe_root_window);
+ defsubr (&Sframe_first_window);
+ defsubr (&Sframe_selected_window);
+ defsubr (&Sset_frame_selected_window);
defsubr (&Spos_visible_in_window_p);
defsubr (&Swindow_line_height);
defsubr (&Swindow_buffer);
+ defsubr (&Swindow_parent);
+ defsubr (&Swindow_vchild);
+ defsubr (&Swindow_hchild);
+ defsubr (&Swindow_next);
+ defsubr (&Swindow_prev);
+ defsubr (&Swindow_use_time);
+ defsubr (&Swindow_top_line);
+ defsubr (&Swindow_left_column);
+ defsubr (&Swindow_total_size);
+ defsubr (&Swindow_body_size);
defsubr (&Swindow_height);
defsubr (&Swindow_width);
defsubr (&Swindow_full_width_p);
defsubr (&Sprevious_window);
defsubr (&Sother_window);
defsubr (&Sget_lru_window);
- defsubr (&Swindow_use_time);
defsubr (&Sget_largest_window);
defsubr (&Sget_buffer_window);
defsubr (&Sdelete_other_windows);
defsubr (&Sset_window_vscroll);
defsubr (&Scompare_window_configurations);
defsubr (&Swindow_list);
+ defsubr (&Swindow_list_1);
defsubr (&Swindow_parameters);
defsubr (&Swindow_parameter);
defsubr (&Sset_window_parameter);
-
}
void
HCoop / bpt / emacs.git / blobdiff