src/widget.c

   1 /* The emacs frame widget.
   2    Copyright (C) 1992-1993, 2000-2014 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software: you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation, either version 3 of the License, or
   9 (at your option) any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 /* Emacs 19 face widget ported by Fred Pierresteguy */
  20
  21 /* This file has been censored by the Communications Decency Act.
  22    That law was passed under the guise of a ban on pornography, but
  23    it bans far more than that.  This file did not contain pornography,
  24    but it was censored nonetheless.
  25
  26    For information on US government censorship of the Internet, and
  27    what you can do to bring back freedom of the press, see the web
  28    site http://www.vtw.org/
  29    */
  30
  31 #include <config.h>
  32 #include <stdio.h>
  33
  34 #include "lisp.h"
  35 #include "xterm.h"
  36
  37 #include "keyboard.h"
  38 #include "frame.h"
  39 #include "window.h"
  40
  41 #include "dispextern.h"
  42 #include "blockinput.h"
  43
  44 #include <X11/StringDefs.h>
  45 #include <X11/IntrinsicP.h>
  46 #include <X11/cursorfont.h>
  47 #include "widgetprv.h"
  48 #include <X11/ObjectP.h>
  49 #include <X11/Shell.h>
  50 #include <X11/ShellP.h>
  51 #include "../lwlib/lwlib.h"
  52
  53 #include "character.h"
  54 #include "font.h"
  55
  56 /* This sucks: this is the first default that x-faces.el tries.  This won't
  57    be used unless neither the "Emacs.EmacsFrame" resource nor the
  58    "Emacs.EmacsFrame" resource is set; the frame
  59    may have the wrong default size if this font doesn't exist, but some other
  60    font that x-faces.el does.  The workaround is to specify some font in the
  61    resource database; I don't know a solution other than duplicating the font-
  62    searching code from x-faces.el in this file.
  63
  64    This also means that if "Emacs.EmacsFrame" is specified as a non-
  65    existent font, then Xt is going to substitute "XtDefaultFont" for it,
  66    which is a different size than this one.  The solution for this is to
  67    make x-faces.el try to use XtDefaultFont.  The problem with that is that
  68    XtDefaultFont is almost certainly variable-width.
  69
  70    #### Perhaps we could have this code explicitly set XtDefaultFont to this?
  71  */
  72 #define DEFAULT_FACE_FONT "-*-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-*"
  73
  74
  75 static void EmacsFrameInitialize (Widget request, Widget new, ArgList dum1, Cardinal *dum2);
  76 static void EmacsFrameDestroy (Widget widget);
  77 static void EmacsFrameRealize (Widget widget, XtValueMask *mask, XSetWindowAttributes *attrs);
  78 static void EmacsFrameResize (Widget widget);
  79 static Boolean EmacsFrameSetValues (Widget cur_widget, Widget req_widget, Widget new_widget, ArgList dum1, Cardinal *dum2);
  80 static XtGeometryResult EmacsFrameQueryGeometry (Widget widget, XtWidgetGeometry *request, XtWidgetGeometry *result);
  81
  82
  83 #undef XtOffset
  84 #define XtOffset(p_type,field) \
  85         ((Cardinal) (((char *) (&(((p_type)0)->field))) - ((char *)0)))
  86 #define offset(field) XtOffset (EmacsFrame, emacs_frame.field)
  87
  88 static XtResource resources[] = {
  89   {XtNgeometry, XtCGeometry, XtRString, sizeof (String),
  90      offset (geometry), XtRString, (XtPointer) 0},
  91   {XtNiconic, XtCIconic, XtRBoolean, sizeof (Boolean),
  92      offset (iconic), XtRImmediate, (XtPointer) False},
  93
  94   {XtNemacsFrame, XtCEmacsFrame, XtRPointer, sizeof (XtPointer),
  95      offset (frame), XtRImmediate, 0},
  96
  97   {XtNminibuffer, XtCMinibuffer, XtRInt, sizeof (int),
  98      offset (minibuffer), XtRImmediate, (XtPointer)0},
  99   {XtNunsplittable, XtCUnsplittable, XtRBoolean, sizeof (Boolean),
 100      offset (unsplittable), XtRImmediate, (XtPointer)0},
 101   {XtNinternalBorderWidth, XtCInternalBorderWidth, XtRInt, sizeof (int),
 102      offset (internal_border_width), XtRImmediate, (XtPointer)4},
 103   {XtNinterline, XtCInterline, XtRInt, sizeof (int),
 104      offset (interline), XtRImmediate, (XtPointer)0},
 105   {XtNfont,  XtCFont, XtRFontStruct, sizeof (struct font *),
 106      offset (font),XtRString, DEFAULT_FACE_FONT},
 107   {XtNforeground, XtCForeground, XtRPixel, sizeof (Pixel),
 108      offset (foreground_pixel), XtRString, "XtDefaultForeground"},
 109   {XtNcursorColor, XtCForeground, XtRPixel, sizeof (Pixel),
 110      offset (cursor_color), XtRString, "XtDefaultForeground"},
 111   {XtNbarCursor, XtCBarCursor, XtRBoolean, sizeof (Boolean),
 112      offset (bar_cursor), XtRImmediate, (XtPointer)0},
 113   {XtNvisualBell, XtCVisualBell, XtRBoolean, sizeof (Boolean),
 114      offset (visual_bell), XtRImmediate, (XtPointer)0},
 115   {XtNbellVolume, XtCBellVolume, XtRInt, sizeof (int),
 116      offset (bell_volume), XtRImmediate, (XtPointer)0},
 117 };
 118
 119 #undef offset
 120
 121 /*
 122 static XtActionsRec
 123 emacsFrameActionsTable [] = {
 124   {"keypress",  key_press},
 125   {"focus_in",  emacs_frame_focus_handler},
 126   {"focus_out", emacs_frame_focus_handler},
 127 };
 128
 129 static char
 130 emacsFrameTranslations [] = "\
 131 <KeyPress>: keypress()\n\
 132 <FocusIn>:  focus_in()\n\
 133 <FocusOut>: focus_out()\n\
 134 ";
 135 */
 136
 137 static EmacsFrameClassRec emacsFrameClassRec = {
 138     { /* core fields */
 139     /* superclass               */      &widgetClassRec,
 140     /* class_name               */      "EmacsFrame",
 141     /* widget_size              */      sizeof (EmacsFrameRec),
 142     /* class_initialize         */      0,
 143     /* class_part_initialize    */      0,
 144     /* class_inited             */      FALSE,
 145     /* initialize               */      EmacsFrameInitialize,
 146     /* initialize_hook          */      0,
 147     /* realize                  */      EmacsFrameRealize,
 148     /* actions                  */      0, /*emacsFrameActionsTable*/
 149     /* num_actions              */      0, /*XtNumber (emacsFrameActionsTable)*/
 150     /* resources                */      resources,
 151     /* resource_count           */      XtNumber (resources),
 152     /* xrm_class                */      NULLQUARK,
 153     /* compress_motion          */      TRUE,
 154     /* compress_exposure        */      TRUE,
 155     /* compress_enterleave      */      TRUE,
 156     /* visible_interest         */      FALSE,
 157     /* destroy                  */      EmacsFrameDestroy,
 158     /* resize                   */      EmacsFrameResize,
 159     /* expose                   */      XtInheritExpose,
 160     /* set_values               */      EmacsFrameSetValues,
 161     /* set_values_hook          */      0,
 162     /* set_values_almost        */      XtInheritSetValuesAlmost,
 163     /* get_values_hook          */      0,
 164     /* accept_focus             */      XtInheritAcceptFocus,
 165     /* version                  */      XtVersion,
 166     /* callback_private         */      0,
 167     /* tm_table                 */      0, /*emacsFrameTranslations*/
 168     /* query_geometry           */      EmacsFrameQueryGeometry,
 169     /* display_accelerator      */      XtInheritDisplayAccelerator,
 170     /* extension                */      0
 171     }
 172 };
 173
 174 WidgetClass emacsFrameClass = (WidgetClass) &emacsFrameClassRec;
 175
 176 static void
 177 get_default_char_pixel_size (EmacsFrame ew, int *pixel_width, int *pixel_height)
 178 {
 179   struct frame* f = ew->emacs_frame.frame;
 180   *pixel_width = FRAME_COLUMN_WIDTH (f);
 181   *pixel_height = FRAME_LINE_HEIGHT (f);
 182 }
 183
 184 static void
 185 pixel_to_char_size (EmacsFrame ew, Dimension pixel_width, Dimension pixel_height, int *char_width, int *char_height)
 186 {
 187   struct frame* f = ew->emacs_frame.frame;
 188   *char_width = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, (int) pixel_width);
 189   *char_height = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, (int) pixel_height);
 190 }
 191
 192 static void
 193 pixel_to_text_size (EmacsFrame ew, Dimension pixel_width, Dimension pixel_height, int *text_width, int *text_height)
 194 {
 195   struct frame* f = ew->emacs_frame.frame;
 196   *text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, (int) pixel_width);
 197   *text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, (int) pixel_height);
 198 }
 199
 200 static void
 201 char_to_pixel_size (EmacsFrame ew, int char_width, int char_height, Dimension *pixel_width, Dimension *pixel_height)
 202 {
 203   struct frame* f = ew->emacs_frame.frame;
 204   *pixel_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, char_width);
 205   *pixel_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, char_height);
 206 }
 207
 208 static void
 209 round_size_to_char (EmacsFrame ew, Dimension in_width, Dimension in_height, Dimension *out_width, Dimension *out_height)
 210 {
 211   int char_width;
 212   int char_height;
 213   pixel_to_char_size (ew, in_width, in_height, &char_width, &char_height);
 214   char_to_pixel_size (ew, char_width, char_height, out_width, out_height);
 215 }
 216
 217 static Widget
 218 get_wm_shell (Widget w)
 219 {
 220   Widget wmshell;
 221
 222   for (wmshell = XtParent (w);
 223        wmshell && !XtIsWMShell (wmshell);
 224        wmshell = XtParent (wmshell));
 225
 226   return wmshell;
 227 }
 228
 229 #if 0 /* Currently not used.  */
 230
 231 static void
 232 mark_shell_size_user_specified (Widget wmshell)
 233 {
 234   if (! XtIsWMShell (wmshell)) emacs_abort ();
 235   /* This is kind of sleazy, but I can't see how else to tell it to make it
 236      mark the WM_SIZE_HINTS size as user specified when appropriate. */
 237   ((WMShellWidget) wmshell)->wm.size_hints.flags |= USSize;
 238 }
 239
 240 #endif
 241
 242
 243 /* Can't have static frame locals because of some broken compilers.
 244    Normally, initializing a variable like this doesn't work in emacs,
 245    but it's ok in this file because it must come after lastfile (and
 246    thus have its data not go into text space) because Xt needs to
 247    write to initialized data objects too.
 248  */
 249 #if 0
 250 static Boolean first_frame_p = True;
 251 #endif
 252
 253 static void
 254 set_frame_size (EmacsFrame ew)
 255 {
 256   /* The widget hierarchy is
 257
 258         argv[0]                 emacsShell      pane    Frame-NAME
 259         ApplicationShell        EmacsShell      Paned   EmacsFrame
 260
 261      We accept geometry specs in this order:
 262
 263         *Frame-NAME.geometry
 264         *EmacsFrame.geometry
 265         Emacs.geometry
 266
 267      Other possibilities for widget hierarchies might be
 268
 269         argv[0]                 frame           pane    Frame-NAME
 270         ApplicationShell        EmacsShell      Paned   EmacsFrame
 271      or
 272         argv[0]                 Frame-NAME      pane    Frame-NAME
 273         ApplicationShell        EmacsShell      Paned   EmacsFrame
 274      or
 275         argv[0]                 Frame-NAME      pane    emacsTextPane
 276         ApplicationShell        EmacsFrame      Paned   EmacsTextPane
 277
 278      With the current setup, the text-display-area is the part which is
 279      an emacs "frame", since that's the only part managed by emacs proper
 280      (the menubar and the parent of the menubar and all that sort of thing
 281      are managed by lwlib.)
 282
 283      The EmacsShell widget is simply a replacement for the Shell widget
 284      which is able to deal with using an externally-supplied window instead
 285      of always creating its own.  It is not actually emacs specific, and
 286      should possibly have class "Shell" instead of "EmacsShell" to simplify
 287      the resources.
 288
 289    */
 290
 291   /* Hairily merged geometry */
 292   unsigned int w = FRAME_COLS (ew->emacs_frame.frame);
 293   unsigned int h = FRAME_LINES (ew->emacs_frame.frame);
 294
 295   Widget wmshell = get_wm_shell ((Widget) ew);
 296   /* Each Emacs shell is now independent and top-level.  */
 297
 298   if (! XtIsSubclass (wmshell, shellWidgetClass)) emacs_abort ();
 299
 300   /* We don't need this for the moment. The geometry is computed in
 301      xfns.c.  */
 302 #if 0
 303   /* If the EmacsFrame doesn't have a geometry but the shell does,
 304      treat that as the geometry of the frame.  (Is this bogus?
 305      I'm not sure.) */
 306   if (ew->emacs_frame.geometry == 0)
 307     XtVaGetValues (wmshell, XtNgeometry, &ew->emacs_frame.geometry, NULL);
 308
 309   /* If the Shell is iconic, then the EmacsFrame is iconic.  (Is
 310      this bogus? I'm not sure.) */
 311   if (!ew->emacs_frame.iconic)
 312     XtVaGetValues (wmshell, XtNiconic, &ew->emacs_frame.iconic, NULL);
 313
 314
 315   {
 316     char *geom = 0;
 317     XtVaGetValues (app_shell, XtNgeometry, &geom, NULL);
 318     if (geom)
 319       app_flags = XParseGeometry (geom, &app_x, &app_y, &app_w, &app_h);
 320   }
 321
 322   if (ew->emacs_frame.geometry)
 323     frame_flags = XParseGeometry (ew->emacs_frame.geometry,
 324                                    &frame_x, &frame_y,
 325                                    &frame_w, &frame_h);
 326
 327   if (first_frame_p)
 328     {
 329       /* If this is the first frame created:
 330          ====================================
 331
 332          - Use the ApplicationShell's size/position, if specified.
 333            (This is "Emacs.geometry", or the "-geometry" command line arg.)
 334          - Else use the EmacsFrame's size/position.
 335            (This is "*Frame-NAME.geometry")
 336
 337          - If the AppShell is iconic, the frame should be iconic.
 338
 339          AppShell comes first so that -geometry always applies to the first
 340          frame created, even if there is an "every frame" entry in the
 341          resource database.
 342        */
 343       if (app_flags & (XValue | YValue))
 344         {
 345           x = app_x; y = app_y;
 346           flags |= (app_flags & (XValue | YValue | XNegative | YNegative));
 347         }
 348       else if (frame_flags & (XValue | YValue))
 349         {
 350           x = frame_x; y = frame_y;
 351           flags |= (frame_flags & (XValue | YValue | XNegative | YNegative));
 352         }
 353
 354       if (app_flags & (WidthValue | HeightValue))
 355         {
 356           w = app_w; h = app_h;
 357           flags |= (app_flags & (WidthValue | HeightValue));
 358         }
 359       else if (frame_flags & (WidthValue | HeightValue))
 360         {
 361           w = frame_w; h = frame_h;
 362           flags |= (frame_flags & (WidthValue | HeightValue));
 363         }
 364
 365       /* If the AppShell is iconic, then the EmacsFrame is iconic. */
 366       if (!ew->emacs_frame.iconic)
 367         XtVaGetValues (app_shell, XtNiconic, &ew->emacs_frame.iconic, NULL);
 368
 369       first_frame_p = False;
 370     }
 371   else
 372     {
 373       /* If this is not the first frame created:
 374          ========================================
 375
 376          - use the EmacsFrame's size/position if specified
 377          - Otherwise, use the ApplicationShell's size, but not position.
 378
 379          So that means that one can specify the position of the first frame
 380          with "Emacs.geometry" or `-geometry'; but can only specify the
 381          position of subsequent frames with "*Frame-NAME.geometry".
 382
 383          AppShell comes second so that -geometry does not apply to subsequent
 384          frames when there is an "every frame" entry in the resource db,
 385          but does apply to the first frame.
 386        */
 387       if (frame_flags & (XValue | YValue))
 388         {
 389           x = frame_x; y = frame_y;
 390           flags |= (frame_flags & (XValue | YValue | XNegative | YNegative));
 391         }
 392
 393       if (frame_flags & (WidthValue | HeightValue))
 394         {
 395           w = frame_w; h = frame_h;
 396           flags |= (frame_flags & (WidthValue | HeightValue));
 397         }
 398       else if (app_flags & (WidthValue | HeightValue))
 399         {
 400           w = app_w;
 401           h = app_h;
 402           flags |= (app_flags & (WidthValue | HeightValue));
 403         }
 404     }
 405 #endif /* 0 */
 406   {
 407     struct frame *f = ew->emacs_frame.frame;
 408     Dimension pixel_width, pixel_height;
 409
 410     /* Take into account the size of the scrollbar.  Always use the
 411        number of columns occupied by the scroll bar here otherwise we
 412        might end up with a frame width that is not a multiple of the
 413        frame's character width which is bad for vertically split
 414        windows.  */
 415
 416     compute_fringe_widths (f, 0);
 417
 418 #if 0 /* This can run Lisp code, and it is dangerous to give
 419          out the frame to Lisp code before it officially exists.
 420          This is handled in Fx_create_frame so not needed here.  */
 421     change_frame_size (f, w, h, 1, 0, 0, 0);
 422 #endif
 423     char_to_pixel_size (ew, w, h, &pixel_width, &pixel_height);
 424     ew->core.width = pixel_width;
 425     ew->core.height = pixel_height;
 426
 427 #if 0 /* xfns.c takes care of this now.  */
 428     /* If a position was specified, assign it to the shell widget.
 429        (Else WM won't do anything with it.)
 430      */
 431     if (flags & (XValue | YValue))
 432       {
 433         /* the tricky things with the sign is to make sure that
 434            -0 is printed -0. */
 435         sprintf (shell_position, "=%c%d%c%d",
 436                  flags & XNegative ? '-' : '+', x < 0 ? -x : x,
 437                  flags & YNegative ? '-' : '+', y < 0 ? -y : y);
 438         XtVaSetValues (wmshell, XtNgeometry, xstrdup (shell_position), NULL);
 439       }
 440     else if (flags & (WidthValue | HeightValue))
 441       {
 442         sprintf (shell_position, "=%dx%d", pixel_width, pixel_height);
 443         XtVaSetValues (wmshell, XtNgeometry, xstrdup (shell_position), NULL);
 444       }
 445
 446     /* If the geometry spec we're using has W/H components, mark the size
 447        in the WM_SIZE_HINTS as user specified. */
 448     if (flags & (WidthValue | HeightValue))
 449       mark_shell_size_user_specified (wmshell);
 450
 451     /* Also assign the iconic status of the frame to the Shell, so that
 452        the WM sees it. */
 453     XtVaSetValues (wmshell, XtNiconic, ew->emacs_frame.iconic, NULL);
 454 #endif /* 0 */
 455   }
 456 }
 457
 458 static void
 459 update_wm_hints (EmacsFrame ew)
 460 {
 461   Widget wmshell = get_wm_shell ((Widget)ew);
 462   int cw;
 463   int ch;
 464   Dimension rounded_width;
 465   Dimension rounded_height;
 466   int char_width;
 467   int char_height;
 468   int base_width;
 469   int base_height;
 470   int min_rows = 0, min_cols = 0;
 471
 472   /* This happens when the frame is just created.  */
 473   if (! wmshell) return;
 474
 475 #if 0
 476   check_frame_size (ew->emacs_frame.frame, &min_cols, &min_rows, 0);
 477 #endif
 478
 479   pixel_to_char_size (ew, ew->core.width, ew->core.height,
 480                       &char_width, &char_height);
 481   char_to_pixel_size (ew, char_width, char_height,
 482                       &rounded_width, &rounded_height);
 483   get_default_char_pixel_size (ew, &cw, &ch);
 484
 485   base_width = (wmshell->core.width - ew->core.width
 486                 + (rounded_width - (char_width * cw)));
 487   base_height = (wmshell->core.height - ew->core.height
 488                 + (rounded_height - (char_height * ch)));
 489
 490   /* This is kind of sleazy, but I can't see how else to tell it to
 491      make it mark the WM_SIZE_HINTS size as user specified.
 492    */
 493 /*  ((WMShellWidget) wmshell)->wm.size_hints.flags |= USSize;*/
 494
 495   XtVaSetValues (wmshell,
 496                  XtNbaseWidth, (XtArgVal) base_width,
 497                  XtNbaseHeight, (XtArgVal) base_height,
 498                  XtNwidthInc, (XtArgVal) (frame_resize_pixelwise ? 1 : cw),
 499                  XtNheightInc, (XtArgVal) (frame_resize_pixelwise ? 1 : ch),
 500                  XtNminWidth, (XtArgVal) (base_width + min_cols * cw),
 501                  XtNminHeight, (XtArgVal) (base_height + min_rows * ch),
 502                  NULL);
 503 }
 504
 505 void
 506 widget_update_wm_size_hints (Widget widget)
 507 {
 508   EmacsFrame ew = (EmacsFrame)widget;
 509   update_wm_hints (ew);
 510 }
 511
 512 static char setup_frame_cursor_bits[] =
 513 {
 514   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 515   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 516   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 517   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 518 };
 519
 520 static void
 521 setup_frame_gcs (EmacsFrame ew)
 522 {
 523   XGCValues gc_values;
 524   struct frame* s = ew->emacs_frame.frame;
 525   Pixmap blank_stipple, blank_tile;
 526   unsigned long valuemask = (GCForeground | GCBackground | GCGraphicsExposures
 527                              | GCStipple | GCTile);
 528   Lisp_Object font;
 529
 530   XSETFONT (font, ew->emacs_frame.font);
 531   font = Ffont_xlfd_name (font, Qnil);
 532   if (STRINGP (font))
 533     {
 534       XFontStruct *xfont = XLoadQueryFont (FRAME_DISPLAY_INFO (s)->display,
 535                                            SSDATA (font));
 536       if (xfont)
 537         {
 538           gc_values.font = xfont->fid;
 539           valuemask |= GCFont;
 540         }
 541     }
 542
 543   /* We have to initialize all of our GCs to have a stipple/tile, otherwise
 544      XGetGCValues returns uninitialized data when we query the stipple
 545      (instead of None or something sensible) and it makes things hard.
 546
 547      This should be fixed for real by not querying the GCs but instead having
 548      some GC-based cache instead of the current face-based cache which doesn't
 549      effectively cache all of the GC settings we need to use.
 550    */
 551
 552   blank_stipple
 553     = XCreateBitmapFromData (XtDisplay (ew),
 554                              RootWindowOfScreen (XtScreen (ew)),
 555                              setup_frame_cursor_bits, 2, 2);
 556
 557   /* use fg = 0, bg = 1 below, but it's irrelevant since this pixmap should
 558      never actually get used as a background tile!
 559    */
 560   blank_tile
 561     = XCreatePixmapFromBitmapData (XtDisplay (ew),
 562                                    RootWindowOfScreen (XtScreen (ew)),
 563                                    setup_frame_cursor_bits, 2, 2,
 564                                    0, 1, ew->core.depth);
 565
 566   /* Normal video */
 567   gc_values.foreground = ew->emacs_frame.foreground_pixel;
 568   gc_values.background = ew->core.background_pixel;
 569   gc_values.graphics_exposures = False;
 570   gc_values.stipple = blank_stipple;
 571   gc_values.tile = blank_tile;
 572   XChangeGC (XtDisplay (ew), s->output_data.x->normal_gc,
 573              valuemask, &gc_values);
 574
 575   /* Reverse video style. */
 576   gc_values.foreground = ew->core.background_pixel;
 577   gc_values.background = ew->emacs_frame.foreground_pixel;
 578   gc_values.graphics_exposures = False;
 579   gc_values.stipple = blank_stipple;
 580   gc_values.tile = blank_tile;
 581   XChangeGC (XtDisplay (ew), s->output_data.x->reverse_gc,
 582              valuemask, &gc_values);
 583
 584   /* Cursor has to have an empty stipple. */
 585   gc_values.foreground = ew->core.background_pixel;
 586   gc_values.background = ew->emacs_frame.cursor_color;
 587   gc_values.graphics_exposures = False;
 588   gc_values.tile = blank_tile;
 589   gc_values.stipple
 590     = XCreateBitmapFromData (XtDisplay (ew),
 591                              RootWindowOfScreen (XtScreen (ew)),
 592                              setup_frame_cursor_bits, 16, 16);
 593   XChangeGC (XtDisplay (ew), s->output_data.x->cursor_gc,
 594              valuemask, &gc_values);
 595 }
 596
 597 static void
 598 update_various_frame_slots (EmacsFrame ew)
 599 {
 600   struct frame *f = ew->emacs_frame.frame;
 601   struct x_output *x = f->output_data.x;
 602   /* Don't do that: It confuses the check in change_frame_size_1 whether
 603      the pixel size of the frame changed due to a change of the internal
 604      border width.  Bug#16736.  */
 605 #if 0
 606   FRAME_PIXEL_HEIGHT (f) = ew->core.height + x->menubar_height;
 607   FRAME_PIXEL_WIDTH (f) = ew->core.width;
 608 #endif
 609   f->internal_border_width = ew->emacs_frame.internal_border_width;
 610
 611 }
 612
 613 static void
 614 update_from_various_frame_slots (EmacsFrame ew)
 615 {
 616   struct frame *f = ew->emacs_frame.frame;
 617   struct x_output *x = f->output_data.x;
 618   ew->core.height = FRAME_PIXEL_HEIGHT (f) - x->menubar_height;
 619   ew->core.width = FRAME_PIXEL_WIDTH (f);
 620   ew->core.background_pixel = FRAME_BACKGROUND_PIXEL (f);
 621   ew->emacs_frame.internal_border_width = f->internal_border_width;
 622   ew->emacs_frame.font = x->font;
 623   ew->emacs_frame.foreground_pixel = FRAME_FOREGROUND_PIXEL (f);
 624   ew->emacs_frame.cursor_color = x->cursor_pixel;
 625   ew->core.border_pixel = x->border_pixel;
 626 }
 627
 628 static void
 629 EmacsFrameInitialize (Widget request, Widget new, ArgList dum1, Cardinal *dum2)
 630 {
 631   EmacsFrame ew = (EmacsFrame)new;
 632
 633   if (!ew->emacs_frame.frame)
 634     {
 635       fprintf (stderr,
 636                "can't create an emacs frame widget without a frame\n");
 637       exit (1);
 638     }
 639
 640   update_from_various_frame_slots (ew);
 641   set_frame_size (ew);
 642 }
 643
 644 static void
 645 resize_cb (Widget widget,
 646            XtPointer closure,
 647            XEvent* event,
 648            Boolean* continue_to_dispatch)
 649 {
 650   EmacsFrameResize (widget);
 651 }
 652
 653
 654 static void
 655 EmacsFrameRealize (Widget widget, XtValueMask *mask, XSetWindowAttributes *attrs)
 656 {
 657   EmacsFrame ew = (EmacsFrame)widget;
 658
 659   /* This used to contain SubstructureRedirectMask, but this turns out
 660      to be a problem with XIM on Solaris, and events from that mask
 661      don't seem to be used.  Let's check that.  */
 662   attrs->event_mask = (STANDARD_EVENT_SET
 663                        | PropertyChangeMask
 664                        | SubstructureNotifyMask);
 665   *mask |= CWEventMask;
 666   XtCreateWindow (widget, InputOutput, (Visual *)CopyFromParent, *mask,
 667                   attrs);
 668   /* Some ConfigureNotify events does not end up in EmacsFrameResize so
 669      make sure we get them all.  Seen with xfcwm4 for example.  */
 670   XtAddRawEventHandler (widget, StructureNotifyMask, False, resize_cb, NULL);
 671   update_wm_hints (ew);
 672 }
 673
 674 static void
 675 EmacsFrameDestroy (Widget widget)
 676 {
 677   /* All GCs are now freed in x_free_frame_resources.  */
 678 }
 679
 680 static void
 681 EmacsFrameResize (Widget widget)
 682 {
 683   EmacsFrame ew = (EmacsFrame)widget;
 684   struct frame *f = ew->emacs_frame.frame;
 685   struct x_output *x = f->output_data.x;
 686
 687 #if 0  /* Always process resize requests pixelwise.  Frame maximizing
 688           should work even when frame_resize_pixelwise is nil.  */
 689   if (frame_resize_pixelwise)
 690     {
 691 #endif /* 0 */
 692       int width, height;
 693
 694       pixel_to_text_size (ew, ew->core.width, ew->core.height, &width, &height);
 695       change_frame_size (f, width, height, 0, 1, 0, 1);
 696
 697       update_wm_hints (ew);
 698       update_various_frame_slots (ew);
 699
 700       cancel_mouse_face (f);
 701 #if 0  /* See comment above.  */
 702     }
 703   else
 704     {
 705       int columns, rows;
 706
 707       pixel_to_char_size (ew, ew->core.width, ew->core.height, &columns, &rows);
 708       if (columns != FRAME_COLS (f)
 709           || rows != FRAME_LINES (f)
 710           || ew->core.width != FRAME_PIXEL_WIDTH (f)
 711           || ew->core.height + x->menubar_height != FRAME_PIXEL_HEIGHT (f))
 712         {
 713           change_frame_size (f, columns, rows, 0, 1, 0, 0);
 714           update_wm_hints (ew);
 715           update_various_frame_slots (ew);
 716
 717           cancel_mouse_face (f);
 718         }
 719     }
 720 #endif /* 0 */
 721 }
 722
 723 static Boolean
 724 EmacsFrameSetValues (Widget cur_widget, Widget req_widget, Widget new_widget, ArgList dum1, Cardinal *dum2)
 725 {
 726   EmacsFrame cur = (EmacsFrame)cur_widget;
 727   EmacsFrame new = (EmacsFrame)new_widget;
 728
 729   Boolean needs_a_refresh = False;
 730   Boolean has_to_recompute_size;
 731   Boolean has_to_recompute_gcs;
 732   Boolean has_to_update_hints;
 733
 734   int char_width, char_height;
 735   Dimension pixel_width;
 736   Dimension pixel_height;
 737
 738   /* AFAIK, this function is never called. -- Jan D, Oct 2009.  */
 739   has_to_recompute_gcs = (cur->emacs_frame.font != new->emacs_frame.font
 740                           || (cur->emacs_frame.foreground_pixel
 741                               != new->emacs_frame.foreground_pixel)
 742                           || (cur->core.background_pixel
 743                               != new->core.background_pixel)
 744                           );
 745
 746   has_to_recompute_size = (cur->emacs_frame.font != new->emacs_frame.font
 747                            && cur->core.width == new->core.width
 748                            && cur->core.height == new->core.height);
 749
 750   has_to_update_hints = (cur->emacs_frame.font != new->emacs_frame.font);
 751
 752   if (has_to_recompute_gcs)
 753     {
 754       setup_frame_gcs (new);
 755       needs_a_refresh = True;
 756     }
 757
 758   if (has_to_recompute_size)
 759     {
 760       /* Don't do this pixelwise, hopefully.  */
 761       pixel_width = new->core.width;
 762       pixel_height = new->core.height;
 763       pixel_to_char_size (new, pixel_width, pixel_height, &char_width,
 764                           &char_height);
 765       char_to_pixel_size (new, char_width, char_height, &pixel_width,
 766                           &pixel_height);
 767       new->core.width = pixel_width;
 768       new->core.height = pixel_height;
 769
 770       change_frame_size (new->emacs_frame.frame, char_width, char_height,
 771                          1, 0, 0, 0);
 772       needs_a_refresh = True;
 773     }
 774
 775   if (has_to_update_hints)
 776     update_wm_hints (new);
 777
 778   update_various_frame_slots (new);
 779
 780   /* #### This doesn't work, I haven't been able to find ANY kludge that
 781      will let (x-create-frame '((iconic . t))) work.  It seems that changes
 782      to wm_shell's iconic slot have no effect after it has been realized,
 783      and calling XIconifyWindow doesn't work either (even though the window
 784      has been created.)  Perhaps there is some property we could smash
 785      directly, but I'm sick of this for now.
 786    */
 787   if (cur->emacs_frame.iconic != new->emacs_frame.iconic)
 788     {
 789       Widget wmshell = get_wm_shell ((Widget) cur);
 790       XtVaSetValues (wmshell, XtNiconic,
 791                      (XtArgVal) new->emacs_frame.iconic, NULL);
 792     }
 793
 794   return needs_a_refresh;
 795 }
 796
 797 static XtGeometryResult
 798 EmacsFrameQueryGeometry (Widget widget, XtWidgetGeometry *request, XtWidgetGeometry *result)
 799 {
 800   EmacsFrame ew = (EmacsFrame)widget;
 801
 802   int mask = request->request_mode;
 803   Dimension ok_width, ok_height;
 804
 805   if (mask & (CWWidth | CWHeight))
 806     {
 807       round_size_to_char (ew,
 808                           (mask & CWWidth) ? request->width : ew->core.width,
 809                           ((mask & CWHeight) ? request->height
 810                            : ew->core.height),
 811                           &ok_width, &ok_height);
 812       if ((mask & CWWidth) && (ok_width != request->width))
 813         {
 814           result->request_mode |= CWWidth;
 815           result->width = ok_width;
 816         }
 817       if ((mask & CWHeight) && (ok_height != request->height))
 818         {
 819           result->request_mode |= CWHeight;
 820           result->height = ok_height;
 821         }
 822     }
 823   return result->request_mode ? XtGeometryAlmost : XtGeometryYes;
 824 }
 825
 826 /* Special entry points */
 827 void
 828 EmacsFrameSetCharSize (Widget widget, int columns, int rows)
 829 {
 830   EmacsFrame ew = (EmacsFrame) widget;
 831   struct frame *f = ew->emacs_frame.frame;
 832
 833   x_set_window_size (f, 0, columns, rows, 0);
 834 }
 835
 836 \f
 837 void
 838 widget_store_internal_border (Widget widget)
 839 {
 840   EmacsFrame ew = (EmacsFrame) widget;
 841   struct frame *f = ew->emacs_frame.frame;
 842
 843   ew->emacs_frame.internal_border_width = f->internal_border_width;
 844 }