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_SHOW);
 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 }
 467
 468 static void
 469 mswindows_lower_frame (struct frame *f)
 470 {
 471   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), HWND_BOTTOM, 0, 0, 0, 0,
 472                 SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING);
 473 }
 474
 475 static void
 476 mswindows_set_title_from_bufbyte (struct frame *f, Bufbyte *title)
 477 {
 478   unsigned int new_checksum = hash_string (title, strlen (title));
 479   if (new_checksum != FRAME_MSWINDOWS_TITLE_CHECKSUM(f))
 480     {
 481       FRAME_MSWINDOWS_TITLE_CHECKSUM(f) = new_checksum;
 482       SetWindowText (FRAME_MSWINDOWS_HANDLE(f), title);
 483     }
 484 }
 485
 486 static Lisp_Object
 487 mswindows_frame_property (struct frame *f, Lisp_Object property)
 488 {
 489   if (EQ (Qleft, property) || EQ (Qtop, property))
 490     {
 491       RECT rc;
 492       GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rc);
 493       return make_int (EQ (Qtop,  property) ? rc.top : rc.left);
 494     }
 495   return Qunbound;
 496 }
 497
 498 static int
 499 mswindows_internal_frame_property_p (struct frame *f, Lisp_Object property)
 500 {
 501   return EQ (property, Qleft)
 502     || EQ (property, Qtop);
 503   /* #### frame-x.c has also this. Why?
 504     || STRINGP (property);
 505   */
 506 }
 507
 508 static Lisp_Object
 509 mswindows_frame_properties (struct frame *f)
 510 {
 511   Lisp_Object props = Qnil;
 512   RECT rc;
 513   GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rc);
 514
 515   props = cons3 (Qtop,  make_int (rc.top), props);
 516   props = cons3 (Qleft, make_int (rc.left), props);
 517
 518   return props;
 519 }
 520
 521 static void
 522 mswindows_set_frame_properties (struct frame *f, Lisp_Object plist)
 523 {
 524   int x=-1, y=-1;
 525   int width = -1, height = -1;
 526   BOOL width_specified_p = FALSE;
 527   BOOL height_specified_p = FALSE;
 528   BOOL x_specified_p = FALSE;
 529   BOOL y_specified_p = FALSE;
 530   Lisp_Object tail;
 531
 532   /* Extract the properties from plist */
 533   for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail)))
 534     {
 535       Lisp_Object prop = Fcar (tail);
 536       Lisp_Object val = Fcar (Fcdr (tail));
 537
 538       if (SYMBOLP (prop))
 539         {
 540           /* Kludge to handle the font property. */
 541           if (EQ (prop, Qfont))
 542             {
 543               /* If the value is not a string we silently ignore it. */
 544               if (STRINGP (val))
 545                 {
 546                   Lisp_Object frm, font_spec;
 547
 548                   XSETFRAME (frm, f);
 549                   font_spec = Fget (Fget_face (Qdefault), Qfont, Qnil);
 550
 551                   Fadd_spec_to_specifier (font_spec, val, frm, Qnil, Qnil);
 552                   update_frame_face_values (f);
 553                 }
 554             }
 555           else if (EQ (prop, Qwidth))
 556             {
 557               CHECK_INT (val);
 558               width = XINT (val);
 559               width_specified_p = TRUE;
 560             }
 561           else if (EQ (prop, Qheight))
 562             {
 563               CHECK_INT (val);
 564               height = XINT (val);
 565               height_specified_p = TRUE;
 566             }
 567           else if (EQ (prop, Qleft))
 568             {
 569               CHECK_INT (val);
 570               x = XINT (val);
 571               x_specified_p = TRUE;
 572             }
 573           else if (EQ (prop, Qtop))
 574             {
 575               CHECK_INT (val);
 576               y = XINT (val);
 577               y_specified_p = TRUE;
 578             }
 579         }
 580     }
 581
 582   /* Now we've extracted the properties, apply them.
 583      Do not apply geometric properties during frame creation. This
 584      is excessive anyways, and this loses becuase WM_SIZE has not
 585      been sent yet, so frame width and height fields are not initialized.
 586
 587      unfortunately WM_SIZE loses as well since the resize is only
 588      applied once and the first time WM_SIZE is applied not everything
 589      is initialised in the frame (toolbars for instance). enabling
 590      this always makes no visible difference and fixes a whole host of
 591      bugs (and is more consistent with X) so I am going to reenable it.
 592      --andyp */
 593   if ( FRAME_PIXWIDTH (f) && FRAME_PIXHEIGHT (f)
 594        && (width_specified_p || height_specified_p || x_specified_p || y_specified_p))
 595     {
 596       XEMACS_RECT_WH dest = { x, y, width, height };
 597
 598       mswindows_size_frame_internal (f, &dest);
 599     }
 600 }
 601
 602 void mswindows_size_frame_internal (struct frame* f, XEMACS_RECT_WH* dest)
 603 {
 604   RECT rect;
 605   int pixel_width, pixel_height;
 606   int size_p = (dest->width >=0 || dest->height >=0);
 607   int move_p = (dest->top >=0 || dest->left >=0);
 608   struct device* d = XDEVICE (FRAME_DEVICE (f));
 609   char_to_real_pixel_size (f, dest->width, dest->height, &pixel_width, &pixel_height);
 610
 611   if (dest->width < 0)
 612     pixel_width = FRAME_PIXWIDTH (f);
 613   if (dest->height < 0)
 614     pixel_height = FRAME_PIXHEIGHT (f);
 615
 616   GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rect);
 617   if (dest->left < 0)
 618     dest->left = rect.left;
 619   if (dest->top < 0)
 620     dest->top = rect.top;
 621
 622   rect.left = rect.top = 0;
 623   rect.right = pixel_width;
 624   rect.bottom = pixel_height;
 625
 626   AdjustWindowRectEx (&rect,
 627                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_STYLE),
 628                       GetMenu (FRAME_MSWINDOWS_HANDLE(f)) != NULL,
 629                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_EXSTYLE));
 630
 631   /* resize and move the window so that it fits on the screen. This is
 632   not restrictive since this will happen later anyway in WM_SIZE.  We
 633   have to do this after adjusting the rect to account for menubar
 634   etc. */
 635   pixel_width = rect.right - rect.left;
 636   pixel_height = rect.bottom - rect.top;
 637   if (pixel_width > DEVICE_MSWINDOWS_HORZRES(d))
 638     {
 639       pixel_width = DEVICE_MSWINDOWS_HORZRES(d);
 640       size_p=1;
 641     }
 642   if (pixel_height > DEVICE_MSWINDOWS_VERTRES(d))
 643     {
 644       pixel_height = DEVICE_MSWINDOWS_VERTRES(d);
 645       size_p=1;
 646     }
 647
 648   /* adjust position so window is on screen */
 649   if (dest->left + pixel_width > DEVICE_MSWINDOWS_HORZRES(d))
 650     {
 651       dest->left = DEVICE_MSWINDOWS_HORZRES(d) - pixel_width;
 652       move_p=1;
 653     }
 654   if (dest->top + pixel_height > DEVICE_MSWINDOWS_VERTRES(d))
 655     {
 656       dest->top = DEVICE_MSWINDOWS_VERTRES(d) - pixel_height;
 657       move_p=1;
 658     }
 659
 660   if (IsIconic (FRAME_MSWINDOWS_HANDLE(f))
 661       || IsZoomed (FRAME_MSWINDOWS_HANDLE(f)))
 662     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_RESTORE);
 663
 664   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), NULL,
 665                 dest->left, dest->top, pixel_width, pixel_height,
 666                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING
 667                 | (size_p ? 0 : SWP_NOSIZE)
 668                 | (move_p ? 0 : SWP_NOMOVE));
 669 }
 670
 671 static Lisp_Object
 672 mswindows_get_frame_parent (struct frame *f)
 673 {
 674   HWND hwnd = FRAME_MSWINDOWS_HANDLE(f);
 675   hwnd = GetParent (hwnd);
 676   if (hwnd)
 677     {
 678       Lisp_Object parent;
 679       VOID_TO_LISP (parent, GetWindowLong (hwnd, XWL_FRAMEOBJ));
 680       assert (FRAME_MSWINDOWS_P (XFRAME (parent)));
 681       return parent;
 682     }
 683   else
 684     return Qnil;
 685 }
 686
 687 static void
 688 mswindows_update_frame_external_traits (struct frame* frm, Lisp_Object name)
 689 {
 690 }
 691
 692 static int
 693 mswindows_frame_size_fixed_p (struct frame *f)
 694 {
 695   /* Frame size cannot change if the frame is maximized */
 696   return IsZoomed (FRAME_MSWINDOWS_HANDLE (f));
 697 }
 698
 699 void
 700 console_type_create_frame_mswindows (void)
 701 {
 702   /* frame methods */
 703   CONSOLE_HAS_METHOD (mswindows, init_frame_1);
 704   CONSOLE_HAS_METHOD (mswindows, init_frame_2);
 705   CONSOLE_HAS_METHOD (mswindows, init_frame_3);
 706   CONSOLE_HAS_METHOD (mswindows, after_init_frame);
 707   CONSOLE_HAS_METHOD (mswindows, mark_frame);
 708   CONSOLE_HAS_METHOD (mswindows, focus_on_frame);
 709   CONSOLE_HAS_METHOD (mswindows, delete_frame);
 710   CONSOLE_HAS_METHOD (mswindows, get_mouse_position);
 711   CONSOLE_HAS_METHOD (mswindows, set_mouse_position);
 712   CONSOLE_HAS_METHOD (mswindows, raise_frame);
 713   CONSOLE_HAS_METHOD (mswindows, lower_frame);
 714   CONSOLE_HAS_METHOD (mswindows, make_frame_visible);
 715   CONSOLE_HAS_METHOD (mswindows, make_frame_invisible);
 716   CONSOLE_HAS_METHOD (mswindows, iconify_frame);
 717   CONSOLE_HAS_METHOD (mswindows, set_frame_size);
 718   CONSOLE_HAS_METHOD (mswindows, set_frame_position);
 719   CONSOLE_HAS_METHOD (mswindows, frame_property);
 720   CONSOLE_HAS_METHOD (mswindows, internal_frame_property_p);
 721   CONSOLE_HAS_METHOD (mswindows, frame_properties);
 722   CONSOLE_HAS_METHOD (mswindows, set_frame_properties);
 723   CONSOLE_HAS_METHOD (mswindows, set_title_from_bufbyte);
 724 /*  CONSOLE_HAS_METHOD (mswindows, set_icon_name_from_bufbyte); */
 725   CONSOLE_HAS_METHOD (mswindows, frame_visible_p);
 726   CONSOLE_HAS_METHOD (mswindows, frame_totally_visible_p);
 727   CONSOLE_HAS_METHOD (mswindows, frame_iconified_p);
 728   CONSOLE_HAS_METHOD (mswindows, set_frame_pointer);
 729   CONSOLE_HAS_METHOD (mswindows, set_frame_icon);
 730   CONSOLE_HAS_METHOD (mswindows, get_frame_parent);
 731   CONSOLE_HAS_METHOD (mswindows, update_frame_external_traits);
 732   CONSOLE_HAS_METHOD (mswindows, frame_size_fixed_p);
 733 }
 734
 735 void
 736 syms_of_frame_mswindows (void)
 737 {
 738 }
 739
 740 void
 741 vars_of_frame_mswindows (void)
 742 {
 743   /* Needn't staticpro -- see comment above.  */
 744   Vmswindows_frame_being_created = Qnil;
 745
 746   DEFVAR_LISP ("mswindows-use-system-frame-size-defaults", &Vmswindows_use_system_frame_size_defaults /*
 747 Controls whether to use system or XEmacs defaults for frame size.
 748 If nil then reasonable defaults are used for intial frame sizes. If t
 749 then the system will choose default sizes for the frame.
 750 */ );
 751   Vmswindows_use_system_frame_size_defaults = Qnil;
 752
 753   DEFVAR_LISP ("default-mswindows-frame-plist", &Vdefault_mswindows_frame_plist /*
 754 Plist of default frame-creation properties for mswindows frames.
 755 These override what is specified in `default-frame-plist', but are
 756 overridden by the arguments to the particular call to `make-frame'.
 757
 758 Note: In many cases, properties of a frame are available as specifiers
 759 instead of through the frame-properties mechanism.
 760
 761 Here is a list of recognized frame properties, other than those
 762 documented in `set-frame-properties' (they can be queried and
 763 set at any time, except as otherwise noted):
 764
 765   initially-unmapped            If non-nil, the frame will not be visible
 766                                 when it is created.  In this case, you
 767                                 need to call `make-frame-visible' to make
 768                                 the frame appear.
 769   popup                         If non-nil, it should be a frame, and this
 770                                 frame will be created as a "popup" frame
 771                                 whose parent is the given frame.  This
 772                                 will make the window manager treat the
 773                                 frame as a dialog box, which may entail
 774                                 doing different things (e.g. not asking
 775                                 for positioning, and not iconifying
 776                                 separate from its parent).
 777   top                           Y position (in pixels) of the upper-left
 778                                 outermost corner of the frame (i.e. the
 779                                 upper-left of the window-manager
 780                                 decorations).
 781   left                          X position (in pixels) of the upper-left
 782                                 outermost corner of the frame (i.e. the
 783                                 upper-left of the window-manager
 784                                 decorations).
 785
 786 See also `default-frame-plist', which specifies properties which apply
 787 to all frames, not just mswindows frames.
 788 */ );
 789   Vdefault_mswindows_frame_plist = Qnil;
 790
 791   mswindows_console_methods->device_specific_frame_props =
 792     &Vdefault_mswindows_frame_plist;
 793 }