60e60e4a2b923e81c948849a89636b4d1aaa7628
[chise/xemacs-chise.git.1] / 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 regular frame 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 Vdefault_msprinter_frame_plist;
74 Lisp_Object Vmswindows_use_system_frame_size_defaults;
75
76 /* This does not need to be GC protected, as it holds a
77    frame Lisp_Object already protected by Fmake_frame */
78 Lisp_Object Vmswindows_frame_being_created;
79
80 /*---------------------------------------------------------------------*/
81 /*-----                    DISPLAY FRAME                          -----*/
82 /*---------------------------------------------------------------------*/
83
84 HWND
85 mswindows_get_selected_frame_hwnd (void)
86 {
87   Lisp_Object frame, device;
88
89   device = Ffind_device (Qnil, Qmswindows);
90   if (NILP (device))
91     return NULL;
92   frame = DEVICE_SELECTED_FRAME (XDEVICE (device));
93   if (NILP (frame))
94     return NULL;
95
96   return FRAME_MSWINDOWS_HANDLE (XFRAME (frame));
97 }
98
99 static void
100 mswindows_init_frame_1 (struct frame *f, Lisp_Object props)
101 {
102   Lisp_Object initially_unmapped;
103   Lisp_Object name, height, width, popup, top, left;
104   Lisp_Object frame_obj = Qnil;
105   RECT rect;
106   XEMACS_RECT_WH rect_default;
107   DWORD style, exstyle;
108   HWND hwnd, hwnd_parent;
109
110   /* Pick up relevant properties */
111   initially_unmapped = Fplist_get (props, Qinitially_unmapped, Qnil);
112   name = Fplist_get (props, Qname, Qnil);
113
114   popup = Fplist_get (props, Qpopup, Qnil);
115   if (EQ (popup, Qt))
116     popup = Fselected_frame (Qnil);
117
118   left = Fplist_get (props, Qleft, Qnil);
119   if (!NILP (left))
120     CHECK_INT (left);
121
122   top = Fplist_get (props, Qtop, Qnil);
123   if (!NILP (top))
124     CHECK_INT (top);
125
126   width = Fplist_get (props, Qwidth, Qnil);
127   if (!NILP (width))
128     CHECK_INT (width);
129
130   height = Fplist_get (props, Qheight, Qnil);
131   if (!NILP (height))
132     CHECK_INT (height);
133
134   f->frame_data = xnew_and_zero (struct mswindows_frame);
135   FRAME_MSWINDOWS_TARGET_RECT (f) = xnew_and_zero (XEMACS_RECT_WH);
136
137   FRAME_MSWINDOWS_TARGET_RECT (f)->left = NILP (left) ? -1 : abs (XINT (left));
138   FRAME_MSWINDOWS_TARGET_RECT (f)->top = NILP (top) ? -1 : abs (XINT (top));
139   FRAME_MSWINDOWS_TARGET_RECT (f)->width = NILP (width) ? -1 :
140     abs (XINT (width));
141   FRAME_MSWINDOWS_TARGET_RECT (f)->height = NILP (height) ? -1 :
142     abs (XINT (height));
143
144   /* Misc frame stuff */
145   FRAME_MSWINDOWS_MENU_HASH_TABLE(f) = Qnil;
146 #ifdef HAVE_TOOLBARS
147   FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE(f) =
148     make_lisp_hash_table (50, HASH_TABLE_NON_WEAK, HASH_TABLE_EQUAL);
149 #endif
150   /* hashtable of instantiated glyphs on the frame. */
151   FRAME_MSWINDOWS_WIDGET_HASH_TABLE1 (f) =
152     make_lisp_hash_table (50, HASH_TABLE_VALUE_WEAK, HASH_TABLE_EQUAL);
153   FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f) =
154     make_lisp_hash_table (50, HASH_TABLE_VALUE_WEAK, HASH_TABLE_EQUAL);
155   FRAME_MSWINDOWS_WIDGET_HASH_TABLE3 (f) =
156     make_lisp_hash_table (50, HASH_TABLE_VALUE_WEAK, HASH_TABLE_EQUAL);
157   /* Will initialize these in WM_SIZE handler. We cannot do it now,
158      because we do not know what is CW_USEDEFAULT height and width */
159   FRAME_WIDTH (f) = 0;
160   FRAME_HEIGHT (f) = 0;
161   FRAME_PIXWIDTH (f) = 0;
162   FRAME_PIXHEIGHT (f) = 0;
163
164   if (NILP (popup))
165     {
166       style = MSWINDOWS_FRAME_STYLE;
167       exstyle = MSWINDOWS_FRAME_EXSTYLE;
168       hwnd_parent = NULL;
169
170       rect_default.left = rect_default.top = CW_USEDEFAULT;
171       rect_default.width = rect_default.height = CW_USEDEFAULT;
172     }
173   else
174     {
175       style = MSWINDOWS_POPUP_STYLE;
176       exstyle = MSWINDOWS_POPUP_EXSTYLE;
177
178       CHECK_MSWINDOWS_FRAME (popup);
179       hwnd_parent = FRAME_MSWINDOWS_HANDLE (XFRAME (popup));
180       assert (IsWindow (hwnd_parent));
181
182       /* We cannot use CW_USEDEFAULT when creating a popup window.
183          So by default, we offset the new popup 30 pixels right
184          and down from its parent, and give it size of 30x10 characters.
185          These dimensions look adequate on both high and low res monitors */
186       GetWindowRect (hwnd_parent, &rect);
187       rect_default.left = rect.left + POPUP_OFFSET;
188       rect_default.top = rect.top + POPUP_OFFSET;
189       char_to_real_pixel_size (f, POPUP_WIDTH, POPUP_HEIGHT,
190                                &rect_default.width, &rect_default.height);
191       FRAME_MSWINDOWS_POPUP (f) = 1;
192     }
193
194   AdjustWindowRectEx(&rect, style, ADJR_MENUFLAG, exstyle);
195
196   XSETFRAME (frame_obj, f);
197
198   Vmswindows_frame_being_created = frame_obj;
199
200   hwnd = CreateWindowEx (exstyle,
201                          XEMACS_CLASS,
202                          STRINGP (f->name) ? (LPCTSTR) XSTRING_DATA (f->name) :
203                          (STRINGP (name) ? (LPCTSTR) XSTRING_DATA (name) :
204                           XEMACS_CLASS),
205                          style,
206                          rect_default.left, rect_default.top,
207                          rect_default.width, rect_default.height,
208                          hwnd_parent, NULL, NULL, NULL);
209
210   Vmswindows_frame_being_created = Qnil;
211
212   if (hwnd == NULL)
213     invalid_operation ("System call to create frame failed",
214                        STRINGP (f->name) ? f->name :
215                        STRINGP (name) ? name :
216                        Qunbound);
217
218   FRAME_MSWINDOWS_HANDLE(f) = hwnd;
219
220   SetWindowLong (hwnd, XWL_FRAMEOBJ, (LONG)LISP_TO_VOID(frame_obj));
221   FRAME_MSWINDOWS_DC(f) = GetDC (hwnd);
222   SetTextAlign (FRAME_MSWINDOWS_DC(f), TA_BASELINE | TA_LEFT | TA_NOUPDATECP);
223
224   if (FRAME_MSWINDOWS_POPUP (f))
225     mswindows_register_popup_frame (frame_obj);
226 }
227
228 static void
229 mswindows_init_frame_2 (struct frame *f, Lisp_Object props)
230 {
231   if (NILP (Vmswindows_use_system_frame_size_defaults))
232     {
233       /* I don't think anything can set the frame size before this
234          since we don't have X resources. This may change if we look
235          at the registry. Even so these values can get overridden
236          later.*/
237       XEMACS_RECT_WH dest = { -1, -1, DEFAULT_FRAME_WIDTH,
238                               DEFAULT_FRAME_HEIGHT };
239       mswindows_size_frame_internal (f, &dest);
240     }
241 }
242
243 /* Called after frame's properties are set */
244 static void
245 mswindows_init_frame_3 (struct frame *f)
246 {
247   /* Don't do this earlier or we get a WM_PAINT before the frame is ready.
248    * The SW_x parameter in the first call that an app makes to ShowWindow is
249    * ignored, and the parameter specified in the caller's STARTUPINFO is
250    * substituted instead. That parameter is SW_HIDE if we were started by
251    * runemacs, so call this twice. #### runemacs is evil */
252   ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_SHOWNORMAL);
253   ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_SHOWNORMAL);
254   SetForegroundWindow (FRAME_MSWINDOWS_HANDLE(f));
255   DragAcceptFiles (FRAME_MSWINDOWS_HANDLE(f), TRUE);
256 }
257
258 static void
259 mswindows_after_init_frame (struct frame *f, int first_on_device,
260                             int first_on_console)
261 {
262   /* Windows, unlike X, is very synchronous. After the initial
263      frame is created, it will never be displayed, except for
264      hollow border, unless we start pumping messages. Load progress
265      messages show in the bottom of the hollow frame, which is ugly.
266      We redisplay the initial frame here, so modeline and root window
267      background show.
268   */
269   if (first_on_console)
270     redisplay ();
271 }
272
273 static void
274 mswindows_mark_frame (struct frame *f)
275 {
276   mark_object (FRAME_MSWINDOWS_MENU_HASH_TABLE (f));
277 #ifdef HAVE_TOOLBARS
278   mark_object (FRAME_MSWINDOWS_TOOLBAR_HASH_TABLE (f));
279 #endif
280   mark_object (FRAME_MSWINDOWS_WIDGET_HASH_TABLE1 (f));
281   mark_object (FRAME_MSWINDOWS_WIDGET_HASH_TABLE2 (f));
282   mark_object (FRAME_MSWINDOWS_WIDGET_HASH_TABLE3 (f));
283 }
284
285 static void
286 mswindows_focus_on_frame (struct frame *f)
287 {
288   SetForegroundWindow (FRAME_MSWINDOWS_HANDLE(f));
289 }
290
291 static void
292 mswindows_delete_frame (struct frame *f)
293 {
294   if (f->frame_data)
295     {
296       Lisp_Object frame;
297       XSETFRAME (frame, f);
298       mswindows_unregister_popup_frame (frame);
299       ReleaseDC(FRAME_MSWINDOWS_HANDLE(f), FRAME_MSWINDOWS_DC(f));
300       DestroyWindow(FRAME_MSWINDOWS_HANDLE(f));
301       xfree (f->frame_data);
302     }
303   f->frame_data = 0;
304 }
305
306 static void
307 mswindows_set_frame_size (struct frame *f, int width, int height)
308 {
309   RECT rect;
310   rect.left = rect.top = 0;
311   rect.right = width;
312   rect.bottom = height;
313
314   AdjustWindowRectEx (&rect,
315                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_STYLE),
316                       GetMenu (FRAME_MSWINDOWS_HANDLE(f)) != NULL,
317                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_EXSTYLE));
318
319   if (IsIconic (FRAME_MSWINDOWS_HANDLE(f)) || IsZoomed (FRAME_MSWINDOWS_HANDLE(f)))
320     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_RESTORE);
321
322   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), NULL,
323                 0, 0, rect.right-rect.left, rect.bottom-rect.top,
324                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING | SWP_NOMOVE);
325 }
326
327 static void
328 mswindows_set_frame_position (struct frame *f, int xoff, int yoff)
329 {
330   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), NULL,
331                 xoff, yoff, 0, 0,
332                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING | SWP_NOSIZE);
333 }
334
335 static void
336 mswindows_make_frame_visible (struct frame *f)
337 {
338   if (!FRAME_VISIBLE_P(f))
339     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_RESTORE);
340   else
341     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_SHOW);
342   f->visible = 1;
343   f->iconified = 0;
344 }
345
346 static void
347 mswindows_make_frame_invisible (struct frame *f)
348 {
349   if (!FRAME_VISIBLE_P(f))
350     return;
351
352   ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_HIDE);
353   f->visible = 0;
354 }
355
356 static int
357 mswindows_frame_totally_visible_p (struct frame *f)
358 {
359   RECT rc_me, rc_other, rc_temp;
360   HWND hwnd = FRAME_MSWINDOWS_HANDLE(f);
361
362   /* We test against not a whole window rectangle, only against its
363      client part. So, if non-client are is covered and client area is
364      not, we return true. */
365   GetClientRect (hwnd, &rc_me);
366   MapWindowPoints (hwnd, HWND_DESKTOP, (LPPOINT)&rc_me, 2);
367
368   /* First see if we're off the desktop */
369   GetWindowRect (GetDesktopWindow(), &rc_other);
370   UnionRect(&rc_temp, &rc_me, &rc_other);
371   if (!EqualRect (&rc_temp, &rc_other))
372     return 0;
373
374   /* Then see if any window above us obscures us */
375   while ((hwnd = GetWindow (hwnd, GW_HWNDPREV)) != NULL)
376     if (IsWindowVisible (hwnd))
377       {
378         GetWindowRect (hwnd, &rc_other);
379         if (IntersectRect(&rc_temp, &rc_me, &rc_other))
380           return 0;
381       }
382
383   return 1;
384 }
385
386 static int
387 mswindows_frame_visible_p (struct frame *f)
388 {
389   return IsWindowVisible (FRAME_MSWINDOWS_HANDLE(f))
390     && !IsIconic (FRAME_MSWINDOWS_HANDLE(f));
391 }
392
393
394 static void
395 mswindows_iconify_frame (struct frame *f)
396 {
397   ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_MINIMIZE);
398   f->visible = 0;
399   f->iconified = 1;
400 }
401
402 static int
403 mswindows_frame_iconified_p (struct frame *f)
404 {
405   return IsIconic (FRAME_MSWINDOWS_HANDLE(f));
406 }
407
408 static void
409 mswindows_set_frame_icon (struct frame *f)
410 {
411   if (IMAGE_INSTANCEP (f->icon)
412       && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (f->icon)))
413     {
414       if (!XIMAGE_INSTANCE_MSWINDOWS_ICON (f->icon))
415         {
416           mswindows_initialize_image_instance_icon (XIMAGE_INSTANCE (f->icon),
417                                                     FALSE);
418         }
419
420       SetClassLong (FRAME_MSWINDOWS_HANDLE (f), GCL_HICON,
421                     (LONG) XIMAGE_INSTANCE_MSWINDOWS_ICON (f->icon));
422     }
423 }
424
425 static void
426 mswindows_set_frame_pointer (struct frame *f)
427 {
428   if (IMAGE_INSTANCEP (f->pointer)
429       && IMAGE_INSTANCE_TYPE (XIMAGE_INSTANCE (f->pointer)) == IMAGE_POINTER)
430     {
431       SetClassLong (FRAME_MSWINDOWS_HANDLE (f), GCL_HCURSOR,
432                     (LONG) XIMAGE_INSTANCE_MSWINDOWS_ICON (f->pointer));
433       /* we only have to do this because GC doesn't cause a mouse
434          event and doesn't give time to event processing even if it
435          did. */
436       SetCursor (XIMAGE_INSTANCE_MSWINDOWS_ICON (f->pointer));
437     }
438 }
439
440 static void
441 mswindows_set_mouse_position (struct window *w, int x, int y)
442 {
443   struct frame *f = XFRAME (w->frame);
444   POINT pt;
445
446   pt.x = w->pixel_left + x;
447   pt.y = w->pixel_top  + y;
448   ClientToScreen (FRAME_MSWINDOWS_HANDLE(f), &pt);
449   SetCursorPos (pt.x, pt.y);
450 }
451
452 static int
453 mswindows_get_mouse_position (struct device *d, Lisp_Object *frame, int *x, int *y)
454 {
455   POINT pt;
456   HWND hwnd;
457
458   GetCursorPos (&pt);
459
460   /* What's under cursor? */
461   hwnd = WindowFromPoint (pt);
462   if (hwnd == NULL)
463     return 0;
464
465   /* Get grandest parent of the window */
466   {
467     HWND hwnd_parent;
468     while ((hwnd_parent = GetParent (hwnd)) != NULL)
469       hwnd = hwnd_parent;
470   }
471
472   /* Make sure it belongs to us */
473   if (GetWindowThreadProcessId (hwnd, NULL) != GetCurrentThreadId ())
474     return 0;
475
476   /* And that the window is an XEmacs frame */
477   {
478     char class_name [sizeof(XEMACS_CLASS) + 1];
479     if (!GetClassName (hwnd, class_name, sizeof(XEMACS_CLASS))
480         || strcmp (class_name, XEMACS_CLASS) != 0)
481       return 0;
482   }
483
484   /* Yippie! */
485   ScreenToClient (hwnd, &pt);
486   VOID_TO_LISP (*frame, GetWindowLong (hwnd, XWL_FRAMEOBJ));
487   *x = pt.x;
488   *y = pt.y;
489   return 1;
490 }
491
492 static void
493 mswindows_raise_frame (struct frame *f)
494 {
495   BringWindowToTop (FRAME_MSWINDOWS_HANDLE(f));
496 }
497
498 static void
499 mswindows_lower_frame (struct frame *f)
500 {
501   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), HWND_BOTTOM, 0, 0, 0, 0,
502                 SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING);
503 }
504
505 static void
506 mswindows_enable_frame (struct frame *f)
507 {
508   EnableWindow (FRAME_MSWINDOWS_HANDLE (f), TRUE);
509 }
510
511 static void
512 mswindows_disable_frame (struct frame *f)
513 {
514   EnableWindow (FRAME_MSWINDOWS_HANDLE (f), FALSE);
515 }
516
517 static void
518 mswindows_set_title_from_bufbyte (struct frame *f, Bufbyte *title)
519 {
520   unsigned int new_checksum = hash_string (title, strlen (title));
521   if (new_checksum != FRAME_MSWINDOWS_TITLE_CHECKSUM(f))
522     {
523       FRAME_MSWINDOWS_TITLE_CHECKSUM(f) = new_checksum;
524       SetWindowText (FRAME_MSWINDOWS_HANDLE(f), title);
525     }
526 }
527
528 static Lisp_Object
529 mswindows_frame_property (struct frame *f, Lisp_Object property)
530 {
531   if (EQ (Qleft, property) || EQ (Qtop, property))
532     {
533       RECT rc;
534       GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rc);
535       return make_int (EQ (Qtop,  property) ? rc.top : rc.left);
536     }
537   return Qunbound;
538 }
539
540 static int
541 mswindows_internal_frame_property_p (struct frame *f, Lisp_Object property)
542 {
543   return EQ (property, Qleft)
544     || EQ (property, Qtop);
545   /* #### frame-x.c has also this. Why?
546     || STRINGP (property);
547   */
548 }
549
550 static Lisp_Object
551 mswindows_frame_properties (struct frame *f)
552 {
553   Lisp_Object props = Qnil;
554   RECT rc;
555   GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rc);
556
557   props = cons3 (Qtop,  make_int (rc.top), props);
558   props = cons3 (Qleft, make_int (rc.left), props);
559
560   return props;
561 }
562
563 static void
564 mswindows_set_frame_properties (struct frame *f, Lisp_Object plist)
565 {
566   int x=-1, y=-1;
567   int width = -1, height = -1;
568   BOOL width_specified_p = FALSE;
569   BOOL height_specified_p = FALSE;
570   BOOL x_specified_p = FALSE;
571   BOOL y_specified_p = FALSE;
572   Lisp_Object tail;
573
574   /* Extract the properties from plist */
575   for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail)))
576     {
577       Lisp_Object prop = Fcar (tail);
578       Lisp_Object val = Fcar (Fcdr (tail));
579
580       if (SYMBOLP (prop))
581         {
582           /* Kludge to handle the font property. */
583           if (EQ (prop, Qfont))
584             {
585               /* If the value is not a string we silently ignore it. */
586               if (STRINGP (val))
587                 {
588                   Lisp_Object frm, font_spec;
589
590                   XSETFRAME (frm, f);
591                   font_spec = Fget (Fget_face (Qdefault), Qfont, Qnil);
592
593                   Fadd_spec_to_specifier (font_spec, val, frm, Qnil, Qnil);
594                   update_frame_face_values (f);
595                 }
596             }
597           else if (EQ (prop, Qwidth))
598             {
599               CHECK_INT (val);
600               width = XINT (val);
601               width_specified_p = TRUE;
602             }
603           else if (EQ (prop, Qheight))
604             {
605               CHECK_INT (val);
606               height = XINT (val);
607               height_specified_p = TRUE;
608             }
609           else if (EQ (prop, Qleft))
610             {
611               CHECK_INT (val);
612               x = XINT (val);
613               x_specified_p = TRUE;
614             }
615           else if (EQ (prop, Qtop))
616             {
617               CHECK_INT (val);
618               y = XINT (val);
619               y_specified_p = TRUE;
620             }
621         }
622     }
623
624   /* Now we've extracted the properties, apply them.
625      Do not apply geometric properties during frame creation. This
626      is excessive anyways, and this loses because WM_SIZE has not
627      been sent yet, so frame width and height fields are not initialized.
628
629      unfortunately WM_SIZE loses as well since the resize is only
630      applied once and the first time WM_SIZE is applied not everything
631      is initialised in the frame (toolbars for instance). enabling
632      this always makes no visible difference and fixes a whole host of
633      bugs (and is more consistent with X) so I am going to reenable it.
634      --andyp */
635   if ( FRAME_PIXWIDTH (f) && FRAME_PIXHEIGHT (f)
636        && (width_specified_p || height_specified_p
637            || x_specified_p || y_specified_p))
638     {
639       XEMACS_RECT_WH dest = { x, y, width, height };
640
641       mswindows_size_frame_internal (f, &dest);
642     }
643 }
644
645 void mswindows_size_frame_internal (struct frame* f, XEMACS_RECT_WH* dest)
646 {
647   RECT rect, ws_rect;
648   int pixel_width, pixel_height;
649   int size_p = (dest->width >=0 || dest->height >=0);
650   int move_p = (dest->top >=0 || dest->left >=0);
651   char_to_real_pixel_size (f, dest->width, dest->height, &pixel_width, &pixel_height);
652
653   if (dest->width < 0)
654     pixel_width = FRAME_PIXWIDTH (f);
655   if (dest->height < 0)
656     pixel_height = FRAME_PIXHEIGHT (f);
657
658   GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rect);
659   if (dest->left < 0)
660     dest->left = rect.left;
661   if (dest->top < 0)
662     dest->top = rect.top;
663
664   rect.left = rect.top = 0;
665   rect.right = pixel_width;
666   rect.bottom = pixel_height;
667
668   AdjustWindowRectEx (&rect,
669                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_STYLE),
670                       GetMenu (FRAME_MSWINDOWS_HANDLE(f)) != NULL,
671                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_EXSTYLE));
672
673   /* resize and move the window so that it fits in the workspace. This is
674   not restrictive since this will happen later anyway in WM_SIZE.  We
675   have to do this after adjusting the rect to account for menubar
676   etc. */
677   mswindows_get_workspace_coords (&ws_rect);
678   pixel_width = rect.right - rect.left;
679   pixel_height = rect.bottom - rect.top;
680   if (pixel_width > ws_rect.right - ws_rect.left)
681     {
682       pixel_width = ws_rect.right - ws_rect.left;
683       size_p=1;
684     }
685   if (pixel_height > ws_rect.bottom - ws_rect.top)
686     {
687       pixel_height = ws_rect.bottom - ws_rect.top;
688       size_p=1;
689     }
690
691   /* adjust position so window is in workspace */
692   if (dest->left + pixel_width > ws_rect.right)
693     {
694       dest->left = ws_rect.right - pixel_width;
695       move_p=1;
696     }
697   if (dest->left < ws_rect.left)
698     {
699       dest->left = ws_rect.left;
700       move_p=1;
701     }
702
703   if (dest->top + pixel_height > ws_rect.bottom)
704     {
705       dest->top = ws_rect.bottom - pixel_height;
706       move_p=1;
707     }
708   if (dest->top < ws_rect.top)
709     {
710       dest->top = ws_rect.top;
711       move_p=1;
712     }
713
714   if (IsIconic (FRAME_MSWINDOWS_HANDLE(f))
715       || IsZoomed (FRAME_MSWINDOWS_HANDLE(f)))
716     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_RESTORE);
717
718   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), NULL,
719                 dest->left, dest->top, pixel_width, pixel_height,
720                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING
721                 | (size_p ? 0 : SWP_NOSIZE)
722                 | (move_p ? 0 : SWP_NOMOVE));
723 }
724
725 static Lisp_Object
726 mswindows_get_frame_parent (struct frame *f)
727 {
728   HWND hwnd = FRAME_MSWINDOWS_HANDLE(f);
729   hwnd = GetParent (hwnd);
730   if (hwnd)
731     {
732       Lisp_Object parent;
733       VOID_TO_LISP (parent, GetWindowLong (hwnd, XWL_FRAMEOBJ));
734       assert (FRAME_MSWINDOWS_P (XFRAME (parent)));
735       return parent;
736     }
737   else
738     return Qnil;
739 }
740
741 static void
742 mswindows_update_frame_external_traits (struct frame* frm, Lisp_Object name)
743 {
744 }
745
746 static int
747 mswindows_frame_size_fixed_p (struct frame *f)
748 {
749   /* Frame size cannot change if the frame is maximized */
750   return IsZoomed (FRAME_MSWINDOWS_HANDLE (f));
751 }
752
753 /*---------------------------------------------------------------------*/
754 /*-----                    PRINTER FRAME                          -----*/
755 /*---------------------------------------------------------------------*/
756
757 /*
758  * With some driver/os combination (I discovered this with HP drivers
759  * under W2K), DC geometry is reset upon StartDoc and EndPage
760  * calls. This is called every time one of these calls is made.
761  */
762 static void
763 apply_dc_geometry (struct frame* f)
764 {
765   HDC hdc = DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f)));
766   SetTextAlign (hdc, TA_BASELINE | TA_LEFT | TA_NOUPDATECP);
767   SetViewportOrgEx (hdc, FRAME_MSPRINTER_PIXLEFT(f),
768                     FRAME_MSPRINTER_PIXTOP(f), NULL);
769 }
770
771 void
772 msprinter_start_page (struct frame *f)
773 {
774   if (!FRAME_MSPRINTER_PAGE_STARTED (f))
775     {
776       FRAME_MSPRINTER_PAGE_STARTED (f) = 1;
777       StartPage (DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f))));
778       apply_dc_geometry (f);
779     }
780 }
781
782 static void
783 error_frame_unsizable (struct frame *f)
784 {
785   Lisp_Object frame;
786   XSETFRAME (frame, f);
787   invalid_change ("Cannot resize frame (margins) after print job has started.",
788                   frame);
789 }
790
791 static void
792 maybe_error_if_job_active (struct frame *f)
793 {
794   if (FRAME_MSPRINTER_JOB_STARTED (f))
795     error_frame_unsizable (f);
796 }
797
798 static void
799 msprinter_init_frame_1 (struct frame *f, Lisp_Object props)
800 {
801   /* Make sure this is the only frame on device. Windows printer can
802      handle only one job at a time. */
803   if (!NILP (DEVICE_FRAME_LIST (XDEVICE (FRAME_DEVICE (f)))))
804     invalid_operation ("Only one frame (print job) at a time is allowed on "
805                        "this printer device", FRAME_DEVICE (f));
806
807   f->frame_data = xnew_and_zero (struct msprinter_frame);
808
809   /* Default margin size is 1" = 1440 twips */
810   FRAME_MSPRINTER_TOP_MARGIN(f) = 1440;
811   FRAME_MSPRINTER_BOTTOM_MARGIN(f) = 1440;
812   FRAME_MSPRINTER_LEFT_MARGIN(f) = 1440;
813   FRAME_MSPRINTER_RIGHT_MARGIN(f) = 1440;
814
815   /* Negative for "uinspecified" */
816   FRAME_MSPRINTER_CHARWIDTH(f) = -1;
817   FRAME_MSPRINTER_CHARHEIGHT(f) = -1;
818 }
819
820 static void
821 msprinter_init_frame_3 (struct frame *f)
822 {
823   DOCINFO di;
824   struct device *device = XDEVICE (FRAME_DEVICE (f));
825   HDC hdc;
826   int frame_left, frame_top, frame_width, frame_height;
827
828   /* DC might be recreated in msprinter_apply_devmode,
829      so do not initialize until now */
830   hdc = DEVICE_MSPRINTER_HDC (device);
831
832   /* Compute geometry properties */
833   frame_left = (MulDiv (GetDeviceCaps (hdc, LOGPIXELSX),
834                         FRAME_MSPRINTER_LEFT_MARGIN(f), 1440)
835                 - GetDeviceCaps (hdc, PHYSICALOFFSETX));
836
837   if (FRAME_MSPRINTER_CHARWIDTH(f) > 0)
838     {
839       char_to_real_pixel_size (f, FRAME_MSPRINTER_CHARWIDTH(f), 0,
840                                &frame_width, NULL);
841       FRAME_MSPRINTER_RIGHT_MARGIN(f) =
842         MulDiv (GetDeviceCaps (hdc, PHYSICALWIDTH)
843                 - (frame_left + frame_width), 1440,
844                 GetDeviceCaps (hdc, LOGPIXELSX));
845     }
846   else
847     frame_width = (GetDeviceCaps (hdc, PHYSICALWIDTH)
848                    - frame_left
849                    - MulDiv (GetDeviceCaps (hdc, LOGPIXELSX),
850                              FRAME_MSPRINTER_RIGHT_MARGIN(f), 1440));
851
852   frame_top = (MulDiv (GetDeviceCaps (hdc, LOGPIXELSY),
853                        FRAME_MSPRINTER_TOP_MARGIN(f), 1440)
854                - GetDeviceCaps (hdc, PHYSICALOFFSETY));
855
856   if (FRAME_MSPRINTER_CHARHEIGHT(f) > 0)
857     {
858       char_to_real_pixel_size (f, 0, FRAME_MSPRINTER_CHARHEIGHT(f),
859                                NULL, &frame_height);
860
861       FRAME_MSPRINTER_BOTTOM_MARGIN(f) =
862         MulDiv (GetDeviceCaps (hdc, PHYSICALHEIGHT)
863                 - (frame_top + frame_height), 1440,
864                 GetDeviceCaps (hdc, LOGPIXELSY));
865     }
866   else
867     frame_height = (GetDeviceCaps (hdc, PHYSICALHEIGHT)
868                     - frame_top
869                     - MulDiv (GetDeviceCaps (hdc, LOGPIXELSY),
870                               FRAME_MSPRINTER_BOTTOM_MARGIN(f), 1440));
871
872   /* Geometry sanity checks */
873   if (!frame_pixsize_valid_p (f, frame_width, frame_height))
874     invalid_operation ("Area inside print margins has shrunk to naught",
875                        STRINGP (f->name) ? f->name : Qunbound);
876
877   if (frame_left < 0
878       || frame_top < 0
879       || frame_left + frame_width > GetDeviceCaps (hdc, HORZRES)
880       || frame_top + frame_height > GetDeviceCaps (hdc, VERTRES))
881     invalid_operation ("Print area is ouside of the printer's "
882                        "hardware printable area",
883                        STRINGP (f->name) ? f->name : Qunbound);
884
885   /* Apply XEmacs frame geometry and layout windows */
886   {
887     int rows, columns;
888     FRAME_PIXWIDTH(f) = frame_width;
889     FRAME_PIXHEIGHT(f) = frame_height;
890     pixel_to_char_size (f, frame_width, frame_height, &columns, &rows);
891     change_frame_size (f, rows, columns, 0);
892   }
893
894   FRAME_MSPRINTER_PIXLEFT(f) = frame_left;
895   FRAME_MSPRINTER_PIXTOP(f) = frame_top;
896
897   /* Start print job */
898   di.cbSize = sizeof (di);
899   di.lpszDocName = (STRINGP(f->name)
900                     ? (char*) XSTRING_DATA(f->name)
901                     : "XEmacs print document");
902   di.lpszOutput = NULL;
903   di.lpszDatatype = NULL;
904   di.fwType = 0;
905
906   if (StartDoc (hdc, &di) <= 0)
907     invalid_operation ("Cannot start print job",
908                        STRINGP (f->name) ? f->name : Qunbound);
909
910   apply_dc_geometry (f);
911
912   /* Finish frame setup */
913   FRAME_MSPRINTER_JOB_STARTED (f) = 1;
914   FRAME_VISIBLE_P(f) = 0;
915 }
916
917 static void
918 msprinter_mark_frame (struct frame *f)
919 {
920 }
921
922 static void
923 msprinter_delete_frame (struct frame *f)
924 {
925   if (f->frame_data)
926     {
927       HDC hdc = DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f)));
928       if (FRAME_MSPRINTER_PAGE_STARTED (f))
929         EndPage (hdc);
930       if (FRAME_MSPRINTER_JOB_STARTED (f))
931         EndDoc (hdc);
932       xfree (f->frame_data);
933     }
934
935   f->frame_data = 0;
936 }
937
938 static Lisp_Object
939 msprinter_frame_property (struct frame *f, Lisp_Object property)
940 {
941   if (EQ (Qleft_margin, property))
942     return make_int (FRAME_MSPRINTER_LEFT_MARGIN(f));
943   else if (EQ (Qtop_margin, property))
944     return make_int (FRAME_MSPRINTER_TOP_MARGIN(f));
945   if (EQ (Qright_margin, property))
946     return make_int (FRAME_MSPRINTER_RIGHT_MARGIN(f));
947   else if (EQ (Qbottom_margin, property))
948     return make_int (FRAME_MSPRINTER_BOTTOM_MARGIN(f));
949   else
950     return Qunbound;
951 }
952
953 static int
954 msprinter_internal_frame_property_p (struct frame *f, Lisp_Object property)
955 {
956   return (EQ (Qleft_margin, property) || EQ (Qtop_margin, property) ||
957           EQ (Qright_margin, property) || EQ (Qbottom_margin, property));
958 }
959
960 static Lisp_Object
961 msprinter_frame_properties (struct frame *f)
962 {
963   Lisp_Object props = Qnil;
964   props = cons3 (Qbottom_margin,
965                  make_int (FRAME_MSPRINTER_BOTTOM_MARGIN(f)), props);
966   props = cons3 (Qright_margin,
967                  make_int (FRAME_MSPRINTER_RIGHT_MARGIN(f)), props);
968   props = cons3 (Qtop_margin,
969                  make_int (FRAME_MSPRINTER_TOP_MARGIN(f)), props);
970   props = cons3 (Qleft_margin,
971                  make_int (FRAME_MSPRINTER_LEFT_MARGIN(f)), props);
972   return props;
973 }
974
975 static void
976 msprinter_set_frame_properties (struct frame *f, Lisp_Object plist)
977 {
978   Lisp_Object tail;
979
980   /* Extract the properties from plist */
981   for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail)))
982     {
983       Lisp_Object prop = Fcar (tail);
984       Lisp_Object val = Fcar (Fcdr (tail));
985
986       if (SYMBOLP (prop))
987         {
988           if (EQ (prop, Qwidth))
989             {
990               maybe_error_if_job_active (f);
991               if (!NILP (val))
992                 {
993                   CHECK_NATNUM (val);
994                   FRAME_MSPRINTER_CHARWIDTH(f) = XINT (val);
995                 }
996             }
997           if (EQ (prop, Qheight))
998             {
999               maybe_error_if_job_active (f);
1000               if (!NILP (val))
1001                 {
1002                   CHECK_NATNUM (val);
1003                   FRAME_MSPRINTER_CHARHEIGHT(f) = XINT (val);
1004                 }
1005             }
1006           else if (EQ (prop, Qleft_margin))
1007             {
1008               maybe_error_if_job_active (f);
1009               CHECK_NATNUM (val);
1010               FRAME_MSPRINTER_LEFT_MARGIN(f) = XINT (val);
1011             }
1012           else if (EQ (prop, Qtop_margin))
1013             {
1014               maybe_error_if_job_active (f);
1015               CHECK_NATNUM (val);
1016               FRAME_MSPRINTER_TOP_MARGIN(f) = XINT (val);
1017             }
1018           else if (EQ (prop, Qright_margin))
1019             {
1020               maybe_error_if_job_active (f);
1021               CHECK_NATNUM (val);
1022               FRAME_MSPRINTER_RIGHT_MARGIN(f) = XINT (val);
1023             }
1024           else if (EQ (prop, Qbottom_margin))
1025             {
1026               maybe_error_if_job_active (f);
1027               CHECK_NATNUM (val);
1028               FRAME_MSPRINTER_BOTTOM_MARGIN(f) = XINT (val);
1029             }
1030         }
1031     }
1032 }
1033
1034 static void
1035 msprinter_set_frame_size (struct frame *f, int width, int height)
1036 {
1037   /* We're absolutely unsizeable */
1038   error_frame_unsizable (f);
1039 }
1040
1041 static void
1042 msprinter_eject_page (struct frame *f)
1043 {
1044   /* #### Should we eject empty pages? */
1045   if (FRAME_MSPRINTER_PAGE_STARTED (f))
1046     {
1047       FRAME_MSPRINTER_PAGE_STARTED (f) = 0;
1048       EndPage (DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f))));
1049       apply_dc_geometry (f);
1050     }
1051 }
1052
1053 \f
1054 void
1055 console_type_create_frame_mswindows (void)
1056 {
1057   /* Display frames */
1058   CONSOLE_HAS_METHOD (mswindows, init_frame_1);
1059   CONSOLE_HAS_METHOD (mswindows, init_frame_2);
1060   CONSOLE_HAS_METHOD (mswindows, init_frame_3);
1061   CONSOLE_HAS_METHOD (mswindows, after_init_frame);
1062   CONSOLE_HAS_METHOD (mswindows, mark_frame);
1063   CONSOLE_HAS_METHOD (mswindows, focus_on_frame);
1064   CONSOLE_HAS_METHOD (mswindows, delete_frame);
1065   CONSOLE_HAS_METHOD (mswindows, get_mouse_position);
1066   CONSOLE_HAS_METHOD (mswindows, set_mouse_position);
1067   CONSOLE_HAS_METHOD (mswindows, raise_frame);
1068   CONSOLE_HAS_METHOD (mswindows, lower_frame);
1069   CONSOLE_HAS_METHOD (mswindows, enable_frame);
1070   CONSOLE_HAS_METHOD (mswindows, disable_frame);
1071   CONSOLE_HAS_METHOD (mswindows, make_frame_visible);
1072   CONSOLE_HAS_METHOD (mswindows, make_frame_invisible);
1073   CONSOLE_HAS_METHOD (mswindows, iconify_frame);
1074   CONSOLE_HAS_METHOD (mswindows, set_frame_size);
1075   CONSOLE_HAS_METHOD (mswindows, set_frame_position);
1076   CONSOLE_HAS_METHOD (mswindows, frame_property);
1077   CONSOLE_HAS_METHOD (mswindows, internal_frame_property_p);
1078   CONSOLE_HAS_METHOD (mswindows, frame_properties);
1079   CONSOLE_HAS_METHOD (mswindows, set_frame_properties);
1080   CONSOLE_HAS_METHOD (mswindows, set_title_from_bufbyte);
1081 /*  CONSOLE_HAS_METHOD (mswindows, set_icon_name_from_bufbyte); */
1082   CONSOLE_HAS_METHOD (mswindows, frame_visible_p);
1083   CONSOLE_HAS_METHOD (mswindows, frame_totally_visible_p);
1084   CONSOLE_HAS_METHOD (mswindows, frame_iconified_p);
1085   CONSOLE_HAS_METHOD (mswindows, set_frame_pointer);
1086   CONSOLE_HAS_METHOD (mswindows, set_frame_icon);
1087   CONSOLE_HAS_METHOD (mswindows, get_frame_parent);
1088   CONSOLE_HAS_METHOD (mswindows, update_frame_external_traits);
1089   CONSOLE_HAS_METHOD (mswindows, frame_size_fixed_p);
1090
1091   /* Printer frames, aka print jobs */
1092   CONSOLE_HAS_METHOD (msprinter, init_frame_1);
1093   CONSOLE_HAS_METHOD (msprinter, init_frame_3);
1094   CONSOLE_HAS_METHOD (msprinter, mark_frame);
1095   CONSOLE_HAS_METHOD (msprinter, delete_frame);
1096   CONSOLE_HAS_METHOD (msprinter, frame_property);
1097   CONSOLE_HAS_METHOD (msprinter, internal_frame_property_p);
1098   CONSOLE_HAS_METHOD (msprinter, frame_properties);
1099   CONSOLE_HAS_METHOD (msprinter, set_frame_properties);
1100   CONSOLE_HAS_METHOD (msprinter, set_frame_size);
1101   CONSOLE_HAS_METHOD (msprinter, eject_page);
1102 }
1103
1104 void
1105 syms_of_frame_mswindows (void)
1106 {
1107 }
1108
1109 void
1110 reinit_vars_of_frame_mswindows (void)
1111 {
1112   /* Needn't staticpro -- see comment above.  */
1113   Vmswindows_frame_being_created = Qnil;
1114 }
1115
1116 void
1117 vars_of_frame_mswindows (void)
1118 {
1119   reinit_vars_of_frame_mswindows ();
1120
1121   DEFVAR_LISP ("mswindows-use-system-frame-size-defaults", &Vmswindows_use_system_frame_size_defaults /*
1122 Controls whether to use system or XEmacs defaults for frame size.
1123 If nil then reasonable defaults are used for initial frame sizes. If t
1124 then the system will choose default sizes for the frame.
1125 */ );
1126   Vmswindows_use_system_frame_size_defaults = Qnil;
1127
1128   DEFVAR_LISP ("default-mswindows-frame-plist", &Vdefault_mswindows_frame_plist /*
1129 Plist of default frame-creation properties for mswindows frames.
1130 These override what is specified in `default-frame-plist', but are
1131 overridden by the arguments to the particular call to `make-frame'.
1132
1133 Note: In many cases, properties of a frame are available as specifiers
1134 instead of through the frame-properties mechanism.
1135
1136 Here is a list of recognized frame properties, other than those
1137 documented in `set-frame-properties' (they can be queried and
1138 set at any time, except as otherwise noted):
1139
1140   initially-unmapped            If non-nil, the frame will not be visible
1141                                 when it is created.  In this case, you
1142                                 need to call `make-frame-visible' to make
1143                                 the frame appear.
1144   popup                         If non-nil, it should be a frame, and this
1145                                 frame will be created as a "popup" frame
1146                                 whose parent is the given frame.  This
1147                                 will make the window manager treat the
1148                                 frame as a dialog box, which may entail
1149                                 doing different things (e.g. not asking
1150                                 for positioning, and not iconifying
1151                                 separate from its parent).
1152   top                           Y position (in pixels) of the upper-left
1153                                 outermost corner of the frame (i.e. the
1154                                 upper-left of the window-manager
1155                                 decorations).
1156   left                          X position (in pixels) of the upper-left
1157                                 outermost corner of the frame (i.e. the
1158                                 upper-left of the window-manager
1159                                 decorations).
1160
1161 See also `default-frame-plist', which specifies properties which apply
1162 to all frames, not just mswindows frames.
1163 */ );
1164   Vdefault_mswindows_frame_plist = Qnil;
1165
1166   mswindows_console_methods->device_specific_frame_props =
1167     &Vdefault_mswindows_frame_plist;
1168
1169   DEFVAR_LISP ("default-msprinter-frame-plist", &Vdefault_msprinter_frame_plist /*
1170 Plist of default frame-creation properties for msprinter print job frames.
1171 These override what is specified in `default-frame-plist', but are
1172 overridden by the arguments to the particular call to `make-frame'.
1173
1174 Note: In many cases, properties of a frame are available as specifiers
1175 instead of through the frame-properties mechanism.
1176
1177 Here is a list of recognized frame properties, other than those
1178 documented in `set-frame-properties' (they can be queried and
1179 set at any time, except as otherwise noted):
1180
1181   left-margin                   Margin of the page, in twips. Twip is a
1182   top-margin                    typographical unit of measurement,
1183   right-margin                  equal to 1/1440 of an inch, or 1/20 of a
1184   bottom-margin                 point, and roughly equal to 7/400 of a
1185                                 millimeter. If not specified, each margin
1186                                 defaults to one inch (25.4 mm).
1187
1188      MARGINS NOTE. right-margin and bottom-margin are overridden by
1189        the height and width properties. If you want to specify size
1190        of the printable area in character, as with the rest of XEmacs,
1191        use these properties. If height and/or width are nil, then
1192        corresponding margin setting is taken into account. If you
1193        specify height and/or width in `default-frame-plist', but still
1194        want to specify right/bottom margins, set height/width in this
1195        plist to nil, as in this example:
1196
1197           (setq default-frame-plist '(height 55 'width 80)
1198                 default-msprinter-frame-plist '(height nil 'width nil))
1199
1200 See also `default-frame-plist', which specifies properties which apply
1201 to all frames, not just mswindows frames.
1202 */ );
1203   Vdefault_msprinter_frame_plist = Qnil;
1204
1205   msprinter_console_methods->device_specific_frame_props =
1206     &Vdefault_msprinter_frame_plist;
1207 }