src/widget.c

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