mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2025-12-29 08:31:35 -08:00
Code Issues Projects Releases Wiki Activity

Remove code left dead after 2014-07-27 changes.

Browse source 
* frame.c (frame_inhibit_resize):
* widget.c (EmacsFrameResize):
* window.c (resize_frame_windows, Fset_window_configuration):
* xdisp.c (expose_frame):
* xfns.c (x_change_tool_bar_height):
* xmenu.c (update_frame_menubar):
* xterm.c (handle_one_xevent, x_new_font, x_set_window_size_1):
Remove code left dead after 2014-07-27 changes.
This commit is contained in:
Martin Rudalics 2014-09-25 09:01:35 +02:00
parent 2494447b71
commit 340e4cce7a
8 changed files with 12 additions and 477 deletions
Download patch file Download diff file Expand all files Collapse all files

11
src/ChangeLog
View file

@ -1,3 +1,14 @@
2014-09-25 Martin Rudalics <rudalics@gmx.at>
* frame.c (frame_inhibit_resize):
* widget.c (EmacsFrameResize):
* window.c (resize_frame_windows, Fset_window_configuration):
* xdisp.c (expose_frame):
* xfns.c (x_change_tool_bar_height):
* xmenu.c (update_frame_menubar):
* xterm.c (handle_one_xevent, x_new_font, x_set_window_size_1):
Remove code left dead after 2014-07-27 changes.
2014-09-25 Paul Eggert <eggert@cs.ucla.edu>
Fix local_cons etc. to not exhaust the stack when in a loop.

15
src/frame.c
View file

@ -219,21 +219,6 @@ frame_inhibit_resize (struct frame *f, bool horizontal)
|| FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f));
}
#if 0
bool
frame_inhibit_resize (struct frame *f, bool horizontal)
{
Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
return (frame_inhibit_implied_resize
|| EQ (fullscreen, Qfullboth)
|| EQ (fullscreen, Qfullscreen)
|| EQ (fullscreen, Qmaximized)
|| (horizontal && EQ (fullscreen, Qfullwidth))
|| (!horizontal && EQ (fullscreen, Qfullheight)));
}
#endif
static void
set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
{

9
src/widget.c
View file

@ -579,15 +579,6 @@ EmacsFrameResize (Widget widget)
if (true || frame_resize_pixelwise)
{
int width, height;
/** int width = (ew->core.width **/
/** - FRAME_SCROLL_BAR_AREA_WIDTH (f) **/
/** - FRAME_TOTAL_FRINGE_WIDTH (f) **/
/** - 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
/** int height = (ew->core.height **/
/** - FRAME_TOOLBAR_HEIGHT (f) **/
/** - FRAME_SCROLL_BAR_AREA_HEIGHT (f) **/
/** - 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
pixel_to_text_size (ew, ew->core.width, ew->core.height, &width, &height);
change_frame_size (f, width, height, 0, 1, 0, 1);

416
src/window.c
View file

@ -4163,7 +4163,6 @@ resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
new_pixel_size = max (horflag
? size
: (size
/** - FRAME_TOP_MARGIN_HEIGHT (f) **/
- ((FRAME_HAS_MINIBUF_P (f)
&& !FRAME_MINIBUF_ONLY_P (f))
? FRAME_LINE_HEIGHT (f) : 0)),
@ -4175,7 +4174,6 @@ resize_frame_windows (struct frame *f, int size, bool horflag, bool pixelwise)
new_size = max (horflag
? size
: (size
/** - FRAME_TOP_MARGIN (f) **/
- ((FRAME_HAS_MINIBUF_P (f)
&& !FRAME_MINIBUF_ONLY_P (f))
? 1 : 0)),
@ -6462,420 +6460,6 @@ the return value is nil. Otherwise the value is t. */)
}
#if 0
DEFUN ("set-window-configuration", Fset_window_configuration,
Sset_window_configuration, 1, 1, 0,
doc: /* Set the configuration of windows and buffers as specified by CONFIGURATION.
CONFIGURATION must be a value previously returned
by `current-window-configuration' (which see).
If CONFIGURATION was made from a frame that is now deleted,
only frame-independent values can be restored. In this case,
the return value is nil. Otherwise the value is t. */)
(Lisp_Object configuration)
{
register struct save_window_data *data;
struct Lisp_Vector *saved_windows;
Lisp_Object new_current_buffer;
Lisp_Object frame;
struct frame *f;
ptrdiff_t old_point = -1;
CHECK_WINDOW_CONFIGURATION (configuration);
data = (struct save_window_data *) XVECTOR (configuration);
saved_windows = XVECTOR (data->saved_windows);
new_current_buffer = data->current_buffer;
if (!BUFFER_LIVE_P (XBUFFER (new_current_buffer)))
new_current_buffer = Qnil;
else
{
if (XBUFFER (new_current_buffer) == current_buffer)
/* The code further down "preserves point" by saving here PT in
old_point and then setting it later back into PT. When the
current-selected-window and the final-selected-window both show
the current buffer, this suffers from the problem that the
current PT is the window-point of the current-selected-window,
while the final PT is the point of the final-selected-window, so
this copy from one PT to the other would end up moving the
window-point of the final-selected-window to the window-point of
the current-selected-window. So we have to be careful which
point of the current-buffer we copy into old_point. */
if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer)
&& WINDOWP (selected_window)
&& EQ (XWINDOW (selected_window)->contents, new_current_buffer)
&& !EQ (selected_window, data->current_window))
old_point = marker_position (XWINDOW (data->current_window)->pointm);
else
old_point = PT;
else
/* BUF_PT (XBUFFER (new_current_buffer)) gives us the position of
point in new_current_buffer as of the last time this buffer was
used. This can be non-deterministic since it can be changed by
things like jit-lock by mere temporary selection of some random
window that happens to show this buffer.
So if possible we want this arbitrary choice of "which point" to
be the one from the to-be-selected-window so as to prevent this
window's cursor from being copied from another window. */
if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer)
/* If current_window = selected_window, its point is in BUF_PT. */
&& !EQ (selected_window, data->current_window))
old_point = marker_position (XWINDOW (data->current_window)->pointm);
else
old_point = BUF_PT (XBUFFER (new_current_buffer));
}
frame = XWINDOW (SAVED_WINDOW_N (saved_windows, 0)->window)->frame;
f = XFRAME (frame);
/* If f is a dead frame, don't bother rebuilding its window tree.
However, there is other stuff we should still try to do below. */
if (FRAME_LIVE_P (f))
{
Lisp_Object window;
Lisp_Object dead_windows = Qnil;
register Lisp_Object tem, par, pers;
register struct window *w;
register struct saved_window *p;
struct window *root_window;
struct window **leaf_windows;
int n_leaf_windows;
ptrdiff_t k;
int i, n;
ptrdiff_t count = SPECPDL_INDEX ();
/* If the frame has been resized since this window configuration was
made, we change the frame to the size specified in the
configuration, restore the configuration, and then resize it
back. We keep track of the prevailing height in these variables. */
int previous_frame_text_height = FRAME_TEXT_HEIGHT (f);
int previous_frame_text_width = FRAME_TEXT_WIDTH (f);
/* int previous_frame_menu_bar_height = FRAME_MENU_BAR_HEIGHT (f); */
/* int previous_frame_tool_bar_height = FRAME_TOOL_BAR_HEIGHT (f); */
/* int previous_frame_lines = FRAME_LINES (f); */
/* int previous_frame_cols = FRAME_COLS (f); */
int previous_frame_menu_bar_lines = FRAME_MENU_BAR_LINES (f);
int previous_frame_tool_bar_lines = FRAME_TOOL_BAR_LINES (f);
/* Don't do this within the main loop below: This may call Lisp
code and is thus potentially unsafe while input is blocked. */
for (k = 0; k < saved_windows->header.size; k++)
{
p = SAVED_WINDOW_N (saved_windows, k);
window = p->window;
w = XWINDOW (window);
if (BUFFERP (w->contents)
&& !EQ (w->contents, p->buffer)
&& BUFFER_LIVE_P (XBUFFER (p->buffer)))
/* If a window we restore gets another buffer, record the
window's old buffer. */
call1 (Qrecord_window_buffer, window);
}
/* Consider frame unofficial, temporarily. */
f->official = false;
/* The mouse highlighting code could get screwed up
if it runs during this. */
block_input ();
if (data->frame_text_width != previous_frame_text_width
|| data->frame_text_height != previous_frame_text_height)
/* Make frame size fit the one in data, so window sizes restored
from data match those of the frame. */
adjust_frame_size (f, data->frame_text_width,
data->frame_text_height, 5, 0);
if (data->frame_menu_bar_lines != previous_frame_menu_bar_lines)
{
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
x_set_menu_bar_lines (f, make_number (data->frame_menu_bar_lines),
make_number (0));
else /* TTY or MSDOS */
#endif
set_menu_bar_lines (f, make_number (data->frame_menu_bar_lines),
make_number (0));
}
#ifdef HAVE_WINDOW_SYSTEM
if (data->frame_tool_bar_lines != previous_frame_tool_bar_lines)
x_set_tool_bar_lines (f, make_number (data->frame_tool_bar_lines),
make_number (0));
#endif
/* "Swap out" point from the selected window's buffer
into the window itself. (Normally the pointm of the selected
window holds garbage.) We do this now, before
restoring the window contents, and prevent it from
being done later on when we select a new window. */
if (! NILP (XWINDOW (selected_window)->contents))
{
w = XWINDOW (selected_window);
set_marker_both (w->pointm,
w->contents,
BUF_PT (XBUFFER (w->contents)),
BUF_PT_BYTE (XBUFFER (w->contents)));
}
fset_redisplay (f);
FRAME_WINDOW_SIZES_CHANGED (f) = 1;
/* Problem: Freeing all matrices and later allocating them again
is a serious redisplay flickering problem. What we would
really like to do is to free only those matrices not reused
below. */
root_window = XWINDOW (FRAME_ROOT_WINDOW (f));
leaf_windows = alloca (count_windows (root_window)
* sizeof *leaf_windows);
n_leaf_windows = get_leaf_windows (root_window, leaf_windows, 0);
/* Kludge Alert!
Mark all windows now on frame as "deleted".
Restoring the new configuration "undeletes" any that are in it.
Save their current buffers in their height fields, since we may
need it later, if a buffer saved in the configuration is now
dead. */
delete_all_child_windows (FRAME_ROOT_WINDOW (f));
for (k = 0; k < saved_windows->header.size; k++)
{
p = SAVED_WINDOW_N (saved_windows, k);
window = p->window;
w = XWINDOW (window);
wset_next (w, Qnil);
if (!NILP (p->parent))
wset_parent
(w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->parent))->window);
else
wset_parent (w, Qnil);
if (!NILP (p->prev))
{
wset_prev
(w, SAVED_WINDOW_N (saved_windows, XFASTINT (p->prev))->window);
wset_next (XWINDOW (w->prev), p->window);
}
else
{
wset_prev (w, Qnil);
if (!NILP (w->parent))
wset_combination (XWINDOW (w->parent),
(XINT (p->total_cols)
!= XWINDOW (w->parent)->total_cols),
p->window);
}
/* If we squirreled away the buffer, restore it now. */
if (BUFFERP (w->combination_limit))
wset_buffer (w, w->combination_limit);
w->pixel_left = XFASTINT (p->pixel_left);
w->pixel_top = XFASTINT (p->pixel_top);
w->pixel_width = XFASTINT (p->pixel_width);
w->pixel_height = XFASTINT (p->pixel_height);
w->left_col = XFASTINT (p->left_col);
w->top_line = XFASTINT (p->top_line);
w->total_cols = XFASTINT (p->total_cols);
w->total_lines = XFASTINT (p->total_lines);
wset_normal_cols (w, p->normal_cols);
wset_normal_lines (w, p->normal_lines);
w->hscroll = XFASTINT (p->hscroll);
w->suspend_auto_hscroll = !NILP (p->suspend_auto_hscroll);
w->min_hscroll = XFASTINT (p->min_hscroll);
w->hscroll_whole = XFASTINT (p->hscroll_whole);
wset_display_table (w, p->display_table);
w->left_margin_cols = XINT (p->left_margin_cols);
w->right_margin_cols = XINT (p->right_margin_cols);
w->left_fringe_width = XINT (p->left_fringe_width);
w->right_fringe_width = XINT (p->right_fringe_width);
w->fringes_outside_margins = !NILP (p->fringes_outside_margins);
w->scroll_bar_width = XINT (p->scroll_bar_width);
w->scroll_bar_height = XINT (p->scroll_bar_height);
wset_vertical_scroll_bar_type (w, p->vertical_scroll_bar_type);
wset_horizontal_scroll_bar_type (w, p->horizontal_scroll_bar_type);
wset_dedicated (w, p->dedicated);
wset_combination_limit (w, p->combination_limit);
/* Restore any window parameters that have been saved.
Parameters that have not been saved are left alone. */
for (tem = p->window_parameters; CONSP (tem); tem = XCDR (tem))
{
pers = XCAR (tem);
if (CONSP (pers))
{
if (NILP (XCDR (pers)))
{
par = Fassq (XCAR (pers), w->window_parameters);
if (CONSP (par) && !NILP (XCDR (par)))
/* Reset a parameter to nil if and only if it
has a non-nil association. Don't make new
associations. */
Fsetcdr (par, Qnil);
}
else
/* Always restore a non-nil value. */
Fset_window_parameter (window, XCAR (pers), XCDR (pers));
}
}
if (BUFFERP (p->buffer) && BUFFER_LIVE_P (XBUFFER (p->buffer)))
/* If saved buffer is alive, install it. */
{
wset_buffer (w, p->buffer);
w->start_at_line_beg = !NILP (p->start_at_line_beg);
set_marker_restricted (w->start, p->start, w->contents);
set_marker_restricted (w->pointm, p->pointm, w->contents);
set_marker_restricted (w->old_pointm, p->old_pointm, w->contents);
/* As documented in Fcurrent_window_configuration, don't
restore the location of point in the buffer which was
current when the window configuration was recorded. */
if (!EQ (p->buffer, new_current_buffer)
&& XBUFFER (p->buffer) == current_buffer)
Fgoto_char (w->pointm);
}
else if (BUFFERP (w->contents) && BUFFER_LIVE_P (XBUFFER (w->contents)))
/* Keep window's old buffer; make sure the markers are real. */
{
/* Set window markers at start of visible range. */
if (XMARKER (w->start)->buffer == 0)
set_marker_restricted_both (w->start, w->contents, 0, 0);
if (XMARKER (w->pointm)->buffer == 0)
set_marker_restricted_both
(w->pointm, w->contents,
BUF_PT (XBUFFER (w->contents)),
BUF_PT_BYTE (XBUFFER (w->contents)));
if (XMARKER (w->old_pointm)->buffer == 0)
set_marker_restricted_both
(w->old_pointm, w->contents,
BUF_PT (XBUFFER (w->contents)),
BUF_PT_BYTE (XBUFFER (w->contents)));
w->start_at_line_beg = 1;
}
else if (!NILP (w->start))
/* Leaf window has no live buffer, get one. */
{
/* Get the buffer via other_buffer_safely in order to
avoid showing an unimportant buffer and, if necessary, to
recreate *scratch* in the course (part of Juanma's bs-show
scenario from March 2011). */
wset_buffer (w, other_buffer_safely (Fcurrent_buffer ()));
/* This will set the markers to beginning of visible
range. */
set_marker_restricted_both (w->start, w->contents, 0, 0);
set_marker_restricted_both (w->pointm, w->contents, 0, 0);
set_marker_restricted_both (w->old_pointm, w->contents, 0, 0);
w->start_at_line_beg = 1;
if (!NILP (w->dedicated))
/* Record this window as dead. */
dead_windows = Fcons (window, dead_windows);
/* Make sure window is no more dedicated. */
wset_dedicated (w, Qnil);
}
}
fset_root_window (f, data->root_window);
/* Arrange *not* to restore point in the buffer that was
current when the window configuration was saved. */
if (EQ (XWINDOW (data->current_window)->contents, new_current_buffer))
set_marker_restricted (XWINDOW (data->current_window)->pointm,
make_number (old_point),
XWINDOW (data->current_window)->contents);
/* In the following call to `select-window', prevent "swapping out
point" in the old selected window using the buffer that has
been restored into it. We already swapped out that point from
that window's old buffer.
Do not record the buffer here. We do that in a separate call
to select_window below. See also Bug#16207. */
select_window (data->current_window, Qt, 1);
BVAR (XBUFFER (XWINDOW (selected_window)->contents),
last_selected_window)
= selected_window;
if (NILP (data->focus_frame)
|| (FRAMEP (data->focus_frame)
&& FRAME_LIVE_P (XFRAME (data->focus_frame))))
Fredirect_frame_focus (frame, data->focus_frame);
/* Set the frame size to the value it had before this function. */
if (previous_frame_text_width != FRAME_TEXT_WIDTH (f)
|| previous_frame_text_height != FRAME_TEXT_HEIGHT (f))
adjust_frame_size (f, previous_frame_text_width,
previous_frame_text_height, 5, 0);
if (previous_frame_menu_bar_lines != FRAME_MENU_BAR_LINES (f))
{
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
x_set_menu_bar_lines (f,
make_number (previous_frame_menu_bar_lines),
make_number (0));
else /* TTY or MSDOS */
#endif
set_menu_bar_lines (f, make_number (previous_frame_menu_bar_lines),
make_number (0));
}
#ifdef HAVE_WINDOW_SYSTEM
if (previous_frame_tool_bar_lines != FRAME_TOOL_BAR_LINES (f))
x_set_tool_bar_lines (f, make_number (previous_frame_tool_bar_lines),
make_number (0));
#endif
/* Now, free glyph matrices in windows that were not reused. */
for (i = n = 0; i < n_leaf_windows; ++i)
{
if (NILP (leaf_windows[i]->contents))
free_window_matrices (leaf_windows[i]);
else if (EQ (leaf_windows[i]->contents, new_current_buffer))
++n;
}
/* Make frame official again and apply frame size changes if
needed. */
f->official = true;
adjust_frame_size (f, -1, -1, 1, 0);
adjust_frame_glyphs (f);
unblock_input ();
/* Scan dead buffer windows. */
for (; CONSP (dead_windows); dead_windows = XCDR (dead_windows))
{
window = XCAR (dead_windows);
if (WINDOW_LIVE_P (window) && !EQ (window, FRAME_ROOT_WINDOW (f)))
delete_deletable_window (window);
}
/* Record the selected window's buffer here. The window should
already be the selected one from the call above. */
select_window (data->current_window, Qnil, 0);
/* Fselect_window will have made f the selected frame, so we
reselect the proper frame here. Fhandle_switch_frame will change the
selected window too, but that doesn't make the call to
Fselect_window above totally superfluous; it still sets f's
selected window. */
if (FRAME_LIVE_P (XFRAME (data->selected_frame)))
do_switch_frame (data->selected_frame, 0, 0, Qnil);
run_window_configuration_change_hook (f);
}
if (!NILP (new_current_buffer))
{
Fset_buffer (new_current_buffer);
/* If the new current buffer doesn't appear in the selected
window, go to its old point (see bug#12208). */
if (!EQ (XWINDOW (data->current_window)->contents, new_current_buffer))
Fgoto_char (make_number (old_point));
}
Vminibuf_scroll_window = data->minibuf_scroll_window;
minibuf_selected_window = data->minibuf_selected_window;
return (FRAME_LIVE_P (f) ? Qt : Qnil);
}
#endif
void
restore_window_configuration (Lisp_Object configuration)
{

2
src/xdisp.c
View file

@ -30145,8 +30145,6 @@ expose_frame (struct frame *f, int x, int y, int w, int h)
r.x = r.y = 0;
r.width = FRAME_TEXT_WIDTH (f);
r.height = FRAME_TEXT_HEIGHT (f);
/** r.width = FRAME_COLUMN_WIDTH (f) * FRAME_COLS (f); **/
/** r.height = FRAME_LINE_HEIGHT (f) * FRAME_LINES (f); **/
}
else
{

2
src/xfns.c
View file

@ -1140,10 +1140,8 @@ x_change_tool_bar_height (struct frame *f, int height)
adjust_frame_size (f, -1, -1, 4, 0);
/** #if !defined USE_X_TOOLKIT **/
if (FRAME_X_WINDOW (f))
x_clear_under_internal_border (f);
/** #endif **/
#endif /* USE_GTK */
}

8
src/xmenu.c
View file

@ -627,7 +627,6 @@ update_frame_menubar (struct frame *f)
xg_update_frame_menubar (f);
#else
struct x_output *x;
/** int columns, rows; **/
eassert (FRAME_X_P (f));
@ -637,10 +636,6 @@ update_frame_menubar (struct frame *f)
return;
block_input ();
/* Save the size of the frame because the pane widget doesn't accept
to resize itself. So force it. */
/** columns = FRAME_COLS (f); **/
/** rows = FRAME_LINES (f); **/
/* Do the voodoo which means "I'm changing lots of things, don't try
to refigure sizes until I'm done." */
@ -661,8 +656,7 @@ update_frame_menubar (struct frame *f)
XtManageChild (x->edit_widget);
lw_refigure_widget (x->column_widget, True);
/* Force the pane widget to resize itself with the right values. */
/** EmacsFrameSetCharSize (x->edit_widget, columns, rows); **/
/* Force the pane widget to resize itself. */
adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 2, 0);
unblock_input ();
#endif

26
src/xterm.c
View file

@ -7560,9 +7560,6 @@ handle_one_xevent (struct x_display_info *dpyinfo,
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
}
/** FRAME_PIXEL_WIDTH (f) = event->xconfigure.width; **/
/** FRAME_PIXEL_HEIGHT (f) = event->xconfigure.height; **/
#endif /* not USE_GTK */
#endif
@ -8647,7 +8644,6 @@ x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
FRAME_LINE_HEIGHT (f) = FONT_HEIGHT (font);
#ifndef USE_X_TOOLKIT \
/** FRAME_TOOL_BAR_HEIGHT (f) = FRAME_TOOL_BAR_LINES (f) * FRAME_LINE_HEIGHT (f); **/
FRAME_MENU_BAR_HEIGHT (f) = FRAME_MENU_BAR_LINES (f) * FRAME_LINE_HEIGHT (f);
#endif
@ -9490,18 +9486,6 @@ x_set_window_size_1 (struct frame *f, int change_gravity, int width, int height,
{
int pixelwidth, pixelheight;
/** 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); **/
/** } **/
/** FRAME_TOOL_BAR_HEIGHT (f) = FRAME_TOOLBAR_HEIGHT (f); **/
pixelwidth = (pixelwise
? FRAME_TEXT_TO_PIXEL_WIDTH (f, width)
: FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width));
@ -9509,16 +9493,6 @@ x_set_window_size_1 (struct frame *f, int change_gravity, int width, int height,
? FRAME_TEXT_TO_PIXEL_HEIGHT (f, height)
: FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height)));
/** pixelwidth = ((pixelwise ? width : (width * FRAME_COLUMN_WIDTH (f))) **/
/** + FRAME_SCROLL_BAR_AREA_WIDTH (f) **/
/** + FRAME_TOTAL_FRINGE_WIDTH (f) **/
/** + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
/** pixelheight = ((pixelwise ? height : (height * FRAME_LINE_HEIGHT (f))) **/
/** + FRAME_TOOLBAR_HEIGHT (f) **/
/** + FRAME_SCROLL_BAR_AREA_HEIGHT (f) **/
/** + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
if (change_gravity) f->win_gravity = NorthWestGravity;
x_wm_set_size_hint (f, 0, 0);
XResizeWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),