update.
[chise/xemacs-chise.git] / 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   int columns, rows;
311
312   rect.left = rect.top = 0;
313   rect.right = width;
314   rect.bottom = height;
315
316   pixel_to_char_size (f, rect.right, rect.bottom, &columns, &rows);
317   change_frame_size (f, rows, columns, 0);
318
319   AdjustWindowRectEx (&rect,
320                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_STYLE),
321                       GetMenu (FRAME_MSWINDOWS_HANDLE(f)) != NULL,
322                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_EXSTYLE));
323
324   if (IsIconic (FRAME_MSWINDOWS_HANDLE(f)) || IsZoomed (FRAME_MSWINDOWS_HANDLE(f)))
325     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_RESTORE);
326
327   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), NULL,
328                 0, 0, rect.right-rect.left, rect.bottom-rect.top,
329                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING | SWP_NOMOVE);
330 }
331
332 static void
333 mswindows_set_frame_position (struct frame *f, int xoff, int yoff)
334 {
335   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), NULL,
336                 xoff, yoff, 0, 0,
337                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING | SWP_NOSIZE);
338 }
339
340 static void
341 mswindows_make_frame_visible (struct frame *f)
342 {
343   if (!FRAME_VISIBLE_P(f))
344     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_RESTORE);
345   else
346     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_SHOW);
347   f->visible = 1;
348   f->iconified = 0;
349 }
350
351 static void
352 mswindows_make_frame_invisible (struct frame *f)
353 {
354   if (!FRAME_VISIBLE_P(f))
355     return;
356
357   ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_HIDE);
358   f->visible = 0;
359 }
360
361 static int
362 mswindows_frame_totally_visible_p (struct frame *f)
363 {
364   RECT rc_me, rc_other, rc_temp;
365   HWND hwnd = FRAME_MSWINDOWS_HANDLE(f);
366
367   /* We test against not a whole window rectangle, only against its
368      client part. So, if non-client are is covered and client area is
369      not, we return true. */
370   GetClientRect (hwnd, &rc_me);
371   MapWindowPoints (hwnd, HWND_DESKTOP, (LPPOINT)&rc_me, 2);
372
373   /* First see if we're off the desktop */
374   GetWindowRect (GetDesktopWindow(), &rc_other);
375   UnionRect(&rc_temp, &rc_me, &rc_other);
376   if (!EqualRect (&rc_temp, &rc_other))
377     return 0;
378
379   /* Then see if any window above us obscures us */
380   while ((hwnd = GetWindow (hwnd, GW_HWNDPREV)) != NULL)
381     if (IsWindowVisible (hwnd))
382       {
383         GetWindowRect (hwnd, &rc_other);
384         if (IntersectRect(&rc_temp, &rc_me, &rc_other))
385           return 0;
386       }
387
388   return 1;
389 }
390
391 static int
392 mswindows_frame_visible_p (struct frame *f)
393 {
394   return IsWindowVisible (FRAME_MSWINDOWS_HANDLE(f))
395     && !IsIconic (FRAME_MSWINDOWS_HANDLE(f));
396 }
397
398
399 static void
400 mswindows_iconify_frame (struct frame *f)
401 {
402   ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_MINIMIZE);
403   f->visible = 0;
404   f->iconified = 1;
405 }
406
407 static int
408 mswindows_frame_iconified_p (struct frame *f)
409 {
410   return IsIconic (FRAME_MSWINDOWS_HANDLE(f));
411 }
412
413 static void
414 mswindows_set_frame_icon (struct frame *f)
415 {
416   if (IMAGE_INSTANCEP (f->icon)
417       && IMAGE_INSTANCE_PIXMAP_TYPE_P (XIMAGE_INSTANCE (f->icon)))
418     {
419       if (!XIMAGE_INSTANCE_MSWINDOWS_ICON (f->icon))
420         {
421           mswindows_initialize_image_instance_icon (XIMAGE_INSTANCE (f->icon),
422                                                     FALSE);
423         }
424
425       SetClassLong (FRAME_MSWINDOWS_HANDLE (f), GCL_HICON,
426                     (LONG) XIMAGE_INSTANCE_MSWINDOWS_ICON (f->icon));
427     }
428 }
429
430 static void
431 mswindows_set_frame_pointer (struct frame *f)
432 {
433   if (IMAGE_INSTANCEP (f->pointer)
434       && IMAGE_INSTANCE_TYPE (XIMAGE_INSTANCE (f->pointer)) == IMAGE_POINTER)
435     {
436       SetClassLong (FRAME_MSWINDOWS_HANDLE (f), GCL_HCURSOR,
437                     (LONG) XIMAGE_INSTANCE_MSWINDOWS_ICON (f->pointer));
438       /* we only have to do this because GC doesn't cause a mouse
439          event and doesn't give time to event processing even if it
440          did. */
441       SetCursor (XIMAGE_INSTANCE_MSWINDOWS_ICON (f->pointer));
442     }
443 }
444
445 static void
446 mswindows_set_mouse_position (struct window *w, int x, int y)
447 {
448   struct frame *f = XFRAME (w->frame);
449   POINT pt;
450
451   pt.x = w->pixel_left + x;
452   pt.y = w->pixel_top  + y;
453   ClientToScreen (FRAME_MSWINDOWS_HANDLE(f), &pt);
454   SetCursorPos (pt.x, pt.y);
455 }
456
457 static int
458 mswindows_get_mouse_position (struct device *d, Lisp_Object *frame, int *x, int *y)
459 {
460   POINT pt;
461   HWND hwnd;
462
463   GetCursorPos (&pt);
464
465   /* What's under cursor? */
466   hwnd = WindowFromPoint (pt);
467   if (hwnd == NULL)
468     return 0;
469
470   /* Get grandest parent of the window */
471   {
472     HWND hwnd_parent;
473     while ((hwnd_parent = GetParent (hwnd)) != NULL)
474       hwnd = hwnd_parent;
475   }
476
477   /* Make sure it belongs to us */
478   if (GetWindowThreadProcessId (hwnd, NULL) != GetCurrentThreadId ())
479     return 0;
480
481   /* And that the window is an XEmacs frame */
482   {
483     char class_name [sizeof(XEMACS_CLASS) + 1];
484     if (!GetClassName (hwnd, class_name, sizeof(XEMACS_CLASS))
485         || strcmp (class_name, XEMACS_CLASS) != 0)
486       return 0;
487   }
488
489   /* Yippie! */
490   ScreenToClient (hwnd, &pt);
491   VOID_TO_LISP (*frame, GetWindowLong (hwnd, XWL_FRAMEOBJ));
492   *x = pt.x;
493   *y = pt.y;
494   return 1;
495 }
496
497 static void
498 mswindows_raise_frame (struct frame *f)
499 {
500   BringWindowToTop (FRAME_MSWINDOWS_HANDLE(f));
501 }
502
503 static void
504 mswindows_lower_frame (struct frame *f)
505 {
506   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), HWND_BOTTOM, 0, 0, 0, 0,
507                 SWP_NOSIZE | SWP_NOMOVE | SWP_NOSENDCHANGING);
508 }
509
510 static void
511 mswindows_enable_frame (struct frame *f)
512 {
513   EnableWindow (FRAME_MSWINDOWS_HANDLE (f), TRUE);
514 }
515
516 static void
517 mswindows_disable_frame (struct frame *f)
518 {
519   EnableWindow (FRAME_MSWINDOWS_HANDLE (f), FALSE);
520 }
521
522 static void
523 mswindows_set_title_from_bufbyte (struct frame *f, Bufbyte *title)
524 {
525   unsigned int new_checksum = hash_string (title, strlen (title));
526   if (new_checksum != FRAME_MSWINDOWS_TITLE_CHECKSUM(f))
527     {
528       FRAME_MSWINDOWS_TITLE_CHECKSUM(f) = new_checksum;
529       SetWindowText (FRAME_MSWINDOWS_HANDLE(f), title);
530     }
531 }
532
533 static Lisp_Object
534 mswindows_frame_property (struct frame *f, Lisp_Object property)
535 {
536   if (EQ (Qleft, property) || EQ (Qtop, property))
537     {
538       RECT rc;
539       GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rc);
540       return make_int (EQ (Qtop,  property) ? rc.top : rc.left);
541     }
542   return Qunbound;
543 }
544
545 static int
546 mswindows_internal_frame_property_p (struct frame *f, Lisp_Object property)
547 {
548   return EQ (property, Qleft)
549     || EQ (property, Qtop);
550   /* #### frame-x.c has also this. Why?
551     || STRINGP (property);
552   */
553 }
554
555 static Lisp_Object
556 mswindows_frame_properties (struct frame *f)
557 {
558   Lisp_Object props = Qnil;
559   RECT rc;
560   GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rc);
561
562   props = cons3 (Qtop,  make_int (rc.top), props);
563   props = cons3 (Qleft, make_int (rc.left), props);
564
565   return props;
566 }
567
568 static void
569 mswindows_set_frame_properties (struct frame *f, Lisp_Object plist)
570 {
571   int x=-1, y=-1;
572   int width = -1, height = -1;
573   BOOL width_specified_p = FALSE;
574   BOOL height_specified_p = FALSE;
575   BOOL x_specified_p = FALSE;
576   BOOL y_specified_p = FALSE;
577   Lisp_Object tail;
578
579   /* Extract the properties from plist */
580   for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail)))
581     {
582       Lisp_Object prop = Fcar (tail);
583       Lisp_Object val = Fcar (Fcdr (tail));
584
585       if (SYMBOLP (prop))
586         {
587           /* Kludge to handle the font property. */
588           if (EQ (prop, Qfont))
589             {
590               /* If the value is not a string we silently ignore it. */
591               if (STRINGP (val))
592                 {
593                   Lisp_Object frm, font_spec;
594
595                   XSETFRAME (frm, f);
596                   font_spec = Fget (Fget_face (Qdefault), Qfont, Qnil);
597
598                   Fadd_spec_to_specifier (font_spec, val, frm, Qnil, Qnil);
599                   update_frame_face_values (f);
600                 }
601             }
602           else if (EQ (prop, Qwidth))
603             {
604               CHECK_INT (val);
605               width = XINT (val);
606               width_specified_p = TRUE;
607             }
608           else if (EQ (prop, Qheight))
609             {
610               CHECK_INT (val);
611               height = XINT (val);
612               height_specified_p = TRUE;
613             }
614           else if (EQ (prop, Qleft))
615             {
616               CHECK_INT (val);
617               x = XINT (val);
618               x_specified_p = TRUE;
619             }
620           else if (EQ (prop, Qtop))
621             {
622               CHECK_INT (val);
623               y = XINT (val);
624               y_specified_p = TRUE;
625             }
626         }
627     }
628
629   /* Now we've extracted the properties, apply them.
630      Do not apply geometric properties during frame creation. This
631      is excessive anyways, and this loses because WM_SIZE has not
632      been sent yet, so frame width and height fields are not initialized.
633
634      unfortunately WM_SIZE loses as well since the resize is only
635      applied once and the first time WM_SIZE is applied not everything
636      is initialised in the frame (toolbars for instance). enabling
637      this always makes no visible difference and fixes a whole host of
638      bugs (and is more consistent with X) so I am going to reenable it.
639      --andyp */
640   if ( FRAME_PIXWIDTH (f) && FRAME_PIXHEIGHT (f)
641        && (width_specified_p || height_specified_p
642            || x_specified_p || y_specified_p))
643     {
644       XEMACS_RECT_WH dest = { x, y, width, height };
645
646       mswindows_size_frame_internal (f, &dest);
647     }
648 }
649
650 void
651 mswindows_size_frame_internal (struct frame* f, XEMACS_RECT_WH* dest)
652 {
653   RECT rect, ws_rect;
654   int pixel_width, pixel_height;
655   int size_p = (dest->width >=0 || dest->height >=0);
656   int move_p = (dest->top >=0 || dest->left >=0);
657   char_to_real_pixel_size (f, dest->width, dest->height, &pixel_width,
658                            &pixel_height);
659
660   if (dest->width < 0)
661     pixel_width = FRAME_PIXWIDTH (f);
662   if (dest->height < 0)
663     pixel_height = FRAME_PIXHEIGHT (f);
664
665   GetWindowRect (FRAME_MSWINDOWS_HANDLE(f), &rect);
666   if (dest->left < 0)
667     dest->left = rect.left;
668   if (dest->top < 0)
669     dest->top = rect.top;
670
671   rect.left = rect.top = 0;
672   rect.right = pixel_width;
673   rect.bottom = pixel_height;
674
675   AdjustWindowRectEx (&rect,
676                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_STYLE),
677                       GetMenu (FRAME_MSWINDOWS_HANDLE(f)) != NULL,
678                       GetWindowLong (FRAME_MSWINDOWS_HANDLE(f), GWL_EXSTYLE));
679
680   /* resize and move the window so that it fits in the workspace. This is
681   not restrictive since this will happen later anyway in WM_SIZE.  We
682   have to do this after adjusting the rect to account for menubar
683   etc. */
684   mswindows_get_workspace_coords (&ws_rect);
685   pixel_width = rect.right - rect.left;
686   pixel_height = rect.bottom - rect.top;
687   if (pixel_width > ws_rect.right - ws_rect.left)
688     {
689       pixel_width = ws_rect.right - ws_rect.left;
690       size_p=1;
691     }
692   if (pixel_height > ws_rect.bottom - ws_rect.top)
693     {
694       pixel_height = ws_rect.bottom - ws_rect.top;
695       size_p=1;
696     }
697
698   /* adjust position so window is in workspace */
699   if (dest->left + pixel_width > ws_rect.right)
700     {
701       dest->left = ws_rect.right - pixel_width;
702       move_p=1;
703     }
704   if (dest->left < ws_rect.left)
705     {
706       dest->left = ws_rect.left;
707       move_p=1;
708     }
709
710   if (dest->top + pixel_height > ws_rect.bottom)
711     {
712       dest->top = ws_rect.bottom - pixel_height;
713       move_p=1;
714     }
715   if (dest->top < ws_rect.top)
716     {
717       dest->top = ws_rect.top;
718       move_p=1;
719     }
720
721   if (IsIconic (FRAME_MSWINDOWS_HANDLE(f))
722       || IsZoomed (FRAME_MSWINDOWS_HANDLE(f)))
723     ShowWindow (FRAME_MSWINDOWS_HANDLE(f), SW_RESTORE);
724
725   SetWindowPos (FRAME_MSWINDOWS_HANDLE(f), NULL,
726                 dest->left, dest->top, pixel_width, pixel_height,
727                 SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSENDCHANGING
728                 | (size_p ? 0 : SWP_NOSIZE)
729                 | (move_p ? 0 : SWP_NOMOVE));
730 }
731
732 static Lisp_Object
733 mswindows_get_frame_parent (struct frame *f)
734 {
735   HWND hwnd = FRAME_MSWINDOWS_HANDLE(f);
736   hwnd = GetParent (hwnd);
737   if (hwnd)
738     {
739       Lisp_Object parent;
740       VOID_TO_LISP (parent, GetWindowLong (hwnd, XWL_FRAMEOBJ));
741       assert (FRAME_MSWINDOWS_P (XFRAME (parent)));
742       return parent;
743     }
744   else
745     return Qnil;
746 }
747
748 static void
749 mswindows_update_frame_external_traits (struct frame* frm, Lisp_Object name)
750 {
751 }
752
753 static int
754 mswindows_frame_size_fixed_p (struct frame *f)
755 {
756   /* Frame size cannot change if the frame is maximized */
757   return IsZoomed (FRAME_MSWINDOWS_HANDLE (f));
758 }
759
760 /*---------------------------------------------------------------------*/
761 /*-----                    PRINTER FRAME                          -----*/
762 /*---------------------------------------------------------------------*/
763
764 /*
765  * With some driver/os combination (I discovered this with HP drivers
766  * under W2K), DC geometry is reset upon StartDoc and EndPage
767  * calls. This is called every time one of these calls is made.
768  */
769 static void
770 apply_dc_geometry (struct frame* f)
771 {
772   HDC hdc = DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f)));
773   SetTextAlign (hdc, TA_BASELINE | TA_LEFT | TA_NOUPDATECP);
774   SetViewportOrgEx (hdc, FRAME_MSPRINTER_PIXLEFT(f),
775                     FRAME_MSPRINTER_PIXTOP(f), NULL);
776 }
777
778 void
779 msprinter_start_page (struct frame *f)
780 {
781   if (!FRAME_MSPRINTER_PAGE_STARTED (f))
782     {
783       FRAME_MSPRINTER_PAGE_STARTED (f) = 1;
784       StartPage (DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f))));
785       apply_dc_geometry (f);
786     }
787 }
788
789 static void
790 error_frame_unsizable (struct frame *f)
791 {
792   Lisp_Object frame;
793   XSETFRAME (frame, f);
794   invalid_change ("Cannot resize frame (margins) after print job has started.",
795                   frame);
796 }
797
798 static void
799 maybe_error_if_job_active (struct frame *f)
800 {
801   if (FRAME_MSPRINTER_JOB_STARTED (f))
802     error_frame_unsizable (f);
803 }
804
805 static void
806 msprinter_init_frame_1 (struct frame *f, Lisp_Object props)
807 {
808   /* Make sure this is the only frame on device. Windows printer can
809      handle only one job at a time. */
810   if (!NILP (DEVICE_FRAME_LIST (XDEVICE (FRAME_DEVICE (f)))))
811     invalid_operation ("Only one frame (print job) at a time is allowed on "
812                        "this printer device", FRAME_DEVICE (f));
813
814   f->frame_data = xnew_and_zero (struct msprinter_frame);
815
816   FRAME_MSPRINTER_TOP_MARGIN (f) =
817     mswindows_get_default_margin (Qtop_margin);
818   FRAME_MSPRINTER_BOTTOM_MARGIN (f) =
819     mswindows_get_default_margin (Qbottom_margin);
820   FRAME_MSPRINTER_LEFT_MARGIN (f) =
821     mswindows_get_default_margin (Qleft_margin);
822   FRAME_MSPRINTER_RIGHT_MARGIN (f) =
823     mswindows_get_default_margin (Qright_margin);
824
825   /* Negative for "uinspecified" */
826   FRAME_MSPRINTER_CHARWIDTH (f) = -1;
827   FRAME_MSPRINTER_CHARHEIGHT (f) = -1;
828 }
829
830 static void
831 msprinter_init_frame_3 (struct frame *f)
832 {
833   DOCINFO di;
834   struct device *device = XDEVICE (FRAME_DEVICE (f));
835   int frame_left, frame_top, frame_width, frame_height;
836   
837   /* DC might be recreated in msprinter_apply_devmode,
838      so do not initialize until now */
839   HDC hdc = DEVICE_MSPRINTER_HDC (device);
840   int logpixelsx = GetDeviceCaps (hdc, LOGPIXELSX);
841   int logpixelsy = GetDeviceCaps (hdc, LOGPIXELSY);
842   int physicaloffsetx = GetDeviceCaps (hdc, PHYSICALOFFSETX);
843   int physicaloffsety = GetDeviceCaps (hdc, PHYSICALOFFSETY);
844   int physicalheight = GetDeviceCaps (hdc, PHYSICALHEIGHT);
845   int physicalwidth = GetDeviceCaps (hdc, PHYSICALWIDTH);
846
847   /* Compute geometry properties.
848      Conversion is from TWIPS -> inches -> pixels. */
849   frame_left = MulDiv (logpixelsx, FRAME_MSPRINTER_LEFT_MARGIN(f), 1440)
850     - physicaloffsetx;
851
852   if (FRAME_MSPRINTER_CHARWIDTH(f) > 0)
853     {
854       char_to_real_pixel_size (f, FRAME_MSPRINTER_CHARWIDTH(f), 0,
855                                &frame_width, NULL);
856       FRAME_MSPRINTER_RIGHT_MARGIN(f) =
857         MulDiv (physicalwidth - (frame_left + frame_width), 1440,
858                 logpixelsx);
859     }
860   else
861     frame_width = physicalwidth - frame_left
862       - MulDiv (logpixelsx, FRAME_MSPRINTER_RIGHT_MARGIN(f), 1440)
863       - physicaloffsetx;
864
865   frame_top = MulDiv (logpixelsy, FRAME_MSPRINTER_TOP_MARGIN(f), 1440)
866     - physicaloffsety;
867
868   if (FRAME_MSPRINTER_CHARHEIGHT(f) > 0)
869     {
870       char_to_real_pixel_size (f, 0, FRAME_MSPRINTER_CHARHEIGHT(f),
871                                NULL, &frame_height);
872
873       FRAME_MSPRINTER_BOTTOM_MARGIN(f) =
874         MulDiv (physicalheight - (frame_top + frame_height), 1440,
875                 logpixelsy);
876     }
877   else
878     frame_height = physicalheight - frame_top
879       - MulDiv (logpixelsy, FRAME_MSPRINTER_BOTTOM_MARGIN(f), 1440)
880       - physicaloffsety;
881
882   /* Geometry sanity checks */
883   if (!frame_pixsize_valid_p (f, frame_width, frame_height))
884     invalid_operation ("Area inside print margins has shrunk to naught",
885                        STRINGP (f->name) ? f->name : Qunbound);
886
887   if (frame_left < 0
888       || frame_top < 0
889       || frame_left + frame_width > GetDeviceCaps (hdc, HORZRES)
890       || frame_top + frame_height > GetDeviceCaps (hdc, VERTRES))
891     invalid_operation ("Print area is ouside of the printer's "
892                        "hardware printable area",
893                        STRINGP (f->name) ? f->name : Qunbound);
894
895   /* Apply XEmacs frame geometry and layout windows */
896   {
897     int rows, columns;
898     FRAME_PIXWIDTH(f) = frame_width;
899     FRAME_PIXHEIGHT(f) = frame_height;
900     pixel_to_char_size (f, frame_width, frame_height, &columns, &rows);
901     change_frame_size (f, rows, columns, 0);
902   }
903
904   FRAME_MSPRINTER_PIXLEFT(f) = frame_left;
905   FRAME_MSPRINTER_PIXTOP(f) = frame_top;
906
907   /* Start print job */
908   di.cbSize = sizeof (di);
909   di.lpszDocName = (STRINGP(f->name)
910                     ? (char*) XSTRING_DATA(f->name)
911                     : "XEmacs print document");
912   di.lpszOutput = NULL;
913   di.lpszDatatype = NULL;
914   di.fwType = 0;
915
916   if (StartDoc (hdc, &di) <= 0)
917     invalid_operation ("Cannot start print job",
918                        STRINGP (f->name) ? f->name : Qunbound);
919
920   apply_dc_geometry (f);
921
922   /* Finish frame setup */
923   FRAME_MSPRINTER_JOB_STARTED (f) = 1;
924   FRAME_VISIBLE_P(f) = 0;
925 }
926
927 static void
928 msprinter_mark_frame (struct frame *f)
929 {
930 }
931
932 static void
933 msprinter_delete_frame (struct frame *f)
934 {
935   if (f->frame_data)
936     {
937       HDC hdc = DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f)));
938       if (FRAME_MSPRINTER_PAGE_STARTED (f))
939         EndPage (hdc);
940       if (FRAME_MSPRINTER_JOB_STARTED (f))
941         EndDoc (hdc);
942       xfree (f->frame_data);
943     }
944
945   f->frame_data = 0;
946 }
947
948 static Lisp_Object
949 msprinter_frame_property (struct frame *f, Lisp_Object property)
950 {
951   if (EQ (Qleft_margin, property))
952     return make_int (FRAME_MSPRINTER_LEFT_MARGIN(f));
953   else if (EQ (Qtop_margin, property))
954     return make_int (FRAME_MSPRINTER_TOP_MARGIN(f));
955   if (EQ (Qright_margin, property))
956     return make_int (FRAME_MSPRINTER_RIGHT_MARGIN(f));
957   else if (EQ (Qbottom_margin, property))
958     return make_int (FRAME_MSPRINTER_BOTTOM_MARGIN(f));
959   else
960     return Qunbound;
961 }
962
963 static int
964 msprinter_internal_frame_property_p (struct frame *f, Lisp_Object property)
965 {
966   return (EQ (Qleft_margin, property) || EQ (Qtop_margin, property) ||
967           EQ (Qright_margin, property) || EQ (Qbottom_margin, property));
968 }
969
970 static Lisp_Object
971 msprinter_frame_properties (struct frame *f)
972 {
973   Lisp_Object props = Qnil;
974   props = cons3 (Qbottom_margin,
975                  make_int (FRAME_MSPRINTER_BOTTOM_MARGIN(f)), props);
976   props = cons3 (Qright_margin,
977                  make_int (FRAME_MSPRINTER_RIGHT_MARGIN(f)), props);
978   props = cons3 (Qtop_margin,
979                  make_int (FRAME_MSPRINTER_TOP_MARGIN(f)), props);
980   props = cons3 (Qleft_margin,
981                  make_int (FRAME_MSPRINTER_LEFT_MARGIN(f)), props);
982   return props;
983 }
984
985 static void
986 msprinter_set_frame_properties (struct frame *f, Lisp_Object plist)
987 {
988   Lisp_Object tail;
989
990   /* Extract the properties from plist */
991   for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail)))
992     {
993       Lisp_Object prop = Fcar (tail);
994       Lisp_Object val = Fcar (Fcdr (tail));
995
996       if (SYMBOLP (prop))
997         {
998           if (EQ (prop, Qwidth))
999             {
1000               maybe_error_if_job_active (f);
1001               if (!NILP (val))
1002                 {
1003                   CHECK_NATNUM (val);
1004                   FRAME_MSPRINTER_CHARWIDTH(f) = XINT (val);
1005                 }
1006             }
1007           if (EQ (prop, Qheight))
1008             {
1009               maybe_error_if_job_active (f);
1010               if (!NILP (val))
1011                 {
1012                   CHECK_NATNUM (val);
1013                   FRAME_MSPRINTER_CHARHEIGHT(f) = XINT (val);
1014                 }
1015             }
1016           else if (EQ (prop, Qleft_margin))
1017             {
1018               maybe_error_if_job_active (f);
1019               CHECK_NATNUM (val);
1020               FRAME_MSPRINTER_LEFT_MARGIN(f) = XINT (val);
1021             }
1022           else if (EQ (prop, Qtop_margin))
1023             {
1024               maybe_error_if_job_active (f);
1025               CHECK_NATNUM (val);
1026               FRAME_MSPRINTER_TOP_MARGIN(f) = XINT (val);
1027             }
1028           else if (EQ (prop, Qright_margin))
1029             {
1030               maybe_error_if_job_active (f);
1031               CHECK_NATNUM (val);
1032               FRAME_MSPRINTER_RIGHT_MARGIN(f) = XINT (val);
1033             }
1034           else if (EQ (prop, Qbottom_margin))
1035             {
1036               maybe_error_if_job_active (f);
1037               CHECK_NATNUM (val);
1038               FRAME_MSPRINTER_BOTTOM_MARGIN(f) = XINT (val);
1039             }
1040         }
1041     }
1042 }
1043
1044 static void
1045 msprinter_set_frame_size (struct frame *f, int width, int height)
1046 {
1047   /* We're absolutely unsizeable */
1048   error_frame_unsizable (f);
1049 }
1050
1051 static void
1052 msprinter_eject_page (struct frame *f)
1053 {
1054   /* #### Should we eject empty pages? */
1055   if (FRAME_MSPRINTER_PAGE_STARTED (f))
1056     {
1057       FRAME_MSPRINTER_PAGE_STARTED (f) = 0;
1058       EndPage (DEVICE_MSPRINTER_HDC (XDEVICE (FRAME_DEVICE (f))));
1059       apply_dc_geometry (f);
1060     }
1061 }
1062
1063 \f
1064 void
1065 console_type_create_frame_mswindows (void)
1066 {
1067   /* Display frames */
1068   CONSOLE_HAS_METHOD (mswindows, init_frame_1);
1069   CONSOLE_HAS_METHOD (mswindows, init_frame_2);
1070   CONSOLE_HAS_METHOD (mswindows, init_frame_3);
1071   CONSOLE_HAS_METHOD (mswindows, after_init_frame);
1072   CONSOLE_HAS_METHOD (mswindows, mark_frame);
1073   CONSOLE_HAS_METHOD (mswindows, focus_on_frame);
1074   CONSOLE_HAS_METHOD (mswindows, delete_frame);
1075   CONSOLE_HAS_METHOD (mswindows, get_mouse_position);
1076   CONSOLE_HAS_METHOD (mswindows, set_mouse_position);
1077   CONSOLE_HAS_METHOD (mswindows, raise_frame);
1078   CONSOLE_HAS_METHOD (mswindows, lower_frame);
1079   CONSOLE_HAS_METHOD (mswindows, enable_frame);
1080   CONSOLE_HAS_METHOD (mswindows, disable_frame);
1081   CONSOLE_HAS_METHOD (mswindows, make_frame_visible);
1082   CONSOLE_HAS_METHOD (mswindows, make_frame_invisible);
1083   CONSOLE_HAS_METHOD (mswindows, iconify_frame);
1084   CONSOLE_HAS_METHOD (mswindows, set_frame_size);
1085   CONSOLE_HAS_METHOD (mswindows, set_frame_position);
1086   CONSOLE_HAS_METHOD (mswindows, frame_property);
1087   CONSOLE_HAS_METHOD (mswindows, internal_frame_property_p);
1088   CONSOLE_HAS_METHOD (mswindows, frame_properties);
1089   CONSOLE_HAS_METHOD (mswindows, set_frame_properties);
1090   CONSOLE_HAS_METHOD (mswindows, set_title_from_bufbyte);
1091 /*  CONSOLE_HAS_METHOD (mswindows, set_icon_name_from_bufbyte); */
1092   CONSOLE_HAS_METHOD (mswindows, frame_visible_p);
1093   CONSOLE_HAS_METHOD (mswindows, frame_totally_visible_p);
1094   CONSOLE_HAS_METHOD (mswindows, frame_iconified_p);
1095   CONSOLE_HAS_METHOD (mswindows, set_frame_pointer);
1096   CONSOLE_HAS_METHOD (mswindows, set_frame_icon);
1097   CONSOLE_HAS_METHOD (mswindows, get_frame_parent);
1098   CONSOLE_HAS_METHOD (mswindows, update_frame_external_traits);
1099   CONSOLE_HAS_METHOD (mswindows, frame_size_fixed_p);
1100
1101   /* Printer frames, aka print jobs */
1102   CONSOLE_HAS_METHOD (msprinter, init_frame_1);
1103   CONSOLE_HAS_METHOD (msprinter, init_frame_3);
1104   CONSOLE_HAS_METHOD (msprinter, mark_frame);
1105   CONSOLE_HAS_METHOD (msprinter, delete_frame);
1106   CONSOLE_HAS_METHOD (msprinter, frame_property);
1107   CONSOLE_HAS_METHOD (msprinter, internal_frame_property_p);
1108   CONSOLE_HAS_METHOD (msprinter, frame_properties);
1109   CONSOLE_HAS_METHOD (msprinter, set_frame_properties);
1110   CONSOLE_HAS_METHOD (msprinter, set_frame_size);
1111   CONSOLE_HAS_METHOD (msprinter, eject_page);
1112 }
1113
1114 void
1115 syms_of_frame_mswindows (void)
1116 {
1117 }
1118
1119 void
1120 reinit_vars_of_frame_mswindows (void)
1121 {
1122   /* Needn't staticpro -- see comment above.  */
1123   Vmswindows_frame_being_created = Qnil;
1124 }
1125
1126 void
1127 vars_of_frame_mswindows (void)
1128 {
1129   reinit_vars_of_frame_mswindows ();
1130
1131   DEFVAR_LISP ("mswindows-use-system-frame-size-defaults", &Vmswindows_use_system_frame_size_defaults /*
1132 Controls whether to use system or XEmacs defaults for frame size.
1133 If nil then reasonable defaults are used for initial frame sizes. If t
1134 then the system will choose default sizes for the frame.
1135 */ );
1136   Vmswindows_use_system_frame_size_defaults = Qnil;
1137
1138   DEFVAR_LISP ("default-mswindows-frame-plist", &Vdefault_mswindows_frame_plist /*
1139 Plist of default frame-creation properties for mswindows frames.
1140 These override what is specified in `default-frame-plist', but are
1141 overridden by the arguments to the particular call to `make-frame'.
1142
1143 Note: In many cases, properties of a frame are available as specifiers
1144 instead of through the frame-properties mechanism.
1145
1146 Here is a list of recognized frame properties, other than those
1147 documented in `set-frame-properties' (they can be queried and
1148 set at any time, except as otherwise noted):
1149
1150   initially-unmapped            If non-nil, the frame will not be visible
1151                                 when it is created.  In this case, you
1152                                 need to call `make-frame-visible' to make
1153                                 the frame appear.
1154   popup                         If non-nil, it should be a frame, and this
1155                                 frame will be created as a "popup" frame
1156                                 whose parent is the given frame.  This
1157                                 will make the window manager treat the
1158                                 frame as a dialog box, which may entail
1159                                 doing different things (e.g. not asking
1160                                 for positioning, and not iconifying
1161                                 separate from its parent).
1162   top                           Y position (in pixels) of the upper-left
1163                                 outermost corner of the frame (i.e. the
1164                                 upper-left of the window-manager
1165                                 decorations).
1166   left                          X position (in pixels) of the upper-left
1167                                 outermost corner of the frame (i.e. the
1168                                 upper-left of the window-manager
1169                                 decorations).
1170
1171 See also `default-frame-plist', which specifies properties which apply
1172 to all frames, not just mswindows frames.
1173 */ );
1174   Vdefault_mswindows_frame_plist = Qnil;
1175
1176   mswindows_console_methods->device_specific_frame_props =
1177     &Vdefault_mswindows_frame_plist;
1178
1179   DEFVAR_LISP ("default-msprinter-frame-plist", &Vdefault_msprinter_frame_plist /*
1180 Plist of default frame-creation properties for msprinter print job frames.
1181 These override what is specified in `default-frame-plist', but are
1182 overridden by the arguments to the particular call to `make-frame'.
1183
1184 Note: In many cases, properties of a frame are available as specifiers
1185 instead of through the frame-properties mechanism.
1186
1187 Here is a list of recognized frame properties, other than those
1188 documented in `set-frame-properties' (they can be queried and
1189 set at any time, except as otherwise noted):
1190
1191   left-margin                   Margin of the page, in twips. Twip is a
1192   top-margin                    typographical unit of measurement,
1193   right-margin                  equal to 1/1440 of an inch, or 1/20 of a
1194   bottom-margin                 point, and roughly equal to 7/400 of a
1195                                 millimeter.  If not specified, the left
1196                                 and right margins default to 1 inch
1197                                 (25.4 mm) and the top and bottom margins
1198                                 to 0.5 inch (12.7 mm).
1199
1200      MARGINS NOTE. right-margin and bottom-margin are overridden by
1201        the height and width properties. If you want to specify size
1202        of the printable area in character, as with the rest of XEmacs,
1203        use these properties. If height and/or width are nil, then
1204        corresponding margin setting is taken into account. If you
1205        specify height and/or width in `default-frame-plist', but still
1206        want to specify right/bottom margins, set height/width in this
1207        plist to nil, as in this example:
1208
1209           (setq default-frame-plist '(height 55 width 80)
1210                 default-msprinter-frame-plist '(height nil width nil))
1211
1212 See also `default-frame-plist', which specifies properties which apply
1213 to all frames, not just mswindows frames.
1214 */ );
1215   Vdefault_msprinter_frame_plist = Qnil;
1216
1217   msprinter_console_methods->device_specific_frame_props =
1218     &Vdefault_msprinter_frame_plist;
1219 }