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   FRAME_PIXEL_HEIGHT (f) = ew->core.height + x->menubar_height;
 603   FRAME_PIXEL_WIDTH (f) = ew->core.width;
 604   f->internal_border_width = ew->emacs_frame.internal_border_width;
 605
 606 }
 607
 608 static void
 609 update_from_various_frame_slots (EmacsFrame ew)
 610 {
 611   struct frame *f = ew->emacs_frame.frame;
 612   struct x_output *x = f->output_data.x;
 613   ew->core.height = FRAME_PIXEL_HEIGHT (f) - x->menubar_height;
 614   ew->core.width = FRAME_PIXEL_WIDTH (f);
 615   ew->core.background_pixel = FRAME_BACKGROUND_PIXEL (f);
 616   ew->emacs_frame.internal_border_width = f->internal_border_width;
 617   ew->emacs_frame.font = x->font;
 618   ew->emacs_frame.foreground_pixel = FRAME_FOREGROUND_PIXEL (f);
 619   ew->emacs_frame.cursor_color = x->cursor_pixel;
 620   ew->core.border_pixel = x->border_pixel;
 621 }
 622
 623 static void
 624 EmacsFrameInitialize (Widget request, Widget new, ArgList dum1, Cardinal *dum2)
 625 {
 626   EmacsFrame ew = (EmacsFrame)new;
 627
 628   if (!ew->emacs_frame.frame)
 629     {
 630       fprintf (stderr,
 631                "can't create an emacs frame widget without a frame\n");
 632       exit (1);
 633     }
 634
 635   update_from_various_frame_slots (ew);
 636   set_frame_size (ew);
 637 }
 638
 639 static void
 640 resize_cb (Widget widget,
 641            XtPointer closure,
 642            XEvent* event,
 643            Boolean* continue_to_dispatch)
 644 {
 645   EmacsFrameResize (widget);
 646 }
 647
 648
 649 static void
 650 EmacsFrameRealize (Widget widget, XtValueMask *mask, XSetWindowAttributes *attrs)
 651 {
 652   EmacsFrame ew = (EmacsFrame)widget;
 653
 654   /* This used to contain SubstructureRedirectMask, but this turns out
 655      to be a problem with XIM on Solaris, and events from that mask
 656      don't seem to be used.  Let's check that.  */
 657   attrs->event_mask = (STANDARD_EVENT_SET
 658                        | PropertyChangeMask
 659                        | SubstructureNotifyMask);
 660   *mask |= CWEventMask;
 661   XtCreateWindow (widget, InputOutput, (Visual *)CopyFromParent, *mask,
 662                   attrs);
 663   /* Some ConfigureNotify events does not end up in EmacsFrameResize so
 664      make sure we get them all.  Seen with xfcwm4 for example.  */
 665   XtAddRawEventHandler (widget, StructureNotifyMask, False, resize_cb, NULL);
 666   update_wm_hints (ew);
 667 }
 668
 669 static void
 670 EmacsFrameDestroy (Widget widget)
 671 {
 672   /* All GCs are now freed in x_free_frame_resources.  */
 673 }
 674
 675 static void
 676 EmacsFrameResize (Widget widget)
 677 {
 678   EmacsFrame ew = (EmacsFrame)widget;
 679   struct frame *f = ew->emacs_frame.frame;
 680   struct x_output *x = f->output_data.x;
 681
 682 #if 0  /* Always process resize requests pixelwise.  Frame maximizing
 683           should work even when frame_resize_pixelwise is nil.  */
 684   if (frame_resize_pixelwise)
 685     {
 686 #endif /* 0 */
 687       int width, height;
 688
 689       pixel_to_text_size (ew, ew->core.width, ew->core.height, &width, &height);
 690       change_frame_size (f, width, height, 0, 1, 0, 1);
 691
 692       update_wm_hints (ew);
 693       update_various_frame_slots (ew);
 694
 695       cancel_mouse_face (f);
 696 #if 0  /* See comment above.  */
 697     }
 698   else
 699     {
 700       int columns, rows;
 701
 702       pixel_to_char_size (ew, ew->core.width, ew->core.height, &columns, &rows);
 703       if (columns != FRAME_COLS (f)
 704           || rows != FRAME_LINES (f)
 705           || ew->core.width != FRAME_PIXEL_WIDTH (f)
 706           || ew->core.height + x->menubar_height != FRAME_PIXEL_HEIGHT (f))
 707         {
 708           change_frame_size (f, columns, rows, 0, 1, 0, 0);
 709           update_wm_hints (ew);
 710           update_various_frame_slots (ew);
 711
 712           cancel_mouse_face (f);
 713         }
 714     }
 715 #endif /* 0 */
 716 }
 717
 718 static Boolean
 719 EmacsFrameSetValues (Widget cur_widget, Widget req_widget, Widget new_widget, ArgList dum1, Cardinal *dum2)
 720 {
 721   EmacsFrame cur = (EmacsFrame)cur_widget;
 722   EmacsFrame new = (EmacsFrame)new_widget;
 723
 724   Boolean needs_a_refresh = False;
 725   Boolean has_to_recompute_size;
 726   Boolean has_to_recompute_gcs;
 727   Boolean has_to_update_hints;
 728
 729   int char_width, char_height;
 730   Dimension pixel_width;
 731   Dimension pixel_height;
 732
 733   /* AFAIK, this function is never called. -- Jan D, Oct 2009.  */
 734   has_to_recompute_gcs = (cur->emacs_frame.font != new->emacs_frame.font
 735                           || (cur->emacs_frame.foreground_pixel
 736                               != new->emacs_frame.foreground_pixel)
 737                           || (cur->core.background_pixel
 738                               != new->core.background_pixel)
 739                           );
 740
 741   has_to_recompute_size = (cur->emacs_frame.font != new->emacs_frame.font
 742                            && cur->core.width == new->core.width
 743                            && cur->core.height == new->core.height);
 744
 745   has_to_update_hints = (cur->emacs_frame.font != new->emacs_frame.font);
 746
 747   if (has_to_recompute_gcs)
 748     {
 749       setup_frame_gcs (new);
 750       needs_a_refresh = True;
 751     }
 752
 753   if (has_to_recompute_size)
 754     {
 755       /* Don't do this pixelwise, hopefully.  */
 756       pixel_width = new->core.width;
 757       pixel_height = new->core.height;
 758       pixel_to_char_size (new, pixel_width, pixel_height, &char_width,
 759                           &char_height);
 760       char_to_pixel_size (new, char_width, char_height, &pixel_width,
 761                           &pixel_height);
 762       new->core.width = pixel_width;
 763       new->core.height = pixel_height;
 764
 765       change_frame_size (new->emacs_frame.frame, char_width, char_height,
 766                          1, 0, 0, 0);
 767       needs_a_refresh = True;
 768     }
 769
 770   if (has_to_update_hints)
 771     update_wm_hints (new);
 772
 773   update_various_frame_slots (new);
 774
 775   /* #### This doesn't work, I haven't been able to find ANY kludge that
 776      will let (x-create-frame '((iconic . t))) work.  It seems that changes
 777      to wm_shell's iconic slot have no effect after it has been realized,
 778      and calling XIconifyWindow doesn't work either (even though the window
 779      has been created.)  Perhaps there is some property we could smash
 780      directly, but I'm sick of this for now.
 781    */
 782   if (cur->emacs_frame.iconic != new->emacs_frame.iconic)
 783     {
 784       Widget wmshell = get_wm_shell ((Widget) cur);
 785       XtVaSetValues (wmshell, XtNiconic,
 786                      (XtArgVal) new->emacs_frame.iconic, NULL);
 787     }
 788
 789   return needs_a_refresh;
 790 }
 791
 792 static XtGeometryResult
 793 EmacsFrameQueryGeometry (Widget widget, XtWidgetGeometry *request, XtWidgetGeometry *result)
 794 {
 795   EmacsFrame ew = (EmacsFrame)widget;
 796
 797   int mask = request->request_mode;
 798   Dimension ok_width, ok_height;
 799
 800   if (mask & (CWWidth | CWHeight))
 801     {
 802       round_size_to_char (ew,
 803                           (mask & CWWidth) ? request->width : ew->core.width,
 804                           ((mask & CWHeight) ? request->height
 805                            : ew->core.height),
 806                           &ok_width, &ok_height);
 807       if ((mask & CWWidth) && (ok_width != request->width))
 808         {
 809           result->request_mode |= CWWidth;
 810           result->width = ok_width;
 811         }
 812       if ((mask & CWHeight) && (ok_height != request->height))
 813         {
 814           result->request_mode |= CWHeight;
 815           result->height = ok_height;
 816         }
 817     }
 818   return result->request_mode ? XtGeometryAlmost : XtGeometryYes;
 819 }
 820
 821 /* Special entry points */
 822 void
 823 EmacsFrameSetCharSize (Widget widget, int columns, int rows)
 824 {
 825   EmacsFrame ew = (EmacsFrame) widget;
 826   struct frame *f = ew->emacs_frame.frame;
 827
 828   x_set_window_size (f, 0, columns, rows, 0);
 829 }
 830
 831 \f
 832 void
 833 widget_store_internal_border (Widget widget)
 834 {
 835   EmacsFrame ew = (EmacsFrame) widget;
 836   struct frame *f = ew->emacs_frame.frame;
 837
 838   ew->emacs_frame.internal_border_width = f->internal_border_width;
 839 }