/* Window creation, deletion and examination for GNU Emacs.
Does not include redisplay.
- Copyright (C) 1985-1987, 1993-1998, 2000-2015 Free Software
+ Copyright (C) 1985-1987, 1993-1998, 2000-2016 Free Software
Foundation, Inc.
This file is part of GNU Emacs.
#include <stdio.h>
#include "lisp.h"
-#include "character.h"
#include "buffer.h"
#include "keyboard.h"
#include "keymap.h"
-#include "menu.h"
#include "frame.h"
#include "window.h"
#include "commands.h"
#include "disptab.h"
#include "dispextern.h"
#include "blockinput.h"
-#include "intervals.h"
#include "termhooks.h" /* For FRAME_TERMINAL. */
+#include "xwidget.h"
#ifdef HAVE_WINDOW_SYSTEM
#include TERM_HEADER
#endif /* HAVE_WINDOW_SYSTEM */
w->horizontal = horflag;
}
+static void
+wset_update_mode_line (struct window *w)
+{
+ /* If this window is the selected window on its frame, set the
+ global variable update_mode_lines, so that x_consider_frame_title
+ will consider this frame's title for redisplay. */
+ Lisp_Object fselected_window = XFRAME (WINDOW_FRAME (w))->selected_window;
+
+ if (WINDOWP (fselected_window) && XWINDOW (fselected_window) == w)
+ update_mode_lines = 42;
+ else
+ w->update_mode_line = true;
+}
+
/* True if leaf window W doesn't reflect the actual state
of displayed buffer due to its text or overlays change. */
WINDOW must be a valid window used in horizontal or vertical combination.
If the return value is nil, child windows of WINDOW can be recombined with
WINDOW's siblings. A return value of t means that child windows of
-WINDOW are never \(re-)combined with WINDOW's siblings. */)
+WINDOW are never (re-)combined with WINDOW's siblings. */)
(Lisp_Object window)
{
struct window *w;
WINDOW must be a valid window used in horizontal or vertical combination.
If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
siblings. LIMIT t means that child windows of WINDOW are never
-\(re-)combined with WINDOW's siblings. Other values are reserved for
+(re-)combined with WINDOW's siblings. Other values are reserved for
future use. */)
(Lisp_Object window, Lisp_Object limit)
{
WINDOW must be a live window and defaults to the selected one.
COORDINATES is a cons of the form (X . Y), X and Y being distances
measured in characters from the upper-left corner of the frame.
-\(0 . 0) denotes the character in the upper left corner of the
+(0 . 0) denotes the character in the upper left corner of the
frame.
If COORDINATES are in the text portion of WINDOW,
the coordinates relative to the window are returned.
w->start_at_line_beg = false;
if (NILP (noforce))
w->force_start = true;
- w->update_mode_line = true;
+ wset_update_mode_line (w);
/* Bug#15957. */
w->window_end_valid = false;
wset_redisplay (w);
character is only partially visible, nil is returned, unless the
optional argument PARTIALLY is non-nil. If POS is only out of view
because of horizontal scrolling, return non-nil. If POS is t, it
-specifies the position of the last visible glyph in WINDOW. POS
-defaults to point in WINDOW; WINDOW defaults to the selected window.
+specifies either the first position displayed on the last visible
+screen line in WINDOW, or the end-of-buffer position, whichever comes
+first. POS defaults to point in WINDOW; WINDOW defaults to the
+selected window.
If POS is visible, return t if PARTIALLY is nil; if PARTIALLY is non-nil,
the return value is a list of 2 or 6 elements (X Y [RTOP RBOT ROWH VPOS]),
POS is fully visible; otherwise, RTOP and RBOT are the number of pixels
off-window at the top and bottom of the screen line ("row") containing
POS, ROWH is the visible height of that row, and VPOS is the row number
-\(zero-based). */)
+(zero-based). */)
(Lisp_Object pos, Lisp_Object window, Lisp_Object partially)
{
struct window *w;
/* Maybe we could move this into the `if' but it's not obviously safe and
I doubt it's worth the trouble. */
wset_redisplay (w);
- w->update_mode_line = true;
+
+ wset_update_mode_line (w);
/* We must select BUFFER to run the window-scroll-functions and to look up
the buffer-local value of Vwindow_point_insertion_type. */
/* old_size is the old size of the frame's root window. */
int old_size = horflag ? r->total_cols : r->total_lines;
int old_pixel_size = horflag ? r->pixel_width : r->pixel_height;
- int old_pixel_top = r->pixel_top;
/* new_size is the new size of the frame's root window. */
int new_size, new_pixel_size;
int unit = horflag ? FRAME_COLUMN_WIDTH (f) : FRAME_LINE_HEIGHT (f);
new_pixel_size = new_size * unit;
}
- r->top_line = FRAME_TOP_MARGIN (f);
- r->pixel_top = FRAME_TOP_MARGIN_HEIGHT (f);
-
if (new_pixel_size == old_pixel_size
- && r->pixel_top == old_pixel_top)
+ && (horflag || r->pixel_top == FRAME_TOP_MARGIN_HEIGHT (f)))
;
else if (WINDOW_LEAF_P (r))
/* For a leaf root window just set the size. */
}
else
{
+ r->top_line = FRAME_TOP_MARGIN (f);
+ r->pixel_top = FRAME_TOP_MARGIN_HEIGHT (f);
+
r->total_lines = new_size;
r->pixel_height = new_pixel_size;
}
{
Lisp_Object delta;
+ if (!horflag)
+ {
+ r->top_line = FRAME_TOP_MARGIN (f);
+ r->pixel_top = FRAME_TOP_MARGIN_HEIGHT (f);
+ }
+
if (pixelwise)
XSETINT (delta, new_pixel_size - old_pixel_size);
else
{
window_resize_apply (r, horflag);
window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
-#if false /* Let's try without safe sizes and/or killing other windows. */
- }
- else
- {
- /* Finally, try with "safe" minimum sizes. */
- resize_root_window (root, delta, horflag ? Qt : Qnil, Qsafe,
- pixelwise ? Qt : Qnil);
- if (window_resize_check (r, horflag)
- && new_pixel_size == XINT (r->new_pixel))
- {
- window_resize_apply (r, horflag);
- window_pixel_to_total (r->frame, horflag ? Qt : Qnil);
- }
- else
- {
- /* We lost. Delete all windows but the frame's
- selected one. */
- root = f->selected_window;
- Fdelete_other_windows_internal (root, Qnil);
- if (horflag)
- {
- XWINDOW (root)->total_cols = new_size;
- XWINDOW (root)->pixel_width = new_pixel_size;
- }
- else
- {
- XWINDOW (root)->total_lines = new_size;
- XWINDOW (root)->pixel_height = new_pixel_size;
- }
- }
-#endif /* false */
}
}
}
}
}
+ FRAME_WINDOW_SIZES_CHANGED (f) = true;
fset_redisplay (f);
}
/* Block input. */
block_input ();
+ xwidget_view_delete_all_in_window (w);
window_resize_apply (p, horflag);
/* If this window is referred to by the dpyinfo's mouse
highlight, invalidate that slot to be safe (Bug#9904). */
/* Enforce full redisplay of the frame. */
/* FIXME: Shouldn't window--resize-root-window-vertically do it? */
fset_redisplay (f);
+ FRAME_WINDOW_SIZES_CHANGED (f) = true;
adjust_frame_glyphs (f);
unblock_input ();
}
/* Enforce full redisplay of the frame. */
/* FIXME: Shouldn't window--resize-root-window-vertically do it? */
fset_redisplay (f);
+ FRAME_WINDOW_SIZES_CHANGED (f) = true;
adjust_frame_glyphs (f);
unblock_input ();
}
set_marker_restricted (w->start, make_number (spos),
w->contents);
w->start_at_line_beg = true;
- w->update_mode_line = true;
+ wset_update_mode_line (w);
/* Set force_start so that redisplay_window will run the
window-scroll-functions. */
w->force_start = true;
IT_BYTEPOS (it));
bytepos = marker_byte_position (w->start);
w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
- w->update_mode_line = true;
+ wset_update_mode_line (w);
/* Set force_start so that redisplay_window will run the
window-scroll-functions. */
w->force_start = true;
if (n > 0)
{
+ int last_y = it.last_visible_y - this_scroll_margin - 1;
+
/* We moved the window start towards ZV, so PT may be now
in the scroll margin at the top. */
move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
- if (IT_CHARPOS (it) == PT && it.current_y >= this_scroll_margin
+ if (IT_CHARPOS (it) == PT
+ && it.current_y >= this_scroll_margin
+ && it.current_y <= last_y - WINDOW_HEADER_LINE_HEIGHT (w)
&& (NILP (Vscroll_preserve_screen_position)
|| EQ (Vscroll_preserve_screen_position, Qt)))
/* We found PT at a legitimate height. Leave it alone. */
;
- else if (window_scroll_pixel_based_preserve_y >= 0)
- {
- /* If we have a header line, take account of it.
- This is necessary because we set it.current_y to 0, above. */
- move_it_to (&it, -1,
- window_scroll_pixel_based_preserve_x,
- (window_scroll_pixel_based_preserve_y
- - WINDOW_WANTS_HEADER_LINE_P (w)),
- -1, MOVE_TO_Y | MOVE_TO_X);
- SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
- }
else
{
+ if (window_scroll_pixel_based_preserve_y >= 0)
+ {
+ /* Don't enter the scroll margin at the end of the window. */
+ int goal_y = min (last_y, window_scroll_pixel_based_preserve_y);
+
+ /* If we have a header line, take account of it. This
+ is necessary because we set it.current_y to 0, above. */
+ move_it_to (&it, -1,
+ window_scroll_pixel_based_preserve_x,
+ goal_y - WINDOW_HEADER_LINE_HEIGHT (w),
+ -1, MOVE_TO_Y | MOVE_TO_X);
+ }
+
+ /* Get out of the scroll margin at the top of the window. */
while (it.current_y < this_scroll_margin)
{
int prev = it.current_y;
/* We moved the window start towards BEGV, so PT may be now
in the scroll margin at the bottom. */
move_it_to (&it, PT, -1,
- (it.last_visible_y - CURRENT_HEADER_LINE_HEIGHT (w)
+ (it.last_visible_y - WINDOW_HEADER_LINE_HEIGHT (w)
- this_scroll_margin - 1),
-1,
MOVE_TO_POS | MOVE_TO_Y);
;
else if (window_scroll_pixel_based_preserve_y >= 0)
{
+ int goal_y = min (it.last_visible_y - this_scroll_margin - 1,
+ window_scroll_pixel_based_preserve_y);
+
+ /* Don't let the preserved screen Y coordinate put us inside
+ any of the two margins. */
+ if (goal_y < this_scroll_margin)
+ goal_y = this_scroll_margin;
SET_TEXT_POS_FROM_MARKER (start, w->start);
start_display (&it, w, start);
/* It would be wrong to subtract CURRENT_HEADER_LINE_HEIGHT
here because we called start_display again and did not
alter it.current_y this time. */
move_it_to (&it, -1, window_scroll_pixel_based_preserve_x,
- window_scroll_pixel_based_preserve_y, -1,
- MOVE_TO_Y | MOVE_TO_X);
+ goal_y, -1, MOVE_TO_Y | MOVE_TO_X);
SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
}
else
set_marker_restricted_both (w->start, w->contents, pos, pos_byte);
w->start_at_line_beg = !NILP (bolp);
- w->update_mode_line = true;
+ wset_update_mode_line (w);
/* Set force_start so that redisplay_window will run
the window-scroll-functions. */
w->force_start = true;
if (!NILP (Vscroll_preserve_screen_position)
+ && this_scroll_margin == 0
&& (whole || !EQ (Vscroll_preserve_screen_position, Qt)))
{
SET_PT_BOTH (pos, pos_byte);
marker_byte_position (opoint_marker));
else if (!NILP (Vscroll_preserve_screen_position))
{
+ int nlines = window_scroll_preserve_vpos;
+
SET_PT_BOTH (pos, pos_byte);
- Fvertical_motion (original_pos, window, Qnil);
+ if (window_scroll_preserve_vpos < this_scroll_margin)
+ nlines = this_scroll_margin;
+ else if (window_scroll_preserve_vpos
+ >= w->total_lines - this_scroll_margin)
+ nlines = w->total_lines - this_scroll_margin - 1;
+ Fvertical_motion (Fcons (make_number (window_scroll_preserve_hpos),
+ make_number (nlines)), window, Qnil);
}
else
SET_PT (top_margin);
{
if (!NILP (Vscroll_preserve_screen_position))
{
+ int nlines = window_scroll_preserve_vpos;
+
SET_PT_BOTH (pos, pos_byte);
- Fvertical_motion (original_pos, window, Qnil);
+ if (window_scroll_preserve_vpos < this_scroll_margin)
+ nlines = this_scroll_margin;
+ else if (window_scroll_preserve_vpos
+ >= ht - this_scroll_margin)
+ nlines = ht - this_scroll_margin - 1;
+ Fvertical_motion (Fcons (make_number (window_scroll_preserve_hpos),
+ make_number (nlines)), window, Qnil);
}
else
Fvertical_motion (make_number (-1), window, Qnil);
eassert (w);
clear_glyph_matrix (w->current_matrix);
w->window_end_valid = false;
- windows_or_buffers_changed = 30;
wset_redisplay (w);
adjust_frame_glyphs (XFRAME (WINDOW_FRAME (w)));
}
If this variable is t, splitting a window tries to get the space
proportionally from all windows in the same combination. This also
-allows to split a window that is otherwise too small or of fixed size.
+allows splitting a window that is otherwise too small or of fixed size.
Resizing and deleting a window proportionally resize all windows in the
same combination.