xemacs-beta: src/frame.c comparison

comparison src/frame.c @ 5052:92dc90c0bb40

merge

author	Ben Wing <ben@xemacs.org>
date	Sat, 20 Feb 2010 23:56:01 -0600
parents	6f2158fa75ed 07dcc7000bbf
children	a04cf0fea770 2a462149bd6a

comparison

equal deleted inserted replaced

-:c3d372419e09
+:92dc90c0bb40
 /* Generic frame functions.
 Copyright (C) 1989, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
-Copyright (C) 1995, 1996, 2002, 2003, 2005 Ben Wing.
+Copyright (C) 1995, 1996, 2002, 2003, 2005, 2010 Ben Wing.
 Copyright (C) 1995 Sun Microsystems, Inc.
 This file is part of XEmacs.
 XEmacs is free software; you can redistribute it and/or modify it
 Boston, MA 02111-1307, USA.  */
 /* Synched up with: FSF 19.30. */
 /* This file has been Mule-ized. */
+/* About window and frame geometry [ben]:
+Here is an ASCII diagram:
++------------------------------------------------------------------------|
+|                         window-manager decoration                      |
+| +--------------------------------------------------------------------+ |
+| |                               menubar                              | |
+| ###################################################################### |
+| #                               toolbar                              # |
+| #--------------------------------------------------------------------# |
+| #  |                            gutter                            |  # |
+| #  |--------------------------------------------------------------|  # |
+| #  | |                  internal border width                   | |  # |
+| #  | | ******************************************************** | |  # |
+|w#  | | *                         |s|v*                      |s* | |  #w|
+|i#  | | *                         |c|e*                      |c* | |  #i|
+|n#  | | *                         |r|r*                      |r* | |  #n|
+|d#  | | *                         |o|t*                      |o* | |  #d|
+|o#  | | *        text area        |l|.*      text area       |l* | |  #o|
+|w#  | |i*                         |l| *                      |l*i| |  #w|
+|-#  | |n*                         |b|d*                      |b*n| |  #-|
+|m#  | |t*                         |a|i*                      |a*t| |  #m|
+|a#  | |.*                         |r|v*                      |r*.| |  #a|
+|n# t| | *-------------------------+-|i*----------------------+-* | |t #n|
+|a# o|g|b*        scrollbar        | |d*      scrollbar       | *b|g|o #a|
+|g# o|u|o*-------------------------+-|e*----------------------+-*o|u|o #g|
+|e# l|t|r*        modeline           |r*      modeline          *r|t|l #e|
+|r# b|t|d********************************************************d|t|b #r|
+| # a|e|e*   =..texttexttex....=   |s|v*                      |s*e|e|a # |
+|d# r|r|r*o m=..texttexttextt..=o m|c|e*                      |c*r|r|r #d|
+|e#  | | *u a=.exttexttextte...=u a|r|r*                      |r* | |  #e|
+|c#  | |w*t r=....texttexttex..=t r|o|t*                      |o*w| |  #c|
+|o#  | |i*s g=        etc.     =s g|l|.*      text area       |l*i| |  #o|
+|r#  | |d*i i=                 =i i|l| *                      |l*d| |  #r|
+|a#  | |t*d n=                 =d n|b|d*                      |b*t| |  #a|
+|t#  | |h*e  = inner text area =e  |a|i*                      |a*h| |  #t|
+|i#  | | *   =                 =   |r|v*                      |r* | |  #i|
+|o#  | | *---===================---+-|i*----------------------+-* | |  #o|
+|n#  | | *        scrollbar        | |d*      scrollbar       | * | |  #n|
+| #  | | *-------------------------+-|e*----------------------+-* | |  # |
+| #  | | *        modeline           |r*      modeline          * | |  # |
+| #  | | ******************************************************** | |  # |
+| #  | | *                        minibuffer                    * | |  # |
+| #  | | ******************************************************** | |  # |
+| #  | |                   internal border width                  | |  # |
+| #  |--------------------------------------------------------------|  # |
+| #  |                             gutter                           |  # |
+| #--------------------------------------------------------------------# |
+| #                                toolbar                             # |
+| ###################################################################### |
+|                          window manager decoration                     |
++------------------------------------------------------------------------+
+# = boundary of client area; * = window boundaries, boundary of paned area
+= = boundary of inner text area; . = inside margin area
+Note in particular what happens at the corners, where a "corner box"
+occurs.  Top and bottom toolbars take precedence over left and right
+toolbars, extending out horizontally into the corner boxes.  Gutters
+work the same way.  The corner box where the scrollbars meet, however,
+is assigned to neither scrollbar, and is known as the "dead box"; it is
+an area that must be cleared specially.
+THE FRAME
+---------
+The "top-level window area" is the entire area of a top-level window (or
+"frame").  The "client area" (a term from MS Windows) is the area of a
+top-level window that XEmacs draws into and manages with redisplay.
+This includes the toolbar, scrollbars, gutters, dividers, text area,
+modeline and minibuffer.  It does not include the menubar, title or
+outer borders.  The "non-client area" is the area of a top-level window
+outside of the client area and includes the menubar, title and outer
+borders.  Internally, all frame coordinates are relative to the client
+area.
+THE NON-CLIENT AREA
+-------------------
+Under X, the non-client area is split into two parts:
+(1) The outer layer is the window-manager decorations: The title and
+borders.  These are controlled by the window manager, a separate process
+that controls the desktop, the location of icons, etc.  When a process
+tries to create a window, the window manager intercepts this action and
+"reparents" the window, placing another window around it which contains
+the window decorations, including the title bar, outer borders used for
+resizing, etc.  The window manager also implements any actions involving
+the decorations, such as the ability to resize a window by dragging its
+borders, move a window by dragging its title bar, etc.  If there is no
+window manager or you kill it, windows will have no decorations (and
+will lose them if they previously had any) and you will not be able to
+move or resize them.
+(2) Inside of the window-manager decorations is the "shell", which is
+managed by the toolkit and widget libraries your program is linked with.
+The code in *-x.c uses the Xt toolkit and various possible widget
+libraries built on top of Xt, such as Motif, Athena, the "Lucid"
+widgets, etc.  Another possibility is GTK (*-gtk.c), which implements
+both the toolkit and widgets.  Under Xt, the "shell" window is an
+EmacsShell widget, containing an EmacsManager widget of the same size,
+which in turn contains a menubar widget and an EmacsFrame widget, inside
+of which is the client area. (The division into EmacsShell and
+EmacsManager is due to the complex and screwy geometry-management system
+in Xt [and X more generally].  The EmacsShell handles negotation with
+the window manager; the place of the EmacsManager widget is normally
+assumed by a widget that manages the geometry of its child widgets, but
+the EmacsManager widget just lets the XEmacs redisplay mechanism do the
+positioning.)
+Under Windows, the non-client area is managed by the window system.
+There is no division such as under X.  Part of the window-system API
+(USER.DLL) of Win32 includes functions to control the menubars, title,
+etc. and implements the move and resize behavior.  There *is* an
+equivalent of the window manager, called the "shell", but it manages
+only the desktop, not the windows themselves.  The normal shell under
+Windows is EXPLORER.EXE; if you kill this, you will lose the bar
+containing the "Start" menu and tray and such, but the windows
+themselves will not be affected or lose their decorations.
+THE CLIENT AREA
+---------------
+Inside of the client area is the toolbars, the gutters (where the buffer
+tabs are displayed), the minibuffer, the internal border width, and one
+or more non-overlapping "windows" (this is old Emacs terminology, from
+before the time when frames existed at all; the standard terminology for
+this would be "pane").  Each window can contain a modeline, horizontal
+and/or vertical scrollbars, and (for non-rightmost windows) a vertical
+divider, surrounding a text area.
+The dimensions of the toolbars and gutters are determined by the formula
+(THICKNESS + 2 * BORDER-THICKNESS), where "thickness" is a cover term
+for height or width, as appropriate.  The height and width come from
+`default-toolbar-height' and `default-toolbar-width' and the specific
+versions of these (`top-toolbar-height', `left-toolbar-width', etc.).
+The border thickness comes from `default-toolbar-border-height' and
+`default-toolbar-border-width', and the specific versions of these.  The
+gutter works exactly equivalently.
+Note that for any particular toolbar or gutter, it will only be
+displayed if [a] its visibility specifier (`default-toolbar-visible-p'
+etc.) is non-nil; [b] its thickness (`default-toolbar-height' etc.)  is
+greater than 0; [c] its contents (`default-toolbar' etc.) are non-nil.
+The position-specific toolbars interact with the default specifications
+as follows: If the value for a position-specific specifier is not
+defined in a particular domain (usually a window), and the position of
+that specifier is set as the default position (using
+`default-toolbar-position'), then the value from the corresponding
+default specifier in that domain will be used.  The gutters work the
+same.
+THE PANED AREA
+--------------
+The area occupied by the "windows" is called the paned area.  Note that
+this includes the minibuffer, which is just another window but is
+special-cased in XEmacs.  Each window can include a horizontal and/or
+vertical scrollbar, a modeline and a vertical divider to its right, as
+well as the text area.  Only non-rightmost windows can include a
+vertical divider. (The minibuffer normally does not include either
+modeline or scrollbars.)
+Note that, because the toolbars and gutters are controlled by
+specifiers, and specifiers can have window-specific and buffer-specific
+values, the size of the paned area can change depending on which window
+is selected: In other words, if the selected window or buffer changes,
+the entire paned area for the frame may change.
+TEXT AREAS, FRINGES, MARGINS
+----------------------------
+The space occupied by a window can be divided into the text area and the
+fringes.  The fringes include the modeline, scrollbars and vertical
+divider on the right side (if any); inside of this is the text area,
+where the text actually occurs.  Note that a window may or may not
+contain any of the elements that are part of the fringe -- this is
+controlled by specifiers, e.g. `has-modeline-p',
+`horizontal-scrollbar-visible-p', `vertical-scrollbar-visible-p',
+`vertical-divider-always-visible-p', etc.
+In addition, it is possible to set margins in the text area using the
+specifiers `left-margin-width' and `right-margin-width'.  When this is
+done, only the "inner text area" (the area inside of the margins) will
+be used for normal display of text; the margins will be used for glyphs
+with a layout policy of `outside-margin' (as set on an extent containing
+the glyph by `set-extent-begin-glyph-layout' or
+`set-extent-end-glyph-layout').  However, the calculation of the text
+area size (e.g. in the function `window-text-area-width') includes the
+margins.  Which margin is used depends on whether a glyph has been set
+as the begin-glyph or end-glyph of an extent (`set-extent-begin-glyph'
+etc.), using the left and right margins, respectively.
+Technically, the margins outside of the inner text area are known as the
+"outside margins".  The "inside margins" are in the inner text area and
+constitute the whitespace between the outside margins and the first or
+last non-whitespace character in a line; their width can vary from line
+to line.  Glyphs will be placed in the inside margin if their layout
+policy is `inside-margin' or `whitespace', with `whitespace' glyphs on
+the inside and `inside-margin' glyphs on the outside.  Inside-margin
+glyphs can spill over into the outside margin if `use-left-overflow' or
+`use-right-overflow', respectively, is non-nil.
+See the Lisp Reference manual, under Annotations, for more details.
+THE DISPLAYABLE AREA
+--------------------
+The "displayable area" is not so much an actual area as a convenient
+fiction.  It is the area used to convert between pixel and character
+dimensions for frames.  The character dimensions for a frame (e.g. as
+returned by `frame-width' and `frame-height' and set by
+`set-frame-width' and `set-frame-height') are determined from the
+displayable area by dividing by the pixel size of the default font as
+instantiated in the frame. (For proportional fonts, the "average" width
+is used.  Under Windows, this is a built-in property of the fonts.
+Under X, this is based on the width of the lowercase 'n', or if this is
+zero then the width of the default character. [We prefer 'n' to the
+specified default character because many X fonts have a default
+character with a zero or otherwise non-representative width.])
+The displayable area is essentially the "theoretical" paned area of the
+frame excluding the rightmost and bottom-most scrollbars.  In this
+context, "theoretical" means that all calculations on based on
+frame-level values for toolbar, gutter and scrollbar thicknesses.
+Because these thicknesses are controlled by specifiers, and specifiers
+can have window-specific and buffer-specific values, these calculations
+may or may not reflect the actual size of the paned area or of the
+scrollbars when any particular window is selected.  Note also that the
+"displayable area" may not even be contiguous!  In particular, if the
+frame-level value of the horizontal scrollbar height is non-zero, then
+the displayable area includes the paned area above and below the bottom
+horizontal scrollbar but not the scrollbar itself.
+As a further twist, the character-dimension calculations are adjusted so
+that the truncation and continuation glyphs (see `truncation-glyph' and
+`continuation-glyph') count as a single character even if they are wider
+than the default font width. (Technically, the character width is
+computed from the displayable-area width by subtracting the maximum of
+the truncation-glyph width, continuation-glyph width and default-font
+width before dividing by the default-font width, and then adding 1 to
+the result.) (The ultimate motivation for this kludge as well as the
+subtraction of the scrollbars, but not the minibuffer or bottom-most
+modeline, is to maintain compatibility with TTY's.)
+Despite all these concerns and kludges, however, the "displayable area"
+concept works well in practice and mostly ensures that by default the
+frame will actually fit 79 characters + continuation/truncation glyph.
+WHICH FUNCTIONS USE WHICH?
+--------------------------
+[1] Top-level window area:
+set-frame-position
+`left' and `top' frame properties
+[2] Client area:
+frame-pixel-*, set-frame-pixel-*
+[3] Paned area:
+window-pixel-edges
+event-x-pixel, event-y-pixel, event-properties, make-event
+[4] Displayable area:
+frame-width, frame-height and other all functions specifying frame size
+in characters
+frame-displayable-pixel-*
+--ben
+*/
 #include <config.h>
 #include "lisp.h"
 #include "buffer.h"             /* for Vbuffer_alist */
 Lisp_Object Vframe_being_created;
 Lisp_Object Qframe_being_created;
 static void store_minibuf_frame_prop (struct frame *f, Lisp_Object val);
-typedef enum  {
+typedef enum
+{
 DISPLAYABLE_PIXEL_TO_CHAR,
+CHAR_TO_DISPLAYABLE_PIXEL,
 TOTAL_PIXEL_TO_CHAR,
 CHAR_TO_TOTAL_PIXEL,
-CHAR_TO_DISPLAYABLE_PIXEL
+TOTAL_PIXEL_TO_DISPLAYABLE_PIXEL,
-} pixel_to_char_mode_t;
+DISPLAYABLE_PIXEL_TO_TOTAL_PIXEL,
+}
+pixel_to_char_mode_t;
+enum frame_size_type
+{
+SIZE_TOTAL_PIXEL,
+SIZE_DISPLAYABLE_PIXEL,
+SIZE_CHAR_CELL,
+SIZE_FRAME_UNIT,
+};
 static void frame_conversion_internal (struct frame *f,
-				       pixel_to_char_mode_t pixel_to_char,
+				       enum frame_size_type source,
-				       int *pixel_width, int *pixel_height,
+				       int source_width, int source_height,
-				       int *char_width, int *char_height,
+				       enum frame_size_type dest,
-				       int real_face);
+				       int *dest_width, int *dest_height);
+static void get_frame_char_size (struct frame *f, int *out_width,
+				 int *out_height);
+static void get_frame_displayable_pixel_size (struct frame *f, int *out_width,
+					      int *out_height);
 static struct display_line title_string_display_line;
 /* Used by generate_title_string. Global because they get used so much that
 the dynamic allocation time adds up. */
 static Ichar_dynarr *title_string_ichar_dynarr;
 	{
 	  reset_face_cachels (XWINDOW (f->minibuffer_window));
 	  reset_glyph_cachels (XWINDOW (f->minibuffer_window));
 	}
-change_frame_size (f, f->height, f->width, 0);
+change_frame_size (f, f->width, f->height, 0);
 }
 MAYBE_FRAMEMETH (f, init_frame_2, (f, props));
 Fset_frame_properties (frame, props);
 MAYBE_FRAMEMETH (f, init_frame_3, (f));
 	 will eventually do. Unfortunately gutter sizing code relies
 	 on the frame in question being visible so we can't do this
 	 earlier. */
 init_frame_gutters (f);
-change_frame_size (f, f->height, f->width, 0);
+change_frame_size (f, f->width, f->height, 0);
 }
 if (first_frame_on_device)
 {
 if (first_frame_on_console)
 }
 if (!keep_char_size)
 {
 int height, width;
-pixel_to_char_size (f, FRAME_PIXWIDTH(f), FRAME_PIXHEIGHT(f),
+pixel_to_frame_unit_size (f, FRAME_PIXWIDTH(f), FRAME_PIXHEIGHT(f),
 			  &width, &height);
-change_frame_size (f, height, width, 0);
+change_frame_size (f, width, height, 0);
 CLEAR_FRAME_SIZE_SLIPPED (f);
 }
 }
 /*
 /***************************************************************************/
 /*                           frame properties                              */
 /***************************************************************************/
-static void internal_set_frame_size (struct frame *f, int cols, int rows,
-				     int pretend);
 static void
 store_minibuf_frame_prop (struct frame *f, Lisp_Object val)
 {
 /* This can call Lisp. */
 if (EQ (Qname, property)) return f->name;
 if (EQ (Qheight, property) || EQ (Qwidth, property))
 {
-if (window_system_pixelated_geometry (frame))
+int width, height;
-	{
+get_frame_char_size (f, &width, &height);
-	  int width, height;
+return make_int (EQ (Qheight, property) ? height : width);
-	  pixel_to_real_char_size (f, FRAME_PIXWIDTH (f), FRAME_PIXHEIGHT (f),
-				   &width, &height);
-	  return make_int (EQ (Qheight, property) ? height: width);
-	}
-else
-	return make_int (EQ (Qheight, property) ?
-			 FRAME_HEIGHT (f) :
-			 FRAME_WIDTH  (f));
 }
 /* NOTE: FSF returns Qnil instead of Qt for FRAME_HAS_MINIBUF_P.
 This is over-the-top bogosity, because it's inconsistent with
 the semantics of `minibuffer' when passed to `make-frame'.
 		   FRAME_HAS_MINIBUF_P  (f) ? Qt    :
 		   FRAME_MINIBUF_WINDOW (f)),
 		  result);
 {
 int width, height;
+get_frame_char_size (f, &width, &height);
-if (window_system_pixelated_geometry (frame))
-{
-	pixel_to_real_char_size (f, FRAME_PIXWIDTH (f), FRAME_PIXHEIGHT (f),
-				 &width, &height);
-}
-else
-{
-	height = FRAME_HEIGHT (f);
-	width = FRAME_WIDTH (f);
-}
 result = cons3 (Qwidth , make_int (width),  result);
 result = cons3 (Qheight, make_int (height), result);
 }
 result = cons3 (Qname, f->name, result);
 Return the height of the displayable area in pixels of FRAME.
 */
 (frame))
 {
 struct frame *f = decode_frame (frame);
-int height, pheight;
+int width, height;
-frame = wrap_frame (f);
+get_frame_displayable_pixel_size (f, &width, &height);
-if (!window_system_pixelated_geometry (frame))
+return make_int (height);
-{
-height = FRAME_HEIGHT (f);
-frame_conversion_internal (f, CHAR_TO_DISPLAYABLE_PIXEL,
-				 0, &pheight, 0, &height, 0);
-}
-else
-pheight = FRAME_PIXHEIGHT (f);
-return make_int (pheight);
 }
 DEFUN ("frame-pixel-width", Fframe_pixel_width, 0, 1, 0, /*
 Return the total width in pixels of FRAME.
 */
 Return the width of the displayable area in pixels of FRAME.
 */
 (frame))
 {
 struct frame *f = decode_frame (frame);
-int width, pwidth;
+int width, height;
-frame = wrap_frame (f);
+get_frame_displayable_pixel_size (f, &width, &height);
-if (!window_system_pixelated_geometry (frame))
+return make_int (width);
-{
-width = FRAME_WIDTH (f);
-frame_conversion_internal (f, CHAR_TO_DISPLAYABLE_PIXEL,
-				 &pwidth, 0, &width, 0, 0);
-}
-else
-pwidth = FRAME_PIXWIDTH (f);
-return make_int (pwidth);
 }
 DEFUN ("frame-name", Fframe_name, 0, 1, 0, /*
 Return the name of FRAME (defaulting to the selected frame).
 This is not the same as the `title' of the frame.
 (frame))
 {
 return make_int (decode_frame (frame)->modiff);
 }
-static void
+void
 internal_set_frame_size (struct frame *f, int cols, int rows, int pretend)
 {
 /* This can call Lisp.  See mswindows_set_frame_size(). */
 /* An explicit size change cancels any pending frame size adjustment */
 CLEAR_FRAME_SIZE_SLIPPED (f);
 if (pretend || !HAS_FRAMEMETH_P (f, set_frame_size))
-change_frame_size (f, rows, cols, 0);
+change_frame_size (f, cols, rows, 0);
 else
 FRAMEMETH (f, set_frame_size, (f, cols, rows));
 }
 DEFUN ("set-frame-height", Fset_frame_height, 2, 3, 0, /*
 */
 (frame, lines, pretend))
 {
 /* This can call Lisp. */
 struct frame *f = decode_frame (frame);
-int height, width;
+int cwidth, cheight;
-frame = wrap_frame (f);
+int guwidth, guheight;
 CHECK_INT (lines);
+get_frame_char_size (f, &cwidth, &cheight);
-if (window_system_pixelated_geometry (frame))
+cheight = XINT (lines);
-{
+frame_conversion_internal (f, SIZE_CHAR_CELL, cwidth, cheight,
-char_to_real_pixel_size (f, 0, XINT (lines), 0, &height);
+			     SIZE_FRAME_UNIT, &guwidth, &guheight);
-width = FRAME_PIXWIDTH (f);
+internal_set_frame_size (f, guwidth, guheight, !NILP (pretend));
-}
+return wrap_frame (f);
-else
-{
-height = XINT (lines);
-width = FRAME_WIDTH (f);
-}
-internal_set_frame_size (f, width, height, !NILP (pretend));
-return frame;
 }
 DEFUN ("set-frame-pixel-height", Fset_frame_pixel_height, 2, 3, 0, /*
 Specify that the frame FRAME is a total of HEIGHT pixels tall.
 Optional third arg non-nil means that redisplay should be HEIGHT pixels tall
 */
 (frame, height, pretend))
 {
 /* This can call Lisp. */
 struct frame *f = decode_frame (frame);
-int pheight, width;
+int pwidth, pheight;
-frame = wrap_frame (f);
+int guwidth, guheight;
 CHECK_INT (height);
+pheight = XINT (height);
-if (!window_system_pixelated_geometry (frame))
+pwidth = FRAME_PIXWIDTH (f);
-{
+frame_conversion_internal (f, SIZE_TOTAL_PIXEL, pwidth, pheight,
-int h = XINT (height);
+			     SIZE_FRAME_UNIT, &guwidth, &guheight);
-width = FRAME_WIDTH (f);
+internal_set_frame_size (f, guwidth, guheight, !NILP (pretend));
+return wrap_frame (f);
-frame_conversion_internal (f, TOTAL_PIXEL_TO_CHAR, 0, &h, 0, &pheight, 0);
-}
-else
-{
-width = FRAME_PIXWIDTH (f);
-pheight = XINT (height);
-}
-internal_set_frame_size (f, width, pheight, !NILP (pretend));
-return frame;
 }
 DEFUN ("set-frame-displayable-pixel-height", Fset_frame_displayable_pixel_height, 2, 3, 0, /*
 Specify that the displayable area of frame FRAME is HEIGHT pixels tall.
 Optional third arg non-nil means that redisplay should be HEIGHT pixels tall
 */
 (frame, height, pretend))
 {
 /* This can call Lisp. */
 struct frame *f = decode_frame (frame);
-int pheight, width;
+int pwidth, pheight;
-frame = wrap_frame (f);
+int guwidth, guheight;
 CHECK_INT (height);
+get_frame_displayable_pixel_size (f, &pwidth, &pheight);
-if (!window_system_pixelated_geometry (frame))
+pheight = XINT (height);
-{
+frame_conversion_internal (f, SIZE_DISPLAYABLE_PIXEL, pwidth, pheight,
-int h = XINT (height);
+			     SIZE_FRAME_UNIT, &guwidth, &guheight);
-width = FRAME_WIDTH (f);
+internal_set_frame_size (f, guwidth, guheight, !NILP (pretend));
-frame_conversion_internal (f, DISPLAYABLE_PIXEL_TO_CHAR, 0, &h, 0, &pheight, 0);
+return wrap_frame (f);
-}
-else
-{
-width = FRAME_PIXWIDTH (f);
-pheight = XINT (height);
-}
-internal_set_frame_size (f, width, pheight, !NILP (pretend));
-return frame;
 }
 DEFUN ("set-frame-width", Fset_frame_width, 2, 3, 0, /*
 Specify that the frame FRAME has COLS columns.
 */
 (frame, cols, pretend))
 {
 /* This can call Lisp. */
 struct frame *f = decode_frame (frame);
-int width, height;
+int cwidth, cheight;
-frame = wrap_frame (f);
+int guwidth, guheight;
 CHECK_INT (cols);
+get_frame_char_size (f, &cwidth, &cheight);
-if (window_system_pixelated_geometry (frame))
+cwidth = XINT (cols);
-{
+frame_conversion_internal (f, SIZE_CHAR_CELL, cwidth, cheight,
-char_to_real_pixel_size (f, XINT (cols), 0, &width, 0);
+			     SIZE_FRAME_UNIT, &guwidth, &guheight);
-height = FRAME_PIXHEIGHT (f);
+internal_set_frame_size (f, guwidth, guheight, !NILP (pretend));
-}
+return wrap_frame (f);
-else
-{
-width = XINT (cols);
-height = FRAME_HEIGHT (f);
-}
-internal_set_frame_size (f, width, height, !NILP (pretend));
-return frame;
 }
 DEFUN ("set-frame-pixel-width", Fset_frame_pixel_width, 2, 3, 0, /*
 Specify that the frame FRAME is a total of WIDTH pixels wide.
 Optional third arg non-nil means that redisplay should be WIDTH wide
 */
 (frame, width, pretend))
 {
 /* This can call Lisp. */
 struct frame *f = decode_frame (frame);
-int height, pwidth;
+int pwidth, pheight;
-frame = wrap_frame (f);
+int guwidth, guheight;
 CHECK_INT (width);
+pwidth = XINT (width);
-if (!window_system_pixelated_geometry (frame))
+pheight = FRAME_PIXHEIGHT (f);
-{
+frame_conversion_internal (f, SIZE_TOTAL_PIXEL, pwidth, pheight,
-int w = XINT (width);
+			     SIZE_FRAME_UNIT, &guwidth, &guheight);
-height = FRAME_HEIGHT (f);
+internal_set_frame_size (f, guwidth, guheight, !NILP (pretend));
-frame_conversion_internal (f, TOTAL_PIXEL_TO_CHAR, &w, 0, &pwidth, 0, 0);
+return wrap_frame (f);
-}
-else
-{
-height = FRAME_PIXHEIGHT (f);
-pwidth = XINT (width);
-}
-internal_set_frame_size (f, pwidth, height, !NILP (pretend));
-return frame;
 }
 DEFUN ("set-frame-displayable-pixel-width", Fset_frame_displayable_pixel_width, 2, 3, 0, /*
 Specify that the displayable area of frame FRAME is WIDTH pixels wide.
 Optional third arg non-nil means that redisplay should be WIDTH wide
 */
 (frame, width, pretend))
 {
 /* This can call Lisp. */
 struct frame *f = decode_frame (frame);
-int height, pwidth;
+int pwidth, pheight;
-frame = wrap_frame (f);
+int guwidth, guheight;
 CHECK_INT (width);
+get_frame_displayable_pixel_size (f, &pwidth, &pheight);
-if (!window_system_pixelated_geometry (frame))
+pwidth = XINT (width);
-{
+frame_conversion_internal (f, SIZE_DISPLAYABLE_PIXEL, pwidth, pheight,
-int w = XINT (width);
+			     SIZE_FRAME_UNIT, &guwidth, &guheight);
-height = FRAME_HEIGHT (f);
+internal_set_frame_size (f, guwidth, guheight, !NILP (pretend));
-frame_conversion_internal (f, DISPLAYABLE_PIXEL_TO_CHAR, &w, 0, &pwidth, 0, 0);
+return wrap_frame (f);
-}
-else
-{
-height = FRAME_PIXHEIGHT (f);
-pwidth = XINT (width);
-}
-internal_set_frame_size (f, pwidth, height, !NILP (pretend));
-return frame;
 }
 DEFUN ("set-frame-size", Fset_frame_size, 3, 4, 0, /*
 Set the size of FRAME to COLS by ROWS, measured in characters.
 Optional fourth arg non-nil means that redisplay should use COLS by ROWS
 */
 (frame, cols, rows, pretend))
 {
 /* This can call Lisp. */
 struct frame *f = decode_frame (frame);
-int height, width;
+int guwidth, guheight;
-frame = wrap_frame (f);
 CHECK_INT (cols);
 CHECK_INT (rows);
+frame_conversion_internal (f, SIZE_CHAR_CELL, XINT (cols), XINT (rows),
-if (window_system_pixelated_geometry (frame))
+			     SIZE_FRAME_UNIT, &guwidth, &guheight);
-char_to_real_pixel_size (f, XINT (cols), XINT (rows), &width, &height);
+internal_set_frame_size (f, guwidth, guheight, !NILP (pretend));
-else
+return wrap_frame (f);
-{
-height = XINT (rows);
-width = XINT (cols);
-}
-internal_set_frame_size (f, width, height, !NILP (pretend));
-return frame;
 }
 DEFUN ("set-frame-pixel-size", Fset_frame_pixel_size, 3, 4, 0, /*
 Set the total size of FRAME to WIDTH by HEIGHT, measured in pixels.
 Optional fourth arg non-nil means that redisplay should use WIDTH by HEIGHT
 */
 (frame, width, height, pretend))
 {
 /* This can call Lisp. */
 struct frame *f = decode_frame (frame);
-int pheight, pwidth;
+int guwidth, guheight;
-frame = wrap_frame (f);
 CHECK_INT (width);
 CHECK_INT (height);
+frame_conversion_internal (f, SIZE_TOTAL_PIXEL, XINT (width), XINT (height),
-if (!window_system_pixelated_geometry (frame))
+			     SIZE_FRAME_UNIT, &guwidth, &guheight);
-{
+internal_set_frame_size (f, guwidth, guheight, !NILP (pretend));
-int w = XINT (width);
+return wrap_frame (f);
-int h = XINT (height);
-frame_conversion_internal (f, TOTAL_PIXEL_TO_CHAR, &w, &h, &pwidth, &pheight, 0);
-}
-else
-{
-pheight = XINT (height);
-pwidth = XINT (width);
-}
-internal_set_frame_size (f, pwidth, pheight, !NILP (pretend));
-return frame;
 }
 DEFUN ("set-frame-displayable-pixel-size", Fset_frame_displayable_pixel_size, 3, 4, 0, /*
 Set the displayable size of FRAME to WIDTH by HEIGHT, measured in pixels.
 Optional fourth arg non-nil means that redisplay should use WIDTH by HEIGHT
 */
 (frame, width, height, pretend))
 {
 /* This can call Lisp. */
 struct frame *f = decode_frame (frame);
-int pheight, pwidth;
+int guwidth, guheight;
-frame = wrap_frame (f);
 CHECK_INT (width);
 CHECK_INT (height);
+frame_conversion_internal (f, SIZE_DISPLAYABLE_PIXEL,
-if (!window_system_pixelated_geometry (frame))
+			     XINT (width), XINT (height),
-{
+			     SIZE_FRAME_UNIT, &guwidth, &guheight);
-int w = XINT (width);
+internal_set_frame_size (f, guwidth, guheight, !NILP (pretend));
-int h = XINT (height);
+return wrap_frame (f);
-frame_conversion_internal (f, DISPLAYABLE_PIXEL_TO_CHAR, &w, &h, &pwidth, &pheight, 0);
-}
-else
-{
-pheight = XINT (height);
-pwidth = XINT (width);
-}
-internal_set_frame_size (f, pwidth, pheight, !NILP (pretend));
-return frame;
 }
 DEFUN ("set-frame-position", Fset_frame_position, 3, 3, 0, /*
 Set position of FRAME in pixels to XOFFSET by YOFFSET.
 This is actually the position of the upper left corner of the frame.
 /* Frame size conversion functions moved here from EmacsFrame.c
 because they're generic and really don't belong in that file.
 Function get_default_char_pixel_size() removed because it's
-exactly the same as default_face_height_and_width(). */
+exactly the same as default_face_width_and_height().
+Convert between total pixel size, displayable pixel size and
+character-cell size.  Variables are either "in" or "out"
+depending on the value of PIXEL_TO_CHAR.
+*/
 static void
-frame_conversion_internal (struct frame *f,
+frame_conversion_internal_1 (struct frame *f,
-			   pixel_to_char_mode_t pixel_to_char,
+			     pixel_to_char_mode_t pixel_to_char,
-			   int *pixel_width, int *pixel_height,
+			     int *total_pixel_width, int *total_pixel_height,
-			   int *char_width, int *char_height,
+			     int *disp_pixel_width, int *disp_pixel_height,
-			   int real_face)
+			     int *char_width, int *char_height)
 {
-int cpw;
+int cpw, cph;
-int cph;
 int egw;
 int obw, obh, bdr;
 Lisp_Object frame, window;
 frame = wrap_frame (f);
-if (real_face)
+default_face_width_and_height (frame, &cpw, &cph);
-default_face_height_and_width (frame, &cph, &cpw);
-else
-default_face_height_and_width_1 (frame, &cph, &cpw);
 window = FRAME_SELECTED_WINDOW (f);
+/* #### It really seems like we should also be subtracting out the
+theoretical gutter width and height, just like we do for toolbars.
+There is currently a bug where if you call `set-frame-pixel-width'
+on MS Windows (at least, possibly also X) things get confused and
+the top of the root window overlaps the top gutter instead of being
+below it.  This gets fixed next time you resize the frame using the
+mouse.  Possibly this is caused by not handling the gutter height
+here? */
 egw = max (glyph_width (Vcontinuation_glyph, window),
 	     glyph_width (Vtruncation_glyph, window));
 egw = max (egw, cpw);
 bdr = 2 * f->internal_border_width;
 obw = FRAME_SCROLLBAR_WIDTH (f) + FRAME_THEORETICAL_LEFT_TOOLBAR_WIDTH (f) +
 much space. */
 switch (pixel_to_char)
 {
 case DISPLAYABLE_PIXEL_TO_CHAR:
 if (char_width)
-	*char_width = ROUND_UP (*pixel_width, cpw) / cpw;
+	*char_width = ROUND_UP (*disp_pixel_width, cpw) / cpw;
 if (char_height)
-	*char_height = ROUND_UP (*pixel_height, cph) / cph;
+	*char_height = ROUND_UP (*disp_pixel_height, cph) / cph;
+break;
+case CHAR_TO_DISPLAYABLE_PIXEL:
+if (disp_pixel_width)
+	*disp_pixel_width = *char_width * cpw;
+if (disp_pixel_height)
+	*disp_pixel_height = *char_height * cph;
 break;
 case TOTAL_PIXEL_TO_CHAR:
 /* Convert to chars so that the total frame size is pixel_width x
 	 pixel_height. */
 if (char_width)
-	*char_width = 1 + ((*pixel_width - egw) - bdr - obw) / cpw;
+	*char_width = 1 + ((*total_pixel_width - egw) - bdr - obw) / cpw;
 if (char_height)
-	*char_height = (*pixel_height - bdr - obh) / cph;
+	*char_height = (*total_pixel_height - bdr - obh) / cph;
 break;
 case CHAR_TO_TOTAL_PIXEL:
-if (pixel_width)
+if (total_pixel_width)
-	*pixel_width = (*char_width - 1) * cpw + egw + bdr + obw;
+	*total_pixel_width = (*char_width - 1) * cpw + egw + bdr + obw;
-if (pixel_height)
+if (total_pixel_height)
-	*pixel_height = *char_height * cph + bdr + obh;
+	*total_pixel_height = *char_height * cph + bdr + obh;
 break;
-case CHAR_TO_DISPLAYABLE_PIXEL:
+case TOTAL_PIXEL_TO_DISPLAYABLE_PIXEL:
-if (pixel_width)
+/* Convert to chars so that the total frame size is pixel_width x
-	*pixel_width = *char_width * cpw;
+	 pixel_height. */
-if (pixel_height)
+if (disp_pixel_width)
-	*pixel_height = *char_height * cph;
+	*disp_pixel_width = cpw + (*total_pixel_width - egw) - bdr - obw;
+if (disp_pixel_height)
+	*disp_pixel_height = *total_pixel_height - bdr - obh;
 break;
-}
+case DISPLAYABLE_PIXEL_TO_TOTAL_PIXEL:
-}
+if (total_pixel_width)
+	*total_pixel_width = *disp_pixel_width - cpw + egw + bdr + obw;
-/* This takes the size in pixels of the text area, and returns the number
+if (total_pixel_height)
+	*total_pixel_height = *disp_pixel_height + bdr + obh;
+break;
+}
+}
+static enum frame_size_type
+canonicalize_frame_size_type (enum frame_size_type type, int pixgeom)
+{
+if (type == SIZE_FRAME_UNIT)
+{
+if (pixgeom)
+	type = SIZE_DISPLAYABLE_PIXEL;
+else
+	type = SIZE_CHAR_CELL;
+}
+return type;
+}
+/* Basic frame conversion function.  Convert source size to destination
+size, where either of them can be in total pixels, displayable pixels,
+frame units or character-cell units. */
+static void
+frame_conversion_internal (struct frame *f,
+			   enum frame_size_type source,
+			   int source_width, int source_height,
+			   enum frame_size_type dest,
+			   int *dest_width, int *dest_height)
+{
+int pixgeom = window_system_pixelated_geometry (wrap_frame (f));
+dest = canonicalize_frame_size_type (dest, pixgeom);
+source = canonicalize_frame_size_type (source, pixgeom);
+if (source == dest)
+{
+*dest_width = source_width;
+*dest_height = source_height;
+}
+else if (source == SIZE_TOTAL_PIXEL && dest == SIZE_CHAR_CELL)
+frame_conversion_internal_1 (f, TOTAL_PIXEL_TO_CHAR,
+				 &source_width, &source_height, 0, 0,
+				 dest_width, dest_height);
+else if (source == SIZE_DISPLAYABLE_PIXEL && dest == SIZE_CHAR_CELL)
+frame_conversion_internal_1 (f, DISPLAYABLE_PIXEL_TO_CHAR, 0, 0,
+				 &source_width, &source_height,
+				 dest_width, dest_height);
+else if (source == SIZE_TOTAL_PIXEL && dest == SIZE_DISPLAYABLE_PIXEL)
+frame_conversion_internal_1 (f, TOTAL_PIXEL_TO_DISPLAYABLE_PIXEL,
+				 &source_width, &source_height,
+				 dest_width, dest_height, 0, 0);
+else if (dest == SIZE_TOTAL_PIXEL && source == SIZE_CHAR_CELL)
+frame_conversion_internal_1 (f, CHAR_TO_TOTAL_PIXEL,
+				 dest_width, dest_height, 0, 0,
+				 &source_width, &source_height);
+else if (dest == SIZE_DISPLAYABLE_PIXEL && source == SIZE_CHAR_CELL)
+frame_conversion_internal_1 (f, CHAR_TO_DISPLAYABLE_PIXEL, 0, 0,
+				 dest_width, dest_height,
+				 &source_width, &source_height);
+else if (dest == SIZE_TOTAL_PIXEL && source == SIZE_DISPLAYABLE_PIXEL)
+frame_conversion_internal_1 (f, DISPLAYABLE_PIXEL_TO_TOTAL_PIXEL,
+				 dest_width, dest_height,
+				 &source_width, &source_height, 0, 0);
+else
+{
+ABORT ();
+if (dest_width)
+	*dest_width = 0;
+if (dest_height)
+	*dest_height = 0;
+}
+}
+/* This takes the size in pixels of the client area, and returns the number
 of characters that will fit there, taking into account the internal
 border width, and the pixel width of the line terminator glyphs (which
 always count as one "character" wide, even if they are not the same size
 as the default character size of the default font).  The frame scrollbar
 width and left and right toolbar widths are also subtracted out of the
 available width.  The frame scrollbar height and top and bottom toolbar
 heights are subtracted out of the available height.
 Therefore the result is not necessarily a multiple of anything in
 particular.  */
 void
 pixel_to_char_size (struct frame *f, int pixel_width, int pixel_height,
 		    int *char_width, int *char_height)
 {
-frame_conversion_internal (f, TOTAL_PIXEL_TO_CHAR,
+frame_conversion_internal (f, SIZE_TOTAL_PIXEL, pixel_width, pixel_height,
-			     &pixel_width, &pixel_height, char_width,
+			     SIZE_CHAR_CELL, char_width, char_height);
-			     char_height, 0);
+}
-}
+/* Given a character size, this returns the minimum pixel size of the
-/* Given a character size, this returns the minimum number of pixels
+client area necessary to display that many characters, taking into
-necessary to display that many characters, taking into account the
+account the internal border width, scrollbar height and width, toolbar
-internal border width, scrollbar height and width, toolbar heights and
+heights and widths and the size of the line terminator glyphs (assuming
-widths and the size of the line terminator glyphs (assuming the line
+the line terminators take up exactly one character position).
-terminators take up exactly one character position).
 Therefore the result is not necessarily a multiple of anything in
 particular.  */
 void
 char_to_pixel_size (struct frame *f, int char_width, int char_height,
 		    int *pixel_width, int *pixel_height)
 {
-frame_conversion_internal (f, CHAR_TO_TOTAL_PIXEL,
+frame_conversion_internal (f, SIZE_CHAR_CELL, char_width, char_height,
-			     pixel_width, pixel_height, &char_width,
+			     SIZE_TOTAL_PIXEL, pixel_width, pixel_height);
-			     &char_height, 0);
+}
-}
+/* Versions of the above that operate in "frame units" instead of
-/* Given a pixel size, rounds DOWN to the smallest size in pixels necessary
+characters.  frame units are the same as characters except on
-to display the same number of characters as are displayable now.
+MS Windows and MS Printer frames, where they are displayable-area
-*/
+pixels. */
+void
+pixel_to_frame_unit_size (struct frame *f, int pixel_width, int pixel_height,
+			 int *frame_unit_width, int *frame_unit_height)
+{
+frame_conversion_internal (f, SIZE_TOTAL_PIXEL, pixel_width, pixel_height,
+			     SIZE_FRAME_UNIT, frame_unit_width,
+			     frame_unit_height);
+}
+void
+frame_unit_to_pixel_size (struct frame *f, int frame_unit_width,
+			 int frame_unit_height,
+			 int *pixel_width, int *pixel_height)
+{
+frame_conversion_internal (f, SIZE_FRAME_UNIT, frame_unit_width,
+			     frame_unit_height,
+			     SIZE_TOTAL_PIXEL, pixel_width, pixel_height);
+}
 void
 round_size_to_char (struct frame *f, int in_width, int in_height,
 		    int *out_width, int *out_height)
 {
 int char_width;
 int char_height;
 pixel_to_char_size (f, in_width, in_height, &char_width, &char_height);
 char_to_pixel_size (f, char_width, char_height, out_width, out_height);
 }
-/* Versions of the above which always account for real font metrics.
+/* Get the frame size in character cells, recalculating on the fly.
-*/
+#### The logic of this function follows former logic elsewhere,
-void
+which used FRAME_PIXWIDTH() on pixelated-geometry systems but
-pixel_to_real_char_size (struct frame *f, int pixel_width, int pixel_height,
+FRAME_WIDTH() on non-pixelated-geometry systems.  Not clear why not
-			 int *char_width, int *char_height)
+always just use one or the other.
-{
-frame_conversion_internal (f, TOTAL_PIXEL_TO_CHAR,
+Why don't we just use FRAME_CHARWIDTH() etc. in get_frame_char_size()?
-			     &pixel_width, &pixel_height, char_width,
+That wouldn't work because change_frame_size_1() depends on the
-			     char_height, 1);
+following function to *set* the values of FRAME_CHARWIDTH() etc.
-}
+But elsewhere I suppose we could use it.
-void
+*/
-char_to_real_pixel_size (struct frame *f, int char_width, int char_height,
-			 int *pixel_width, int *pixel_height)
-{
-frame_conversion_internal (f, CHAR_TO_TOTAL_PIXEL,
-			     pixel_width, pixel_height, &char_width,
-			     &char_height, 1);
-}
-void
-round_size_to_real_char (struct frame *f, int in_width, int in_height,
-			 int *out_width, int *out_height)
-{
-int char_width;
-int char_height;
-pixel_to_real_char_size (f, in_width, in_height, &char_width, &char_height);
-char_to_real_pixel_size (f, char_width, char_height, out_width, out_height);
-}
-/* Change the frame height and/or width.  Values may be given as zero to
-indicate no change is to take place. */
 static void
-change_frame_size_1 (struct frame *f, int newheight, int newwidth)
+get_frame_char_size (struct frame *f, int *out_width, int *out_height)
 {
-Lisp_Object frame;
+if (window_system_pixelated_geometry (wrap_frame (f)))
+pixel_to_char_size (f, FRAME_PIXWIDTH (f), FRAME_PIXHEIGHT (f),
+			out_width, out_height);
+else
+{
+*out_width = FRAME_WIDTH (f);
+*out_height = FRAME_HEIGHT (f);
+}
+}
+static void
+get_frame_displayable_pixel_size (struct frame *f, int *out_width,
+				  int *out_height)
+{
+frame_conversion_internal (f, SIZE_FRAME_UNIT, FRAME_WIDTH (f),
+			     FRAME_HEIGHT (f), SIZE_DISPLAYABLE_PIXEL,
+			     out_width, out_height);
+}
+/* Change the frame height and/or width.  Values passed in are in
+frame units (character cells on X/GTK, displayable-area pixels
+on MS Windows or generally on pixelated-geometry window systems). */
+static void
+change_frame_size_1 (struct frame *f, int newwidth, int newheight)
+{
 int new_pixheight, new_pixwidth;
-int font_height, real_font_height, font_width;
+int real_font_height, real_font_width;
 /* #### Chuck -- shouldn't we be checking to see if the frame
 is being "changed" to its existing size, and do nothing if so? */
 /* No, because it would hose toolbar updates.  The toolbar
 update code relies on this function to cause window `top' and
 `left' coordinates to be recomputed even though no frame size
 change occurs. --kyle */
 assert (!in_display && !hold_frame_size_changes);
-frame = wrap_frame (f);
+/* We no longer allow bogus values passed in. */
+assert (newheight && newwidth);
-default_face_height_and_width (frame, &real_font_height, 0);
-default_face_height_and_width_1 (frame, &font_height, &font_width);
+default_face_width_and_height (wrap_frame (f), &real_font_width,
+				 &real_font_height);
+frame_conversion_internal (f, SIZE_FRAME_UNIT, newwidth, newheight,
+			     SIZE_TOTAL_PIXEL, &new_pixwidth,
+			     &new_pixheight);
 /* This size-change overrides any pending one for this frame.  */
 f->size_change_pending = 0;
 FRAME_NEW_HEIGHT (f) = 0;
 FRAME_NEW_WIDTH (f) = 0;
-new_pixheight = newheight * font_height;
+/* We need to remove the boundaries of the paned area (see top of file)
-new_pixwidth = (newwidth - 1) * font_width;
+from the total-area pixel size, which is what we have now.
-/* #### dependency on FRAME_WIN_P should be removed. */
+#### We should also be subtracting the internal borders. */
-if (FRAME_WIN_P (f))
+new_pixheight -=
-{
+(FRAME_REAL_TOP_TOOLBAR_BOUNDS (f)
-new_pixheight += FRAME_SCROLLBAR_HEIGHT (f);
++ FRAME_REAL_BOTTOM_TOOLBAR_BOUNDS (f)
-new_pixwidth += FRAME_SCROLLBAR_WIDTH (f);
++ FRAME_TOP_GUTTER_BOUNDS (f)
-}
++ FRAME_BOTTOM_GUTTER_BOUNDS (f));
-/* when frame_conversion_internal() calculated the number of rows/cols
+new_pixwidth -=
-in the frame, the theoretical toolbar sizes were subtracted out.
+(FRAME_REAL_LEFT_TOOLBAR_BOUNDS (f)
-The calculations below adjust for real toolbar height/width in
++ FRAME_REAL_RIGHT_TOOLBAR_BOUNDS (f)
-frame, which may be different from frame spec, taking the above
++ FRAME_LEFT_GUTTER_BOUNDS (f)
-fact into account */
++ FRAME_RIGHT_GUTTER_BOUNDS (f));
-new_pixheight +=
-+ FRAME_THEORETICAL_TOP_TOOLBAR_HEIGHT (f)
+XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_top
-+ 2 * FRAME_THEORETICAL_TOP_TOOLBAR_BORDER_WIDTH (f)
+= FRAME_TOP_BORDER_END (f) + FRAME_TOP_GUTTER_BOUNDS (f);
-- FRAME_REAL_TOP_TOOLBAR_HEIGHT (f)
-- 2 * FRAME_REAL_TOP_TOOLBAR_BORDER_WIDTH (f);
+if (FRAME_HAS_MINIBUF_P (f)
+&& ! FRAME_MINIBUF_ONLY_P (f))
-new_pixheight +=
+/* Frame has both root and minibuffer.  */
-+ FRAME_THEORETICAL_BOTTOM_TOOLBAR_HEIGHT (f)
+{
-+ 2 * FRAME_THEORETICAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f)
+/*
-- FRAME_REAL_BOTTOM_TOOLBAR_HEIGHT (f)
+* Leave the minibuffer height the same if the frame has
-- 2 * FRAME_REAL_BOTTOM_TOOLBAR_BORDER_WIDTH (f);
+* been initialized, and the minibuffer height is tall
+* enough to display at least one line of text in the default
-new_pixwidth +=
+* font, and the old minibuffer height is a multiple of the
-+ FRAME_THEORETICAL_LEFT_TOOLBAR_WIDTH (f)
+* default font height.  This should cause the minibuffer
-+ 2 * FRAME_THEORETICAL_LEFT_TOOLBAR_BORDER_WIDTH (f)
+* height to be recomputed on font changes but not for
-- FRAME_REAL_LEFT_TOOLBAR_WIDTH (f)
+* other frame size changes, which seems reasonable.
-- 2 * FRAME_REAL_LEFT_TOOLBAR_BORDER_WIDTH (f);
+*/
+int old_minibuf_height =
-new_pixwidth +=
+	XWINDOW(FRAME_MINIBUF_WINDOW(f))->pixel_height;
-+ FRAME_THEORETICAL_RIGHT_TOOLBAR_WIDTH (f)
+int minibuf_height =
-+ 2 * FRAME_THEORETICAL_RIGHT_TOOLBAR_BORDER_WIDTH (f)
+	f->init_finished && (old_minibuf_height % real_font_height) == 0 ?
-- FRAME_REAL_RIGHT_TOOLBAR_WIDTH (f)
+	max(old_minibuf_height, real_font_height) :
-- 2 * FRAME_REAL_RIGHT_TOOLBAR_BORDER_WIDTH (f);
+	real_font_height;
+set_window_pixheight (FRAME_ROOT_WINDOW (f),
-/* Adjust the width for the end glyph which may be a different width
+			    /* - font_height for minibuffer */
-than the default character width. */
+			    new_pixheight - minibuf_height, 0);
-{
-int adjustment, trunc_width, cont_width;
+XWINDOW (FRAME_MINIBUF_WINDOW (f))->pixel_top =
+	FRAME_TOP_BORDER_END (f) +
-trunc_width = glyph_width (Vtruncation_glyph,
+	FRAME_TOP_GUTTER_BOUNDS (f) +
-			       FRAME_SELECTED_WINDOW (f));
+	FRAME_BOTTOM_GUTTER_BOUNDS (f) +
-cont_width = glyph_width (Vcontinuation_glyph,
+	new_pixheight - minibuf_height;
-			      FRAME_SELECTED_WINDOW (f));
-adjustment = max (trunc_width, cont_width);
+set_window_pixheight (FRAME_MINIBUF_WINDOW (f), minibuf_height, 0);
-adjustment = max (adjustment, font_width);
+}
+else
-new_pixwidth += adjustment;
+/* Frame has just one top-level window.  */
-}
+set_window_pixheight (FRAME_ROOT_WINDOW (f), new_pixheight, 0);
-/* If we don't have valid values, exit. */
+FRAME_HEIGHT (f) = newheight;
-if (!new_pixheight && !new_pixwidth)
+if (FRAME_TTY_P (f))
-return;
+f->pixheight = newheight;
-if (new_pixheight)
+XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_left =
-{
+FRAME_LEFT_BORDER_END (f) + FRAME_LEFT_GUTTER_BOUNDS (f);
-/* Adjust for gutters here so that we always get set
+set_window_pixwidth (FRAME_ROOT_WINDOW (f), new_pixwidth, 0);
-	 properly. */
-new_pixheight -=
+if (FRAME_HAS_MINIBUF_P (f))
-	(FRAME_TOP_GUTTER_BOUNDS (f)
+{
-	 + FRAME_BOTTOM_GUTTER_BOUNDS (f));
+XWINDOW (FRAME_MINIBUF_WINDOW (f))->pixel_left =
-XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_top
-	= FRAME_TOP_BORDER_END (f) + FRAME_TOP_GUTTER_BOUNDS (f);
-if (FRAME_HAS_MINIBUF_P (f)
-	  && ! FRAME_MINIBUF_ONLY_P (f))
-	/* Frame has both root and minibuffer.  */
-	{
-	  /*
-	   * Leave the minibuffer height the same if the frame has
-	   * been initialized, and the minibuffer height is tall
-	   * enough to display at least one line of text in the default
-	   * font, and the old minibuffer height is a multiple of the
-	   * default font height.  This should cause the minibuffer
-	   * height to be recomputed on font changes but not for
-	   * other frame size changes, which seems reasonable.
-	   */
-	  int old_minibuf_height =
-	    XWINDOW(FRAME_MINIBUF_WINDOW(f))->pixel_height;
-	  int minibuf_height =
-	    f->init_finished && (old_minibuf_height % real_font_height) == 0 ?
-	    max(old_minibuf_height, real_font_height) :
-	    real_font_height;
-	  set_window_pixheight (FRAME_ROOT_WINDOW (f),
-				/* - font_height for minibuffer */
-				new_pixheight - minibuf_height, 0);
-	  XWINDOW (FRAME_MINIBUF_WINDOW (f))->pixel_top =
-	    FRAME_TOP_BORDER_END (f) +
-	    FRAME_TOP_GUTTER_BOUNDS (f) +
-	    FRAME_BOTTOM_GUTTER_BOUNDS (f) +
-	    new_pixheight - minibuf_height;
-	  set_window_pixheight (FRAME_MINIBUF_WINDOW (f), minibuf_height, 0);
-	}
-else
-	/* Frame has just one top-level window.  */
-	set_window_pixheight (FRAME_ROOT_WINDOW (f), new_pixheight, 0);
-FRAME_HEIGHT (f) = newheight;
-if (FRAME_TTY_P (f))
-	f->pixheight = newheight;
-}
-if (new_pixwidth)
-{
-/* Adjust for gutters here so that we always get set
-	 properly. */
-new_pixwidth -=
-	(FRAME_LEFT_GUTTER_BOUNDS (f)
-	 + FRAME_RIGHT_GUTTER_BOUNDS (f));
-XWINDOW (FRAME_ROOT_WINDOW (f))->pixel_left =
 	FRAME_LEFT_BORDER_END (f) + FRAME_LEFT_GUTTER_BOUNDS (f);
-set_window_pixwidth (FRAME_ROOT_WINDOW (f), new_pixwidth, 0);
+set_window_pixwidth (FRAME_MINIBUF_WINDOW (f), new_pixwidth, 0);
+}
-if (FRAME_HAS_MINIBUF_P (f))
-	{
+FRAME_WIDTH (f) = newwidth;
-	  XWINDOW (FRAME_MINIBUF_WINDOW (f))->pixel_left =
+if (FRAME_TTY_P (f))
-	    FRAME_LEFT_BORDER_END (f) + FRAME_LEFT_GUTTER_BOUNDS (f);
+f->pixwidth = newwidth;
-	  set_window_pixwidth (FRAME_MINIBUF_WINDOW (f), new_pixwidth, 0);
-	}
+/* #### On MS Windows, this references FRAME_PIXWIDTH() and FRAME_PIXHEIGHT().
+I'm not sure we can count on those values being set.  Instead we should
-FRAME_WIDTH (f) = newwidth;
+use the total pixel size we got near the top by calling
-if (FRAME_TTY_P (f))
+frame_conversion_internal().  We should inline the logic in
-	f->pixwidth = newwidth;
+get_frame_char_size() here and change that function so it just looks
-}
+at FRAME_CHARWIDTH() and FRAME_CHARHEIGHT(). */
+get_frame_char_size (f, &FRAME_CHARWIDTH (f), &FRAME_CHARHEIGHT (f));
-if (window_system_pixelated_geometry (frame))
-pixel_to_real_char_size (f, FRAME_PIXWIDTH (f), FRAME_PIXHEIGHT (f),
-			     &FRAME_CHARWIDTH (f), &FRAME_CHARHEIGHT (f));
-else
-{
-FRAME_CHARWIDTH (f) = FRAME_WIDTH (f);
-FRAME_CHARHEIGHT (f) = FRAME_HEIGHT (f);
-}
 MARK_FRAME_TOOLBARS_CHANGED (f);
 MARK_FRAME_GUTTERS_CHANGED (f);
 MARK_FRAME_CHANGED (f);
 f->echo_area_garbaged = 1;
 }
 void
-change_frame_size (struct frame *f, int newheight, int newwidth, int delay)
+change_frame_size (struct frame *f, int newwidth, int newheight, int delay)
 {
 /* sometimes we get passed a size that's too small (esp. when a
 client widget gets resized, since we have no control over this).
 So deal. */
-check_frame_size (f, &newheight, &newwidth);
+check_frame_size (f, &newwidth, &newheight);
 /* Unconditionally mark that the frame has changed size. This is
 because many things need to know after the
 fact. f->size_change_pending will get reset below. The most that
 can happen is that we will cycle through redisplay once more
 if (FRAME_TTY_P (f))
 {
 Lisp_Object frmcons;
 DEVICE_FRAME_LOOP (frmcons, XDEVICE (FRAME_DEVICE (f)))
-	change_frame_size_1 (XFRAME (XCAR (frmcons)), newheight, newwidth);
+	change_frame_size_1 (XFRAME (XCAR (frmcons)), newwidth, newheight);
 }
 else
-change_frame_size_1 (f, newheight, newwidth);
+change_frame_size_1 (f, newwidth, newheight);
 }
 /* The caller is responsible for freeing the returned string. */
 static Ibyte *

Mercurial > hg > xemacs-beta

comparison src/frame.c @ 5052:92dc90c0bb40