git.chise.org Git - chise/xemacs-chise.git.1/blob - src/frame-msw.c

   1 /* Functions for the mswindows window system.
   2    Copyright (C) 1989, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
   3    Copyright (C) 1995, 1996 Ben Wing.
   4
   5 This file is part of XEmacs.
   6
   7 XEmacs is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU General Public License as published by the
   9 Free Software Foundation; either version 2, or (at your option) any
  10 later version.
  11
  12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
  13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with XEmacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 /* Synched up with: Not synched with FSF. */
  23
  24 /* Authorship:
  25
  26    Ultimately based on FSF.
  27    Substantially rewritten for XEmacs by Ben Wing.
  28    Rewritten for mswindows by Jonathan Harris, November 1997 for 21.0.
  29    Graphics features added and frame resizing fiddled with by Andy Piper.
  30  */
  31
  32 #include <config.h>
  33 #include "lisp.h"
  34
  35 #include "buffer.h"
  36 #include "elhash.h"
  37 #include "console-msw.h"
  38 #include "glyphs-msw.h"
  39 #include "elhash.h"
  40 #include "events.h"
  41 #include "faces.h"
  42 #include "frame.h"
  43 #include "redisplay.h"
  44 #include "window.h"
  45
  46 #define MSWINDOWS_FRAME_STYLE (WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_OVERLAPPEDWINDOW)
  47 #define MSWINDOWS_POPUP_STYLE (WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_POPUP \
  48                                | WS_CAPTION | WS_BORDER | WS_SYSMENU | WS_MINIMIZEBOX)
  49
  50 #define MSWINDOWS_FRAME_EXSTYLE WS_EX_OVERLAPPEDWINDOW
  51 #define MSWINDOWS_POPUP_EXSTYLE WS_EX_PALETTEWINDOW
  52
  53 /* Default popup left top corner offset from the same
  54    corner of the parent frame, in pixel */
  55 #define POPUP_OFFSET 30
  56
  57 /* Default popup size, in characters */
  58 #define POPUP_WIDTH 30
  59 #define POPUP_HEIGHT 10
  60
  61 /* Default popup size, in characters */
  62 #define DEFAULT_FRAME_WIDTH 80
  63 #define DEFAULT_FRAME_HEIGHT 35
  64
  65 #ifdef HAVE_MENUBARS
  66 #define ADJR_MENUFLAG TRUE
  67 #else
  68 #define ADJR_MENUFLAG FALSE
  69 #endif
  70
  71 /* Default properties to use when creating frames.  */
  72 Lisp_Object Vdefault_mswindows_frame_plist;
  73 Lisp_Object Vmswindows_use_system_frame_size_defaults;
  74
  75 /* This does not need to be GC protected, as it holds a
  76    frame Lisp_Object already protected by Fmake_frame */
  77 Lisp_Object Vmswindows_frame_being_created;
  78
  79 static void
  80 mswindows_init_frame_1 (struct frame *f, Lisp_Object props)
  81 {
  82   Lisp_Object initially_unmapped;
  83   Lisp_Object name, height, width, popup, top, left;
  84   Lisp_Object frame_obj = Qnil;
  85   RECT rect;
  86   XEMACS_RECT_WH rect_default;
  87   DWORD style, exstyle;
  88   HWND hwnd, hwnd_parent;
  89
  90   /* Pick up relevant properties */
  91   initially_unmapped = Fplist_get (props, Qinitially_unmapped, Qnil);
  92   name = Fplist_get (props, Qname, Qnil);
  93
  94   popup = Fplist_get (props, Qpopup, Qnil);
  95   if (EQ (popup, Qt))
  96     popup = Fselected_frame (Qnil);
  97
  98   left = Fplist_get (props, Qleft, Qnil);
  99   if (!NILP (left))
 100     CHECK_INT (left);
 101
 102   top = Fplist_get (props, Qtop, Qnil);
 103   if (!NILP (top))
 104     CHECK_INT (top);
 105
 106   width = Fplist_get (props, Qwidth, Qnil);
 107   if (!NILP (width))
 108     CHECK_INT (width);
 109
 110   height = Fplist_get (props, Qheight, Qnil);
 111   if (!NILP (height))
 112     CHECK_INT (height);
 113
 114   f->frame_data = xnew_and_zero (struct mswindows_frame);
 115   FRAME_MSWINDOWS_TARGET_RECT (f) = xnew_and_zero (XEMACS_RECT_WH);
 116
 117   FRAME_MSWINDOWS_TARGET_RECT (f)->left = NILP (left) ? -1 : abs (XINT (left));
 118   FRAME_MSWINDOWS_TARGET_RECT (f)->top = NILP (top) ? -1 : abs (XINT (top));
 119   FRAME_MSWINDOWS_TARGET_RECT (f)->width = NILP (width) ? -1 :
 120     abs (XINT (width));
 121   FRAME_MSWINDOWS_TARGET_RECT (f)->height = NILP (height) ? -1 :
 122     abs (XINT (height));
 123
 124   /* Misc frame stuff */
 125   FRAME_MSWINDOWS_DATA(f)->button2_need_lbutton = 0;
 126   FRAME_MSWINDOWS_DATA(f)->button2_need_rbutton = 0;
 127   FRAME_MSWINDOWS_DATA(f)->button2_is_down = 0;
 128   FRAME_MSWINDOWS_DATA(f)->ignore_next_lbutton_up = 0;
 129   FRAME_MSWINDOWS_DATA(f)->ignore_next_rbutton_up = 0;
 130   FRAME_MSWINDOWS_DATA(f)->sizing = 0;
 131   FRAME_MSWINDOWS_MENU_HASH_TABLE(f) = Qnil;
 132 #ifdef HAVE_TOOLBARS
 133   FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE(f) =
 134     make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
 135 #endif
 136   /* hashtable of instantiated glyphs on the frame. */
 137   FRAME_MSWINDOWS_WIDGET_HASH_TABLE (f) =
 138     make_lisp_hash_table (50, HASH_TABLE_VALUE_WEAK, HASH_TABLE_EQUAL);
 139   /* Will initialize these in WM_SIZE handler. We cannot do it now,
 140      because we do not know what is CW_USEDEFAULT height and width */
 141   FRAME_WIDTH (f) = 0;
 142   FRAME_HEIGHT (f) = 0;
 143   FRAME_PIXWIDTH (f) = 0;
 144   FRAME_PIXHEIGHT (f) = 0;
 145
 146   if (NILP (popup))
 147     {
 148       style = MSWINDOWS_FRAME_STYLE;
 149       exstyle = MSWINDOWS_FRAME_EXSTYLE;
 150       hwnd_parent = NULL;
 151
 152       rect_default.left = rect_default.top = CW_USEDEFAULT;
 153       rect_default.width = rect_default.height = CW_USEDEFAULT;
 154     }
 155   else
 156     {
 157       style = MSWINDOWS_POPUP_STYLE;
 158       exstyle = MSWINDOWS_POPUP_EXSTYLE;
 159
 160       CHECK_MSWINDOWS_FRAME (popup);
 161       hwnd_parent = FRAME_MSWINDOWS_HANDLE (XFRAME (popup));
 162       assert (IsWindow (hwnd_parent));
 163
 164       /* We cannot use CW_USEDEFAULT when creating a popup window.
 165          So by default, we offset the new popup 30 pixels right
 166          and down from its parent, and give it size of 30x10 characters.
 167          These dimensions look adequate on both high and low res monitors */
 168       GetWindowRect (hwnd_parent, &rect);
 169       rect_default.left = rect.left + POPUP_OFFSET;
 170       rect_default.top = rect.top + POPUP_OFFSET;
 171       char_to_real_pixel_size (f, POPUP_WIDTH, POPUP_HEIGHT,
 172                                &rect_default.width, &rect_default.height);
 173     }
 174
 175   AdjustWindowRectEx(&rect, style, ADJR_MENUFLAG, exstyle);
 176
 177   XSETFRAME (frame_obj, f);
 178
 179   Vmswindows_frame_being_created = frame_obj;
 180
 181   hwnd = CreateWindowEx (exstyle,
 182                          XEMACS_CLASS,
 183                          STRINGP(f->name) ? XSTRING_DATA(f->name) :
 184                          (STRINGP(name) ?
 185                           (CONST Extbyte*)XSTRING_DATA(name) :
 186                           (CONST Extbyte*)XEMACS_CLASS),
 187                          style,
 188                          rect_default.left, rect_default.top,
 189                          rect_default.width, rect_default.height,
 190                          hwnd_parent, NULL, NULL, NULL);
 191
 192   Vmswindows_frame_being_created = Qnil;
 193
 194   if (hwnd == NULL)
 195     error ("System call to create frame failed");
 196
 197   FRAME_MSWINDOWS_HANDLE(f) = hwnd;
 198
 199   SetWindowLong (hwnd, XWL_FRAMEOBJ, (LONG)LISP_TO_VOID(frame_obj));
 200   FRAME_MSWINDOWS_DC(f) = GetDC (hwnd);
 201   FRAME_MSWINDOWS_CDC(f) = CreateCompatibleDC (FRAME_MSWINDOWS_CDC(f));
 202   SetTextAlign (FRAME_MSWINDOWS_DC(f), TA_BASELINE | TA_LEFT | TA_NOUPDATECP);
 203 }
 204
 205 static void
 206 mswindows_init_frame_2 (struct frame *f, Lisp_Object props)
 207 {
 208   if (NILP (Vmswindows_use_system_frame_size_defaults))
 209     {
 210       /* I don't think anything can set the frame size before this
 211          since we don't have X resources. This may change if we look
 212          at the registry. Even so these values can get overridden
 213          later.*/
 214       XEMACS_RECT_WH dest = { -1, -1, DEFAULT_FRAME_WIDTH,
 215                               DEFAULT_FRAME_HEIGHT };
 216       mswindows_size_frame_internal (f, &dest);
 217     }
 218 }
 219
 220 /* Called after frame's properties are set */
 221 static void
 222 mswindows_init_frame_3 (struct frame *f)
 223 {
 224   /* Don't do this earlier or we get a WM_PAINT before the frame is ready.
 225    * The SW_x parameter in the first call that an app makes to ShowWindow is
 226    * ignored, and the parameter specified in the caller's STARTUPINFO is
 227    * substituted instead. That parameter is SW_HIDE if we were started by
 228    * runemacs, so call this twice. #### runemacs is evil */
 229   ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_SHOWNORMAL);
 230   ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_SHOWNORMAL);
 231   SetForegroundWindow (FRAME_MSWINDOWS_HANDLE(f));
 232   DragAcceptFiles (FRAME_MSWINDOWS_HANDLE(f), TRUE);
 233 }
 234
 235 static void
 236 mswindows_after_init_frame (struct frame *f, int first_on_device,
 237                             int first_on_console)
 238 {
 239   /* Windows, unlike X, is very synchronous. After the initial
 240      frame is created, it will never be displayed, except for
 241      hollow border, unless we start pumping messages. Load progress
 242      messages show in the bottom of the hollow frame, which is ugly.
 243      We redisplay the initial frame here, so modeline and root window
 244      background show.
 245   */
 246   if (first_on_console)
 247     redisplay ();
 248 }
 249
 250 static void
 251 mswindows_mark_frame (struct frame *f, void (*markobj) (Lisp_Object))
 252 {
 253   markobj (FRAME_MSWINDOWS_MENU_HASH_TABLE (f));
 254 #ifdef HAVE_TOOLBARS
 255   markobj (FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE (f));
 256 #endif
 257   markobj (FRAME_MSWINDOWS_WIDGET_HASH_TABLE (f));
 258 }
 259
 260 static void
 261 mswindows_focus_on_frame (struct frame *f)
 262 {
 263   SetForegroundWindow (FRAME_MSWINDOWS_HANDLE(f));
 264 }
 265
 266 static void
 267 mswindows_delete_frame (struct frame *f)
 268 {
 269   if (f->frame_data)
 270     {
 271       DeleteDC(FRAME_MSWINDOWS_CDC(f));
 272       ReleaseDC(FRAME_MSWINDOWS_HANDLE(f), FRAME_MSWINDOWS_DC(f));
 273       DestroyWindow(FRAME_MSWINDOWS_HANDLE(f));
 274       xfree (f->frame_data);
 275     }
 276   f->frame_data = 0;
 277 }
 278
 279 static void
 280 mswindows_set_frame_size (struct frame *f, int width, int height)
 281 {
 282   RECT rect;
 283   rect.left = rect.top = 0;
 284   rect.right = width;
 285   rect.bottom = height;
 286
 287   AdjustWindowRectEx (&rect,
 288                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_STYLE),
 289                       GetMenu (FRAME_MSWINDOWS_HANDLE(f)) != NULL,
 290                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_EXSTYLE));
 291
 292   if (IsIconic (FRAME_MSWINDOWS_HANDLE(f)) || IsZoomed (FRAME_MSWINDOWS_HANDLE(f)))
 293     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_RESTORE);
 294
 295   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), NULL,
 296                 0, 0, rect.right-rect.left, rect.bottom-rect.top,
 297                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING | SWP_NOMOVE);
 298 }
 299
 300 static void
 301 mswindows_set_frame_position (struct frame *f, int xoff, int yoff)
 302 {
 303   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), NULL,
 304                 xoff, yoff, 0, 0,
 305                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING | SWP_NOSIZE);
 306 }
 307
 308 static void
 309 mswindows_make_frame_visible (struct frame *f)
 310 {
 311   if (f->iconified)
 312     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_RESTORE);
 313   else
 314     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_SHOWNORMAL);
 315   f->visible = 1;
 316   f->iconified = 0;
 317 }
 318
 319 static void
 320 mswindows_make_frame_invisible (struct frame *f)
 321 {
 322   ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_HIDE);
 323   f->visible = -1;
 324 }
 325
 326 static int
 327 mswindows_frame_totally_visible_p (struct frame *f)
 328 {
 329   RECT rc_me, rc_other, rc_temp;
 330   HWND hwnd = FRAME_MSWINDOWS_HANDLE(f);
 331
 332   /* We test against not a whole window rectangle, only against its
 333      client part. So, if non-client are is covered and client area is
 334      not, we return true. */
 335   GetClientRect (hwnd, &rc_me);
 336   MapWindowPoints (hwnd, HWND_DESKTOP, (LPPOINT)&rc_me, 2);
 337
 338   /* First see if we're off the desktop */
 339   GetWindowRect (GetDesktopWindow(), &rc_other);
 340   UnionRect(&rc_temp, &rc_me, &rc_other);
 341   if (!EqualRect (&rc_temp, &rc_other))
 342     return 0;
 343
 344   /* Then see if any window above us obscures us */
 345   while ((hwnd = GetWindow (hwnd, GW_HWNDPREV)) != NULL)
 346     if (IsWindowVisible (hwnd))
 347       {
 348         GetWindowRect (hwnd, &rc_other);
 349         if (IntersectRect(&rc_temp, &rc_me, &rc_other))
 350           return 0;
 351       }
 352
 353   return 1;
 354 }
 355
 356 static int
 357 mswindows_frame_visible_p (struct frame *f)
 358 {
 359   return IsWindowVisible (FRAME_MSWINDOWS_HANDLE(f))
 360     && !IsIconic (FRAME_MSWINDOWS_HANDLE(f));
 361 }
 362
 363
 364 static void
 365 mswindows_iconify_frame (struct frame *f)
 366 {
 367   ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_MINIMIZE);
 368   f->visible = 0;
 369   f->iconified = 1;
 370 }
 371
 372 static int
 373 mswindows_frame_iconified_p (struct frame *f)
 374 {
 375   return IsIconic (FRAME_MSWINDOWS_HANDLE(f));
 376 }
 377
 378 static void
 379 mswindows_set_frame_icon (struct frame *f)
 380 {
 381   if (IMAGE_INSTANCEP (f->icon)
 382       && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (f->icon)))
 383     {
 384       if (!XIMAGE_INSTANCE_MSWINDOWS_ICON (f->icon))
 385         {
 386           mswindows_initialize_image_instance_icon (XIMAGE_INSTANCE (f->icon),
 387                                                     FALSE);
 388         }
 389
 390       SetClassLong (FRAME_MSWINDOWS_HANDLE (f), GCL_HICON,
 391                     (LONG) XIMAGE_INSTANCE_MSWINDOWS_ICON (f->icon));
 392     }
 393 }
 394
 395 static void
 396 mswindows_set_frame_pointer (struct frame *f)
 397 {
 398   if (IMAGE_INSTANCEP (f->pointer)
 399       && IMAGE_INSTANCE_TYPE (XIMAGE_INSTANCE (f->pointer)) == IMAGE_POINTER)
 400     {
 401       SetClassLong (FRAME_MSWINDOWS_HANDLE (f), GCL_HCURSOR,
 402                     (LONG) XIMAGE_INSTANCE_MSWINDOWS_ICON (f->pointer));
 403       /* we only have to do this because GC doesn't cause a mouse
 404          event and doesn't give time to event processing even if it
 405          did. */
 406       SetCursor (XIMAGE_INSTANCE_MSWINDOWS_ICON (f->pointer));
 407     }
 408 }
 409
 410 static void
 411 mswindows_set_mouse_position (struct window *w, int x, int y)
 412 {
 413   struct frame *f = XFRAME (w->frame);
 414   POINT pt;
 415
 416   pt.x = w->pixel_left + x;
 417   pt.y = w->pixel_top  + y;
 418   ClientToScreen (FRAME_MSWINDOWS_HANDLE(f), &pt);
 419   SetCursorPos (pt.x, pt.y);
 420 }
 421
 422 static int
 423 mswindows_get_mouse_position (struct device *d, Lisp_Object *frame, int *x, int *y)
 424 {
 425   POINT pt;
 426   HWND hwnd;
 427
 428   GetCursorPos (&pt);
 429
 430   /* What's under cursor? */
 431   hwnd = WindowFromPoint (pt);
 432   if (hwnd == NULL)
 433     return 0;
 434
 435   /* Get grandest parent of the window */
 436   {
 437     HWND hwnd_parent;
 438     while ((hwnd_parent = GetParent (hwnd)) != NULL)
 439       hwnd = hwnd_parent;
 440   }
 441
 442   /* Make sure it belongs to us */
 443   if (GetWindowThreadProcessId (hwnd, NULL) != GetCurrentThreadId ())
 444     return 0;
 445
 446   /* And that the window is an XEmacs frame */
 447   {
 448     char class_name [sizeof(XEMACS_CLASS) + 1];
 449     if (!GetClassName (hwnd, class_name, sizeof(XEMACS_CLASS))
 450         || strcmp (class_name, XEMACS_CLASS) != 0)
 451       return 0;
 452   }
 453
 454   /* Yippie! */
 455   ScreenToClient (hwnd, &pt);
 456   VOID_TO_LISP (*frame, GetWindowLong (hwnd, XWL_FRAMEOBJ));
 457   *x = pt.x;
 458   *y = pt.y;
 459   return 1;
 460 }
 461
 462 static void
 463 mswindows_raise_frame (struct frame *f)
 464 {
 465   BringWindowToTop (FRAME_MSWINDOWS_HANDLE(f));
 466   /* XXX Should we do SetWindowForeground too ? */
 467 }
 468
 469 static void
 470 mswindows_lower_frame (struct frame *f)
 471 {
 472   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), HWND_BOTTOM, 0, 0, 0, 0,
 473                 SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING);
 474 }
 475
 476 static void
 477 mswindows_set_title_from_bufbyte (struct frame *f, Bufbyte *title)
 478 {
 479   unsigned int new_checksum = hash_string (title, strlen (title));
 480   if (new_checksum != FRAME_MSWINDOWS_TITLE_CHECKSUM(f))
 481     {
 482       FRAME_MSWINDOWS_TITLE_CHECKSUM(f) = new_checksum;
 483       SetWindowText (FRAME_MSWINDOWS_HANDLE(f), title);
 484     }
 485 }
 486
 487 static Lisp_Object
 488 mswindows_frame_property (struct frame *f, Lisp_Object property)
 489 {
 490   if (EQ (Qleft, property) || EQ (Qtop, property))
 491     {
 492       RECT rc;
 493       GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rc);
 494       return make_int (EQ (Qtop,  property) ? rc.top : rc.left);
 495     }
 496   return Qunbound;
 497 }
 498
 499 static int
 500 mswindows_internal_frame_property_p (struct frame *f, Lisp_Object property)
 501 {
 502   return EQ (property, Qleft)
 503     || EQ (property, Qtop);
 504   /* #### frame-x.c has also this. Why?
 505     || STRINGP (property);
 506   */
 507 }
 508
 509 static Lisp_Object
 510 mswindows_frame_properties (struct frame *f)
 511 {
 512   Lisp_Object props = Qnil;
 513   RECT rc;
 514   GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rc);
 515
 516   props = cons3 (Qtop,  make_int (rc.top), props);
 517   props = cons3 (Qleft, make_int (rc.left), props);
 518
 519   return props;
 520 }
 521
 522 static void
 523 mswindows_set_frame_properties (struct frame *f, Lisp_Object plist)
 524 {
 525   int x=-1, y=-1;
 526   int width = -1, height = -1;
 527   BOOL width_specified_p = FALSE;
 528   BOOL height_specified_p = FALSE;
 529   BOOL x_specified_p = FALSE;
 530   BOOL y_specified_p = FALSE;
 531   Lisp_Object tail;
 532
 533   /* Extract the properties from plist */
 534   for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail)))
 535     {
 536       Lisp_Object prop = Fcar (tail);
 537       Lisp_Object val = Fcar (Fcdr (tail));
 538
 539       if (SYMBOLP (prop))
 540         {
 541           /* Kludge to handle the font property. */
 542           if (EQ (prop, Qfont))
 543             {
 544               /* If the value is not a string we silently ignore it. */
 545               if (STRINGP (val))
 546                 {
 547                   Lisp_Object frm, font_spec;
 548
 549                   XSETFRAME (frm, f);
 550                   font_spec = Fget (Fget_face (Qdefault), Qfont, Qnil);
 551
 552                   Fadd_spec_to_specifier (font_spec, val, frm, Qnil, Qnil);
 553                   update_frame_face_values (f);
 554                 }
 555             }
 556           else if (EQ (prop, Qwidth))
 557             {
 558               CHECK_INT (val);
 559               width = XINT (val);
 560               width_specified_p = TRUE;
 561             }
 562           else if (EQ (prop, Qheight))
 563             {
 564               CHECK_INT (val);
 565               height = XINT (val);
 566               height_specified_p = TRUE;
 567             }
 568           else if (EQ (prop, Qleft))
 569             {
 570               CHECK_INT (val);
 571               x = XINT (val);
 572               x_specified_p = TRUE;
 573             }
 574           else if (EQ (prop, Qtop))
 575             {
 576               CHECK_INT (val);
 577               y = XINT (val);
 578               y_specified_p = TRUE;
 579             }
 580         }
 581     }
 582
 583   /* Now we've extracted the properties, apply them.
 584      Do not apply geometric properties during frame creation. This
 585      is excessive anyways, and this loses becuase WM_SIZE has not
 586      been sent yet, so frame width and height fields are not initialized.
 587
 588      unfortunately WM_SIZE loses as well since the resize is only
 589      applied once and the first time WM_SIZE is applied not everything
 590      is initialised in the frame (toolbars for instance). enabling
 591      this always makes no visible difference and fixes a whole host of
 592      bugs (and is more consistent with X) so I am going to reenable it.
 593      --andyp */
 594   if ( FRAME_PIXWIDTH (f) && FRAME_PIXHEIGHT (f)
 595        && (width_specified_p || height_specified_p || x_specified_p || y_specified_p))
 596     {
 597       XEMACS_RECT_WH dest = { x, y, width, height };
 598
 599       mswindows_size_frame_internal (f, &dest);
 600     }
 601 }
 602
 603 void mswindows_size_frame_internal (struct frame* f, XEMACS_RECT_WH* dest)
 604 {
 605   RECT rect;
 606   int pixel_width, pixel_height;
 607   int size_p = (dest->width >=0 || dest->height >=0);
 608   int move_p = (dest->top >=0 || dest->left >=0);
 609   struct device* d = XDEVICE (FRAME_DEVICE (f));
 610   char_to_real_pixel_size (f, dest->width, dest->height, &pixel_width, &pixel_height);
 611
 612   if (dest->width < 0)
 613     pixel_width = FRAME_PIXWIDTH (f);
 614   if (dest->height < 0)
 615     pixel_height = FRAME_PIXHEIGHT (f);
 616
 617   GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rect);
 618   if (dest->left < 0)
 619     dest->left = rect.left;
 620   if (dest->top < 0)
 621     dest->top = rect.top;
 622
 623   rect.left = rect.top = 0;
 624   rect.right = pixel_width;
 625   rect.bottom = pixel_height;
 626
 627   AdjustWindowRectEx (&rect,
 628                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_STYLE),
 629                       GetMenu (FRAME_MSWINDOWS_HANDLE(f)) != NULL,
 630                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_EXSTYLE));
 631
 632   /* resize and move the window so that it fits on the screen. This is
 633   not restrictive since this will happen later anyway in WM_SIZE.  We
 634   have to do this after adjusting the rect to account for menubar
 635   etc. */
 636   pixel_width = rect.right - rect.left;
 637   pixel_height = rect.bottom - rect.top;
 638   if (pixel_width > DEVICE_MSWINDOWS_HORZRES(d))
 639     {
 640       pixel_width = DEVICE_MSWINDOWS_HORZRES(d);
 641       size_p=1;
 642     }
 643   if (pixel_height > DEVICE_MSWINDOWS_VERTRES(d))
 644     {
 645       pixel_height = DEVICE_MSWINDOWS_VERTRES(d);
 646       size_p=1;
 647     }
 648
 649   /* adjust position so window is on screen */
 650   if (dest->left + pixel_width > DEVICE_MSWINDOWS_HORZRES(d))
 651     {
 652       dest->left = DEVICE_MSWINDOWS_HORZRES(d) - pixel_width;
 653       move_p=1;
 654     }
 655   if (dest->top + pixel_height > DEVICE_MSWINDOWS_VERTRES(d))
 656     {
 657       dest->top = DEVICE_MSWINDOWS_VERTRES(d) - pixel_height;
 658       move_p=1;
 659     }
 660
 661   if (IsIconic (FRAME_MSWINDOWS_HANDLE(f))
 662       || IsZoomed (FRAME_MSWINDOWS_HANDLE(f)))
 663     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_RESTORE);
 664
 665   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), NULL,
 666                 dest->left, dest->top, pixel_width, pixel_height,
 667                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING
 668                 | (size_p ? 0 : SWP_NOSIZE)
 669                 | (move_p ? 0 : SWP_NOMOVE));
 670 }
 671
 672 static Lisp_Object
 673 mswindows_get_frame_parent (struct frame *f)
 674 {
 675   HWND hwnd = FRAME_MSWINDOWS_HANDLE(f);
 676   hwnd = GetParent (hwnd);
 677   if (hwnd)
 678     {
 679       Lisp_Object parent;
 680       VOID_TO_LISP (parent, GetWindowLong (hwnd, XWL_FRAMEOBJ));
 681       assert (FRAME_MSWINDOWS_P (XFRAME (parent)));
 682       return parent;
 683     }
 684   else
 685     return Qnil;
 686 }
 687
 688 static void
 689 mswindows_update_frame_external_traits (struct frame* frm, Lisp_Object name)
 690 {
 691 }
 692
 693 static int
 694 mswindows_frame_size_fixed_p (struct frame *f)
 695 {
 696   /* Frame size cannot change if the frame is maximized */
 697   return IsZoomed (FRAME_MSWINDOWS_HANDLE (f));
 698 }
 699
 700 void
 701 console_type_create_frame_mswindows (void)
 702 {
 703   /* frame methods */
 704   CONSOLE_HAS_METHOD (mswindows, init_frame_1);
 705   CONSOLE_HAS_METHOD (mswindows, init_frame_2);
 706   CONSOLE_HAS_METHOD (mswindows, init_frame_3);
 707   CONSOLE_HAS_METHOD (mswindows, after_init_frame);
 708   CONSOLE_HAS_METHOD (mswindows, mark_frame);
 709   CONSOLE_HAS_METHOD (mswindows, focus_on_frame);
 710   CONSOLE_HAS_METHOD (mswindows, delete_frame);
 711   CONSOLE_HAS_METHOD (mswindows, get_mouse_position);
 712   CONSOLE_HAS_METHOD (mswindows, set_mouse_position);
 713   CONSOLE_HAS_METHOD (mswindows, raise_frame);
 714   CONSOLE_HAS_METHOD (mswindows, lower_frame);
 715   CONSOLE_HAS_METHOD (mswindows, make_frame_visible);
 716   CONSOLE_HAS_METHOD (mswindows, make_frame_invisible);
 717   CONSOLE_HAS_METHOD (mswindows, iconify_frame);
 718   CONSOLE_HAS_METHOD (mswindows, set_frame_size);
 719   CONSOLE_HAS_METHOD (mswindows, set_frame_position);
 720   CONSOLE_HAS_METHOD (mswindows, frame_property);
 721   CONSOLE_HAS_METHOD (mswindows, internal_frame_property_p);
 722   CONSOLE_HAS_METHOD (mswindows, frame_properties);
 723   CONSOLE_HAS_METHOD (mswindows, set_frame_properties);
 724   CONSOLE_HAS_METHOD (mswindows, set_title_from_bufbyte);
 725 /*  CONSOLE_HAS_METHOD (mswindows, set_icon_name_from_bufbyte); */
 726   CONSOLE_HAS_METHOD (mswindows, frame_visible_p);
 727   CONSOLE_HAS_METHOD (mswindows, frame_totally_visible_p);
 728   CONSOLE_HAS_METHOD (mswindows, frame_iconified_p);
 729   CONSOLE_HAS_METHOD (mswindows, set_frame_pointer);
 730   CONSOLE_HAS_METHOD (mswindows, set_frame_icon);
 731   CONSOLE_HAS_METHOD (mswindows, get_frame_parent);
 732   CONSOLE_HAS_METHOD (mswindows, update_frame_external_traits);
 733   CONSOLE_HAS_METHOD (mswindows, frame_size_fixed_p);
 734 }
 735
 736 void
 737 syms_of_frame_mswindows (void)
 738 {
 739 }
 740
 741 void
 742 vars_of_frame_mswindows (void)
 743 {
 744   /* Needn't staticpro -- see comment above.  */
 745   Vmswindows_frame_being_created = Qnil;
 746
 747   DEFVAR_LISP ("mswindows-use-system-frame-size-defaults", &Vmswindows_use_system_frame_size_defaults /*
 748 Controls whether to use system or XEmacs defaults for frame size.
 749 If nil then reasonable defaults are used for intial frame sizes. If t
 750 then the system will choose default sizes for the frame.
 751 */ );
 752   Vmswindows_use_system_frame_size_defaults = Qnil;
 753
 754   DEFVAR_LISP ("default-mswindows-frame-plist", &Vdefault_mswindows_frame_plist /*
 755 Plist of default frame-creation properties for mswindows frames.
 756 These override what is specified in `default-frame-plist', but are
 757 overridden by the arguments to the particular call to `make-frame'.
 758
 759 Note: In many cases, properties of a frame are available as specifiers
 760 instead of through the frame-properties mechanism.
 761
 762 Here is a list of recognized frame properties, other than those
 763 documented in `set-frame-properties' (they can be queried and
 764 set at any time, except as otherwise noted):
 765
 766   initially-unmapped            If non-nil, the frame will not be visible
 767                                 when it is created.  In this case, you
 768                                 need to call `make-frame-visible' to make
 769                                 the frame appear.
 770   popup                         If non-nil, it should be a frame, and this
 771                                 frame will be created as a "popup" frame
 772                                 whose parent is the given frame.  This
 773                                 will make the window manager treat the
 774                                 frame as a dialog box, which may entail
 775                                 doing different things (e.g. not asking
 776                                 for positioning, and not iconifying
 777                                 separate from its parent).
 778   top                           Y position (in pixels) of the upper-left
 779                                 outermost corner of the frame (i.e. the
 780                                 upper-left of the window-manager
 781                                 decorations).
 782   left                          X position (in pixels) of the upper-left
 783                                 outermost corner of the frame (i.e. the
 784                                 upper-left of the window-manager
 785                                 decorations).
 786
 787 See also `default-frame-plist', which specifies properties which apply
 788 to all frames, not just mswindows frames.
 789 */ );
 790   Vdefault_mswindows_frame_plist = Qnil;
 791
 792   mswindows_console_methods->device_specific_frame_props =
 793     &Vdefault_mswindows_frame_plist;
 794 }