1 /* Graphical user interface functions for the Microsoft W32 API.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 /* Added by Kevin Gallo */
34 #include "dispextern.h"
41 #include "intervals.h"
42 #include "blockinput.h"
45 #include "termhooks.h"
50 #include "bitmaps/gray.xbm"
60 #define FILE_NAME_TEXT_FIELD edt1
62 void syms_of_w32fns ();
63 void globals_of_w32fns ();
65 extern void free_frame_menubar ();
66 extern double atof ();
67 extern int w32_console_toggle_lock_key
P_ ((int, Lisp_Object
));
68 extern void w32_menu_display_help
P_ ((HWND
, HMENU
, UINT
, UINT
));
69 extern void w32_free_menu_strings
P_ ((HWND
));
70 extern XCharStruct
*w32_per_char_metric
P_ ((XFontStruct
*, wchar_t *, int));
74 extern char *lispy_function_keys
[];
76 /* The gray bitmap `bitmaps/gray'. This is done because w32term.c uses
77 it, and including `bitmaps/gray' more than once is a problem when
78 config.h defines `static' as an empty replacement string. */
80 int gray_bitmap_width
= gray_width
;
81 int gray_bitmap_height
= gray_height
;
82 unsigned char *gray_bitmap_bits
= gray_bits
;
84 /* The colormap for converting color names to RGB values */
85 Lisp_Object Vw32_color_map
;
87 /* Non nil if alt key presses are passed on to Windows. */
88 Lisp_Object Vw32_pass_alt_to_system
;
90 /* Non nil if alt key is translated to meta_modifier, nil if it is translated
92 Lisp_Object Vw32_alt_is_meta
;
94 /* If non-zero, the windows virtual key code for an alternative quit key. */
97 /* Non nil if left window key events are passed on to Windows (this only
98 affects whether "tapping" the key opens the Start menu). */
99 Lisp_Object Vw32_pass_lwindow_to_system
;
101 /* Non nil if right window key events are passed on to Windows (this
102 only affects whether "tapping" the key opens the Start menu). */
103 Lisp_Object Vw32_pass_rwindow_to_system
;
105 /* Virtual key code used to generate "phantom" key presses in order
106 to stop system from acting on Windows key events. */
107 Lisp_Object Vw32_phantom_key_code
;
109 /* Modifier associated with the left "Windows" key, or nil to act as a
111 Lisp_Object Vw32_lwindow_modifier
;
113 /* Modifier associated with the right "Windows" key, or nil to act as a
115 Lisp_Object Vw32_rwindow_modifier
;
117 /* Modifier associated with the "Apps" key, or nil to act as a normal
119 Lisp_Object Vw32_apps_modifier
;
121 /* Value is nil if Num Lock acts as a function key. */
122 Lisp_Object Vw32_enable_num_lock
;
124 /* Value is nil if Caps Lock acts as a function key. */
125 Lisp_Object Vw32_enable_caps_lock
;
127 /* Modifier associated with Scroll Lock, or nil to act as a normal key. */
128 Lisp_Object Vw32_scroll_lock_modifier
;
130 /* Switch to control whether we inhibit requests for synthesized bold
131 and italic versions of fonts. */
132 int w32_enable_synthesized_fonts
;
134 /* Enable palette management. */
135 Lisp_Object Vw32_enable_palette
;
137 /* Control how close left/right button down events must be to
138 be converted to a middle button down event. */
139 int w32_mouse_button_tolerance
;
141 /* Minimum interval between mouse movement (and scroll bar drag)
142 events that are passed on to the event loop. */
143 int w32_mouse_move_interval
;
145 /* Flag to indicate if XBUTTON events should be passed on to Windows. */
146 int w32_pass_extra_mouse_buttons_to_system
;
148 /* Non nil if no window manager is in use. */
149 Lisp_Object Vx_no_window_manager
;
151 /* Non-zero means we're allowed to display a hourglass pointer. */
153 int display_hourglass_p
;
155 /* The background and shape of the mouse pointer, and shape when not
156 over text or in the modeline. */
158 Lisp_Object Vx_pointer_shape
, Vx_nontext_pointer_shape
, Vx_mode_pointer_shape
;
159 Lisp_Object Vx_hourglass_pointer_shape
, Vx_window_horizontal_drag_shape
;
161 /* The shape when over mouse-sensitive text. */
163 Lisp_Object Vx_sensitive_text_pointer_shape
;
166 #define IDC_HAND MAKEINTRESOURCE(32649)
169 /* Color of chars displayed in cursor box. */
171 Lisp_Object Vx_cursor_fore_pixel
;
173 /* Nonzero if using Windows. */
175 static int w32_in_use
;
177 /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'. */
179 Lisp_Object Vx_pixel_size_width_font_regexp
;
181 /* Alist of bdf fonts and the files that define them. */
182 Lisp_Object Vw32_bdf_filename_alist
;
184 /* A flag to control whether fonts are matched strictly or not. */
185 int w32_strict_fontnames
;
187 /* A flag to control whether we should only repaint if GetUpdateRect
188 indicates there is an update region. */
189 int w32_strict_painting
;
191 /* Associative list linking character set strings to Windows codepages. */
192 Lisp_Object Vw32_charset_info_alist
;
194 /* VIETNAMESE_CHARSET is not defined in some versions of MSVC. */
195 #ifndef VIETNAMESE_CHARSET
196 #define VIETNAMESE_CHARSET 163
200 Lisp_Object Qsuppress_icon
;
201 Lisp_Object Qundefined_color
;
202 Lisp_Object Qcancel_timer
;
208 Lisp_Object Qcontrol
;
211 Lisp_Object Qw32_charset_ansi
;
212 Lisp_Object Qw32_charset_default
;
213 Lisp_Object Qw32_charset_symbol
;
214 Lisp_Object Qw32_charset_shiftjis
;
215 Lisp_Object Qw32_charset_hangeul
;
216 Lisp_Object Qw32_charset_gb2312
;
217 Lisp_Object Qw32_charset_chinesebig5
;
218 Lisp_Object Qw32_charset_oem
;
220 #ifndef JOHAB_CHARSET
221 #define JOHAB_CHARSET 130
224 Lisp_Object Qw32_charset_easteurope
;
225 Lisp_Object Qw32_charset_turkish
;
226 Lisp_Object Qw32_charset_baltic
;
227 Lisp_Object Qw32_charset_russian
;
228 Lisp_Object Qw32_charset_arabic
;
229 Lisp_Object Qw32_charset_greek
;
230 Lisp_Object Qw32_charset_hebrew
;
231 Lisp_Object Qw32_charset_vietnamese
;
232 Lisp_Object Qw32_charset_thai
;
233 Lisp_Object Qw32_charset_johab
;
234 Lisp_Object Qw32_charset_mac
;
237 #ifdef UNICODE_CHARSET
238 Lisp_Object Qw32_charset_unicode
;
241 /* The ANSI codepage. */
242 int w32_ansi_code_page
;
244 /* Prefix for system colors. */
245 #define SYSTEM_COLOR_PREFIX "System"
246 #define SYSTEM_COLOR_PREFIX_LEN (sizeof (SYSTEM_COLOR_PREFIX) - 1)
248 /* State variables for emulating a three button mouse. */
253 static int button_state
= 0;
254 static W32Msg saved_mouse_button_msg
;
255 static unsigned mouse_button_timer
= 0; /* non-zero when timer is active */
256 static W32Msg saved_mouse_move_msg
;
257 static unsigned mouse_move_timer
= 0;
259 /* Window that is tracking the mouse. */
260 static HWND track_mouse_window
;
262 typedef BOOL (WINAPI
* TrackMouseEvent_Proc
)
263 (IN OUT LPTRACKMOUSEEVENT lpEventTrack
);
265 TrackMouseEvent_Proc track_mouse_event_fn
= NULL
;
266 ClipboardSequence_Proc clipboard_sequence_fn
= NULL
;
267 extern AppendMenuW_Proc unicode_append_menu
;
269 /* W95 mousewheel handler */
270 unsigned int msh_mousewheel
= 0;
273 #define MOUSE_BUTTON_ID 1
274 #define MOUSE_MOVE_ID 2
275 #define MENU_FREE_ID 3
276 /* The delay (milliseconds) before a menu is freed after WM_EXITMENULOOP
278 #define MENU_FREE_DELAY 1000
279 static unsigned menu_free_timer
= 0;
281 /* The below are defined in frame.c. */
283 extern Lisp_Object Vwindow_system_version
;
286 int image_cache_refcount
, dpyinfo_refcount
;
290 /* From w32term.c. */
291 extern int w32_num_mouse_buttons
;
292 extern Lisp_Object Vw32_recognize_altgr
;
294 extern HWND w32_system_caret_hwnd
;
296 extern int w32_system_caret_height
;
297 extern int w32_system_caret_x
;
298 extern int w32_system_caret_y
;
299 extern int w32_use_visible_system_caret
;
301 static HWND w32_visible_system_caret_hwnd
;
304 extern HMENU current_popup_menu
;
305 static int menubar_in_use
= 0;
308 /* Error if we are not connected to MS-Windows. */
313 error ("MS-Windows not in use or not initialized");
316 /* Nonzero if we can use mouse menus.
317 You should not call this unless HAVE_MENUS is defined. */
325 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
326 and checking validity for W32. */
329 check_x_frame (frame
)
335 frame
= selected_frame
;
336 CHECK_LIVE_FRAME (frame
);
338 if (! FRAME_W32_P (f
))
339 error ("Non-W32 frame used");
343 /* Let the user specify a display with a frame.
344 nil stands for the selected frame--or, if that is not a w32 frame,
345 the first display on the list. */
347 struct w32_display_info
*
348 check_x_display_info (frame
)
353 struct frame
*sf
= XFRAME (selected_frame
);
355 if (FRAME_W32_P (sf
) && FRAME_LIVE_P (sf
))
356 return FRAME_W32_DISPLAY_INFO (sf
);
358 return &one_w32_display_info
;
360 else if (STRINGP (frame
))
361 return x_display_info_for_name (frame
);
366 CHECK_LIVE_FRAME (frame
);
368 if (! FRAME_W32_P (f
))
369 error ("Non-W32 frame used");
370 return FRAME_W32_DISPLAY_INFO (f
);
374 /* Return the Emacs frame-object corresponding to an w32 window.
375 It could be the frame's main window or an icon window. */
377 /* This function can be called during GC, so use GC_xxx type test macros. */
380 x_window_to_frame (dpyinfo
, wdesc
)
381 struct w32_display_info
*dpyinfo
;
384 Lisp_Object tail
, frame
;
387 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
390 if (!GC_FRAMEP (frame
))
393 if (!FRAME_W32_P (f
) || FRAME_W32_DISPLAY_INFO (f
) != dpyinfo
)
395 if (f
->output_data
.w32
->hourglass_window
== wdesc
)
398 if (FRAME_W32_WINDOW (f
) == wdesc
)
405 static Lisp_Object unwind_create_frame
P_ ((Lisp_Object
));
406 static Lisp_Object unwind_create_tip_frame
P_ ((Lisp_Object
));
407 static void my_create_window
P_ ((struct frame
*));
408 static void my_create_tip_window
P_ ((struct frame
*));
410 /* TODO: Native Input Method support; see x_create_im. */
411 void x_set_foreground_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
412 void x_set_background_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
413 void x_set_mouse_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
414 void x_set_cursor_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
415 void x_set_border_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
416 void x_set_cursor_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
417 void x_set_icon_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
418 void x_set_icon_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
419 void x_explicitly_set_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
420 void x_set_menu_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
421 void x_set_title
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
422 void x_set_tool_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
423 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
429 /* Store the screen positions of frame F into XPTR and YPTR.
430 These are the positions of the containing window manager window,
431 not Emacs's own window. */
434 x_real_positions (f
, xptr
, yptr
)
441 /* Get the bounds of the WM window. */
442 GetWindowRect (FRAME_W32_WINDOW (f
), &rect
);
447 /* Convert (0, 0) in the client area to screen co-ordinates. */
448 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
450 /* Remember x_pixels_diff and y_pixels_diff. */
451 f
->x_pixels_diff
= pt
.x
- rect
.left
;
452 f
->y_pixels_diff
= pt
.y
- rect
.top
;
460 DEFUN ("w32-define-rgb-color", Fw32_define_rgb_color
,
461 Sw32_define_rgb_color
, 4, 4, 0,
462 doc
: /* Convert RGB numbers to a windows color reference and associate with NAME.
463 This adds or updates a named color to w32-color-map, making it
464 available for use. The original entry's RGB ref is returned, or nil
465 if the entry is new. */)
466 (red
, green
, blue
, name
)
467 Lisp_Object red
, green
, blue
, name
;
470 Lisp_Object oldrgb
= Qnil
;
474 CHECK_NUMBER (green
);
478 XSETINT (rgb
, RGB(XUINT (red
), XUINT (green
), XUINT (blue
)));
482 /* replace existing entry in w32-color-map or add new entry. */
483 entry
= Fassoc (name
, Vw32_color_map
);
486 entry
= Fcons (name
, rgb
);
487 Vw32_color_map
= Fcons (entry
, Vw32_color_map
);
491 oldrgb
= Fcdr (entry
);
492 Fsetcdr (entry
, rgb
);
500 DEFUN ("w32-load-color-file", Fw32_load_color_file
,
501 Sw32_load_color_file
, 1, 1, 0,
502 doc
: /* Create an alist of color entries from an external file.
503 Assign this value to w32-color-map to replace the existing color map.
505 The file should define one named RGB color per line like so:
507 where R,G,B are numbers between 0 and 255 and name is an arbitrary string. */)
509 Lisp_Object filename
;
512 Lisp_Object cmap
= Qnil
;
515 CHECK_STRING (filename
);
516 abspath
= Fexpand_file_name (filename
, Qnil
);
518 fp
= fopen (SDATA (filename
), "rt");
522 int red
, green
, blue
;
527 while (fgets (buf
, sizeof (buf
), fp
) != NULL
) {
528 if (sscanf (buf
, "%u %u %u %n", &red
, &green
, &blue
, &num
) == 3)
530 char *name
= buf
+ num
;
531 num
= strlen (name
) - 1;
532 if (name
[num
] == '\n')
534 cmap
= Fcons (Fcons (build_string (name
),
535 make_number (RGB (red
, green
, blue
))),
547 /* The default colors for the w32 color map */
548 typedef struct colormap_t
554 colormap_t w32_color_map
[] =
556 {"snow" , PALETTERGB (255,250,250)},
557 {"ghost white" , PALETTERGB (248,248,255)},
558 {"GhostWhite" , PALETTERGB (248,248,255)},
559 {"white smoke" , PALETTERGB (245,245,245)},
560 {"WhiteSmoke" , PALETTERGB (245,245,245)},
561 {"gainsboro" , PALETTERGB (220,220,220)},
562 {"floral white" , PALETTERGB (255,250,240)},
563 {"FloralWhite" , PALETTERGB (255,250,240)},
564 {"old lace" , PALETTERGB (253,245,230)},
565 {"OldLace" , PALETTERGB (253,245,230)},
566 {"linen" , PALETTERGB (250,240,230)},
567 {"antique white" , PALETTERGB (250,235,215)},
568 {"AntiqueWhite" , PALETTERGB (250,235,215)},
569 {"papaya whip" , PALETTERGB (255,239,213)},
570 {"PapayaWhip" , PALETTERGB (255,239,213)},
571 {"blanched almond" , PALETTERGB (255,235,205)},
572 {"BlanchedAlmond" , PALETTERGB (255,235,205)},
573 {"bisque" , PALETTERGB (255,228,196)},
574 {"peach puff" , PALETTERGB (255,218,185)},
575 {"PeachPuff" , PALETTERGB (255,218,185)},
576 {"navajo white" , PALETTERGB (255,222,173)},
577 {"NavajoWhite" , PALETTERGB (255,222,173)},
578 {"moccasin" , PALETTERGB (255,228,181)},
579 {"cornsilk" , PALETTERGB (255,248,220)},
580 {"ivory" , PALETTERGB (255,255,240)},
581 {"lemon chiffon" , PALETTERGB (255,250,205)},
582 {"LemonChiffon" , PALETTERGB (255,250,205)},
583 {"seashell" , PALETTERGB (255,245,238)},
584 {"honeydew" , PALETTERGB (240,255,240)},
585 {"mint cream" , PALETTERGB (245,255,250)},
586 {"MintCream" , PALETTERGB (245,255,250)},
587 {"azure" , PALETTERGB (240,255,255)},
588 {"alice blue" , PALETTERGB (240,248,255)},
589 {"AliceBlue" , PALETTERGB (240,248,255)},
590 {"lavender" , PALETTERGB (230,230,250)},
591 {"lavender blush" , PALETTERGB (255,240,245)},
592 {"LavenderBlush" , PALETTERGB (255,240,245)},
593 {"misty rose" , PALETTERGB (255,228,225)},
594 {"MistyRose" , PALETTERGB (255,228,225)},
595 {"white" , PALETTERGB (255,255,255)},
596 {"black" , PALETTERGB ( 0, 0, 0)},
597 {"dark slate gray" , PALETTERGB ( 47, 79, 79)},
598 {"DarkSlateGray" , PALETTERGB ( 47, 79, 79)},
599 {"dark slate grey" , PALETTERGB ( 47, 79, 79)},
600 {"DarkSlateGrey" , PALETTERGB ( 47, 79, 79)},
601 {"dim gray" , PALETTERGB (105,105,105)},
602 {"DimGray" , PALETTERGB (105,105,105)},
603 {"dim grey" , PALETTERGB (105,105,105)},
604 {"DimGrey" , PALETTERGB (105,105,105)},
605 {"slate gray" , PALETTERGB (112,128,144)},
606 {"SlateGray" , PALETTERGB (112,128,144)},
607 {"slate grey" , PALETTERGB (112,128,144)},
608 {"SlateGrey" , PALETTERGB (112,128,144)},
609 {"light slate gray" , PALETTERGB (119,136,153)},
610 {"LightSlateGray" , PALETTERGB (119,136,153)},
611 {"light slate grey" , PALETTERGB (119,136,153)},
612 {"LightSlateGrey" , PALETTERGB (119,136,153)},
613 {"gray" , PALETTERGB (190,190,190)},
614 {"grey" , PALETTERGB (190,190,190)},
615 {"light grey" , PALETTERGB (211,211,211)},
616 {"LightGrey" , PALETTERGB (211,211,211)},
617 {"light gray" , PALETTERGB (211,211,211)},
618 {"LightGray" , PALETTERGB (211,211,211)},
619 {"midnight blue" , PALETTERGB ( 25, 25,112)},
620 {"MidnightBlue" , PALETTERGB ( 25, 25,112)},
621 {"navy" , PALETTERGB ( 0, 0,128)},
622 {"navy blue" , PALETTERGB ( 0, 0,128)},
623 {"NavyBlue" , PALETTERGB ( 0, 0,128)},
624 {"cornflower blue" , PALETTERGB (100,149,237)},
625 {"CornflowerBlue" , PALETTERGB (100,149,237)},
626 {"dark slate blue" , PALETTERGB ( 72, 61,139)},
627 {"DarkSlateBlue" , PALETTERGB ( 72, 61,139)},
628 {"slate blue" , PALETTERGB (106, 90,205)},
629 {"SlateBlue" , PALETTERGB (106, 90,205)},
630 {"medium slate blue" , PALETTERGB (123,104,238)},
631 {"MediumSlateBlue" , PALETTERGB (123,104,238)},
632 {"light slate blue" , PALETTERGB (132,112,255)},
633 {"LightSlateBlue" , PALETTERGB (132,112,255)},
634 {"medium blue" , PALETTERGB ( 0, 0,205)},
635 {"MediumBlue" , PALETTERGB ( 0, 0,205)},
636 {"royal blue" , PALETTERGB ( 65,105,225)},
637 {"RoyalBlue" , PALETTERGB ( 65,105,225)},
638 {"blue" , PALETTERGB ( 0, 0,255)},
639 {"dodger blue" , PALETTERGB ( 30,144,255)},
640 {"DodgerBlue" , PALETTERGB ( 30,144,255)},
641 {"deep sky blue" , PALETTERGB ( 0,191,255)},
642 {"DeepSkyBlue" , PALETTERGB ( 0,191,255)},
643 {"sky blue" , PALETTERGB (135,206,235)},
644 {"SkyBlue" , PALETTERGB (135,206,235)},
645 {"light sky blue" , PALETTERGB (135,206,250)},
646 {"LightSkyBlue" , PALETTERGB (135,206,250)},
647 {"steel blue" , PALETTERGB ( 70,130,180)},
648 {"SteelBlue" , PALETTERGB ( 70,130,180)},
649 {"light steel blue" , PALETTERGB (176,196,222)},
650 {"LightSteelBlue" , PALETTERGB (176,196,222)},
651 {"light blue" , PALETTERGB (173,216,230)},
652 {"LightBlue" , PALETTERGB (173,216,230)},
653 {"powder blue" , PALETTERGB (176,224,230)},
654 {"PowderBlue" , PALETTERGB (176,224,230)},
655 {"pale turquoise" , PALETTERGB (175,238,238)},
656 {"PaleTurquoise" , PALETTERGB (175,238,238)},
657 {"dark turquoise" , PALETTERGB ( 0,206,209)},
658 {"DarkTurquoise" , PALETTERGB ( 0,206,209)},
659 {"medium turquoise" , PALETTERGB ( 72,209,204)},
660 {"MediumTurquoise" , PALETTERGB ( 72,209,204)},
661 {"turquoise" , PALETTERGB ( 64,224,208)},
662 {"cyan" , PALETTERGB ( 0,255,255)},
663 {"light cyan" , PALETTERGB (224,255,255)},
664 {"LightCyan" , PALETTERGB (224,255,255)},
665 {"cadet blue" , PALETTERGB ( 95,158,160)},
666 {"CadetBlue" , PALETTERGB ( 95,158,160)},
667 {"medium aquamarine" , PALETTERGB (102,205,170)},
668 {"MediumAquamarine" , PALETTERGB (102,205,170)},
669 {"aquamarine" , PALETTERGB (127,255,212)},
670 {"dark green" , PALETTERGB ( 0,100, 0)},
671 {"DarkGreen" , PALETTERGB ( 0,100, 0)},
672 {"dark olive green" , PALETTERGB ( 85,107, 47)},
673 {"DarkOliveGreen" , PALETTERGB ( 85,107, 47)},
674 {"dark sea green" , PALETTERGB (143,188,143)},
675 {"DarkSeaGreen" , PALETTERGB (143,188,143)},
676 {"sea green" , PALETTERGB ( 46,139, 87)},
677 {"SeaGreen" , PALETTERGB ( 46,139, 87)},
678 {"medium sea green" , PALETTERGB ( 60,179,113)},
679 {"MediumSeaGreen" , PALETTERGB ( 60,179,113)},
680 {"light sea green" , PALETTERGB ( 32,178,170)},
681 {"LightSeaGreen" , PALETTERGB ( 32,178,170)},
682 {"pale green" , PALETTERGB (152,251,152)},
683 {"PaleGreen" , PALETTERGB (152,251,152)},
684 {"spring green" , PALETTERGB ( 0,255,127)},
685 {"SpringGreen" , PALETTERGB ( 0,255,127)},
686 {"lawn green" , PALETTERGB (124,252, 0)},
687 {"LawnGreen" , PALETTERGB (124,252, 0)},
688 {"green" , PALETTERGB ( 0,255, 0)},
689 {"chartreuse" , PALETTERGB (127,255, 0)},
690 {"medium spring green" , PALETTERGB ( 0,250,154)},
691 {"MediumSpringGreen" , PALETTERGB ( 0,250,154)},
692 {"green yellow" , PALETTERGB (173,255, 47)},
693 {"GreenYellow" , PALETTERGB (173,255, 47)},
694 {"lime green" , PALETTERGB ( 50,205, 50)},
695 {"LimeGreen" , PALETTERGB ( 50,205, 50)},
696 {"yellow green" , PALETTERGB (154,205, 50)},
697 {"YellowGreen" , PALETTERGB (154,205, 50)},
698 {"forest green" , PALETTERGB ( 34,139, 34)},
699 {"ForestGreen" , PALETTERGB ( 34,139, 34)},
700 {"olive drab" , PALETTERGB (107,142, 35)},
701 {"OliveDrab" , PALETTERGB (107,142, 35)},
702 {"dark khaki" , PALETTERGB (189,183,107)},
703 {"DarkKhaki" , PALETTERGB (189,183,107)},
704 {"khaki" , PALETTERGB (240,230,140)},
705 {"pale goldenrod" , PALETTERGB (238,232,170)},
706 {"PaleGoldenrod" , PALETTERGB (238,232,170)},
707 {"light goldenrod yellow" , PALETTERGB (250,250,210)},
708 {"LightGoldenrodYellow" , PALETTERGB (250,250,210)},
709 {"light yellow" , PALETTERGB (255,255,224)},
710 {"LightYellow" , PALETTERGB (255,255,224)},
711 {"yellow" , PALETTERGB (255,255, 0)},
712 {"gold" , PALETTERGB (255,215, 0)},
713 {"light goldenrod" , PALETTERGB (238,221,130)},
714 {"LightGoldenrod" , PALETTERGB (238,221,130)},
715 {"goldenrod" , PALETTERGB (218,165, 32)},
716 {"dark goldenrod" , PALETTERGB (184,134, 11)},
717 {"DarkGoldenrod" , PALETTERGB (184,134, 11)},
718 {"rosy brown" , PALETTERGB (188,143,143)},
719 {"RosyBrown" , PALETTERGB (188,143,143)},
720 {"indian red" , PALETTERGB (205, 92, 92)},
721 {"IndianRed" , PALETTERGB (205, 92, 92)},
722 {"saddle brown" , PALETTERGB (139, 69, 19)},
723 {"SaddleBrown" , PALETTERGB (139, 69, 19)},
724 {"sienna" , PALETTERGB (160, 82, 45)},
725 {"peru" , PALETTERGB (205,133, 63)},
726 {"burlywood" , PALETTERGB (222,184,135)},
727 {"beige" , PALETTERGB (245,245,220)},
728 {"wheat" , PALETTERGB (245,222,179)},
729 {"sandy brown" , PALETTERGB (244,164, 96)},
730 {"SandyBrown" , PALETTERGB (244,164, 96)},
731 {"tan" , PALETTERGB (210,180,140)},
732 {"chocolate" , PALETTERGB (210,105, 30)},
733 {"firebrick" , PALETTERGB (178,34, 34)},
734 {"brown" , PALETTERGB (165,42, 42)},
735 {"dark salmon" , PALETTERGB (233,150,122)},
736 {"DarkSalmon" , PALETTERGB (233,150,122)},
737 {"salmon" , PALETTERGB (250,128,114)},
738 {"light salmon" , PALETTERGB (255,160,122)},
739 {"LightSalmon" , PALETTERGB (255,160,122)},
740 {"orange" , PALETTERGB (255,165, 0)},
741 {"dark orange" , PALETTERGB (255,140, 0)},
742 {"DarkOrange" , PALETTERGB (255,140, 0)},
743 {"coral" , PALETTERGB (255,127, 80)},
744 {"light coral" , PALETTERGB (240,128,128)},
745 {"LightCoral" , PALETTERGB (240,128,128)},
746 {"tomato" , PALETTERGB (255, 99, 71)},
747 {"orange red" , PALETTERGB (255, 69, 0)},
748 {"OrangeRed" , PALETTERGB (255, 69, 0)},
749 {"red" , PALETTERGB (255, 0, 0)},
750 {"hot pink" , PALETTERGB (255,105,180)},
751 {"HotPink" , PALETTERGB (255,105,180)},
752 {"deep pink" , PALETTERGB (255, 20,147)},
753 {"DeepPink" , PALETTERGB (255, 20,147)},
754 {"pink" , PALETTERGB (255,192,203)},
755 {"light pink" , PALETTERGB (255,182,193)},
756 {"LightPink" , PALETTERGB (255,182,193)},
757 {"pale violet red" , PALETTERGB (219,112,147)},
758 {"PaleVioletRed" , PALETTERGB (219,112,147)},
759 {"maroon" , PALETTERGB (176, 48, 96)},
760 {"medium violet red" , PALETTERGB (199, 21,133)},
761 {"MediumVioletRed" , PALETTERGB (199, 21,133)},
762 {"violet red" , PALETTERGB (208, 32,144)},
763 {"VioletRed" , PALETTERGB (208, 32,144)},
764 {"magenta" , PALETTERGB (255, 0,255)},
765 {"violet" , PALETTERGB (238,130,238)},
766 {"plum" , PALETTERGB (221,160,221)},
767 {"orchid" , PALETTERGB (218,112,214)},
768 {"medium orchid" , PALETTERGB (186, 85,211)},
769 {"MediumOrchid" , PALETTERGB (186, 85,211)},
770 {"dark orchid" , PALETTERGB (153, 50,204)},
771 {"DarkOrchid" , PALETTERGB (153, 50,204)},
772 {"dark violet" , PALETTERGB (148, 0,211)},
773 {"DarkViolet" , PALETTERGB (148, 0,211)},
774 {"blue violet" , PALETTERGB (138, 43,226)},
775 {"BlueViolet" , PALETTERGB (138, 43,226)},
776 {"purple" , PALETTERGB (160, 32,240)},
777 {"medium purple" , PALETTERGB (147,112,219)},
778 {"MediumPurple" , PALETTERGB (147,112,219)},
779 {"thistle" , PALETTERGB (216,191,216)},
780 {"gray0" , PALETTERGB ( 0, 0, 0)},
781 {"grey0" , PALETTERGB ( 0, 0, 0)},
782 {"dark grey" , PALETTERGB (169,169,169)},
783 {"DarkGrey" , PALETTERGB (169,169,169)},
784 {"dark gray" , PALETTERGB (169,169,169)},
785 {"DarkGray" , PALETTERGB (169,169,169)},
786 {"dark blue" , PALETTERGB ( 0, 0,139)},
787 {"DarkBlue" , PALETTERGB ( 0, 0,139)},
788 {"dark cyan" , PALETTERGB ( 0,139,139)},
789 {"DarkCyan" , PALETTERGB ( 0,139,139)},
790 {"dark magenta" , PALETTERGB (139, 0,139)},
791 {"DarkMagenta" , PALETTERGB (139, 0,139)},
792 {"dark red" , PALETTERGB (139, 0, 0)},
793 {"DarkRed" , PALETTERGB (139, 0, 0)},
794 {"light green" , PALETTERGB (144,238,144)},
795 {"LightGreen" , PALETTERGB (144,238,144)},
798 DEFUN ("w32-default-color-map", Fw32_default_color_map
, Sw32_default_color_map
,
799 0, 0, 0, doc
: /* Return the default color map. */)
803 colormap_t
*pc
= w32_color_map
;
810 for (i
= 0; i
< sizeof (w32_color_map
) / sizeof (w32_color_map
[0]);
812 cmap
= Fcons (Fcons (build_string (pc
->name
),
813 make_number (pc
->colorref
)),
831 color
= Frassq (rgb
, Vw32_color_map
);
836 return (Fcar (color
));
842 w32_color_map_lookup (colorname
)
845 Lisp_Object tail
, ret
= Qnil
;
849 for (tail
= Vw32_color_map
; CONSP (tail
); tail
= XCDR (tail
))
851 register Lisp_Object elt
, tem
;
854 if (!CONSP (elt
)) continue;
858 if (lstrcmpi (SDATA (tem
), colorname
) == 0)
875 add_system_logical_colors_to_map (system_colors
)
876 Lisp_Object
*system_colors
;
880 /* Other registry operations are done with input blocked. */
883 /* Look for "Control Panel/Colors" under User and Machine registry
885 if (RegOpenKeyEx (HKEY_CURRENT_USER
, "Control Panel\\Colors", 0,
886 KEY_READ
, &colors_key
) == ERROR_SUCCESS
887 || RegOpenKeyEx (HKEY_LOCAL_MACHINE
, "Control Panel\\Colors", 0,
888 KEY_READ
, &colors_key
) == ERROR_SUCCESS
)
891 char color_buffer
[64];
892 char full_name_buffer
[MAX_PATH
+ SYSTEM_COLOR_PREFIX_LEN
];
894 DWORD name_size
, color_size
;
895 char *name_buffer
= full_name_buffer
+ SYSTEM_COLOR_PREFIX_LEN
;
897 name_size
= sizeof (full_name_buffer
) - SYSTEM_COLOR_PREFIX_LEN
;
898 color_size
= sizeof (color_buffer
);
900 strcpy (full_name_buffer
, SYSTEM_COLOR_PREFIX
);
902 while (RegEnumValueA (colors_key
, index
, name_buffer
, &name_size
,
903 NULL
, NULL
, color_buffer
, &color_size
)
907 if (sscanf (color_buffer
, " %u %u %u", &r
, &g
, &b
) == 3)
908 *system_colors
= Fcons (Fcons (build_string (full_name_buffer
),
909 make_number (RGB (r
, g
, b
))),
912 name_size
= sizeof (full_name_buffer
) - SYSTEM_COLOR_PREFIX_LEN
;
913 color_size
= sizeof (color_buffer
);
916 RegCloseKey (colors_key
);
924 x_to_w32_color (colorname
)
927 register Lisp_Object ret
= Qnil
;
931 if (colorname
[0] == '#')
933 /* Could be an old-style RGB Device specification. */
936 color
= colorname
+ 1;
938 size
= strlen(color
);
939 if (size
== 3 || size
== 6 || size
== 9 || size
== 12)
947 for (i
= 0; i
< 3; i
++)
953 /* The check for 'x' in the following conditional takes into
954 account the fact that strtol allows a "0x" in front of
955 our numbers, and we don't. */
956 if (!isxdigit(color
[0]) || color
[1] == 'x')
960 value
= strtoul(color
, &end
, 16);
962 if (errno
== ERANGE
|| end
- color
!= size
)
967 value
= value
* 0x10;
978 colorval
|= (value
<< pos
);
983 XSETINT (ret
, colorval
);
990 else if (strnicmp(colorname
, "rgb:", 4) == 0)
998 color
= colorname
+ 4;
999 for (i
= 0; i
< 3; i
++)
1002 unsigned long value
;
1004 /* The check for 'x' in the following conditional takes into
1005 account the fact that strtol allows a "0x" in front of
1006 our numbers, and we don't. */
1007 if (!isxdigit(color
[0]) || color
[1] == 'x')
1009 value
= strtoul(color
, &end
, 16);
1010 if (errno
== ERANGE
)
1012 switch (end
- color
)
1015 value
= value
* 0x10 + value
;
1028 if (value
== ULONG_MAX
)
1030 colorval
|= (value
<< pos
);
1037 XSETINT (ret
, colorval
);
1045 else if (strnicmp(colorname
, "rgbi:", 5) == 0)
1047 /* This is an RGB Intensity specification. */
1054 color
= colorname
+ 5;
1055 for (i
= 0; i
< 3; i
++)
1061 value
= strtod(color
, &end
);
1062 if (errno
== ERANGE
)
1064 if (value
< 0.0 || value
> 1.0)
1066 val
= (UINT
)(0x100 * value
);
1067 /* We used 0x100 instead of 0xFF to give a continuous
1068 range between 0.0 and 1.0 inclusive. The next statement
1069 fixes the 1.0 case. */
1072 colorval
|= (val
<< pos
);
1079 XSETINT (ret
, colorval
);
1087 /* I am not going to attempt to handle any of the CIE color schemes
1088 or TekHVC, since I don't know the algorithms for conversion to
1091 /* If we fail to lookup the color name in w32_color_map, then check the
1092 colorname to see if it can be crudely approximated: If the X color
1093 ends in a number (e.g., "darkseagreen2"), strip the number and
1094 return the result of looking up the base color name. */
1095 ret
= w32_color_map_lookup (colorname
);
1098 int len
= strlen (colorname
);
1100 if (isdigit (colorname
[len
- 1]))
1102 char *ptr
, *approx
= alloca (len
+ 1);
1104 strcpy (approx
, colorname
);
1105 ptr
= &approx
[len
- 1];
1106 while (ptr
> approx
&& isdigit (*ptr
))
1109 ret
= w32_color_map_lookup (approx
);
1118 w32_regenerate_palette (FRAME_PTR f
)
1120 struct w32_palette_entry
* list
;
1121 LOGPALETTE
* log_palette
;
1122 HPALETTE new_palette
;
1125 /* don't bother trying to create palette if not supported */
1126 if (! FRAME_W32_DISPLAY_INFO (f
)->has_palette
)
1129 log_palette
= (LOGPALETTE
*)
1130 alloca (sizeof (LOGPALETTE
) +
1131 FRAME_W32_DISPLAY_INFO (f
)->num_colors
* sizeof (PALETTEENTRY
));
1132 log_palette
->palVersion
= 0x300;
1133 log_palette
->palNumEntries
= FRAME_W32_DISPLAY_INFO (f
)->num_colors
;
1135 list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1137 i
< FRAME_W32_DISPLAY_INFO (f
)->num_colors
;
1138 i
++, list
= list
->next
)
1139 log_palette
->palPalEntry
[i
] = list
->entry
;
1141 new_palette
= CreatePalette (log_palette
);
1145 if (FRAME_W32_DISPLAY_INFO (f
)->palette
)
1146 DeleteObject (FRAME_W32_DISPLAY_INFO (f
)->palette
);
1147 FRAME_W32_DISPLAY_INFO (f
)->palette
= new_palette
;
1149 /* Realize display palette and garbage all frames. */
1150 release_frame_dc (f
, get_frame_dc (f
));
1155 #define W32_COLOR(pe) RGB (pe.peRed, pe.peGreen, pe.peBlue)
1156 #define SET_W32_COLOR(pe, color) \
1159 pe.peRed = GetRValue (color); \
1160 pe.peGreen = GetGValue (color); \
1161 pe.peBlue = GetBValue (color); \
1166 /* Keep these around in case we ever want to track color usage. */
1168 w32_map_color (FRAME_PTR f
, COLORREF color
)
1170 struct w32_palette_entry
* list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1172 if (NILP (Vw32_enable_palette
))
1175 /* check if color is already mapped */
1178 if (W32_COLOR (list
->entry
) == color
)
1186 /* not already mapped, so add to list and recreate Windows palette */
1187 list
= (struct w32_palette_entry
*)
1188 xmalloc (sizeof (struct w32_palette_entry
));
1189 SET_W32_COLOR (list
->entry
, color
);
1191 list
->next
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1192 FRAME_W32_DISPLAY_INFO (f
)->color_list
= list
;
1193 FRAME_W32_DISPLAY_INFO (f
)->num_colors
++;
1195 /* set flag that palette must be regenerated */
1196 FRAME_W32_DISPLAY_INFO (f
)->regen_palette
= TRUE
;
1200 w32_unmap_color (FRAME_PTR f
, COLORREF color
)
1202 struct w32_palette_entry
* list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1203 struct w32_palette_entry
**prev
= &FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1205 if (NILP (Vw32_enable_palette
))
1208 /* check if color is already mapped */
1211 if (W32_COLOR (list
->entry
) == color
)
1213 if (--list
->refcount
== 0)
1217 FRAME_W32_DISPLAY_INFO (f
)->num_colors
--;
1227 /* set flag that palette must be regenerated */
1228 FRAME_W32_DISPLAY_INFO (f
)->regen_palette
= TRUE
;
1233 /* Gamma-correct COLOR on frame F. */
1236 gamma_correct (f
, color
)
1242 *color
= PALETTERGB (
1243 pow (GetRValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5,
1244 pow (GetGValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5,
1245 pow (GetBValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5);
1250 /* Decide if color named COLOR is valid for the display associated with
1251 the selected frame; if so, return the rgb values in COLOR_DEF.
1252 If ALLOC is nonzero, allocate a new colormap cell. */
1255 w32_defined_color (f
, color
, color_def
, alloc
)
1261 register Lisp_Object tem
;
1262 COLORREF w32_color_ref
;
1264 tem
= x_to_w32_color (color
);
1270 /* Apply gamma correction. */
1271 w32_color_ref
= XUINT (tem
);
1272 gamma_correct (f
, &w32_color_ref
);
1273 XSETINT (tem
, w32_color_ref
);
1276 /* Map this color to the palette if it is enabled. */
1277 if (!NILP (Vw32_enable_palette
))
1279 struct w32_palette_entry
* entry
=
1280 one_w32_display_info
.color_list
;
1281 struct w32_palette_entry
** prev
=
1282 &one_w32_display_info
.color_list
;
1284 /* check if color is already mapped */
1287 if (W32_COLOR (entry
->entry
) == XUINT (tem
))
1289 prev
= &entry
->next
;
1290 entry
= entry
->next
;
1293 if (entry
== NULL
&& alloc
)
1295 /* not already mapped, so add to list */
1296 entry
= (struct w32_palette_entry
*)
1297 xmalloc (sizeof (struct w32_palette_entry
));
1298 SET_W32_COLOR (entry
->entry
, XUINT (tem
));
1301 one_w32_display_info
.num_colors
++;
1303 /* set flag that palette must be regenerated */
1304 one_w32_display_info
.regen_palette
= TRUE
;
1307 /* Ensure COLORREF value is snapped to nearest color in (default)
1308 palette by simulating the PALETTERGB macro. This works whether
1309 or not the display device has a palette. */
1310 w32_color_ref
= XUINT (tem
) | 0x2000000;
1312 color_def
->pixel
= w32_color_ref
;
1313 color_def
->red
= GetRValue (w32_color_ref
) * 256;
1314 color_def
->green
= GetGValue (w32_color_ref
) * 256;
1315 color_def
->blue
= GetBValue (w32_color_ref
) * 256;
1325 /* Given a string ARG naming a color, compute a pixel value from it
1326 suitable for screen F.
1327 If F is not a color screen, return DEF (default) regardless of what
1331 x_decode_color (f
, arg
, def
)
1340 if (strcmp (SDATA (arg
), "black") == 0)
1341 return BLACK_PIX_DEFAULT (f
);
1342 else if (strcmp (SDATA (arg
), "white") == 0)
1343 return WHITE_PIX_DEFAULT (f
);
1345 if ((FRAME_W32_DISPLAY_INFO (f
)->n_planes
* FRAME_W32_DISPLAY_INFO (f
)->n_cbits
) == 1)
1348 /* w32_defined_color is responsible for coping with failures
1349 by looking for a near-miss. */
1350 if (w32_defined_color (f
, SDATA (arg
), &cdef
, 1))
1353 /* defined_color failed; return an ultimate default. */
1359 /* Functions called only from `x_set_frame_param'
1360 to set individual parameters.
1362 If FRAME_W32_WINDOW (f) is 0,
1363 the frame is being created and its window does not exist yet.
1364 In that case, just record the parameter's new value
1365 in the standard place; do not attempt to change the window. */
1368 x_set_foreground_color (f
, arg
, oldval
)
1370 Lisp_Object arg
, oldval
;
1372 struct w32_output
*x
= f
->output_data
.w32
;
1373 PIX_TYPE fg
, old_fg
;
1375 fg
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1376 old_fg
= FRAME_FOREGROUND_PIXEL (f
);
1377 FRAME_FOREGROUND_PIXEL (f
) = fg
;
1379 if (FRAME_W32_WINDOW (f
) != 0)
1381 if (x
->cursor_pixel
== old_fg
)
1382 x
->cursor_pixel
= fg
;
1384 update_face_from_frame_parameter (f
, Qforeground_color
, arg
);
1385 if (FRAME_VISIBLE_P (f
))
1391 x_set_background_color (f
, arg
, oldval
)
1393 Lisp_Object arg
, oldval
;
1395 FRAME_BACKGROUND_PIXEL (f
)
1396 = x_decode_color (f
, arg
, WHITE_PIX_DEFAULT (f
));
1398 if (FRAME_W32_WINDOW (f
) != 0)
1400 SetWindowLong (FRAME_W32_WINDOW (f
), WND_BACKGROUND_INDEX
,
1401 FRAME_BACKGROUND_PIXEL (f
));
1403 update_face_from_frame_parameter (f
, Qbackground_color
, arg
);
1405 if (FRAME_VISIBLE_P (f
))
1411 x_set_mouse_color (f
, arg
, oldval
)
1413 Lisp_Object arg
, oldval
;
1415 Cursor cursor
, nontext_cursor
, mode_cursor
, hand_cursor
;
1419 if (!EQ (Qnil
, arg
))
1420 f
->output_data
.w32
->mouse_pixel
1421 = x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1422 mask_color
= FRAME_BACKGROUND_PIXEL (f
);
1424 /* Don't let pointers be invisible. */
1425 if (mask_color
== f
->output_data
.w32
->mouse_pixel
1426 && mask_color
== FRAME_BACKGROUND_PIXEL (f
))
1427 f
->output_data
.w32
->mouse_pixel
= FRAME_FOREGROUND_PIXEL (f
);
1429 #if 0 /* TODO : cursor changes */
1432 /* It's not okay to crash if the user selects a screwy cursor. */
1433 count
= x_catch_errors (FRAME_W32_DISPLAY (f
));
1435 if (!EQ (Qnil
, Vx_pointer_shape
))
1437 CHECK_NUMBER (Vx_pointer_shape
);
1438 cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XINT (Vx_pointer_shape
));
1441 cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_xterm
);
1442 x_check_errors (FRAME_W32_DISPLAY (f
), "bad text pointer cursor: %s");
1444 if (!EQ (Qnil
, Vx_nontext_pointer_shape
))
1446 CHECK_NUMBER (Vx_nontext_pointer_shape
);
1447 nontext_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1448 XINT (Vx_nontext_pointer_shape
));
1451 nontext_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_left_ptr
);
1452 x_check_errors (FRAME_W32_DISPLAY (f
), "bad nontext pointer cursor: %s");
1454 if (!EQ (Qnil
, Vx_hourglass_pointer_shape
))
1456 CHECK_NUMBER (Vx_hourglass_pointer_shape
);
1457 hourglass_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1458 XINT (Vx_hourglass_pointer_shape
));
1461 hourglass_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_watch
);
1462 x_check_errors (FRAME_W32_DISPLAY (f
), "bad busy pointer cursor: %s");
1464 x_check_errors (FRAME_W32_DISPLAY (f
), "bad nontext pointer cursor: %s");
1465 if (!EQ (Qnil
, Vx_mode_pointer_shape
))
1467 CHECK_NUMBER (Vx_mode_pointer_shape
);
1468 mode_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1469 XINT (Vx_mode_pointer_shape
));
1472 mode_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_xterm
);
1473 x_check_errors (FRAME_W32_DISPLAY (f
), "bad modeline pointer cursor: %s");
1475 if (!EQ (Qnil
, Vx_sensitive_text_pointer_shape
))
1477 CHECK_NUMBER (Vx_sensitive_text_pointer_shape
);
1479 = XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1480 XINT (Vx_sensitive_text_pointer_shape
));
1483 hand_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_crosshair
);
1485 if (!NILP (Vx_window_horizontal_drag_shape
))
1487 CHECK_NUMBER (Vx_window_horizontal_drag_shape
);
1488 horizontal_drag_cursor
1489 = XCreateFontCursor (FRAME_X_DISPLAY (f
),
1490 XINT (Vx_window_horizontal_drag_shape
));
1493 horizontal_drag_cursor
1494 = XCreateFontCursor (FRAME_X_DISPLAY (f
), XC_sb_h_double_arrow
);
1496 /* Check and report errors with the above calls. */
1497 x_check_errors (FRAME_W32_DISPLAY (f
), "can't set cursor shape: %s");
1498 x_uncatch_errors (FRAME_W32_DISPLAY (f
), count
);
1501 XColor fore_color
, back_color
;
1503 fore_color
.pixel
= f
->output_data
.w32
->mouse_pixel
;
1504 back_color
.pixel
= mask_color
;
1505 XQueryColor (FRAME_W32_DISPLAY (f
),
1506 DefaultColormap (FRAME_W32_DISPLAY (f
),
1507 DefaultScreen (FRAME_W32_DISPLAY (f
))),
1509 XQueryColor (FRAME_W32_DISPLAY (f
),
1510 DefaultColormap (FRAME_W32_DISPLAY (f
),
1511 DefaultScreen (FRAME_W32_DISPLAY (f
))),
1513 XRecolorCursor (FRAME_W32_DISPLAY (f
), cursor
,
1514 &fore_color
, &back_color
);
1515 XRecolorCursor (FRAME_W32_DISPLAY (f
), nontext_cursor
,
1516 &fore_color
, &back_color
);
1517 XRecolorCursor (FRAME_W32_DISPLAY (f
), mode_cursor
,
1518 &fore_color
, &back_color
);
1519 XRecolorCursor (FRAME_W32_DISPLAY (f
), hand_cursor
,
1520 &fore_color
, &back_color
);
1521 XRecolorCursor (FRAME_W32_DISPLAY (f
), hourglass_cursor
,
1522 &fore_color
, &back_color
);
1525 if (FRAME_W32_WINDOW (f
) != 0)
1526 XDefineCursor (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
), cursor
);
1528 if (cursor
!= f
->output_data
.w32
->text_cursor
&& f
->output_data
.w32
->text_cursor
!= 0)
1529 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->text_cursor
);
1530 f
->output_data
.w32
->text_cursor
= cursor
;
1532 if (nontext_cursor
!= f
->output_data
.w32
->nontext_cursor
1533 && f
->output_data
.w32
->nontext_cursor
!= 0)
1534 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->nontext_cursor
);
1535 f
->output_data
.w32
->nontext_cursor
= nontext_cursor
;
1537 if (hourglass_cursor
!= f
->output_data
.w32
->hourglass_cursor
1538 && f
->output_data
.w32
->hourglass_cursor
!= 0)
1539 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->hourglass_cursor
);
1540 f
->output_data
.w32
->hourglass_cursor
= hourglass_cursor
;
1542 if (mode_cursor
!= f
->output_data
.w32
->modeline_cursor
1543 && f
->output_data
.w32
->modeline_cursor
!= 0)
1544 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->modeline_cursor
);
1545 f
->output_data
.w32
->modeline_cursor
= mode_cursor
;
1547 if (hand_cursor
!= f
->output_data
.w32
->hand_cursor
1548 && f
->output_data
.w32
->hand_cursor
!= 0)
1549 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->hand_cursor
);
1550 f
->output_data
.w32
->hand_cursor
= hand_cursor
;
1552 XFlush (FRAME_W32_DISPLAY (f
));
1555 update_face_from_frame_parameter (f
, Qmouse_color
, arg
);
1559 /* Defined in w32term.c. */
1561 x_set_cursor_color (f
, arg
, oldval
)
1563 Lisp_Object arg
, oldval
;
1565 unsigned long fore_pixel
, pixel
;
1567 if (!NILP (Vx_cursor_fore_pixel
))
1568 fore_pixel
= x_decode_color (f
, Vx_cursor_fore_pixel
,
1569 WHITE_PIX_DEFAULT (f
));
1571 fore_pixel
= FRAME_BACKGROUND_PIXEL (f
);
1573 pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1575 /* Make sure that the cursor color differs from the background color. */
1576 if (pixel
== FRAME_BACKGROUND_PIXEL (f
))
1578 pixel
= f
->output_data
.w32
->mouse_pixel
;
1579 if (pixel
== fore_pixel
)
1580 fore_pixel
= FRAME_BACKGROUND_PIXEL (f
);
1583 f
->output_data
.w32
->cursor_foreground_pixel
= fore_pixel
;
1584 f
->output_data
.w32
->cursor_pixel
= pixel
;
1586 if (FRAME_W32_WINDOW (f
) != 0)
1589 /* Update frame's cursor_gc. */
1590 f
->output_data
.w32
->cursor_gc
->foreground
= fore_pixel
;
1591 f
->output_data
.w32
->cursor_gc
->background
= pixel
;
1595 if (FRAME_VISIBLE_P (f
))
1597 x_update_cursor (f
, 0);
1598 x_update_cursor (f
, 1);
1602 update_face_from_frame_parameter (f
, Qcursor_color
, arg
);
1605 /* Set the border-color of frame F to pixel value PIX.
1606 Note that this does not fully take effect if done before
1610 x_set_border_pixel (f
, pix
)
1615 f
->output_data
.w32
->border_pixel
= pix
;
1617 if (FRAME_W32_WINDOW (f
) != 0 && f
->border_width
> 0)
1619 if (FRAME_VISIBLE_P (f
))
1624 /* Set the border-color of frame F to value described by ARG.
1625 ARG can be a string naming a color.
1626 The border-color is used for the border that is drawn by the server.
1627 Note that this does not fully take effect if done before
1628 F has a window; it must be redone when the window is created. */
1631 x_set_border_color (f
, arg
, oldval
)
1633 Lisp_Object arg
, oldval
;
1638 pix
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1639 x_set_border_pixel (f
, pix
);
1640 update_face_from_frame_parameter (f
, Qborder_color
, arg
);
1645 x_set_cursor_type (f
, arg
, oldval
)
1647 Lisp_Object arg
, oldval
;
1649 set_frame_cursor_types (f
, arg
);
1651 /* Make sure the cursor gets redrawn. */
1652 cursor_type_changed
= 1;
1656 x_set_icon_type (f
, arg
, oldval
)
1658 Lisp_Object arg
, oldval
;
1662 if (NILP (arg
) && NILP (oldval
))
1665 if (STRINGP (arg
) && STRINGP (oldval
)
1666 && EQ (Fstring_equal (oldval
, arg
), Qt
))
1669 if (SYMBOLP (arg
) && SYMBOLP (oldval
) && EQ (arg
, oldval
))
1674 result
= x_bitmap_icon (f
, arg
);
1678 error ("No icon window available");
1685 x_set_icon_name (f
, arg
, oldval
)
1687 Lisp_Object arg
, oldval
;
1691 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1694 else if (!NILP (arg
) || NILP (oldval
))
1700 if (f
->output_data
.w32
->icon_bitmap
!= 0)
1705 result
= x_text_icon (f
,
1706 (char *) SDATA ((!NILP (f
->icon_name
)
1715 error ("No icon window available");
1718 /* If the window was unmapped (and its icon was mapped),
1719 the new icon is not mapped, so map the window in its stead. */
1720 if (FRAME_VISIBLE_P (f
))
1722 #ifdef USE_X_TOOLKIT
1723 XtPopup (f
->output_data
.w32
->widget
, XtGrabNone
);
1725 XMapWindow (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
));
1728 XFlush (FRAME_W32_DISPLAY (f
));
1735 x_set_menu_bar_lines (f
, value
, oldval
)
1737 Lisp_Object value
, oldval
;
1740 int olines
= FRAME_MENU_BAR_LINES (f
);
1742 /* Right now, menu bars don't work properly in minibuf-only frames;
1743 most of the commands try to apply themselves to the minibuffer
1744 frame itself, and get an error because you can't switch buffers
1745 in or split the minibuffer window. */
1746 if (FRAME_MINIBUF_ONLY_P (f
))
1749 if (INTEGERP (value
))
1750 nlines
= XINT (value
);
1754 FRAME_MENU_BAR_LINES (f
) = 0;
1756 FRAME_EXTERNAL_MENU_BAR (f
) = 1;
1759 if (FRAME_EXTERNAL_MENU_BAR (f
) == 1)
1760 free_frame_menubar (f
);
1761 FRAME_EXTERNAL_MENU_BAR (f
) = 0;
1763 /* Adjust the frame size so that the client (text) dimensions
1764 remain the same. This depends on FRAME_EXTERNAL_MENU_BAR being
1766 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1767 do_pending_window_change (0);
1773 /* Set the number of lines used for the tool bar of frame F to VALUE.
1774 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1775 is the old number of tool bar lines. This function changes the
1776 height of all windows on frame F to match the new tool bar height.
1777 The frame's height doesn't change. */
1780 x_set_tool_bar_lines (f
, value
, oldval
)
1782 Lisp_Object value
, oldval
;
1784 int delta
, nlines
, root_height
;
1785 Lisp_Object root_window
;
1787 /* Treat tool bars like menu bars. */
1788 if (FRAME_MINIBUF_ONLY_P (f
))
1791 /* Use VALUE only if an integer >= 0. */
1792 if (INTEGERP (value
) && XINT (value
) >= 0)
1793 nlines
= XFASTINT (value
);
1797 /* Make sure we redisplay all windows in this frame. */
1798 ++windows_or_buffers_changed
;
1800 delta
= nlines
- FRAME_TOOL_BAR_LINES (f
);
1802 /* Don't resize the tool-bar to more than we have room for. */
1803 root_window
= FRAME_ROOT_WINDOW (f
);
1804 root_height
= WINDOW_TOTAL_LINES (XWINDOW (root_window
));
1805 if (root_height
- delta
< 1)
1807 delta
= root_height
- 1;
1808 nlines
= FRAME_TOOL_BAR_LINES (f
) + delta
;
1811 FRAME_TOOL_BAR_LINES (f
) = nlines
;
1812 change_window_heights (root_window
, delta
);
1815 /* We also have to make sure that the internal border at the top of
1816 the frame, below the menu bar or tool bar, is redrawn when the
1817 tool bar disappears. This is so because the internal border is
1818 below the tool bar if one is displayed, but is below the menu bar
1819 if there isn't a tool bar. The tool bar draws into the area
1820 below the menu bar. */
1821 if (FRAME_W32_WINDOW (f
) && FRAME_TOOL_BAR_LINES (f
) == 0)
1824 clear_current_matrices (f
);
1827 /* If the tool bar gets smaller, the internal border below it
1828 has to be cleared. It was formerly part of the display
1829 of the larger tool bar, and updating windows won't clear it. */
1832 int height
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1833 int width
= FRAME_PIXEL_WIDTH (f
);
1834 int y
= nlines
* FRAME_LINE_HEIGHT (f
);
1838 HDC hdc
= get_frame_dc (f
);
1839 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
1840 release_frame_dc (f
, hdc
);
1844 if (WINDOWP (f
->tool_bar_window
))
1845 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1850 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1853 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1854 name; if NAME is a string, set F's name to NAME and set
1855 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1857 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1858 suggesting a new name, which lisp code should override; if
1859 F->explicit_name is set, ignore the new name; otherwise, set it. */
1862 x_set_name (f
, name
, explicit)
1867 /* Make sure that requests from lisp code override requests from
1868 Emacs redisplay code. */
1871 /* If we're switching from explicit to implicit, we had better
1872 update the mode lines and thereby update the title. */
1873 if (f
->explicit_name
&& NILP (name
))
1874 update_mode_lines
= 1;
1876 f
->explicit_name
= ! NILP (name
);
1878 else if (f
->explicit_name
)
1881 /* If NAME is nil, set the name to the w32_id_name. */
1884 /* Check for no change needed in this very common case
1885 before we do any consing. */
1886 if (!strcmp (FRAME_W32_DISPLAY_INFO (f
)->w32_id_name
,
1889 name
= build_string (FRAME_W32_DISPLAY_INFO (f
)->w32_id_name
);
1892 CHECK_STRING (name
);
1894 /* Don't change the name if it's already NAME. */
1895 if (! NILP (Fstring_equal (name
, f
->name
)))
1900 /* For setting the frame title, the title parameter should override
1901 the name parameter. */
1902 if (! NILP (f
->title
))
1905 if (FRAME_W32_WINDOW (f
))
1907 if (STRING_MULTIBYTE (name
))
1908 name
= ENCODE_SYSTEM (name
);
1911 SetWindowText(FRAME_W32_WINDOW (f
), SDATA (name
));
1916 /* This function should be called when the user's lisp code has
1917 specified a name for the frame; the name will override any set by the
1920 x_explicitly_set_name (f
, arg
, oldval
)
1922 Lisp_Object arg
, oldval
;
1924 x_set_name (f
, arg
, 1);
1927 /* This function should be called by Emacs redisplay code to set the
1928 name; names set this way will never override names set by the user's
1931 x_implicitly_set_name (f
, arg
, oldval
)
1933 Lisp_Object arg
, oldval
;
1935 x_set_name (f
, arg
, 0);
1938 /* Change the title of frame F to NAME.
1939 If NAME is nil, use the frame name as the title. */
1942 x_set_title (f
, name
, old_name
)
1944 Lisp_Object name
, old_name
;
1946 /* Don't change the title if it's already NAME. */
1947 if (EQ (name
, f
->title
))
1950 update_mode_lines
= 1;
1957 if (FRAME_W32_WINDOW (f
))
1959 if (STRING_MULTIBYTE (name
))
1960 name
= ENCODE_SYSTEM (name
);
1963 SetWindowText(FRAME_W32_WINDOW (f
), SDATA (name
));
1969 void x_set_scroll_bar_default_width (f
)
1972 int wid
= FRAME_COLUMN_WIDTH (f
);
1974 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = GetSystemMetrics (SM_CXVSCROLL
);
1975 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) +
1980 /* Subroutines of creating a frame. */
1983 /* Return the value of parameter PARAM.
1985 First search ALIST, then Vdefault_frame_alist, then the X defaults
1986 database, using ATTRIBUTE as the attribute name and CLASS as its class.
1988 Convert the resource to the type specified by desired_type.
1990 If no default is specified, return Qunbound. If you call
1991 w32_get_arg, make sure you deal with Qunbound in a reasonable way,
1992 and don't let it get stored in any Lisp-visible variables! */
1995 w32_get_arg (alist
, param
, attribute
, class, type
)
1996 Lisp_Object alist
, param
;
1999 enum resource_types type
;
2001 return x_get_arg (check_x_display_info (Qnil
),
2002 alist
, param
, attribute
, class, type
);
2007 w32_load_cursor (LPCTSTR name
)
2009 /* Try first to load cursor from application resource. */
2010 Cursor cursor
= LoadImage ((HINSTANCE
) GetModuleHandle(NULL
),
2011 name
, IMAGE_CURSOR
, 0, 0,
2012 LR_DEFAULTCOLOR
| LR_DEFAULTSIZE
| LR_SHARED
);
2015 /* Then try to load a shared predefined cursor. */
2016 cursor
= LoadImage (NULL
, name
, IMAGE_CURSOR
, 0, 0,
2017 LR_DEFAULTCOLOR
| LR_DEFAULTSIZE
| LR_SHARED
);
2022 extern LRESULT CALLBACK
w32_wnd_proc ();
2025 w32_init_class (hinst
)
2030 wc
.style
= CS_HREDRAW
| CS_VREDRAW
;
2031 wc
.lpfnWndProc
= (WNDPROC
) w32_wnd_proc
;
2033 wc
.cbWndExtra
= WND_EXTRA_BYTES
;
2034 wc
.hInstance
= hinst
;
2035 wc
.hIcon
= LoadIcon (hinst
, EMACS_CLASS
);
2036 wc
.hCursor
= w32_load_cursor (IDC_ARROW
);
2037 wc
.hbrBackground
= NULL
; /* GetStockObject (WHITE_BRUSH); */
2038 wc
.lpszMenuName
= NULL
;
2039 wc
.lpszClassName
= EMACS_CLASS
;
2041 return (RegisterClass (&wc
));
2045 w32_createscrollbar (f
, bar
)
2047 struct scroll_bar
* bar
;
2049 return (CreateWindow ("SCROLLBAR", "", SBS_VERT
| WS_CHILD
| WS_VISIBLE
,
2050 /* Position and size of scroll bar. */
2051 XINT(bar
->left
) + VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
2053 XINT(bar
->width
) - VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
2055 FRAME_W32_WINDOW (f
),
2062 w32_createwindow (f
)
2067 Lisp_Object top
= Qunbound
;
2068 Lisp_Object left
= Qunbound
;
2070 rect
.left
= rect
.top
= 0;
2071 rect
.right
= FRAME_PIXEL_WIDTH (f
);
2072 rect
.bottom
= FRAME_PIXEL_HEIGHT (f
);
2074 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
2075 FRAME_EXTERNAL_MENU_BAR (f
));
2077 /* Do first time app init */
2081 w32_init_class (hinst
);
2084 if (f
->size_hint_flags
& USPosition
|| f
->size_hint_flags
& PPosition
)
2086 XSETINT (left
, f
->left_pos
);
2087 XSETINT (top
, f
->top_pos
);
2089 else if (EQ (left
, Qunbound
) && EQ (top
, Qunbound
))
2091 /* When called with RES_TYPE_NUMBER, w32_get_arg will return zero
2092 for anything that is not a number and is not Qunbound. */
2093 left
= w32_get_arg (Qnil
, Qleft
, "left", "Left", RES_TYPE_NUMBER
);
2094 top
= w32_get_arg (Qnil
, Qtop
, "top", "Top", RES_TYPE_NUMBER
);
2097 FRAME_W32_WINDOW (f
) = hwnd
2098 = CreateWindow (EMACS_CLASS
,
2100 f
->output_data
.w32
->dwStyle
| WS_CLIPCHILDREN
,
2101 EQ (left
, Qunbound
) ? CW_USEDEFAULT
: XINT (left
),
2102 EQ (top
, Qunbound
) ? CW_USEDEFAULT
: XINT (top
),
2103 rect
.right
- rect
.left
,
2104 rect
.bottom
- rect
.top
,
2112 SetWindowLong (hwnd
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
2113 SetWindowLong (hwnd
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
2114 SetWindowLong (hwnd
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
2115 SetWindowLong (hwnd
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
2116 SetWindowLong (hwnd
, WND_BACKGROUND_INDEX
, FRAME_BACKGROUND_PIXEL (f
));
2118 /* Enable drag-n-drop. */
2119 DragAcceptFiles (hwnd
, TRUE
);
2121 /* Do this to discard the default setting specified by our parent. */
2122 ShowWindow (hwnd
, SW_HIDE
);
2124 /* Update frame positions. */
2125 GetWindowRect (hwnd
, &rect
);
2126 f
->left_pos
= rect
.left
;
2127 f
->top_pos
= rect
.top
;
2132 my_post_msg (wmsg
, hwnd
, msg
, wParam
, lParam
)
2139 wmsg
->msg
.hwnd
= hwnd
;
2140 wmsg
->msg
.message
= msg
;
2141 wmsg
->msg
.wParam
= wParam
;
2142 wmsg
->msg
.lParam
= lParam
;
2143 wmsg
->msg
.time
= GetMessageTime ();
2148 /* GetKeyState and MapVirtualKey on Windows 95 do not actually distinguish
2149 between left and right keys as advertised. We test for this
2150 support dynamically, and set a flag when the support is absent. If
2151 absent, we keep track of the left and right control and alt keys
2152 ourselves. This is particularly necessary on keyboards that rely
2153 upon the AltGr key, which is represented as having the left control
2154 and right alt keys pressed. For these keyboards, we need to know
2155 when the left alt key has been pressed in addition to the AltGr key
2156 so that we can properly support M-AltGr-key sequences (such as M-@
2157 on Swedish keyboards). */
2159 #define EMACS_LCONTROL 0
2160 #define EMACS_RCONTROL 1
2161 #define EMACS_LMENU 2
2162 #define EMACS_RMENU 3
2164 static int modifiers
[4];
2165 static int modifiers_recorded
;
2166 static int modifier_key_support_tested
;
2169 test_modifier_support (unsigned int wparam
)
2173 if (wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
)
2175 if (wparam
== VK_CONTROL
)
2185 if (!(GetKeyState (l
) & 0x8000) && !(GetKeyState (r
) & 0x8000))
2186 modifiers_recorded
= 1;
2188 modifiers_recorded
= 0;
2189 modifier_key_support_tested
= 1;
2193 record_keydown (unsigned int wparam
, unsigned int lparam
)
2197 if (!modifier_key_support_tested
)
2198 test_modifier_support (wparam
);
2200 if ((wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
) || !modifiers_recorded
)
2203 if (wparam
== VK_CONTROL
)
2204 i
= (lparam
& 0x1000000) ? EMACS_RCONTROL
: EMACS_LCONTROL
;
2206 i
= (lparam
& 0x1000000) ? EMACS_RMENU
: EMACS_LMENU
;
2212 record_keyup (unsigned int wparam
, unsigned int lparam
)
2216 if ((wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
) || !modifiers_recorded
)
2219 if (wparam
== VK_CONTROL
)
2220 i
= (lparam
& 0x1000000) ? EMACS_RCONTROL
: EMACS_LCONTROL
;
2222 i
= (lparam
& 0x1000000) ? EMACS_RMENU
: EMACS_LMENU
;
2227 /* Emacs can lose focus while a modifier key has been pressed. When
2228 it regains focus, be conservative and clear all modifiers since
2229 we cannot reconstruct the left and right modifier state. */
2235 if (GetFocus () == NULL
)
2236 /* Emacs doesn't have keyboard focus. Do nothing. */
2239 ctrl
= GetAsyncKeyState (VK_CONTROL
);
2240 alt
= GetAsyncKeyState (VK_MENU
);
2242 if (!(ctrl
& 0x08000))
2243 /* Clear any recorded control modifier state. */
2244 modifiers
[EMACS_RCONTROL
] = modifiers
[EMACS_LCONTROL
] = 0;
2246 if (!(alt
& 0x08000))
2247 /* Clear any recorded alt modifier state. */
2248 modifiers
[EMACS_RMENU
] = modifiers
[EMACS_LMENU
] = 0;
2250 /* Update the state of all modifier keys, because modifiers used in
2251 hot-key combinations can get stuck on if Emacs loses focus as a
2252 result of a hot-key being pressed. */
2256 #define CURRENT_STATE(key) ((GetAsyncKeyState (key) & 0x8000) >> 8)
2258 GetKeyboardState (keystate
);
2259 keystate
[VK_SHIFT
] = CURRENT_STATE (VK_SHIFT
);
2260 keystate
[VK_CONTROL
] = CURRENT_STATE (VK_CONTROL
);
2261 keystate
[VK_LCONTROL
] = CURRENT_STATE (VK_LCONTROL
);
2262 keystate
[VK_RCONTROL
] = CURRENT_STATE (VK_RCONTROL
);
2263 keystate
[VK_MENU
] = CURRENT_STATE (VK_MENU
);
2264 keystate
[VK_LMENU
] = CURRENT_STATE (VK_LMENU
);
2265 keystate
[VK_RMENU
] = CURRENT_STATE (VK_RMENU
);
2266 keystate
[VK_LWIN
] = CURRENT_STATE (VK_LWIN
);
2267 keystate
[VK_RWIN
] = CURRENT_STATE (VK_RWIN
);
2268 keystate
[VK_APPS
] = CURRENT_STATE (VK_APPS
);
2269 SetKeyboardState (keystate
);
2273 /* Synchronize modifier state with what is reported with the current
2274 keystroke. Even if we cannot distinguish between left and right
2275 modifier keys, we know that, if no modifiers are set, then neither
2276 the left or right modifier should be set. */
2280 if (!modifiers_recorded
)
2283 if (!(GetKeyState (VK_CONTROL
) & 0x8000))
2284 modifiers
[EMACS_RCONTROL
] = modifiers
[EMACS_LCONTROL
] = 0;
2286 if (!(GetKeyState (VK_MENU
) & 0x8000))
2287 modifiers
[EMACS_RMENU
] = modifiers
[EMACS_LMENU
] = 0;
2291 modifier_set (int vkey
)
2293 if (vkey
== VK_CAPITAL
|| vkey
== VK_SCROLL
)
2294 return (GetKeyState (vkey
) & 0x1);
2295 if (!modifiers_recorded
)
2296 return (GetKeyState (vkey
) & 0x8000);
2301 return modifiers
[EMACS_LCONTROL
];
2303 return modifiers
[EMACS_RCONTROL
];
2305 return modifiers
[EMACS_LMENU
];
2307 return modifiers
[EMACS_RMENU
];
2309 return (GetKeyState (vkey
) & 0x8000);
2312 /* Convert between the modifier bits W32 uses and the modifier bits
2316 w32_key_to_modifier (int key
)
2318 Lisp_Object key_mapping
;
2323 key_mapping
= Vw32_lwindow_modifier
;
2326 key_mapping
= Vw32_rwindow_modifier
;
2329 key_mapping
= Vw32_apps_modifier
;
2332 key_mapping
= Vw32_scroll_lock_modifier
;
2338 /* NB. This code runs in the input thread, asychronously to the lisp
2339 thread, so we must be careful to ensure access to lisp data is
2340 thread-safe. The following code is safe because the modifier
2341 variable values are updated atomically from lisp and symbols are
2342 not relocated by GC. Also, we don't have to worry about seeing GC
2344 if (EQ (key_mapping
, Qhyper
))
2345 return hyper_modifier
;
2346 if (EQ (key_mapping
, Qsuper
))
2347 return super_modifier
;
2348 if (EQ (key_mapping
, Qmeta
))
2349 return meta_modifier
;
2350 if (EQ (key_mapping
, Qalt
))
2351 return alt_modifier
;
2352 if (EQ (key_mapping
, Qctrl
))
2353 return ctrl_modifier
;
2354 if (EQ (key_mapping
, Qcontrol
)) /* synonym for ctrl */
2355 return ctrl_modifier
;
2356 if (EQ (key_mapping
, Qshift
))
2357 return shift_modifier
;
2359 /* Don't generate any modifier if not explicitly requested. */
2364 w32_get_modifiers ()
2366 return ((modifier_set (VK_SHIFT
) ? shift_modifier
: 0) |
2367 (modifier_set (VK_CONTROL
) ? ctrl_modifier
: 0) |
2368 (modifier_set (VK_LWIN
) ? w32_key_to_modifier (VK_LWIN
) : 0) |
2369 (modifier_set (VK_RWIN
) ? w32_key_to_modifier (VK_RWIN
) : 0) |
2370 (modifier_set (VK_APPS
) ? w32_key_to_modifier (VK_APPS
) : 0) |
2371 (modifier_set (VK_SCROLL
) ? w32_key_to_modifier (VK_SCROLL
) : 0) |
2372 (modifier_set (VK_MENU
) ?
2373 ((NILP (Vw32_alt_is_meta
)) ? alt_modifier
: meta_modifier
) : 0));
2376 /* We map the VK_* modifiers into console modifier constants
2377 so that we can use the same routines to handle both console
2378 and window input. */
2381 construct_console_modifiers ()
2386 mods
|= (modifier_set (VK_SHIFT
)) ? SHIFT_PRESSED
: 0;
2387 mods
|= (modifier_set (VK_CAPITAL
)) ? CAPSLOCK_ON
: 0;
2388 mods
|= (modifier_set (VK_SCROLL
)) ? SCROLLLOCK_ON
: 0;
2389 mods
|= (modifier_set (VK_NUMLOCK
)) ? NUMLOCK_ON
: 0;
2390 mods
|= (modifier_set (VK_LCONTROL
)) ? LEFT_CTRL_PRESSED
: 0;
2391 mods
|= (modifier_set (VK_RCONTROL
)) ? RIGHT_CTRL_PRESSED
: 0;
2392 mods
|= (modifier_set (VK_LMENU
)) ? LEFT_ALT_PRESSED
: 0;
2393 mods
|= (modifier_set (VK_RMENU
)) ? RIGHT_ALT_PRESSED
: 0;
2394 mods
|= (modifier_set (VK_LWIN
)) ? LEFT_WIN_PRESSED
: 0;
2395 mods
|= (modifier_set (VK_RWIN
)) ? RIGHT_WIN_PRESSED
: 0;
2396 mods
|= (modifier_set (VK_APPS
)) ? APPS_PRESSED
: 0;
2402 w32_get_key_modifiers (unsigned int wparam
, unsigned int lparam
)
2406 /* Convert to emacs modifiers. */
2407 mods
= w32_kbd_mods_to_emacs (construct_console_modifiers (), wparam
);
2413 map_keypad_keys (unsigned int virt_key
, unsigned int extended
)
2415 if (virt_key
< VK_CLEAR
|| virt_key
> VK_DELETE
)
2418 if (virt_key
== VK_RETURN
)
2419 return (extended
? VK_NUMPAD_ENTER
: VK_RETURN
);
2421 if (virt_key
>= VK_PRIOR
&& virt_key
<= VK_DOWN
)
2422 return (!extended
? (VK_NUMPAD_PRIOR
+ (virt_key
- VK_PRIOR
)) : virt_key
);
2424 if (virt_key
== VK_INSERT
|| virt_key
== VK_DELETE
)
2425 return (!extended
? (VK_NUMPAD_INSERT
+ (virt_key
- VK_INSERT
)) : virt_key
);
2427 if (virt_key
== VK_CLEAR
)
2428 return (!extended
? VK_NUMPAD_CLEAR
: virt_key
);
2433 /* List of special key combinations which w32 would normally capture,
2434 but emacs should grab instead. Not directly visible to lisp, to
2435 simplify synchronization. Each item is an integer encoding a virtual
2436 key code and modifier combination to capture. */
2437 Lisp_Object w32_grabbed_keys
;
2439 #define HOTKEY(vk,mods) make_number (((vk) & 255) | ((mods) << 8))
2440 #define HOTKEY_ID(k) (XFASTINT (k) & 0xbfff)
2441 #define HOTKEY_VK_CODE(k) (XFASTINT (k) & 255)
2442 #define HOTKEY_MODIFIERS(k) (XFASTINT (k) >> 8)
2444 #define RAW_HOTKEY_ID(k) ((k) & 0xbfff)
2445 #define RAW_HOTKEY_VK_CODE(k) ((k) & 255)
2446 #define RAW_HOTKEY_MODIFIERS(k) ((k) >> 8)
2448 /* Register hot-keys for reserved key combinations when Emacs has
2449 keyboard focus, since this is the only way Emacs can receive key
2450 combinations like Alt-Tab which are used by the system. */
2453 register_hot_keys (hwnd
)
2456 Lisp_Object keylist
;
2458 /* Use GC_CONSP, since we are called asynchronously. */
2459 for (keylist
= w32_grabbed_keys
; GC_CONSP (keylist
); keylist
= XCDR (keylist
))
2461 Lisp_Object key
= XCAR (keylist
);
2463 /* Deleted entries get set to nil. */
2464 if (!INTEGERP (key
))
2467 RegisterHotKey (hwnd
, HOTKEY_ID (key
),
2468 HOTKEY_MODIFIERS (key
), HOTKEY_VK_CODE (key
));
2473 unregister_hot_keys (hwnd
)
2476 Lisp_Object keylist
;
2478 /* Use GC_CONSP, since we are called asynchronously. */
2479 for (keylist
= w32_grabbed_keys
; GC_CONSP (keylist
); keylist
= XCDR (keylist
))
2481 Lisp_Object key
= XCAR (keylist
);
2483 if (!INTEGERP (key
))
2486 UnregisterHotKey (hwnd
, HOTKEY_ID (key
));
2490 /* Main message dispatch loop. */
2493 w32_msg_pump (deferred_msg
* msg_buf
)
2499 msh_mousewheel
= RegisterWindowMessage (MSH_MOUSEWHEEL
);
2501 while (GetMessage (&msg
, NULL
, 0, 0))
2503 if (msg
.hwnd
== NULL
)
2505 switch (msg
.message
)
2508 /* Produced by complete_deferred_msg; just ignore. */
2510 case WM_EMACS_CREATEWINDOW
:
2511 /* Initialize COM for this window. Even though we don't use it,
2512 some third party shell extensions can cause it to be used in
2513 system dialogs, which causes a crash if it is not initialized.
2514 This is a known bug in Windows, which was fixed long ago, but
2515 the patch for XP is not publically available until XP SP3,
2516 and older versions will never be patched. */
2517 CoInitialize (NULL
);
2518 w32_createwindow ((struct frame
*) msg
.wParam
);
2519 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2522 case WM_EMACS_SETLOCALE
:
2523 SetThreadLocale (msg
.wParam
);
2524 /* Reply is not expected. */
2526 case WM_EMACS_SETKEYBOARDLAYOUT
:
2527 result
= (int) ActivateKeyboardLayout ((HKL
) msg
.wParam
, 0);
2528 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
,
2532 case WM_EMACS_REGISTER_HOT_KEY
:
2533 focus_window
= GetFocus ();
2534 if (focus_window
!= NULL
)
2535 RegisterHotKey (focus_window
,
2536 RAW_HOTKEY_ID (msg
.wParam
),
2537 RAW_HOTKEY_MODIFIERS (msg
.wParam
),
2538 RAW_HOTKEY_VK_CODE (msg
.wParam
));
2539 /* Reply is not expected. */
2541 case WM_EMACS_UNREGISTER_HOT_KEY
:
2542 focus_window
= GetFocus ();
2543 if (focus_window
!= NULL
)
2544 UnregisterHotKey (focus_window
, RAW_HOTKEY_ID (msg
.wParam
));
2545 /* Mark item as erased. NB: this code must be
2546 thread-safe. The next line is okay because the cons
2547 cell is never made into garbage and is not relocated by
2549 XSETCAR ((Lisp_Object
) ((EMACS_INT
) msg
.lParam
), Qnil
);
2550 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2553 case WM_EMACS_TOGGLE_LOCK_KEY
:
2555 int vk_code
= (int) msg
.wParam
;
2556 int cur_state
= (GetKeyState (vk_code
) & 1);
2557 Lisp_Object new_state
= (Lisp_Object
) ((EMACS_INT
) msg
.lParam
);
2559 /* NB: This code must be thread-safe. It is safe to
2560 call NILP because symbols are not relocated by GC,
2561 and pointer here is not touched by GC (so the markbit
2562 can't be set). Numbers are safe because they are
2563 immediate values. */
2564 if (NILP (new_state
)
2565 || (NUMBERP (new_state
)
2566 && ((XUINT (new_state
)) & 1) != cur_state
))
2568 one_w32_display_info
.faked_key
= vk_code
;
2570 keybd_event ((BYTE
) vk_code
,
2571 (BYTE
) MapVirtualKey (vk_code
, 0),
2572 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2573 keybd_event ((BYTE
) vk_code
,
2574 (BYTE
) MapVirtualKey (vk_code
, 0),
2575 KEYEVENTF_EXTENDEDKEY
| 0, 0);
2576 keybd_event ((BYTE
) vk_code
,
2577 (BYTE
) MapVirtualKey (vk_code
, 0),
2578 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2579 cur_state
= !cur_state
;
2581 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
,
2587 DebPrint (("msg %x not expected by w32_msg_pump\n", msg
.message
));
2592 DispatchMessage (&msg
);
2595 /* Exit nested loop when our deferred message has completed. */
2596 if (msg_buf
->completed
)
2601 deferred_msg
* deferred_msg_head
;
2603 static deferred_msg
*
2604 find_deferred_msg (HWND hwnd
, UINT msg
)
2606 deferred_msg
* item
;
2608 /* Don't actually need synchronization for read access, since
2609 modification of single pointer is always atomic. */
2610 /* enter_crit (); */
2612 for (item
= deferred_msg_head
; item
!= NULL
; item
= item
->next
)
2613 if (item
->w32msg
.msg
.hwnd
== hwnd
2614 && item
->w32msg
.msg
.message
== msg
)
2617 /* leave_crit (); */
2623 send_deferred_msg (deferred_msg
* msg_buf
,
2629 /* Only input thread can send deferred messages. */
2630 if (GetCurrentThreadId () != dwWindowsThreadId
)
2633 /* It is an error to send a message that is already deferred. */
2634 if (find_deferred_msg (hwnd
, msg
) != NULL
)
2637 /* Enforced synchronization is not needed because this is the only
2638 function that alters deferred_msg_head, and the following critical
2639 section is guaranteed to only be serially reentered (since only the
2640 input thread can call us). */
2642 /* enter_crit (); */
2644 msg_buf
->completed
= 0;
2645 msg_buf
->next
= deferred_msg_head
;
2646 deferred_msg_head
= msg_buf
;
2647 my_post_msg (&msg_buf
->w32msg
, hwnd
, msg
, wParam
, lParam
);
2649 /* leave_crit (); */
2651 /* Start a new nested message loop to process other messages until
2652 this one is completed. */
2653 w32_msg_pump (msg_buf
);
2655 deferred_msg_head
= msg_buf
->next
;
2657 return msg_buf
->result
;
2661 complete_deferred_msg (HWND hwnd
, UINT msg
, LRESULT result
)
2663 deferred_msg
* msg_buf
= find_deferred_msg (hwnd
, msg
);
2665 if (msg_buf
== NULL
)
2666 /* Message may have been cancelled, so don't abort(). */
2669 msg_buf
->result
= result
;
2670 msg_buf
->completed
= 1;
2672 /* Ensure input thread is woken so it notices the completion. */
2673 PostThreadMessage (dwWindowsThreadId
, WM_NULL
, 0, 0);
2677 cancel_all_deferred_msgs ()
2679 deferred_msg
* item
;
2681 /* Don't actually need synchronization for read access, since
2682 modification of single pointer is always atomic. */
2683 /* enter_crit (); */
2685 for (item
= deferred_msg_head
; item
!= NULL
; item
= item
->next
)
2688 item
->completed
= 1;
2691 /* leave_crit (); */
2693 /* Ensure input thread is woken so it notices the completion. */
2694 PostThreadMessage (dwWindowsThreadId
, WM_NULL
, 0, 0);
2698 w32_msg_worker (void *arg
)
2701 deferred_msg dummy_buf
;
2703 /* Ensure our message queue is created */
2705 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
2707 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2710 memset (&dummy_buf
, 0, sizeof (dummy_buf
));
2711 dummy_buf
.w32msg
.msg
.hwnd
= NULL
;
2712 dummy_buf
.w32msg
.msg
.message
= WM_NULL
;
2714 /* This is the inital message loop which should only exit when the
2715 application quits. */
2716 w32_msg_pump (&dummy_buf
);
2722 signal_user_input ()
2724 /* Interrupt any lisp that wants to be interrupted by input. */
2725 if (!NILP (Vthrow_on_input
))
2727 Vquit_flag
= Vthrow_on_input
;
2728 /* If we're inside a function that wants immediate quits,
2730 if (immediate_quit
&& NILP (Vinhibit_quit
))
2740 post_character_message (hwnd
, msg
, wParam
, lParam
, modifiers
)
2750 wmsg
.dwModifiers
= modifiers
;
2752 /* Detect quit_char and set quit-flag directly. Note that we
2753 still need to post a message to ensure the main thread will be
2754 woken up if blocked in sys_select(), but we do NOT want to post
2755 the quit_char message itself (because it will usually be as if
2756 the user had typed quit_char twice). Instead, we post a dummy
2757 message that has no particular effect. */
2760 if (isalpha (c
) && wmsg
.dwModifiers
== ctrl_modifier
)
2761 c
= make_ctrl_char (c
) & 0377;
2763 || (wmsg
.dwModifiers
== 0 &&
2764 w32_quit_key
&& wParam
== w32_quit_key
))
2768 /* The choice of message is somewhat arbitrary, as long as
2769 the main thread handler just ignores it. */
2772 /* Interrupt any blocking system calls. */
2775 /* As a safety precaution, forcibly complete any deferred
2776 messages. This is a kludge, but I don't see any particularly
2777 clean way to handle the situation where a deferred message is
2778 "dropped" in the lisp thread, and will thus never be
2779 completed, eg. by the user trying to activate the menubar
2780 when the lisp thread is busy, and then typing C-g when the
2781 menubar doesn't open promptly (with the result that the
2782 menubar never responds at all because the deferred
2783 WM_INITMENU message is never completed). Another problem
2784 situation is when the lisp thread calls SendMessage (to send
2785 a window manager command) when a message has been deferred;
2786 the lisp thread gets blocked indefinitely waiting for the
2787 deferred message to be completed, which itself is waiting for
2788 the lisp thread to respond.
2790 Note that we don't want to block the input thread waiting for
2791 a reponse from the lisp thread (although that would at least
2792 solve the deadlock problem above), because we want to be able
2793 to receive C-g to interrupt the lisp thread. */
2794 cancel_all_deferred_msgs ();
2797 signal_user_input ();
2800 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2803 /* Main window procedure */
2806 w32_wnd_proc (hwnd
, msg
, wParam
, lParam
)
2813 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
2815 int windows_translate
;
2818 /* Note that it is okay to call x_window_to_frame, even though we are
2819 not running in the main lisp thread, because frame deletion
2820 requires the lisp thread to synchronize with this thread. Thus, if
2821 a frame struct is returned, it can be used without concern that the
2822 lisp thread might make it disappear while we are using it.
2824 NB. Walking the frame list in this thread is safe (as long as
2825 writes of Lisp_Object slots are atomic, which they are on Windows).
2826 Although delete-frame can destructively modify the frame list while
2827 we are walking it, a garbage collection cannot occur until after
2828 delete-frame has synchronized with this thread.
2830 It is also safe to use functions that make GDI calls, such as
2831 w32_clear_rect, because these functions must obtain a DC handle
2832 from the frame struct using get_frame_dc which is thread-aware. */
2837 f
= x_window_to_frame (dpyinfo
, hwnd
);
2840 HDC hdc
= get_frame_dc (f
);
2841 GetUpdateRect (hwnd
, &wmsg
.rect
, FALSE
);
2842 w32_clear_rect (f
, hdc
, &wmsg
.rect
);
2843 release_frame_dc (f
, hdc
);
2845 #if defined (W32_DEBUG_DISPLAY)
2846 DebPrint (("WM_ERASEBKGND (frame %p): erasing %d,%d-%d,%d\n",
2848 wmsg
.rect
.left
, wmsg
.rect
.top
,
2849 wmsg
.rect
.right
, wmsg
.rect
.bottom
));
2850 #endif /* W32_DEBUG_DISPLAY */
2853 case WM_PALETTECHANGED
:
2854 /* ignore our own changes */
2855 if ((HWND
)wParam
!= hwnd
)
2857 f
= x_window_to_frame (dpyinfo
, hwnd
);
2859 /* get_frame_dc will realize our palette and force all
2860 frames to be redrawn if needed. */
2861 release_frame_dc (f
, get_frame_dc (f
));
2866 PAINTSTRUCT paintStruct
;
2868 bzero (&update_rect
, sizeof (update_rect
));
2870 f
= x_window_to_frame (dpyinfo
, hwnd
);
2873 DebPrint (("WM_PAINT received for unknown window %p\n", hwnd
));
2877 /* MSDN Docs say not to call BeginPaint if GetUpdateRect
2878 fails. Apparently this can happen under some
2880 if (GetUpdateRect (hwnd
, &update_rect
, FALSE
) || !w32_strict_painting
)
2883 BeginPaint (hwnd
, &paintStruct
);
2885 /* The rectangles returned by GetUpdateRect and BeginPaint
2886 do not always match. Play it safe by assuming both areas
2888 UnionRect (&(wmsg
.rect
), &update_rect
, &(paintStruct
.rcPaint
));
2890 #if defined (W32_DEBUG_DISPLAY)
2891 DebPrint (("WM_PAINT (frame %p): painting %d,%d-%d,%d\n",
2893 wmsg
.rect
.left
, wmsg
.rect
.top
,
2894 wmsg
.rect
.right
, wmsg
.rect
.bottom
));
2895 DebPrint ((" [update region is %d,%d-%d,%d]\n",
2896 update_rect
.left
, update_rect
.top
,
2897 update_rect
.right
, update_rect
.bottom
));
2899 EndPaint (hwnd
, &paintStruct
);
2902 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2907 /* If GetUpdateRect returns 0 (meaning there is no update
2908 region), assume the whole window needs to be repainted. */
2909 GetClientRect(hwnd
, &wmsg
.rect
);
2910 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2914 case WM_INPUTLANGCHANGE
:
2915 /* Inform lisp thread of keyboard layout changes. */
2916 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2918 /* Clear dead keys in the keyboard state; for simplicity only
2919 preserve modifier key states. */
2924 GetKeyboardState (keystate
);
2925 for (i
= 0; i
< 256; i
++)
2942 SetKeyboardState (keystate
);
2947 /* Synchronize hot keys with normal input. */
2948 PostMessage (hwnd
, WM_KEYDOWN
, HIWORD (lParam
), 0);
2953 record_keyup (wParam
, lParam
);
2958 /* Ignore keystrokes we fake ourself; see below. */
2959 if (dpyinfo
->faked_key
== wParam
)
2961 dpyinfo
->faked_key
= 0;
2962 /* Make sure TranslateMessage sees them though (as long as
2963 they don't produce WM_CHAR messages). This ensures that
2964 indicator lights are toggled promptly on Windows 9x, for
2966 if (lispy_function_keys
[wParam
] != 0)
2968 windows_translate
= 1;
2974 /* Synchronize modifiers with current keystroke. */
2976 record_keydown (wParam
, lParam
);
2977 wParam
= map_keypad_keys (wParam
, (lParam
& 0x1000000L
) != 0);
2979 windows_translate
= 0;
2984 if (NILP (Vw32_pass_lwindow_to_system
))
2986 /* Prevent system from acting on keyup (which opens the
2987 Start menu if no other key was pressed) by simulating a
2988 press of Space which we will ignore. */
2989 if (GetAsyncKeyState (wParam
) & 1)
2991 if (NUMBERP (Vw32_phantom_key_code
))
2992 key
= XUINT (Vw32_phantom_key_code
) & 255;
2995 dpyinfo
->faked_key
= key
;
2996 keybd_event (key
, (BYTE
) MapVirtualKey (key
, 0), 0, 0);
2999 if (!NILP (Vw32_lwindow_modifier
))
3003 if (NILP (Vw32_pass_rwindow_to_system
))
3005 if (GetAsyncKeyState (wParam
) & 1)
3007 if (NUMBERP (Vw32_phantom_key_code
))
3008 key
= XUINT (Vw32_phantom_key_code
) & 255;
3011 dpyinfo
->faked_key
= key
;
3012 keybd_event (key
, (BYTE
) MapVirtualKey (key
, 0), 0, 0);
3015 if (!NILP (Vw32_rwindow_modifier
))
3019 if (!NILP (Vw32_apps_modifier
))
3023 if (NILP (Vw32_pass_alt_to_system
))
3024 /* Prevent DefWindowProc from activating the menu bar if an
3025 Alt key is pressed and released by itself. */
3027 windows_translate
= 1;
3030 /* Decide whether to treat as modifier or function key. */
3031 if (NILP (Vw32_enable_caps_lock
))
3032 goto disable_lock_key
;
3033 windows_translate
= 1;
3036 /* Decide whether to treat as modifier or function key. */
3037 if (NILP (Vw32_enable_num_lock
))
3038 goto disable_lock_key
;
3039 windows_translate
= 1;
3042 /* Decide whether to treat as modifier or function key. */
3043 if (NILP (Vw32_scroll_lock_modifier
))
3044 goto disable_lock_key
;
3045 windows_translate
= 1;
3048 /* Ensure the appropriate lock key state (and indicator light)
3049 remains in the same state. We do this by faking another
3050 press of the relevant key. Apparently, this really is the
3051 only way to toggle the state of the indicator lights. */
3052 dpyinfo
->faked_key
= wParam
;
3053 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
3054 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
3055 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
3056 KEYEVENTF_EXTENDEDKEY
| 0, 0);
3057 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
3058 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
3059 /* Ensure indicator lights are updated promptly on Windows 9x
3060 (TranslateMessage apparently does this), after forwarding
3062 post_character_message (hwnd
, msg
, wParam
, lParam
,
3063 w32_get_key_modifiers (wParam
, lParam
));
3064 windows_translate
= 1;
3068 case VK_PROCESSKEY
: /* Generated by IME. */
3069 windows_translate
= 1;
3072 /* Windows maps Ctrl-Pause (aka Ctrl-Break) into VK_CANCEL,
3073 which is confusing for purposes of key binding; convert
3074 VK_CANCEL events into VK_PAUSE events. */
3078 /* Windows maps Ctrl-NumLock into VK_PAUSE, which is confusing
3079 for purposes of key binding; convert these back into
3080 VK_NUMLOCK events, at least when we want to see NumLock key
3081 presses. (Note that there is never any possibility that
3082 VK_PAUSE with Ctrl really is C-Pause as per above.) */
3083 if (NILP (Vw32_enable_num_lock
) && modifier_set (VK_CONTROL
))
3084 wParam
= VK_NUMLOCK
;
3087 /* If not defined as a function key, change it to a WM_CHAR message. */
3088 if (lispy_function_keys
[wParam
] == 0)
3090 DWORD modifiers
= construct_console_modifiers ();
3092 if (!NILP (Vw32_recognize_altgr
)
3093 && modifier_set (VK_LCONTROL
) && modifier_set (VK_RMENU
))
3095 /* Always let TranslateMessage handle AltGr key chords;
3096 for some reason, ToAscii doesn't always process AltGr
3097 chords correctly. */
3098 windows_translate
= 1;
3100 else if ((modifiers
& (~SHIFT_PRESSED
& ~CAPSLOCK_ON
)) != 0)
3102 /* Handle key chords including any modifiers other
3103 than shift directly, in order to preserve as much
3104 modifier information as possible. */
3105 if ('A' <= wParam
&& wParam
<= 'Z')
3107 /* Don't translate modified alphabetic keystrokes,
3108 so the user doesn't need to constantly switch
3109 layout to type control or meta keystrokes when
3110 the normal layout translates alphabetic
3111 characters to non-ascii characters. */
3112 if (!modifier_set (VK_SHIFT
))
3113 wParam
+= ('a' - 'A');
3118 /* Try to handle other keystrokes by determining the
3119 base character (ie. translating the base key plus
3123 KEY_EVENT_RECORD key
;
3125 key
.bKeyDown
= TRUE
;
3126 key
.wRepeatCount
= 1;
3127 key
.wVirtualKeyCode
= wParam
;
3128 key
.wVirtualScanCode
= (lParam
& 0xFF0000) >> 16;
3129 key
.uChar
.AsciiChar
= 0;
3130 key
.dwControlKeyState
= modifiers
;
3132 add
= w32_kbd_patch_key (&key
);
3133 /* 0 means an unrecognised keycode, negative means
3134 dead key. Ignore both. */
3137 /* Forward asciified character sequence. */
3138 post_character_message
3139 (hwnd
, WM_CHAR
, key
.uChar
.AsciiChar
, lParam
,
3140 w32_get_key_modifiers (wParam
, lParam
));
3141 w32_kbd_patch_key (&key
);
3148 /* Let TranslateMessage handle everything else. */
3149 windows_translate
= 1;
3155 if (windows_translate
)
3157 MSG windows_msg
= { hwnd
, msg
, wParam
, lParam
, 0, {0,0} };
3159 windows_msg
.time
= GetMessageTime ();
3160 TranslateMessage (&windows_msg
);
3168 post_character_message (hwnd
, msg
, wParam
, lParam
,
3169 w32_get_key_modifiers (wParam
, lParam
));
3172 /* Simulate middle mouse button events when left and right buttons
3173 are used together, but only if user has two button mouse. */
3174 case WM_LBUTTONDOWN
:
3175 case WM_RBUTTONDOWN
:
3176 if (w32_num_mouse_buttons
> 2)
3177 goto handle_plain_button
;
3180 int this = (msg
== WM_LBUTTONDOWN
) ? LMOUSE
: RMOUSE
;
3181 int other
= (msg
== WM_LBUTTONDOWN
) ? RMOUSE
: LMOUSE
;
3183 if (button_state
& this)
3186 if (button_state
== 0)
3189 button_state
|= this;
3191 if (button_state
& other
)
3193 if (mouse_button_timer
)
3195 KillTimer (hwnd
, mouse_button_timer
);
3196 mouse_button_timer
= 0;
3198 /* Generate middle mouse event instead. */
3199 msg
= WM_MBUTTONDOWN
;
3200 button_state
|= MMOUSE
;
3202 else if (button_state
& MMOUSE
)
3204 /* Ignore button event if we've already generated a
3205 middle mouse down event. This happens if the
3206 user releases and press one of the two buttons
3207 after we've faked a middle mouse event. */
3212 /* Flush out saved message. */
3213 post_msg (&saved_mouse_button_msg
);
3215 wmsg
.dwModifiers
= w32_get_modifiers ();
3216 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3217 signal_user_input ();
3219 /* Clear message buffer. */
3220 saved_mouse_button_msg
.msg
.hwnd
= 0;
3224 /* Hold onto message for now. */
3225 mouse_button_timer
=
3226 SetTimer (hwnd
, MOUSE_BUTTON_ID
,
3227 w32_mouse_button_tolerance
, NULL
);
3228 saved_mouse_button_msg
.msg
.hwnd
= hwnd
;
3229 saved_mouse_button_msg
.msg
.message
= msg
;
3230 saved_mouse_button_msg
.msg
.wParam
= wParam
;
3231 saved_mouse_button_msg
.msg
.lParam
= lParam
;
3232 saved_mouse_button_msg
.msg
.time
= GetMessageTime ();
3233 saved_mouse_button_msg
.dwModifiers
= w32_get_modifiers ();
3240 if (w32_num_mouse_buttons
> 2)
3241 goto handle_plain_button
;
3244 int this = (msg
== WM_LBUTTONUP
) ? LMOUSE
: RMOUSE
;
3245 int other
= (msg
== WM_LBUTTONUP
) ? RMOUSE
: LMOUSE
;
3247 if ((button_state
& this) == 0)
3250 button_state
&= ~this;
3252 if (button_state
& MMOUSE
)
3254 /* Only generate event when second button is released. */
3255 if ((button_state
& other
) == 0)
3258 button_state
&= ~MMOUSE
;
3260 if (button_state
) abort ();
3267 /* Flush out saved message if necessary. */
3268 if (saved_mouse_button_msg
.msg
.hwnd
)
3270 post_msg (&saved_mouse_button_msg
);
3273 wmsg
.dwModifiers
= w32_get_modifiers ();
3274 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3275 signal_user_input ();
3277 /* Always clear message buffer and cancel timer. */
3278 saved_mouse_button_msg
.msg
.hwnd
= 0;
3279 KillTimer (hwnd
, mouse_button_timer
);
3280 mouse_button_timer
= 0;
3282 if (button_state
== 0)
3287 case WM_XBUTTONDOWN
:
3289 if (w32_pass_extra_mouse_buttons_to_system
)
3291 /* else fall through and process them. */
3292 case WM_MBUTTONDOWN
:
3294 handle_plain_button
:
3299 /* Ignore middle and extra buttons as long as the menu is active. */
3300 f
= x_window_to_frame (dpyinfo
, hwnd
);
3301 if (f
&& f
->output_data
.w32
->menubar_active
)
3304 if (parse_button (msg
, HIWORD (wParam
), &button
, &up
))
3306 if (up
) ReleaseCapture ();
3307 else SetCapture (hwnd
);
3308 button
= (button
== 0) ? LMOUSE
:
3309 ((button
== 1) ? MMOUSE
: RMOUSE
);
3311 button_state
&= ~button
;
3313 button_state
|= button
;
3317 wmsg
.dwModifiers
= w32_get_modifiers ();
3318 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3319 signal_user_input ();
3321 /* Need to return true for XBUTTON messages, false for others,
3322 to indicate that we processed the message. */
3323 return (msg
== WM_XBUTTONDOWN
|| msg
== WM_XBUTTONUP
);
3326 /* Ignore mouse movements as long as the menu is active. These
3327 movements are processed by the window manager anyway, and
3328 it's wrong to handle them as if they happened on the
3329 underlying frame. */
3330 f
= x_window_to_frame (dpyinfo
, hwnd
);
3331 if (f
&& f
->output_data
.w32
->menubar_active
)
3334 /* If the mouse has just moved into the frame, start tracking
3335 it, so we will be notified when it leaves the frame. Mouse
3336 tracking only works under W98 and NT4 and later. On earlier
3337 versions, there is no way of telling when the mouse leaves the
3338 frame, so we just have to put up with help-echo and mouse
3339 highlighting remaining while the frame is not active. */
3340 if (track_mouse_event_fn
&& !track_mouse_window
)
3342 TRACKMOUSEEVENT tme
;
3343 tme
.cbSize
= sizeof (tme
);
3344 tme
.dwFlags
= TME_LEAVE
;
3345 tme
.hwndTrack
= hwnd
;
3347 track_mouse_event_fn (&tme
);
3348 track_mouse_window
= hwnd
;
3351 if (w32_mouse_move_interval
<= 0
3352 || (msg
== WM_MOUSEMOVE
&& button_state
== 0))
3354 wmsg
.dwModifiers
= w32_get_modifiers ();
3355 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3359 /* Hang onto mouse move and scroll messages for a bit, to avoid
3360 sending such events to Emacs faster than it can process them.
3361 If we get more events before the timer from the first message
3362 expires, we just replace the first message. */
3364 if (saved_mouse_move_msg
.msg
.hwnd
== 0)
3366 SetTimer (hwnd
, MOUSE_MOVE_ID
,
3367 w32_mouse_move_interval
, NULL
);
3369 /* Hold onto message for now. */
3370 saved_mouse_move_msg
.msg
.hwnd
= hwnd
;
3371 saved_mouse_move_msg
.msg
.message
= msg
;
3372 saved_mouse_move_msg
.msg
.wParam
= wParam
;
3373 saved_mouse_move_msg
.msg
.lParam
= lParam
;
3374 saved_mouse_move_msg
.msg
.time
= GetMessageTime ();
3375 saved_mouse_move_msg
.dwModifiers
= w32_get_modifiers ();
3381 wmsg
.dwModifiers
= w32_get_modifiers ();
3382 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3383 signal_user_input ();
3386 case WM_MOUSEHWHEEL
:
3387 wmsg
.dwModifiers
= w32_get_modifiers ();
3388 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3389 signal_user_input ();
3390 /* Non-zero must be returned when WM_MOUSEHWHEEL messages are
3391 handled, to prevent the system trying to handle it by faking
3392 scroll bar events. */
3396 /* Flush out saved messages if necessary. */
3397 if (wParam
== mouse_button_timer
)
3399 if (saved_mouse_button_msg
.msg
.hwnd
)
3401 post_msg (&saved_mouse_button_msg
);
3402 signal_user_input ();
3403 saved_mouse_button_msg
.msg
.hwnd
= 0;
3405 KillTimer (hwnd
, mouse_button_timer
);
3406 mouse_button_timer
= 0;
3408 else if (wParam
== mouse_move_timer
)
3410 if (saved_mouse_move_msg
.msg
.hwnd
)
3412 post_msg (&saved_mouse_move_msg
);
3413 saved_mouse_move_msg
.msg
.hwnd
= 0;
3415 KillTimer (hwnd
, mouse_move_timer
);
3416 mouse_move_timer
= 0;
3418 else if (wParam
== menu_free_timer
)
3420 KillTimer (hwnd
, menu_free_timer
);
3421 menu_free_timer
= 0;
3422 f
= x_window_to_frame (dpyinfo
, hwnd
);
3423 /* If a popup menu is active, don't wipe its strings. */
3425 && current_popup_menu
== NULL
)
3427 /* Free memory used by owner-drawn and help-echo strings. */
3428 w32_free_menu_strings (hwnd
);
3429 f
->output_data
.w32
->menubar_active
= 0;
3436 /* Windows doesn't send us focus messages when putting up and
3437 taking down a system popup dialog as for Ctrl-Alt-Del on Windows 95.
3438 The only indication we get that something happened is receiving
3439 this message afterwards. So this is a good time to reset our
3440 keyboard modifiers' state. */
3447 /* We must ensure menu bar is fully constructed and up to date
3448 before allowing user interaction with it. To achieve this
3449 we send this message to the lisp thread and wait for a
3450 reply (whose value is not actually needed) to indicate that
3451 the menu bar is now ready for use, so we can now return.
3453 To remain responsive in the meantime, we enter a nested message
3454 loop that can process all other messages.
3456 However, we skip all this if the message results from calling
3457 TrackPopupMenu - in fact, we must NOT attempt to send the lisp
3458 thread a message because it is blocked on us at this point. We
3459 set menubar_active before calling TrackPopupMenu to indicate
3460 this (there is no possibility of confusion with real menubar
3463 f
= x_window_to_frame (dpyinfo
, hwnd
);
3465 && (f
->output_data
.w32
->menubar_active
3466 /* We can receive this message even in the absence of a
3467 menubar (ie. when the system menu is activated) - in this
3468 case we do NOT want to forward the message, otherwise it
3469 will cause the menubar to suddenly appear when the user
3470 had requested it to be turned off! */
3471 || f
->output_data
.w32
->menubar_widget
== NULL
))
3475 deferred_msg msg_buf
;
3477 /* Detect if message has already been deferred; in this case
3478 we cannot return any sensible value to ignore this. */
3479 if (find_deferred_msg (hwnd
, msg
) != NULL
)
3484 return send_deferred_msg (&msg_buf
, hwnd
, msg
, wParam
, lParam
);
3487 case WM_EXITMENULOOP
:
3488 f
= x_window_to_frame (dpyinfo
, hwnd
);
3490 /* If a menu is still active, check again after a short delay,
3491 since Windows often (always?) sends the WM_EXITMENULOOP
3492 before the corresponding WM_COMMAND message.
3493 Don't do this if a popup menu is active, since it is only
3494 menubar menus that require cleaning up in this way.
3496 if (f
&& menubar_in_use
&& current_popup_menu
== NULL
)
3497 menu_free_timer
= SetTimer (hwnd
, MENU_FREE_ID
, MENU_FREE_DELAY
, NULL
);
3501 /* Direct handling of help_echo in menus. Should be safe now
3502 that we generate the help_echo by placing a help event in the
3505 HMENU menu
= (HMENU
) lParam
;
3506 UINT menu_item
= (UINT
) LOWORD (wParam
);
3507 UINT flags
= (UINT
) HIWORD (wParam
);
3509 w32_menu_display_help (hwnd
, menu
, menu_item
, flags
);
3513 case WM_MEASUREITEM
:
3514 f
= x_window_to_frame (dpyinfo
, hwnd
);
3517 MEASUREITEMSTRUCT
* pMis
= (MEASUREITEMSTRUCT
*) lParam
;
3519 if (pMis
->CtlType
== ODT_MENU
)
3521 /* Work out dimensions for popup menu titles. */
3522 char * title
= (char *) pMis
->itemData
;
3523 HDC hdc
= GetDC (hwnd
);
3524 HFONT menu_font
= GetCurrentObject (hdc
, OBJ_FONT
);
3525 LOGFONT menu_logfont
;
3529 GetObject (menu_font
, sizeof (menu_logfont
), &menu_logfont
);
3530 menu_logfont
.lfWeight
= FW_BOLD
;
3531 menu_font
= CreateFontIndirect (&menu_logfont
);
3532 old_font
= SelectObject (hdc
, menu_font
);
3534 pMis
->itemHeight
= GetSystemMetrics (SM_CYMENUSIZE
);
3537 if (unicode_append_menu
)
3538 GetTextExtentPoint32W (hdc
, (WCHAR
*) title
,
3539 wcslen ((WCHAR
*) title
),
3542 GetTextExtentPoint32 (hdc
, title
, strlen (title
), &size
);
3544 pMis
->itemWidth
= size
.cx
;
3545 if (pMis
->itemHeight
< size
.cy
)
3546 pMis
->itemHeight
= size
.cy
;
3549 pMis
->itemWidth
= 0;
3551 SelectObject (hdc
, old_font
);
3552 DeleteObject (menu_font
);
3553 ReleaseDC (hwnd
, hdc
);
3560 f
= x_window_to_frame (dpyinfo
, hwnd
);
3563 DRAWITEMSTRUCT
* pDis
= (DRAWITEMSTRUCT
*) lParam
;
3565 if (pDis
->CtlType
== ODT_MENU
)
3567 /* Draw popup menu title. */
3568 char * title
= (char *) pDis
->itemData
;
3571 HDC hdc
= pDis
->hDC
;
3572 HFONT menu_font
= GetCurrentObject (hdc
, OBJ_FONT
);
3573 LOGFONT menu_logfont
;
3576 GetObject (menu_font
, sizeof (menu_logfont
), &menu_logfont
);
3577 menu_logfont
.lfWeight
= FW_BOLD
;
3578 menu_font
= CreateFontIndirect (&menu_logfont
);
3579 old_font
= SelectObject (hdc
, menu_font
);
3581 /* Always draw title as if not selected. */
3582 if (unicode_append_menu
)
3585 + GetSystemMetrics (SM_CXMENUCHECK
),
3587 ETO_OPAQUE
, &pDis
->rcItem
,
3589 wcslen ((WCHAR
*) title
), NULL
);
3593 + GetSystemMetrics (SM_CXMENUCHECK
),
3595 ETO_OPAQUE
, &pDis
->rcItem
,
3596 title
, strlen (title
), NULL
);
3598 SelectObject (hdc
, old_font
);
3599 DeleteObject (menu_font
);
3607 /* Still not right - can't distinguish between clicks in the
3608 client area of the frame from clicks forwarded from the scroll
3609 bars - may have to hook WM_NCHITTEST to remember the mouse
3610 position and then check if it is in the client area ourselves. */
3611 case WM_MOUSEACTIVATE
:
3612 /* Discard the mouse click that activates a frame, allowing the
3613 user to click anywhere without changing point (or worse!).
3614 Don't eat mouse clicks on scrollbars though!! */
3615 if (LOWORD (lParam
) == HTCLIENT
)
3616 return MA_ACTIVATEANDEAT
;
3621 /* No longer tracking mouse. */
3622 track_mouse_window
= NULL
;
3624 case WM_ACTIVATEAPP
:
3626 case WM_WINDOWPOSCHANGED
:
3628 /* Inform lisp thread that a frame might have just been obscured
3629 or exposed, so should recheck visibility of all frames. */
3630 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3634 dpyinfo
->faked_key
= 0;
3636 register_hot_keys (hwnd
);
3639 unregister_hot_keys (hwnd
);
3642 /* Relinquish the system caret. */
3643 if (w32_system_caret_hwnd
)
3645 w32_visible_system_caret_hwnd
= NULL
;
3646 w32_system_caret_hwnd
= NULL
;
3652 f
= x_window_to_frame (dpyinfo
, hwnd
);
3653 if (f
&& HIWORD (wParam
) == 0)
3655 if (menu_free_timer
)
3657 KillTimer (hwnd
, menu_free_timer
);
3658 menu_free_timer
= 0;
3664 wmsg
.dwModifiers
= w32_get_modifiers ();
3665 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3673 wmsg
.dwModifiers
= w32_get_modifiers ();
3674 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3677 case WM_WINDOWPOSCHANGING
:
3678 /* Don't restrict the sizing of tip frames. */
3679 if (hwnd
== tip_window
)
3683 LPWINDOWPOS lppos
= (WINDOWPOS
*) lParam
;
3685 wp
.length
= sizeof (WINDOWPLACEMENT
);
3686 GetWindowPlacement (hwnd
, &wp
);
3688 if (wp
.showCmd
!= SW_SHOWMINIMIZED
&& (lppos
->flags
& SWP_NOSIZE
) == 0)
3695 DWORD internal_border
;
3696 DWORD scrollbar_extra
;
3699 wp
.length
= sizeof(wp
);
3700 GetWindowRect (hwnd
, &wr
);
3704 font_width
= GetWindowLong (hwnd
, WND_FONTWIDTH_INDEX
);
3705 line_height
= GetWindowLong (hwnd
, WND_LINEHEIGHT_INDEX
);
3706 internal_border
= GetWindowLong (hwnd
, WND_BORDER_INDEX
);
3707 scrollbar_extra
= GetWindowLong (hwnd
, WND_SCROLLBAR_INDEX
);
3711 memset (&rect
, 0, sizeof (rect
));
3712 AdjustWindowRect (&rect
, GetWindowLong (hwnd
, GWL_STYLE
),
3713 GetMenu (hwnd
) != NULL
);
3715 /* Force width and height of client area to be exact
3716 multiples of the character cell dimensions. */
3717 wdiff
= (lppos
->cx
- (rect
.right
- rect
.left
)
3718 - 2 * internal_border
- scrollbar_extra
)
3720 hdiff
= (lppos
->cy
- (rect
.bottom
- rect
.top
)
3721 - 2 * internal_border
)
3726 /* For right/bottom sizing we can just fix the sizes.
3727 However for top/left sizing we will need to fix the X
3728 and Y positions as well. */
3730 int cx_mintrack
= GetSystemMetrics (SM_CXMINTRACK
);
3731 int cy_mintrack
= GetSystemMetrics (SM_CYMINTRACK
);
3733 lppos
->cx
= max (lppos
->cx
- wdiff
, cx_mintrack
);
3734 lppos
->cy
= max (lppos
->cy
- hdiff
, cy_mintrack
);
3736 if (wp
.showCmd
!= SW_SHOWMAXIMIZED
3737 && (lppos
->flags
& SWP_NOMOVE
) == 0)
3739 if (lppos
->x
!= wr
.left
|| lppos
->y
!= wr
.top
)
3746 lppos
->flags
|= SWP_NOMOVE
;
3757 case WM_GETMINMAXINFO
:
3758 /* Hack to allow resizing the Emacs frame above the screen size.
3759 Note that Windows 9x limits coordinates to 16-bits. */
3760 ((LPMINMAXINFO
) lParam
)->ptMaxTrackSize
.x
= 32767;
3761 ((LPMINMAXINFO
) lParam
)->ptMaxTrackSize
.y
= 32767;
3765 if (LOWORD (lParam
) == HTCLIENT
)
3770 case WM_EMACS_SETCURSOR
:
3772 Cursor cursor
= (Cursor
) wParam
;
3778 case WM_EMACS_CREATESCROLLBAR
:
3779 return (LRESULT
) w32_createscrollbar ((struct frame
*) wParam
,
3780 (struct scroll_bar
*) lParam
);
3782 case WM_EMACS_SHOWWINDOW
:
3783 return ShowWindow ((HWND
) wParam
, (WPARAM
) lParam
);
3785 case WM_EMACS_SETFOREGROUND
:
3787 HWND foreground_window
;
3788 DWORD foreground_thread
, retval
;
3790 /* On NT 5.0, and apparently Windows 98, it is necessary to
3791 attach to the thread that currently has focus in order to
3792 pull the focus away from it. */
3793 foreground_window
= GetForegroundWindow ();
3794 foreground_thread
= GetWindowThreadProcessId (foreground_window
, NULL
);
3795 if (!foreground_window
3796 || foreground_thread
== GetCurrentThreadId ()
3797 || !AttachThreadInput (GetCurrentThreadId (),
3798 foreground_thread
, TRUE
))
3799 foreground_thread
= 0;
3801 retval
= SetForegroundWindow ((HWND
) wParam
);
3803 /* Detach from the previous foreground thread. */
3804 if (foreground_thread
)
3805 AttachThreadInput (GetCurrentThreadId (),
3806 foreground_thread
, FALSE
);
3811 case WM_EMACS_SETWINDOWPOS
:
3813 WINDOWPOS
* pos
= (WINDOWPOS
*) wParam
;
3814 return SetWindowPos (hwnd
, pos
->hwndInsertAfter
,
3815 pos
->x
, pos
->y
, pos
->cx
, pos
->cy
, pos
->flags
);
3818 case WM_EMACS_DESTROYWINDOW
:
3819 DragAcceptFiles ((HWND
) wParam
, FALSE
);
3820 return DestroyWindow ((HWND
) wParam
);
3822 case WM_EMACS_HIDE_CARET
:
3823 return HideCaret (hwnd
);
3825 case WM_EMACS_SHOW_CARET
:
3826 return ShowCaret (hwnd
);
3828 case WM_EMACS_DESTROY_CARET
:
3829 w32_system_caret_hwnd
= NULL
;
3830 w32_visible_system_caret_hwnd
= NULL
;
3831 return DestroyCaret ();
3833 case WM_EMACS_TRACK_CARET
:
3834 /* If there is currently no system caret, create one. */
3835 if (w32_system_caret_hwnd
== NULL
)
3837 /* Use the default caret width, and avoid changing it
3838 unneccesarily, as it confuses screen reader software. */
3839 w32_system_caret_hwnd
= hwnd
;
3840 CreateCaret (hwnd
, NULL
, 0,
3841 w32_system_caret_height
);
3844 if (!SetCaretPos (w32_system_caret_x
, w32_system_caret_y
))
3846 /* Ensure visible caret gets turned on when requested. */
3847 else if (w32_use_visible_system_caret
3848 && w32_visible_system_caret_hwnd
!= hwnd
)
3850 w32_visible_system_caret_hwnd
= hwnd
;
3851 return ShowCaret (hwnd
);
3853 /* Ensure visible caret gets turned off when requested. */
3854 else if (!w32_use_visible_system_caret
3855 && w32_visible_system_caret_hwnd
)
3857 w32_visible_system_caret_hwnd
= NULL
;
3858 return HideCaret (hwnd
);
3863 case WM_EMACS_TRACKPOPUPMENU
:
3868 pos
= (POINT
*)lParam
;
3869 flags
= TPM_CENTERALIGN
;
3870 if (button_state
& LMOUSE
)
3871 flags
|= TPM_LEFTBUTTON
;
3872 else if (button_state
& RMOUSE
)
3873 flags
|= TPM_RIGHTBUTTON
;
3875 /* Remember we did a SetCapture on the initial mouse down event,
3876 so for safety, we make sure the capture is cancelled now. */
3880 /* Use menubar_active to indicate that WM_INITMENU is from
3881 TrackPopupMenu below, and should be ignored. */
3882 f
= x_window_to_frame (dpyinfo
, hwnd
);
3884 f
->output_data
.w32
->menubar_active
= 1;
3886 if (TrackPopupMenu ((HMENU
)wParam
, flags
, pos
->x
, pos
->y
,
3890 /* Eat any mouse messages during popupmenu */
3891 while (PeekMessage (&amsg
, hwnd
, WM_MOUSEFIRST
, WM_MOUSELAST
,
3893 /* Get the menu selection, if any */
3894 if (PeekMessage (&amsg
, hwnd
, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
))
3896 retval
= LOWORD (amsg
.wParam
);
3912 /* Check for messages registered at runtime. */
3913 if (msg
== msh_mousewheel
)
3915 wmsg
.dwModifiers
= w32_get_modifiers ();
3916 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3917 signal_user_input ();
3922 return DefWindowProc (hwnd
, msg
, wParam
, lParam
);
3926 /* The most common default return code for handled messages is 0. */
3931 my_create_window (f
)
3936 if (!PostThreadMessage (dwWindowsThreadId
, WM_EMACS_CREATEWINDOW
, (WPARAM
)f
, 0))
3938 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3942 /* Create a tooltip window. Unlike my_create_window, we do not do this
3943 indirectly via the Window thread, as we do not need to process Window
3944 messages for the tooltip. Creating tooltips indirectly also creates
3945 deadlocks when tooltips are created for menu items. */
3947 my_create_tip_window (f
)
3952 rect
.left
= rect
.top
= 0;
3953 rect
.right
= FRAME_PIXEL_WIDTH (f
);
3954 rect
.bottom
= FRAME_PIXEL_HEIGHT (f
);
3956 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
3957 FRAME_EXTERNAL_MENU_BAR (f
));
3959 tip_window
= FRAME_W32_WINDOW (f
)
3960 = CreateWindow (EMACS_CLASS
,
3962 f
->output_data
.w32
->dwStyle
,
3965 rect
.right
- rect
.left
,
3966 rect
.bottom
- rect
.top
,
3967 FRAME_W32_WINDOW (SELECTED_FRAME ()), /* owner */
3974 SetWindowLong (tip_window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
3975 SetWindowLong (tip_window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
3976 SetWindowLong (tip_window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
3977 SetWindowLong (tip_window
, WND_BACKGROUND_INDEX
, FRAME_BACKGROUND_PIXEL (f
));
3979 /* Tip frames have no scrollbars. */
3980 SetWindowLong (tip_window
, WND_SCROLLBAR_INDEX
, 0);
3982 /* Do this to discard the default setting specified by our parent. */
3983 ShowWindow (tip_window
, SW_HIDE
);
3988 /* Create and set up the w32 window for frame F. */
3991 w32_window (f
, window_prompting
, minibuffer_only
)
3993 long window_prompting
;
3994 int minibuffer_only
;
3998 /* Use the resource name as the top-level window name
3999 for looking up resources. Make a non-Lisp copy
4000 for the window manager, so GC relocation won't bother it.
4002 Elsewhere we specify the window name for the window manager. */
4005 char *str
= (char *) SDATA (Vx_resource_name
);
4006 f
->namebuf
= (char *) xmalloc (strlen (str
) + 1);
4007 strcpy (f
->namebuf
, str
);
4010 my_create_window (f
);
4012 validate_x_resource_name ();
4014 /* x_set_name normally ignores requests to set the name if the
4015 requested name is the same as the current name. This is the one
4016 place where that assumption isn't correct; f->name is set, but
4017 the server hasn't been told. */
4020 int explicit = f
->explicit_name
;
4022 f
->explicit_name
= 0;
4025 x_set_name (f
, name
, explicit);
4030 if (!minibuffer_only
&& FRAME_EXTERNAL_MENU_BAR (f
))
4031 initialize_frame_menubar (f
);
4033 if (FRAME_W32_WINDOW (f
) == 0)
4034 error ("Unable to create window");
4037 /* Handle the icon stuff for this window. Perhaps later we might
4038 want an x_set_icon_position which can be called interactively as
4046 Lisp_Object icon_x
, icon_y
;
4048 /* Set the position of the icon. Note that Windows 95 groups all
4049 icons in the tray. */
4050 icon_x
= w32_get_arg (parms
, Qicon_left
, 0, 0, RES_TYPE_NUMBER
);
4051 icon_y
= w32_get_arg (parms
, Qicon_top
, 0, 0, RES_TYPE_NUMBER
);
4052 if (!EQ (icon_x
, Qunbound
) && !EQ (icon_y
, Qunbound
))
4054 CHECK_NUMBER (icon_x
);
4055 CHECK_NUMBER (icon_y
);
4057 else if (!EQ (icon_x
, Qunbound
) || !EQ (icon_y
, Qunbound
))
4058 error ("Both left and top icon corners of icon must be specified");
4062 if (! EQ (icon_x
, Qunbound
))
4063 x_wm_set_icon_position (f
, XINT (icon_x
), XINT (icon_y
));
4066 /* Start up iconic or window? */
4067 x_wm_set_window_state
4068 (f
, (EQ (w32_get_arg (parms
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
), Qicon
)
4072 x_text_icon (f
, (char *) SDATA ((!NILP (f
->icon_name
)
4085 XGCValues gc_values
;
4089 /* Create the GC's of this frame.
4090 Note that many default values are used. */
4093 gc_values
.font
= FRAME_FONT (f
);
4095 /* Cursor has cursor-color background, background-color foreground. */
4096 gc_values
.foreground
= FRAME_BACKGROUND_PIXEL (f
);
4097 gc_values
.background
= f
->output_data
.w32
->cursor_pixel
;
4098 f
->output_data
.w32
->cursor_gc
4099 = XCreateGC (NULL
, FRAME_W32_WINDOW (f
),
4100 (GCFont
| GCForeground
| GCBackground
),
4104 f
->output_data
.w32
->white_relief
.gc
= 0;
4105 f
->output_data
.w32
->black_relief
.gc
= 0;
4111 /* Handler for signals raised during x_create_frame and
4112 x_create_top_frame. FRAME is the frame which is partially
4116 unwind_create_frame (frame
)
4119 struct frame
*f
= XFRAME (frame
);
4121 /* If frame is ``official'', nothing to do. */
4122 if (!CONSP (Vframe_list
) || !EQ (XCAR (Vframe_list
), frame
))
4125 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
4128 x_free_frame_resources (f
);
4130 /* Check that reference counts are indeed correct. */
4131 xassert (dpyinfo
->reference_count
== dpyinfo_refcount
);
4132 xassert (dpyinfo
->image_cache
->refcount
== image_cache_refcount
);
4141 DEFUN ("x-create-frame", Fx_create_frame
, Sx_create_frame
,
4143 doc
: /* Make a new window, which is called a \"frame\" in Emacs terms.
4144 Returns an Emacs frame object.
4145 PARAMETERS is an alist of frame parameters.
4146 If the parameters specify that the frame should not have a minibuffer,
4147 and do not specify a specific minibuffer window to use,
4148 then `default-minibuffer-frame' must be a frame whose minibuffer can
4149 be shared by the new frame.
4151 This function is an internal primitive--use `make-frame' instead. */)
4153 Lisp_Object parameters
;
4156 Lisp_Object frame
, tem
;
4158 int minibuffer_only
= 0;
4159 long window_prompting
= 0;
4161 int count
= SPECPDL_INDEX ();
4162 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4163 Lisp_Object display
;
4164 struct w32_display_info
*dpyinfo
= NULL
;
4170 /* Use this general default value to start with
4171 until we know if this frame has a specified name. */
4172 Vx_resource_name
= Vinvocation_name
;
4174 display
= w32_get_arg (parameters
, Qdisplay
, 0, 0, RES_TYPE_STRING
);
4175 if (EQ (display
, Qunbound
))
4177 dpyinfo
= check_x_display_info (display
);
4179 kb
= dpyinfo
->terminal
->kboard
;
4181 kb
= &the_only_kboard
;
4184 name
= w32_get_arg (parameters
, Qname
, "name", "Name", RES_TYPE_STRING
);
4186 && ! EQ (name
, Qunbound
)
4188 error ("Invalid frame name--not a string or nil");
4191 Vx_resource_name
= name
;
4193 /* See if parent window is specified. */
4194 parent
= w32_get_arg (parameters
, Qparent_id
, NULL
, NULL
, RES_TYPE_NUMBER
);
4195 if (EQ (parent
, Qunbound
))
4197 if (! NILP (parent
))
4198 CHECK_NUMBER (parent
);
4200 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
4201 /* No need to protect DISPLAY because that's not used after passing
4202 it to make_frame_without_minibuffer. */
4204 GCPRO4 (parameters
, parent
, name
, frame
);
4205 tem
= w32_get_arg (parameters
, Qminibuffer
, "minibuffer", "Minibuffer",
4207 if (EQ (tem
, Qnone
) || NILP (tem
))
4208 f
= make_frame_without_minibuffer (Qnil
, kb
, display
);
4209 else if (EQ (tem
, Qonly
))
4211 f
= make_minibuffer_frame ();
4212 minibuffer_only
= 1;
4214 else if (WINDOWP (tem
))
4215 f
= make_frame_without_minibuffer (tem
, kb
, display
);
4219 XSETFRAME (frame
, f
);
4221 /* Note that Windows does support scroll bars. */
4222 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
4224 /* By default, make scrollbars the system standard width. */
4225 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = GetSystemMetrics (SM_CXVSCROLL
);
4227 f
->terminal
= dpyinfo
->terminal
;
4228 f
->terminal
->reference_count
++;
4230 f
->output_method
= output_w32
;
4231 f
->output_data
.w32
=
4232 (struct w32_output
*) xmalloc (sizeof (struct w32_output
));
4233 bzero (f
->output_data
.w32
, sizeof (struct w32_output
));
4234 FRAME_FONTSET (f
) = -1;
4235 record_unwind_protect (unwind_create_frame
, frame
);
4238 = w32_get_arg (parameters
, Qicon_name
, "iconName", "Title", RES_TYPE_STRING
);
4239 if (! STRINGP (f
->icon_name
))
4240 f
->icon_name
= Qnil
;
4242 /* FRAME_W32_DISPLAY_INFO (f) = dpyinfo; */
4244 FRAME_KBOARD (f
) = kb
;
4247 /* Specify the parent under which to make this window. */
4251 f
->output_data
.w32
->parent_desc
= (Window
) XFASTINT (parent
);
4252 f
->output_data
.w32
->explicit_parent
= 1;
4256 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
4257 f
->output_data
.w32
->explicit_parent
= 0;
4260 /* Set the name; the functions to which we pass f expect the name to
4262 if (EQ (name
, Qunbound
) || NILP (name
))
4264 f
->name
= build_string (dpyinfo
->w32_id_name
);
4265 f
->explicit_name
= 0;
4270 f
->explicit_name
= 1;
4271 /* use the frame's title when getting resources for this frame. */
4272 specbind (Qx_resource_name
, name
);
4275 /* Extract the window parameters from the supplied values
4276 that are needed to determine window geometry. */
4280 font
= w32_get_arg (parameters
, Qfont
, "font", "Font", RES_TYPE_STRING
);
4283 /* First, try whatever font the caller has specified. */
4286 tem
= Fquery_fontset (font
, Qnil
);
4288 font
= x_new_fontset (f
, SDATA (tem
));
4290 font
= x_new_font (f
, SDATA (font
));
4292 /* Try out a font which we hope has bold and italic variations. */
4293 if (!STRINGP (font
))
4294 font
= x_new_font (f
, "-*-Courier New-normal-r-*-*-*-100-*-*-c-*-iso8859-1");
4295 if (! STRINGP (font
))
4296 font
= x_new_font (f
, "-*-Courier-normal-r-*-*-13-*-*-*-c-*-iso8859-1");
4297 /* If those didn't work, look for something which will at least work. */
4298 if (! STRINGP (font
))
4299 font
= x_new_font (f
, "-*-Fixedsys-normal-r-*-*-12-*-*-*-c-*-iso8859-1");
4301 if (! STRINGP (font
))
4302 font
= build_string ("Fixedsys");
4304 x_default_parameter (f
, parameters
, Qfont
, font
,
4305 "font", "Font", RES_TYPE_STRING
);
4308 x_default_parameter (f
, parameters
, Qborder_width
, make_number (2),
4309 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
4310 /* This defaults to 2 in order to match xterm. We recognize either
4311 internalBorderWidth or internalBorder (which is what xterm calls
4313 if (NILP (Fassq (Qinternal_border_width
, parameters
)))
4317 value
= w32_get_arg (parameters
, Qinternal_border_width
,
4318 "internalBorder", "InternalBorder", RES_TYPE_NUMBER
);
4319 if (! EQ (value
, Qunbound
))
4320 parameters
= Fcons (Fcons (Qinternal_border_width
, value
),
4323 /* Default internalBorderWidth to 0 on Windows to match other programs. */
4324 x_default_parameter (f
, parameters
, Qinternal_border_width
, make_number (0),
4325 "internalBorderWidth", "InternalBorder", RES_TYPE_NUMBER
);
4326 x_default_parameter (f
, parameters
, Qvertical_scroll_bars
, Qright
,
4327 "verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL
);
4329 /* Also do the stuff which must be set before the window exists. */
4330 x_default_parameter (f
, parameters
, Qforeground_color
, build_string ("black"),
4331 "foreground", "Foreground", RES_TYPE_STRING
);
4332 x_default_parameter (f
, parameters
, Qbackground_color
, build_string ("white"),
4333 "background", "Background", RES_TYPE_STRING
);
4334 x_default_parameter (f
, parameters
, Qmouse_color
, build_string ("black"),
4335 "pointerColor", "Foreground", RES_TYPE_STRING
);
4336 x_default_parameter (f
, parameters
, Qcursor_color
, build_string ("black"),
4337 "cursorColor", "Foreground", RES_TYPE_STRING
);
4338 x_default_parameter (f
, parameters
, Qborder_color
, build_string ("black"),
4339 "borderColor", "BorderColor", RES_TYPE_STRING
);
4340 x_default_parameter (f
, parameters
, Qscreen_gamma
, Qnil
,
4341 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT
);
4342 x_default_parameter (f
, parameters
, Qline_spacing
, Qnil
,
4343 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER
);
4344 x_default_parameter (f
, parameters
, Qleft_fringe
, Qnil
,
4345 "leftFringe", "LeftFringe", RES_TYPE_NUMBER
);
4346 x_default_parameter (f
, parameters
, Qright_fringe
, Qnil
,
4347 "rightFringe", "RightFringe", RES_TYPE_NUMBER
);
4350 /* Init faces before x_default_parameter is called for scroll-bar
4351 parameters because that function calls x_set_scroll_bar_width,
4352 which calls change_frame_size, which calls Fset_window_buffer,
4353 which runs hooks, which call Fvertical_motion. At the end, we
4354 end up in init_iterator with a null face cache, which should not
4356 init_frame_faces (f
);
4358 x_default_parameter (f
, parameters
, Qmenu_bar_lines
, make_number (1),
4359 "menuBar", "MenuBar", RES_TYPE_NUMBER
);
4360 x_default_parameter (f
, parameters
, Qtool_bar_lines
, make_number (1),
4361 "toolBar", "ToolBar", RES_TYPE_NUMBER
);
4363 x_default_parameter (f
, parameters
, Qbuffer_predicate
, Qnil
,
4364 "bufferPredicate", "BufferPredicate", RES_TYPE_SYMBOL
);
4365 x_default_parameter (f
, parameters
, Qtitle
, Qnil
,
4366 "title", "Title", RES_TYPE_STRING
);
4367 x_default_parameter (f
, parameters
, Qfullscreen
, Qnil
,
4368 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL
);
4370 f
->output_data
.w32
->dwStyle
= WS_OVERLAPPEDWINDOW
;
4371 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
4373 f
->output_data
.w32
->text_cursor
= w32_load_cursor (IDC_IBEAM
);
4374 f
->output_data
.w32
->nontext_cursor
= w32_load_cursor (IDC_ARROW
);
4375 f
->output_data
.w32
->modeline_cursor
= w32_load_cursor (IDC_ARROW
);
4376 f
->output_data
.w32
->hand_cursor
= w32_load_cursor (IDC_HAND
);
4377 f
->output_data
.w32
->hourglass_cursor
= w32_load_cursor (IDC_WAIT
);
4378 f
->output_data
.w32
->horizontal_drag_cursor
= w32_load_cursor (IDC_SIZEWE
);
4380 window_prompting
= x_figure_window_size (f
, parameters
, 1);
4382 tem
= w32_get_arg (parameters
, Qunsplittable
, 0, 0, RES_TYPE_BOOLEAN
);
4383 f
->no_split
= minibuffer_only
|| EQ (tem
, Qt
);
4385 w32_window (f
, window_prompting
, minibuffer_only
);
4386 x_icon (f
, parameters
);
4390 /* Now consider the frame official. */
4391 FRAME_W32_DISPLAY_INFO (f
)->reference_count
++;
4392 Vframe_list
= Fcons (frame
, Vframe_list
);
4394 /* We need to do this after creating the window, so that the
4395 icon-creation functions can say whose icon they're describing. */
4396 x_default_parameter (f
, parameters
, Qicon_type
, Qnil
,
4397 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL
);
4399 x_default_parameter (f
, parameters
, Qauto_raise
, Qnil
,
4400 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
4401 x_default_parameter (f
, parameters
, Qauto_lower
, Qnil
,
4402 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
4403 x_default_parameter (f
, parameters
, Qcursor_type
, Qbox
,
4404 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
4405 x_default_parameter (f
, parameters
, Qscroll_bar_width
, Qnil
,
4406 "scrollBarWidth", "ScrollBarWidth", RES_TYPE_NUMBER
);
4408 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
4409 Change will not be effected unless different from the current
4411 width
= FRAME_COLS (f
);
4412 height
= FRAME_LINES (f
);
4414 FRAME_LINES (f
) = 0;
4415 SET_FRAME_COLS (f
, 0);
4416 change_frame_size (f
, height
, width
, 1, 0, 0);
4418 /* Tell the server what size and position, etc, we want, and how
4419 badly we want them. This should be done after we have the menu
4420 bar so that its size can be taken into account. */
4422 x_wm_set_size_hint (f
, window_prompting
, 0);
4425 /* Make the window appear on the frame and enable display, unless
4426 the caller says not to. However, with explicit parent, Emacs
4427 cannot control visibility, so don't try. */
4428 if (! f
->output_data
.w32
->explicit_parent
)
4430 Lisp_Object visibility
;
4432 visibility
= w32_get_arg (parameters
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
);
4433 if (EQ (visibility
, Qunbound
))
4436 if (EQ (visibility
, Qicon
))
4437 x_iconify_frame (f
);
4438 else if (! NILP (visibility
))
4439 x_make_frame_visible (f
);
4441 /* Must have been Qnil. */
4445 /* Initialize `default-minibuffer-frame' in case this is the first
4446 frame on this terminal. */
4447 if (FRAME_HAS_MINIBUF_P (f
)
4448 && (!FRAMEP (kb
->Vdefault_minibuffer_frame
)
4449 || !FRAME_LIVE_P (XFRAME (kb
->Vdefault_minibuffer_frame
))))
4450 kb
->Vdefault_minibuffer_frame
= frame
;
4452 /* All remaining specified parameters, which have not been "used"
4453 by x_get_arg and friends, now go in the misc. alist of the frame. */
4454 for (tem
= parameters
; CONSP (tem
); tem
= XCDR (tem
))
4455 if (CONSP (XCAR (tem
)) && !NILP (XCAR (XCAR (tem
))))
4456 f
->param_alist
= Fcons (XCAR (tem
), f
->param_alist
);
4460 /* Make sure windows on this frame appear in calls to next-window
4461 and similar functions. */
4462 Vwindow_list
= Qnil
;
4464 return unbind_to (count
, frame
);
4467 /* FRAME is used only to get a handle on the X display. We don't pass the
4468 display info directly because we're called from frame.c, which doesn't
4469 know about that structure. */
4471 x_get_focus_frame (frame
)
4472 struct frame
*frame
;
4474 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (frame
);
4476 if (! dpyinfo
->w32_focus_frame
)
4479 XSETFRAME (xfocus
, dpyinfo
->w32_focus_frame
);
4483 DEFUN ("x-focus-frame", Fx_focus_frame
, Sx_focus_frame
, 1, 1, 0,
4484 doc
: /* Give FRAME input focus, raising to foreground if necessary. */)
4488 x_focus_on_frame (check_x_frame (frame
));
4493 /* Return the charset portion of a font name. */
4494 char * xlfd_charset_of_font (char * fontname
)
4496 char *charset
, *encoding
;
4498 encoding
= strrchr(fontname
, '-');
4499 if (!encoding
|| encoding
== fontname
)
4502 for (charset
= encoding
- 1; charset
>= fontname
; charset
--)
4503 if (*charset
== '-')
4506 if (charset
== fontname
|| strcmp(charset
, "-*-*") == 0)
4512 struct font_info
*w32_load_bdf_font (struct frame
*f
, char *fontname
,
4513 int size
, char* filename
);
4514 static Lisp_Object
w32_list_bdf_fonts (Lisp_Object pattern
, int max_names
);
4515 static BOOL
w32_to_x_font (LOGFONT
* lplf
, char * lpxstr
, int len
,
4517 static BOOL
x_to_w32_font (char *lpxstr
, LOGFONT
*lplogfont
);
4519 static struct font_info
*
4520 w32_load_system_font (f
,fontname
,size
)
4525 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
4526 Lisp_Object font_names
;
4528 /* Get a list of all the fonts that match this name. Once we
4529 have a list of matching fonts, we compare them against the fonts
4530 we already have loaded by comparing names. */
4531 font_names
= w32_list_fonts (f
, build_string (fontname
), size
, 100);
4533 if (!NILP (font_names
))
4538 /* First check if any are already loaded, as that is cheaper
4539 than loading another one. */
4540 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
4541 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
4542 if (dpyinfo
->font_table
[i
].name
4543 && (!strcmp (dpyinfo
->font_table
[i
].name
,
4544 SDATA (XCAR (tail
)))
4545 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
4546 SDATA (XCAR (tail
)))))
4547 return (dpyinfo
->font_table
+ i
);
4549 fontname
= (char *) SDATA (XCAR (font_names
));
4551 else if (w32_strict_fontnames
)
4553 /* If EnumFontFamiliesEx was available, we got a full list of
4554 fonts back so stop now to avoid the possibility of loading a
4555 random font. If we had to fall back to EnumFontFamilies, the
4556 list is incomplete, so continue whether the font we want was
4558 HMODULE gdi32
= GetModuleHandle ("gdi32.dll");
4559 FARPROC enum_font_families_ex
4560 = GetProcAddress (gdi32
, "EnumFontFamiliesExA");
4561 if (enum_font_families_ex
)
4565 /* Load the font and add it to the table. */
4567 char *full_name
, *encoding
, *charset
;
4569 struct font_info
*fontp
;
4575 if (!fontname
|| !x_to_w32_font (fontname
, &lf
))
4578 if (!*lf
.lfFaceName
)
4579 /* If no name was specified for the font, we get a random font
4580 from CreateFontIndirect - this is not particularly
4581 desirable, especially since CreateFontIndirect does not
4582 fill out the missing name in lf, so we never know what we
4586 lf
.lfQuality
= DEFAULT_QUALITY
;
4588 font
= (XFontStruct
*) xmalloc (sizeof (XFontStruct
));
4589 bzero (font
, sizeof (*font
));
4591 /* Set bdf to NULL to indicate that this is a Windows font. */
4596 font
->hfont
= CreateFontIndirect (&lf
);
4598 if (font
->hfont
== NULL
)
4607 codepage
= w32_codepage_for_font (fontname
);
4609 hdc
= GetDC (dpyinfo
->root_window
);
4610 oldobj
= SelectObject (hdc
, font
->hfont
);
4612 ok
= GetTextMetrics (hdc
, &font
->tm
);
4613 if (codepage
== CP_UNICODE
)
4614 font
->double_byte_p
= 1;
4617 /* Unfortunately, some fonts (eg. MingLiU, a big5 ttf font)
4618 don't report themselves as double byte fonts, when
4619 patently they are. So instead of trusting
4620 GetFontLanguageInfo, we check the properties of the
4621 codepage directly, since that is ultimately what we are
4622 working from anyway. */
4623 /* font->double_byte_p = GetFontLanguageInfo(hdc) & GCP_DBCS; */
4625 GetCPInfo (codepage
, &cpi
);
4626 font
->double_byte_p
= cpi
.MaxCharSize
> 1;
4629 SelectObject (hdc
, oldobj
);
4630 ReleaseDC (dpyinfo
->root_window
, hdc
);
4631 /* Fill out details in lf according to the font that was
4633 lf
.lfHeight
= font
->tm
.tmInternalLeading
- font
->tm
.tmHeight
;
4634 lf
.lfWidth
= font
->tm
.tmMaxCharWidth
;
4635 lf
.lfWeight
= font
->tm
.tmWeight
;
4636 lf
.lfItalic
= font
->tm
.tmItalic
;
4637 lf
.lfCharSet
= font
->tm
.tmCharSet
;
4638 lf
.lfPitchAndFamily
= ((font
->tm
.tmPitchAndFamily
& TMPF_FIXED_PITCH
)
4639 ? VARIABLE_PITCH
: FIXED_PITCH
);
4640 lf
.lfOutPrecision
= ((font
->tm
.tmPitchAndFamily
& TMPF_VECTOR
)
4641 ? OUT_STROKE_PRECIS
: OUT_STRING_PRECIS
);
4643 w32_cache_char_metrics (font
);
4650 w32_unload_font (dpyinfo
, font
);
4654 /* Find a free slot in the font table. */
4655 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
4656 if (dpyinfo
->font_table
[i
].name
== NULL
)
4659 /* If no free slot found, maybe enlarge the font table. */
4660 if (i
== dpyinfo
->n_fonts
4661 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
4664 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
4665 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
4667 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
4670 fontp
= dpyinfo
->font_table
+ i
;
4671 if (i
== dpyinfo
->n_fonts
)
4674 /* Now fill in the slots of *FONTP. */
4676 bzero (fontp
, sizeof (*fontp
));
4678 fontp
->font_idx
= i
;
4679 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
4680 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
4682 if (lf
.lfPitchAndFamily
== FIXED_PITCH
)
4684 /* Fixed width font. */
4685 fontp
->average_width
= fontp
->space_width
= FONT_WIDTH (font
);
4691 pcm
= w32_per_char_metric (font
, &space
, ANSI_FONT
);
4693 fontp
->space_width
= pcm
->width
;
4695 fontp
->space_width
= FONT_WIDTH (font
);
4697 fontp
->average_width
= font
->tm
.tmAveCharWidth
;
4700 charset
= xlfd_charset_of_font (fontname
);
4702 /* Cache the W32 codepage for a font. This makes w32_encode_char
4703 (called for every glyph during redisplay) much faster. */
4704 fontp
->codepage
= codepage
;
4706 /* Work out the font's full name. */
4707 full_name
= (char *)xmalloc (100);
4708 if (full_name
&& w32_to_x_font (&lf
, full_name
, 100, charset
))
4709 fontp
->full_name
= full_name
;
4712 /* If all else fails - just use the name we used to load it. */
4714 fontp
->full_name
= fontp
->name
;
4717 fontp
->size
= FONT_WIDTH (font
);
4718 fontp
->height
= FONT_HEIGHT (font
);
4720 /* The slot `encoding' specifies how to map a character
4721 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
4722 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
4723 (0:0x20..0x7F, 1:0xA0..0xFF,
4724 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
4725 2:0xA020..0xFF7F). For the moment, we don't know which charset
4726 uses this font. So, we set information in fontp->encoding[1]
4727 which is never used by any charset. If mapping can't be
4728 decided, set FONT_ENCODING_NOT_DECIDED. */
4730 /* SJIS fonts need to be set to type 4, all others seem to work as
4731 type FONT_ENCODING_NOT_DECIDED. */
4732 encoding
= strrchr (fontp
->name
, '-');
4733 if (encoding
&& strnicmp (encoding
+1, "sjis", 4) == 0)
4734 fontp
->encoding
[1] = 4;
4736 fontp
->encoding
[1] = FONT_ENCODING_NOT_DECIDED
;
4738 /* The following three values are set to 0 under W32, which is
4739 what they get set to if XGetFontProperty fails under X. */
4740 fontp
->baseline_offset
= 0;
4741 fontp
->relative_compose
= 0;
4742 fontp
->default_ascent
= 0;
4744 /* Set global flag fonts_changed_p to non-zero if the font loaded
4745 has a character with a smaller width than any other character
4746 before, or if the font loaded has a smaller height than any
4747 other font loaded before. If this happens, it will make a
4748 glyph matrix reallocation necessary. */
4749 fonts_changed_p
|= x_compute_min_glyph_bounds (f
);
4755 /* Load font named FONTNAME of size SIZE for frame F, and return a
4756 pointer to the structure font_info while allocating it dynamically.
4757 If loading fails, return NULL. */
4759 w32_load_font (f
,fontname
,size
)
4764 Lisp_Object bdf_fonts
;
4765 struct font_info
*retval
= NULL
;
4766 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
4768 bdf_fonts
= w32_list_bdf_fonts (build_string (fontname
), 1);
4770 while (!retval
&& CONSP (bdf_fonts
))
4772 char *bdf_name
, *bdf_file
;
4773 Lisp_Object bdf_pair
;
4776 bdf_name
= SDATA (XCAR (bdf_fonts
));
4777 bdf_pair
= Fassoc (XCAR (bdf_fonts
), Vw32_bdf_filename_alist
);
4778 bdf_file
= SDATA (XCDR (bdf_pair
));
4780 // If the font is already loaded, do not load it again.
4781 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
4783 if ((dpyinfo
->font_table
[i
].name
4784 && !strcmp (dpyinfo
->font_table
[i
].name
, bdf_name
))
4785 || (dpyinfo
->font_table
[i
].full_name
4786 && !strcmp (dpyinfo
->font_table
[i
].full_name
, bdf_name
)))
4787 return dpyinfo
->font_table
+ i
;
4790 retval
= w32_load_bdf_font (f
, bdf_name
, size
, bdf_file
);
4792 bdf_fonts
= XCDR (bdf_fonts
);
4798 return w32_load_system_font(f
, fontname
, size
);
4803 w32_unload_font (dpyinfo
, font
)
4804 struct w32_display_info
*dpyinfo
;
4809 if (font
->per_char
) xfree (font
->per_char
);
4810 if (font
->bdf
) w32_free_bdf_font (font
->bdf
);
4812 if (font
->hfont
) DeleteObject(font
->hfont
);
4817 /* The font conversion stuff between x and w32 */
4819 /* X font string is as follows (from faces.el)
4823 * (weight "\\(bold\\|demibold\\|medium\\)") ; 1
4824 * (weight\? "\\([^-]*\\)") ; 1
4825 * (slant "\\([ior]\\)") ; 2
4826 * (slant\? "\\([^-]?\\)") ; 2
4827 * (swidth "\\([^-]*\\)") ; 3
4828 * (adstyle "[^-]*") ; 4
4829 * (pixelsize "[0-9]+")
4830 * (pointsize "[0-9][0-9]+")
4831 * (resx "[0-9][0-9]+")
4832 * (resy "[0-9][0-9]+")
4833 * (spacing "[cmp?*]")
4834 * (avgwidth "[0-9]+")
4835 * (registry "[^-]+")
4836 * (encoding "[^-]+")
4841 x_to_w32_weight (lpw
)
4844 if (!lpw
) return (FW_DONTCARE
);
4846 if (stricmp (lpw
,"heavy") == 0) return FW_HEAVY
;
4847 else if (stricmp (lpw
,"extrabold") == 0) return FW_EXTRABOLD
;
4848 else if (stricmp (lpw
,"bold") == 0) return FW_BOLD
;
4849 else if (stricmp (lpw
,"demibold") == 0) return FW_SEMIBOLD
;
4850 else if (stricmp (lpw
,"semibold") == 0) return FW_SEMIBOLD
;
4851 else if (stricmp (lpw
,"medium") == 0) return FW_MEDIUM
;
4852 else if (stricmp (lpw
,"normal") == 0) return FW_NORMAL
;
4853 else if (stricmp (lpw
,"light") == 0) return FW_LIGHT
;
4854 else if (stricmp (lpw
,"extralight") == 0) return FW_EXTRALIGHT
;
4855 else if (stricmp (lpw
,"thin") == 0) return FW_THIN
;
4862 w32_to_x_weight (fnweight
)
4865 if (fnweight
>= FW_HEAVY
) return "heavy";
4866 if (fnweight
>= FW_EXTRABOLD
) return "extrabold";
4867 if (fnweight
>= FW_BOLD
) return "bold";
4868 if (fnweight
>= FW_SEMIBOLD
) return "demibold";
4869 if (fnweight
>= FW_MEDIUM
) return "medium";
4870 if (fnweight
>= FW_NORMAL
) return "normal";
4871 if (fnweight
>= FW_LIGHT
) return "light";
4872 if (fnweight
>= FW_EXTRALIGHT
) return "extralight";
4873 if (fnweight
>= FW_THIN
) return "thin";
4879 x_to_w32_charset (lpcs
)
4882 Lisp_Object this_entry
, w32_charset
;
4884 int len
= strlen (lpcs
);
4886 /* Support "*-#nnn" format for unknown charsets. */
4887 if (strncmp (lpcs
, "*-#", 3) == 0)
4888 return atoi (lpcs
+ 3);
4890 /* Handle wildcards by ignoring them; eg. treat "big5*-*" as "big5". */
4891 charset
= alloca (len
+ 1);
4892 strcpy (charset
, lpcs
);
4893 lpcs
= strchr (charset
, '*');
4897 /* Look through w32-charset-info-alist for the character set.
4898 Format of each entry is
4899 (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE)).
4901 this_entry
= Fassoc (build_string(charset
), Vw32_charset_info_alist
);
4903 if (NILP(this_entry
))
4905 /* At startup, we want iso8859-1 fonts to come up properly. */
4906 if (stricmp(charset
, "iso8859-1") == 0)
4907 return ANSI_CHARSET
;
4909 return DEFAULT_CHARSET
;
4912 w32_charset
= Fcar (Fcdr (this_entry
));
4914 /* Translate Lisp symbol to number. */
4915 if (EQ (w32_charset
, Qw32_charset_ansi
))
4916 return ANSI_CHARSET
;
4917 if (EQ (w32_charset
, Qw32_charset_symbol
))
4918 return SYMBOL_CHARSET
;
4919 if (EQ (w32_charset
, Qw32_charset_shiftjis
))
4920 return SHIFTJIS_CHARSET
;
4921 if (EQ (w32_charset
, Qw32_charset_hangeul
))
4922 return HANGEUL_CHARSET
;
4923 if (EQ (w32_charset
, Qw32_charset_chinesebig5
))
4924 return CHINESEBIG5_CHARSET
;
4925 if (EQ (w32_charset
, Qw32_charset_gb2312
))
4926 return GB2312_CHARSET
;
4927 if (EQ (w32_charset
, Qw32_charset_oem
))
4929 #ifdef JOHAB_CHARSET
4930 if (EQ (w32_charset
, Qw32_charset_johab
))
4931 return JOHAB_CHARSET
;
4932 if (EQ (w32_charset
, Qw32_charset_easteurope
))
4933 return EASTEUROPE_CHARSET
;
4934 if (EQ (w32_charset
, Qw32_charset_turkish
))
4935 return TURKISH_CHARSET
;
4936 if (EQ (w32_charset
, Qw32_charset_baltic
))
4937 return BALTIC_CHARSET
;
4938 if (EQ (w32_charset
, Qw32_charset_russian
))
4939 return RUSSIAN_CHARSET
;
4940 if (EQ (w32_charset
, Qw32_charset_arabic
))
4941 return ARABIC_CHARSET
;
4942 if (EQ (w32_charset
, Qw32_charset_greek
))
4943 return GREEK_CHARSET
;
4944 if (EQ (w32_charset
, Qw32_charset_hebrew
))
4945 return HEBREW_CHARSET
;
4946 if (EQ (w32_charset
, Qw32_charset_vietnamese
))
4947 return VIETNAMESE_CHARSET
;
4948 if (EQ (w32_charset
, Qw32_charset_thai
))
4949 return THAI_CHARSET
;
4950 if (EQ (w32_charset
, Qw32_charset_mac
))
4952 #endif /* JOHAB_CHARSET */
4953 #ifdef UNICODE_CHARSET
4954 if (EQ (w32_charset
, Qw32_charset_unicode
))
4955 return UNICODE_CHARSET
;
4958 return DEFAULT_CHARSET
;
4963 w32_to_x_charset (fncharset
)
4966 static char buf
[32];
4967 Lisp_Object charset_type
;
4972 /* Handle startup case of w32-charset-info-alist not
4973 being set up yet. */
4974 if (NILP(Vw32_charset_info_alist
))
4976 charset_type
= Qw32_charset_ansi
;
4978 case DEFAULT_CHARSET
:
4979 charset_type
= Qw32_charset_default
;
4981 case SYMBOL_CHARSET
:
4982 charset_type
= Qw32_charset_symbol
;
4984 case SHIFTJIS_CHARSET
:
4985 charset_type
= Qw32_charset_shiftjis
;
4987 case HANGEUL_CHARSET
:
4988 charset_type
= Qw32_charset_hangeul
;
4990 case GB2312_CHARSET
:
4991 charset_type
= Qw32_charset_gb2312
;
4993 case CHINESEBIG5_CHARSET
:
4994 charset_type
= Qw32_charset_chinesebig5
;
4997 charset_type
= Qw32_charset_oem
;
5000 /* More recent versions of Windows (95 and NT4.0) define more
5002 #ifdef EASTEUROPE_CHARSET
5003 case EASTEUROPE_CHARSET
:
5004 charset_type
= Qw32_charset_easteurope
;
5006 case TURKISH_CHARSET
:
5007 charset_type
= Qw32_charset_turkish
;
5009 case BALTIC_CHARSET
:
5010 charset_type
= Qw32_charset_baltic
;
5012 case RUSSIAN_CHARSET
:
5013 charset_type
= Qw32_charset_russian
;
5015 case ARABIC_CHARSET
:
5016 charset_type
= Qw32_charset_arabic
;
5019 charset_type
= Qw32_charset_greek
;
5021 case HEBREW_CHARSET
:
5022 charset_type
= Qw32_charset_hebrew
;
5024 case VIETNAMESE_CHARSET
:
5025 charset_type
= Qw32_charset_vietnamese
;
5028 charset_type
= Qw32_charset_thai
;
5031 charset_type
= Qw32_charset_mac
;
5034 charset_type
= Qw32_charset_johab
;
5038 #ifdef UNICODE_CHARSET
5039 case UNICODE_CHARSET
:
5040 charset_type
= Qw32_charset_unicode
;
5044 /* Encode numerical value of unknown charset. */
5045 sprintf (buf
, "*-#%u", fncharset
);
5051 char * best_match
= NULL
;
5053 /* Look through w32-charset-info-alist for the character set.
5054 Prefer ISO codepages, and prefer lower numbers in the ISO
5055 range. Only return charsets for codepages which are installed.
5057 Format of each entry is
5058 (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE)).
5060 for (rest
= Vw32_charset_info_alist
; CONSP (rest
); rest
= XCDR (rest
))
5063 Lisp_Object w32_charset
;
5064 Lisp_Object codepage
;
5066 Lisp_Object this_entry
= XCAR (rest
);
5068 /* Skip invalid entries in alist. */
5069 if (!CONSP (this_entry
) || !STRINGP (XCAR (this_entry
))
5070 || !CONSP (XCDR (this_entry
))
5071 || !SYMBOLP (XCAR (XCDR (this_entry
))))
5074 x_charset
= SDATA (XCAR (this_entry
));
5075 w32_charset
= XCAR (XCDR (this_entry
));
5076 codepage
= XCDR (XCDR (this_entry
));
5078 /* Look for Same charset and a valid codepage (or non-int
5079 which means ignore). */
5080 if (EQ (w32_charset
, charset_type
)
5081 && (!INTEGERP (codepage
) || XINT (codepage
) == CP_DEFAULT
5082 || IsValidCodePage (XINT (codepage
))))
5084 /* If we don't have a match already, then this is the
5087 best_match
= x_charset
;
5088 /* If this is an ISO codepage, and the best so far isn't,
5089 then this is better. */
5090 else if (strnicmp (best_match
, "iso", 3) != 0
5091 && strnicmp (x_charset
, "iso", 3) == 0)
5092 best_match
= x_charset
;
5093 /* If both are ISO8859 codepages, choose the one with the
5094 lowest number in the encoding field. */
5095 else if (strnicmp (best_match
, "iso8859-", 8) == 0
5096 && strnicmp (x_charset
, "iso8859-", 8) == 0)
5098 int best_enc
= atoi (best_match
+ 8);
5099 int this_enc
= atoi (x_charset
+ 8);
5100 if (this_enc
> 0 && this_enc
< best_enc
)
5101 best_match
= x_charset
;
5106 /* If no match, encode the numeric value. */
5109 sprintf (buf
, "*-#%u", fncharset
);
5113 strncpy(buf
, best_match
, 31);
5120 /* Return all the X charsets that map to a font. */
5122 w32_to_all_x_charsets (fncharset
)
5125 static char buf
[32];
5126 Lisp_Object charset_type
;
5127 Lisp_Object retval
= Qnil
;
5132 /* Handle startup case of w32-charset-info-alist not
5133 being set up yet. */
5134 if (NILP(Vw32_charset_info_alist
))
5135 return Fcons (build_string ("iso8859-1"), Qnil
);
5137 charset_type
= Qw32_charset_ansi
;
5139 case DEFAULT_CHARSET
:
5140 charset_type
= Qw32_charset_default
;
5142 case SYMBOL_CHARSET
:
5143 charset_type
= Qw32_charset_symbol
;
5145 case SHIFTJIS_CHARSET
:
5146 charset_type
= Qw32_charset_shiftjis
;
5148 case HANGEUL_CHARSET
:
5149 charset_type
= Qw32_charset_hangeul
;
5151 case GB2312_CHARSET
:
5152 charset_type
= Qw32_charset_gb2312
;
5154 case CHINESEBIG5_CHARSET
:
5155 charset_type
= Qw32_charset_chinesebig5
;
5158 charset_type
= Qw32_charset_oem
;
5161 /* More recent versions of Windows (95 and NT4.0) define more
5163 #ifdef EASTEUROPE_CHARSET
5164 case EASTEUROPE_CHARSET
:
5165 charset_type
= Qw32_charset_easteurope
;
5167 case TURKISH_CHARSET
:
5168 charset_type
= Qw32_charset_turkish
;
5170 case BALTIC_CHARSET
:
5171 charset_type
= Qw32_charset_baltic
;
5173 case RUSSIAN_CHARSET
:
5174 charset_type
= Qw32_charset_russian
;
5176 case ARABIC_CHARSET
:
5177 charset_type
= Qw32_charset_arabic
;
5180 charset_type
= Qw32_charset_greek
;
5182 case HEBREW_CHARSET
:
5183 charset_type
= Qw32_charset_hebrew
;
5185 case VIETNAMESE_CHARSET
:
5186 charset_type
= Qw32_charset_vietnamese
;
5189 charset_type
= Qw32_charset_thai
;
5192 charset_type
= Qw32_charset_mac
;
5195 charset_type
= Qw32_charset_johab
;
5199 #ifdef UNICODE_CHARSET
5200 case UNICODE_CHARSET
:
5201 charset_type
= Qw32_charset_unicode
;
5205 /* Encode numerical value of unknown charset. */
5206 sprintf (buf
, "*-#%u", fncharset
);
5207 return Fcons (build_string (buf
), Qnil
);
5212 /* Look through w32-charset-info-alist for the character set.
5213 Only return charsets for codepages which are installed.
5215 Format of each entry in Vw32_charset_info_alist is
5216 (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE)).
5218 for (rest
= Vw32_charset_info_alist
; CONSP (rest
); rest
= XCDR (rest
))
5220 Lisp_Object x_charset
;
5221 Lisp_Object w32_charset
;
5222 Lisp_Object codepage
;
5224 Lisp_Object this_entry
= XCAR (rest
);
5226 /* Skip invalid entries in alist. */
5227 if (!CONSP (this_entry
) || !STRINGP (XCAR (this_entry
))
5228 || !CONSP (XCDR (this_entry
))
5229 || !SYMBOLP (XCAR (XCDR (this_entry
))))
5232 x_charset
= XCAR (this_entry
);
5233 w32_charset
= XCAR (XCDR (this_entry
));
5234 codepage
= XCDR (XCDR (this_entry
));
5236 /* Look for Same charset and a valid codepage (or non-int
5237 which means ignore). */
5238 if (EQ (w32_charset
, charset_type
)
5239 && (!INTEGERP (codepage
) || XINT (codepage
) == CP_DEFAULT
5240 || IsValidCodePage (XINT (codepage
))))
5242 retval
= Fcons (x_charset
, retval
);
5246 /* If no match, encode the numeric value. */
5249 sprintf (buf
, "*-#%u", fncharset
);
5250 return Fcons (build_string (buf
), Qnil
);
5257 /* Get the Windows codepage corresponding to the specified font. The
5258 charset info in the font name is used to look up
5259 w32-charset-to-codepage-alist. */
5261 w32_codepage_for_font (char *fontname
)
5263 Lisp_Object codepage
, entry
;
5264 char *charset_str
, *charset
, *end
;
5266 if (NILP (Vw32_charset_info_alist
))
5269 /* Extract charset part of font string. */
5270 charset
= xlfd_charset_of_font (fontname
);
5275 charset_str
= (char *) alloca (strlen (charset
) + 1);
5276 strcpy (charset_str
, charset
);
5279 /* Remove leading "*-". */
5280 if (strncmp ("*-", charset_str
, 2) == 0)
5281 charset
= charset_str
+ 2;
5284 charset
= charset_str
;
5286 /* Stop match at wildcard (including preceding '-'). */
5287 if (end
= strchr (charset
, '*'))
5289 if (end
> charset
&& *(end
-1) == '-')
5294 entry
= Fassoc (build_string(charset
), Vw32_charset_info_alist
);
5298 codepage
= Fcdr (Fcdr (entry
));
5300 if (NILP (codepage
))
5302 else if (XFASTINT (codepage
) == XFASTINT (Qt
))
5304 else if (INTEGERP (codepage
))
5305 return XINT (codepage
);
5312 w32_to_x_font (lplogfont
, lpxstr
, len
, specific_charset
)
5313 LOGFONT
* lplogfont
;
5316 char * specific_charset
;
5320 char height_pixels
[8];
5322 char width_pixels
[8];
5323 char *fontname_dash
;
5324 int display_resy
= (int) one_w32_display_info
.resy
;
5325 int display_resx
= (int) one_w32_display_info
.resx
;
5327 struct coding_system coding
;
5329 if (!lpxstr
) abort ();
5334 if (lplogfont
->lfOutPrecision
== OUT_STRING_PRECIS
)
5335 fonttype
= "raster";
5336 else if (lplogfont
->lfOutPrecision
== OUT_STROKE_PRECIS
)
5337 fonttype
= "outline";
5339 fonttype
= "unknown";
5341 setup_coding_system (Fcheck_coding_system (Vlocale_coding_system
),
5343 coding
.src_multibyte
= 0;
5344 coding
.dst_multibyte
= 1;
5345 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
5346 /* We explicitely disable composition handling because selection
5347 data should not contain any composition sequence. */
5348 coding
.composing
= COMPOSITION_DISABLED
;
5349 bufsz
= decoding_buffer_size (&coding
, LF_FACESIZE
);
5351 fontname
= alloca(sizeof(*fontname
) * bufsz
);
5352 decode_coding (&coding
, lplogfont
->lfFaceName
, fontname
,
5353 strlen(lplogfont
->lfFaceName
), bufsz
- 1);
5354 *(fontname
+ coding
.produced
) = '\0';
5356 /* Replace dashes with underscores so the dashes are not
5358 fontname_dash
= fontname
;
5359 while (fontname_dash
= strchr (fontname_dash
, '-'))
5360 *fontname_dash
= '_';
5362 if (lplogfont
->lfHeight
)
5364 sprintf (height_pixels
, "%u", eabs (lplogfont
->lfHeight
));
5365 sprintf (height_dpi
, "%u",
5366 eabs (lplogfont
->lfHeight
) * 720 / display_resy
);
5370 strcpy (height_pixels
, "*");
5371 strcpy (height_dpi
, "*");
5374 #if 0 /* Never put the width in the xfld. It fails on fonts with
5375 double-width characters. */
5376 if (lplogfont
->lfWidth
)
5377 sprintf (width_pixels
, "%u", lplogfont
->lfWidth
* 10);
5380 strcpy (width_pixels
, "*");
5382 _snprintf (lpxstr
, len
- 1,
5383 "-%s-%s-%s-%c-normal-normal-%s-%s-%d-%d-%c-%s-%s",
5384 fonttype
, /* foundry */
5385 fontname
, /* family */
5386 w32_to_x_weight (lplogfont
->lfWeight
), /* weight */
5387 lplogfont
->lfItalic
?'i':'r', /* slant */
5389 /* add style name */
5390 height_pixels
, /* pixel size */
5391 height_dpi
, /* point size */
5392 display_resx
, /* resx */
5393 display_resy
, /* resy */
5394 ((lplogfont
->lfPitchAndFamily
& 0x3) == VARIABLE_PITCH
)
5395 ? 'p' : 'c', /* spacing */
5396 width_pixels
, /* avg width */
5397 specific_charset
? specific_charset
5398 : w32_to_x_charset (lplogfont
->lfCharSet
)
5399 /* charset registry and encoding */
5402 lpxstr
[len
- 1] = 0; /* just to be sure */
5407 x_to_w32_font (lpxstr
, lplogfont
)
5409 LOGFONT
* lplogfont
;
5411 struct coding_system coding
;
5413 if (!lplogfont
) return (FALSE
);
5415 memset (lplogfont
, 0, sizeof (*lplogfont
));
5417 /* Set default value for each field. */
5419 lplogfont
->lfOutPrecision
= OUT_DEFAULT_PRECIS
;
5420 lplogfont
->lfClipPrecision
= CLIP_DEFAULT_PRECIS
;
5421 lplogfont
->lfQuality
= DEFAULT_QUALITY
;
5423 /* go for maximum quality */
5424 lplogfont
->lfOutPrecision
= OUT_STROKE_PRECIS
;
5425 lplogfont
->lfClipPrecision
= CLIP_STROKE_PRECIS
;
5426 lplogfont
->lfQuality
= PROOF_QUALITY
;
5429 lplogfont
->lfCharSet
= DEFAULT_CHARSET
;
5430 lplogfont
->lfWeight
= FW_DONTCARE
;
5431 lplogfont
->lfPitchAndFamily
= DEFAULT_PITCH
| FF_DONTCARE
;
5436 /* Provide a simple escape mechanism for specifying Windows font names
5437 * directly -- if font spec does not beginning with '-', assume this
5439 * "<font name>[:height in pixels[:width in pixels[:weight]]]"
5445 char name
[50], weight
[20], slant
, pitch
, pixels
[10], height
[10],
5446 width
[10], resy
[10], remainder
[50];
5448 int dpi
= (int) one_w32_display_info
.resy
;
5450 fields
= sscanf (lpxstr
,
5451 "-%*[^-]-%49[^-]-%19[^-]-%c-%*[^-]-%*[^-]-%9[^-]-%9[^-]-%*[^-]-%9[^-]-%c-%9[^-]-%49s",
5452 name
, weight
, &slant
, pixels
, height
, resy
, &pitch
, width
, remainder
);
5456 /* In the general case when wildcards cover more than one field,
5457 we don't know which field is which, so don't fill any in.
5458 However, we need to cope with this particular form, which is
5459 generated by font_list_1 (invoked by try_font_list):
5460 "-raster-6x10-*-gb2312*-*"
5461 and make sure to correctly parse the charset field. */
5464 fields
= sscanf (lpxstr
,
5465 "-%*[^-]-%49[^-]-*-%49s",
5468 else if (fields
< 9)
5474 if (fields
> 0 && name
[0] != '*')
5480 (Fcheck_coding_system (Vlocale_coding_system
), &coding
);
5481 coding
.src_multibyte
= 1;
5482 coding
.dst_multibyte
= 0;
5483 /* Need to set COMPOSITION_DISABLED, otherwise Emacs crashes in
5484 encode_coding_iso2022 trying to dereference a null pointer. */
5485 coding
.composing
= COMPOSITION_DISABLED
;
5486 if (coding
.type
== coding_type_iso2022
)
5487 coding
.flags
|= CODING_FLAG_ISO_SAFE
;
5488 bufsize
= encoding_buffer_size (&coding
, strlen (name
));
5489 buf
= (unsigned char *) alloca (bufsize
);
5490 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
5491 encode_coding (&coding
, name
, buf
, strlen (name
), bufsize
);
5492 if (coding
.produced
>= LF_FACESIZE
)
5493 coding
.produced
= LF_FACESIZE
- 1;
5494 buf
[coding
.produced
] = 0;
5495 strcpy (lplogfont
->lfFaceName
, buf
);
5499 lplogfont
->lfFaceName
[0] = '\0';
5504 lplogfont
->lfWeight
= x_to_w32_weight ((fields
> 0 ? weight
: ""));
5508 lplogfont
->lfItalic
= (fields
> 0 && slant
== 'i');
5512 if (fields
> 0 && pixels
[0] != '*')
5513 lplogfont
->lfHeight
= atoi (pixels
);
5517 if (fields
> 0 && resy
[0] != '*')
5520 if (tem
> 0) dpi
= tem
;
5523 if (fields
> -1 && lplogfont
->lfHeight
== 0 && height
[0] != '*')
5524 lplogfont
->lfHeight
= atoi (height
) * dpi
/ 720;
5527 lplogfont
->lfPitchAndFamily
=
5528 (fields
> 0 && pitch
== 'p') ? VARIABLE_PITCH
: FIXED_PITCH
;
5532 if (fields
> 0 && width
[0] != '*')
5533 lplogfont
->lfWidth
= atoi (width
) / 10;
5537 /* Strip the trailing '-' if present. (it shouldn't be, as it
5538 fails the test against xlfd-tight-regexp in fontset.el). */
5540 int len
= strlen (remainder
);
5541 if (len
> 0 && remainder
[len
-1] == '-')
5542 remainder
[len
-1] = 0;
5544 encoding
= remainder
;
5546 if (strncmp (encoding
, "*-", 2) == 0)
5549 lplogfont
->lfCharSet
= x_to_w32_charset (encoding
);
5554 char name
[100], height
[10], width
[10], weight
[20];
5556 fields
= sscanf (lpxstr
,
5557 "%99[^:]:%9[^:]:%9[^:]:%19s",
5558 name
, height
, width
, weight
);
5560 if (fields
== EOF
) return (FALSE
);
5564 strncpy (lplogfont
->lfFaceName
,name
, LF_FACESIZE
);
5565 lplogfont
->lfFaceName
[LF_FACESIZE
-1] = 0;
5569 lplogfont
->lfFaceName
[0] = 0;
5575 lplogfont
->lfHeight
= atoi (height
);
5580 lplogfont
->lfWidth
= atoi (width
);
5584 lplogfont
->lfWeight
= x_to_w32_weight ((fields
> 0 ? weight
: ""));
5587 /* This makes TrueType fonts work better. */
5588 lplogfont
->lfHeight
= - eabs (lplogfont
->lfHeight
);
5593 /* Strip the pixel height and point height from the given xlfd, and
5594 return the pixel height. If no pixel height is specified, calculate
5595 one from the point height, or if that isn't defined either, return
5596 0 (which usually signifies a scalable font).
5599 xlfd_strip_height (char *fontname
)
5601 int pixel_height
, field_number
;
5602 char *read_from
, *write_to
;
5606 pixel_height
= field_number
= 0;
5609 /* Look for height fields. */
5610 for (read_from
= fontname
; *read_from
; read_from
++)
5612 if (*read_from
== '-')
5615 if (field_number
== 7) /* Pixel height. */
5618 write_to
= read_from
;
5620 /* Find end of field. */
5621 for (;*read_from
&& *read_from
!= '-'; read_from
++)
5624 /* Split the fontname at end of field. */
5630 pixel_height
= atoi (write_to
);
5631 /* Blank out field. */
5632 if (read_from
> write_to
)
5637 /* If the pixel height field is at the end (partial xlfd),
5640 return pixel_height
;
5642 /* If we got a pixel height, the point height can be
5643 ignored. Just blank it out and break now. */
5646 /* Find end of point size field. */
5647 for (; *read_from
&& *read_from
!= '-'; read_from
++)
5653 /* Blank out the point size field. */
5654 if (read_from
> write_to
)
5660 return pixel_height
;
5664 /* If the point height is already blank, break now. */
5665 if (*read_from
== '-')
5671 else if (field_number
== 8)
5673 /* If we didn't get a pixel height, try to get the point
5674 height and convert that. */
5676 char *point_size_start
= read_from
++;
5678 /* Find end of field. */
5679 for (; *read_from
&& *read_from
!= '-'; read_from
++)
5688 point_size
= atoi (point_size_start
);
5690 /* Convert to pixel height. */
5691 pixel_height
= point_size
5692 * one_w32_display_info
.height_in
/ 720;
5694 /* Blank out this field and break. */
5702 /* Shift the rest of the font spec into place. */
5703 if (write_to
&& read_from
> write_to
)
5705 for (; *read_from
; read_from
++, write_to
++)
5706 *write_to
= *read_from
;
5710 return pixel_height
;
5713 /* Assume parameter 1 is fully qualified, no wildcards. */
5715 w32_font_match (fontname
, pattern
)
5720 char *font_name_copy
;
5721 char *regex
= alloca (strlen (pattern
) * 2 + 3);
5723 font_name_copy
= alloca (strlen (fontname
) + 1);
5724 strcpy (font_name_copy
, fontname
);
5729 /* Turn pattern into a regexp and do a regexp match. */
5730 for (; *pattern
; pattern
++)
5732 if (*pattern
== '?')
5734 else if (*pattern
== '*')
5745 /* Strip out font heights and compare them seperately, since
5746 rounding error can cause mismatches. This also allows a
5747 comparison between a font that declares only a pixel height and a
5748 pattern that declares the point height.
5751 int font_height
, pattern_height
;
5753 font_height
= xlfd_strip_height (font_name_copy
);
5754 pattern_height
= xlfd_strip_height (regex
);
5756 /* Compare now, and don't bother doing expensive regexp matching
5757 if the heights differ. */
5758 if (font_height
&& pattern_height
&& (font_height
!= pattern_height
))
5762 return (fast_string_match_ignore_case (build_string (regex
),
5763 build_string(font_name_copy
)) >= 0);
5766 /* Callback functions, and a structure holding info they need, for
5767 listing system fonts on W32. We need one set of functions to do the
5768 job properly, but these don't work on NT 3.51 and earlier, so we
5769 have a second set which don't handle character sets properly to
5772 In both cases, there are two passes made. The first pass gets one
5773 font from each family, the second pass lists all the fonts from
5776 typedef struct enumfont_t
5781 XFontStruct
*size_ref
;
5782 Lisp_Object pattern
;
5788 enum_font_maybe_add_to_list (enumfont_t
*, LOGFONT
*, char *, Lisp_Object
);
5792 enum_font_cb2 (lplf
, lptm
, FontType
, lpef
)
5794 NEWTEXTMETRIC
* lptm
;
5798 /* Ignore struck out and underlined versions of fonts. */
5799 if (lplf
->elfLogFont
.lfStrikeOut
|| lplf
->elfLogFont
.lfUnderline
)
5802 /* Only return fonts with names starting with @ if they were
5803 explicitly specified, since Microsoft uses an initial @ to
5804 denote fonts for vertical writing, without providing a more
5805 convenient way of identifying them. */
5806 if (lplf
->elfLogFont
.lfFaceName
[0] == '@'
5807 && lpef
->logfont
.lfFaceName
[0] != '@')
5810 /* Check that the character set matches if it was specified */
5811 if (lpef
->logfont
.lfCharSet
!= DEFAULT_CHARSET
&&
5812 lplf
->elfLogFont
.lfCharSet
!= lpef
->logfont
.lfCharSet
)
5815 if (FontType
== RASTER_FONTTYPE
)
5817 /* DBCS raster fonts have problems displaying, so skip them. */
5818 int charset
= lplf
->elfLogFont
.lfCharSet
;
5819 if (charset
== SHIFTJIS_CHARSET
5820 || charset
== HANGEUL_CHARSET
5821 || charset
== CHINESEBIG5_CHARSET
5822 || charset
== GB2312_CHARSET
5823 #ifdef JOHAB_CHARSET
5824 || charset
== JOHAB_CHARSET
5832 Lisp_Object width
= Qnil
;
5833 Lisp_Object charset_list
= Qnil
;
5834 char *charset
= NULL
;
5836 /* Truetype fonts do not report their true metrics until loaded */
5837 if (FontType
!= RASTER_FONTTYPE
)
5839 if (!NILP (lpef
->pattern
))
5841 /* Scalable fonts are as big as you want them to be. */
5842 lplf
->elfLogFont
.lfHeight
= lpef
->logfont
.lfHeight
;
5843 lplf
->elfLogFont
.lfWidth
= lpef
->logfont
.lfWidth
;
5844 width
= make_number (lpef
->logfont
.lfWidth
);
5848 lplf
->elfLogFont
.lfHeight
= 0;
5849 lplf
->elfLogFont
.lfWidth
= 0;
5853 /* Make sure the height used here is the same as everywhere
5854 else (ie character height, not cell height). */
5855 if (lplf
->elfLogFont
.lfHeight
> 0)
5857 /* lptm can be trusted for RASTER fonts, but not scalable ones. */
5858 if (FontType
== RASTER_FONTTYPE
)
5859 lplf
->elfLogFont
.lfHeight
= lptm
->tmInternalLeading
- lptm
->tmHeight
;
5861 lplf
->elfLogFont
.lfHeight
= -lplf
->elfLogFont
.lfHeight
;
5864 if (!NILP (lpef
->pattern
))
5866 charset
= xlfd_charset_of_font (SDATA (lpef
->pattern
));
5868 /* We already checked charsets above, but DEFAULT_CHARSET
5869 slipped through. So only allow exact matches for DEFAULT_CHARSET. */
5871 && strncmp (charset
, "*-*", 3) != 0
5872 && lpef
->logfont
.lfCharSet
== DEFAULT_CHARSET
5873 && strcmp (charset
, w32_to_x_charset (DEFAULT_CHARSET
)) != 0)
5878 charset_list
= Fcons (build_string (charset
), Qnil
);
5880 charset_list
= w32_to_all_x_charsets (lplf
->elfLogFont
.lfCharSet
);
5882 /* Loop through the charsets. */
5883 for ( ; CONSP (charset_list
); charset_list
= Fcdr (charset_list
))
5885 Lisp_Object this_charset
= Fcar (charset_list
);
5886 charset
= SDATA (this_charset
);
5888 /* List bold and italic variations if w32-enable-synthesized-fonts
5889 is non-nil and this is a plain font. */
5890 if (w32_enable_synthesized_fonts
5891 && lplf
->elfLogFont
.lfWeight
== FW_NORMAL
5892 && lplf
->elfLogFont
.lfItalic
== FALSE
)
5894 enum_font_maybe_add_to_list (lpef
, &(lplf
->elfLogFont
),
5897 lplf
->elfLogFont
.lfWeight
= FW_BOLD
;
5898 enum_font_maybe_add_to_list (lpef
, &(lplf
->elfLogFont
),
5901 lplf
->elfLogFont
.lfItalic
= TRUE
;
5902 enum_font_maybe_add_to_list (lpef
, &(lplf
->elfLogFont
),
5905 lplf
->elfLogFont
.lfWeight
= FW_NORMAL
;
5906 enum_font_maybe_add_to_list (lpef
, &(lplf
->elfLogFont
),
5910 enum_font_maybe_add_to_list (lpef
, &(lplf
->elfLogFont
),
5919 enum_font_maybe_add_to_list (lpef
, logfont
, match_charset
, width
)
5922 char * match_charset
;
5927 if (!w32_to_x_font (logfont
, buf
, 100, match_charset
))
5930 if (NILP (lpef
->pattern
)
5931 || w32_font_match (buf
, SDATA (lpef
->pattern
)))
5933 /* Check if we already listed this font. This may happen if
5934 w32_enable_synthesized_fonts is non-nil, and there are real
5935 bold and italic versions of the font. */
5936 Lisp_Object font_name
= build_string (buf
);
5937 if (NILP (Fmember (font_name
, lpef
->list
)))
5939 Lisp_Object entry
= Fcons (font_name
, width
);
5940 lpef
->list
= Fcons (entry
, lpef
->list
);
5948 enum_font_cb1 (lplf
, lptm
, FontType
, lpef
)
5950 NEWTEXTMETRIC
* lptm
;
5954 return EnumFontFamilies (lpef
->hdc
,
5955 lplf
->elfLogFont
.lfFaceName
,
5956 (FONTENUMPROC
) enum_font_cb2
,
5962 enum_fontex_cb2 (lplf
, lptm
, font_type
, lpef
)
5963 ENUMLOGFONTEX
* lplf
;
5964 NEWTEXTMETRICEX
* lptm
;
5968 /* We are not interested in the extra info we get back from the 'Ex
5969 version - only the fact that we get character set variations
5970 enumerated seperately. */
5971 return enum_font_cb2 ((ENUMLOGFONT
*) lplf
, (NEWTEXTMETRIC
*) lptm
,
5976 enum_fontex_cb1 (lplf
, lptm
, font_type
, lpef
)
5977 ENUMLOGFONTEX
* lplf
;
5978 NEWTEXTMETRICEX
* lptm
;
5982 HMODULE gdi32
= GetModuleHandle ("gdi32.dll");
5983 FARPROC enum_font_families_ex
5984 = GetProcAddress ( gdi32
, "EnumFontFamiliesExA");
5985 /* We don't really expect EnumFontFamiliesEx to disappear once we
5986 get here, so don't bother handling it gracefully. */
5987 if (enum_font_families_ex
== NULL
)
5988 error ("gdi32.dll has disappeared!");
5989 return enum_font_families_ex (lpef
->hdc
,
5991 (FONTENUMPROC
) enum_fontex_cb2
,
5995 /* Interface to fontset handler. (adapted from mw32font.c in Meadow
5996 and xterm.c in Emacs 20.3) */
5998 static Lisp_Object
w32_list_bdf_fonts (Lisp_Object pattern
, int max_names
)
6000 char *fontname
, *ptnstr
;
6001 Lisp_Object list
, tem
, newlist
= Qnil
;
6004 list
= Vw32_bdf_filename_alist
;
6005 ptnstr
= SDATA (pattern
);
6007 for ( ; CONSP (list
); list
= XCDR (list
))
6011 fontname
= SDATA (XCAR (tem
));
6012 else if (STRINGP (tem
))
6013 fontname
= SDATA (tem
);
6017 if (w32_font_match (fontname
, ptnstr
))
6019 newlist
= Fcons (XCAR (tem
), newlist
);
6021 if (max_names
>= 0 && n_fonts
>= max_names
)
6030 /* Return a list of names of available fonts matching PATTERN on frame
6031 F. If SIZE is not 0, it is the size (maximum bound width) of fonts
6032 to be listed. Frame F NULL means we have not yet created any
6033 frame, which means we can't get proper size info, as we don't have
6034 a device context to use for GetTextMetrics.
6035 MAXNAMES sets a limit on how many fonts to match. If MAXNAMES is
6036 negative, then all matching fonts are returned. */
6039 w32_list_fonts (f
, pattern
, size
, maxnames
)
6041 Lisp_Object pattern
;
6045 Lisp_Object patterns
, key
= Qnil
, tem
, tpat
;
6046 Lisp_Object list
= Qnil
, newlist
= Qnil
, second_best
= Qnil
;
6047 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6050 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
6051 if (NILP (patterns
))
6052 patterns
= Fcons (pattern
, Qnil
);
6054 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
6059 tpat
= XCAR (patterns
);
6061 if (!STRINGP (tpat
))
6064 /* Avoid expensive EnumFontFamilies functions if we are not
6065 going to be able to output one of these anyway. */
6066 codepage
= w32_codepage_for_font (SDATA (tpat
));
6067 if (codepage
!= CP_8BIT
&& codepage
!= CP_UNICODE
6068 && codepage
!= CP_DEFAULT
&& codepage
!= CP_UNKNOWN
6069 && !IsValidCodePage(codepage
))
6072 /* See if we cached the result for this particular query.
6073 The cache is an alist of the form:
6074 ((PATTERN (FONTNAME . WIDTH) ...) ...)
6076 if (tem
= XCDR (dpyinfo
->name_list_element
),
6077 !NILP (list
= Fassoc (tpat
, tem
)))
6079 list
= Fcdr_safe (list
);
6080 /* We have a cached list. Don't have to get the list again. */
6085 /* At first, put PATTERN in the cache. */
6090 /* Use EnumFontFamiliesEx where it is available, as it knows
6091 about character sets. Fall back to EnumFontFamilies for
6092 older versions of NT that don't support the 'Ex function. */
6093 x_to_w32_font (SDATA (tpat
), &ef
.logfont
);
6095 LOGFONT font_match_pattern
;
6096 HMODULE gdi32
= GetModuleHandle ("gdi32.dll");
6097 FARPROC enum_font_families_ex
6098 = GetProcAddress ( gdi32
, "EnumFontFamiliesExA");
6100 /* We do our own pattern matching so we can handle wildcards. */
6101 font_match_pattern
.lfFaceName
[0] = 0;
6102 font_match_pattern
.lfPitchAndFamily
= 0;
6103 /* We can use the charset, because if it is a wildcard it will
6104 be DEFAULT_CHARSET anyway. */
6105 font_match_pattern
.lfCharSet
= ef
.logfont
.lfCharSet
;
6107 ef
.hdc
= GetDC (dpyinfo
->root_window
);
6109 if (enum_font_families_ex
)
6110 enum_font_families_ex (ef
.hdc
,
6111 &font_match_pattern
,
6112 (FONTENUMPROC
) enum_fontex_cb1
,
6115 EnumFontFamilies (ef
.hdc
, NULL
, (FONTENUMPROC
) enum_font_cb1
,
6118 ReleaseDC (dpyinfo
->root_window
, ef
.hdc
);
6124 /* Make a list of the fonts we got back.
6125 Store that in the font cache for the display. */
6126 XSETCDR (dpyinfo
->name_list_element
,
6127 Fcons (Fcons (tpat
, list
),
6128 XCDR (dpyinfo
->name_list_element
)));
6131 if (NILP (list
)) continue; /* Try the remaining alternatives. */
6133 newlist
= second_best
= Qnil
;
6135 /* Make a list of the fonts that have the right width. */
6136 for (; CONSP (list
); list
= XCDR (list
))
6143 if (NILP (XCAR (tem
)))
6147 newlist
= Fcons (XCAR (tem
), newlist
);
6149 if (maxnames
>= 0 && n_fonts
>= maxnames
)
6154 if (!INTEGERP (XCDR (tem
)))
6156 /* Since we don't yet know the size of the font, we must
6157 load it and try GetTextMetrics. */
6158 W32FontStruct thisinfo
;
6163 if (!x_to_w32_font (SDATA (XCAR (tem
)), &lf
))
6167 thisinfo
.bdf
= NULL
;
6168 thisinfo
.hfont
= CreateFontIndirect (&lf
);
6169 if (thisinfo
.hfont
== NULL
)
6172 hdc
= GetDC (dpyinfo
->root_window
);
6173 oldobj
= SelectObject (hdc
, thisinfo
.hfont
);
6174 if (GetTextMetrics (hdc
, &thisinfo
.tm
))
6175 XSETCDR (tem
, make_number (FONT_WIDTH (&thisinfo
)));
6177 XSETCDR (tem
, make_number (0));
6178 SelectObject (hdc
, oldobj
);
6179 ReleaseDC (dpyinfo
->root_window
, hdc
);
6180 DeleteObject(thisinfo
.hfont
);
6183 found_size
= XINT (XCDR (tem
));
6184 if (found_size
== size
)
6186 newlist
= Fcons (XCAR (tem
), newlist
);
6188 if (maxnames
>= 0 && n_fonts
>= maxnames
)
6191 /* keep track of the closest matching size in case
6192 no exact match is found. */
6193 else if (found_size
> 0)
6195 if (NILP (second_best
))
6198 else if (found_size
< size
)
6200 if (XINT (XCDR (second_best
)) > size
6201 || XINT (XCDR (second_best
)) < found_size
)
6206 if (XINT (XCDR (second_best
)) > size
6207 && XINT (XCDR (second_best
)) >
6214 if (!NILP (newlist
))
6216 else if (!NILP (second_best
))
6218 newlist
= Fcons (XCAR (second_best
), Qnil
);
6223 /* Include any bdf fonts. */
6224 if (n_fonts
< maxnames
|| maxnames
< 0)
6226 Lisp_Object combined
[2];
6227 combined
[0] = w32_list_bdf_fonts (pattern
, maxnames
- n_fonts
);
6228 combined
[1] = newlist
;
6229 newlist
= Fnconc(2, combined
);
6236 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
6238 w32_get_font_info (f
, font_idx
)
6242 return (FRAME_W32_FONT_TABLE (f
) + font_idx
);
6247 w32_query_font (struct frame
*f
, char *fontname
)
6250 struct font_info
*pfi
;
6252 pfi
= FRAME_W32_FONT_TABLE (f
);
6254 for (i
= 0; i
< one_w32_display_info
.n_fonts
;i
++, pfi
++)
6256 if (stricmp(pfi
->name
, fontname
) == 0) return pfi
;
6262 /* Find a CCL program for a font specified by FONTP, and set the member
6263 `encoder' of the structure. */
6266 w32_find_ccl_program (fontp
)
6267 struct font_info
*fontp
;
6269 Lisp_Object list
, elt
;
6271 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
6275 && STRINGP (XCAR (elt
))
6276 && (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
6282 struct ccl_program
*ccl
6283 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
6285 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
6288 fontp
->font_encoder
= ccl
;
6292 /* directory-files from dired.c. */
6293 Lisp_Object Fdirectory_files
P_((Lisp_Object
, Lisp_Object
, Lisp_Object
, Lisp_Object
));
6296 /* Find BDF files in a specified directory. (use GCPRO when calling,
6297 as this calls lisp to get a directory listing). */
6299 w32_find_bdf_fonts_in_dir (Lisp_Object directory
)
6301 Lisp_Object filelist
, list
= Qnil
;
6304 if (!STRINGP(directory
))
6307 filelist
= Fdirectory_files (directory
, Qt
,
6308 build_string (".*\\.[bB][dD][fF]"), Qt
);
6310 for ( ; CONSP(filelist
); filelist
= XCDR (filelist
))
6312 Lisp_Object filename
= XCAR (filelist
);
6313 if (w32_BDF_to_x_font (SDATA (filename
), fontname
, 100))
6314 store_in_alist (&list
, build_string (fontname
), filename
);
6319 DEFUN ("w32-find-bdf-fonts", Fw32_find_bdf_fonts
, Sw32_find_bdf_fonts
,
6321 doc
: /* Return a list of BDF fonts in DIRECTORY.
6322 The list is suitable for appending to `w32-bdf-filename-alist'.
6323 Fonts which do not contain an xlfd description will not be included
6324 in the list. DIRECTORY may be a list of directories. */)
6326 Lisp_Object directory
;
6328 Lisp_Object list
= Qnil
;
6329 struct gcpro gcpro1
, gcpro2
;
6331 if (!CONSP (directory
))
6332 return w32_find_bdf_fonts_in_dir (directory
);
6334 for ( ; CONSP (directory
); directory
= XCDR (directory
))
6336 Lisp_Object pair
[2];
6339 GCPRO2 (directory
, list
);
6340 pair
[1] = w32_find_bdf_fonts_in_dir( XCAR (directory
) );
6341 list
= Fnconc( 2, pair
);
6348 DEFUN ("xw-color-defined-p", Fxw_color_defined_p
, Sxw_color_defined_p
, 1, 2, 0,
6349 doc
: /* Internal function called by `color-defined-p', which see. */)
6351 Lisp_Object color
, frame
;
6354 FRAME_PTR f
= check_x_frame (frame
);
6356 CHECK_STRING (color
);
6358 if (w32_defined_color (f
, SDATA (color
), &foo
, 0))
6364 DEFUN ("xw-color-values", Fxw_color_values
, Sxw_color_values
, 1, 2, 0,
6365 doc
: /* Internal function called by `color-values', which see. */)
6367 Lisp_Object color
, frame
;
6370 FRAME_PTR f
= check_x_frame (frame
);
6372 CHECK_STRING (color
);
6374 if (w32_defined_color (f
, SDATA (color
), &foo
, 0))
6375 return list3 (make_number ((GetRValue (foo
.pixel
) << 8)
6376 | GetRValue (foo
.pixel
)),
6377 make_number ((GetGValue (foo
.pixel
) << 8)
6378 | GetGValue (foo
.pixel
)),
6379 make_number ((GetBValue (foo
.pixel
) << 8)
6380 | GetBValue (foo
.pixel
)));
6385 DEFUN ("xw-display-color-p", Fxw_display_color_p
, Sxw_display_color_p
, 0, 1, 0,
6386 doc
: /* Internal function called by `display-color-p', which see. */)
6388 Lisp_Object display
;
6390 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6392 if ((dpyinfo
->n_planes
* dpyinfo
->n_cbits
) <= 2)
6398 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p
,
6399 Sx_display_grayscale_p
, 0, 1, 0,
6400 doc
: /* Return t if DISPLAY supports shades of gray.
6401 Note that color displays do support shades of gray.
6402 The optional argument DISPLAY specifies which display to ask about.
6403 DISPLAY should be either a frame or a display name (a string).
6404 If omitted or nil, that stands for the selected frame's display. */)
6406 Lisp_Object display
;
6408 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6410 if ((dpyinfo
->n_planes
* dpyinfo
->n_cbits
) <= 1)
6416 DEFUN ("x-display-pixel-width", Fx_display_pixel_width
,
6417 Sx_display_pixel_width
, 0, 1, 0,
6418 doc
: /* Returns the width in pixels of DISPLAY.
6419 The optional argument DISPLAY specifies which display to ask about.
6420 DISPLAY should be either a frame or a display name (a string).
6421 If omitted or nil, that stands for the selected frame's display. */)
6423 Lisp_Object display
;
6425 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6427 return make_number (dpyinfo
->width
);
6430 DEFUN ("x-display-pixel-height", Fx_display_pixel_height
,
6431 Sx_display_pixel_height
, 0, 1, 0,
6432 doc
: /* Returns the height in pixels of DISPLAY.
6433 The optional argument DISPLAY specifies which display to ask about.
6434 DISPLAY should be either a frame or a display name (a string).
6435 If omitted or nil, that stands for the selected frame's display. */)
6437 Lisp_Object display
;
6439 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6441 return make_number (dpyinfo
->height
);
6444 DEFUN ("x-display-planes", Fx_display_planes
, Sx_display_planes
,
6446 doc
: /* Returns the number of bitplanes of DISPLAY.
6447 The optional argument DISPLAY specifies which display to ask about.
6448 DISPLAY should be either a frame or a display name (a string).
6449 If omitted or nil, that stands for the selected frame's display. */)
6451 Lisp_Object display
;
6453 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6455 return make_number (dpyinfo
->n_planes
* dpyinfo
->n_cbits
);
6458 DEFUN ("x-display-color-cells", Fx_display_color_cells
, Sx_display_color_cells
,
6460 doc
: /* Returns the number of color cells of DISPLAY.
6461 The optional argument DISPLAY specifies which display to ask about.
6462 DISPLAY should be either a frame or a display name (a string).
6463 If omitted or nil, that stands for the selected frame's display. */)
6465 Lisp_Object display
;
6467 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6471 hdc
= GetDC (dpyinfo
->root_window
);
6472 if (dpyinfo
->has_palette
)
6473 cap
= GetDeviceCaps (hdc
, SIZEPALETTE
);
6475 cap
= GetDeviceCaps (hdc
, NUMCOLORS
);
6477 /* We force 24+ bit depths to 24-bit, both to prevent an overflow
6478 and because probably is more meaningful on Windows anyway */
6480 cap
= 1 << min(dpyinfo
->n_planes
* dpyinfo
->n_cbits
, 24);
6482 ReleaseDC (dpyinfo
->root_window
, hdc
);
6484 return make_number (cap
);
6487 DEFUN ("x-server-max-request-size", Fx_server_max_request_size
,
6488 Sx_server_max_request_size
,
6490 doc
: /* Returns the maximum request size of the server of DISPLAY.
6491 The optional argument DISPLAY specifies which display to ask about.
6492 DISPLAY should be either a frame or a display name (a string).
6493 If omitted or nil, that stands for the selected frame's display. */)
6495 Lisp_Object display
;
6497 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6499 return make_number (1);
6502 DEFUN ("x-server-vendor", Fx_server_vendor
, Sx_server_vendor
, 0, 1, 0,
6503 doc
: /* Returns the "vendor ID" string of the W32 system (Microsoft).
6504 The optional argument DISPLAY specifies which display to ask about.
6505 DISPLAY should be either a frame or a display name (a string).
6506 If omitted or nil, that stands for the selected frame's display. */)
6508 Lisp_Object display
;
6510 return build_string ("Microsoft Corp.");
6513 DEFUN ("x-server-version", Fx_server_version
, Sx_server_version
, 0, 1, 0,
6514 doc
: /* Returns the version numbers of the server of DISPLAY.
6515 The value is a list of three integers: the major and minor
6516 version numbers of the X Protocol in use, and the distributor-specific release
6517 number. See also the function `x-server-vendor'.
6519 The optional argument DISPLAY specifies which display to ask about.
6520 DISPLAY should be either a frame or a display name (a string).
6521 If omitted or nil, that stands for the selected frame's display. */)
6523 Lisp_Object display
;
6525 return Fcons (make_number (w32_major_version
),
6526 Fcons (make_number (w32_minor_version
),
6527 Fcons (make_number (w32_build_number
), Qnil
)));
6530 DEFUN ("x-display-screens", Fx_display_screens
, Sx_display_screens
, 0, 1, 0,
6531 doc
: /* Returns the number of screens on the server of DISPLAY.
6532 The optional argument DISPLAY specifies which display to ask about.
6533 DISPLAY should be either a frame or a display name (a string).
6534 If omitted or nil, that stands for the selected frame's display. */)
6536 Lisp_Object display
;
6538 return make_number (1);
6541 DEFUN ("x-display-mm-height", Fx_display_mm_height
,
6542 Sx_display_mm_height
, 0, 1, 0,
6543 doc
: /* Returns the height in millimeters of DISPLAY.
6544 The optional argument DISPLAY specifies which display to ask about.
6545 DISPLAY should be either a frame or a display name (a string).
6546 If omitted or nil, that stands for the selected frame's display. */)
6548 Lisp_Object display
;
6550 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6554 hdc
= GetDC (dpyinfo
->root_window
);
6556 cap
= GetDeviceCaps (hdc
, VERTSIZE
);
6558 ReleaseDC (dpyinfo
->root_window
, hdc
);
6560 return make_number (cap
);
6563 DEFUN ("x-display-mm-width", Fx_display_mm_width
, Sx_display_mm_width
, 0, 1, 0,
6564 doc
: /* Returns the width in millimeters of DISPLAY.
6565 The optional argument DISPLAY specifies which display to ask about.
6566 DISPLAY should be either a frame or a display name (a string).
6567 If omitted or nil, that stands for the selected frame's display. */)
6569 Lisp_Object display
;
6571 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6576 hdc
= GetDC (dpyinfo
->root_window
);
6578 cap
= GetDeviceCaps (hdc
, HORZSIZE
);
6580 ReleaseDC (dpyinfo
->root_window
, hdc
);
6582 return make_number (cap
);
6585 DEFUN ("x-display-backing-store", Fx_display_backing_store
,
6586 Sx_display_backing_store
, 0, 1, 0,
6587 doc
: /* Returns an indication of whether DISPLAY does backing store.
6588 The value may be `always', `when-mapped', or `not-useful'.
6589 The optional argument DISPLAY specifies which display to ask about.
6590 DISPLAY should be either a frame or a display name (a string).
6591 If omitted or nil, that stands for the selected frame's display. */)
6593 Lisp_Object display
;
6595 return intern ("not-useful");
6598 DEFUN ("x-display-visual-class", Fx_display_visual_class
,
6599 Sx_display_visual_class
, 0, 1, 0,
6600 doc
: /* Returns the visual class of DISPLAY.
6601 The value is one of the symbols `static-gray', `gray-scale',
6602 `static-color', `pseudo-color', `true-color', or `direct-color'.
6604 The optional argument DISPLAY specifies which display to ask about.
6605 DISPLAY should be either a frame or a display name (a string).
6606 If omitted or nil, that stands for the selected frame's display. */)
6608 Lisp_Object display
;
6610 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6611 Lisp_Object result
= Qnil
;
6613 if (dpyinfo
->has_palette
)
6614 result
= intern ("pseudo-color");
6615 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
== 1)
6616 result
= intern ("static-grey");
6617 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
== 4)
6618 result
= intern ("static-color");
6619 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
> 8)
6620 result
= intern ("true-color");
6625 DEFUN ("x-display-save-under", Fx_display_save_under
,
6626 Sx_display_save_under
, 0, 1, 0,
6627 doc
: /* Returns t if DISPLAY supports the save-under feature.
6628 The optional argument DISPLAY specifies which display to ask about.
6629 DISPLAY should be either a frame or a display name (a string).
6630 If omitted or nil, that stands for the selected frame's display. */)
6632 Lisp_Object display
;
6639 register struct frame
*f
;
6641 return FRAME_PIXEL_WIDTH (f
);
6646 register struct frame
*f
;
6648 return FRAME_PIXEL_HEIGHT (f
);
6653 register struct frame
*f
;
6655 return FRAME_COLUMN_WIDTH (f
);
6660 register struct frame
*f
;
6662 return FRAME_LINE_HEIGHT (f
);
6667 register struct frame
*f
;
6669 return FRAME_W32_DISPLAY_INFO (f
)->n_planes
;
6672 /* Return the display structure for the display named NAME.
6673 Open a new connection if necessary. */
6675 struct w32_display_info
*
6676 x_display_info_for_name (name
)
6680 struct w32_display_info
*dpyinfo
;
6682 CHECK_STRING (name
);
6684 for (dpyinfo
= &one_w32_display_info
, names
= w32_display_name_list
;
6686 dpyinfo
= dpyinfo
->next
, names
= XCDR (names
))
6689 tem
= Fstring_equal (XCAR (XCAR (names
)), name
);
6694 /* Use this general default value to start with. */
6695 Vx_resource_name
= Vinvocation_name
;
6697 validate_x_resource_name ();
6699 dpyinfo
= w32_term_init (name
, (unsigned char *)0,
6700 (char *) SDATA (Vx_resource_name
));
6703 error ("Cannot connect to server %s", SDATA (name
));
6706 XSETFASTINT (Vwindow_system_version
, 3);
6711 DEFUN ("x-open-connection", Fx_open_connection
, Sx_open_connection
,
6712 1, 3, 0, doc
: /* Open a connection to a server.
6713 DISPLAY is the name of the display to connect to.
6714 Optional second arg XRM-STRING is a string of resources in xrdb format.
6715 If the optional third arg MUST-SUCCEED is non-nil,
6716 terminate Emacs if we can't open the connection. */)
6717 (display
, xrm_string
, must_succeed
)
6718 Lisp_Object display
, xrm_string
, must_succeed
;
6720 unsigned char *xrm_option
;
6721 struct w32_display_info
*dpyinfo
;
6723 /* If initialization has already been done, return now to avoid
6724 overwriting critical parts of one_w32_display_info. */
6728 CHECK_STRING (display
);
6729 if (! NILP (xrm_string
))
6730 CHECK_STRING (xrm_string
);
6733 if (! EQ (Vwindow_system
, intern ("w32")))
6734 error ("Not using Microsoft Windows");
6737 /* Allow color mapping to be defined externally; first look in user's
6738 HOME directory, then in Emacs etc dir for a file called rgb.txt. */
6740 Lisp_Object color_file
;
6741 struct gcpro gcpro1
;
6743 color_file
= build_string("~/rgb.txt");
6745 GCPRO1 (color_file
);
6747 if (NILP (Ffile_readable_p (color_file
)))
6749 Fexpand_file_name (build_string ("rgb.txt"),
6750 Fsymbol_value (intern ("data-directory")));
6752 Vw32_color_map
= Fw32_load_color_file (color_file
);
6756 if (NILP (Vw32_color_map
))
6757 Vw32_color_map
= Fw32_default_color_map ();
6759 /* Merge in system logical colors. */
6760 add_system_logical_colors_to_map (&Vw32_color_map
);
6762 if (! NILP (xrm_string
))
6763 xrm_option
= (unsigned char *) SDATA (xrm_string
);
6765 xrm_option
= (unsigned char *) 0;
6767 /* Use this general default value to start with. */
6768 /* First remove .exe suffix from invocation-name - it looks ugly. */
6770 char basename
[ MAX_PATH
], *str
;
6772 strcpy (basename
, SDATA (Vinvocation_name
));
6773 str
= strrchr (basename
, '.');
6775 Vinvocation_name
= build_string (basename
);
6777 Vx_resource_name
= Vinvocation_name
;
6779 validate_x_resource_name ();
6781 /* This is what opens the connection and sets x_current_display.
6782 This also initializes many symbols, such as those used for input. */
6783 dpyinfo
= w32_term_init (display
, xrm_option
,
6784 (char *) SDATA (Vx_resource_name
));
6788 if (!NILP (must_succeed
))
6789 fatal ("Cannot connect to server %s.\n",
6792 error ("Cannot connect to server %s", SDATA (display
));
6797 XSETFASTINT (Vwindow_system_version
, 3);
6801 DEFUN ("x-close-connection", Fx_close_connection
,
6802 Sx_close_connection
, 1, 1, 0,
6803 doc
: /* Close the connection to DISPLAY's server.
6804 For DISPLAY, specify either a frame or a display name (a string).
6805 If DISPLAY is nil, that stands for the selected frame's display. */)
6807 Lisp_Object display
;
6809 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
6812 if (dpyinfo
->reference_count
> 0)
6813 error ("Display still has frames on it");
6816 /* Free the fonts in the font table. */
6817 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
6818 if (dpyinfo
->font_table
[i
].name
)
6820 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
6821 xfree (dpyinfo
->font_table
[i
].full_name
);
6822 xfree (dpyinfo
->font_table
[i
].name
);
6823 w32_unload_font (dpyinfo
, dpyinfo
->font_table
[i
].font
);
6825 x_destroy_all_bitmaps (dpyinfo
);
6827 x_delete_display (dpyinfo
);
6833 DEFUN ("x-display-list", Fx_display_list
, Sx_display_list
, 0, 0, 0,
6834 doc
: /* Return the list of display names that Emacs has connections to. */)
6837 Lisp_Object tail
, result
;
6840 for (tail
= w32_display_name_list
; CONSP (tail
); tail
= XCDR (tail
))
6841 result
= Fcons (XCAR (XCAR (tail
)), result
);
6846 DEFUN ("x-synchronize", Fx_synchronize
, Sx_synchronize
, 1, 2, 0,
6847 doc
: /* This is a noop on W32 systems. */)
6849 Lisp_Object display
, on
;
6856 /***********************************************************************
6858 ***********************************************************************/
6860 DEFUN ("x-change-window-property", Fx_change_window_property
,
6861 Sx_change_window_property
, 2, 6, 0,
6862 doc
: /* Change window property PROP to VALUE on the X window of FRAME.
6863 VALUE may be a string or a list of conses, numbers and/or strings.
6864 If an element in the list is a string, it is converted to
6865 an Atom and the value of the Atom is used. If an element is a cons,
6866 it is converted to a 32 bit number where the car is the 16 top bits and the
6867 cdr is the lower 16 bits.
6868 FRAME nil or omitted means use the selected frame.
6869 If TYPE is given and non-nil, it is the name of the type of VALUE.
6870 If TYPE is not given or nil, the type is STRING.
6871 FORMAT gives the size in bits of each element if VALUE is a list.
6872 It must be one of 8, 16 or 32.
6873 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
6874 If OUTER_P is non-nil, the property is changed for the outer X window of
6875 FRAME. Default is to change on the edit X window.
6878 (prop
, value
, frame
, type
, format
, outer_p
)
6879 Lisp_Object prop
, value
, frame
, type
, format
, outer_p
;
6881 #if 0 /* TODO : port window properties to W32 */
6882 struct frame
*f
= check_x_frame (frame
);
6885 CHECK_STRING (prop
);
6886 CHECK_STRING (value
);
6889 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
6890 XChangeProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
6891 prop_atom
, XA_STRING
, 8, PropModeReplace
,
6892 SDATA (value
), SCHARS (value
));
6894 /* Make sure the property is set when we return. */
6895 XFlush (FRAME_W32_DISPLAY (f
));
6904 DEFUN ("x-delete-window-property", Fx_delete_window_property
,
6905 Sx_delete_window_property
, 1, 2, 0,
6906 doc
: /* Remove window property PROP from X window of FRAME.
6907 FRAME nil or omitted means use the selected frame. Value is PROP. */)
6909 Lisp_Object prop
, frame
;
6911 #if 0 /* TODO : port window properties to W32 */
6913 struct frame
*f
= check_x_frame (frame
);
6916 CHECK_STRING (prop
);
6918 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
6919 XDeleteProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
), prop_atom
);
6921 /* Make sure the property is removed when we return. */
6922 XFlush (FRAME_W32_DISPLAY (f
));
6930 DEFUN ("x-window-property", Fx_window_property
, Sx_window_property
,
6932 doc
: /* Value is the value of window property PROP on FRAME.
6933 If FRAME is nil or omitted, use the selected frame. Value is nil
6934 if FRAME hasn't a property with name PROP or if PROP has no string
6937 Lisp_Object prop
, frame
;
6939 #if 0 /* TODO : port window properties to W32 */
6941 struct frame
*f
= check_x_frame (frame
);
6944 Lisp_Object prop_value
= Qnil
;
6945 char *tmp_data
= NULL
;
6948 unsigned long actual_size
, bytes_remaining
;
6950 CHECK_STRING (prop
);
6952 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
6953 rc
= XGetWindowProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
6954 prop_atom
, 0, 0, False
, XA_STRING
,
6955 &actual_type
, &actual_format
, &actual_size
,
6956 &bytes_remaining
, (unsigned char **) &tmp_data
);
6959 int size
= bytes_remaining
;
6964 rc
= XGetWindowProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
6965 prop_atom
, 0, bytes_remaining
,
6967 &actual_type
, &actual_format
,
6968 &actual_size
, &bytes_remaining
,
6969 (unsigned char **) &tmp_data
);
6971 prop_value
= make_string (tmp_data
, size
);
6986 /***********************************************************************
6988 ***********************************************************************/
6990 /* If non-null, an asynchronous timer that, when it expires, displays
6991 an hourglass cursor on all frames. */
6993 static struct atimer
*hourglass_atimer
;
6995 /* Non-zero means an hourglass cursor is currently shown. */
6997 static int hourglass_shown_p
;
6999 /* Number of seconds to wait before displaying an hourglass cursor. */
7001 static Lisp_Object Vhourglass_delay
;
7003 /* Default number of seconds to wait before displaying an hourglass
7006 #define DEFAULT_HOURGLASS_DELAY 1
7008 /* Function prototypes. */
7010 static void show_hourglass
P_ ((struct atimer
*));
7011 static void hide_hourglass
P_ ((void));
7014 /* Cancel a currently active hourglass timer, and start a new one. */
7019 #if 0 /* TODO: cursor shape changes. */
7021 int secs
, usecs
= 0;
7023 cancel_hourglass ();
7025 if (INTEGERP (Vhourglass_delay
)
7026 && XINT (Vhourglass_delay
) > 0)
7027 secs
= XFASTINT (Vhourglass_delay
);
7028 else if (FLOATP (Vhourglass_delay
)
7029 && XFLOAT_DATA (Vhourglass_delay
) > 0)
7032 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
7033 secs
= XFASTINT (tem
);
7034 usecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000000;
7037 secs
= DEFAULT_HOURGLASS_DELAY
;
7039 EMACS_SET_SECS_USECS (delay
, secs
, usecs
);
7040 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
7041 show_hourglass
, NULL
);
7046 /* Cancel the hourglass cursor timer if active, hide an hourglass
7052 if (hourglass_atimer
)
7054 cancel_atimer (hourglass_atimer
);
7055 hourglass_atimer
= NULL
;
7058 if (hourglass_shown_p
)
7063 /* Timer function of hourglass_atimer. TIMER is equal to
7066 Display an hourglass cursor on all frames by mapping the frames'
7067 hourglass_window. Set the hourglass_p flag in the frames'
7068 output_data.x structure to indicate that an hourglass cursor is
7069 shown on the frames. */
7072 show_hourglass (timer
)
7073 struct atimer
*timer
;
7075 #if 0 /* TODO: cursor shape changes. */
7076 /* The timer implementation will cancel this timer automatically
7077 after this function has run. Set hourglass_atimer to null
7078 so that we know the timer doesn't have to be canceled. */
7079 hourglass_atimer
= NULL
;
7081 if (!hourglass_shown_p
)
7083 Lisp_Object rest
, frame
;
7087 FOR_EACH_FRAME (rest
, frame
)
7088 if (FRAME_W32_P (XFRAME (frame
)))
7090 struct frame
*f
= XFRAME (frame
);
7092 f
->output_data
.w32
->hourglass_p
= 1;
7094 if (!f
->output_data
.w32
->hourglass_window
)
7096 unsigned long mask
= CWCursor
;
7097 XSetWindowAttributes attrs
;
7099 attrs
.cursor
= f
->output_data
.w32
->hourglass_cursor
;
7101 f
->output_data
.w32
->hourglass_window
7102 = XCreateWindow (FRAME_X_DISPLAY (f
),
7103 FRAME_OUTER_WINDOW (f
),
7104 0, 0, 32000, 32000, 0, 0,
7110 XMapRaised (FRAME_X_DISPLAY (f
),
7111 f
->output_data
.w32
->hourglass_window
);
7112 XFlush (FRAME_X_DISPLAY (f
));
7115 hourglass_shown_p
= 1;
7122 /* Hide the hourglass cursor on all frames, if it is currently shown. */
7127 #if 0 /* TODO: cursor shape changes. */
7128 if (hourglass_shown_p
)
7130 Lisp_Object rest
, frame
;
7133 FOR_EACH_FRAME (rest
, frame
)
7135 struct frame
*f
= XFRAME (frame
);
7138 /* Watch out for newly created frames. */
7139 && f
->output_data
.x
->hourglass_window
)
7141 XUnmapWindow (FRAME_X_DISPLAY (f
),
7142 f
->output_data
.x
->hourglass_window
);
7143 /* Sync here because XTread_socket looks at the
7144 hourglass_p flag that is reset to zero below. */
7145 XSync (FRAME_X_DISPLAY (f
), False
);
7146 f
->output_data
.x
->hourglass_p
= 0;
7150 hourglass_shown_p
= 0;
7158 /***********************************************************************
7160 ***********************************************************************/
7162 static Lisp_Object x_create_tip_frame
P_ ((struct w32_display_info
*,
7163 Lisp_Object
, Lisp_Object
));
7164 static void compute_tip_xy
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
,
7165 Lisp_Object
, int, int, int *, int *));
7167 /* The frame of a currently visible tooltip. */
7169 Lisp_Object tip_frame
;
7171 /* If non-nil, a timer started that hides the last tooltip when it
7174 Lisp_Object tip_timer
;
7177 /* If non-nil, a vector of 3 elements containing the last args
7178 with which x-show-tip was called. See there. */
7180 Lisp_Object last_show_tip_args
;
7182 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
7184 Lisp_Object Vx_max_tooltip_size
;
7188 unwind_create_tip_frame (frame
)
7191 Lisp_Object deleted
;
7193 deleted
= unwind_create_frame (frame
);
7194 if (EQ (deleted
, Qt
))
7204 /* Create a frame for a tooltip on the display described by DPYINFO.
7205 PARMS is a list of frame parameters. TEXT is the string to
7206 display in the tip frame. Value is the frame.
7208 Note that functions called here, esp. x_default_parameter can
7209 signal errors, for instance when a specified color name is
7210 undefined. We have to make sure that we're in a consistent state
7211 when this happens. */
7214 x_create_tip_frame (dpyinfo
, parms
, text
)
7215 struct w32_display_info
*dpyinfo
;
7216 Lisp_Object parms
, text
;
7219 Lisp_Object frame
, tem
;
7221 long window_prompting
= 0;
7223 int count
= SPECPDL_INDEX ();
7224 struct gcpro gcpro1
, gcpro2
, gcpro3
;
7226 int face_change_count_before
= face_change_count
;
7228 struct buffer
*old_buffer
;
7232 /* Use this general default value to start with until we know if
7233 this frame has a specified name. */
7234 Vx_resource_name
= Vinvocation_name
;
7237 kb
= dpyinfo
->terminal
->kboard
;
7239 kb
= &the_only_kboard
;
7242 /* Get the name of the frame to use for resource lookup. */
7243 name
= w32_get_arg (parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
7245 && !EQ (name
, Qunbound
)
7247 error ("Invalid frame name--not a string or nil");
7248 Vx_resource_name
= name
;
7251 GCPRO3 (parms
, name
, frame
);
7252 /* Make a frame without minibuffer nor mode-line. */
7254 f
->wants_modeline
= 0;
7255 XSETFRAME (frame
, f
);
7257 buffer
= Fget_buffer_create (build_string (" *tip*"));
7258 Fset_window_buffer (FRAME_ROOT_WINDOW (f
), buffer
, Qnil
);
7259 old_buffer
= current_buffer
;
7260 set_buffer_internal_1 (XBUFFER (buffer
));
7261 current_buffer
->truncate_lines
= Qnil
;
7262 specbind (Qinhibit_read_only
, Qt
);
7263 specbind (Qinhibit_modification_hooks
, Qt
);
7266 set_buffer_internal_1 (old_buffer
);
7268 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
7269 record_unwind_protect (unwind_create_tip_frame
, frame
);
7271 /* By setting the output method, we're essentially saying that
7272 the frame is live, as per FRAME_LIVE_P. If we get a signal
7273 from this point on, x_destroy_window might screw up reference
7275 f
->terminal
= dpyinfo
->terminal
;
7276 f
->terminal
->reference_count
++;
7277 f
->output_method
= output_w32
;
7278 f
->output_data
.w32
=
7279 (struct w32_output
*) xmalloc (sizeof (struct w32_output
));
7280 bzero (f
->output_data
.w32
, sizeof (struct w32_output
));
7282 FRAME_FONTSET (f
) = -1;
7283 f
->icon_name
= Qnil
;
7285 #if 0 /* GLYPH_DEBUG TODO: image support. */
7286 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
7287 dpyinfo_refcount
= dpyinfo
->reference_count
;
7288 #endif /* GLYPH_DEBUG */
7290 FRAME_KBOARD (f
) = kb
;
7292 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
7293 f
->output_data
.w32
->explicit_parent
= 0;
7295 /* Set the name; the functions to which we pass f expect the name to
7297 if (EQ (name
, Qunbound
) || NILP (name
))
7299 f
->name
= build_string (dpyinfo
->w32_id_name
);
7300 f
->explicit_name
= 0;
7305 f
->explicit_name
= 1;
7306 /* use the frame's title when getting resources for this frame. */
7307 specbind (Qx_resource_name
, name
);
7310 /* Extract the window parameters from the supplied values
7311 that are needed to determine window geometry. */
7315 font
= w32_get_arg (parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
7318 /* First, try whatever font the caller has specified. */
7321 tem
= Fquery_fontset (font
, Qnil
);
7323 font
= x_new_fontset (f
, SDATA (tem
));
7325 font
= x_new_font (f
, SDATA (font
));
7328 /* Try out a font which we hope has bold and italic variations. */
7329 if (!STRINGP (font
))
7330 font
= x_new_font (f
, "-*-Courier New-normal-r-*-*-*-100-*-*-c-*-iso8859-1");
7331 if (! STRINGP (font
))
7332 font
= x_new_font (f
, "-*-Courier-normal-r-*-*-13-*-*-*-c-*-iso8859-1");
7333 /* If those didn't work, look for something which will at least work. */
7334 if (! STRINGP (font
))
7335 font
= x_new_font (f
, "-*-Fixedsys-normal-r-*-*-12-*-*-*-c-*-iso8859-1");
7337 if (! STRINGP (font
))
7338 font
= build_string ("Fixedsys");
7340 x_default_parameter (f
, parms
, Qfont
, font
,
7341 "font", "Font", RES_TYPE_STRING
);
7344 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
7345 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
7346 /* This defaults to 2 in order to match xterm. We recognize either
7347 internalBorderWidth or internalBorder (which is what xterm calls
7349 if (NILP (Fassq (Qinternal_border_width
, parms
)))
7353 value
= w32_get_arg (parms
, Qinternal_border_width
,
7354 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
7355 if (! EQ (value
, Qunbound
))
7356 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
7359 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
7360 "internalBorderWidth", "internalBorderWidth",
7363 /* Also do the stuff which must be set before the window exists. */
7364 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
7365 "foreground", "Foreground", RES_TYPE_STRING
);
7366 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
7367 "background", "Background", RES_TYPE_STRING
);
7368 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
7369 "pointerColor", "Foreground", RES_TYPE_STRING
);
7370 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
7371 "cursorColor", "Foreground", RES_TYPE_STRING
);
7372 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
7373 "borderColor", "BorderColor", RES_TYPE_STRING
);
7375 /* Init faces before x_default_parameter is called for scroll-bar
7376 parameters because that function calls x_set_scroll_bar_width,
7377 which calls change_frame_size, which calls Fset_window_buffer,
7378 which runs hooks, which call Fvertical_motion. At the end, we
7379 end up in init_iterator with a null face cache, which should not
7381 init_frame_faces (f
);
7383 f
->output_data
.w32
->dwStyle
= WS_BORDER
| WS_POPUP
| WS_DISABLED
;
7384 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
7386 window_prompting
= x_figure_window_size (f
, parms
, 0);
7388 /* No fringes on tip frame. */
7390 f
->left_fringe_width
= 0;
7391 f
->right_fringe_width
= 0;
7394 my_create_tip_window (f
);
7399 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
7400 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
7401 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
7402 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
7403 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
7404 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
7406 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
7407 Change will not be effected unless different from the current
7409 width
= FRAME_COLS (f
);
7410 height
= FRAME_LINES (f
);
7411 FRAME_LINES (f
) = 0;
7412 SET_FRAME_COLS (f
, 0);
7413 change_frame_size (f
, height
, width
, 1, 0, 0);
7415 /* Add `tooltip' frame parameter's default value. */
7416 if (NILP (Fframe_parameter (frame
, intern ("tooltip"))))
7417 Fmodify_frame_parameters (frame
, Fcons (Fcons (intern ("tooltip"), Qt
),
7420 /* Set up faces after all frame parameters are known. This call
7421 also merges in face attributes specified for new frames.
7423 Frame parameters may be changed if .Xdefaults contains
7424 specifications for the default font. For example, if there is an
7425 `Emacs.default.attributeBackground: pink', the `background-color'
7426 attribute of the frame get's set, which let's the internal border
7427 of the tooltip frame appear in pink. Prevent this. */
7429 Lisp_Object bg
= Fframe_parameter (frame
, Qbackground_color
);
7431 /* Set tip_frame here, so that */
7433 call1 (Qface_set_after_frame_default
, frame
);
7435 if (!EQ (bg
, Fframe_parameter (frame
, Qbackground_color
)))
7436 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qbackground_color
, bg
),
7444 /* It is now ok to make the frame official even if we get an error
7445 below. And the frame needs to be on Vframe_list or making it
7446 visible won't work. */
7447 Vframe_list
= Fcons (frame
, Vframe_list
);
7449 /* Now that the frame is official, it counts as a reference to
7451 FRAME_W32_DISPLAY_INFO (f
)->reference_count
++;
7453 /* Setting attributes of faces of the tooltip frame from resources
7454 and similar will increment face_change_count, which leads to the
7455 clearing of all current matrices. Since this isn't necessary
7456 here, avoid it by resetting face_change_count to the value it
7457 had before we created the tip frame. */
7458 face_change_count
= face_change_count_before
;
7460 /* Discard the unwind_protect. */
7461 return unbind_to (count
, frame
);
7465 /* Compute where to display tip frame F. PARMS is the list of frame
7466 parameters for F. DX and DY are specified offsets from the current
7467 location of the mouse. WIDTH and HEIGHT are the width and height
7468 of the tooltip. Return coordinates relative to the root window of
7469 the display in *ROOT_X, and *ROOT_Y. */
7472 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, root_x
, root_y
)
7474 Lisp_Object parms
, dx
, dy
;
7476 int *root_x
, *root_y
;
7478 Lisp_Object left
, top
;
7480 /* User-specified position? */
7481 left
= Fcdr (Fassq (Qleft
, parms
));
7482 top
= Fcdr (Fassq (Qtop
, parms
));
7484 /* Move the tooltip window where the mouse pointer is. Resize and
7486 if (!INTEGERP (left
) || !INTEGERP (top
))
7498 *root_y
= XINT (top
);
7499 else if (*root_y
+ XINT (dy
) <= 0)
7500 *root_y
= 0; /* Can happen for negative dy */
7501 else if (*root_y
+ XINT (dy
) + height
<= FRAME_W32_DISPLAY_INFO (f
)->height
)
7502 /* It fits below the pointer */
7503 *root_y
+= XINT (dy
);
7504 else if (height
+ XINT (dy
) <= *root_y
)
7505 /* It fits above the pointer. */
7506 *root_y
-= height
+ XINT (dy
);
7508 /* Put it on the top. */
7511 if (INTEGERP (left
))
7512 *root_x
= XINT (left
);
7513 else if (*root_x
+ XINT (dx
) <= 0)
7514 *root_x
= 0; /* Can happen for negative dx */
7515 else if (*root_x
+ XINT (dx
) + width
<= FRAME_W32_DISPLAY_INFO (f
)->width
)
7516 /* It fits to the right of the pointer. */
7517 *root_x
+= XINT (dx
);
7518 else if (width
+ XINT (dx
) <= *root_x
)
7519 /* It fits to the left of the pointer. */
7520 *root_x
-= width
+ XINT (dx
);
7522 /* Put it left justified on the screen -- it ought to fit that way. */
7527 DEFUN ("x-show-tip", Fx_show_tip
, Sx_show_tip
, 1, 6, 0,
7528 doc
: /* Show STRING in a \"tooltip\" window on frame FRAME.
7529 A tooltip window is a small window displaying a string.
7531 This is an internal function; Lisp code should call `tooltip-show'.
7533 FRAME nil or omitted means use the selected frame.
7535 PARMS is an optional list of frame parameters which can be
7536 used to change the tooltip's appearance.
7538 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
7539 means use the default timeout of 5 seconds.
7541 If the list of frame parameters PARMS contains a `left' parameter,
7542 the tooltip is displayed at that x-position. Otherwise it is
7543 displayed at the mouse position, with offset DX added (default is 5 if
7544 DX isn't specified). Likewise for the y-position; if a `top' frame
7545 parameter is specified, it determines the y-position of the tooltip
7546 window, otherwise it is displayed at the mouse position, with offset
7547 DY added (default is -10).
7549 A tooltip's maximum size is specified by `x-max-tooltip-size'.
7550 Text larger than the specified size is clipped. */)
7551 (string
, frame
, parms
, timeout
, dx
, dy
)
7552 Lisp_Object string
, frame
, parms
, timeout
, dx
, dy
;
7557 struct buffer
*old_buffer
;
7558 struct text_pos pos
;
7559 int i
, width
, height
;
7560 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
7561 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
7562 int count
= SPECPDL_INDEX ();
7564 specbind (Qinhibit_redisplay
, Qt
);
7566 GCPRO4 (string
, parms
, frame
, timeout
);
7568 CHECK_STRING (string
);
7569 f
= check_x_frame (frame
);
7571 timeout
= make_number (5);
7573 CHECK_NATNUM (timeout
);
7576 dx
= make_number (5);
7581 dy
= make_number (-10);
7585 if (NILP (last_show_tip_args
))
7586 last_show_tip_args
= Fmake_vector (make_number (3), Qnil
);
7588 if (!NILP (tip_frame
))
7590 Lisp_Object last_string
= AREF (last_show_tip_args
, 0);
7591 Lisp_Object last_frame
= AREF (last_show_tip_args
, 1);
7592 Lisp_Object last_parms
= AREF (last_show_tip_args
, 2);
7594 if (EQ (frame
, last_frame
)
7595 && !NILP (Fequal (last_string
, string
))
7596 && !NILP (Fequal (last_parms
, parms
)))
7598 struct frame
*f
= XFRAME (tip_frame
);
7600 /* Only DX and DY have changed. */
7601 if (!NILP (tip_timer
))
7603 Lisp_Object timer
= tip_timer
;
7605 call1 (Qcancel_timer
, timer
);
7609 compute_tip_xy (f
, parms
, dx
, dy
, FRAME_PIXEL_WIDTH (f
),
7610 FRAME_PIXEL_HEIGHT (f
), &root_x
, &root_y
);
7612 /* Put tooltip in topmost group and in position. */
7613 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOPMOST
,
7614 root_x
, root_y
, 0, 0,
7615 SWP_NOSIZE
| SWP_NOACTIVATE
);
7617 /* Ensure tooltip is on top of other topmost windows (eg menus). */
7618 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOP
,
7620 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
7627 /* Hide a previous tip, if any. */
7630 ASET (last_show_tip_args
, 0, string
);
7631 ASET (last_show_tip_args
, 1, frame
);
7632 ASET (last_show_tip_args
, 2, parms
);
7634 /* Add default values to frame parameters. */
7635 if (NILP (Fassq (Qname
, parms
)))
7636 parms
= Fcons (Fcons (Qname
, build_string ("tooltip")), parms
);
7637 if (NILP (Fassq (Qinternal_border_width
, parms
)))
7638 parms
= Fcons (Fcons (Qinternal_border_width
, make_number (3)), parms
);
7639 if (NILP (Fassq (Qborder_width
, parms
)))
7640 parms
= Fcons (Fcons (Qborder_width
, make_number (1)), parms
);
7641 if (NILP (Fassq (Qborder_color
, parms
)))
7642 parms
= Fcons (Fcons (Qborder_color
, build_string ("lightyellow")), parms
);
7643 if (NILP (Fassq (Qbackground_color
, parms
)))
7644 parms
= Fcons (Fcons (Qbackground_color
, build_string ("lightyellow")),
7647 /* Block input until the tip has been fully drawn, to avoid crashes
7648 when drawing tips in menus. */
7651 /* Create a frame for the tooltip, and record it in the global
7652 variable tip_frame. */
7653 frame
= x_create_tip_frame (FRAME_W32_DISPLAY_INFO (f
), parms
, string
);
7656 /* Set up the frame's root window. */
7657 w
= XWINDOW (FRAME_ROOT_WINDOW (f
));
7658 w
->left_col
= w
->top_line
= make_number (0);
7660 if (CONSP (Vx_max_tooltip_size
)
7661 && INTEGERP (XCAR (Vx_max_tooltip_size
))
7662 && XINT (XCAR (Vx_max_tooltip_size
)) > 0
7663 && INTEGERP (XCDR (Vx_max_tooltip_size
))
7664 && XINT (XCDR (Vx_max_tooltip_size
)) > 0)
7666 w
->total_cols
= XCAR (Vx_max_tooltip_size
);
7667 w
->total_lines
= XCDR (Vx_max_tooltip_size
);
7671 w
->total_cols
= make_number (80);
7672 w
->total_lines
= make_number (40);
7675 FRAME_TOTAL_COLS (f
) = XINT (w
->total_cols
);
7677 w
->pseudo_window_p
= 1;
7679 /* Display the tooltip text in a temporary buffer. */
7680 old_buffer
= current_buffer
;
7681 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f
))->buffer
));
7682 current_buffer
->truncate_lines
= Qnil
;
7683 clear_glyph_matrix (w
->desired_matrix
);
7684 clear_glyph_matrix (w
->current_matrix
);
7685 SET_TEXT_POS (pos
, BEGV
, BEGV_BYTE
);
7686 try_window (FRAME_ROOT_WINDOW (f
), pos
, 0);
7688 /* Compute width and height of the tooltip. */
7690 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
7692 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
7696 /* Stop at the first empty row at the end. */
7697 if (!row
->enabled_p
|| !row
->displays_text_p
)
7700 /* Let the row go over the full width of the frame. */
7701 row
->full_width_p
= 1;
7703 #ifdef TODO /* Investigate why some fonts need more width than is
7704 calculated for some tooltips. */
7705 /* There's a glyph at the end of rows that is use to place
7706 the cursor there. Don't include the width of this glyph. */
7707 if (row
->used
[TEXT_AREA
])
7709 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
7710 row_width
= row
->pixel_width
- last
->pixel_width
;
7714 row_width
= row
->pixel_width
;
7716 /* TODO: find why tips do not draw along baseline as instructed. */
7717 height
+= row
->height
;
7718 width
= max (width
, row_width
);
7721 /* Add the frame's internal border to the width and height the X
7722 window should have. */
7723 height
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
7724 width
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
7726 /* Move the tooltip window where the mouse pointer is. Resize and
7728 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, &root_x
, &root_y
);
7731 /* Adjust Window size to take border into account. */
7733 rect
.left
= rect
.top
= 0;
7735 rect
.bottom
= height
;
7736 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
7737 FRAME_EXTERNAL_MENU_BAR (f
));
7739 /* Position and size tooltip, and put it in the topmost group.
7740 The add-on of 3 to the 5th argument is a kludge: without it,
7741 some fonts cause the last character of the tip to be truncated,
7742 for some obscure reason. */
7743 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOPMOST
,
7744 root_x
, root_y
, rect
.right
- rect
.left
+ 3,
7745 rect
.bottom
- rect
.top
, SWP_NOACTIVATE
);
7747 /* Ensure tooltip is on top of other topmost windows (eg menus). */
7748 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOP
,
7750 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
7752 /* Let redisplay know that we have made the frame visible already. */
7753 f
->async_visible
= 1;
7755 ShowWindow (FRAME_W32_WINDOW (f
), SW_SHOWNOACTIVATE
);
7758 /* Draw into the window. */
7759 w
->must_be_updated_p
= 1;
7760 update_single_window (w
, 1);
7764 /* Restore original current buffer. */
7765 set_buffer_internal_1 (old_buffer
);
7766 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
7769 /* Let the tip disappear after timeout seconds. */
7770 tip_timer
= call3 (intern ("run-at-time"), timeout
, Qnil
,
7771 intern ("x-hide-tip"));
7774 return unbind_to (count
, Qnil
);
7778 DEFUN ("x-hide-tip", Fx_hide_tip
, Sx_hide_tip
, 0, 0, 0,
7779 doc
: /* Hide the current tooltip window, if there is any.
7780 Value is t if tooltip was open, nil otherwise. */)
7784 Lisp_Object deleted
, frame
, timer
;
7785 struct gcpro gcpro1
, gcpro2
;
7787 /* Return quickly if nothing to do. */
7788 if (NILP (tip_timer
) && NILP (tip_frame
))
7793 GCPRO2 (frame
, timer
);
7794 tip_frame
= tip_timer
= deleted
= Qnil
;
7796 count
= SPECPDL_INDEX ();
7797 specbind (Qinhibit_redisplay
, Qt
);
7798 specbind (Qinhibit_quit
, Qt
);
7801 call1 (Qcancel_timer
, timer
);
7805 Fdelete_frame (frame
, Qnil
);
7810 return unbind_to (count
, deleted
);
7815 /***********************************************************************
7816 File selection dialog
7817 ***********************************************************************/
7818 extern Lisp_Object Qfile_name_history
;
7820 /* Callback for altering the behaviour of the Open File dialog.
7821 Makes the Filename text field contain "Current Directory" and be
7822 read-only when "Directories" is selected in the filter. This
7823 allows us to work around the fact that the standard Open File
7824 dialog does not support directories. */
7826 file_dialog_callback (hwnd
, msg
, wParam
, lParam
)
7832 if (msg
== WM_NOTIFY
)
7834 OFNOTIFY
* notify
= (OFNOTIFY
*)lParam
;
7835 /* Detect when the Filter dropdown is changed. */
7836 if (notify
->hdr
.code
== CDN_TYPECHANGE
7837 || notify
->hdr
.code
== CDN_INITDONE
)
7839 HWND dialog
= GetParent (hwnd
);
7840 HWND edit_control
= GetDlgItem (dialog
, FILE_NAME_TEXT_FIELD
);
7842 /* Directories is in index 2. */
7843 if (notify
->lpOFN
->nFilterIndex
== 2)
7845 CommDlg_OpenSave_SetControlText (dialog
, FILE_NAME_TEXT_FIELD
,
7846 "Current Directory");
7847 EnableWindow (edit_control
, FALSE
);
7851 /* Don't override default filename on init done. */
7852 if (notify
->hdr
.code
== CDN_TYPECHANGE
)
7853 CommDlg_OpenSave_SetControlText (dialog
,
7854 FILE_NAME_TEXT_FIELD
, "");
7855 EnableWindow (edit_control
, TRUE
);
7862 /* Since we compile with _WIN32_WINNT set to 0x0400 (for NT4 compatibility)
7863 we end up with the old file dialogs. Define a big enough struct for the
7864 new dialog to trick GetOpenFileName into giving us the new dialogs on
7865 Windows 2000 and XP. */
7868 OPENFILENAME real_details
;
7875 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 5, 0,
7876 doc
: /* Read file name, prompting with PROMPT in directory DIR.
7877 Use a file selection dialog.
7878 Select DEFAULT-FILENAME in the dialog's file selection box, if
7879 specified. Ensure that file exists if MUSTMATCH is non-nil.
7880 If ONLY-DIR-P is non-nil, the user can only select directories. */)
7881 (prompt
, dir
, default_filename
, mustmatch
, only_dir_p
)
7882 Lisp_Object prompt
, dir
, default_filename
, mustmatch
, only_dir_p
;
7884 struct frame
*f
= SELECTED_FRAME ();
7885 Lisp_Object file
= Qnil
;
7886 int count
= SPECPDL_INDEX ();
7887 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
7888 char filename
[MAX_PATH
+ 1];
7889 char init_dir
[MAX_PATH
+ 1];
7890 int default_filter_index
= 1; /* 1: All Files, 2: Directories only */
7892 GCPRO6 (prompt
, dir
, default_filename
, mustmatch
, only_dir_p
, file
);
7893 CHECK_STRING (prompt
);
7896 /* Create the dialog with PROMPT as title, using DIR as initial
7897 directory and using "*" as pattern. */
7898 dir
= Fexpand_file_name (dir
, Qnil
);
7899 strncpy (init_dir
, SDATA (ENCODE_FILE (dir
)), MAX_PATH
);
7900 init_dir
[MAX_PATH
] = '\0';
7901 unixtodos_filename (init_dir
);
7903 if (STRINGP (default_filename
))
7905 char *file_name_only
;
7906 char *full_path_name
= SDATA (ENCODE_FILE (default_filename
));
7908 unixtodos_filename (full_path_name
);
7910 file_name_only
= strrchr (full_path_name
, '\\');
7911 if (!file_name_only
)
7912 file_name_only
= full_path_name
;
7916 strncpy (filename
, file_name_only
, MAX_PATH
);
7917 filename
[MAX_PATH
] = '\0';
7923 NEWOPENFILENAME new_file_details
;
7924 BOOL file_opened
= FALSE
;
7925 OPENFILENAME
* file_details
= &new_file_details
.real_details
;
7927 /* Prevent redisplay. */
7928 specbind (Qinhibit_redisplay
, Qt
);
7931 bzero (&new_file_details
, sizeof (new_file_details
));
7932 /* Apparently NT4 crashes if you give it an unexpected size.
7933 I'm not sure about Windows 9x, so play it safe. */
7934 if (w32_major_version
> 4 && w32_major_version
< 95)
7935 file_details
->lStructSize
= sizeof (NEWOPENFILENAME
);
7937 file_details
->lStructSize
= sizeof (OPENFILENAME
);
7939 file_details
->hwndOwner
= FRAME_W32_WINDOW (f
);
7940 /* Undocumented Bug in Common File Dialog:
7941 If a filter is not specified, shell links are not resolved. */
7942 file_details
->lpstrFilter
= "All Files (*.*)\0*.*\0Directories\0*|*\0\0";
7943 file_details
->lpstrFile
= filename
;
7944 file_details
->nMaxFile
= sizeof (filename
);
7945 file_details
->lpstrInitialDir
= init_dir
;
7946 file_details
->lpstrTitle
= SDATA (prompt
);
7948 if (! NILP (only_dir_p
))
7949 default_filter_index
= 2;
7951 file_details
->nFilterIndex
= default_filter_index
;
7953 file_details
->Flags
= (OFN_HIDEREADONLY
| OFN_NOCHANGEDIR
7954 | OFN_EXPLORER
| OFN_ENABLEHOOK
);
7955 if (!NILP (mustmatch
))
7957 /* Require that the path to the parent directory exists. */
7958 file_details
->Flags
|= OFN_PATHMUSTEXIST
;
7959 /* If we are looking for a file, require that it exists. */
7960 if (NILP (only_dir_p
))
7961 file_details
->Flags
|= OFN_FILEMUSTEXIST
;
7964 file_details
->lpfnHook
= (LPOFNHOOKPROC
) file_dialog_callback
;
7966 file_opened
= GetOpenFileName (file_details
);
7972 dostounix_filename (filename
);
7974 if (file_details
->nFilterIndex
== 2)
7976 /* "Directories" selected - strip dummy file name. */
7977 char * last
= strrchr (filename
, '/');
7981 file
= DECODE_FILE(build_string (filename
));
7983 /* User cancelled the dialog without making a selection. */
7984 else if (!CommDlgExtendedError ())
7986 /* An error occurred, fallback on reading from the mini-buffer. */
7988 file
= Fcompleting_read (prompt
, intern ("read-file-name-internal"),
7989 dir
, mustmatch
, dir
, Qfile_name_history
,
7990 default_filename
, Qnil
);
7992 file
= unbind_to (count
, file
);
7997 /* Make "Cancel" equivalent to C-g. */
7999 Fsignal (Qquit
, Qnil
);
8001 return unbind_to (count
, file
);
8006 /***********************************************************************
8007 w32 specialized functions
8008 ***********************************************************************/
8010 DEFUN ("w32-select-font", Fw32_select_font
, Sw32_select_font
, 0, 2, 0,
8011 doc
: /* Select a font for the named FRAME using the W32 font dialog.
8012 Returns an X-style font string corresponding to the selection.
8014 If FRAME is omitted or nil, it defaults to the selected frame.
8015 If INCLUDE-PROPORTIONAL is non-nil, include proportional fonts
8016 in the font selection dialog. */)
8017 (frame
, include_proportional
)
8018 Lisp_Object frame
, include_proportional
;
8020 FRAME_PTR f
= check_x_frame (frame
);
8028 bzero (&cf
, sizeof (cf
));
8029 bzero (&lf
, sizeof (lf
));
8031 cf
.lStructSize
= sizeof (cf
);
8032 cf
.hwndOwner
= FRAME_W32_WINDOW (f
);
8033 cf
.Flags
= CF_FORCEFONTEXIST
| CF_SCREENFONTS
| CF_NOVERTFONTS
;
8035 /* Unless include_proportional is non-nil, limit the selection to
8036 monospaced fonts. */
8037 if (NILP (include_proportional
))
8038 cf
.Flags
|= CF_FIXEDPITCHONLY
;
8042 /* Initialize as much of the font details as we can from the current
8044 hdc
= GetDC (FRAME_W32_WINDOW (f
));
8045 oldobj
= SelectObject (hdc
, FRAME_FONT (f
)->hfont
);
8046 GetTextFace (hdc
, LF_FACESIZE
, lf
.lfFaceName
);
8047 if (GetTextMetrics (hdc
, &tm
))
8049 lf
.lfHeight
= tm
.tmInternalLeading
- tm
.tmHeight
;
8050 lf
.lfWeight
= tm
.tmWeight
;
8051 lf
.lfItalic
= tm
.tmItalic
;
8052 lf
.lfUnderline
= tm
.tmUnderlined
;
8053 lf
.lfStrikeOut
= tm
.tmStruckOut
;
8054 lf
.lfCharSet
= tm
.tmCharSet
;
8055 cf
.Flags
|= CF_INITTOLOGFONTSTRUCT
;
8057 SelectObject (hdc
, oldobj
);
8058 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
8060 if (!ChooseFont (&cf
) || !w32_to_x_font (&lf
, buf
, 100, NULL
))
8063 return build_string (buf
);
8066 DEFUN ("w32-send-sys-command", Fw32_send_sys_command
,
8067 Sw32_send_sys_command
, 1, 2, 0,
8068 doc
: /* Send frame a Windows WM_SYSCOMMAND message of type COMMAND.
8069 Some useful values for COMMAND are #xf030 to maximize frame (#xf020
8070 to minimize), #xf120 to restore frame to original size, and #xf100
8071 to activate the menubar for keyboard access. #xf140 activates the
8072 screen saver if defined.
8074 If optional parameter FRAME is not specified, use selected frame. */)
8076 Lisp_Object command
, frame
;
8078 FRAME_PTR f
= check_x_frame (frame
);
8080 CHECK_NUMBER (command
);
8082 PostMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, XINT (command
), 0);
8087 DEFUN ("w32-shell-execute", Fw32_shell_execute
, Sw32_shell_execute
, 2, 4, 0,
8088 doc
: /* Get Windows to perform OPERATION on DOCUMENT.
8089 This is a wrapper around the ShellExecute system function, which
8090 invokes the application registered to handle OPERATION for DOCUMENT.
8092 OPERATION is either nil or a string that names a supported operation.
8093 What operations can be used depends on the particular DOCUMENT and its
8094 handler application, but typically it is one of the following common
8097 \"open\" - open DOCUMENT, which could be a file, a directory, or an
8098 executable program. If it is an application, that
8099 application is launched in the current buffer's default
8100 directory. Otherwise, the application associated with
8101 DOCUMENT is launched in the buffer's default directory.
8102 \"print\" - print DOCUMENT, which must be a file
8103 \"explore\" - start the Windows Explorer on DOCUMENT
8104 \"edit\" - launch an editor and open DOCUMENT for editing; which
8105 editor is launched depends on the association for the
8107 \"find\" - initiate search starting from DOCUMENT which must specify
8109 nil - invoke the default OPERATION, or \"open\" if default is
8110 not defined or unavailable
8112 DOCUMENT is typically the name of a document file or a URL, but can
8113 also be a program executable to run, or a directory to open in the
8116 If DOCUMENT is a program executable, the optional arg PARAMETERS can
8117 be a string containing command line parameters that will be passed to
8118 the program; otherwise, PARAMETERS should be nil or unspecified.
8120 Second optional argument SHOW-FLAG can be used to control how the
8121 application will be displayed when it is invoked. If SHOW-FLAG is nil
8122 or unspceified, the application is displayed normally, otherwise it is
8123 an integer representing a ShowWindow flag:
8128 6 - start minimized */)
8129 (operation
, document
, parameters
, show_flag
)
8130 Lisp_Object operation
, document
, parameters
, show_flag
;
8132 Lisp_Object current_dir
;
8134 CHECK_STRING (document
);
8136 /* Encode filename and current directory. */
8137 current_dir
= ENCODE_FILE (current_buffer
->directory
);
8138 document
= ENCODE_FILE (document
);
8139 if ((int) ShellExecute (NULL
,
8140 (STRINGP (operation
) ?
8141 SDATA (operation
) : NULL
),
8143 (STRINGP (parameters
) ?
8144 SDATA (parameters
) : NULL
),
8145 SDATA (current_dir
),
8146 (INTEGERP (show_flag
) ?
8147 XINT (show_flag
) : SW_SHOWDEFAULT
))
8150 error ("ShellExecute failed: %s", w32_strerror (0));
8153 /* Lookup virtual keycode from string representing the name of a
8154 non-ascii keystroke into the corresponding virtual key, using
8155 lispy_function_keys. */
8157 lookup_vk_code (char *key
)
8161 for (i
= 0; i
< 256; i
++)
8162 if (lispy_function_keys
[i
] != 0
8163 && strcmp (lispy_function_keys
[i
], key
) == 0)
8169 /* Convert a one-element vector style key sequence to a hot key
8172 w32_parse_hot_key (key
)
8175 /* Copied from Fdefine_key and store_in_keymap. */
8176 register Lisp_Object c
;
8180 struct gcpro gcpro1
;
8184 if (XFASTINT (Flength (key
)) != 1)
8189 c
= Faref (key
, make_number (0));
8191 if (CONSP (c
) && lucid_event_type_list_p (c
))
8192 c
= Fevent_convert_list (c
);
8196 if (! INTEGERP (c
) && ! SYMBOLP (c
))
8197 error ("Key definition is invalid");
8199 /* Work out the base key and the modifiers. */
8202 c
= parse_modifiers (c
);
8203 lisp_modifiers
= XINT (Fcar (Fcdr (c
)));
8207 vk_code
= lookup_vk_code (SDATA (SYMBOL_NAME (c
)));
8209 else if (INTEGERP (c
))
8211 lisp_modifiers
= XINT (c
) & ~CHARACTERBITS
;
8212 /* Many ascii characters are their own virtual key code. */
8213 vk_code
= XINT (c
) & CHARACTERBITS
;
8216 if (vk_code
< 0 || vk_code
> 255)
8219 if ((lisp_modifiers
& meta_modifier
) != 0
8220 && !NILP (Vw32_alt_is_meta
))
8221 lisp_modifiers
|= alt_modifier
;
8223 /* Supply defs missing from mingw32. */
8225 #define MOD_ALT 0x0001
8226 #define MOD_CONTROL 0x0002
8227 #define MOD_SHIFT 0x0004
8228 #define MOD_WIN 0x0008
8231 /* Convert lisp modifiers to Windows hot-key form. */
8232 w32_modifiers
= (lisp_modifiers
& hyper_modifier
) ? MOD_WIN
: 0;
8233 w32_modifiers
|= (lisp_modifiers
& alt_modifier
) ? MOD_ALT
: 0;
8234 w32_modifiers
|= (lisp_modifiers
& ctrl_modifier
) ? MOD_CONTROL
: 0;
8235 w32_modifiers
|= (lisp_modifiers
& shift_modifier
) ? MOD_SHIFT
: 0;
8237 return HOTKEY (vk_code
, w32_modifiers
);
8240 DEFUN ("w32-register-hot-key", Fw32_register_hot_key
,
8241 Sw32_register_hot_key
, 1, 1, 0,
8242 doc
: /* Register KEY as a hot-key combination.
8243 Certain key combinations like Alt-Tab are reserved for system use on
8244 Windows, and therefore are normally intercepted by the system. However,
8245 most of these key combinations can be received by registering them as
8246 hot-keys, overriding their special meaning.
8248 KEY must be a one element key definition in vector form that would be
8249 acceptable to `define-key' (e.g. [A-tab] for Alt-Tab). The meta
8250 modifier is interpreted as Alt if `w32-alt-is-meta' is t, and hyper
8251 is always interpreted as the Windows modifier keys.
8253 The return value is the hotkey-id if registered, otherwise nil. */)
8257 key
= w32_parse_hot_key (key
);
8259 if (NILP (Fmemq (key
, w32_grabbed_keys
)))
8261 /* Reuse an empty slot if possible. */
8262 Lisp_Object item
= Fmemq (Qnil
, w32_grabbed_keys
);
8264 /* Safe to add new key to list, even if we have focus. */
8266 w32_grabbed_keys
= Fcons (key
, w32_grabbed_keys
);
8268 XSETCAR (item
, key
);
8270 /* Notify input thread about new hot-key definition, so that it
8271 takes effect without needing to switch focus. */
8272 #ifdef USE_LISP_UNION_TYPE
8273 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_REGISTER_HOT_KEY
,
8276 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_REGISTER_HOT_KEY
,
8284 DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key
,
8285 Sw32_unregister_hot_key
, 1, 1, 0,
8286 doc
: /* Unregister KEY as a hot-key combination. */)
8292 if (!INTEGERP (key
))
8293 key
= w32_parse_hot_key (key
);
8295 item
= Fmemq (key
, w32_grabbed_keys
);
8299 /* Notify input thread about hot-key definition being removed, so
8300 that it takes effect without needing focus switch. */
8301 #ifdef USE_LISP_UNION_TYPE
8302 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_UNREGISTER_HOT_KEY
,
8303 (WPARAM
) XINT (XCAR (item
)), (LPARAM
) item
.i
))
8305 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_UNREGISTER_HOT_KEY
,
8306 (WPARAM
) XINT (XCAR (item
)), (LPARAM
) item
))
8311 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
8318 DEFUN ("w32-registered-hot-keys", Fw32_registered_hot_keys
,
8319 Sw32_registered_hot_keys
, 0, 0, 0,
8320 doc
: /* Return list of registered hot-key IDs. */)
8323 return Fcopy_sequence (w32_grabbed_keys
);
8326 DEFUN ("w32-reconstruct-hot-key", Fw32_reconstruct_hot_key
,
8327 Sw32_reconstruct_hot_key
, 1, 1, 0,
8328 doc
: /* Convert hot-key ID to a lisp key combination.
8329 usage: (w32-reconstruct-hot-key ID) */)
8331 Lisp_Object hotkeyid
;
8333 int vk_code
, w32_modifiers
;
8336 CHECK_NUMBER (hotkeyid
);
8338 vk_code
= HOTKEY_VK_CODE (hotkeyid
);
8339 w32_modifiers
= HOTKEY_MODIFIERS (hotkeyid
);
8341 if (lispy_function_keys
[vk_code
])
8342 key
= intern (lispy_function_keys
[vk_code
]);
8344 key
= make_number (vk_code
);
8346 key
= Fcons (key
, Qnil
);
8347 if (w32_modifiers
& MOD_SHIFT
)
8348 key
= Fcons (Qshift
, key
);
8349 if (w32_modifiers
& MOD_CONTROL
)
8350 key
= Fcons (Qctrl
, key
);
8351 if (w32_modifiers
& MOD_ALT
)
8352 key
= Fcons (NILP (Vw32_alt_is_meta
) ? Qalt
: Qmeta
, key
);
8353 if (w32_modifiers
& MOD_WIN
)
8354 key
= Fcons (Qhyper
, key
);
8359 DEFUN ("w32-toggle-lock-key", Fw32_toggle_lock_key
,
8360 Sw32_toggle_lock_key
, 1, 2, 0,
8361 doc
: /* Toggle the state of the lock key KEY.
8362 KEY can be `capslock', `kp-numlock', or `scroll'.
8363 If the optional parameter NEW-STATE is a number, then the state of KEY
8364 is set to off if the low bit of NEW-STATE is zero, otherwise on. */)
8366 Lisp_Object key
, new_state
;
8370 if (EQ (key
, intern ("capslock")))
8371 vk_code
= VK_CAPITAL
;
8372 else if (EQ (key
, intern ("kp-numlock")))
8373 vk_code
= VK_NUMLOCK
;
8374 else if (EQ (key
, intern ("scroll")))
8375 vk_code
= VK_SCROLL
;
8379 if (!dwWindowsThreadId
)
8380 return make_number (w32_console_toggle_lock_key (vk_code
, new_state
));
8382 #ifdef USE_LISP_UNION_TYPE
8383 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_TOGGLE_LOCK_KEY
,
8384 (WPARAM
) vk_code
, (LPARAM
) new_state
.i
))
8386 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_TOGGLE_LOCK_KEY
,
8387 (WPARAM
) vk_code
, (LPARAM
) new_state
))
8391 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
8392 return make_number (msg
.wParam
);
8397 DEFUN ("w32-window-exists-p", Fw32_window_exists_p
, Sw32_window_exists_p
,
8399 doc
: /* Return non-nil if a window exists with the specified CLASS and NAME.
8401 This is a direct interface to the Windows API FindWindow function. */)
8403 Lisp_Object
class, name
;
8408 CHECK_STRING (class);
8410 CHECK_STRING (name
);
8412 hnd
= FindWindow (STRINGP (class) ? ((LPCTSTR
) SDATA (class)) : NULL
,
8413 STRINGP (name
) ? ((LPCTSTR
) SDATA (name
)) : NULL
);
8421 DEFUN ("file-system-info", Ffile_system_info
, Sfile_system_info
, 1, 1, 0,
8422 doc
: /* Return storage information about the file system FILENAME is on.
8423 Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total
8424 storage of the file system, FREE is the free storage, and AVAIL is the
8425 storage available to a non-superuser. All 3 numbers are in bytes.
8426 If the underlying system call fails, value is nil. */)
8428 Lisp_Object filename
;
8430 Lisp_Object encoded
, value
;
8432 CHECK_STRING (filename
);
8433 filename
= Fexpand_file_name (filename
, Qnil
);
8434 encoded
= ENCODE_FILE (filename
);
8438 /* Determining the required information on Windows turns out, sadly,
8439 to be more involved than one would hope. The original Win32 api
8440 call for this will return bogus information on some systems, but we
8441 must dynamically probe for the replacement api, since that was
8442 added rather late on. */
8444 HMODULE hKernel
= GetModuleHandle ("kernel32");
8445 BOOL (*pfn_GetDiskFreeSpaceEx
)
8446 (char *, PULARGE_INTEGER
, PULARGE_INTEGER
, PULARGE_INTEGER
)
8447 = (void *) GetProcAddress (hKernel
, "GetDiskFreeSpaceEx");
8449 /* On Windows, we may need to specify the root directory of the
8450 volume holding FILENAME. */
8451 char rootname
[MAX_PATH
];
8452 char *name
= SDATA (encoded
);
8454 /* find the root name of the volume if given */
8455 if (isalpha (name
[0]) && name
[1] == ':')
8457 rootname
[0] = name
[0];
8458 rootname
[1] = name
[1];
8462 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
8464 char *str
= rootname
;
8468 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
8478 if (pfn_GetDiskFreeSpaceEx
)
8480 /* Unsigned large integers cannot be cast to double, so
8481 use signed ones instead. */
8482 LARGE_INTEGER availbytes
;
8483 LARGE_INTEGER freebytes
;
8484 LARGE_INTEGER totalbytes
;
8486 if (pfn_GetDiskFreeSpaceEx(rootname
,
8487 (ULARGE_INTEGER
*)&availbytes
,
8488 (ULARGE_INTEGER
*)&totalbytes
,
8489 (ULARGE_INTEGER
*)&freebytes
))
8490 value
= list3 (make_float ((double) totalbytes
.QuadPart
),
8491 make_float ((double) freebytes
.QuadPart
),
8492 make_float ((double) availbytes
.QuadPart
));
8496 DWORD sectors_per_cluster
;
8497 DWORD bytes_per_sector
;
8498 DWORD free_clusters
;
8499 DWORD total_clusters
;
8501 if (GetDiskFreeSpace(rootname
,
8502 §ors_per_cluster
,
8506 value
= list3 (make_float ((double) total_clusters
8507 * sectors_per_cluster
* bytes_per_sector
),
8508 make_float ((double) free_clusters
8509 * sectors_per_cluster
* bytes_per_sector
),
8510 make_float ((double) free_clusters
8511 * sectors_per_cluster
* bytes_per_sector
));
8518 DEFUN ("default-printer-name", Fdefault_printer_name
, Sdefault_printer_name
,
8519 0, 0, 0, doc
: /* Return the name of Windows default printer device. */)
8522 static char pname_buf
[256];
8525 PRINTER_INFO_2
*ppi2
= NULL
;
8526 DWORD dwNeeded
= 0, dwReturned
= 0;
8528 /* Retrieve the default string from Win.ini (the registry).
8529 * String will be in form "printername,drivername,portname".
8530 * This is the most portable way to get the default printer. */
8531 if (GetProfileString ("windows", "device", ",,", pname_buf
, sizeof (pname_buf
)) <= 0)
8533 /* printername precedes first "," character */
8534 strtok (pname_buf
, ",");
8535 /* We want to know more than the printer name */
8536 if (!OpenPrinter (pname_buf
, &hPrn
, NULL
))
8538 GetPrinter (hPrn
, 2, NULL
, 0, &dwNeeded
);
8541 ClosePrinter (hPrn
);
8544 /* Allocate memory for the PRINTER_INFO_2 struct */
8545 ppi2
= (PRINTER_INFO_2
*) xmalloc (dwNeeded
);
8548 ClosePrinter (hPrn
);
8551 /* Call GetPrinter() again with big enouth memory block */
8552 err
= GetPrinter (hPrn
, 2, (LPBYTE
)ppi2
, dwNeeded
, &dwReturned
);
8553 ClosePrinter (hPrn
);
8562 if (ppi2
->Attributes
& PRINTER_ATTRIBUTE_SHARED
&& ppi2
->pServerName
)
8564 /* a remote printer */
8565 if (*ppi2
->pServerName
== '\\')
8566 _snprintf(pname_buf
, sizeof (pname_buf
), "%s\\%s", ppi2
->pServerName
,
8569 _snprintf(pname_buf
, sizeof (pname_buf
), "\\\\%s\\%s", ppi2
->pServerName
,
8571 pname_buf
[sizeof (pname_buf
) - 1] = '\0';
8575 /* a local printer */
8576 strncpy(pname_buf
, ppi2
->pPortName
, sizeof (pname_buf
));
8577 pname_buf
[sizeof (pname_buf
) - 1] = '\0';
8578 /* `pPortName' can include several ports, delimited by ','.
8579 * we only use the first one. */
8580 strtok(pname_buf
, ",");
8585 return build_string (pname_buf
);
8588 /***********************************************************************
8590 ***********************************************************************/
8592 /* Keep this list in the same order as frame_parms in frame.c.
8593 Use 0 for unsupported frame parameters. */
8595 frame_parm_handler w32_frame_parm_handlers
[] =
8599 x_set_background_color
,
8605 x_set_foreground_color
,
8608 x_set_internal_border_width
,
8609 x_set_menu_bar_lines
,
8611 x_explicitly_set_name
,
8612 x_set_scroll_bar_width
,
8615 x_set_vertical_scroll_bars
,
8617 x_set_tool_bar_lines
,
8618 0, /* x_set_scroll_bar_foreground, */
8619 0, /* x_set_scroll_bar_background, */
8624 0, /* x_set_wait_for_wm, */
8631 globals_of_w32fns ();
8632 /* This is zero if not using MS-Windows. */
8634 track_mouse_window
= NULL
;
8636 w32_visible_system_caret_hwnd
= NULL
;
8638 Qnone
= intern ("none");
8640 Qsuppress_icon
= intern ("suppress-icon");
8641 staticpro (&Qsuppress_icon
);
8642 Qundefined_color
= intern ("undefined-color");
8643 staticpro (&Qundefined_color
);
8644 Qcancel_timer
= intern ("cancel-timer");
8645 staticpro (&Qcancel_timer
);
8647 Qhyper
= intern ("hyper");
8648 staticpro (&Qhyper
);
8649 Qsuper
= intern ("super");
8650 staticpro (&Qsuper
);
8651 Qmeta
= intern ("meta");
8653 Qalt
= intern ("alt");
8655 Qctrl
= intern ("ctrl");
8657 Qcontrol
= intern ("control");
8658 staticpro (&Qcontrol
);
8659 Qshift
= intern ("shift");
8660 staticpro (&Qshift
);
8661 /* This is the end of symbol initialization. */
8663 /* Text property `display' should be nonsticky by default. */
8664 Vtext_property_default_nonsticky
8665 = Fcons (Fcons (Qdisplay
, Qt
), Vtext_property_default_nonsticky
);
8668 Fput (Qundefined_color
, Qerror_conditions
,
8669 Fcons (Qundefined_color
, Fcons (Qerror
, Qnil
)));
8670 Fput (Qundefined_color
, Qerror_message
,
8671 build_string ("Undefined color"));
8673 staticpro (&w32_grabbed_keys
);
8674 w32_grabbed_keys
= Qnil
;
8676 DEFVAR_LISP ("w32-color-map", &Vw32_color_map
,
8677 doc
: /* An array of color name mappings for Windows. */);
8678 Vw32_color_map
= Qnil
;
8680 DEFVAR_LISP ("w32-pass-alt-to-system", &Vw32_pass_alt_to_system
,
8681 doc
: /* Non-nil if Alt key presses are passed on to Windows.
8682 When non-nil, for example, Alt pressed and released and then space will
8683 open the System menu. When nil, Emacs processes the Alt key events, and
8684 then silently swallows them. */);
8685 Vw32_pass_alt_to_system
= Qnil
;
8687 DEFVAR_LISP ("w32-alt-is-meta", &Vw32_alt_is_meta
,
8688 doc
: /* Non-nil if the Alt key is to be considered the same as the META key.
8689 When nil, Emacs will translate the Alt key to the ALT modifier, not to META. */);
8690 Vw32_alt_is_meta
= Qt
;
8692 DEFVAR_INT ("w32-quit-key", &w32_quit_key
,
8693 doc
: /* If non-zero, the virtual key code for an alternative quit key. */);
8696 DEFVAR_LISP ("w32-pass-lwindow-to-system",
8697 &Vw32_pass_lwindow_to_system
,
8698 doc
: /* If non-nil, the left \"Windows\" key is passed on to Windows.
8700 When non-nil, the Start menu is opened by tapping the key.
8701 If you set this to nil, the left \"Windows\" key is processed by Emacs
8702 according to the value of `w32-lwindow-modifier', which see.
8704 Note that some combinations of the left \"Windows\" key with other keys are
8705 caught by Windows at low level, and so binding them in Emacs will have no
8706 effect. For example, <lwindow>-r always pops up the Windows Run dialog,
8707 <lwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
8708 the doc string of `w32-phantom-key-code'. */);
8709 Vw32_pass_lwindow_to_system
= Qt
;
8711 DEFVAR_LISP ("w32-pass-rwindow-to-system",
8712 &Vw32_pass_rwindow_to_system
,
8713 doc
: /* If non-nil, the right \"Windows\" key is passed on to Windows.
8715 When non-nil, the Start menu is opened by tapping the key.
8716 If you set this to nil, the right \"Windows\" key is processed by Emacs
8717 according to the value of `w32-rwindow-modifier', which see.
8719 Note that some combinations of the right \"Windows\" key with other keys are
8720 caught by Windows at low level, and so binding them in Emacs will have no
8721 effect. For example, <rwindow>-r always pops up the Windows Run dialog,
8722 <rwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
8723 the doc string of `w32-phantom-key-code'. */);
8724 Vw32_pass_rwindow_to_system
= Qt
;
8726 DEFVAR_LISP ("w32-phantom-key-code",
8727 &Vw32_phantom_key_code
,
8728 doc
: /* Virtual key code used to generate \"phantom\" key presses.
8729 Value is a number between 0 and 255.
8731 Phantom key presses are generated in order to stop the system from
8732 acting on \"Windows\" key events when `w32-pass-lwindow-to-system' or
8733 `w32-pass-rwindow-to-system' is nil. */);
8734 /* Although 255 is technically not a valid key code, it works and
8735 means that this hack won't interfere with any real key code. */
8736 XSETINT (Vw32_phantom_key_code
, 255);
8738 DEFVAR_LISP ("w32-enable-num-lock",
8739 &Vw32_enable_num_lock
,
8740 doc
: /* If non-nil, the Num Lock key acts normally.
8741 Set to nil to handle Num Lock as the `kp-numlock' key. */);
8742 Vw32_enable_num_lock
= Qt
;
8744 DEFVAR_LISP ("w32-enable-caps-lock",
8745 &Vw32_enable_caps_lock
,
8746 doc
: /* If non-nil, the Caps Lock key acts normally.
8747 Set to nil to handle Caps Lock as the `capslock' key. */);
8748 Vw32_enable_caps_lock
= Qt
;
8750 DEFVAR_LISP ("w32-scroll-lock-modifier",
8751 &Vw32_scroll_lock_modifier
,
8752 doc
: /* Modifier to use for the Scroll Lock ON state.
8753 The value can be hyper, super, meta, alt, control or shift for the
8754 respective modifier, or nil to handle Scroll Lock as the `scroll' key.
8755 Any other value will cause the Scroll Lock key to be ignored. */);
8756 Vw32_scroll_lock_modifier
= Qt
;
8758 DEFVAR_LISP ("w32-lwindow-modifier",
8759 &Vw32_lwindow_modifier
,
8760 doc
: /* Modifier to use for the left \"Windows\" key.
8761 The value can be hyper, super, meta, alt, control or shift for the
8762 respective modifier, or nil to appear as the `lwindow' key.
8763 Any other value will cause the key to be ignored. */);
8764 Vw32_lwindow_modifier
= Qnil
;
8766 DEFVAR_LISP ("w32-rwindow-modifier",
8767 &Vw32_rwindow_modifier
,
8768 doc
: /* Modifier to use for the right \"Windows\" key.
8769 The value can be hyper, super, meta, alt, control or shift for the
8770 respective modifier, or nil to appear as the `rwindow' key.
8771 Any other value will cause the key to be ignored. */);
8772 Vw32_rwindow_modifier
= Qnil
;
8774 DEFVAR_LISP ("w32-apps-modifier",
8775 &Vw32_apps_modifier
,
8776 doc
: /* Modifier to use for the \"Apps\" key.
8777 The value can be hyper, super, meta, alt, control or shift for the
8778 respective modifier, or nil to appear as the `apps' key.
8779 Any other value will cause the key to be ignored. */);
8780 Vw32_apps_modifier
= Qnil
;
8782 DEFVAR_BOOL ("w32-enable-synthesized-fonts", &w32_enable_synthesized_fonts
,
8783 doc
: /* Non-nil enables selection of artificially italicized and bold fonts. */);
8784 w32_enable_synthesized_fonts
= 0;
8786 DEFVAR_LISP ("w32-enable-palette", &Vw32_enable_palette
,
8787 doc
: /* Non-nil enables Windows palette management to map colors exactly. */);
8788 Vw32_enable_palette
= Qt
;
8790 DEFVAR_INT ("w32-mouse-button-tolerance",
8791 &w32_mouse_button_tolerance
,
8792 doc
: /* Analogue of double click interval for faking middle mouse events.
8793 The value is the minimum time in milliseconds that must elapse between
8794 left and right button down events before they are considered distinct events.
8795 If both mouse buttons are depressed within this interval, a middle mouse
8796 button down event is generated instead. */);
8797 w32_mouse_button_tolerance
= GetDoubleClickTime () / 2;
8799 DEFVAR_INT ("w32-mouse-move-interval",
8800 &w32_mouse_move_interval
,
8801 doc
: /* Minimum interval between mouse move events.
8802 The value is the minimum time in milliseconds that must elapse between
8803 successive mouse move (or scroll bar drag) events before they are
8804 reported as lisp events. */);
8805 w32_mouse_move_interval
= 0;
8807 DEFVAR_BOOL ("w32-pass-extra-mouse-buttons-to-system",
8808 &w32_pass_extra_mouse_buttons_to_system
,
8809 doc
: /* If non-nil, the fourth and fifth mouse buttons are passed to Windows.
8810 Recent versions of Windows support mice with up to five buttons.
8811 Since most applications don't support these extra buttons, most mouse
8812 drivers will allow you to map them to functions at the system level.
8813 If this variable is non-nil, Emacs will pass them on, allowing the
8814 system to handle them. */);
8815 w32_pass_extra_mouse_buttons_to_system
= 0;
8817 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape
,
8818 doc
: /* The shape of the pointer when over text.
8819 Changing the value does not affect existing frames
8820 unless you set the mouse color. */);
8821 Vx_pointer_shape
= Qnil
;
8823 Vx_nontext_pointer_shape
= Qnil
;
8825 Vx_mode_pointer_shape
= Qnil
;
8827 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape
,
8828 doc
: /* The shape of the pointer when Emacs is busy.
8829 This variable takes effect when you create a new frame
8830 or when you set the mouse color. */);
8831 Vx_hourglass_pointer_shape
= Qnil
;
8833 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p
,
8834 doc
: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
8835 display_hourglass_p
= 1;
8837 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay
,
8838 doc
: /* *Seconds to wait before displaying an hourglass pointer.
8839 Value must be an integer or float. */);
8840 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
8842 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
8843 &Vx_sensitive_text_pointer_shape
,
8844 doc
: /* The shape of the pointer when over mouse-sensitive text.
8845 This variable takes effect when you create a new frame
8846 or when you set the mouse color. */);
8847 Vx_sensitive_text_pointer_shape
= Qnil
;
8849 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
8850 &Vx_window_horizontal_drag_shape
,
8851 doc
: /* Pointer shape to use for indicating a window can be dragged horizontally.
8852 This variable takes effect when you create a new frame
8853 or when you set the mouse color. */);
8854 Vx_window_horizontal_drag_shape
= Qnil
;
8856 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel
,
8857 doc
: /* A string indicating the foreground color of the cursor box. */);
8858 Vx_cursor_fore_pixel
= Qnil
;
8860 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size
,
8861 doc
: /* Maximum size for tooltips.
8862 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
8863 Vx_max_tooltip_size
= Fcons (make_number (80), make_number (40));
8865 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager
,
8866 doc
: /* Non-nil if no window manager is in use.
8867 Emacs doesn't try to figure this out; this is always nil
8868 unless you set it to something else. */);
8869 /* We don't have any way to find this out, so set it to nil
8870 and maybe the user would like to set it to t. */
8871 Vx_no_window_manager
= Qnil
;
8873 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
8874 &Vx_pixel_size_width_font_regexp
,
8875 doc
: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
8877 Since Emacs gets width of a font matching with this regexp from
8878 PIXEL_SIZE field of the name, font finding mechanism gets faster for
8879 such a font. This is especially effective for such large fonts as
8880 Chinese, Japanese, and Korean. */);
8881 Vx_pixel_size_width_font_regexp
= Qnil
;
8883 DEFVAR_LISP ("w32-bdf-filename-alist",
8884 &Vw32_bdf_filename_alist
,
8885 doc
: /* List of bdf fonts and their corresponding filenames. */);
8886 Vw32_bdf_filename_alist
= Qnil
;
8888 DEFVAR_BOOL ("w32-strict-fontnames",
8889 &w32_strict_fontnames
,
8890 doc
: /* Non-nil means only use fonts that are exact matches for those requested.
8891 Default is nil, which allows old fontnames that are not XLFD compliant,
8892 and allows third-party CJK display to work by specifying false charset
8893 fields to trick Emacs into translating to Big5, SJIS etc.
8894 Setting this to t will prevent wrong fonts being selected when
8895 fontsets are automatically created. */);
8896 w32_strict_fontnames
= 0;
8898 DEFVAR_BOOL ("w32-strict-painting",
8899 &w32_strict_painting
,
8900 doc
: /* Non-nil means use strict rules for repainting frames.
8901 Set this to nil to get the old behavior for repainting; this should
8902 only be necessary if the default setting causes problems. */);
8903 w32_strict_painting
= 1;
8905 DEFVAR_LISP ("w32-charset-info-alist",
8906 &Vw32_charset_info_alist
,
8907 doc
: /* Alist linking Emacs character sets to Windows fonts and codepages.
8908 Each entry should be of the form:
8910 (CHARSET_NAME . (WINDOWS_CHARSET . CODEPAGE))
8912 where CHARSET_NAME is a string used in font names to identify the charset,
8913 WINDOWS_CHARSET is a symbol that can be one of:
8914 w32-charset-ansi, w32-charset-default, w32-charset-symbol,
8915 w32-charset-shiftjis, w32-charset-hangeul, w32-charset-gb2312,
8916 w32-charset-chinesebig5,
8917 w32-charset-johab, w32-charset-hebrew,
8918 w32-charset-arabic, w32-charset-greek, w32-charset-turkish,
8919 w32-charset-vietnamese, w32-charset-thai, w32-charset-easteurope,
8920 w32-charset-russian, w32-charset-mac, w32-charset-baltic,
8921 w32-charset-unicode,
8923 CODEPAGE should be an integer specifying the codepage that should be used
8924 to display the character set, t to do no translation and output as Unicode,
8925 or nil to do no translation and output as 8 bit (or multibyte on far-east
8926 versions of Windows) characters. */);
8927 Vw32_charset_info_alist
= Qnil
;
8929 staticpro (&Qw32_charset_ansi
);
8930 Qw32_charset_ansi
= intern ("w32-charset-ansi");
8931 staticpro (&Qw32_charset_symbol
);
8932 Qw32_charset_default
= intern ("w32-charset-default");
8933 staticpro (&Qw32_charset_default
);
8934 Qw32_charset_symbol
= intern ("w32-charset-symbol");
8935 staticpro (&Qw32_charset_shiftjis
);
8936 Qw32_charset_shiftjis
= intern ("w32-charset-shiftjis");
8937 staticpro (&Qw32_charset_hangeul
);
8938 Qw32_charset_hangeul
= intern ("w32-charset-hangeul");
8939 staticpro (&Qw32_charset_chinesebig5
);
8940 Qw32_charset_chinesebig5
= intern ("w32-charset-chinesebig5");
8941 staticpro (&Qw32_charset_gb2312
);
8942 Qw32_charset_gb2312
= intern ("w32-charset-gb2312");
8943 staticpro (&Qw32_charset_oem
);
8944 Qw32_charset_oem
= intern ("w32-charset-oem");
8946 #ifdef JOHAB_CHARSET
8948 static int w32_extra_charsets_defined
= 1;
8949 DEFVAR_BOOL ("w32-extra-charsets-defined", &w32_extra_charsets_defined
,
8950 doc
: /* Internal variable. */);
8952 staticpro (&Qw32_charset_johab
);
8953 Qw32_charset_johab
= intern ("w32-charset-johab");
8954 staticpro (&Qw32_charset_easteurope
);
8955 Qw32_charset_easteurope
= intern ("w32-charset-easteurope");
8956 staticpro (&Qw32_charset_turkish
);
8957 Qw32_charset_turkish
= intern ("w32-charset-turkish");
8958 staticpro (&Qw32_charset_baltic
);
8959 Qw32_charset_baltic
= intern ("w32-charset-baltic");
8960 staticpro (&Qw32_charset_russian
);
8961 Qw32_charset_russian
= intern ("w32-charset-russian");
8962 staticpro (&Qw32_charset_arabic
);
8963 Qw32_charset_arabic
= intern ("w32-charset-arabic");
8964 staticpro (&Qw32_charset_greek
);
8965 Qw32_charset_greek
= intern ("w32-charset-greek");
8966 staticpro (&Qw32_charset_hebrew
);
8967 Qw32_charset_hebrew
= intern ("w32-charset-hebrew");
8968 staticpro (&Qw32_charset_vietnamese
);
8969 Qw32_charset_vietnamese
= intern ("w32-charset-vietnamese");
8970 staticpro (&Qw32_charset_thai
);
8971 Qw32_charset_thai
= intern ("w32-charset-thai");
8972 staticpro (&Qw32_charset_mac
);
8973 Qw32_charset_mac
= intern ("w32-charset-mac");
8977 #ifdef UNICODE_CHARSET
8979 static int w32_unicode_charset_defined
= 1;
8980 DEFVAR_BOOL ("w32-unicode-charset-defined",
8981 &w32_unicode_charset_defined
,
8982 doc
: /* Internal variable. */);
8984 staticpro (&Qw32_charset_unicode
);
8985 Qw32_charset_unicode
= intern ("w32-charset-unicode");
8989 #if 0 /* TODO: Port to W32 */
8990 defsubr (&Sx_change_window_property
);
8991 defsubr (&Sx_delete_window_property
);
8992 defsubr (&Sx_window_property
);
8994 defsubr (&Sxw_display_color_p
);
8995 defsubr (&Sx_display_grayscale_p
);
8996 defsubr (&Sxw_color_defined_p
);
8997 defsubr (&Sxw_color_values
);
8998 defsubr (&Sx_server_max_request_size
);
8999 defsubr (&Sx_server_vendor
);
9000 defsubr (&Sx_server_version
);
9001 defsubr (&Sx_display_pixel_width
);
9002 defsubr (&Sx_display_pixel_height
);
9003 defsubr (&Sx_display_mm_width
);
9004 defsubr (&Sx_display_mm_height
);
9005 defsubr (&Sx_display_screens
);
9006 defsubr (&Sx_display_planes
);
9007 defsubr (&Sx_display_color_cells
);
9008 defsubr (&Sx_display_visual_class
);
9009 defsubr (&Sx_display_backing_store
);
9010 defsubr (&Sx_display_save_under
);
9011 defsubr (&Sx_create_frame
);
9012 defsubr (&Sx_open_connection
);
9013 defsubr (&Sx_close_connection
);
9014 defsubr (&Sx_display_list
);
9015 defsubr (&Sx_synchronize
);
9016 defsubr (&Sx_focus_frame
);
9018 /* W32 specific functions */
9020 defsubr (&Sw32_select_font
);
9021 defsubr (&Sw32_define_rgb_color
);
9022 defsubr (&Sw32_default_color_map
);
9023 defsubr (&Sw32_load_color_file
);
9024 defsubr (&Sw32_send_sys_command
);
9025 defsubr (&Sw32_shell_execute
);
9026 defsubr (&Sw32_register_hot_key
);
9027 defsubr (&Sw32_unregister_hot_key
);
9028 defsubr (&Sw32_registered_hot_keys
);
9029 defsubr (&Sw32_reconstruct_hot_key
);
9030 defsubr (&Sw32_toggle_lock_key
);
9031 defsubr (&Sw32_window_exists_p
);
9032 defsubr (&Sw32_find_bdf_fonts
);
9034 defsubr (&Sfile_system_info
);
9035 defsubr (&Sdefault_printer_name
);
9037 /* Setting callback functions for fontset handler. */
9038 get_font_info_func
= w32_get_font_info
;
9040 #if 0 /* This function pointer doesn't seem to be used anywhere.
9041 And the pointer assigned has the wrong type, anyway. */
9042 list_fonts_func
= w32_list_fonts
;
9045 load_font_func
= w32_load_font
;
9046 find_ccl_program_func
= w32_find_ccl_program
;
9047 query_font_func
= w32_query_font
;
9048 set_frame_fontset_func
= x_set_font
;
9049 check_window_system_func
= check_w32
;
9052 hourglass_atimer
= NULL
;
9053 hourglass_shown_p
= 0;
9054 defsubr (&Sx_show_tip
);
9055 defsubr (&Sx_hide_tip
);
9057 staticpro (&tip_timer
);
9059 staticpro (&tip_frame
);
9061 last_show_tip_args
= Qnil
;
9062 staticpro (&last_show_tip_args
);
9064 defsubr (&Sx_file_dialog
);
9069 globals_of_w32fns is used to initialize those global variables that
9070 must always be initialized on startup even when the global variable
9071 initialized is non zero (see the function main in emacs.c).
9072 globals_of_w32fns is called from syms_of_w32fns when the global
9073 variable initialized is 0 and directly from main when initialized
9076 void globals_of_w32fns ()
9078 HMODULE user32_lib
= GetModuleHandle ("user32.dll");
9080 TrackMouseEvent not available in all versions of Windows, so must load
9081 it dynamically. Do it once, here, instead of every time it is used.
9083 track_mouse_event_fn
= (TrackMouseEvent_Proc
)
9084 GetProcAddress (user32_lib
, "TrackMouseEvent");
9085 /* ditto for GetClipboardSequenceNumber. */
9086 clipboard_sequence_fn
= (ClipboardSequence_Proc
)
9087 GetProcAddress (user32_lib
, "GetClipboardSequenceNumber");
9089 DEFVAR_INT ("w32-ansi-code-page",
9090 &w32_ansi_code_page
,
9091 doc
: /* The ANSI code page used by the system. */);
9092 w32_ansi_code_page
= GetACP ();
9094 /* MessageBox does not work without this when linked to comctl32.dll 6.0. */
9095 InitCommonControls ();
9104 button
= MessageBox (NULL
,
9105 "A fatal error has occurred!\n\n"
9106 "Would you like to attach a debugger?\n\n"
9107 "Select YES to debug, NO to abort Emacs"
9109 "\n\n(type \"gdb -p <emacs-PID>\" and\n"
9110 "\"continue\" inside GDB before clicking YES.)"
9112 , "Emacs Abort Dialog",
9113 MB_ICONEXCLAMATION
| MB_TASKMODAL
9114 | MB_SETFOREGROUND
| MB_YESNO
);
9119 exit (2); /* tell the compiler we will never return */
9127 /* For convenience when debugging. */
9131 return GetLastError ();
9134 /* arch-tag: 707589ab-b9be-4638-8cdd-74629cc9b446
9135 (do not change this comment) */