/* Window creation, deletion and examination for GNU Emacs.
Does not include redisplay.
Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1996, 1997, 1998, 2000,
- 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
#include <stdio.h>
+#include <setjmp.h>
#include "lisp.h"
#include "buffer.h"
Lisp_Object Qwindowp, Qwindow_live_p, Qwindow_configuration_p;
Lisp_Object Qdisplay_buffer;
-Lisp_Object Qscroll_up, Qscroll_down;
+Lisp_Object Qscroll_up, Qscroll_down, Qscroll_command;
Lisp_Object Qwindow_size_fixed;
extern Lisp_Object Qleft_margin, Qright_margin;
extern EMACS_INT scroll_margin;
extern Lisp_Object Qwindow_scroll_functions, Vwindow_scroll_functions;
+
+/* If non-nil, then the `recenter' command with a nil argument
+ the entire frame to be redrawn; the special value `tty' causes the
+ frame to be redrawn only if it is a tty frame. */
+
+static Lisp_Object Vrecenter_redisplay;
+extern Lisp_Object Qtty;
+
\f
DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
doc: /* Return t if OBJECT is a window. */)
DEFUN ("window-edges", Fwindow_edges, Swindow_edges, 0, 1, 0,
doc: /* Return a list of the edge coordinates of WINDOW.
-\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
-RIGHT is one more than the rightmost column occupied by WINDOW,
-and BOTTOM is one more than the bottommost row occupied by WINDOW.
-The edges include the space used by the window's scroll bar,
-display margins, fringes, header line, and mode line, if it has them.
-To get the edges of the actual text area, use `window-inside-edges'. */)
+The list has the form (LEFT TOP RIGHT BOTTOM).
+TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
+all relative to 0, 0 at top left corner of frame.
+
+RIGHT is one more than the rightmost column occupied by WINDOW.
+BOTTOM is one more than the bottommost row occupied by WINDOW.
+The edges include the space used by WINDOW's scroll bar, display
+margins, fringes, header line, and/or mode line. For the edges of
+just the text area, use `window-inside-edges'. */)
(window)
Lisp_Object window;
{
DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges, 0, 1, 0,
doc: /* Return a list of the edge pixel coordinates of WINDOW.
-\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
-RIGHT is one more than the rightmost x position occupied by WINDOW,
-and BOTTOM is one more than the bottommost y position occupied by WINDOW.
-The pixel edges include the space used by the window's scroll bar,
-display margins, fringes, header line, and mode line, if it has them.
-To get the edges of the actual text area, use `window-inside-pixel-edges'. */)
+The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
+the top left corner of the frame.
+
+RIGHT is one more than the rightmost x position occupied by WINDOW.
+BOTTOM is one more than the bottommost y position occupied by WINDOW.
+The pixel edges include the space used by WINDOW's scroll bar, display
+margins, fringes, header line, and/or mode line. For the pixel edges
+of just the text area, use `window-inside-pixel-edges'. */)
(window)
Lisp_Object window;
{
DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
doc: /* Return a list of the edge coordinates of WINDOW.
-\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
-RIGHT is one more than the rightmost column used by text in WINDOW,
-and BOTTOM is one more than the bottommost row used by text in WINDOW.
-The inside edges do not include the space used by the window's scroll bar,
-display margins, fringes, header line, and/or mode line. */)
+The list has the form (LEFT TOP RIGHT BOTTOM).
+TOP and BOTTOM count by lines, and LEFT and RIGHT count by columns,
+all relative to 0, 0 at top left corner of frame.
+
+RIGHT is one more than the rightmost column of WINDOW's text area.
+BOTTOM is one more than the bottommost row of WINDOW's text area.
+The inside edges do not include the space used by the WINDOW's scroll
+bar, display margins, fringes, header line, and/or mode line. */)
(window)
Lisp_Object window;
{
DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
doc: /* Return a list of the edge pixel coordinates of WINDOW.
-\(LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at top left corner of frame.
-RIGHT is one more than the rightmost x position used by text in WINDOW,
-and BOTTOM is one more than the bottommost y position used by text in WINDOW.
-The inside edges do not include the space used by the window's scroll bar,
+The list has the form (LEFT TOP RIGHT BOTTOM), all relative to 0, 0 at
+the top left corner of the frame.
+
+RIGHT is one more than the rightmost x position of WINDOW's text area.
+BOTTOM is one more than the bottommost y position of WINDOW's text area.
+The inside edges do not include the space used by WINDOW's scroll bar,
display margins, fringes, header line, and/or mode line. */)
(window)
Lisp_Object window;
}
else
{
- if (eabs (*x - x1) < grabbable_width)
+ /* Make sure we're not at the rightmost position of a
+ mode-/header-line and there's yet another window on
+ the right. (Bug#1372) */
+ if ((WINDOW_RIGHTMOST_P (w) || *x < x1)
+ && eabs (*x - x1) < grabbable_width)
{
/* Convert X and Y to window relative coordinates.
Vertical border is at the right edge of window. */
struct frame *f;
if (NILP (window))
window = selected_window;
+ else
+ CHECK_LIVE_WINDOW (window);
+
f = XFRAME (WINDOW_FRAME (XWINDOW (window)));
delete_window (window);
}
-/* Return the next or previous window of WINDOW in canonical ordering
+/* Return the next or previous window of WINDOW in cyclic ordering
of windows. NEXT_P non-zero means return the next window. See the
documentation string of next-window for the meaning of MINIBUF and
ALL_FRAMES. */
DEFUN ("next-window", Fnext_window, Snext_window, 0, 3, 0,
- doc: /* Return next window after WINDOW in canonical ordering of windows.
-If omitted, WINDOW defaults to the selected window.
+ doc: /* Return window following WINDOW in cyclic ordering of windows.
+WINDOW defaults to the selected window. The optional arguments
+MINIBUF and ALL-FRAMES specify the set of windows to consider.
-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
-minibuffer even if it is active.
+MINIBUF t means consider the minibuffer window even if the
+minibuffer is not active. MINIBUF nil or omitted means consider
+the minibuffer window only if the minibuffer is active. Any
+other value means do not consider the minibuffer window even if
+the minibuffer is active.
Several frames may share a single minibuffer; if the minibuffer
-counts, all windows on all frames that share that minibuffer count
-too. Therefore, `next-window' can be used to iterate through the
-set of windows even when the minibuffer is on another frame. If the
-minibuffer does not count, only windows from WINDOW's frame count.
-
-Optional third arg ALL-FRAMES t means include windows on all frames.
-ALL-FRAMES nil or omitted means cycle within the frames as specified
-above. ALL-FRAMES = `visible' means include windows on all visible frames.
-ALL-FRAMES = 0 means include windows on all visible and iconified frames.
-If ALL-FRAMES is a frame, restrict search to windows on that frame.
-Anything else means restrict to WINDOW's frame.
+is active, all windows on all frames that share that minibuffer
+are considered too. Therefore, if you are using a separate
+minibuffer frame and the minibuffer is active and MINIBUF says it
+counts, `next-window' considers the windows in the frame from
+which you entered the minibuffer, as well as the minibuffer
+window.
+
+ALL-FRAMES nil or omitted means consider all windows on WINDOW's
+ frame, plus the minibuffer window if specified by the MINIBUF
+ argument, see above. If the minibuffer counts, consider all
+ windows on all frames that share that minibuffer too.
+ALL-FRAMES t means consider all windows on all existing frames.
+ALL-FRAMES `visible' means consider all windows on all visible
+ frames.
+ALL-FRAMES 0 means consider all windows on all visible and
+ iconified frames.
+ALL-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 you use consistent values for MINIBUF and ALL-FRAMES, you can use
`next-window' to iterate through the entire cycle of acceptable
DEFUN ("previous-window", Fprevious_window, Sprevious_window, 0, 3, 0,
- doc: /* Return the window preceding 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
-minibuffer even if it is active.
-
-Several frames may share a single minibuffer; if the minibuffer
-counts, all windows on all frames that share that minibuffer count
-too. Therefore, `previous-window' can be used to iterate through
-the set of windows even when the minibuffer is on another frame. If
-the minibuffer does not count, only windows from WINDOW's frame count
-
-Optional third arg ALL-FRAMES t means include windows on all frames.
-ALL-FRAMES nil or omitted means cycle within the frames as specified
-above. ALL-FRAMES = `visible' means include windows on all visible frames.
-ALL-FRAMES = 0 means include windows on all visible and iconified frames.
-If ALL-FRAMES is a frame, restrict search to windows on that frame.
-Anything else means restrict to WINDOW's frame.
-
-If you use consistent values for MINIBUF and ALL-FRAMES, 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. */)
+ doc: /* Return window preceding WINDOW in cyclic ordering of windows.
+WINDOW defaults to the selected window. The optional arguments
+MINIBUF and ALL-FRAMES specify the set of windows to consider.
+For the precise meaning of these arguments see `next-window'.
+
+If you use consistent values for MINIBUF and ALL-FRAMES, 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)
Lisp_Object window, minibuf, all_frames;
{
DEFUN ("other-window", Fother_window, Sother_window, 1, 2, "p",
- doc: /* Select the ARG'th different window on this frame.
-All windows on current frame are arranged in a cyclic order.
-This command selects the window ARG steps away in that order.
-A negative ARG moves in the opposite order. The optional second
-argument ALL-FRAMES has the same meaning as in `next-window', which see. */)
- (arg, all_frames)
- Lisp_Object arg, all_frames;
+ doc: /* Select another window in cyclic ordering of windows.
+COUNT specifies the number of windows to skip, starting with the
+selected window, before making the selection. If COUNT is
+positive, skip COUNT windows forwards. If COUNT is negative,
+skip -COUNT windows backwards. COUNT zero means do not skip any
+window, so select the selected window. In an interactive call,
+COUNT is the numeric prefix argument. Return nil.
+
+This function uses `next-window' for finding the window to select.
+The argument ALL-FRAMES has the same meaning as in `next-window',
+but the MINIBUF argument of `next-window' is always effectively
+nil. */)
+ (count, all_frames)
+ Lisp_Object count, all_frames;
{
Lisp_Object window;
int i;
- CHECK_NUMBER (arg);
+ CHECK_NUMBER (count);
window = selected_window;
- for (i = XINT (arg); i > 0; --i)
+ for (i = XINT (count); i > 0; --i)
window = Fnext_window (window, Qnil, all_frames);
for (; i < 0; ++i)
window = Fprevious_window (window, Qnil, all_frames);
}
-/* Return a list of windows in canonical ordering. Arguments are like
+/* Return a list of windows in cyclic ordering. Arguments are like
for `next-window'. */
static Lisp_Object
windows = XCDR (windows);
/* Now we can safely delete the frame. */
- Fdelete_frame (w->frame, Qnil);
+ delete_frame (w->frame, Qnil);
}
else if (NILP (w->parent))
{
display there. */
Lisp_Object buffer;
buffer = Fother_buffer (obj, Qnil, w->frame);
+ /* Reset dedicated state of window. */
+ w->dedicated = Qnil;
Fset_window_buffer (window, buffer, Qnil);
if (EQ (window, selected_window))
Fset_buffer (w->buffer);
windows = XCDR (windows);
/* Now we can safely delete the frame. */
- Fdelete_frame (w->frame, Qnil);
+ delete_frame (w->frame, Qnil);
}
else if (!NILP (w->dedicated) && !NILP (w->parent))
{
}
static Lisp_Object select_window_norecord (Lisp_Object window);
+static Lisp_Object select_frame_norecord (Lisp_Object frame);
void
run_window_configuration_change_hook (struct frame *f)
if (SELECTED_FRAME () != f)
{
- record_unwind_protect (Fselect_frame, Fselected_frame ());
- Fselect_frame (frame);
+ record_unwind_protect (select_frame_norecord, Fselected_frame ());
+ Fselect_frame (frame, Qt);
}
/* Use the right buffer. Matters when running the local hooks. */
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.
+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. */)
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));
+ 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;
select_window_norecord (window)
Lisp_Object window;
{
- return Fselect_window (window, Qt);
+ return WINDOW_LIVE_P (window)
+ ? Fselect_window (window, Qt) : selected_window;
+}
+
+static Lisp_Object
+select_frame_norecord (frame)
+ Lisp_Object frame;
+{
+ return FRAME_LIVE_P (XFRAME (frame))
+ ? Fselect_frame (frame, Qt) : selected_frame;
}
\f
Lisp_Object
struct window *root;
xassert (MINI_WINDOW_P (w));
- xassert (delta >= 0);
+ /* Commenting out the following assertion goes against the stated interface
+ of the function, but it currently does not seem to do anything useful.
+ See discussion of this issue in the thread for bug#4534.
+ xassert (delta >= 0); */
/* Compute how much we can enlarge the mini-window without deleting
other windows. */
root = XWINDOW (FRAME_ROOT_WINDOW (f));
- if (delta)
+ if (delta > 0)
{
int min_height = window_min_size (root, 0, 0, 0, 0);
if (XFASTINT (root->total_lines) - delta < min_height)
if (!NILP (Vscroll_preserve_screen_position))
{
/* We preserve the goal pixel coordinate across consecutive
- calls to scroll-up or scroll-down. This avoids the
+ calls to scroll-up, scroll-down and other commands that
+ have the `scroll-command' property. This avoids the
possibility of point becoming "stuck" on a tall line when
scrolling by one line. */
if (window_scroll_pixel_based_preserve_y < 0
- || (!EQ (current_kboard->Vlast_command, Qscroll_up)
- && !EQ (current_kboard->Vlast_command, Qscroll_down)))
+ || !SYMBOLP (current_kboard->Vlast_command)
+ || NILP (Fget (current_kboard->Vlast_command, Qscroll_command)))
{
start_display (&it, w, start);
move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
if (!NILP (Vscroll_preserve_screen_position))
{
if (window_scroll_preserve_vpos <= 0
- || (!EQ (current_kboard->Vlast_command, Qscroll_up)
- && !EQ (current_kboard->Vlast_command, Qscroll_down)))
+ || !SYMBOLP (current_kboard->Vlast_command)
+ || NILP (Fget (current_kboard->Vlast_command, Qscroll_command)))
{
struct position posit
= *compute_motion (startpos, 0, 0, 0,
DEFUN ("recenter", Frecenter, Srecenter, 0, 1, "P",
- doc: /* Center point in selected window and redisplay frame.
+ doc: /* Center point in selected window and maybe redisplay frame.
With prefix argument ARG, recenter putting point on screen line ARG
relative to the selected window. If ARG is negative, it counts up from the
bottom of the window. (ARG should be less than the height of the window.)
-If ARG is omitted or nil, erase the entire frame and then redraw with point
-in the center of the selected window. If `auto-resize-tool-bars' is set to
-`grow-only', this resets the tool-bar's height to the minimum height needed.
+If ARG is omitted or nil, then recenter with point on the middle line of
+the selected window; if the variable `recenter-redisplay' is non-nil,
+also erase the entire frame and redraw it (when `auto-resize-tool-bars'
+is set to `grow-only', this resets the tool-bar's height to the minimum
+height needed); if `recenter-redisplay' has the special value `tty',
+then only tty frame are redrawn.
Just C-u as prefix means put point in the center of the window
and redisplay normally--don't erase and redraw the frame. */)
if (NILP (arg))
{
- int i;
+ if (!NILP (Vrecenter_redisplay)
+ && (!EQ (Vrecenter_redisplay, Qtty)
+ || !NILP (Ftty_type (selected_frame))))
+ {
+ int i;
- /* Invalidate pixel data calculated for all compositions. */
- for (i = 0; i < n_compositions; i++)
- composition_table[i]->font = NULL;
+ /* Invalidate pixel data calculated for all compositions. */
+ for (i = 0; i < n_compositions; i++)
+ composition_table[i]->font = NULL;
- WINDOW_XFRAME (w)->minimize_tool_bar_window_p = 1;
+ WINDOW_XFRAME (w)->minimize_tool_bar_window_p = 1;
+
+ Fredraw_frame (WINDOW_FRAME (w));
+ SET_FRAME_GARBAGED (WINDOW_XFRAME (w));
+ }
- Fredraw_frame (WINDOW_FRAME (w));
- SET_FRAME_GARBAGED (WINDOW_XFRAME (w));
center_p = 1;
}
else if (CONSP (arg)) /* Just C-u. */
doc: /* Return the height in lines of the text display area of WINDOW.
WINDOW defaults to the selected window.
-The return value does neither include the mode line or header line, if
-any, nor any partial-height lines in the text display area. */)
+The return value does not include the mode line, any header line, nor
+any partial-height lines in the text display area. */)
(window)
Lisp_Object window;
{
when the frame's old selected window has been deleted. */
if (f != selected_frame && FRAME_WINDOW_P (f))
do_switch_frame (WINDOW_FRAME (XWINDOW (data->root_window)),
- 0, 0);
+ 0, 0, Qnil);
#endif
/* Set the screen height to the value it had before this function. */
Fselect_window above totally superfluous; it still sets f's
selected window. */
if (FRAME_LIVE_P (XFRAME (data->selected_frame)))
- do_switch_frame (data->selected_frame, 0, 0);
+ do_switch_frame (data->selected_frame, 0, 0, Qnil);
run_window_configuration_change_hook (f);
}
int (* fn) P_ ((struct window *, void *));
void *user_data;
{
- /* Fdelete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
+ /* delete_frame may set FRAME_ROOT_WINDOW (f) to Qnil. */
if (WINDOWP (FRAME_ROOT_WINDOW (f)))
foreach_window_1 (XWINDOW (FRAME_ROOT_WINDOW (f)), fn, user_data);
}
void
syms_of_window ()
{
- Qscroll_up = intern ("scroll-up");
+ Qscroll_up = intern_c_string ("scroll-up");
staticpro (&Qscroll_up);
- Qscroll_down = intern ("scroll-down");
+ Qscroll_down = intern_c_string ("scroll-down");
staticpro (&Qscroll_down);
- Qwindow_size_fixed = intern ("window-size-fixed");
+ Qscroll_command = intern_c_string ("scroll-command");
+ staticpro (&Qscroll_command);
+
+ Fput (Qscroll_up, Qscroll_command, Qt);
+ Fput (Qscroll_down, Qscroll_command, Qt);
+
+ Qwindow_size_fixed = intern_c_string ("window-size-fixed");
staticpro (&Qwindow_size_fixed);
Fset (Qwindow_size_fixed, Qnil);
staticpro (&Qwindow_configuration_change_hook);
Qwindow_configuration_change_hook
- = intern ("window-configuration-change-hook");
+ = intern_c_string ("window-configuration-change-hook");
- Qwindowp = intern ("windowp");
+ Qwindowp = intern_c_string ("windowp");
staticpro (&Qwindowp);
- Qwindow_configuration_p = intern ("window-configuration-p");
+ Qwindow_configuration_p = intern_c_string ("window-configuration-p");
staticpro (&Qwindow_configuration_p);
- Qwindow_live_p = intern ("window-live-p");
+ Qwindow_live_p = intern_c_string ("window-live-p");
staticpro (&Qwindow_live_p);
- Qdisplay_buffer = intern ("display-buffer");
+ Qdisplay_buffer = intern_c_string ("display-buffer");
staticpro (&Qdisplay_buffer);
- Qtemp_buffer_show_hook = intern ("temp-buffer-show-hook");
+ Qtemp_buffer_show_hook = intern_c_string ("temp-buffer-show-hook");
staticpro (&Qtemp_buffer_show_hook);
staticpro (&Vwindow_list);
A value of t means point keeps its screen position if the scroll
command moved it vertically out of the window, e.g. when scrolling
by full screens.
-Any other value means point always keeps its screen position. */);
+Any other value means point always keeps its screen position.
+Scroll commands should have the `scroll-command' property
+on their symbols to be controlled by this variable. */);
Vscroll_preserve_screen_position = Qnil;
DEFVAR_LISP ("window-point-insertion-type", &Vwindow_point_insertion_type,
with the relevant frame selected. */);
Vwindow_configuration_change_hook = Qnil;
+ DEFVAR_LISP ("recenter-redisplay", &Vrecenter_redisplay,
+ doc: /* If non-nil, then the `recenter' command with a nil argument
+the entire frame to be redrawn; the special value `tty' causes the
+frame to be redrawn only if it is a tty frame. */);
+ Vrecenter_redisplay = Qtty;
+
+
defsubr (&Sselected_window);
defsubr (&Sminibuffer_window);
defsubr (&Swindow_minibuffer_p);
initial_define_key (control_x_map, '<', "scroll-left");
initial_define_key (control_x_map, '>', "scroll-right");
- initial_define_key (global_map, Ctl ('V'), "scroll-up");
+ initial_define_key (global_map, Ctl ('V'), "scroll-up-command");
initial_define_key (meta_map, Ctl ('V'), "scroll-other-window");
- initial_define_key (meta_map, 'v', "scroll-down");
-
- initial_define_key (global_map, Ctl('L'), "recenter");
- initial_define_key (meta_map, 'r', "move-to-window-line");
+ initial_define_key (meta_map, 'v', "scroll-down-command");
}
/* arch-tag: 90a9c576-0590-48f1-a5f1-6c96a0452d9f