/* 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 Free Software Foundation, Inc.
+ 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
+the Free Software Foundation; either version 3, or (at your option)
any later version.
GNU Emacs is distributed in the hope that it will be useful,
static void window_scroll_pixel_based P_ ((Lisp_Object, int, int, int));
static void window_scroll_line_based P_ ((Lisp_Object, int, int, int));
static int window_min_size_1 P_ ((struct window *, int));
+static int window_min_size_2 P_ ((struct window *, int));
static int window_min_size P_ ((struct window *, int, int, int *));
static void size_window P_ ((Lisp_Object, int, int, int, int, int));
static int freeze_window_start P_ ((struct window *, void *));
}
DEFUN ("window-height", Fwindow_height, Swindow_height, 0, 1, 0,
- doc: /* Return the number of lines in WINDOW (including its mode line). */)
+ doc: /* Return the number of lines in WINDOW (including its mode line).
+WINDOW defaults to the selected window. */)
(window)
Lisp_Object window;
{
return make_number (window_box_text_cols (decode_any_window (window)));
}
+DEFUN ("window-full-width-p", Fwindow_full_width_p, Swindow_full_width_p, 0, 1, 0,
+ doc: /* Return t if WINDOW is as wide as its frame.
+WINDOW defaults to the selected window. */)
+ (window)
+ Lisp_Object window;
+{
+ return WINDOW_FULL_WIDTH_P (decode_any_window (window)) ? Qt : Qnil;
+}
+
DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
- doc: /* Return the number of columns by which WINDOW is scrolled from left margin. */)
+ doc: /* Return the number of columns by which WINDOW is scrolled from left margin.
+WINDOW defaults to the selected window. */)
(window)
Lisp_Object window;
{
DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
Swindow_redisplay_end_trigger, 0, 1, 0,
doc: /* Return WINDOW's redisplay end trigger value.
+WINDOW defaults to the selected window.
See `set-window-redisplay-end-trigger' for more information. */)
(window)
Lisp_Object window;
DEFUN ("window-point", Fwindow_point, Swindow_point, 0, 1, 0,
doc: /* Return current value of point in WINDOW.
+WINDOW defaults to the selected window.
+
For a nonselected window, this is the value point would have
if that window were selected.
DEFUN ("window-start", Fwindow_start, Swindow_start, 0, 1, 0,
doc: /* Return position at which display currently starts in WINDOW.
+WINDOW defaults to the selected window.
This is updated by redisplay or by calling `set-window-start'. */)
(window)
Lisp_Object window;
DEFUN ("window-end", Fwindow_end, Swindow_end, 0, 2, 0,
doc: /* Return position at which display currently ends in WINDOW.
+WINDOW defaults to the selected 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 (! NILP (update)
&& ! (! NILP (w->window_end_valid)
- && XFASTINT (w->last_modified) >= BUF_MODIFF (b))
+ && XFASTINT (w->last_modified) >= BUF_MODIFF (b)
+ && XFASTINT (w->last_overlay_modified) >= BUF_OVERLAY_MODIFF (b))
&& !noninteractive)
{
struct text_pos startp;
DEFUN ("window-display-table", Fwindow_display_table, Swindow_display_table,
0, 1, 0,
- doc: /* Return the display-table that WINDOW is using. */)
+ doc: /* Return the display-table that WINDOW is using.
+WINDOW defaults to the selected window. */)
(window)
Lisp_Object window;
{
if (!EQ (window, pwindow))
break;
/* Otherwise, try another window for SWINDOW. */
- swindow = Fnext_window (swindow, Qlambda, Qnil);;
+ swindow = Fnext_window (swindow, Qlambda, Qnil);
/* If we get back to the frame's selected window,
it means there was no acceptable alternative,
DEFUN ("get-lru-window", Fget_lru_window, Sget_lru_window, 0, 2, 0,
doc: /* Return the window least recently selected or used for display.
+\(LRU means Least Recently Used.)
+
Return a full-width window if possible.
A minibuffer window is never a candidate.
A dedicated window is never a candidate, unless DEDICATED is non-nil,
*cols = MIN_SAFE_WINDOW_WIDTH;
}
-
/* Value is non-zero if window W is fixed-size. WIDTH_P non-zero means
check if W's width can be changed, otherwise check W's height.
CHECK_SIBLINGS_P non-zero means check resizablity of WINDOW's
return fixed_p;
}
+/* Return the minimum size for leaf window W. WIDTH_P non-zero means
+ take into account fringes and the scrollbar of W. WIDTH_P zero means
+ take into account mode-line of W. Return 1 for the minibuffer. */
+
+static int
+window_min_size_2 (w, width_p)
+ struct window *w;
+ int width_p;
+{
+ int size;
+
+ if (width_p)
+ size = max (window_min_width,
+ (MIN_SAFE_WINDOW_WIDTH
+ + WINDOW_FRINGE_COLS (w)
+ + WINDOW_SCROLL_BAR_COLS (w)));
+ else if (MINI_WINDOW_P (w))
+ size = 1;
+ else
+ size = max (window_min_height,
+ (MIN_SAFE_WINDOW_HEIGHT
+ /* Don't count the header-line here. It would break
+ splitting a window with a header-line when the new
+ window shall have a height of two (calculator does
+ that). */
+ + (WINDOW_WANTS_MODELINE_P (w) ? 1 : 0)));
+
+ return size;
+}
/* Return the minimum size of window W, not taking fixed-width windows
into account. WIDTH_P non-zero means return the minimum width,
}
}
else
- {
- if (width_p)
- size = max (window_min_width,
- (MIN_SAFE_WINDOW_WIDTH
- + WINDOW_FRINGE_COLS (w)
- + WINDOW_SCROLL_BAR_COLS (w)));
- else
- {
- if (MINI_WINDOW_P (w)
- || (!WINDOW_WANTS_MODELINE_P (w)
- && !WINDOW_WANTS_HEADER_LINE_P (w)))
- size = 1;
- else
- size = window_min_height;
- }
- }
+ size = window_min_size_2 (w, width_p);
return size;
}
Lisp_Object child, *forward, *sideward;
int old_size, min_size, safe_min_size;
- /* We test nodelete_p != 2 and nodelete_p != 1 below, so it
- seems like it's too soon to do this here. ++KFS. */
- if (nodelete_p == 2)
- nodelete_p = 0;
-
check_min_window_sizes ();
size = max (0, size);
{
old_size = WINDOW_TOTAL_COLS (w);
min_size = window_min_width;
- /* Ensure that there is room for the scroll bar and fringes!
- We may reduce display margins though. */
- safe_min_size = (MIN_SAFE_WINDOW_WIDTH
- + WINDOW_FRINGE_COLS (w)
- + WINDOW_SCROLL_BAR_COLS (w));
+ safe_min_size = window_min_size_2 (w, 1);
}
else
{
old_size = XINT (w->total_lines);
min_size = window_min_height;
- safe_min_size = MIN_SAFE_WINDOW_HEIGHT;
+ safe_min_size = window_min_size_2 (w, 0);
}
if (old_size < min_size && nodelete_p != 2)
w->too_small_ok = Qt;
+ /* Move the following test here since otherwise the
+ preceding test doesn't make sense. martin. */
+ if (nodelete_p == 2)
+ nodelete_p = 0;
+
/* Maybe delete WINDOW if it's too small. */
if (nodelete_p != 1 && !NILP (w->parent))
{
struct window *w = XWINDOW (window);
struct buffer *b = XBUFFER (buffer);
int count = SPECPDL_INDEX ();
-#ifdef HAVE_WINDOW_SYSTEM
- struct frame *f = XFRAME (w->frame);
- Display_Info *dpyinfo;
-#endif
w->buffer = buffer;
call1 (Vrun_hooks, Qwindow_configuration_change_hook);
}
-#ifdef HAVE_WINDOW_SYSTEM
- BLOCK_INPUT;
- if (f && FRAME_X_OUTPUT (f)
- && (dpyinfo = FRAME_X_DISPLAY_INFO (f))
- && EQ (window, dpyinfo->mouse_face_window))
- clear_mouse_face (dpyinfo);
- UNBLOCK_INPUT;
-#endif
-
unbind_to (count, Qnil);
}
`same-window-regexps' customize how certain buffer names are handled.
The latter two take effect only if NOT-THIS-WINDOW is nil.
-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 a frame, search only that frame.
-If FRAME is nil, search only the selected frame
+If optional argument FRAME is `visible', check all visible frames
+for a window to use.
+If FRAME is 0, check all visible and iconified frames.
+If FRAME is t, check all frames.
+If FRAME is a frame, check only that frame.
+If FRAME is nil, check only the selected frame
(actually the last nonminibuffer frame),
unless `pop-up-frames' or `display-buffer-reuse-frames' is non-nil,
which means search visible and iconified frames.
frames = Qnil;
if (FRAME_MINIBUF_ONLY_P (f))
XSETFRAME (frames, last_nonminibuf_frame);
- /* Don't try to create a window if we would get an error. */
- if (split_height_threshold < window_min_height << 1)
- split_height_threshold = window_min_height << 1;
/* Note that both Fget_largest_window and Fget_lru_window
ignore minibuffers and dedicated windows.
else
window = Fget_largest_window (frames, Qt);
- /* If we got a tall enough full-width window that can be split,
- split it. */
+ /* If the largest window is tall enough, full-width, and either eligible
+ for splitting or the only window, split it. */
if (!NILP (window)
&& ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window)->frame))
- && window_height (window) >= split_height_threshold
- && WINDOW_FULL_WIDTH_P (XWINDOW (window)))
+ && WINDOW_FULL_WIDTH_P (XWINDOW (window))
+ && (window_height (window) >= split_height_threshold
+ || (NILP (XWINDOW (window)->parent)))
+ && (window_height (window)
+ >= (2 * window_min_size_2 (XWINDOW (window), 0))))
window = Fsplit_window (window, Qnil, Qnil);
else
{
Lisp_Object upper, lower, other;
window = Fget_lru_window (frames, Qt);
- /* If the LRU window is selected, and big enough,
- and can be split, split it. */
+ /* If the LRU window is tall enough, and either eligible for splitting
+ and selected or the only window, split it. */
if (!NILP (window)
&& ! FRAME_NO_SPLIT_P (XFRAME (XWINDOW (window)->frame))
- && (EQ (window, selected_window)
- || EQ (XWINDOW (window)->parent, Qnil))
- && window_height (window) >= window_min_height << 1)
+ && ((EQ (window, selected_window)
+ && window_height (window) >= split_height_threshold)
+ || (NILP (XWINDOW (window)->parent)))
+ && (window_height (window)
+ >= (2 * window_min_size_2 (XWINDOW (window), 0))))
window = Fsplit_window (window, Qnil, Qnil);
else
window = Fget_lru_window (frames, Qnil);
if (NILP (horflag))
{
- if (size_int < window_min_height)
+ int window_safe_height = window_min_size_2 (o, 0);
+
+ if (size_int < window_safe_height)
error ("Window height %d too small (after splitting)", size_int);
- if (size_int + window_min_height > XFASTINT (o->total_lines))
+ if (size_int + window_safe_height > XFASTINT (o->total_lines))
error ("Window height %d too small (after splitting)",
XFASTINT (o->total_lines) - size_int);
if (NILP (o->parent)
}
else
{
- if (size_int < window_min_width)
+ int window_safe_width = window_min_size_2 (o, 1);
+
+ if (size_int < window_safe_width)
error ("Window width %d too small (after splitting)", size_int);
-
- if (size_int + window_min_width > XFASTINT (o->total_cols))
+ if (size_int + window_safe_width > XFASTINT (o->total_cols))
error ("Window width %d too small (after splitting)",
XFASTINT (o->total_cols) - size_int);
if (NILP (o->parent)
DEFUN ("shrink-window", Fshrink_window, Sshrink_window, 1, 2, "p",
doc: /* Make current window ARG lines smaller.
From program, optional second arg non-nil means shrink sideways arg columns.
-Interactively, if an argument is not given, make the window one line smaller. Only
-siblings to the right or below are changed. */)
+Interactively, if an argument is not given, make the window one line smaller.
+Only siblings to the right or below are changed. */)
(arg, side)
Lisp_Object arg, side;
{
/* Don't make this window too small. */
if (XINT (CURSIZE (window)) + delta
- < (horiz_flag ? window_min_width : window_min_height))
+ < window_min_size_2 (XWINDOW (window), horiz_flag))
{
Fset_window_configuration (old_config);
error ("Cannot adjust window size as specified");
relative to the current 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 current window.
+If ARG is omitted or nil, erase the entire frame and then redraw with point
+in the center of the current window. If `auto-resize-tool-bars' is set to
+`grow-only', this resets the tool-bar's height to the minimum height needed.
+
Just C-u as prefix means put point in the center of the window
and redisplay normally--don't erase and redraw the frame. */)
(arg)
for (i = 0; i < n_compositions; i++)
composition_table[i]->font = NULL;
- Fredraw_frame (w->frame);
- SET_FRAME_GARBAGED (XFRAME (WINDOW_FRAME (w)));
+ WINDOW_XFRAME (w)->minimize_tool_bar_window_p = 1;
+
+ Fredraw_frame (WINDOW_FRAME (w));
+ SET_FRAME_GARBAGED (WINDOW_XFRAME (w));
center_p = 1;
}
else if (CONSP (arg)) /* Just C-u. */
DEFUN ("window-text-height", Fwindow_text_height, Swindow_text_height,
0, 1, 0,
doc: /* Return the height in lines of the text display area of WINDOW.
+WINDOW defaults to the selected window.
This doesn't include the mode-line (or header-line if any) or any
partial-height lines in the text display area. */)
(window)
Also restore the choice of selected window.
Also restore which buffer is current.
Does not restore the value of point in current buffer.
-usage: (save-window-excursion BODY ...) */)
+usage: (save-window-excursion BODY...) */)
(args)
Lisp_Object args;
{
vertical_type = Qnil;
}
- if (!(EQ (vertical_type, Qnil)
+ if (!(NILP (vertical_type)
|| EQ (vertical_type, Qleft)
|| EQ (vertical_type, Qright)
|| EQ (vertical_type, Qt)))
defsubr (&Swindow_buffer);
defsubr (&Swindow_height);
defsubr (&Swindow_width);
+ defsubr (&Swindow_full_width_p);
defsubr (&Swindow_hscroll);
defsubr (&Sset_window_hscroll);
defsubr (&Swindow_redisplay_end_trigger);