src/widget.c

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