procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Major rewrite of adjust_frame_size

Browse source 
Have adjust_frame_size pass native frame sizes to backends
instead of text sizes.  Expand frame size history management.
Drop PIXELWISE argument from change_frame_size and convert
native to text sizes only when calling adjust_frame_size.  Use
convention in arguments that -1 instead of 0 means that no size
change is required.  When adjusting frame sizes pick up delayed
size changes (Bug#46827).

* lisp/frame.el (frame-notice-user-settings, make-frame): Don't
set frame size history.
(frame--size-history): Rewrite doc-string.  Handle new formats
of `frame-size-history' entries.
* src/dispextern.h (delayed_size_change): Extern it.
(change_frame_size): Drop last argument from extern.
* src/dispnew.c (delayed_size_change): Make it global.
(handle_window_change_signal): Reformat.  Drop last argument
from change_frame_size call.
(do_pending_window_change, init_display_interactive): Drop last
argument from change_frame_size call.
(change_frame_size_1): NEW_WIDTH and NEW_HEIGHT now specify
native sizes.  Drop last argument PIXELWISE.  Queue a change
when it either differs from F's current pixel sizes or F's
previously queued sizes.  Inject frame_size_history_extra call
when queuing.  Adopt convention that for queued sizes -1 means
that no size change is required.  Convert from native to text
sizes when calling adjust_frame_size.
(change_frame_size): Drop last argument PIXELWISE and drop it
also in change_frame_size_1 calls.
* src/frame.c (frame_size_history_add): Remove.
(frame_inhibit_resize): Remove call to frame_size_history_add.
(set_menu_bar_lines, set_tab_bar_lines): Simplify.  Drop last
argument from change_frame_size call.
(frame_windows_min_size): No more static.
(keep_ratio): Minor rewrite using macros.
(frame_size_history_adjust, frame_size_history_plain)
(frame_size_history_extra): New functions.
(adjust_frame_size): Major rewrite.  Adopt new convention that
negative values for new sizes mean no change.  Pick up delayed
size changes from F's new_width and new_height slots
(Bug#46827).  Call set_window_size_hook with native instead of
text sizes.  Do not sanitize window sizes any more.  Call
frame_size_history_adjust instead of frame_size_history_add.
Always set F's resized_p slot to true.
(make_frame): Initialize new_width and new_height slots to -1.
Simplify setup of initial sizes and an adjust_frame_size call.
(Fframe_parameters): Drop processing F's new_pixelwise slot.
(check_frame_pixels): Reorder to make declarations appear first.
(Fset_frame_height, Fset_frame_width, Fset_frame_size): Pass
explicit width and height values to adjust_frame_size instead of
-1.
(gui_set_frame_parameters): Minor rewrite making sure that
explicit sizes and the corresponding parameter are passed to
adjust_frame_size.  Remove frame_size_history_add call.
(gui_figure_window_size): Drop last two arguments.  Simplify
assignment of initial size.  Set new_height and new_width slots
to -1.  Use adjust_frame_size to set sizes instead of returning
them to caller.
(syms_of_frame): Drop symbols used by frame size history; these
are now built on-the-fly.  Also drop some menu bar related
symbols in favor of Qmenu_bar_lines.
* src/frame.h (struct frame): Remove new_pixelwise.
(SET_FRAME_COLS, SET_FRAME_LINES, SET_FRAME_WIDTH)
(SET_FRAME_HEIGHT): Remove macros.
(frame_size_history_add): Remove externs.
(frame_windows_min_size, frame_size_history_plain)
(frame_size_history_extra): Add externs.
(FRAME_WINDOWS_WIDTH, FRAME_WINDOWS_HEIGHT): Rename to
FRAME_INNER_WIDTH and FRAME_INNER_HEIGHT.
(gui_figure_window_size): Drop last two arguments from
extern.
* src/gtkutil.c (xg_frame_resized): Rename arguments to WIDTH
and HEIGHT.  Consult delayed_size_change to handle case where
WIDTH and HEIGHT do not match F's new_width and new_height
values.  Call change_frame_size with native sizes and without
PIXELWISE argument.  Instead of frame_size_history_add call
frame_size_history_extra.
(xg_frame_set_char_size): WIDTH and HEIGHT are native sizes now;
fix adjust_frame_size call accordingly.  Instead of
frame_size_history_add call frame_size_history_extra.
(style_changed_cb): Call xg_frame_set_char_size with native
instead of text sizes.
(tb_size_cb): Remove frame_size_history_add call.  Call
adjust_frame_size with INHIBIT 5.
(free_frame_tool_bar, xg_change_toolbar_position): Remove
frame_size_history_add call.
(update_frame_tool_bar): Call adjust_frame_size with INHIBIT 2
and let it handle frame_inhibit_implied_resize and
fullheight/-width.  Remove frame_size_history_add call.
* src/keyboard.c (Fsuspend_emacs): Call change_frame_size with
native sizes.
* src/nsfns.m (ns_set_tool_bar_lines): Call adjust_frame_size
with INHIBIT 2 and let it handle frame_inhibit_implied_resize
and fullheight/-width.  Remove frame_size_history_add call.
(Fx_create_frame): Drop two last arguments in
gui_figure_window_size call.  Do not SET_FRAME_WIDTH and
SET_FRAME_HEIGHT, the adjust_frame_size in
gui_figure_window_size did that already.
* src/nsterm.m (ns_set_window_size): Drop PIXELWISE argument and
its processing; WIDTH and HEIGHT represent native pixel sizes
now.  Call change_frame_size with native sizes.  Remove call to
frame_size_history_add.
([EmacsView viewDidResize:]): Call change_frame_size with native
sizes.
* src/term.c (Fresume_tty): Call change_frame_size with native
sizes.
* src/termhooks.h (*set_window_size_hook): Drop last argument
PIXELWISE.
* src/w32fns.c (w32_change_tab_bar_height)
(w32_change_tool_bar_height): Fix handling of these in the initial
phase before they have been resized at least once.
(Fx_create_frame, w32_create_tip_frame): Drop two last arguments
in gui_figure_window_size call.  Do not SET_FRAME_WIDTH and
SET_FRAME_HEIGHT (or SET_FRAME_COLS and SET_FRAME_LINES), the
adjust_frame_size in gui_figure_window_size did that already.
* src/w32inevt.c (resize_event, maybe_generate_resize_event):
Pass native sizes to change_frame_size.
* src/w32term.c (w32_read_socket): When WM_WINDOWPOSCHANGED pass
native sizes to change_frame_size.
(w32_new_font): Recalculate FRAME_TAB_BAR_HEIGHT.  Simplify
code.
(w32fullscreen_hook): Call change_frame_size with native sizes.
(w32_set_window_size): Drop argument PIXELWISE and its
processing; WIDTH and HEIGHT are native sizes now.  Remove
frame_size_history_add calls.  Pass native sizes to
change_frame_size.
* src/widget.c (set_frame_size): Set width and height of widget
directly.  Call frame_size_history_plain instead of
frame_size_history_add.
(update_from_various_frame_slots): Call
frame_size_history_extra.
(EmacsFrameRealize): Call frame_size_history_plain.
(EmacsFrameResize): Call change_frame_size with native sizes.
Call frame_size_history_extra instead of frame_size_history_add.
(EmacsFrameSetCharSize): Call frame_size_history_extra.  Drop
PIXELWISE argument in x_set_window_size call and specify pixels.
(pixel_to_text_size): Remove function.
* src/xdisp.c (resize_mini_window): Replace FRAME_WINDOWS_HEIGHT
with FRAME_INNER_HEIGHT.
(redisplay_tab_bar): Don't set tab_bar_redisplayed when we did
not redisplay it.
(redisplay_tool_bar): Don't call it for external tool bar.
Don't set tool_bar_redisplayed when we did not redisplay it.
(redisplay_window): When the tool bar is external call
update_frame_tool_bar directly.
* src/xfns.c (x_set_menu_bar_lines): Call adjust_frame_size only
if number of menu bar lines changed and fix 6th argument.
(x_change_tab_bar_height, x_change_tool_bar_height): Fix
handling of these in the initial phase before they have been
resized at least once.
(Fx_create_frame, x_create_tip_frame): Drop two last arguments
in gui_figure_window_size call.  Do not SET_FRAME_WIDTH and
SET_FRAME_HEIGHT (or SET_FRAME_COLS and SET_FRAME_LINES), the
adjust_frame_size in gui_figure_window_size did that already.
* src/xmenu.c (update_frame_menubar): Fix 6th arg of
adjust_frame_size call.
(free_frame_menubar): For Motif frames fix fullscreen and
`frame-inhibit-implied-resize' handling.  Fix 6th arg of
adjust_frame_size calls.
* src/xterm.c (x_net_wm_state): Remove call to
frame_size_history_add.
(handle_one_xevent): For PropertyNotify and UnmapNotify events
add frame_size_history_plain calls.  For MapNotify and
ConfigureNotify events add a frame_size_history_extra call.  For
ConfigureNotify events also handle delayed size changes and call
change_frame_size with native sizes.
(x_new_font): Recalculate FRAME_TAB_BAR_HEIGHT.  Simplify code.
(x_handle_net_wm_state): Remove frame_size_history_add call.
(x_check_fullscreen): Remove frame_size_history_add call.  Call
change_frame_size with native height.
(x_set_window_size_1): WIDTH and HEIGHT are now native.  Remove
some frame_size_history_add calls and add frame_size_history_extra
calls instead.  If the frame is not visible call adjust_frame_size
directly instead of calling change_frame_size.
(x_set_window_size): Drop PIXELWISE argument.  WIDTH and HEIGHT
represent native sizes now.
(x_make_frame_visible, x_make_frame_invisible): Call
frame_size_history_plain.
* src/xterm.h (x_set_window_size): Drop last argument from
extern declaration.
This commit is contained in:
Martin Rudalics 2021-04-27 09:53:42 +02:00
parent 40a1e94f4c
commit a190b4cfd8
20 changed files with 988 additions and 1215 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

121
lisp/frame.el
View file

@ -615,15 +615,6 @@ there (in decreasing order of priority)."
(face-set-after-frame-default frame-initial-frame)
(setq newparms (delq new-bg newparms)))
(when (numberp (car frame-size-history))
(setq frame-size-history
(cons (1- (car frame-size-history))
(cons
(list frame-initial-frame
"FRAME-NOTICE-USER"
nil newparms)
(cdr frame-size-history)))))
(modify-frame-parameters frame-initial-frame newparms)))))
;; Restore the original buffer.
@ -926,12 +917,6 @@ the new frame according to its own rules."
(let ((val (frame-parameter oldframe param)))
(when val (set-frame-parameter frame param val)))))
(when (numberp (car frame-size-history))
(setq frame-size-history
(cons (1- (car frame-size-history))
(cons (list frame "MAKE-FRAME")
(cdr frame-size-history)))))
;; We can run `window-configuration-change-hook' for this frame now.
(frame-after-make-frame frame t)
(run-hook-with-args 'after-make-frame-functions frame)
@ -1695,26 +1680,104 @@ and width values are in pixels.
(defun frame--size-history (&optional frame)
"Print history of resize operations for FRAME.
Print prettified version of `frame-size-history' into a buffer
called *frame-size-history*. Optional argument FRAME denotes the
frame whose history will be printed. FRAME defaults to the
selected frame."
This function dumps a prettified version of `frame-size-history'
into a buffer called *frame-size-history*. The optional argument
FRAME denotes the frame whose history will be dumped; it defaults
to the selected frame.
Storing information about resize operations is off by default.
If you set the variable `frame-size-history' like this
(setq frame-size-history '(100))
then Emacs will save information about the next 100 significant
operations affecting any frame's size in that variable. This
function prints the entries for FRAME stored in that variable in
a more legible way.
All lines start with an indication of the requested action. An
entry like `menu-bar-lines' or `scroll-bar-width' indicates that
a change of the corresponding frame parameter or Lisp variable
was requested. An entry like gui_figure_window_size indicates
that that C function was executed, an entry like ConfigureNotify
indicates that that event was received.
In long entries, a number in parentheses displays the INHIBIT
parameter passed to the C function adjust_frame_size. Such
entries may also display changes of frame rectangles in a form
like R=n1xn2~>n3xn4 where R denotes the rectangle type (TS for
text, NS for native and IS for inner frame rectangle sizes, all
in pixels, TC for text rectangle sizes in frame columns and
lines), n1 and n2 denote the old width and height and n3 and n4
the new width and height in the according units. MS stands for
the minimum inner frame size in pixels, IH and IV, if present,
indicate that resizing horizontally and/or vertically was
inhibited (either by `frame-inhibit-implied-resize' or because of
the frame's fullscreen state).
Shorter entries represent C functions that process width and
height changes of the native rectangle where PS stands for the
frame's present pixel width and height, XS for a requested pixel
width and height and DS for some earlier requested but so far
delayed pixel width and height.
Very short entries represent calls of C functions that do not
directly ask for size changes but may indirectly affect the size
of frames like calls to map a frame or change its visibility."
(let ((history (reverse frame-size-history))
entry)
entry item)
(setq frame (window-normalize-frame frame))
(with-current-buffer (get-buffer-create "*frame-size-history*")
(erase-buffer)
(insert (format "Frame size history of %s\n" frame))
(while (consp (setq entry (pop history)))
(when (eq (car entry) frame)
(pop entry)
(insert (format "%s" (pop entry)))
(move-to-column 24 t)
(while entry
(insert (format " %s" (pop entry))))
(insert "\n")))
(unless frame-size-history
(insert "Frame size history is nil.\n")))))
(setq item (car entry))
(cond
((not (consp item))
;; An item added quickly for debugging purposes.
(insert (format "%s\n" entry)))
((and (eq (nth 0 item) frame) (= (nth 1 item) 1))
;; Length 1 is a "plain event".
(insert (format "%s\n" (nth 2 item))))
((and (eq (nth 0 item) frame) (= (nth 1 item) 2))
;; Length 2 is an "extra" item.
(insert (format "%s" (nth 2 item)))
(setq item (nth 0 (cdr entry)))
(insert (format ", PS=%sx%s" (nth 0 item) (nth 1 item)))
(when (or (>= (nth 2 item) 0) (>= (nth 3 item) 0))
(insert (format ", XS=%sx%s" (nth 2 item) (nth 3 item))))
(setq item (nth 1 (cdr entry)))
(when (or (>= (nth 0 item) 0) (>= (nth 1 item) 0))
(insert (format ", DS=%sx%s" (nth 0 item) (nth 1 item))))
(insert "\n"))
((and (eq (nth 0 item) frame) (= (nth 1 item) 5))
;; Length 5 is an `adjust-frame-size' item.
(insert (format "%s (%s)" (nth 3 item) (nth 2 item)))
(setq item (nth 0 (cdr entry)))
(unless (and (= (nth 0 item) (nth 2 item))
(= (nth 1 item) (nth 3 item)))
(insert (format ", TS=%sx%s~>%sx%s"
(nth 0 item) (nth 1 item) (nth 2 item) (nth 3 item))))
(setq item (nth 1 (cdr entry)))
(unless (and (= (nth 0 item) (nth 2 item))
(= (nth 1 item) (nth 3 item)))
(insert (format ", TC=%sx%s~>%sx%s"
(nth 0 item) (nth 1 item) (nth 2 item) (nth 3 item))))
(setq item (nth 2 (cdr entry)))
(unless (and (= (nth 0 item) (nth 2 item))
(= (nth 1 item) (nth 3 item)))
(insert (format ", NS=%sx%s~>%sx%s"
(nth 0 item) (nth 1 item) (nth 2 item) (nth 3 item))))
(setq item (nth 3 (cdr entry)))
(unless (and (= (nth 0 item) (nth 2 item))
(= (nth 1 item) (nth 3 item)))
(insert (format ", IS=%sx%s~>%sx%s"
(nth 0 item) (nth 1 item) (nth 2 item) (nth 3 item))))
(setq item (nth 4 (cdr entry)))
(insert (format ", MS=%sx%s" (nth 0 item) (nth 1 item)))
(when (nth 2 item) (insert " IH"))
(when (nth 3 item) (insert " IV"))
(insert "\n")))))))
(declare-function x-frame-edges "xfns.c" (&optional frame type))
(declare-function w32-frame-edges "w32fns.c" (&optional frame type))

4
src/dispextern.h
View file

@ -1262,7 +1262,7 @@ extern struct glyph space_glyph;
/* True means last display completed. False means it was preempted. */
extern bool display_completed;
extern bool delayed_size_change;
/************************************************************************
@ -3641,7 +3641,7 @@ extern void gui_update_window_begin (struct window *);
extern void gui_update_window_end (struct window *, bool, bool);
#endif
void do_pending_window_change (bool);
void change_frame_size (struct frame *, int, int, bool, bool, bool, bool);
void change_frame_size (struct frame *, int, int, bool, bool, bool);
void init_display (void);
void syms_of_display (void);
extern void spec_glyph_lookup_face (struct window *, GLYPH *);

120
src/dispnew.c
View file

@ -102,7 +102,7 @@ bool display_completed;
/* True means SIGWINCH happened when not safe. */
static bool delayed_size_change;
bool delayed_size_change;
/* A glyph for a space. */
@ -5770,32 +5770,34 @@ handle_window_change_signal (int sig)
termcap-controlled terminal, but we can't decide which.
Therefore, we resize the frames corresponding to each tty.
*/
for (tty = tty_list; tty; tty = tty->next) {
for (tty = tty_list; tty; tty = tty->next)
{
if (! tty->term_initted)
continue;
if (! tty->term_initted)
continue;
/* Suspended tty frames have tty->input == NULL avoid trying to
use it. */
if (!tty->input)
continue;
/* Suspended tty frames have tty->input == NULL avoid trying to
use it. */
if (!tty->input)
continue;
get_tty_size (fileno (tty->input), &width, &height);
get_tty_size (fileno (tty->input), &width, &height);
if (width > 5 && height > 2)
{
Lisp_Object tail, frame;
if (width > 5 && height > 2) {
Lisp_Object tail, frame;
FOR_EACH_FRAME (tail, frame)
{
struct frame *f = XFRAME (frame);
FOR_EACH_FRAME (tail, frame)
if (FRAME_TERMCAP_P (XFRAME (frame)) && FRAME_TTY (XFRAME (frame)) == tty)
/* Record the new sizes, but don't reallocate the data
structures now. Let that be done later outside of the
signal handler. */
change_frame_size (XFRAME (frame), width,
height - FRAME_MENU_BAR_LINES (XFRAME (frame))
- FRAME_TAB_BAR_LINES (XFRAME (frame)),
0, 1, 0, 0);
if (FRAME_TERMCAP_P (f) && FRAME_TTY (f) == tty)
/* Record the new sizes, but don't reallocate the data
structures now. Let that be done later outside of the
signal handler. */
change_frame_size (f, width, height, false, true, false);
}
}
}
}
}
static void
@ -5821,15 +5823,17 @@ do_pending_window_change (bool safe)
{
Lisp_Object tail, frame;
delayed_size_change = 0;
delayed_size_change = false;
FOR_EACH_FRAME (tail, frame)
{
struct frame *f = XFRAME (frame);
if (f->new_height != 0 || f->new_width != 0)
/* Negative new_width or new_height values mean no change is
required (a native size can never drop below zero). */
if (f->new_height >= 0 || f->new_width >= 0)
change_frame_size (f, f->new_width, f->new_height,
0, 0, safe, f->new_pixelwise);
false, false, safe);
}
}
}
@ -5837,47 +5841,43 @@ do_pending_window_change (bool safe)
static void
change_frame_size_1 (struct frame *f, int new_width, int new_height,
bool pretend, bool delay, bool safe, bool pixelwise)
bool pretend, bool delay, bool safe)
{
/* If we can't deal with the change now, queue it for later. */
if (delay || (redisplaying_p && !safe))
{
if (CONSP (frame_size_history)
&& ((new_width != f->new_width
|| new_height != f->new_height
|| new_width != FRAME_PIXEL_WIDTH (f)
|| new_height != FRAME_PIXEL_HEIGHT (f))))
frame_size_history_extra
(f, build_string ("change_frame_size_1, delayed"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
new_width, new_height, f->new_width, f->new_height);
/* We can't deal with the change now, queue it for later. */
f->new_width = new_width;
f->new_height = new_height;
f->new_pixelwise = pixelwise;
delayed_size_change = 1;
delayed_size_change = true;
}
else
{
/* This size-change overrides any pending one for this frame. */
f->new_height = 0;
f->new_width = 0;
f->new_pixelwise = 0;
/* If an argument is zero, set it to the current value. */
if (pixelwise)
{
new_width = (new_width <= 0) ? FRAME_TEXT_WIDTH (f) : new_width;
new_height = (new_height <= 0) ? FRAME_TEXT_HEIGHT (f) : new_height;
}
else
{
new_width = (((new_width <= 0) ? FRAME_COLS (f) : new_width)
* FRAME_COLUMN_WIDTH (f));
new_height = (((new_height <= 0) ? FRAME_LINES (f) : new_height)
* FRAME_LINE_HEIGHT (f));
}
/* Adjust frame size but make sure set_window_size_hook does not
get called. */
adjust_frame_size (f, new_width, new_height, 5, pretend,
Qchange_frame_size);
/* Storing -1 in the new_width/new_height slots means that no size
change is pending. Native sizes are always non-negative. */
f->new_height = -1;
f->new_width = -1;
/* adjust_frame_size wants its arguments in terms of text_width
and text_height, so convert them here. For pathologically
small frames, the resulting values may be negative though. */
adjust_frame_size (f, FRAME_PIXEL_TO_TEXT_WIDTH (f, new_width),
FRAME_PIXEL_TO_TEXT_HEIGHT (f, new_height), 5,
pretend, Qchange_frame_size);
}
}
/* Change text height/width of frame F. Values may be given as zero to
indicate that no change is needed.
/* Change native height/width of frame F to NEW_WIDTH/NEW_HEIGHT pixels.
Values may be given as -1 to indicate that no change is needed.
If DELAY, assume we're being called from a signal handler, and queue
the change for later - perhaps the next redisplay. Since this tries
@ -5887,7 +5887,7 @@ change_frame_size_1 (struct frame *f, int new_width, int new_height,
change frame sizes while a redisplay is in progress. */
void
change_frame_size (struct frame *f, int new_width, int new_height,
bool pretend, bool delay, bool safe, bool pixelwise)
bool pretend, bool delay, bool safe)
{
Lisp_Object tail, frame;
@ -5897,13 +5897,12 @@ change_frame_size (struct frame *f, int new_width, int new_height,
size affects all frames. Termcap now supports multiple
ttys. */
FOR_EACH_FRAME (tail, frame)
if (! FRAME_WINDOW_P (XFRAME (frame)))
if (!FRAME_WINDOW_P (XFRAME (frame)))
change_frame_size_1 (XFRAME (frame), new_width, new_height,
pretend, delay, safe, pixelwise);
pretend, delay, safe);
}
else
change_frame_size_1 (f, new_width, new_height, pretend, delay, safe,
pixelwise);
change_frame_size_1 (f, new_width, new_height, pretend, delay, safe);
}
/***********************************************************************
@ -6492,9 +6491,8 @@ init_display_interactive (void)
t->display_info.tty->top_frame = selected_frame;
change_frame_size (XFRAME (selected_frame),
FrameCols (t->display_info.tty),
FrameRows (t->display_info.tty)
- FRAME_MENU_BAR_LINES (f)
- FRAME_TAB_BAR_LINES (f), 0, 0, 1, 0);
FrameRows (t->display_info.tty),
false, false, true);
/* Delete the initial terminal. */
if (--initial_terminal->reference_count == 0

730
src/frame.c
View file

File diff suppressed because it is too large Load diff

213
src/frame.h
View file

@ -256,8 +256,8 @@ struct frame
be used for output. */
bool_bf glyphs_initialized_p : 1;
/* Set to true in change_frame_size when size of frame changed
Clear the frame in clear_garbaged_frames if set. */
/* Set to true in adjust_frame_size when one of the frame's sizes
changed. Clear the frame in clear_garbaged_frames if set. */
bool_bf resized_p : 1;
/* Set to true if the default face for the frame has been
@ -415,10 +415,6 @@ struct frame
bool_bf no_special_glyphs : 1;
#endif /* HAVE_WINDOW_SYSTEM */
/* Whether new_height and new_width shall be interpreted
in pixels. */
bool_bf new_pixelwise : 1;
/* True means set_window_size_hook requests can be processed for
this frame. */
bool_bf can_set_window_size : 1;
@ -426,11 +422,23 @@ struct frame
/* Set to true after this frame was made by `make-frame'. */
bool_bf after_make_frame : 1;
/* Whether the tab bar height change should be taken into account. */
/* Two sticky flags, that are both false when a frame is created.
'display_tab_bar' sets the former to true the first time it
displays the tab bar. When the former is true, the next call of
'x_change_tab_bar_height' and associates sets the latter true and
tries to adjust the frame height in a way that the now valid pixel
height of the tab bar is taken into account by the frame's native
height. */
bool_bf tab_bar_redisplayed : 1;
bool_bf tab_bar_resized : 1;
/* Whether the tool bar height change should be taken into account. */
/* Two sticky flags, that are both false when a frame is created.
'redisplay_tool_bar' sets the former to true the first time it
displays the tool bar. When the former is true, the next call of
'x_change_tool_bar_height' and associates sets the latter true and
tries to adjust the frame height in a way that the now valid pixel
height of the tool bar is taken into account by the frame's native
height. */
bool_bf tool_bar_redisplayed : 1;
bool_bf tool_bar_resized : 1;
@ -461,7 +469,7 @@ struct frame
last time run_window_change_functions was called on it. */
ptrdiff_t number_of_windows;
/* Number of lines (rounded up) of tab bar. REMOVE THIS */
/* Number of frame lines (rounded up) of tab bar. */
int tab_bar_lines;
/* Height of frame internal tab bar in pixels. */
@ -470,7 +478,7 @@ struct frame
int n_tab_bar_rows;
int n_tab_bar_items;
/* Number of lines (rounded up) of tool bar. REMOVE THIS */
/* Number of frame lines (rounded up) of tool bar. */
int tool_bar_lines;
/* Height of frame internal tool bar in pixels. */
@ -492,39 +500,24 @@ struct frame
/* Cost of deleting n lines on this frame. */
int *delete_n_lines_cost;
/* Text width of this frame (excluding fringes, vertical scroll bar
and internal border widths) and text height (excluding menu bar,
tool bar, horizontal scroll bar and internal border widths) in
units of canonical characters. */
/* Text width and height of this frame in (and maybe rounded to) frame
columns and lines. */
int text_cols, text_lines;
/* Total width of this frame (including fringes, vertical scroll bar
and internal border widths) and total height (including menu bar,
tool bar, horizontal scroll bar and internal border widths) in
units of canonical characters. */
int total_cols, total_lines;
/* Text width of this frame (excluding fringes, vertical scroll bar
and internal border widths) and text height (excluding menu bar,
tool bar, horizontal scroll bar and internal border widths) in
pixels. */
/* Text width and height of this frame in pixels. */
int text_width, text_height;
/* New text height and width for pending size change. 0 if no change
pending. These values represent pixels or canonical character units
according to the value of new_pixelwise and correlate to the
text width/height of the frame. */
/* Native width of this frame in (and maybe rounded to) frame columns
and lines. */
int total_cols, total_lines;
/* Native width and height of this frame in pixels. */
int pixel_width, pixel_height;
/* New native width and height of this frame for pending size change,
in pixels. -1 if no change pending. */
int new_width, new_height;
/* Pixel position of the frame window (x and y offsets in root window). */
int left_pos, top_pos;
/* Total width of this frame (including fringes, vertical scroll bar
and internal border widths) and total height (including internal
menu and tool bars, horizontal scroll bar and internal border
widths) in pixels. */
int pixel_width, pixel_height;
/* This is the gravity value for the specified window position. */
int win_gravity;
@ -848,7 +841,6 @@ default_pixels_per_inch_y (void)
/* FRAME_WINDOW_P tests whether the frame is a graphical window system
frame. */
#ifdef HAVE_X_WINDOWS
#define FRAME_WINDOW_P(f) FRAME_X_P (f)
#endif
@ -914,45 +906,36 @@ default_pixels_per_inch_y (void)
# define FRAME_SCALE_FACTOR(f) 1
#endif
/* Pixel width of frame F. */
/* Native width and height of frame F, in pixels and frame
columns/lines. */
#define FRAME_PIXEL_WIDTH(f) ((f)->pixel_width)
/* Pixel height of frame F. */
#define FRAME_PIXEL_HEIGHT(f) ((f)->pixel_height)
#define FRAME_TOTAL_COLS(f) ((f)->total_cols)
#define FRAME_TOTAL_LINES(f) ((f)->total_lines)
/* Width of frame F, measured in canonical character columns,
not including scroll bars if any. */
#define FRAME_COLS(f) (f)->text_cols
/* Height of frame F, measured in canonical lines, including
non-toolkit menu bar and non-toolkit tool bar lines. */
#define FRAME_LINES(f) (f)->text_lines
/* Width of frame F, measured in pixels not including the width for
fringes, scroll bar, and internal borders. */
/* Text width and height of frame F, in pixels and frame
columns/lines. */
#define FRAME_TEXT_WIDTH(f) (f)->text_width
/* Height of frame F, measured in pixels not including the height
for scroll bar and internal borders. */
#define FRAME_TEXT_HEIGHT(f) (f)->text_height
#define FRAME_COLS(f) ((f)->text_cols)
#define FRAME_LINES(f) ((f)->text_lines)
/* Number of lines of frame F used for menu bar.
This is relevant on terminal frames and on
X Windows when not using the X toolkit.
These lines are counted in FRAME_LINES. */
/* True if this frame should display an external menu bar. */
#ifdef HAVE_EXT_MENU_BAR
#define FRAME_EXTERNAL_MENU_BAR(f) (f)->external_menu_bar
#else
#define FRAME_EXTERNAL_MENU_BAR(f) false
#endif
/* Size of frame F's internal menu bar in frame lines and pixels. */
#define FRAME_MENU_BAR_LINES(f) (f)->menu_bar_lines
/* Pixel height of frame F's menu bar. */
#define FRAME_MENU_BAR_HEIGHT(f) (f)->menu_bar_height
/* Number of lines of frame F used for the tab-bar. */
/* Size of frame F's tab bar in frame lines and pixels. */
#define FRAME_TAB_BAR_LINES(f) (f)->tab_bar_lines
/* Pixel height of frame F's tab-bar. */
#define FRAME_TAB_BAR_HEIGHT(f) (f)->tab_bar_height
/* True if this frame should display a tool bar
in a way that does not use any text lines. */
/* True if this frame should display an external tool bar. */
#ifdef HAVE_EXT_TOOL_BAR
#define FRAME_EXTERNAL_TOOL_BAR(f) (f)->external_tool_bar
#else
@ -966,27 +949,21 @@ default_pixels_per_inch_y (void)
#define FRAME_TOOL_BAR_POSITION(f) ((void) (f), Qtop)
#endif
/* Number of lines of frame F used for the tool-bar. */
/* Size of frame F's internal tool bar in frame lines and pixels. */
#define FRAME_TOOL_BAR_LINES(f) (f)->tool_bar_lines
/* Pixel height of frame F's tool-bar. */
#define FRAME_TOOL_BAR_HEIGHT(f) (f)->tool_bar_height
/* Lines above the top-most window in frame F. */
#define FRAME_TOP_MARGIN(F) \
(FRAME_MENU_BAR_LINES (F) + FRAME_TAB_BAR_LINES (F) + FRAME_TOOL_BAR_LINES (F))
/* Height of frame F's top margin in frame lines. */
#define FRAME_TOP_MARGIN(F) \
(FRAME_MENU_BAR_LINES (F) \
+ FRAME_TAB_BAR_LINES (F) \
+ FRAME_TOOL_BAR_LINES (F))
/* Pixel height of frame F's top margin. */
#define FRAME_TOP_MARGIN_HEIGHT(F) \
(FRAME_MENU_BAR_HEIGHT (F) + FRAME_TAB_BAR_HEIGHT (F) + FRAME_TOOL_BAR_HEIGHT (F))
/* True if this frame should display a menu bar
in a way that does not use any text lines. */
#ifdef HAVE_EXT_MENU_BAR
#define FRAME_EXTERNAL_MENU_BAR(f) (f)->external_menu_bar
#else
#define FRAME_EXTERNAL_MENU_BAR(f) false
#endif
#define FRAME_TOP_MARGIN_HEIGHT(F) \
(FRAME_MENU_BAR_HEIGHT (F) \
+ FRAME_TAB_BAR_HEIGHT (F) \
+ FRAME_TOOL_BAR_HEIGHT (F))
/* True if frame F is currently visible. */
#define FRAME_VISIBLE_P(f) (f)->visible
@ -1183,48 +1160,6 @@ default_pixels_per_inch_y (void)
? FRAME_CONFIG_SCROLL_BAR_LINES (f) \
: 0)
/* Total width of frame F, in columns (characters),
including the width used by scroll bars if any. */
#define FRAME_TOTAL_COLS(f) ((f)->total_cols)
/* Total height of frame F, in lines (characters),
including the height used by scroll bars if any. */
#define FRAME_TOTAL_LINES(f) ((f)->total_lines)
/* Set the character widths of frame F. WIDTH specifies a nominal
character text width. */
#define SET_FRAME_COLS(f, width) \
((f)->text_cols = (width), \
(f)->total_cols = ((width) \
+ FRAME_SCROLL_BAR_COLS (f) \
+ FRAME_FRINGE_COLS (f)))
/* Set the character heights of frame F. HEIGHT specifies a nominal
character text height. */
#define SET_FRAME_LINES(f, height) \
((f)->text_lines = (height), \
(f)->total_lines = ((height) \
+ FRAME_TOP_MARGIN (f) \
+ FRAME_SCROLL_BAR_LINES (f)))
/* Set the widths of frame F. WIDTH specifies a nominal pixel text
width. */
#define SET_FRAME_WIDTH(f, width) \
((f)->text_width = (width), \
(f)->pixel_width = ((width) \
+ FRAME_SCROLL_BAR_AREA_WIDTH (f) \
+ FRAME_TOTAL_FRINGE_WIDTH (f) \
+ 2 * FRAME_INTERNAL_BORDER_WIDTH (f)))
/* Set the heights of frame F. HEIGHT specifies a nominal pixel text
height. */
#define SET_FRAME_HEIGHT(f, height) \
((f)->text_height = (height), \
(f)->pixel_height = ((height) \
+ FRAME_TOP_MARGIN_HEIGHT (f) \
+ FRAME_SCROLL_BAR_AREA_HEIGHT (f) \
+ 2 * FRAME_INTERNAL_BORDER_WIDTH (f)))
/* Maximum + 1 legitimate value for FRAME_CURSOR_X. */
#define FRAME_CURSOR_X_LIMIT(f) \
(FRAME_COLS (f) + FRAME_LEFT_SCROLL_BAR_COLS (f))
@ -1245,7 +1180,6 @@ default_pixels_per_inch_y (void)
#define FRAME_BACKGROUND_PIXEL(f) ((f)->background_pixel)
/* Return a pointer to the face cache of frame F. */
#define FRAME_FACE_CACHE(F) (F)->face_cache
/* Return the size of message_buf of the frame F. We multiply the
@ -1271,15 +1205,13 @@ default_pixels_per_inch_y (void)
This macro is a holdover from a time when multiple frames weren't always
supported. An alternate definition of the macro would expand to
something which executes the statement once. */
#define FOR_EACH_FRAME(list_var, frame_var) \
for ((list_var) = Vframe_list; \
(CONSP (list_var) \
#define FOR_EACH_FRAME(list_var, frame_var) \
for ((list_var) = Vframe_list; \
(CONSP (list_var) \
&& (frame_var = XCAR (list_var), true)); \
list_var = XCDR (list_var))
/* Reflect mouse movement when a complete frame update is performed. */
#define FRAME_MOUSE_UPDATE(frame) \
do { \
Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (frame); \
@ -1294,8 +1226,7 @@ default_pixels_per_inch_y (void)
} while (false)
/* Handy macro to construct an argument to Fmodify_frame_parameters. */
#define AUTO_FRAME_ARG(name, parameter, value) \
#define AUTO_FRAME_ARG(name, parameter, value) \
AUTO_LIST1 (name, AUTO_CONS_EXPR (parameter, value))
/* False means there are no visible garbaged frames. */
@ -1305,7 +1236,6 @@ extern bool frame_garbaged;
We call redisplay_other_windows to make sure the frame gets redisplayed
if some changes were applied to it while it wasn't visible (and hence
wasn't redisplayed). */
INLINE void
SET_FRAME_VISIBLE (struct frame *f, int v)
{
@ -1320,9 +1250,8 @@ SET_FRAME_VISIBLE (struct frame *f, int v)
f->visible = v;
}
/* Set iconify of frame F. */
#define SET_FRAME_ICONIFIED(f, i) \
/* Set iconified status of frame F. */
#define SET_FRAME_ICONIFIED(f, i) \
(f)->iconified = (eassert (0 <= (i) && (i) <= 1), (i))
extern Lisp_Object selected_frame;
@ -1369,11 +1298,14 @@ extern void frame_make_pointer_invisible (struct frame *);
extern void frame_make_pointer_visible (struct frame *);
extern Lisp_Object delete_frame (Lisp_Object, Lisp_Object);
extern bool frame_inhibit_resize (struct frame *, bool, Lisp_Object);
extern void adjust_frame_size (struct frame *, int, int, int, bool, Lisp_Object);
extern void frame_size_history_add (struct frame *f, Lisp_Object fun_symbol,
int width, int height, Lisp_Object rest);
extern void adjust_frame_size (struct frame *, int, int, int, bool,
Lisp_Object);
extern Lisp_Object mouse_position (bool);
extern int frame_windows_min_size (Lisp_Object, Lisp_Object, Lisp_Object,
Lisp_Object);
extern void frame_size_history_plain (struct frame *, Lisp_Object);
extern void frame_size_history_extra (struct frame *, Lisp_Object,
int, int, int, int, int, int);
extern Lisp_Object Vframe_list;
/* Value is a pointer to the selected frame. If the selected frame
@ -1652,12 +1584,11 @@ IMAGE_OPT_FROM_ID (struct frame *f, int id)
- FRAME_SCROLL_BAR_AREA_HEIGHT (f) \
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f))
/* Return the width/height reserved for the windows of frame F. */
#define FRAME_WINDOWS_WIDTH(f) \
#define FRAME_INNER_WIDTH(f) \
(FRAME_PIXEL_WIDTH (f) \
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f))
#define FRAME_WINDOWS_HEIGHT(f) \
#define FRAME_INNER_HEIGHT(f) \
(FRAME_PIXEL_HEIGHT (f) \
- FRAME_TOP_MARGIN_HEIGHT (f) \
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f))
@ -1701,7 +1632,7 @@ extern void gui_set_horizontal_scroll_bars (struct frame *, Lisp_Object, Lisp_Ob
extern void gui_set_scroll_bar_width (struct frame *, Lisp_Object, Lisp_Object);
extern void gui_set_scroll_bar_height (struct frame *, Lisp_Object, Lisp_Object);
extern long gui_figure_window_size (struct frame *, Lisp_Object, bool, bool, int *, int *);
extern long gui_figure_window_size (struct frame *, Lisp_Object, bool, bool);
extern void gui_set_alpha (struct frame *, Lisp_Object, Lisp_Object);
extern void gui_set_no_special_glyphs (struct frame *, Lisp_Object, Lisp_Object);

154
src/gtkutil.c
View file

@ -910,70 +910,58 @@ xg_set_geometry (struct frame *f)
}
}
/* Function to handle resize of our frame. As we have a Gtk+ tool bar
and a Gtk+ menu bar, we get resize events for the edit part of the
frame only. We let Gtk+ deal with the Gtk+ parts.
F is the frame to resize.
PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
/** Function to handle resize of native frame F to WIDTH and HEIGHT
pixels after we got a ConfigureNotify event. */
void
xg_frame_resized (struct frame *f, int pixelwidth, int pixelheight)
xg_frame_resized (struct frame *f, int width, int height)
{
int width, height;
if (pixelwidth == -1 && pixelheight == -1)
/* Ignore case where size of native rectangle didn't change. */
if (width != FRAME_PIXEL_WIDTH (f) || height != FRAME_PIXEL_HEIGHT (f)
|| (delayed_size_change
&& (width != f->new_width || height != f->new_height)))
{
if (FRAME_GTK_WIDGET (f) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f)))
gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f)),
0, 0, &pixelwidth, &pixelheight);
else
return;
}
if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("xg_frame_resized, changed"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f), width, height,
delayed_size_change ? f->new_width : -1,
delayed_size_change ? f->new_height : -1);
width = FRAME_PIXEL_TO_TEXT_WIDTH (f, pixelwidth);
height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelheight);
frame_size_history_add
(f, Qxg_frame_resized, width, height, Qnil);
if (width != FRAME_TEXT_WIDTH (f)
|| height != FRAME_TEXT_HEIGHT (f)
|| pixelwidth != FRAME_PIXEL_WIDTH (f)
|| pixelheight != FRAME_PIXEL_HEIGHT (f))
{
FRAME_RIF (f)->clear_under_internal_border (f);
change_frame_size (f, width, height, 0, 1, 0, 1);
change_frame_size (f, width, height, false, true, false);
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
}
else if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("xg_frame_resized, unchanged"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f), width, height,
delayed_size_change ? f->new_width : -1,
delayed_size_change ? f->new_height : -1);
}
/** Resize the outer window of frame F. WIDTH and HEIGHT are the new
pixel sizes of F's text area. */
native pixel sizes of F. */
void
xg_frame_set_char_size (struct frame *f, int width, int height)
{
int pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
int pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
gint gwidth, gheight;
int totalheight
= pixelheight + FRAME_TOOLBAR_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f);
int totalwidth = pixelwidth + FRAME_TOOLBAR_WIDTH (f);
int outer_height
= height + FRAME_TOOLBAR_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f);
int outer_width = width + FRAME_TOOLBAR_WIDTH (f);
bool was_visible = false;
bool hide_child_frame;
if (FRAME_PIXEL_HEIGHT (f) == 0)
return;
gtk_window_get_size (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
&gwidth, &gheight);
/* Do this before resize, as we don't know yet if we will be resized. */
FRAME_RIF (f)->clear_under_internal_border (f);
totalheight /= xg_get_scale (f);
totalwidth /= xg_get_scale (f);
outer_height /= xg_get_scale (f);
outer_width /= xg_get_scale (f);
x_wm_set_size_hint (f, 0, 0);
@ -986,35 +974,19 @@ xg_frame_set_char_size (struct frame *f, int width, int height)
manager will abolish it. At least the respective size should
remain unchanged but giving the frame back its normal size will
be broken ... */
if (EQ (fullscreen, Qfullwidth) && width == FRAME_TEXT_WIDTH (f))
{
frame_size_history_add
(f, Qxg_frame_set_char_size_1, width, height,
list2i (gheight, totalheight));
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
gwidth, totalheight);
}
else if (EQ (fullscreen, Qfullheight) && height == FRAME_TEXT_HEIGHT (f))
{
frame_size_history_add
(f, Qxg_frame_set_char_size_2, width, height,
list2i (gwidth, totalwidth));
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
totalwidth, gheight);
}
if (EQ (fullscreen, Qfullwidth) && width == FRAME_PIXEL_WIDTH (f))
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
gwidth, outer_height);
else if (EQ (fullscreen, Qfullheight) && height == FRAME_PIXEL_HEIGHT (f))
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
outer_width, gheight);
else if (FRAME_PARENT_FRAME (f) && FRAME_VISIBLE_P (f))
{
was_visible = true;
hide_child_frame = EQ (x_gtk_resize_child_frames, Qhide);
if (totalwidth != gwidth || totalheight != gheight)
if (outer_width != gwidth || outer_height != gheight)
{
frame_size_history_add
(f, Qxg_frame_set_char_size_4, width, height,
list2i (totalwidth, totalheight));
if (hide_child_frame)
{
block_input ();
@ -1023,7 +995,7 @@ xg_frame_set_char_size (struct frame *f, int width, int height)
}
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
totalwidth, totalheight);
outer_width, outer_height);
if (hide_child_frame)
{
@ -1037,11 +1009,8 @@ xg_frame_set_char_size (struct frame *f, int width, int height)
}
else
{
frame_size_history_add
(f, Qxg_frame_set_char_size_3, width, height,
list2i (totalwidth, totalheight));
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
totalwidth, totalheight);
outer_width, outer_height);
fullscreen = Qnil;
}
@ -1062,6 +1031,12 @@ xg_frame_set_char_size (struct frame *f, int width, int height)
gdk_flush ();
x_wait_for_event (f, ConfigureNotify);
if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("xg_frame_set_char_size, visible"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f), width, height,
f->new_width, f->new_height);
if (!NILP (fullscreen))
/* Try to restore fullscreen state. */
{
@ -1070,8 +1045,17 @@ xg_frame_set_char_size (struct frame *f, int width, int height)
}
}
else
adjust_frame_size (f, width, height, 5, 0, Qxg_frame_set_char_size);
{
if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("xg_frame_set_char_size, invisible"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f), width, height,
f->new_width, f->new_height);
adjust_frame_size (f, FRAME_PIXEL_TO_TEXT_WIDTH (f, width),
FRAME_PIXEL_TO_TEXT_HEIGHT (f, height),
5, 0, Qxg_frame_set_char_size);
}
}
/* Handle height/width changes (i.e. add/remove/move menu/toolbar).
@ -1186,7 +1170,8 @@ style_changed_cb (GObject *go,
{
FRAME_TERMINAL (f)->set_scroll_bar_default_width_hook (f);
FRAME_TERMINAL (f)->set_scroll_bar_default_height_hook (f);
xg_frame_set_char_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f));
xg_frame_set_char_size (f, FRAME_PIXEL_WIDTH (f),
FRAME_PIXEL_HEIGHT (f));
}
}
}
@ -4589,10 +4574,7 @@ tb_size_cb (GtkWidget *widget,
struct frame *f = user_data;
if (xg_update_tool_bar_sizes (f))
{
frame_size_history_add (f, Qtb_size_cb, 0, 0, Qnil);
adjust_frame_size (f, -1, -1, 5, 0, Qtool_bar_lines);
}
adjust_frame_size (f, -1, -1, 2, false, Qtool_bar_lines);
}
/* Create a tool bar for frame F. */
@ -5219,23 +5201,10 @@ update_frame_tool_bar (struct frame *f)
xg_pack_tool_bar (f, FRAME_TOOL_BAR_POSITION (f));
gtk_widget_show_all (x->toolbar_widget);
if (xg_update_tool_bar_sizes (f))
{
int inhibit
= ((f->after_make_frame
&& !f->tool_bar_resized
&& (EQ (frame_inhibit_implied_resize, Qt)
|| (CONSP (frame_inhibit_implied_resize)
&& !NILP (Fmemq (Qtool_bar_lines,
frame_inhibit_implied_resize))))
/* This will probably fail to DTRT in the
fullheight/-width cases. */
&& NILP (get_frame_param (f, Qfullscreen)))
? 0
: 2);
/* It's not entirely clear whether here we want a treatment
similar to that for frames with internal tool bar. */
adjust_frame_size (f, -1, -1, 2, 0, Qtool_bar_lines);
frame_size_history_add (f, Qupdate_frame_tool_bar, 0, 0, Qnil);
adjust_frame_size (f, -1, -1, inhibit, 0, Qtool_bar_lines);
}
f->tool_bar_resized = f->tool_bar_redisplayed;
}
@ -5284,7 +5253,6 @@ free_frame_tool_bar (struct frame *f)
NULL);
}
frame_size_history_add (f, Qfree_frame_tool_bar, 0, 0, Qnil);
adjust_frame_size (f, -1, -1, 2, 0, Qtool_bar_lines);
unblock_input ();
@ -5316,11 +5284,7 @@ xg_change_toolbar_position (struct frame *f, Lisp_Object pos)
g_object_unref (top_widget);
if (xg_update_tool_bar_sizes (f))
{
frame_size_history_add (f, Qxg_change_toolbar_position, 0, 0, Qnil);
adjust_frame_size (f, -1, -1, 2, 0, Qtool_bar_lines);
}
adjust_frame_size (f, -1, -1, 2, 0, Qtool_bar_lines);
unblock_input ();
}

5
src/keyboard.c
View file

@ -10665,10 +10665,7 @@ On such systems, Emacs starts a subshell instead of suspending. */)
with a window system; but suspend should be disabled in that case. */
get_tty_size (fileno (CURTTY ()->input), &width, &height);
if (width != old_width || height != old_height)
change_frame_size (SELECTED_FRAME (), width,
height - FRAME_MENU_BAR_LINES (SELECTED_FRAME ())
- FRAME_TAB_BAR_LINES (SELECTED_FRAME ()),
0, 0, 0, 0);
change_frame_size (SELECTED_FRAME (), width, height, false, false, false);
run_hook (intern ("suspend-resume-hook"));

26
src/nsfns.m
View file

@ -669,21 +669,9 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
}
{
int inhibit
= ((f->after_make_frame
&& !f->tool_bar_resized
&& (EQ (frame_inhibit_implied_resize, Qt)
|| (CONSP (frame_inhibit_implied_resize)
&& !NILP (Fmemq (Qtool_bar_lines,
frame_inhibit_implied_resize))))
&& NILP (get_frame_param (f, Qfullscreen)))
? 0
: 2);
NSTRACE_MSG ("inhibit:%d", inhibit);
frame_size_history_add (f, Qupdate_frame_tool_bar, 0, 0, Qnil);
adjust_frame_size (f, -1, -1, inhibit, 0, Qtool_bar_lines);
adjust_frame_size (f, -1, -1, 2, false, Qtool_bar_lines);
}
}
@ -1332,8 +1320,7 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
RES_TYPE_STRING);
parms = get_geometry_from_preferences (dpyinfo, parms);
window_prompting = gui_figure_window_size (f, parms, false, true,
&x_width, &x_height);
window_prompting = gui_figure_window_size (f, parms, false, true);
tem = gui_display_get_arg (dpyinfo, parms, Qunsplittable, 0, 0,
RES_TYPE_BOOLEAN);
@ -1400,13 +1387,8 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side.
/* Allow set_window_size_hook, now. */
f->can_set_window_size = true;
if (x_width > 0)
SET_FRAME_WIDTH (f, x_width);
if (x_height > 0)
SET_FRAME_HEIGHT (f, x_height);
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 0, 1,
Qx_create_frame_2);
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f),
0, true, Qx_create_frame_2);
if (! f->output_data.ns->explicit_parent)
{

41
src/nsterm.m
View file

@ -1876,10 +1876,9 @@ Hide the window (X11 semantics)
ns_set_window_size (struct frame *f,
bool change_gravity,
int width,
int height,
bool pixelwise)
int height)
/* --------------------------------------------------------------------------
Adjust window pixel size based on given character grid size
Adjust window pixel size based on native sizes WIDTH and HEIGHT.
Impl is a bit more complex than other terms, need to do some
internal clipping.
-------------------------------------------------------------------------- */
@ -1887,7 +1886,6 @@ Hide the window (X11 semantics)
EmacsView *view = FRAME_NS_VIEW (f);
NSWindow *window = [view window];
NSRect wr = [window frame];
int pixelwidth, pixelheight;
int orig_height = wr.size.height;
NSTRACE ("ns_set_window_size");
@ -1896,24 +1894,13 @@ Hide the window (X11 semantics)
return;
NSTRACE_RECT ("current", wr);
NSTRACE_MSG ("Width:%d Height:%d Pixelwise:%d", width, height, pixelwise);
NSTRACE_MSG ("Width:%d Height:%d", width, height);
NSTRACE_MSG ("Font %d x %d", FRAME_COLUMN_WIDTH (f), FRAME_LINE_HEIGHT (f));
block_input ();
if (pixelwise)
{
pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
}
else
{
pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width);
pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
}
wr.size.width = pixelwidth + f->border_width;
wr.size.height = pixelheight;
wr.size.width = width + f->border_width;
wr.size.height = height;
if (! [view isFullscreen])
wr.size.height += FRAME_NS_TITLEBAR_HEIGHT (f)
+ FRAME_TOOLBAR_HEIGHT (f);
@ -1926,21 +1913,10 @@ Hide the window (X11 semantics)
else
wr.origin.y += orig_height - wr.size.height;
frame_size_history_add
(f, Qx_set_window_size_1, width, height,
list5 (Fcons (make_fixnum (pixelwidth), make_fixnum (pixelheight)),
Fcons (make_fixnum (wr.size.width), make_fixnum (wr.size.height)),
make_fixnum (f->border_width),
make_fixnum (FRAME_NS_TITLEBAR_HEIGHT (f)),
make_fixnum (FRAME_TOOLBAR_HEIGHT (f))));
/* Usually it seems safe to delay changing the frame size, but when a
series of actions are taken with no redisplay between them then we
can end up using old values so don't delay here. */
change_frame_size (f,
FRAME_PIXEL_TO_TEXT_WIDTH (f, pixelwidth),
FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelheight),
0, NO, 0, 1);
change_frame_size (f, width, height, false, NO, false);
[window setFrame:wr display:NO];
@ -7359,10 +7335,7 @@ - (void)viewDidResize:(NSNotification *)notification
changes size, as Emacs may already know about the change.
Unfortunately there doesn't seem to be a bullet-proof method of
determining whether we need to call it or not. */
change_frame_size (emacsframe,
FRAME_PIXEL_TO_TEXT_WIDTH (emacsframe, neww),
FRAME_PIXEL_TO_TEXT_HEIGHT (emacsframe, newh),
0, YES, 0, 1);
change_frame_size (emacsframe, neww, newh, false, YES, false);
SET_FRAME_GARBAGED (emacsframe);
cancel_mouse_face (emacsframe);

4
src/term.c
View file

@ -2356,9 +2356,7 @@ frame's terminal). */)
was suspended. */
get_tty_size (fileno (t->display_info.tty->input), &width, &height);
if (width != old_width || height != old_height)
change_frame_size (f, width, height - FRAME_MENU_BAR_LINES (f)
- FRAME_TAB_BAR_LINES (f),
0, 0, 0, 0);
change_frame_size (f, width, height, false, false, false);
SET_FRAME_VISIBLE (XFRAME (t->display_info.tty->top_frame), 1);
}

2
src/termhooks.h
View file

@ -583,7 +583,7 @@ struct terminal
window gravity for this size change and subsequent size changes.
Otherwise we leave the window gravity unchanged. */
void (*set_window_size_hook) (struct frame *f, bool change_gravity,
int width, int height, bool pixelwise);
int width, int height);
/* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
to really change the position, and 0 when calling from

96
src/w32fns.c
View file

@ -1701,7 +1701,7 @@ w32_change_tab_bar_height (struct frame *f, int height)
int unit = FRAME_LINE_HEIGHT (f);
int old_height = FRAME_TAB_BAR_HEIGHT (f);
int lines = (height + unit - 1) / unit;
Lisp_Object fullscreen;
Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
/* Make sure we redisplay all windows in this frame. */
fset_redisplay (f);
@ -1728,25 +1728,21 @@ w32_change_tab_bar_height (struct frame *f, int height)
if ((height < old_height) && WINDOWP (f->tab_bar_window))
clear_glyph_matrix (XWINDOW (f->tab_bar_window)->current_matrix);
/* Recalculate tabbar height. */
f->n_tab_bar_rows = 0;
if (old_height == 0
&& (!f->after_make_frame
|| NILP (frame_inhibit_implied_resize)
|| (CONSP (frame_inhibit_implied_resize)
&& NILP (Fmemq (Qtab_bar_lines, frame_inhibit_implied_resize)))))
f->tab_bar_redisplayed = f->tab_bar_resized = false;
if (!f->tab_bar_resized)
{
/* As long as tab_bar_resized is false, effectively try to change
F's native height. */
if (NILP (fullscreen) || EQ (fullscreen, Qfullwidth))
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f),
1, false, Qtab_bar_lines);
else
adjust_frame_size (f, -1, -1, 4, false, Qtab_bar_lines);
adjust_frame_size (f, -1, -1,
((!f->tab_bar_resized
&& (NILP (fullscreen =
get_frame_param (f, Qfullscreen))
|| EQ (fullscreen, Qfullwidth))) ? 1
: (old_height == 0 || height == 0) ? 2
: 4),
false, Qtab_bar_lines);
f->tab_bar_resized = f->tab_bar_redisplayed;
f->tab_bar_resized = f->tab_bar_redisplayed;
}
else
/* Any other change may leave the native size of F alone. */
adjust_frame_size (f, -1, -1, 3, false, Qtab_bar_lines);
/* adjust_frame_size might not have done anything, garbage frame
here. */
@ -1790,7 +1786,7 @@ w32_change_tool_bar_height (struct frame *f, int height)
int unit = FRAME_LINE_HEIGHT (f);
int old_height = FRAME_TOOL_BAR_HEIGHT (f);
int lines = (height + unit - 1) / unit;
Lisp_Object fullscreen;
Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
/* Make sure we redisplay all windows in this frame. */
windows_or_buffers_changed = 23;
@ -1811,25 +1807,21 @@ w32_change_tool_bar_height (struct frame *f, int height)
if ((height < old_height) && WINDOWP (f->tool_bar_window))
clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
/* Recalculate toolbar height. */
f->n_tool_bar_rows = 0;
if (old_height == 0
&& (!f->after_make_frame
|| NILP (frame_inhibit_implied_resize)
|| (CONSP (frame_inhibit_implied_resize)
&& NILP (Fmemq (Qtool_bar_lines, frame_inhibit_implied_resize)))))
f->tool_bar_redisplayed = f->tool_bar_resized = false;
if (!f->tool_bar_resized)
{
/* As long as tool_bar_resized is false, effectively try to change
F's native height. */
if (NILP (fullscreen) || EQ (fullscreen, Qfullwidth))
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f),
1, false, Qtool_bar_lines);
else
adjust_frame_size (f, -1, -1, 4, false, Qtool_bar_lines);
adjust_frame_size (f, -1, -1,
((!f->tool_bar_resized
&& (NILP (fullscreen =
get_frame_param (f, Qfullscreen))
|| EQ (fullscreen, Qfullwidth))) ? 1
: (old_height == 0 || height == 0) ? 2
: 4),
false, Qtool_bar_lines);
f->tool_bar_resized = f->tool_bar_redisplayed;
f->tool_bar_resized = f->tool_bar_redisplayed;
}
else
/* Any other change may leave the native size of F alone. */
adjust_frame_size (f, -1, -1, 3, false, Qtool_bar_lines);
/* adjust_frame_size might not have done anything, garbage frame
here. */
@ -5718,7 +5710,6 @@ DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
struct w32_display_info *dpyinfo = NULL;
Lisp_Object parent, parent_frame;
struct kboard *kb;
int x_width = 0, x_height = 0;
if (!FRAME_W32_P (SELECTED_FRAME ())
&& !FRAME_INITIAL_P (SELECTED_FRAME ()))
@ -6045,8 +6036,7 @@ DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
f->output_data.w32->current_cursor = f->output_data.w32->nontext_cursor;
window_prompting = gui_figure_window_size (f, parameters, true, true,
&x_width, &x_height);
window_prompting = gui_figure_window_size (f, parameters, true, true);
tem = gui_display_get_arg (dpyinfo, parameters, Qunsplittable, 0, 0,
RES_TYPE_BOOLEAN);
@ -6081,11 +6071,6 @@ DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
/* Allow set_window_size_hook, now. */
f->can_set_window_size = true;
if (x_width > 0)
SET_FRAME_WIDTH (f, x_width);
if (x_height > 0)
SET_FRAME_HEIGHT (f, x_height);
/* Tell the server what size and position, etc, we want, and how
badly we want them. This should be done after we have the menu
bar so that its size can be taken into account. */
@ -6093,8 +6078,8 @@ DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
w32_wm_set_size_hint (f, window_prompting, false);
unblock_input ();
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 0, true,
Qx_create_frame_2);
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f),
0, true, Qx_create_frame_2);
/* Process fullscreen parameter here in the hope that normalizing a
fullheight/fullwidth frame will produce the size set by the last
@ -6888,11 +6873,9 @@ w32_create_tip_frame (struct w32_display_info *dpyinfo, Lisp_Object parms)
struct frame *f;
Lisp_Object frame;
Lisp_Object name;
int width, height;
ptrdiff_t count = SPECPDL_INDEX ();
struct kboard *kb;
bool face_change_before = face_change;
int x_width = 0, x_height = 0;
/* Use this general default value to start with until we know if
this frame has a specified name. */
@ -7013,7 +6996,7 @@ w32_create_tip_frame (struct w32_display_info *dpyinfo, Lisp_Object parms)
f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
f->output_data.w32->explicit_parent = false;
gui_figure_window_size (f, parms, true, true, &x_width, &x_height);
gui_figure_window_size (f, parms, true, true);
/* No fringes on tip frame. */
f->fringe_cols = 0;
@ -7039,15 +7022,6 @@ w32_create_tip_frame (struct w32_display_info *dpyinfo, Lisp_Object parms)
gui_default_parameter (f, parms, Qalpha, Qnil,
"alpha", "Alpha", RES_TYPE_NUMBER);
/* Dimensions, especially FRAME_LINES (f), must be done via
change_frame_size. Change will not be effected unless different
from the current FRAME_LINES (f). */
width = FRAME_COLS (f);
height = FRAME_LINES (f);
SET_FRAME_COLS (f, 0);
SET_FRAME_LINES (f, 0);
adjust_frame_size (f, width * FRAME_COLUMN_WIDTH (f),
height * FRAME_LINE_HEIGHT (f), 0, true, Qtip_frame);
/* Add `tooltip' frame parameter's default value. */
if (NILP (Fframe_parameter (frame, Qtooltip)))
Fmodify_frame_parameters (frame, Fcons (Fcons (Qtooltip, Qt), Qnil));
@ -7088,6 +7062,8 @@ w32_create_tip_frame (struct w32_display_info *dpyinfo, Lisp_Object parms)
visible won't work. */
Vframe_list = Fcons (frame, Vframe_list);
f->can_set_window_size = true;
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f),
0, true, Qtip_frame);
/* Setting attributes of faces of the tooltip frame from resources
and similar will set face_change, which leads to the

12
src/w32inevt.c
View file

@ -608,9 +608,7 @@ resize_event (WINDOW_BUFFER_SIZE_RECORD *event)
{
struct frame *f = get_frame ();
change_frame_size (f, event->dwSize.X, event->dwSize.Y
- FRAME_MENU_BAR_LINES (f)
- FRAME_TAB_BAR_LINES (f), 0, 1, 0, 0);
change_frame_size (f, event->dwSize.X, event->dwSize.Y, false, true, false);
SET_FRAME_GARBAGED (f);
}
@ -624,11 +622,9 @@ maybe_generate_resize_event (void)
/* It is okay to call this unconditionally, since it will do nothing
if the size hasn't actually changed. */
change_frame_size (f,
1 + info.srWindow.Right - info.srWindow.Left,
1 + info.srWindow.Bottom - info.srWindow.Top
- FRAME_MENU_BAR_LINES (f)
- FRAME_TAB_BAR_LINES (f), 0, 1, 0, 0);
change_frame_size (f, 1 + info.srWindow.Right - info.srWindow.Left,
1 + info.srWindow.Bottom - info.srWindow.Top,
false, true, false);
}
#if HAVE_W32NOTIFY

156
src/w32term.c
View file

@ -5352,7 +5352,7 @@ w32_read_socket (struct terminal *terminal,
if (f)
{
RECT rect;
int /* rows, columns, */ width, height, text_width, text_height;
int /* rows, columns, */ width, height;
if (GetClientRect (msg.msg.hwnd, &rect)
/* GetClientRect evidently returns (0, 0, 0, 0) if
@ -5365,23 +5365,11 @@ w32_read_socket (struct terminal *terminal,
{
height = rect.bottom - rect.top;
width = rect.right - rect.left;
text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, width);
text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, height);
/* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
/* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
/* TODO: Clip size to the screen dimensions. */
/* Even if the number of character rows and columns
has not changed, the font size may have changed,
so we need to check the pixel dimensions as well. */
if (width != FRAME_PIXEL_WIDTH (f)
|| height != FRAME_PIXEL_HEIGHT (f)
|| text_width != FRAME_TEXT_WIDTH (f)
|| text_height != FRAME_TEXT_HEIGHT (f))
|| height != FRAME_PIXEL_HEIGHT (f))
{
change_frame_size (f, text_width, text_height, 0, 1, 0, 1);
change_frame_size
(f, width, height, false, true, false);
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
f->win_gravity = NorthWestGravity;
@ -5565,7 +5553,7 @@ w32_read_socket (struct terminal *terminal,
if (f && !FRAME_ICONIFIED_P (f) && msg.msg.wParam != SIZE_MINIMIZED)
{
RECT rect;
int /* rows, columns, */ width, height, text_width, text_height;
int /* rows, columns, */ width, height;
if (GetClientRect (msg.msg.hwnd, &rect)
/* GetClientRect evidently returns (0, 0, 0, 0) if
@ -5578,23 +5566,12 @@ w32_read_socket (struct terminal *terminal,
{
height = rect.bottom - rect.top;
width = rect.right - rect.left;
text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, width);
text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, height);
/* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
/* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
/* TODO: Clip size to the screen dimensions. */
/* Even if the number of character rows and columns
has not changed, the font size may have changed,
so we need to check the pixel dimensions as well. */
if (width != FRAME_PIXEL_WIDTH (f)
|| height != FRAME_PIXEL_HEIGHT (f)
|| text_width != FRAME_TEXT_WIDTH (f)
|| text_height != FRAME_TEXT_HEIGHT (f))
|| height != FRAME_PIXEL_HEIGHT (f))
{
change_frame_size (f, text_width, text_height, 0, 1, 0, 1);
change_frame_size
(f, width, height, false, true, false);
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
f->win_gravity = NorthWestGravity;
@ -6267,17 +6244,15 @@ w32_new_font (struct frame *f, Lisp_Object font_object, int fontset)
FRAME_CONFIG_SCROLL_BAR_COLS (f) * unit;
}
/* Now make the frame display the given font. */
if (FRAME_NATIVE_WINDOW (f) != 0)
{
/* Don't change the size of a tip frame; there's no point in
doing it because it's done in Fx_show_tip, and it leads to
problems because the tip frame has no widget. */
if (!FRAME_TOOLTIP_P (f))
adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 3,
false, Qfont);
}
FRAME_TAB_BAR_HEIGHT (f) = FRAME_TAB_BAR_LINES (f) * FRAME_LINE_HEIGHT (f);
/* Don't change the size of a tip frame; there's no point in
doing it because it's done in Fx_show_tip, and it leads to
problems because the tip frame has no widget. */
if (FRAME_NATIVE_WINDOW (f) != 0 && !FRAME_TOOLTIP_P (f))
adjust_frame_size
(f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 3, false, Qfont);
/* X version sets font of input methods here also. */
@ -6490,7 +6465,8 @@ w32fullscreen_hook (struct frame *f)
ShowWindow (hwnd, SW_SHOWNORMAL);
else if (f->want_fullscreen == FULLSCREEN_MAXIMIZED)
{
if (prev_fsmode == FULLSCREEN_BOTH || prev_fsmode == FULLSCREEN_WIDTH
if (prev_fsmode == FULLSCREEN_BOTH
|| prev_fsmode == FULLSCREEN_WIDTH
|| prev_fsmode == FULLSCREEN_HEIGHT)
/* Make window normal since otherwise the subsequent
maximization might fail in some cases. */
@ -6499,52 +6475,31 @@ w32fullscreen_hook (struct frame *f)
}
else if (f->want_fullscreen == FULLSCREEN_BOTH)
{
int menu_bar_height = GetSystemMetrics (SM_CYMENU);
w32_fullscreen_rect (hwnd, f->want_fullscreen,
FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
w32_fullscreen_rect
(hwnd, f->want_fullscreen,
FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
if (!FRAME_UNDECORATED (f))
SetWindowLong (hwnd, GWL_STYLE, dwStyle & ~WS_OVERLAPPEDWINDOW);
SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top,
SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
change_frame_size
(f, FRAME_PIXEL_TO_TEXT_WIDTH (f, rect.right - rect.left),
FRAME_PIXEL_TO_TEXT_HEIGHT (f, (rect.bottom - rect.top
- menu_bar_height)),
0, 1, 0, 1);
(f, rect.right - rect.left, rect.bottom - rect.top,
false, true, false);
}
else
{
ShowWindow (hwnd, SW_SHOWNORMAL);
w32_fullscreen_rect (hwnd, f->want_fullscreen,
FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
w32_fullscreen_rect
(hwnd, f->want_fullscreen,
FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top, 0);
if (f->want_fullscreen == FULLSCREEN_WIDTH)
{
int border_width = GetSystemMetrics (SM_CXFRAME);
change_frame_size
(f, (FRAME_PIXEL_TO_TEXT_WIDTH
(f, rect.right - rect.left - 2 * border_width)),
0, 0, 1, 0, 1);
}
else
{
int border_height = GetSystemMetrics (SM_CYFRAME);
/* Won't work for wrapped menu bar. */
int menu_bar_height = GetSystemMetrics (SM_CYMENU);
int title_height = GetSystemMetrics (SM_CYCAPTION);
change_frame_size
(f, 0, (FRAME_PIXEL_TO_TEXT_HEIGHT
(f, rect.bottom - rect.top - 2 * border_height
- title_height - menu_bar_height)),
0, 1, 0, 1);
}
}
change_frame_size
(f, rect.right - rect.left, rect.bottom - rect.top,
false, true, false);
}
f->want_fullscreen = FULLSCREEN_NONE;
unblock_input ();
@ -6559,16 +6514,14 @@ w32fullscreen_hook (struct frame *f)
f->want_fullscreen |= FULLSCREEN_WAIT;
}
/* Call this to change the size of frame F's native window.
If CHANGE_GRAVITY, change to top-left-corner window gravity
for this size change and subsequent size changes.
Otherwise we leave the window gravity unchanged. */
/* Change the size of frame F's Windows window to WIDTH and HEIGHT
pixels. If CHANGE_GRAVITY, change to top-left-corner window gravity
for this size change and subsequent size changes. Otherwise leave
the window gravity unchanged. */
static void
w32_set_window_size (struct frame *f, bool change_gravity,
int width, int height, bool pixelwise)
int width, int height)
{
int pixelwidth, pixelheight;
Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
RECT rect;
MENUBARINFO info;
@ -6584,17 +6537,6 @@ w32_set_window_size (struct frame *f, bool change_gravity,
GetMenuBarInfo (FRAME_W32_WINDOW (f), 0xFFFFFFFD, 0, &info);
menu_bar_height = info.rcBar.bottom - info.rcBar.top;
if (pixelwise)
{
pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
}
else
{
pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width);
pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
}
if (w32_add_wrapped_menu_bar_lines)
{
/* When the menu bar wraps sending a SetWindowPos shrinks the
@ -6610,15 +6552,15 @@ w32_set_window_size (struct frame *f, bool change_gravity,
if ((default_menu_bar_height > 0)
&& (menu_bar_height > default_menu_bar_height)
&& ((menu_bar_height % default_menu_bar_height) == 0))
pixelheight = pixelheight + menu_bar_height - default_menu_bar_height;
height = height + menu_bar_height - default_menu_bar_height;
}
f->win_gravity = NorthWestGravity;
w32_wm_set_size_hint (f, (long) 0, false);
rect.left = rect.top = 0;
rect.right = pixelwidth;
rect.bottom = pixelheight;
rect.right = width;
rect.bottom = height;
AdjustWindowRect (&rect, f->output_data.w32->dwStyle, menu_bar_height > 0);
@ -6636,7 +6578,7 @@ w32_set_window_size (struct frame *f, bool change_gravity,
{
rect.left = window_rect.left;
rect.right = window_rect.right;
pixelwidth = 0;
width = -1;
}
if (EQ (fullscreen, Qmaximized)
|| EQ (fullscreen, Qfullboth)
@ -6644,19 +6586,12 @@ w32_set_window_size (struct frame *f, bool change_gravity,
{
rect.top = window_rect.top;
rect.bottom = window_rect.bottom;
pixelheight = 0;
height = -1;
}
}
if (pixelwidth > 0 || pixelheight > 0)
if (width > 0 || height > 0)
{
frame_size_history_add
(f, Qx_set_window_size_1, width, height,
list2 (Fcons (make_fixnum (pixelwidth),
make_fixnum (pixelheight)),
Fcons (make_fixnum (rect.right - rect.left),
make_fixnum (rect.bottom - rect.top))));
if (!FRAME_PARENT_FRAME (f))
my_set_window_pos (FRAME_W32_WINDOW (f), NULL,
0, 0,
@ -6670,12 +6605,7 @@ w32_set_window_size (struct frame *f, bool change_gravity,
rect.bottom - rect.top,
SWP_NOMOVE | SWP_NOACTIVATE);
change_frame_size (f,
((pixelwidth == 0)
? 0 : FRAME_PIXEL_TO_TEXT_WIDTH (f, pixelwidth)),
((pixelheight == 0)
? 0 : FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelheight)),
0, 1, 0, 1);
change_frame_size (f, width, height, false, true, false);
SET_FRAME_GARBAGED (f);
/* If cursor was outside the new size, mark it as off. */

71
src/widget.c
View file

@ -168,14 +168,6 @@ pixel_to_char_size (EmacsFrame ew, Dimension pixel_width, Dimension pixel_height
*char_height = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, (int) pixel_height);
}
static void
pixel_to_text_size (EmacsFrame ew, Dimension pixel_width, Dimension pixel_height, int *text_width, int *text_height)
{
struct frame *f = ew->emacs_frame.frame;
*text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, (int) pixel_width);
*text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, (int) pixel_height);
}
static void
char_to_pixel_size (EmacsFrame ew, int char_width, int char_height, Dimension *pixel_width, Dimension *pixel_height)
{
@ -257,27 +249,14 @@ set_frame_size (EmacsFrame ew)
*/
/* Hairily merged geometry */
struct frame *f = ew->emacs_frame.frame;
int w = FRAME_COLS (f);
int h = FRAME_LINES (f);
Widget wmshell = get_wm_shell ((Widget) ew);
Dimension pixel_width, pixel_height;
/* Each Emacs shell is now independent and top-level. */
if (! XtIsSubclass (wmshell, shellWidgetClass)) emacs_abort ();
ew->core.width = FRAME_PIXEL_WIDTH (f);
ew->core.height = FRAME_PIXEL_HEIGHT (f);
char_to_pixel_size (ew, w, h, &pixel_width, &pixel_height);
ew->core.width = (frame_resize_pixelwise
? FRAME_PIXEL_WIDTH (f)
: pixel_width);
ew->core.height = (frame_resize_pixelwise
? FRAME_PIXEL_HEIGHT (f)
: pixel_height);
frame_size_history_add
(f, Qset_frame_size, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f),
list2i (ew->core.width, ew->core.height));
if (CONSP (frame_size_history))
frame_size_history_plain
(f, build_string ("set_frame_size"));
}
static void
@ -350,6 +329,13 @@ update_from_various_frame_slots (EmacsFrame ew)
ew->emacs_frame.foreground_pixel = FRAME_FOREGROUND_PIXEL (f);
ew->emacs_frame.cursor_color = x->cursor_pixel;
ew->core.border_pixel = x->border_pixel;
if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("update_from_various_frame_slots"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
ew->core.width, ew->core.height,
f->new_width, f->new_height);
}
static void
@ -381,6 +367,7 @@ static void
EmacsFrameRealize (Widget widget, XtValueMask *mask, XSetWindowAttributes *attrs)
{
EmacsFrame ew = (EmacsFrame) widget;
struct frame *f = ew->emacs_frame.frame;
/* This used to contain SubstructureRedirectMask, but this turns out
to be a problem with XIM on Solaris, and events from that mask
@ -394,6 +381,11 @@ EmacsFrameRealize (Widget widget, XtValueMask *mask, XSetWindowAttributes *attrs
/* Some ConfigureNotify events does not end up in EmacsFrameResize so
make sure we get them all. Seen with xfcwm4 for example. */
XtAddRawEventHandler (widget, StructureNotifyMask, False, resize_cb, NULL);
if (CONSP (frame_size_history))
frame_size_history_plain
(f, build_string ("EmacsFrameRealize"));
update_wm_hints (ew);
}
@ -408,18 +400,15 @@ EmacsFrameResize (Widget widget)
{
EmacsFrame ew = (EmacsFrame) widget;
struct frame *f = ew->emacs_frame.frame;
int width, height;
pixel_to_text_size (ew, ew->core.width, ew->core.height, &width, &height);
if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("EmacsFrameResize"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
ew->core.width, ew->core.height,
f->new_width, f->new_height);
frame_size_history_add
(f, QEmacsFrameResize, width, height,
list5 (make_fixnum (ew->core.width), make_fixnum (ew->core.height),
make_fixnum (FRAME_TOP_MARGIN_HEIGHT (f)),
make_fixnum (FRAME_SCROLL_BAR_AREA_HEIGHT (f)),
make_fixnum (2 * FRAME_INTERNAL_BORDER_WIDTH (f))));
change_frame_size (f, width, height, 0, 1, 0, 1);
change_frame_size (f, ew->core.width, ew->core.height, false, true, false);
update_wm_hints (ew);
update_various_frame_slots (ew);
@ -463,9 +452,17 @@ EmacsFrameSetCharSize (Widget widget, int columns, int rows)
EmacsFrame ew = (EmacsFrame) widget;
struct frame *f = ew->emacs_frame.frame;
if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("EmacsFrameSetCharSize"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
columns, rows,
f->new_width, f->new_height);
if (!frame_inhibit_resize (f, 0, Qfont)
&& !frame_inhibit_resize (f, 1, Qfont))
x_set_window_size (f, 0, columns, rows, 0);
x_set_window_size (f, 0, columns * FRAME_COLUMN_WIDTH (f),
rows * FRAME_LINE_HEIGHT (f));
}

29
src/xdisp.c
View file

@ -11860,7 +11860,7 @@ resize_mini_window (struct window *w, bool exact_p)
int height, max_height;
struct text_pos start;
struct buffer *old_current_buffer = NULL;
int windows_height = FRAME_WINDOWS_HEIGHT (f);
int windows_height = FRAME_INNER_HEIGHT (f);
if (current_buffer != XBUFFER (w->contents))
{
@ -13477,8 +13477,6 @@ PIXELWISE non-nil means return the height of the tab bar in pixels. */)
static bool
redisplay_tab_bar (struct frame *f)
{
f->tab_bar_redisplayed = true;
struct window *w;
struct it it;
struct glyph_row *row;
@ -13492,6 +13490,8 @@ redisplay_tab_bar (struct frame *f)
WINDOW_TOTAL_LINES (w) == 0))
return false;
f->tab_bar_redisplayed = true;
/* Set up an iterator for the tab-bar window. */
init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TAB_BAR_FACE_ID);
it.first_visible_x = 0;
@ -14402,21 +14402,13 @@ PIXELWISE non-nil means return the height of the tool bar in pixels. */)
return make_fixnum (height);
}
#ifndef HAVE_EXT_TOOL_BAR
/* Display the tool-bar of frame F. Value is true if tool-bar's
height should be changed. */
/* Display the internal tool-bar of frame F. Value is true if
tool-bar's height should be changed. */
static bool
redisplay_tool_bar (struct frame *f)
{
f->tool_bar_redisplayed = true;
#ifdef HAVE_EXT_TOOL_BAR
if (FRAME_EXTERNAL_TOOL_BAR (f))
update_frame_tool_bar (f);
return false;
#else /* ! (HAVE_EXT_TOOL_BAR) */
struct window *w;
struct it it;
struct glyph_row *row;
@ -14430,6 +14422,8 @@ redisplay_tool_bar (struct frame *f)
WINDOW_TOTAL_LINES (w) == 0))
return false;
f->tool_bar_redisplayed = true;
/* Set up an iterator for the tool-bar window. */
init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
it.first_visible_x = 0;
@ -14565,13 +14559,10 @@ redisplay_tool_bar (struct frame *f)
}
f->minimize_tool_bar_window_p = false;
return false;
#endif /* HAVE_EXT_TOOL_BAR */
}
#ifndef HAVE_EXT_TOOL_BAR
/* Get information about the tool-bar item which is displayed in GLYPH
on frame F. Return in *PROP_IDX the index where tool-bar item
properties start in F->tool_bar_items. Value is false if
@ -19334,7 +19325,7 @@ redisplay_window (Lisp_Object window, bool just_this_one_p)
#ifdef HAVE_EXT_TOOL_BAR
if (FRAME_EXTERNAL_TOOL_BAR (f))
redisplay_tool_bar (f);
update_frame_tool_bar (f);
#else
if (WINDOWP (f->tool_bar_window)
&& (FRAME_TOOL_BAR_LINES (f) > 0

127
src/xfns.c
View file

@ -1563,7 +1563,6 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
#else /* not USE_X_TOOLKIT && not USE_GTK */
FRAME_MENU_BAR_LINES (f) = nlines;
FRAME_MENU_BAR_HEIGHT (f) = nlines * FRAME_LINE_HEIGHT (f);
adjust_frame_size (f, -1, -1, 2, true, Qx_set_menu_bar_lines);
if (FRAME_X_WINDOW (f))
x_clear_under_internal_border (f);
@ -1577,6 +1576,8 @@ x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
int width = FRAME_PIXEL_WIDTH (f);
int y;
adjust_frame_size (f, -1, -1, 3, true, Qmenu_bar_lines);
/* height can be zero here. */
if (FRAME_X_WINDOW (f) && height > 0 && width > 0)
{
@ -1637,7 +1638,7 @@ x_change_tab_bar_height (struct frame *f, int height)
int unit = FRAME_LINE_HEIGHT (f);
int old_height = FRAME_TAB_BAR_HEIGHT (f);
int lines = (height + unit - 1) / unit;
Lisp_Object fullscreen;
Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
/* Make sure we redisplay all windows in this frame. */
fset_redisplay (f);
@ -1645,16 +1646,8 @@ x_change_tab_bar_height (struct frame *f, int height)
/* Recalculate tab bar and frame text sizes. */
FRAME_TAB_BAR_HEIGHT (f) = height;
FRAME_TAB_BAR_LINES (f) = lines;
/* Store the `tab-bar-lines' and `height' frame parameters. */
store_frame_param (f, Qtab_bar_lines, make_fixnum (lines));
store_frame_param (f, Qheight, make_fixnum (FRAME_LINES (f)));
/* We also have to make sure that the internal border at the top of
the frame, below the menu bar or tab bar, is redrawn when the
tab bar disappears. This is so because the internal border is
below the tab bar if one is displayed, but is below the menu bar
if there isn't a tab bar. The tab bar draws into the area
below the menu bar. */
if (FRAME_X_WINDOW (f) && FRAME_TAB_BAR_HEIGHT (f) == 0)
{
clear_frame (f);
@ -1664,25 +1657,21 @@ x_change_tab_bar_height (struct frame *f, int height)
if ((height < old_height) && WINDOWP (f->tab_bar_window))
clear_glyph_matrix (XWINDOW (f->tab_bar_window)->current_matrix);
/* Recalculate tabbar height. */
f->n_tab_bar_rows = 0;
if (old_height == 0
&& (!f->after_make_frame
|| NILP (frame_inhibit_implied_resize)
|| (CONSP (frame_inhibit_implied_resize)
&& NILP (Fmemq (Qtab_bar_lines, frame_inhibit_implied_resize)))))
f->tab_bar_redisplayed = f->tab_bar_resized = false;
if (!f->tab_bar_resized)
{
/* As long as tab_bar_resized is false, effectively try to change
F's native height. */
if (NILP (fullscreen) || EQ (fullscreen, Qfullwidth))
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f),
1, false, Qtab_bar_lines);
else
adjust_frame_size (f, -1, -1, 4, false, Qtab_bar_lines);
adjust_frame_size (f, -1, -1,
((!f->tab_bar_resized
&& (NILP (fullscreen =
get_frame_param (f, Qfullscreen))
|| EQ (fullscreen, Qfullwidth))) ? 1
: (old_height == 0 || height == 0) ? 2
: 4),
false, Qtab_bar_lines);
f->tab_bar_resized = f->tab_bar_redisplayed;
f->tab_bar_resized = f->tab_bar_redisplayed;
}
else
/* Any other change may leave the native size of F alone. */
adjust_frame_size (f, -1, -1, 3, false, Qtab_bar_lines);
/* adjust_frame_size might not have done anything, garbage frame
here. */
@ -1743,24 +1732,15 @@ x_change_tool_bar_height (struct frame *f, int height)
int unit = FRAME_LINE_HEIGHT (f);
int old_height = FRAME_TOOL_BAR_HEIGHT (f);
int lines = (height + unit - 1) / unit;
Lisp_Object fullscreen;
Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
/* Make sure we redisplay all windows in this frame. */
fset_redisplay (f);
/* Recalculate tool bar and frame text sizes. */
FRAME_TOOL_BAR_HEIGHT (f) = height;
FRAME_TOOL_BAR_LINES (f) = lines;
/* Store the `tool-bar-lines' and `height' frame parameters. */
store_frame_param (f, Qtool_bar_lines, make_fixnum (lines));
store_frame_param (f, Qheight, make_fixnum (FRAME_LINES (f)));
/* We also have to make sure that the internal border at the top of
the frame, below the menu bar or tool bar, is redrawn when the
tool bar disappears. This is so because the internal border is
below the tool bar if one is displayed, but is below the menu bar
if there isn't a tool bar. The tool bar draws into the area
below the menu bar. */
if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_HEIGHT (f) == 0)
{
clear_frame (f);
@ -1770,25 +1750,21 @@ x_change_tool_bar_height (struct frame *f, int height)
if ((height < old_height) && WINDOWP (f->tool_bar_window))
clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
/* Recalculate toolbar height. */
f->n_tool_bar_rows = 0;
if (old_height == 0
&& (!f->after_make_frame
|| NILP (frame_inhibit_implied_resize)
|| (CONSP (frame_inhibit_implied_resize)
&& NILP (Fmemq (Qtool_bar_lines, frame_inhibit_implied_resize)))))
f->tool_bar_redisplayed = f->tool_bar_resized = false;
if (!f->tool_bar_resized)
{
/* As long as tool_bar_resized is false, effectively try to change
F's native height. */
if (NILP (fullscreen) || EQ (fullscreen, Qfullwidth))
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f),
1, false, Qtool_bar_lines);
else
adjust_frame_size (f, -1, -1, 4, false, Qtool_bar_lines);
adjust_frame_size (f, -1, -1,
((!f->tool_bar_resized
&& (NILP (fullscreen =
get_frame_param (f, Qfullscreen))
|| EQ (fullscreen, Qfullwidth))) ? 1
: (old_height == 0 || height == 0) ? 2
: 4),
false, Qtool_bar_lines);
f->tool_bar_resized = f->tool_bar_redisplayed;
f->tool_bar_resized = f->tool_bar_redisplayed;
}
else
/* Any other change may leave the native size of F alone. */
adjust_frame_size (f, -1, -1, 3, false, Qtool_bar_lines);
/* adjust_frame_size might not have done anything, garbage frame
here. */
@ -3687,7 +3663,6 @@ This function is an internal primitive--use `make-frame' instead. */)
struct x_display_info *dpyinfo = NULL;
Lisp_Object parent, parent_frame;
struct kboard *kb;
int x_width = 0, x_height = 0;
parms = Fcopy_alist (parms);
@ -3999,18 +3974,6 @@ This function is an internal primitive--use `make-frame' instead. */)
init_iterator with a null face cache, which should not happen. */
init_frame_faces (f);
/* We have to call adjust_frame_size here since otherwise
x_set_tool_bar_lines will already work with the character sizes
installed by init_frame_faces while the frame's pixel size is still
calculated from a character size of 1 and we subsequently hit the
(height >= 0) assertion in window_box_height.
The non-pixelwise code apparently worked around this because it
had one frame line vs one toolbar line which left us with a zero
root window height which was obviously wrong as well ...
Also process `min-width' and `min-height' parameters right here
because `frame-windows-min-size' needs them. */
tem = gui_display_get_arg (dpyinfo, parms, Qmin_width, NULL, NULL,
RES_TYPE_NUMBER);
if (FIXNUMP (tem))
@ -4019,6 +3982,7 @@ This function is an internal primitive--use `make-frame' instead. */)
RES_TYPE_NUMBER);
if (FIXNUMP (tem))
store_frame_param (f, Qmin_height, tem);
adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 5, true,
Qx_create_frame_1);
@ -4055,8 +4019,7 @@ This function is an internal primitive--use `make-frame' instead. */)
RES_TYPE_BOOLEAN);
/* Compute the size of the X window. */
window_prompting = gui_figure_window_size (f, parms, true, true,
&x_width, &x_height);
window_prompting = gui_figure_window_size (f, parms, true, true);
tem = gui_display_get_arg (dpyinfo, parms, Qunsplittable, 0, 0,
RES_TYPE_BOOLEAN);
@ -4140,11 +4103,6 @@ This function is an internal primitive--use `make-frame' instead. */)
/* Consider frame official, now. */
f->can_set_window_size = true;
if (x_width > 0)
SET_FRAME_WIDTH (f, x_width);
if (x_height > 0)
SET_FRAME_HEIGHT (f, x_height);
/* Tell the server what size and position, etc, we want, and how
badly we want them. This should be done after we have the menu
bar so that its size can be taken into account. */
@ -6291,10 +6249,8 @@ x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms)
struct frame *f;
Lisp_Object frame;
Lisp_Object name;
int width, height;
ptrdiff_t count = SPECPDL_INDEX ();
bool face_change_before = face_change;
int x_width = 0, x_height = 0;
if (!dpyinfo->terminal->name)
error ("Terminal is not live, can't create new frames on it");
@ -6418,7 +6374,7 @@ x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms)
gui_default_parameter (f, parms, Qborder_width, make_fixnum (0),
"borderWidth", "BorderWidth", RES_TYPE_NUMBER);
/* This defaults to 2 in order to match xterm. We recognize either
/* This defaults to 1 in order to match xterm. We recognize either
internalBorderWidth or internalBorder (which is what xterm calls
it). */
if (NILP (Fassq (Qinternal_border_width, parms)))
@ -6466,7 +6422,7 @@ x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms)
"inhibitDoubleBuffering", "InhibitDoubleBuffering",
RES_TYPE_BOOLEAN);
gui_figure_window_size (f, parms, false, false, &x_width, &x_height);
gui_figure_window_size (f, parms, false, false);
{
XSetWindowAttributes attrs;
@ -6518,15 +6474,6 @@ x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms)
gui_default_parameter (f, parms, Qalpha, Qnil,
"alpha", "Alpha", RES_TYPE_NUMBER);
/* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
Change will not be effected unless different from the current
FRAME_LINES (f). */
width = FRAME_COLS (f);
height = FRAME_LINES (f);
SET_FRAME_COLS (f, 0);
SET_FRAME_LINES (f, 0);
change_frame_size (f, width, height, true, false, false, false);
/* Add `tooltip' frame parameter's default value. */
if (NILP (Fframe_parameter (frame, Qtooltip)))
{
@ -6588,6 +6535,8 @@ x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms)
visible won't work. */
Vframe_list = Fcons (frame, Vframe_list);
f->can_set_window_size = true;
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f),
0, true, Qtip_frame);
/* Setting attributes of faces of the tooltip frame from resources
and similar will set face_change, which leads to the clearing of

32
src/xmenu.c
View file

@ -641,7 +641,7 @@ update_frame_menubar (struct frame *f)
lw_refigure_widget (x->column_widget, True);
/* Force the pane widget to resize itself. */
adjust_frame_size (f, -1, -1, 2, false, Qupdate_frame_menubar);
adjust_frame_size (f, -1, -1, 2, false, Qmenu_bar_lines);
unblock_input ();
#endif /* USE_GTK */
}
@ -1044,6 +1044,7 @@ free_frame_menubar (struct frame *f)
/* Motif automatically shrinks the frame in lw_destroy_all_widgets.
If we want to preserve the old height, calculate it now so we can
restore it below. */
int old_width = FRAME_TEXT_WIDTH (f);
int old_height = FRAME_TEXT_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f);
#endif
@ -1077,26 +1078,43 @@ free_frame_menubar (struct frame *f)
lw_destroy_all_widgets ((LWLIB_ID) f->output_data.x->id);
f->output_data.x->menubar_widget = NULL;
/* When double-buffering is enabled and the frame shall not be
resized either because resizing is inhibited or the frame is
fullheight, some (usually harmless) display artifacts like a
doubled mode line may show up. Sometimes the configuration
gets messed up in a more serious fashion though and you may
have to resize the frame to get it back in a normal state. */
if (f->output_data.x->widget)
{
#ifdef USE_MOTIF
XtVaGetValues (f->output_data.x->widget, XtNx, &x1, XtNy, &y1, NULL);
if (x1 == 0 && y1 == 0)
XtVaSetValues (f->output_data.x->widget, XtNx, x0, XtNy, y0, NULL);
if (frame_inhibit_resize (f, false, Qmenu_bar_lines))
adjust_frame_size (f, -1, old_height, 1, false, Qfree_frame_menubar_1);
/* When resizing is inhibited and a normal Motif frame is not
fullheight, we have to explicitly request its old sizes
here since otherwise turning off the menu bar will shrink
the frame but turning them on again will not resize it
back. For a fullheight frame we let the window manager
deal with this problem. */
if (frame_inhibit_resize (f, false, Qmenu_bar_lines)
&& !EQ (get_frame_param (f, Qfullscreen), Qfullheight))
adjust_frame_size (f, old_width, old_height, 1, false,
Qmenu_bar_lines);
else
adjust_frame_size (f, -1, -1, 2, false, Qfree_frame_menubar_1);
adjust_frame_size (f, -1, -1, 2, false, Qmenu_bar_lines);
#else
adjust_frame_size (f, -1, -1, 2, false, Qfree_frame_menubar_1);
adjust_frame_size (f, -1, -1, 2, false, Qmenu_bar_lines);
#endif /* USE_MOTIF */
}
else
{
#ifdef USE_MOTIF
if (WINDOWP (FRAME_ROOT_WINDOW (f))
&& frame_inhibit_resize (f, false, Qmenu_bar_lines))
adjust_frame_size (f, -1, old_height, 1, false, Qfree_frame_menubar_2);
/* See comment above. */
&& frame_inhibit_resize (f, false, Qmenu_bar_lines)
&& !EQ (get_frame_param (f, Qfullscreen), Qfullheight))
adjust_frame_size (f, old_width, old_height, 1, false,
Qmenu_bar_lines);
#endif
}

258
src/xterm.c
View file

@ -7833,10 +7833,6 @@ x_net_wm_state (struct frame *f, Window window)
break;
}
frame_size_history_add
(f, Qx_net_wm_state, 0, 0,
list2 (get_frame_param (f, Qfullscreen), lval));
store_frame_param (f, Qfullscreen, lval);
/** store_frame_param (f, Qsticky, sticky ? Qt : Qnil); **/
}
@ -8167,19 +8163,29 @@ handle_one_xevent (struct x_display_info *dpyinfo,
if (f && event->xproperty.atom == dpyinfo->Xatom_net_wm_state)
{
bool not_hidden = x_handle_net_wm_state (f, &event->xproperty);
if (not_hidden && FRAME_ICONIFIED_P (f))
{
if (CONSP (frame_size_history))
frame_size_history_plain
(f, build_string ("PropertyNotify, not hidden & iconified"));
/* Gnome shell does not iconify us when C-z is pressed.
It hides the frame. So if our state says we aren't
hidden anymore, treat it as deiconified. */
SET_FRAME_VISIBLE (f, 1);
SET_FRAME_ICONIFIED (f, false);
f->output_data.x->has_been_visible = true;
inev.ie.kind = DEICONIFY_EVENT;
XSETFRAME (inev.ie.frame_or_window, f);
}
else if (! not_hidden && ! FRAME_ICONIFIED_P (f))
else if (!not_hidden && !FRAME_ICONIFIED_P (f))
{
if (CONSP (frame_size_history))
frame_size_history_plain
(f, build_string ("PropertyNotify, hidden & not iconified"));
SET_FRAME_VISIBLE (f, 0);
SET_FRAME_ICONIFIED (f, true);
inev.ie.kind = ICONIFY_EVENT;
@ -8357,10 +8363,17 @@ handle_one_xevent (struct x_display_info *dpyinfo,
and that way, we know the window is not iconified now. */
if (visible || FRAME_ICONIFIED_P (f))
{
if (CONSP (frame_size_history))
frame_size_history_plain
(f, build_string ("UnmapNotify, visible | iconified"));
SET_FRAME_ICONIFIED (f, true);
inev.ie.kind = ICONIFY_EVENT;
inev.ie.kind = ICONIFY_EVENT;
XSETFRAME (inev.ie.frame_or_window, f);
}
else if (CONSP (frame_size_history))
frame_size_history_plain
(f, build_string ("UnmapNotify, not visible & not iconified"));
}
goto OTHER;
@ -8372,8 +8385,24 @@ handle_one_xevent (struct x_display_info *dpyinfo,
if (f)
{
bool iconified = FRAME_ICONIFIED_P (f);
int value;
bool sticky;
bool not_hidden = x_get_current_wm_state (f, event->xmap.window, &value, &sticky);
/* Check if fullscreen was specified before we where mapped the
if (CONSP (frame_size_history))
frame_size_history_extra
(f,
iconified
? (not_hidden
? build_string ("MapNotify, not hidden & iconified")
: build_string ("MapNotify, hidden & iconified"))
: (not_hidden
? build_string ("MapNotify, not hidden & not iconified")
: build_string ("MapNotify, hidden & not iconified")),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
-1, -1, f->new_width, f->new_height);
/* Check if fullscreen was specified before we where mapped the
first time, i.e. from the command line. */
if (!f->output_data.x->has_been_visible)
{
@ -8974,7 +9003,16 @@ handle_one_xevent (struct x_display_info *dpyinfo,
|| !(configureEvent.xconfigure.width <= 1
&& configureEvent.xconfigure.height <= 1)))
{
block_input ();
if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("ConfigureNotify"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
configureEvent.xconfigure.width,
configureEvent.xconfigure.height,
f->new_width, f->new_height);
block_input ();
if (FRAME_X_DOUBLE_BUFFERED_P (f))
font_drop_xrender_surfaces (f);
unblock_input ();
@ -9015,24 +9053,28 @@ handle_one_xevent (struct x_display_info *dpyinfo,
#ifndef USE_X_TOOLKIT
#ifndef USE_GTK
int width =
FRAME_PIXEL_TO_TEXT_WIDTH (f, configureEvent.xconfigure.width);
int height =
FRAME_PIXEL_TO_TEXT_HEIGHT (f, configureEvent.xconfigure.height);
int width = configureEvent.xconfigure.width;
int height = configureEvent.xconfigure.height;
/* In the toolkit version, change_frame_size
if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("ConfigureNotify"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
width, height, f->new_width, f->new_height);
/* In the toolkit version, change_frame_size
is called by the code that handles resizing
of the EmacsFrame widget. */
/* Even if the number of character rows and columns has
not changed, the font size may have changed, so we need
to check the pixel dimensions as well. */
if (width != FRAME_TEXT_WIDTH (f)
|| height != FRAME_TEXT_HEIGHT (f)
|| configureEvent.xconfigure.width != FRAME_PIXEL_WIDTH (f)
|| configureEvent.xconfigure.height != FRAME_PIXEL_HEIGHT (f))
if (width != FRAME_PIXEL_WIDTH (f)
|| height != FRAME_PIXEL_HEIGHT (f)
|| (delayed_size_change
&& (width != f->new_width || height != f->new_height)))
{
change_frame_size (f, width, height, false, true, false, true);
change_frame_size (f, width, height, false, true, false);
x_clear_under_internal_border (f);
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
@ -10217,11 +10259,6 @@ x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
{
struct font *font = XFONT_OBJECT (font_object);
int unit, font_ascent, font_descent;
#ifndef USE_X_TOOLKIT
int old_menu_bar_height = FRAME_MENU_BAR_HEIGHT (f);
int old_tab_bar_height = FRAME_TAB_BAR_HEIGHT (f);
Lisp_Object fullscreen;
#endif
if (fontset < 0)
fontset = fontset_from_font (font_object);
@ -10239,8 +10276,9 @@ x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
#ifndef USE_X_TOOLKIT
FRAME_MENU_BAR_HEIGHT (f) = FRAME_MENU_BAR_LINES (f) * FRAME_LINE_HEIGHT (f);
FRAME_TAB_BAR_HEIGHT (f) = FRAME_TAB_BAR_LINES (f) * FRAME_LINE_HEIGHT (f);
#endif
/* We could use a more elaborate calculation here. */
FRAME_TAB_BAR_HEIGHT (f) = FRAME_TAB_BAR_LINES (f) * FRAME_LINE_HEIGHT (f);
/* Compute character columns occupied by scrollbar.
@ -10253,34 +10291,14 @@ x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
else
FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + unit - 1) / unit;
if (FRAME_X_WINDOW (f) != 0)
{
/* Don't change the size of a tip frame; there's no point in
doing it because it's done in Fx_show_tip, and it leads to
problems because the tip frame has no widget. */
if (!FRAME_TOOLTIP_P (f))
{
adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 3,
false, Qfont);
#ifndef USE_X_TOOLKIT
if ((FRAME_MENU_BAR_HEIGHT (f) != old_menu_bar_height
|| FRAME_TAB_BAR_HEIGHT (f) != old_tab_bar_height)
&& !f->after_make_frame
&& (EQ (frame_inhibit_implied_resize, Qt)
|| (CONSP (frame_inhibit_implied_resize)
&& NILP (Fmemq (Qfont, frame_inhibit_implied_resize))))
&& (NILP (fullscreen = get_frame_param (f, Qfullscreen))
|| EQ (fullscreen, Qfullwidth)))
/* If the menu/tab bar height changes, try to keep text height
constant. */
adjust_frame_size
(f, -1, FRAME_TEXT_HEIGHT (f) + FRAME_MENU_BAR_HEIGHT (f)
+ FRAME_TAB_BAR_HEIGHT (f)
- old_menu_bar_height - old_tab_bar_height, 1, false, Qfont);
#endif /* USE_X_TOOLKIT */
}
}
/* Don't change the size of a tip frame; there's no point in doing it
because it's done in Fx_show_tip, and it leads to problems because
the tip frame has no widget. */
if (FRAME_X_WINDOW (f) != 0 && !FRAME_TOOLTIP_P (f))
adjust_frame_size
(f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 3, false, Qfont);
#ifdef HAVE_X_I18N
if (FRAME_XIC (f)
@ -11164,10 +11182,6 @@ x_handle_net_wm_state (struct frame *f, const XPropertyEvent *event)
break;
}
frame_size_history_add
(f, Qx_handle_net_wm_state, 0, 0,
list2 (get_frame_param (f, Qfullscreen), lval));
store_frame_param (f, Qfullscreen, lval);
store_frame_param (f, Qsticky, sticky ? Qt : Qnil);
@ -11222,9 +11236,6 @@ x_check_fullscreen (struct frame *f)
emacs_abort ();
}
frame_size_history_add
(f, Qx_check_fullscreen, width, height, Qnil);
x_wm_set_size_hint (f, 0, false);
XResizeWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
@ -11234,8 +11245,7 @@ x_check_fullscreen (struct frame *f)
x_wait_for_event (f, ConfigureNotify);
else
{
change_frame_size (f, width, height - FRAME_MENUBAR_HEIGHT (f),
false, true, false, true);
change_frame_size (f, width, height, false, true, false);
x_sync (f);
}
}
@ -11389,57 +11399,12 @@ static void
x_set_window_size_1 (struct frame *f, bool change_gravity,
int width, int height)
{
int pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
int pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
int old_width = FRAME_PIXEL_WIDTH (f);
int old_height = FRAME_PIXEL_HEIGHT (f);
Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
if (change_gravity)
f->win_gravity = NorthWestGravity;
x_wm_set_size_hint (f, 0, false);
/* When the frame is fullheight and we only want to change the width
or it is fullwidth and we only want to change the height we should
be able to preserve the fullscreen property. However, due to the
fact that we have to send a resize request anyway, the window
manager will abolish it. At least the respective size should
remain unchanged but giving the frame back its normal size will
be broken ... */
if (EQ (fullscreen, Qfullwidth) && width == FRAME_TEXT_WIDTH (f))
{
frame_size_history_add
(f, Qx_set_window_size_1, width, height,
list2i (old_height, pixelheight + FRAME_MENUBAR_HEIGHT (f)));
XResizeWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
old_width, pixelheight + FRAME_MENUBAR_HEIGHT (f));
}
else if (EQ (fullscreen, Qfullheight) && height == FRAME_TEXT_HEIGHT (f))
{
frame_size_history_add
(f, Qx_set_window_size_2, width, height,
list2i (old_width, pixelwidth));
XResizeWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
pixelwidth, old_height);
}
else
{
frame_size_history_add
(f, Qx_set_window_size_3, width, height,
list3i (pixelwidth + FRAME_TOOLBAR_WIDTH (f),
(pixelheight + FRAME_TOOLBAR_HEIGHT (f)
+ FRAME_MENUBAR_HEIGHT (f)),
FRAME_MENUBAR_HEIGHT (f)));
XResizeWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
pixelwidth, pixelheight + FRAME_MENUBAR_HEIGHT (f));
fullscreen = Qnil;
}
XResizeWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
width, height + FRAME_MENUBAR_HEIGHT (f));
/* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
receive in the ConfigureNotify event; if we get what we asked
@ -11468,66 +11433,42 @@ x_set_window_size_1 (struct frame *f, bool change_gravity,
{
x_wait_for_event (f, ConfigureNotify);
if (!NILP (fullscreen))
/* Try to restore fullscreen state. */
{
store_frame_param (f, Qfullscreen, fullscreen);
gui_set_fullscreen (f, fullscreen, fullscreen);
}
if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("x_set_window_size_1, visible"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f), width, height,
f->new_width, f->new_height);
}
else
{
change_frame_size (f, width, height, false, true, false, true);
if (CONSP (frame_size_history))
frame_size_history_extra
(f, build_string ("x_set_window_size_1, invisible"),
FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f), width, height,
f->new_width, f->new_height);
/* Call adjust_frame_size right away as with GTK. It might be
tempting to clear out f->new_width and f->new_height here. */
adjust_frame_size (f, FRAME_PIXEL_TO_TEXT_WIDTH (f, width),
FRAME_PIXEL_TO_TEXT_HEIGHT (f, height),
5, 0, Qx_set_window_size_1);
x_sync (f);
}
}
/* Call this to change the size of frame F's x-window.
If CHANGE_GRAVITY, change to top-left-corner window gravity
for this size change and subsequent size changes.
Otherwise we leave the window gravity unchanged. */
/* Change the size of frame F's X window to WIDTH and HEIGHT pixels. If
CHANGE_GRAVITY, change to top-left-corner window gravity for this
size change and subsequent size changes. Otherwise we leave the
window gravity unchanged. */
void
x_set_window_size (struct frame *f, bool change_gravity,
int width, int height, bool pixelwise)
int width, int height)
{
block_input ();
/* The following breaks our calculations. If it's really needed,
think of something else. */
#if false
if (!FRAME_TOOLTIP_P (f))
{
int text_width, text_height;
/* When the frame is maximized/fullscreen or running under for
example Xmonad, x_set_window_size_1 will be a no-op.
In that case, the right thing to do is extend rows/width to
the current frame size. We do that first if x_set_window_size_1
turns out to not be a no-op (there is no way to know).
The size will be adjusted again if the frame gets a
ConfigureNotify event as a result of x_set_window_size. */
int pixelh = FRAME_PIXEL_HEIGHT (f);
#ifdef USE_X_TOOLKIT
/* The menu bar is not part of text lines. The tool bar
is however. */
pixelh -= FRAME_MENUBAR_HEIGHT (f);
#endif
text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, FRAME_PIXEL_WIDTH (f));
text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelh);
change_frame_size (f, text_width, text_height, false, true, false, true);
}
#endif
/* Pixelize width and height, if necessary. */
if (! pixelwise)
{
width = width * FRAME_COLUMN_WIDTH (f);
height = height * FRAME_LINE_HEIGHT (f);
}
#ifdef USE_GTK
if (FRAME_GTK_WIDGET (f))
xg_frame_set_char_size (f, width, height);
@ -11880,6 +11821,11 @@ x_make_frame_visible (struct frame *f)
poll_for_input_1 ();
poll_suppress_count = old_poll_suppress_count;
#endif
if (CONSP (frame_size_history))
frame_size_history_plain
(f, build_string ("x_make_frame_visible"));
if (! FRAME_VISIBLE_P (f))
x_wait_for_event (f, MapNotify);
}
@ -11937,6 +11883,10 @@ x_make_frame_invisible (struct frame *f)
SET_FRAME_VISIBLE (f, 0);
SET_FRAME_ICONIFIED (f, false);
if (CONSP (frame_size_history))
frame_size_history_plain
(f, build_string ("x_make_frame_invisible"));
unblock_input ();
}

2
src/xterm.h
View file

@ -1079,7 +1079,7 @@ extern bool x_had_errors_p (Display *);
extern void x_uncatch_errors (void);
extern void x_uncatch_errors_after_check (void);
extern void x_clear_errors (Display *);
extern void x_set_window_size (struct frame *f, bool, int, int, bool);
extern void x_set_window_size (struct frame *f, bool, int, int);
extern void x_make_frame_visible (struct frame *f);
extern void x_make_frame_invisible (struct frame *f);
extern void x_iconify_frame (struct frame *f);