1 /* Graphical user interface functions for the Microsoft W32 API.
3 Copyright (C) 1989, 1992-2011
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 /* Added by Kevin Gallo */
37 #include "intervals.h"
38 #include "dispextern.h"
40 #include "blockinput.h"
42 #include "character.h"
48 #include "termhooks.h"
52 #include "bitmaps/gray.xbm"
63 #define FILE_NAME_TEXT_FIELD edt1
68 #ifndef FOF_NO_CONNECTED_ELEMENTS
69 #define FOF_NO_CONNECTED_ELEMENTS 0x2000
72 void syms_of_w32fns (void);
73 void globals_of_w32fns (void);
75 extern void free_frame_menubar (struct frame
*);
76 extern double atof (const char *);
77 extern int w32_console_toggle_lock_key (int, Lisp_Object
);
78 extern void w32_menu_display_help (HWND
, HMENU
, UINT
, UINT
);
79 extern void w32_free_menu_strings (HWND
);
80 extern const char *map_w32_filename (const char *, const char **);
84 extern const char *const lispy_function_keys
[];
86 /* If non-zero, a w32 timer that, when it expires, displays an
87 hourglass cursor on all frames. */
88 static unsigned hourglass_timer
= 0;
89 static HWND hourglass_hwnd
= NULL
;
92 #define IDC_HAND MAKEINTRESOURCE(32649)
95 /* Nonzero if using Windows. */
97 static int w32_in_use
;
100 Lisp_Object Qsuppress_icon
;
101 Lisp_Object Qundefined_color
;
102 Lisp_Object Qcancel_timer
;
103 Lisp_Object Qfont_param
;
109 Lisp_Object Qcontrol
;
113 /* Prefix for system colors. */
114 #define SYSTEM_COLOR_PREFIX "System"
115 #define SYSTEM_COLOR_PREFIX_LEN (sizeof (SYSTEM_COLOR_PREFIX) - 1)
117 /* State variables for emulating a three button mouse. */
122 static int button_state
= 0;
123 static W32Msg saved_mouse_button_msg
;
124 static unsigned mouse_button_timer
= 0; /* non-zero when timer is active */
125 static W32Msg saved_mouse_move_msg
;
126 static unsigned mouse_move_timer
= 0;
128 /* Window that is tracking the mouse. */
129 static HWND track_mouse_window
;
131 /* Multi-monitor API definitions that are not pulled from the headers
132 since we are compiling for NT 4. */
133 #ifndef MONITOR_DEFAULT_TO_NEAREST
134 #define MONITOR_DEFAULT_TO_NEAREST 2
136 /* MinGW headers define MONITORINFO unconditionally, but MSVC ones don't.
137 To avoid a compile error on one or the other, redefine with a new name. */
146 /* Reportedly, VS 6 does not have this in its headers. */
147 #if defined (_MSC_VER) && _MSC_VER < 1300
148 DECLARE_HANDLE(HMONITOR
);
151 typedef BOOL (WINAPI
* TrackMouseEvent_Proc
)
152 (IN OUT LPTRACKMOUSEEVENT lpEventTrack
);
153 typedef LONG (WINAPI
* ImmGetCompositionString_Proc
)
154 (IN HIMC context
, IN DWORD index
, OUT LPVOID buffer
, IN DWORD bufLen
);
155 typedef HIMC (WINAPI
* ImmGetContext_Proc
) (IN HWND window
);
156 typedef HWND (WINAPI
* ImmReleaseContext_Proc
) (IN HWND wnd
, IN HIMC context
);
157 typedef HWND (WINAPI
* ImmSetCompositionWindow_Proc
) (IN HIMC context
,
158 IN COMPOSITIONFORM
*form
);
159 typedef HMONITOR (WINAPI
* MonitorFromPoint_Proc
) (IN POINT pt
, IN DWORD flags
);
160 typedef BOOL (WINAPI
* GetMonitorInfo_Proc
)
161 (IN HMONITOR monitor
, OUT
struct MONITOR_INFO
* info
);
163 TrackMouseEvent_Proc track_mouse_event_fn
= NULL
;
164 ImmGetCompositionString_Proc get_composition_string_fn
= NULL
;
165 ImmGetContext_Proc get_ime_context_fn
= NULL
;
166 ImmReleaseContext_Proc release_ime_context_fn
= NULL
;
167 ImmSetCompositionWindow_Proc set_ime_composition_window_fn
= NULL
;
168 MonitorFromPoint_Proc monitor_from_point_fn
= NULL
;
169 GetMonitorInfo_Proc get_monitor_info_fn
= NULL
;
171 extern AppendMenuW_Proc unicode_append_menu
;
173 /* Flag to selectively ignore WM_IME_CHAR messages. */
174 static int ignore_ime_char
= 0;
176 /* W95 mousewheel handler */
177 unsigned int msh_mousewheel
= 0;
180 #define MOUSE_BUTTON_ID 1
181 #define MOUSE_MOVE_ID 2
182 #define MENU_FREE_ID 3
183 #define HOURGLASS_ID 4
184 /* The delay (milliseconds) before a menu is freed after WM_EXITMENULOOP
186 #define MENU_FREE_DELAY 1000
187 static unsigned menu_free_timer
= 0;
189 extern Lisp_Object Qtooltip
;
192 int image_cache_refcount
, dpyinfo_refcount
;
196 extern HWND w32_system_caret_hwnd
;
198 extern int w32_system_caret_height
;
199 extern int w32_system_caret_x
;
200 extern int w32_system_caret_y
;
201 static HWND w32_visible_system_caret_hwnd
;
204 extern HMENU current_popup_menu
;
205 static int menubar_in_use
= 0;
207 /* From w32uniscribe.c */
208 extern void syms_of_w32uniscribe (void);
209 extern int uniscribe_available
;
211 /* Function prototypes for hourglass support. */
212 static void w32_show_hourglass (struct frame
*);
213 static void w32_hide_hourglass (void);
217 /* Error if we are not connected to MS-Windows. */
222 error ("MS-Windows not in use or not initialized");
225 /* Nonzero if we can use mouse menus.
226 You should not call this unless HAVE_MENUS is defined. */
234 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
235 and checking validity for W32. */
238 check_x_frame (Lisp_Object frame
)
243 frame
= selected_frame
;
244 CHECK_LIVE_FRAME (frame
);
246 if (! FRAME_W32_P (f
))
247 error ("Non-W32 frame used");
251 /* Let the user specify a display with a frame.
252 nil stands for the selected frame--or, if that is not a w32 frame,
253 the first display on the list. */
255 struct w32_display_info
*
256 check_x_display_info (Lisp_Object frame
)
260 struct frame
*sf
= XFRAME (selected_frame
);
262 if (FRAME_W32_P (sf
) && FRAME_LIVE_P (sf
))
263 return FRAME_W32_DISPLAY_INFO (sf
);
265 return &one_w32_display_info
;
267 else if (STRINGP (frame
))
268 return x_display_info_for_name (frame
);
273 CHECK_LIVE_FRAME (frame
);
275 if (! FRAME_W32_P (f
))
276 error ("Non-W32 frame used");
277 return FRAME_W32_DISPLAY_INFO (f
);
281 /* Return the Emacs frame-object corresponding to an w32 window.
282 It could be the frame's main window or an icon window. */
284 /* This function can be called during GC, so use GC_xxx type test macros. */
287 x_window_to_frame (struct w32_display_info
*dpyinfo
, HWND wdesc
)
289 Lisp_Object tail
, frame
;
292 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
298 if (!FRAME_W32_P (f
) || FRAME_W32_DISPLAY_INFO (f
) != dpyinfo
)
301 if (FRAME_W32_WINDOW (f
) == wdesc
)
308 static Lisp_Object
unwind_create_frame (Lisp_Object
);
309 static Lisp_Object
unwind_create_tip_frame (Lisp_Object
);
310 static void my_create_window (struct frame
*);
311 static void my_create_tip_window (struct frame
*);
313 /* TODO: Native Input Method support; see x_create_im. */
314 void x_set_foreground_color (struct frame
*, Lisp_Object
, Lisp_Object
);
315 void x_set_background_color (struct frame
*, Lisp_Object
, Lisp_Object
);
316 void x_set_mouse_color (struct frame
*, Lisp_Object
, Lisp_Object
);
317 void x_set_cursor_color (struct frame
*, Lisp_Object
, Lisp_Object
);
318 void x_set_border_color (struct frame
*, Lisp_Object
, Lisp_Object
);
319 void x_set_cursor_type (struct frame
*, Lisp_Object
, Lisp_Object
);
320 void x_set_icon_type (struct frame
*, Lisp_Object
, Lisp_Object
);
321 void x_set_icon_name (struct frame
*, Lisp_Object
, Lisp_Object
);
322 void x_explicitly_set_name (struct frame
*, Lisp_Object
, Lisp_Object
);
323 void x_set_menu_bar_lines (struct frame
*, Lisp_Object
, Lisp_Object
);
324 void x_set_title (struct frame
*, Lisp_Object
, Lisp_Object
);
325 void x_set_tool_bar_lines (struct frame
*, Lisp_Object
, Lisp_Object
);
330 /* Store the screen positions of frame F into XPTR and YPTR.
331 These are the positions of the containing window manager window,
332 not Emacs's own window. */
335 x_real_positions (FRAME_PTR f
, int *xptr
, int *yptr
)
340 /* Get the bounds of the WM window. */
341 GetWindowRect (FRAME_W32_WINDOW (f
), &rect
);
346 /* Convert (0, 0) in the client area to screen co-ordinates. */
347 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
349 /* Remember x_pixels_diff and y_pixels_diff. */
350 f
->x_pixels_diff
= pt
.x
- rect
.left
;
351 f
->y_pixels_diff
= pt
.y
- rect
.top
;
359 DEFUN ("w32-define-rgb-color", Fw32_define_rgb_color
,
360 Sw32_define_rgb_color
, 4, 4, 0,
361 doc
: /* Convert RGB numbers to a Windows color reference and associate with NAME.
362 This adds or updates a named color to `w32-color-map', making it
363 available for use. The original entry's RGB ref is returned, or nil
364 if the entry is new. */)
365 (Lisp_Object red
, Lisp_Object green
, Lisp_Object blue
, Lisp_Object name
)
368 Lisp_Object oldrgb
= Qnil
;
372 CHECK_NUMBER (green
);
376 XSETINT (rgb
, RGB (XUINT (red
), XUINT (green
), XUINT (blue
)));
380 /* replace existing entry in w32-color-map or add new entry. */
381 entry
= Fassoc (name
, Vw32_color_map
);
384 entry
= Fcons (name
, rgb
);
385 Vw32_color_map
= Fcons (entry
, Vw32_color_map
);
389 oldrgb
= Fcdr (entry
);
390 Fsetcdr (entry
, rgb
);
398 /* The default colors for the w32 color map */
399 typedef struct colormap_t
405 colormap_t w32_color_map
[] =
407 {"snow" , PALETTERGB (255,250,250)},
408 {"ghost white" , PALETTERGB (248,248,255)},
409 {"GhostWhite" , PALETTERGB (248,248,255)},
410 {"white smoke" , PALETTERGB (245,245,245)},
411 {"WhiteSmoke" , PALETTERGB (245,245,245)},
412 {"gainsboro" , PALETTERGB (220,220,220)},
413 {"floral white" , PALETTERGB (255,250,240)},
414 {"FloralWhite" , PALETTERGB (255,250,240)},
415 {"old lace" , PALETTERGB (253,245,230)},
416 {"OldLace" , PALETTERGB (253,245,230)},
417 {"linen" , PALETTERGB (250,240,230)},
418 {"antique white" , PALETTERGB (250,235,215)},
419 {"AntiqueWhite" , PALETTERGB (250,235,215)},
420 {"papaya whip" , PALETTERGB (255,239,213)},
421 {"PapayaWhip" , PALETTERGB (255,239,213)},
422 {"blanched almond" , PALETTERGB (255,235,205)},
423 {"BlanchedAlmond" , PALETTERGB (255,235,205)},
424 {"bisque" , PALETTERGB (255,228,196)},
425 {"peach puff" , PALETTERGB (255,218,185)},
426 {"PeachPuff" , PALETTERGB (255,218,185)},
427 {"navajo white" , PALETTERGB (255,222,173)},
428 {"NavajoWhite" , PALETTERGB (255,222,173)},
429 {"moccasin" , PALETTERGB (255,228,181)},
430 {"cornsilk" , PALETTERGB (255,248,220)},
431 {"ivory" , PALETTERGB (255,255,240)},
432 {"lemon chiffon" , PALETTERGB (255,250,205)},
433 {"LemonChiffon" , PALETTERGB (255,250,205)},
434 {"seashell" , PALETTERGB (255,245,238)},
435 {"honeydew" , PALETTERGB (240,255,240)},
436 {"mint cream" , PALETTERGB (245,255,250)},
437 {"MintCream" , PALETTERGB (245,255,250)},
438 {"azure" , PALETTERGB (240,255,255)},
439 {"alice blue" , PALETTERGB (240,248,255)},
440 {"AliceBlue" , PALETTERGB (240,248,255)},
441 {"lavender" , PALETTERGB (230,230,250)},
442 {"lavender blush" , PALETTERGB (255,240,245)},
443 {"LavenderBlush" , PALETTERGB (255,240,245)},
444 {"misty rose" , PALETTERGB (255,228,225)},
445 {"MistyRose" , PALETTERGB (255,228,225)},
446 {"white" , PALETTERGB (255,255,255)},
447 {"black" , PALETTERGB ( 0, 0, 0)},
448 {"dark slate gray" , PALETTERGB ( 47, 79, 79)},
449 {"DarkSlateGray" , PALETTERGB ( 47, 79, 79)},
450 {"dark slate grey" , PALETTERGB ( 47, 79, 79)},
451 {"DarkSlateGrey" , PALETTERGB ( 47, 79, 79)},
452 {"dim gray" , PALETTERGB (105,105,105)},
453 {"DimGray" , PALETTERGB (105,105,105)},
454 {"dim grey" , PALETTERGB (105,105,105)},
455 {"DimGrey" , PALETTERGB (105,105,105)},
456 {"slate gray" , PALETTERGB (112,128,144)},
457 {"SlateGray" , PALETTERGB (112,128,144)},
458 {"slate grey" , PALETTERGB (112,128,144)},
459 {"SlateGrey" , PALETTERGB (112,128,144)},
460 {"light slate gray" , PALETTERGB (119,136,153)},
461 {"LightSlateGray" , PALETTERGB (119,136,153)},
462 {"light slate grey" , PALETTERGB (119,136,153)},
463 {"LightSlateGrey" , PALETTERGB (119,136,153)},
464 {"gray" , PALETTERGB (190,190,190)},
465 {"grey" , PALETTERGB (190,190,190)},
466 {"light grey" , PALETTERGB (211,211,211)},
467 {"LightGrey" , PALETTERGB (211,211,211)},
468 {"light gray" , PALETTERGB (211,211,211)},
469 {"LightGray" , PALETTERGB (211,211,211)},
470 {"midnight blue" , PALETTERGB ( 25, 25,112)},
471 {"MidnightBlue" , PALETTERGB ( 25, 25,112)},
472 {"navy" , PALETTERGB ( 0, 0,128)},
473 {"navy blue" , PALETTERGB ( 0, 0,128)},
474 {"NavyBlue" , PALETTERGB ( 0, 0,128)},
475 {"cornflower blue" , PALETTERGB (100,149,237)},
476 {"CornflowerBlue" , PALETTERGB (100,149,237)},
477 {"dark slate blue" , PALETTERGB ( 72, 61,139)},
478 {"DarkSlateBlue" , PALETTERGB ( 72, 61,139)},
479 {"slate blue" , PALETTERGB (106, 90,205)},
480 {"SlateBlue" , PALETTERGB (106, 90,205)},
481 {"medium slate blue" , PALETTERGB (123,104,238)},
482 {"MediumSlateBlue" , PALETTERGB (123,104,238)},
483 {"light slate blue" , PALETTERGB (132,112,255)},
484 {"LightSlateBlue" , PALETTERGB (132,112,255)},
485 {"medium blue" , PALETTERGB ( 0, 0,205)},
486 {"MediumBlue" , PALETTERGB ( 0, 0,205)},
487 {"royal blue" , PALETTERGB ( 65,105,225)},
488 {"RoyalBlue" , PALETTERGB ( 65,105,225)},
489 {"blue" , PALETTERGB ( 0, 0,255)},
490 {"dodger blue" , PALETTERGB ( 30,144,255)},
491 {"DodgerBlue" , PALETTERGB ( 30,144,255)},
492 {"deep sky blue" , PALETTERGB ( 0,191,255)},
493 {"DeepSkyBlue" , PALETTERGB ( 0,191,255)},
494 {"sky blue" , PALETTERGB (135,206,235)},
495 {"SkyBlue" , PALETTERGB (135,206,235)},
496 {"light sky blue" , PALETTERGB (135,206,250)},
497 {"LightSkyBlue" , PALETTERGB (135,206,250)},
498 {"steel blue" , PALETTERGB ( 70,130,180)},
499 {"SteelBlue" , PALETTERGB ( 70,130,180)},
500 {"light steel blue" , PALETTERGB (176,196,222)},
501 {"LightSteelBlue" , PALETTERGB (176,196,222)},
502 {"light blue" , PALETTERGB (173,216,230)},
503 {"LightBlue" , PALETTERGB (173,216,230)},
504 {"powder blue" , PALETTERGB (176,224,230)},
505 {"PowderBlue" , PALETTERGB (176,224,230)},
506 {"pale turquoise" , PALETTERGB (175,238,238)},
507 {"PaleTurquoise" , PALETTERGB (175,238,238)},
508 {"dark turquoise" , PALETTERGB ( 0,206,209)},
509 {"DarkTurquoise" , PALETTERGB ( 0,206,209)},
510 {"medium turquoise" , PALETTERGB ( 72,209,204)},
511 {"MediumTurquoise" , PALETTERGB ( 72,209,204)},
512 {"turquoise" , PALETTERGB ( 64,224,208)},
513 {"cyan" , PALETTERGB ( 0,255,255)},
514 {"light cyan" , PALETTERGB (224,255,255)},
515 {"LightCyan" , PALETTERGB (224,255,255)},
516 {"cadet blue" , PALETTERGB ( 95,158,160)},
517 {"CadetBlue" , PALETTERGB ( 95,158,160)},
518 {"medium aquamarine" , PALETTERGB (102,205,170)},
519 {"MediumAquamarine" , PALETTERGB (102,205,170)},
520 {"aquamarine" , PALETTERGB (127,255,212)},
521 {"dark green" , PALETTERGB ( 0,100, 0)},
522 {"DarkGreen" , PALETTERGB ( 0,100, 0)},
523 {"dark olive green" , PALETTERGB ( 85,107, 47)},
524 {"DarkOliveGreen" , PALETTERGB ( 85,107, 47)},
525 {"dark sea green" , PALETTERGB (143,188,143)},
526 {"DarkSeaGreen" , PALETTERGB (143,188,143)},
527 {"sea green" , PALETTERGB ( 46,139, 87)},
528 {"SeaGreen" , PALETTERGB ( 46,139, 87)},
529 {"medium sea green" , PALETTERGB ( 60,179,113)},
530 {"MediumSeaGreen" , PALETTERGB ( 60,179,113)},
531 {"light sea green" , PALETTERGB ( 32,178,170)},
532 {"LightSeaGreen" , PALETTERGB ( 32,178,170)},
533 {"pale green" , PALETTERGB (152,251,152)},
534 {"PaleGreen" , PALETTERGB (152,251,152)},
535 {"spring green" , PALETTERGB ( 0,255,127)},
536 {"SpringGreen" , PALETTERGB ( 0,255,127)},
537 {"lawn green" , PALETTERGB (124,252, 0)},
538 {"LawnGreen" , PALETTERGB (124,252, 0)},
539 {"green" , PALETTERGB ( 0,255, 0)},
540 {"chartreuse" , PALETTERGB (127,255, 0)},
541 {"medium spring green" , PALETTERGB ( 0,250,154)},
542 {"MediumSpringGreen" , PALETTERGB ( 0,250,154)},
543 {"green yellow" , PALETTERGB (173,255, 47)},
544 {"GreenYellow" , PALETTERGB (173,255, 47)},
545 {"lime green" , PALETTERGB ( 50,205, 50)},
546 {"LimeGreen" , PALETTERGB ( 50,205, 50)},
547 {"yellow green" , PALETTERGB (154,205, 50)},
548 {"YellowGreen" , PALETTERGB (154,205, 50)},
549 {"forest green" , PALETTERGB ( 34,139, 34)},
550 {"ForestGreen" , PALETTERGB ( 34,139, 34)},
551 {"olive drab" , PALETTERGB (107,142, 35)},
552 {"OliveDrab" , PALETTERGB (107,142, 35)},
553 {"dark khaki" , PALETTERGB (189,183,107)},
554 {"DarkKhaki" , PALETTERGB (189,183,107)},
555 {"khaki" , PALETTERGB (240,230,140)},
556 {"pale goldenrod" , PALETTERGB (238,232,170)},
557 {"PaleGoldenrod" , PALETTERGB (238,232,170)},
558 {"light goldenrod yellow" , PALETTERGB (250,250,210)},
559 {"LightGoldenrodYellow" , PALETTERGB (250,250,210)},
560 {"light yellow" , PALETTERGB (255,255,224)},
561 {"LightYellow" , PALETTERGB (255,255,224)},
562 {"yellow" , PALETTERGB (255,255, 0)},
563 {"gold" , PALETTERGB (255,215, 0)},
564 {"light goldenrod" , PALETTERGB (238,221,130)},
565 {"LightGoldenrod" , PALETTERGB (238,221,130)},
566 {"goldenrod" , PALETTERGB (218,165, 32)},
567 {"dark goldenrod" , PALETTERGB (184,134, 11)},
568 {"DarkGoldenrod" , PALETTERGB (184,134, 11)},
569 {"rosy brown" , PALETTERGB (188,143,143)},
570 {"RosyBrown" , PALETTERGB (188,143,143)},
571 {"indian red" , PALETTERGB (205, 92, 92)},
572 {"IndianRed" , PALETTERGB (205, 92, 92)},
573 {"saddle brown" , PALETTERGB (139, 69, 19)},
574 {"SaddleBrown" , PALETTERGB (139, 69, 19)},
575 {"sienna" , PALETTERGB (160, 82, 45)},
576 {"peru" , PALETTERGB (205,133, 63)},
577 {"burlywood" , PALETTERGB (222,184,135)},
578 {"beige" , PALETTERGB (245,245,220)},
579 {"wheat" , PALETTERGB (245,222,179)},
580 {"sandy brown" , PALETTERGB (244,164, 96)},
581 {"SandyBrown" , PALETTERGB (244,164, 96)},
582 {"tan" , PALETTERGB (210,180,140)},
583 {"chocolate" , PALETTERGB (210,105, 30)},
584 {"firebrick" , PALETTERGB (178,34, 34)},
585 {"brown" , PALETTERGB (165,42, 42)},
586 {"dark salmon" , PALETTERGB (233,150,122)},
587 {"DarkSalmon" , PALETTERGB (233,150,122)},
588 {"salmon" , PALETTERGB (250,128,114)},
589 {"light salmon" , PALETTERGB (255,160,122)},
590 {"LightSalmon" , PALETTERGB (255,160,122)},
591 {"orange" , PALETTERGB (255,165, 0)},
592 {"dark orange" , PALETTERGB (255,140, 0)},
593 {"DarkOrange" , PALETTERGB (255,140, 0)},
594 {"coral" , PALETTERGB (255,127, 80)},
595 {"light coral" , PALETTERGB (240,128,128)},
596 {"LightCoral" , PALETTERGB (240,128,128)},
597 {"tomato" , PALETTERGB (255, 99, 71)},
598 {"orange red" , PALETTERGB (255, 69, 0)},
599 {"OrangeRed" , PALETTERGB (255, 69, 0)},
600 {"red" , PALETTERGB (255, 0, 0)},
601 {"hot pink" , PALETTERGB (255,105,180)},
602 {"HotPink" , PALETTERGB (255,105,180)},
603 {"deep pink" , PALETTERGB (255, 20,147)},
604 {"DeepPink" , PALETTERGB (255, 20,147)},
605 {"pink" , PALETTERGB (255,192,203)},
606 {"light pink" , PALETTERGB (255,182,193)},
607 {"LightPink" , PALETTERGB (255,182,193)},
608 {"pale violet red" , PALETTERGB (219,112,147)},
609 {"PaleVioletRed" , PALETTERGB (219,112,147)},
610 {"maroon" , PALETTERGB (176, 48, 96)},
611 {"medium violet red" , PALETTERGB (199, 21,133)},
612 {"MediumVioletRed" , PALETTERGB (199, 21,133)},
613 {"violet red" , PALETTERGB (208, 32,144)},
614 {"VioletRed" , PALETTERGB (208, 32,144)},
615 {"magenta" , PALETTERGB (255, 0,255)},
616 {"violet" , PALETTERGB (238,130,238)},
617 {"plum" , PALETTERGB (221,160,221)},
618 {"orchid" , PALETTERGB (218,112,214)},
619 {"medium orchid" , PALETTERGB (186, 85,211)},
620 {"MediumOrchid" , PALETTERGB (186, 85,211)},
621 {"dark orchid" , PALETTERGB (153, 50,204)},
622 {"DarkOrchid" , PALETTERGB (153, 50,204)},
623 {"dark violet" , PALETTERGB (148, 0,211)},
624 {"DarkViolet" , PALETTERGB (148, 0,211)},
625 {"blue violet" , PALETTERGB (138, 43,226)},
626 {"BlueViolet" , PALETTERGB (138, 43,226)},
627 {"purple" , PALETTERGB (160, 32,240)},
628 {"medium purple" , PALETTERGB (147,112,219)},
629 {"MediumPurple" , PALETTERGB (147,112,219)},
630 {"thistle" , PALETTERGB (216,191,216)},
631 {"gray0" , PALETTERGB ( 0, 0, 0)},
632 {"grey0" , PALETTERGB ( 0, 0, 0)},
633 {"dark grey" , PALETTERGB (169,169,169)},
634 {"DarkGrey" , PALETTERGB (169,169,169)},
635 {"dark gray" , PALETTERGB (169,169,169)},
636 {"DarkGray" , PALETTERGB (169,169,169)},
637 {"dark blue" , PALETTERGB ( 0, 0,139)},
638 {"DarkBlue" , PALETTERGB ( 0, 0,139)},
639 {"dark cyan" , PALETTERGB ( 0,139,139)},
640 {"DarkCyan" , PALETTERGB ( 0,139,139)},
641 {"dark magenta" , PALETTERGB (139, 0,139)},
642 {"DarkMagenta" , PALETTERGB (139, 0,139)},
643 {"dark red" , PALETTERGB (139, 0, 0)},
644 {"DarkRed" , PALETTERGB (139, 0, 0)},
645 {"light green" , PALETTERGB (144,238,144)},
646 {"LightGreen" , PALETTERGB (144,238,144)},
649 DEFUN ("w32-default-color-map", Fw32_default_color_map
, Sw32_default_color_map
,
650 0, 0, 0, doc
: /* Return the default color map. */)
654 colormap_t
*pc
= w32_color_map
;
661 for (i
= 0; i
< sizeof (w32_color_map
) / sizeof (w32_color_map
[0]);
663 cmap
= Fcons (Fcons (build_string (pc
->name
),
664 make_number (pc
->colorref
)),
673 w32_color_map_lookup (char *colorname
)
675 Lisp_Object tail
, ret
= Qnil
;
679 for (tail
= Vw32_color_map
; CONSP (tail
); tail
= XCDR (tail
))
681 register Lisp_Object elt
, tem
;
684 if (!CONSP (elt
)) continue;
688 if (lstrcmpi (SDATA (tem
), colorname
) == 0)
705 add_system_logical_colors_to_map (Lisp_Object
*system_colors
)
709 /* Other registry operations are done with input blocked. */
712 /* Look for "Control Panel/Colors" under User and Machine registry
714 if (RegOpenKeyEx (HKEY_CURRENT_USER
, "Control Panel\\Colors", 0,
715 KEY_READ
, &colors_key
) == ERROR_SUCCESS
716 || RegOpenKeyEx (HKEY_LOCAL_MACHINE
, "Control Panel\\Colors", 0,
717 KEY_READ
, &colors_key
) == ERROR_SUCCESS
)
720 char color_buffer
[64];
721 char full_name_buffer
[MAX_PATH
+ SYSTEM_COLOR_PREFIX_LEN
];
723 DWORD name_size
, color_size
;
724 char *name_buffer
= full_name_buffer
+ SYSTEM_COLOR_PREFIX_LEN
;
726 name_size
= sizeof (full_name_buffer
) - SYSTEM_COLOR_PREFIX_LEN
;
727 color_size
= sizeof (color_buffer
);
729 strcpy (full_name_buffer
, SYSTEM_COLOR_PREFIX
);
731 while (RegEnumValueA (colors_key
, index
, name_buffer
, &name_size
,
732 NULL
, NULL
, color_buffer
, &color_size
)
736 if (sscanf (color_buffer
, " %u %u %u", &r
, &g
, &b
) == 3)
737 *system_colors
= Fcons (Fcons (build_string (full_name_buffer
),
738 make_number (RGB (r
, g
, b
))),
741 name_size
= sizeof (full_name_buffer
) - SYSTEM_COLOR_PREFIX_LEN
;
742 color_size
= sizeof (color_buffer
);
745 RegCloseKey (colors_key
);
753 x_to_w32_color (char * colorname
)
755 register Lisp_Object ret
= Qnil
;
759 if (colorname
[0] == '#')
761 /* Could be an old-style RGB Device specification. */
764 color
= colorname
+ 1;
766 size
= strlen (color
);
767 if (size
== 3 || size
== 6 || size
== 9 || size
== 12)
775 for (i
= 0; i
< 3; i
++)
781 /* The check for 'x' in the following conditional takes into
782 account the fact that strtol allows a "0x" in front of
783 our numbers, and we don't. */
784 if (!isxdigit (color
[0]) || color
[1] == 'x')
788 value
= strtoul (color
, &end
, 16);
790 if (errno
== ERANGE
|| end
- color
!= size
)
795 value
= value
* 0x10;
806 colorval
|= (value
<< pos
);
811 XSETINT (ret
, colorval
);
818 else if (strnicmp (colorname
, "rgb:", 4) == 0)
826 color
= colorname
+ 4;
827 for (i
= 0; i
< 3; i
++)
832 /* The check for 'x' in the following conditional takes into
833 account the fact that strtol allows a "0x" in front of
834 our numbers, and we don't. */
835 if (!isxdigit (color
[0]) || color
[1] == 'x')
837 value
= strtoul (color
, &end
, 16);
843 value
= value
* 0x10 + value
;
856 if (value
== ULONG_MAX
)
858 colorval
|= (value
<< pos
);
865 XSETINT (ret
, colorval
);
873 else if (strnicmp (colorname
, "rgbi:", 5) == 0)
875 /* This is an RGB Intensity specification. */
882 color
= colorname
+ 5;
883 for (i
= 0; i
< 3; i
++)
889 value
= strtod (color
, &end
);
892 if (value
< 0.0 || value
> 1.0)
894 val
= (UINT
)(0x100 * value
);
895 /* We used 0x100 instead of 0xFF to give a continuous
896 range between 0.0 and 1.0 inclusive. The next statement
897 fixes the 1.0 case. */
900 colorval
|= (val
<< pos
);
907 XSETINT (ret
, colorval
);
915 /* I am not going to attempt to handle any of the CIE color schemes
916 or TekHVC, since I don't know the algorithms for conversion to
919 /* If we fail to lookup the color name in w32_color_map, then check the
920 colorname to see if it can be crudely approximated: If the X color
921 ends in a number (e.g., "darkseagreen2"), strip the number and
922 return the result of looking up the base color name. */
923 ret
= w32_color_map_lookup (colorname
);
926 int len
= strlen (colorname
);
928 if (isdigit (colorname
[len
- 1]))
930 char *ptr
, *approx
= alloca (len
+ 1);
932 strcpy (approx
, colorname
);
933 ptr
= &approx
[len
- 1];
934 while (ptr
> approx
&& isdigit (*ptr
))
937 ret
= w32_color_map_lookup (approx
);
946 w32_regenerate_palette (FRAME_PTR f
)
948 struct w32_palette_entry
* list
;
949 LOGPALETTE
* log_palette
;
950 HPALETTE new_palette
;
953 /* don't bother trying to create palette if not supported */
954 if (! FRAME_W32_DISPLAY_INFO (f
)->has_palette
)
957 log_palette
= (LOGPALETTE
*)
958 alloca (sizeof (LOGPALETTE
) +
959 FRAME_W32_DISPLAY_INFO (f
)->num_colors
* sizeof (PALETTEENTRY
));
960 log_palette
->palVersion
= 0x300;
961 log_palette
->palNumEntries
= FRAME_W32_DISPLAY_INFO (f
)->num_colors
;
963 list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
965 i
< FRAME_W32_DISPLAY_INFO (f
)->num_colors
;
966 i
++, list
= list
->next
)
967 log_palette
->palPalEntry
[i
] = list
->entry
;
969 new_palette
= CreatePalette (log_palette
);
973 if (FRAME_W32_DISPLAY_INFO (f
)->palette
)
974 DeleteObject (FRAME_W32_DISPLAY_INFO (f
)->palette
);
975 FRAME_W32_DISPLAY_INFO (f
)->palette
= new_palette
;
977 /* Realize display palette and garbage all frames. */
978 release_frame_dc (f
, get_frame_dc (f
));
983 #define W32_COLOR(pe) RGB (pe.peRed, pe.peGreen, pe.peBlue)
984 #define SET_W32_COLOR(pe, color) \
987 pe.peRed = GetRValue (color); \
988 pe.peGreen = GetGValue (color); \
989 pe.peBlue = GetBValue (color); \
994 /* Keep these around in case we ever want to track color usage. */
996 w32_map_color (FRAME_PTR f
, COLORREF color
)
998 struct w32_palette_entry
* list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1000 if (NILP (Vw32_enable_palette
))
1003 /* check if color is already mapped */
1006 if (W32_COLOR (list
->entry
) == color
)
1014 /* not already mapped, so add to list and recreate Windows palette */
1015 list
= (struct w32_palette_entry
*)
1016 xmalloc (sizeof (struct w32_palette_entry
));
1017 SET_W32_COLOR (list
->entry
, color
);
1019 list
->next
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1020 FRAME_W32_DISPLAY_INFO (f
)->color_list
= list
;
1021 FRAME_W32_DISPLAY_INFO (f
)->num_colors
++;
1023 /* set flag that palette must be regenerated */
1024 FRAME_W32_DISPLAY_INFO (f
)->regen_palette
= TRUE
;
1028 w32_unmap_color (FRAME_PTR f
, COLORREF color
)
1030 struct w32_palette_entry
* list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1031 struct w32_palette_entry
**prev
= &FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1033 if (NILP (Vw32_enable_palette
))
1036 /* check if color is already mapped */
1039 if (W32_COLOR (list
->entry
) == color
)
1041 if (--list
->refcount
== 0)
1045 FRAME_W32_DISPLAY_INFO (f
)->num_colors
--;
1055 /* set flag that palette must be regenerated */
1056 FRAME_W32_DISPLAY_INFO (f
)->regen_palette
= TRUE
;
1061 /* Gamma-correct COLOR on frame F. */
1064 gamma_correct (struct frame
*f
, COLORREF
*color
)
1068 *color
= PALETTERGB (
1069 pow (GetRValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5,
1070 pow (GetGValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5,
1071 pow (GetBValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5);
1076 /* Decide if color named COLOR is valid for the display associated with
1077 the selected frame; if so, return the rgb values in COLOR_DEF.
1078 If ALLOC is nonzero, allocate a new colormap cell. */
1081 w32_defined_color (FRAME_PTR f
, char *color
, XColor
*color_def
, int alloc
)
1083 register Lisp_Object tem
;
1084 COLORREF w32_color_ref
;
1086 tem
= x_to_w32_color (color
);
1092 /* Apply gamma correction. */
1093 w32_color_ref
= XUINT (tem
);
1094 gamma_correct (f
, &w32_color_ref
);
1095 XSETINT (tem
, w32_color_ref
);
1098 /* Map this color to the palette if it is enabled. */
1099 if (!NILP (Vw32_enable_palette
))
1101 struct w32_palette_entry
* entry
=
1102 one_w32_display_info
.color_list
;
1103 struct w32_palette_entry
** prev
=
1104 &one_w32_display_info
.color_list
;
1106 /* check if color is already mapped */
1109 if (W32_COLOR (entry
->entry
) == XUINT (tem
))
1111 prev
= &entry
->next
;
1112 entry
= entry
->next
;
1115 if (entry
== NULL
&& alloc
)
1117 /* not already mapped, so add to list */
1118 entry
= (struct w32_palette_entry
*)
1119 xmalloc (sizeof (struct w32_palette_entry
));
1120 SET_W32_COLOR (entry
->entry
, XUINT (tem
));
1123 one_w32_display_info
.num_colors
++;
1125 /* set flag that palette must be regenerated */
1126 one_w32_display_info
.regen_palette
= TRUE
;
1129 /* Ensure COLORREF value is snapped to nearest color in (default)
1130 palette by simulating the PALETTERGB macro. This works whether
1131 or not the display device has a palette. */
1132 w32_color_ref
= XUINT (tem
) | 0x2000000;
1134 color_def
->pixel
= w32_color_ref
;
1135 color_def
->red
= GetRValue (w32_color_ref
) * 256;
1136 color_def
->green
= GetGValue (w32_color_ref
) * 256;
1137 color_def
->blue
= GetBValue (w32_color_ref
) * 256;
1147 /* Given a string ARG naming a color, compute a pixel value from it
1148 suitable for screen F.
1149 If F is not a color screen, return DEF (default) regardless of what
1153 x_decode_color (FRAME_PTR f
, Lisp_Object arg
, int def
)
1159 if (strcmp (SDATA (arg
), "black") == 0)
1160 return BLACK_PIX_DEFAULT (f
);
1161 else if (strcmp (SDATA (arg
), "white") == 0)
1162 return WHITE_PIX_DEFAULT (f
);
1164 if ((FRAME_W32_DISPLAY_INFO (f
)->n_planes
* FRAME_W32_DISPLAY_INFO (f
)->n_cbits
) == 1)
1167 /* w32_defined_color is responsible for coping with failures
1168 by looking for a near-miss. */
1169 if (w32_defined_color (f
, SDATA (arg
), &cdef
, 1))
1172 /* defined_color failed; return an ultimate default. */
1178 /* Functions called only from `x_set_frame_param'
1179 to set individual parameters.
1181 If FRAME_W32_WINDOW (f) is 0,
1182 the frame is being created and its window does not exist yet.
1183 In that case, just record the parameter's new value
1184 in the standard place; do not attempt to change the window. */
1187 x_set_foreground_color (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
1189 struct w32_output
*x
= f
->output_data
.w32
;
1190 PIX_TYPE fg
, old_fg
;
1192 fg
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1193 old_fg
= FRAME_FOREGROUND_PIXEL (f
);
1194 FRAME_FOREGROUND_PIXEL (f
) = fg
;
1196 if (FRAME_W32_WINDOW (f
) != 0)
1198 if (x
->cursor_pixel
== old_fg
)
1200 x
->cursor_pixel
= fg
;
1201 x
->cursor_gc
->background
= fg
;
1204 update_face_from_frame_parameter (f
, Qforeground_color
, arg
);
1205 if (FRAME_VISIBLE_P (f
))
1211 x_set_background_color (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
1213 FRAME_BACKGROUND_PIXEL (f
)
1214 = x_decode_color (f
, arg
, WHITE_PIX_DEFAULT (f
));
1216 if (FRAME_W32_WINDOW (f
) != 0)
1218 SetWindowLong (FRAME_W32_WINDOW (f
), WND_BACKGROUND_INDEX
,
1219 FRAME_BACKGROUND_PIXEL (f
));
1221 update_face_from_frame_parameter (f
, Qbackground_color
, arg
);
1223 if (FRAME_VISIBLE_P (f
))
1229 x_set_mouse_color (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
1231 Cursor cursor
, nontext_cursor
, mode_cursor
, hand_cursor
;
1235 if (!EQ (Qnil
, arg
))
1236 f
->output_data
.w32
->mouse_pixel
1237 = x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1238 mask_color
= FRAME_BACKGROUND_PIXEL (f
);
1240 /* Don't let pointers be invisible. */
1241 if (mask_color
== f
->output_data
.w32
->mouse_pixel
1242 && mask_color
== FRAME_BACKGROUND_PIXEL (f
))
1243 f
->output_data
.w32
->mouse_pixel
= FRAME_FOREGROUND_PIXEL (f
);
1245 #if 0 /* TODO : Mouse cursor customization. */
1248 /* It's not okay to crash if the user selects a screwy cursor. */
1249 count
= x_catch_errors (FRAME_W32_DISPLAY (f
));
1251 if (!EQ (Qnil
, Vx_pointer_shape
))
1253 CHECK_NUMBER (Vx_pointer_shape
);
1254 cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XINT (Vx_pointer_shape
));
1257 cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_xterm
);
1258 x_check_errors (FRAME_W32_DISPLAY (f
), "bad text pointer cursor: %s");
1260 if (!EQ (Qnil
, Vx_nontext_pointer_shape
))
1262 CHECK_NUMBER (Vx_nontext_pointer_shape
);
1263 nontext_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1264 XINT (Vx_nontext_pointer_shape
));
1267 nontext_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_left_ptr
);
1268 x_check_errors (FRAME_W32_DISPLAY (f
), "bad nontext pointer cursor: %s");
1270 if (!EQ (Qnil
, Vx_hourglass_pointer_shape
))
1272 CHECK_NUMBER (Vx_hourglass_pointer_shape
);
1273 hourglass_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1274 XINT (Vx_hourglass_pointer_shape
));
1277 hourglass_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_watch
);
1278 x_check_errors (FRAME_W32_DISPLAY (f
), "bad busy pointer cursor: %s");
1280 x_check_errors (FRAME_W32_DISPLAY (f
), "bad nontext pointer cursor: %s");
1281 if (!EQ (Qnil
, Vx_mode_pointer_shape
))
1283 CHECK_NUMBER (Vx_mode_pointer_shape
);
1284 mode_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1285 XINT (Vx_mode_pointer_shape
));
1288 mode_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_xterm
);
1289 x_check_errors (FRAME_W32_DISPLAY (f
), "bad modeline pointer cursor: %s");
1291 if (!EQ (Qnil
, Vx_sensitive_text_pointer_shape
))
1293 CHECK_NUMBER (Vx_sensitive_text_pointer_shape
);
1295 = XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1296 XINT (Vx_sensitive_text_pointer_shape
));
1299 hand_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_crosshair
);
1301 if (!NILP (Vx_window_horizontal_drag_shape
))
1303 CHECK_NUMBER (Vx_window_horizontal_drag_shape
);
1304 horizontal_drag_cursor
1305 = XCreateFontCursor (FRAME_X_DISPLAY (f
),
1306 XINT (Vx_window_horizontal_drag_shape
));
1309 horizontal_drag_cursor
1310 = XCreateFontCursor (FRAME_X_DISPLAY (f
), XC_sb_h_double_arrow
);
1312 /* Check and report errors with the above calls. */
1313 x_check_errors (FRAME_W32_DISPLAY (f
), "can't set cursor shape: %s");
1314 x_uncatch_errors (FRAME_W32_DISPLAY (f
), count
);
1317 XColor fore_color
, back_color
;
1319 fore_color
.pixel
= f
->output_data
.w32
->mouse_pixel
;
1320 back_color
.pixel
= mask_color
;
1321 XQueryColor (FRAME_W32_DISPLAY (f
),
1322 DefaultColormap (FRAME_W32_DISPLAY (f
),
1323 DefaultScreen (FRAME_W32_DISPLAY (f
))),
1325 XQueryColor (FRAME_W32_DISPLAY (f
),
1326 DefaultColormap (FRAME_W32_DISPLAY (f
),
1327 DefaultScreen (FRAME_W32_DISPLAY (f
))),
1329 XRecolorCursor (FRAME_W32_DISPLAY (f
), cursor
,
1330 &fore_color
, &back_color
);
1331 XRecolorCursor (FRAME_W32_DISPLAY (f
), nontext_cursor
,
1332 &fore_color
, &back_color
);
1333 XRecolorCursor (FRAME_W32_DISPLAY (f
), mode_cursor
,
1334 &fore_color
, &back_color
);
1335 XRecolorCursor (FRAME_W32_DISPLAY (f
), hand_cursor
,
1336 &fore_color
, &back_color
);
1337 XRecolorCursor (FRAME_W32_DISPLAY (f
), hourglass_cursor
,
1338 &fore_color
, &back_color
);
1341 if (FRAME_W32_WINDOW (f
) != 0)
1342 XDefineCursor (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
), cursor
);
1344 if (cursor
!= f
->output_data
.w32
->text_cursor
&& f
->output_data
.w32
->text_cursor
!= 0)
1345 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->text_cursor
);
1346 f
->output_data
.w32
->text_cursor
= cursor
;
1348 if (nontext_cursor
!= f
->output_data
.w32
->nontext_cursor
1349 && f
->output_data
.w32
->nontext_cursor
!= 0)
1350 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->nontext_cursor
);
1351 f
->output_data
.w32
->nontext_cursor
= nontext_cursor
;
1353 if (hourglass_cursor
!= f
->output_data
.w32
->hourglass_cursor
1354 && f
->output_data
.w32
->hourglass_cursor
!= 0)
1355 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->hourglass_cursor
);
1356 f
->output_data
.w32
->hourglass_cursor
= hourglass_cursor
;
1358 if (mode_cursor
!= f
->output_data
.w32
->modeline_cursor
1359 && f
->output_data
.w32
->modeline_cursor
!= 0)
1360 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->modeline_cursor
);
1361 f
->output_data
.w32
->modeline_cursor
= mode_cursor
;
1363 if (hand_cursor
!= f
->output_data
.w32
->hand_cursor
1364 && f
->output_data
.w32
->hand_cursor
!= 0)
1365 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->hand_cursor
);
1366 f
->output_data
.w32
->hand_cursor
= hand_cursor
;
1368 XFlush (FRAME_W32_DISPLAY (f
));
1371 update_face_from_frame_parameter (f
, Qmouse_color
, arg
);
1376 x_set_cursor_color (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
1378 unsigned long fore_pixel
, pixel
;
1380 if (!NILP (Vx_cursor_fore_pixel
))
1381 fore_pixel
= x_decode_color (f
, Vx_cursor_fore_pixel
,
1382 WHITE_PIX_DEFAULT (f
));
1384 fore_pixel
= FRAME_BACKGROUND_PIXEL (f
);
1386 pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1388 /* Make sure that the cursor color differs from the background color. */
1389 if (pixel
== FRAME_BACKGROUND_PIXEL (f
))
1391 pixel
= f
->output_data
.w32
->mouse_pixel
;
1392 if (pixel
== fore_pixel
)
1393 fore_pixel
= FRAME_BACKGROUND_PIXEL (f
);
1396 f
->output_data
.w32
->cursor_foreground_pixel
= fore_pixel
;
1397 f
->output_data
.w32
->cursor_pixel
= pixel
;
1399 if (FRAME_W32_WINDOW (f
) != 0)
1402 /* Update frame's cursor_gc. */
1403 f
->output_data
.w32
->cursor_gc
->foreground
= fore_pixel
;
1404 f
->output_data
.w32
->cursor_gc
->background
= pixel
;
1408 if (FRAME_VISIBLE_P (f
))
1410 x_update_cursor (f
, 0);
1411 x_update_cursor (f
, 1);
1415 update_face_from_frame_parameter (f
, Qcursor_color
, arg
);
1418 /* Set the border-color of frame F to pixel value PIX.
1419 Note that this does not fully take effect if done before
1423 x_set_border_pixel (struct frame
*f
, int pix
)
1426 f
->output_data
.w32
->border_pixel
= pix
;
1428 if (FRAME_W32_WINDOW (f
) != 0 && f
->border_width
> 0)
1430 if (FRAME_VISIBLE_P (f
))
1435 /* Set the border-color of frame F to value described by ARG.
1436 ARG can be a string naming a color.
1437 The border-color is used for the border that is drawn by the server.
1438 Note that this does not fully take effect if done before
1439 F has a window; it must be redone when the window is created. */
1442 x_set_border_color (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
1447 pix
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1448 x_set_border_pixel (f
, pix
);
1449 update_face_from_frame_parameter (f
, Qborder_color
, arg
);
1454 x_set_cursor_type (FRAME_PTR f
, Lisp_Object arg
, Lisp_Object oldval
)
1456 set_frame_cursor_types (f
, arg
);
1458 /* Make sure the cursor gets redrawn. */
1459 cursor_type_changed
= 1;
1463 x_set_icon_type (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
1467 if (NILP (arg
) && NILP (oldval
))
1470 if (STRINGP (arg
) && STRINGP (oldval
)
1471 && EQ (Fstring_equal (oldval
, arg
), Qt
))
1474 if (SYMBOLP (arg
) && SYMBOLP (oldval
) && EQ (arg
, oldval
))
1479 result
= x_bitmap_icon (f
, arg
);
1483 error ("No icon window available");
1490 x_set_icon_name (struct frame
*f
, Lisp_Object arg
, Lisp_Object oldval
)
1494 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1497 else if (!NILP (arg
) || NILP (oldval
))
1503 if (f
->output_data
.w32
->icon_bitmap
!= 0)
1508 result
= x_text_icon (f
,
1509 SSDATA ((!NILP (f
->icon_name
)
1518 error ("No icon window available");
1521 /* If the window was unmapped (and its icon was mapped),
1522 the new icon is not mapped, so map the window in its stead. */
1523 if (FRAME_VISIBLE_P (f
))
1525 #ifdef USE_X_TOOLKIT
1526 XtPopup (f
->output_data
.w32
->widget
, XtGrabNone
);
1528 XMapWindow (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
));
1531 XFlush (FRAME_W32_DISPLAY (f
));
1538 x_set_menu_bar_lines (struct frame
*f
, Lisp_Object value
, Lisp_Object oldval
)
1541 int olines
= FRAME_MENU_BAR_LINES (f
);
1543 /* Right now, menu bars don't work properly in minibuf-only frames;
1544 most of the commands try to apply themselves to the minibuffer
1545 frame itself, and get an error because you can't switch buffers
1546 in or split the minibuffer window. */
1547 if (FRAME_MINIBUF_ONLY_P (f
))
1550 if (INTEGERP (value
))
1551 nlines
= XINT (value
);
1555 FRAME_MENU_BAR_LINES (f
) = 0;
1557 FRAME_EXTERNAL_MENU_BAR (f
) = 1;
1560 if (FRAME_EXTERNAL_MENU_BAR (f
) == 1)
1561 free_frame_menubar (f
);
1562 FRAME_EXTERNAL_MENU_BAR (f
) = 0;
1564 /* Adjust the frame size so that the client (text) dimensions
1565 remain the same. This depends on FRAME_EXTERNAL_MENU_BAR being
1567 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1568 do_pending_window_change (0);
1574 /* Set the number of lines used for the tool bar of frame F to VALUE.
1575 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1576 is the old number of tool bar lines. This function changes the
1577 height of all windows on frame F to match the new tool bar height.
1578 The frame's height doesn't change. */
1581 x_set_tool_bar_lines (struct frame
*f
, Lisp_Object value
, Lisp_Object oldval
)
1583 int delta
, nlines
, root_height
;
1584 Lisp_Object root_window
;
1586 /* Treat tool bars like menu bars. */
1587 if (FRAME_MINIBUF_ONLY_P (f
))
1590 /* Use VALUE only if an integer >= 0. */
1591 if (INTEGERP (value
) && XINT (value
) >= 0)
1592 nlines
= XFASTINT (value
);
1596 /* Make sure we redisplay all windows in this frame. */
1597 ++windows_or_buffers_changed
;
1599 delta
= nlines
- FRAME_TOOL_BAR_LINES (f
);
1601 /* Don't resize the tool-bar to more than we have room for. */
1602 root_window
= FRAME_ROOT_WINDOW (f
);
1603 root_height
= WINDOW_TOTAL_LINES (XWINDOW (root_window
));
1604 if (root_height
- delta
< 1)
1606 delta
= root_height
- 1;
1607 nlines
= FRAME_TOOL_BAR_LINES (f
) + delta
;
1610 FRAME_TOOL_BAR_LINES (f
) = nlines
;
1611 change_window_heights (root_window
, delta
);
1614 /* We also have to make sure that the internal border at the top of
1615 the frame, below the menu bar or tool bar, is redrawn when the
1616 tool bar disappears. This is so because the internal border is
1617 below the tool bar if one is displayed, but is below the menu bar
1618 if there isn't a tool bar. The tool bar draws into the area
1619 below the menu bar. */
1620 if (FRAME_W32_WINDOW (f
) && FRAME_TOOL_BAR_LINES (f
) == 0)
1623 clear_current_matrices (f
);
1626 /* If the tool bar gets smaller, the internal border below it
1627 has to be cleared. It was formerly part of the display
1628 of the larger tool bar, and updating windows won't clear it. */
1631 int height
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1632 int width
= FRAME_PIXEL_WIDTH (f
);
1633 int y
= nlines
* FRAME_LINE_HEIGHT (f
);
1637 HDC hdc
= get_frame_dc (f
);
1638 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
1639 release_frame_dc (f
, hdc
);
1643 if (WINDOWP (f
->tool_bar_window
))
1644 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1649 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1652 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1653 name; if NAME is a string, set F's name to NAME and set
1654 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1656 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1657 suggesting a new name, which lisp code should override; if
1658 F->explicit_name is set, ignore the new name; otherwise, set it. */
1661 x_set_name (struct frame
*f
, Lisp_Object name
, int explicit)
1663 /* Make sure that requests from lisp code override requests from
1664 Emacs redisplay code. */
1667 /* If we're switching from explicit to implicit, we had better
1668 update the mode lines and thereby update the title. */
1669 if (f
->explicit_name
&& NILP (name
))
1670 update_mode_lines
= 1;
1672 f
->explicit_name
= ! NILP (name
);
1674 else if (f
->explicit_name
)
1677 /* If NAME is nil, set the name to the w32_id_name. */
1680 /* Check for no change needed in this very common case
1681 before we do any consing. */
1682 if (!strcmp (FRAME_W32_DISPLAY_INFO (f
)->w32_id_name
,
1685 name
= build_string (FRAME_W32_DISPLAY_INFO (f
)->w32_id_name
);
1688 CHECK_STRING (name
);
1690 /* Don't change the name if it's already NAME. */
1691 if (! NILP (Fstring_equal (name
, f
->name
)))
1696 /* For setting the frame title, the title parameter should override
1697 the name parameter. */
1698 if (! NILP (f
->title
))
1701 if (FRAME_W32_WINDOW (f
))
1703 if (STRING_MULTIBYTE (name
))
1704 name
= ENCODE_SYSTEM (name
);
1707 SetWindowText (FRAME_W32_WINDOW (f
), SDATA (name
));
1712 /* This function should be called when the user's lisp code has
1713 specified a name for the frame; the name will override any set by the
1716 x_explicitly_set_name (FRAME_PTR f
, Lisp_Object arg
, Lisp_Object oldval
)
1718 x_set_name (f
, arg
, 1);
1721 /* This function should be called by Emacs redisplay code to set the
1722 name; names set this way will never override names set by the user's
1725 x_implicitly_set_name (FRAME_PTR f
, Lisp_Object arg
, Lisp_Object oldval
)
1727 x_set_name (f
, arg
, 0);
1730 /* Change the title of frame F to NAME.
1731 If NAME is nil, use the frame name as the title. */
1734 x_set_title (struct frame
*f
, Lisp_Object name
, Lisp_Object old_name
)
1736 /* Don't change the title if it's already NAME. */
1737 if (EQ (name
, f
->title
))
1740 update_mode_lines
= 1;
1747 if (FRAME_W32_WINDOW (f
))
1749 if (STRING_MULTIBYTE (name
))
1750 name
= ENCODE_SYSTEM (name
);
1753 SetWindowText (FRAME_W32_WINDOW (f
), SDATA (name
));
1759 x_set_scroll_bar_default_width (struct frame
*f
)
1761 int wid
= FRAME_COLUMN_WIDTH (f
);
1763 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = GetSystemMetrics (SM_CXVSCROLL
);
1764 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) +
1769 /* Subroutines for creating a frame. */
1772 w32_load_cursor (LPCTSTR name
)
1774 /* Try first to load cursor from application resource. */
1775 Cursor cursor
= LoadImage ((HINSTANCE
) GetModuleHandle (NULL
),
1776 name
, IMAGE_CURSOR
, 0, 0,
1777 LR_DEFAULTCOLOR
| LR_DEFAULTSIZE
| LR_SHARED
);
1780 /* Then try to load a shared predefined cursor. */
1781 cursor
= LoadImage (NULL
, name
, IMAGE_CURSOR
, 0, 0,
1782 LR_DEFAULTCOLOR
| LR_DEFAULTSIZE
| LR_SHARED
);
1787 static LRESULT CALLBACK
w32_wnd_proc (HWND
, UINT
, WPARAM
, LPARAM
);
1790 w32_init_class (HINSTANCE hinst
)
1794 wc
.style
= CS_HREDRAW
| CS_VREDRAW
;
1795 wc
.lpfnWndProc
= (WNDPROC
) w32_wnd_proc
;
1797 wc
.cbWndExtra
= WND_EXTRA_BYTES
;
1798 wc
.hInstance
= hinst
;
1799 wc
.hIcon
= LoadIcon (hinst
, EMACS_CLASS
);
1800 wc
.hCursor
= w32_load_cursor (IDC_ARROW
);
1801 wc
.hbrBackground
= NULL
; /* GetStockObject (WHITE_BRUSH); */
1802 wc
.lpszMenuName
= NULL
;
1803 wc
.lpszClassName
= EMACS_CLASS
;
1805 return (RegisterClass (&wc
));
1809 w32_createscrollbar (struct frame
*f
, struct scroll_bar
* bar
)
1811 return (CreateWindow ("SCROLLBAR", "", SBS_VERT
| WS_CHILD
| WS_VISIBLE
,
1812 /* Position and size of scroll bar. */
1813 XINT (bar
->left
) + VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
1815 XINT (bar
->width
) - VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
1817 FRAME_W32_WINDOW (f
),
1824 w32_createwindow (struct frame
*f
)
1828 Lisp_Object top
= Qunbound
;
1829 Lisp_Object left
= Qunbound
;
1830 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
1832 rect
.left
= rect
.top
= 0;
1833 rect
.right
= FRAME_PIXEL_WIDTH (f
);
1834 rect
.bottom
= FRAME_PIXEL_HEIGHT (f
);
1836 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
1837 FRAME_EXTERNAL_MENU_BAR (f
));
1839 /* Do first time app init */
1843 w32_init_class (hinst
);
1846 if (f
->size_hint_flags
& USPosition
|| f
->size_hint_flags
& PPosition
)
1848 XSETINT (left
, f
->left_pos
);
1849 XSETINT (top
, f
->top_pos
);
1851 else if (EQ (left
, Qunbound
) && EQ (top
, Qunbound
))
1853 /* When called with RES_TYPE_NUMBER, w32_get_arg will return zero
1854 for anything that is not a number and is not Qunbound. */
1855 left
= x_get_arg (dpyinfo
, Qnil
, Qleft
, "left", "Left", RES_TYPE_NUMBER
);
1856 top
= x_get_arg (dpyinfo
, Qnil
, Qtop
, "top", "Top", RES_TYPE_NUMBER
);
1859 FRAME_W32_WINDOW (f
) = hwnd
1860 = CreateWindow (EMACS_CLASS
,
1862 f
->output_data
.w32
->dwStyle
| WS_CLIPCHILDREN
,
1863 EQ (left
, Qunbound
) ? CW_USEDEFAULT
: XINT (left
),
1864 EQ (top
, Qunbound
) ? CW_USEDEFAULT
: XINT (top
),
1865 rect
.right
- rect
.left
,
1866 rect
.bottom
- rect
.top
,
1874 SetWindowLong (hwnd
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
1875 SetWindowLong (hwnd
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
1876 SetWindowLong (hwnd
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
1877 SetWindowLong (hwnd
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
1878 SetWindowLong (hwnd
, WND_BACKGROUND_INDEX
, FRAME_BACKGROUND_PIXEL (f
));
1880 /* Enable drag-n-drop. */
1881 DragAcceptFiles (hwnd
, TRUE
);
1883 /* Do this to discard the default setting specified by our parent. */
1884 ShowWindow (hwnd
, SW_HIDE
);
1886 /* Update frame positions. */
1887 GetWindowRect (hwnd
, &rect
);
1888 f
->left_pos
= rect
.left
;
1889 f
->top_pos
= rect
.top
;
1894 my_post_msg (W32Msg
* wmsg
, HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
1896 wmsg
->msg
.hwnd
= hwnd
;
1897 wmsg
->msg
.message
= msg
;
1898 wmsg
->msg
.wParam
= wParam
;
1899 wmsg
->msg
.lParam
= lParam
;
1900 wmsg
->msg
.time
= GetMessageTime ();
1905 /* GetKeyState and MapVirtualKey on Windows 95 do not actually distinguish
1906 between left and right keys as advertised. We test for this
1907 support dynamically, and set a flag when the support is absent. If
1908 absent, we keep track of the left and right control and alt keys
1909 ourselves. This is particularly necessary on keyboards that rely
1910 upon the AltGr key, which is represented as having the left control
1911 and right alt keys pressed. For these keyboards, we need to know
1912 when the left alt key has been pressed in addition to the AltGr key
1913 so that we can properly support M-AltGr-key sequences (such as M-@
1914 on Swedish keyboards). */
1916 #define EMACS_LCONTROL 0
1917 #define EMACS_RCONTROL 1
1918 #define EMACS_LMENU 2
1919 #define EMACS_RMENU 3
1921 static int modifiers
[4];
1922 static int modifiers_recorded
;
1923 static int modifier_key_support_tested
;
1926 test_modifier_support (unsigned int wparam
)
1930 if (wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
)
1932 if (wparam
== VK_CONTROL
)
1942 if (!(GetKeyState (l
) & 0x8000) && !(GetKeyState (r
) & 0x8000))
1943 modifiers_recorded
= 1;
1945 modifiers_recorded
= 0;
1946 modifier_key_support_tested
= 1;
1950 record_keydown (unsigned int wparam
, unsigned int lparam
)
1954 if (!modifier_key_support_tested
)
1955 test_modifier_support (wparam
);
1957 if ((wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
) || !modifiers_recorded
)
1960 if (wparam
== VK_CONTROL
)
1961 i
= (lparam
& 0x1000000) ? EMACS_RCONTROL
: EMACS_LCONTROL
;
1963 i
= (lparam
& 0x1000000) ? EMACS_RMENU
: EMACS_LMENU
;
1969 record_keyup (unsigned int wparam
, unsigned int lparam
)
1973 if ((wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
) || !modifiers_recorded
)
1976 if (wparam
== VK_CONTROL
)
1977 i
= (lparam
& 0x1000000) ? EMACS_RCONTROL
: EMACS_LCONTROL
;
1979 i
= (lparam
& 0x1000000) ? EMACS_RMENU
: EMACS_LMENU
;
1984 /* Emacs can lose focus while a modifier key has been pressed. When
1985 it regains focus, be conservative and clear all modifiers since
1986 we cannot reconstruct the left and right modifier state. */
1988 reset_modifiers (void)
1992 if (GetFocus () == NULL
)
1993 /* Emacs doesn't have keyboard focus. Do nothing. */
1996 ctrl
= GetAsyncKeyState (VK_CONTROL
);
1997 alt
= GetAsyncKeyState (VK_MENU
);
1999 if (!(ctrl
& 0x08000))
2000 /* Clear any recorded control modifier state. */
2001 modifiers
[EMACS_RCONTROL
] = modifiers
[EMACS_LCONTROL
] = 0;
2003 if (!(alt
& 0x08000))
2004 /* Clear any recorded alt modifier state. */
2005 modifiers
[EMACS_RMENU
] = modifiers
[EMACS_LMENU
] = 0;
2007 /* Update the state of all modifier keys, because modifiers used in
2008 hot-key combinations can get stuck on if Emacs loses focus as a
2009 result of a hot-key being pressed. */
2013 #define CURRENT_STATE(key) ((GetAsyncKeyState (key) & 0x8000) >> 8)
2015 GetKeyboardState (keystate
);
2016 keystate
[VK_SHIFT
] = CURRENT_STATE (VK_SHIFT
);
2017 keystate
[VK_CONTROL
] = CURRENT_STATE (VK_CONTROL
);
2018 keystate
[VK_LCONTROL
] = CURRENT_STATE (VK_LCONTROL
);
2019 keystate
[VK_RCONTROL
] = CURRENT_STATE (VK_RCONTROL
);
2020 keystate
[VK_MENU
] = CURRENT_STATE (VK_MENU
);
2021 keystate
[VK_LMENU
] = CURRENT_STATE (VK_LMENU
);
2022 keystate
[VK_RMENU
] = CURRENT_STATE (VK_RMENU
);
2023 keystate
[VK_LWIN
] = CURRENT_STATE (VK_LWIN
);
2024 keystate
[VK_RWIN
] = CURRENT_STATE (VK_RWIN
);
2025 keystate
[VK_APPS
] = CURRENT_STATE (VK_APPS
);
2026 SetKeyboardState (keystate
);
2030 /* Synchronize modifier state with what is reported with the current
2031 keystroke. Even if we cannot distinguish between left and right
2032 modifier keys, we know that, if no modifiers are set, then neither
2033 the left or right modifier should be set. */
2035 sync_modifiers (void)
2037 if (!modifiers_recorded
)
2040 if (!(GetKeyState (VK_CONTROL
) & 0x8000))
2041 modifiers
[EMACS_RCONTROL
] = modifiers
[EMACS_LCONTROL
] = 0;
2043 if (!(GetKeyState (VK_MENU
) & 0x8000))
2044 modifiers
[EMACS_RMENU
] = modifiers
[EMACS_LMENU
] = 0;
2048 modifier_set (int vkey
)
2050 if (vkey
== VK_CAPITAL
|| vkey
== VK_SCROLL
)
2051 return (GetKeyState (vkey
) & 0x1);
2052 if (!modifiers_recorded
)
2053 return (GetKeyState (vkey
) & 0x8000);
2058 return modifiers
[EMACS_LCONTROL
];
2060 return modifiers
[EMACS_RCONTROL
];
2062 return modifiers
[EMACS_LMENU
];
2064 return modifiers
[EMACS_RMENU
];
2066 return (GetKeyState (vkey
) & 0x8000);
2069 /* Convert between the modifier bits W32 uses and the modifier bits
2073 w32_key_to_modifier (int key
)
2075 Lisp_Object key_mapping
;
2080 key_mapping
= Vw32_lwindow_modifier
;
2083 key_mapping
= Vw32_rwindow_modifier
;
2086 key_mapping
= Vw32_apps_modifier
;
2089 key_mapping
= Vw32_scroll_lock_modifier
;
2095 /* NB. This code runs in the input thread, asychronously to the lisp
2096 thread, so we must be careful to ensure access to lisp data is
2097 thread-safe. The following code is safe because the modifier
2098 variable values are updated atomically from lisp and symbols are
2099 not relocated by GC. Also, we don't have to worry about seeing GC
2101 if (EQ (key_mapping
, Qhyper
))
2102 return hyper_modifier
;
2103 if (EQ (key_mapping
, Qsuper
))
2104 return super_modifier
;
2105 if (EQ (key_mapping
, Qmeta
))
2106 return meta_modifier
;
2107 if (EQ (key_mapping
, Qalt
))
2108 return alt_modifier
;
2109 if (EQ (key_mapping
, Qctrl
))
2110 return ctrl_modifier
;
2111 if (EQ (key_mapping
, Qcontrol
)) /* synonym for ctrl */
2112 return ctrl_modifier
;
2113 if (EQ (key_mapping
, Qshift
))
2114 return shift_modifier
;
2116 /* Don't generate any modifier if not explicitly requested. */
2121 w32_get_modifiers (void)
2123 return ((modifier_set (VK_SHIFT
) ? shift_modifier
: 0) |
2124 (modifier_set (VK_CONTROL
) ? ctrl_modifier
: 0) |
2125 (modifier_set (VK_LWIN
) ? w32_key_to_modifier (VK_LWIN
) : 0) |
2126 (modifier_set (VK_RWIN
) ? w32_key_to_modifier (VK_RWIN
) : 0) |
2127 (modifier_set (VK_APPS
) ? w32_key_to_modifier (VK_APPS
) : 0) |
2128 (modifier_set (VK_SCROLL
) ? w32_key_to_modifier (VK_SCROLL
) : 0) |
2129 (modifier_set (VK_MENU
) ?
2130 ((NILP (Vw32_alt_is_meta
)) ? alt_modifier
: meta_modifier
) : 0));
2133 /* We map the VK_* modifiers into console modifier constants
2134 so that we can use the same routines to handle both console
2135 and window input. */
2138 construct_console_modifiers (void)
2143 mods
|= (modifier_set (VK_SHIFT
)) ? SHIFT_PRESSED
: 0;
2144 mods
|= (modifier_set (VK_CAPITAL
)) ? CAPSLOCK_ON
: 0;
2145 mods
|= (modifier_set (VK_SCROLL
)) ? SCROLLLOCK_ON
: 0;
2146 mods
|= (modifier_set (VK_NUMLOCK
)) ? NUMLOCK_ON
: 0;
2147 mods
|= (modifier_set (VK_LCONTROL
)) ? LEFT_CTRL_PRESSED
: 0;
2148 mods
|= (modifier_set (VK_RCONTROL
)) ? RIGHT_CTRL_PRESSED
: 0;
2149 mods
|= (modifier_set (VK_LMENU
)) ? LEFT_ALT_PRESSED
: 0;
2150 mods
|= (modifier_set (VK_RMENU
)) ? RIGHT_ALT_PRESSED
: 0;
2151 mods
|= (modifier_set (VK_LWIN
)) ? LEFT_WIN_PRESSED
: 0;
2152 mods
|= (modifier_set (VK_RWIN
)) ? RIGHT_WIN_PRESSED
: 0;
2153 mods
|= (modifier_set (VK_APPS
)) ? APPS_PRESSED
: 0;
2159 w32_get_key_modifiers (unsigned int wparam
, unsigned int lparam
)
2163 /* Convert to emacs modifiers. */
2164 mods
= w32_kbd_mods_to_emacs (construct_console_modifiers (), wparam
);
2170 map_keypad_keys (unsigned int virt_key
, unsigned int extended
)
2172 if (virt_key
< VK_CLEAR
|| virt_key
> VK_DELETE
)
2175 if (virt_key
== VK_RETURN
)
2176 return (extended
? VK_NUMPAD_ENTER
: VK_RETURN
);
2178 if (virt_key
>= VK_PRIOR
&& virt_key
<= VK_DOWN
)
2179 return (!extended
? (VK_NUMPAD_PRIOR
+ (virt_key
- VK_PRIOR
)) : virt_key
);
2181 if (virt_key
== VK_INSERT
|| virt_key
== VK_DELETE
)
2182 return (!extended
? (VK_NUMPAD_INSERT
+ (virt_key
- VK_INSERT
)) : virt_key
);
2184 if (virt_key
== VK_CLEAR
)
2185 return (!extended
? VK_NUMPAD_CLEAR
: virt_key
);
2190 /* List of special key combinations which w32 would normally capture,
2191 but Emacs should grab instead. Not directly visible to lisp, to
2192 simplify synchronization. Each item is an integer encoding a virtual
2193 key code and modifier combination to capture. */
2194 static Lisp_Object w32_grabbed_keys
;
2196 #define HOTKEY(vk, mods) make_number (((vk) & 255) | ((mods) << 8))
2197 #define HOTKEY_ID(k) (XFASTINT (k) & 0xbfff)
2198 #define HOTKEY_VK_CODE(k) (XFASTINT (k) & 255)
2199 #define HOTKEY_MODIFIERS(k) (XFASTINT (k) >> 8)
2201 #define RAW_HOTKEY_ID(k) ((k) & 0xbfff)
2202 #define RAW_HOTKEY_VK_CODE(k) ((k) & 255)
2203 #define RAW_HOTKEY_MODIFIERS(k) ((k) >> 8)
2205 /* Register hot-keys for reserved key combinations when Emacs has
2206 keyboard focus, since this is the only way Emacs can receive key
2207 combinations like Alt-Tab which are used by the system. */
2210 register_hot_keys (HWND hwnd
)
2212 Lisp_Object keylist
;
2214 /* Use CONSP, since we are called asynchronously. */
2215 for (keylist
= w32_grabbed_keys
; CONSP (keylist
); keylist
= XCDR (keylist
))
2217 Lisp_Object key
= XCAR (keylist
);
2219 /* Deleted entries get set to nil. */
2220 if (!INTEGERP (key
))
2223 RegisterHotKey (hwnd
, HOTKEY_ID (key
),
2224 HOTKEY_MODIFIERS (key
), HOTKEY_VK_CODE (key
));
2229 unregister_hot_keys (HWND hwnd
)
2231 Lisp_Object keylist
;
2233 for (keylist
= w32_grabbed_keys
; CONSP (keylist
); keylist
= XCDR (keylist
))
2235 Lisp_Object key
= XCAR (keylist
);
2237 if (!INTEGERP (key
))
2240 UnregisterHotKey (hwnd
, HOTKEY_ID (key
));
2244 /* Main message dispatch loop. */
2247 w32_msg_pump (deferred_msg
* msg_buf
)
2253 msh_mousewheel
= RegisterWindowMessage (MSH_MOUSEWHEEL
);
2255 while (GetMessage (&msg
, NULL
, 0, 0))
2257 if (msg
.hwnd
== NULL
)
2259 switch (msg
.message
)
2262 /* Produced by complete_deferred_msg; just ignore. */
2264 case WM_EMACS_CREATEWINDOW
:
2265 /* Initialize COM for this window. Even though we don't use it,
2266 some third party shell extensions can cause it to be used in
2267 system dialogs, which causes a crash if it is not initialized.
2268 This is a known bug in Windows, which was fixed long ago, but
2269 the patch for XP is not publically available until XP SP3,
2270 and older versions will never be patched. */
2271 CoInitialize (NULL
);
2272 w32_createwindow ((struct frame
*) msg
.wParam
);
2273 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2276 case WM_EMACS_SETLOCALE
:
2277 SetThreadLocale (msg
.wParam
);
2278 /* Reply is not expected. */
2280 case WM_EMACS_SETKEYBOARDLAYOUT
:
2281 result
= (int) ActivateKeyboardLayout ((HKL
) msg
.wParam
, 0);
2282 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
,
2286 case WM_EMACS_REGISTER_HOT_KEY
:
2287 focus_window
= GetFocus ();
2288 if (focus_window
!= NULL
)
2289 RegisterHotKey (focus_window
,
2290 RAW_HOTKEY_ID (msg
.wParam
),
2291 RAW_HOTKEY_MODIFIERS (msg
.wParam
),
2292 RAW_HOTKEY_VK_CODE (msg
.wParam
));
2293 /* Reply is not expected. */
2295 case WM_EMACS_UNREGISTER_HOT_KEY
:
2296 focus_window
= GetFocus ();
2297 if (focus_window
!= NULL
)
2298 UnregisterHotKey (focus_window
, RAW_HOTKEY_ID (msg
.wParam
));
2299 /* Mark item as erased. NB: this code must be
2300 thread-safe. The next line is okay because the cons
2301 cell is never made into garbage and is not relocated by
2303 XSETCAR ((Lisp_Object
) ((EMACS_INT
) msg
.lParam
), Qnil
);
2304 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2307 case WM_EMACS_TOGGLE_LOCK_KEY
:
2309 int vk_code
= (int) msg
.wParam
;
2310 int cur_state
= (GetKeyState (vk_code
) & 1);
2311 Lisp_Object new_state
= (Lisp_Object
) ((EMACS_INT
) msg
.lParam
);
2313 /* NB: This code must be thread-safe. It is safe to
2314 call NILP because symbols are not relocated by GC,
2315 and pointer here is not touched by GC (so the markbit
2316 can't be set). Numbers are safe because they are
2317 immediate values. */
2318 if (NILP (new_state
)
2319 || (NUMBERP (new_state
)
2320 && ((XUINT (new_state
)) & 1) != cur_state
))
2322 one_w32_display_info
.faked_key
= vk_code
;
2324 keybd_event ((BYTE
) vk_code
,
2325 (BYTE
) MapVirtualKey (vk_code
, 0),
2326 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2327 keybd_event ((BYTE
) vk_code
,
2328 (BYTE
) MapVirtualKey (vk_code
, 0),
2329 KEYEVENTF_EXTENDEDKEY
| 0, 0);
2330 keybd_event ((BYTE
) vk_code
,
2331 (BYTE
) MapVirtualKey (vk_code
, 0),
2332 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2333 cur_state
= !cur_state
;
2335 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
,
2341 /* Broadcast messages make it here, so you need to be looking
2342 for something in particular for this to be useful. */
2344 DebPrint (("msg %x not expected by w32_msg_pump\n", msg
.message
));
2350 DispatchMessage (&msg
);
2353 /* Exit nested loop when our deferred message has completed. */
2354 if (msg_buf
->completed
)
2359 deferred_msg
* deferred_msg_head
;
2361 static deferred_msg
*
2362 find_deferred_msg (HWND hwnd
, UINT msg
)
2364 deferred_msg
* item
;
2366 /* Don't actually need synchronization for read access, since
2367 modification of single pointer is always atomic. */
2368 /* enter_crit (); */
2370 for (item
= deferred_msg_head
; item
!= NULL
; item
= item
->next
)
2371 if (item
->w32msg
.msg
.hwnd
== hwnd
2372 && item
->w32msg
.msg
.message
== msg
)
2375 /* leave_crit (); */
2381 send_deferred_msg (deferred_msg
* msg_buf
,
2387 /* Only input thread can send deferred messages. */
2388 if (GetCurrentThreadId () != dwWindowsThreadId
)
2391 /* It is an error to send a message that is already deferred. */
2392 if (find_deferred_msg (hwnd
, msg
) != NULL
)
2395 /* Enforced synchronization is not needed because this is the only
2396 function that alters deferred_msg_head, and the following critical
2397 section is guaranteed to only be serially reentered (since only the
2398 input thread can call us). */
2400 /* enter_crit (); */
2402 msg_buf
->completed
= 0;
2403 msg_buf
->next
= deferred_msg_head
;
2404 deferred_msg_head
= msg_buf
;
2405 my_post_msg (&msg_buf
->w32msg
, hwnd
, msg
, wParam
, lParam
);
2407 /* leave_crit (); */
2409 /* Start a new nested message loop to process other messages until
2410 this one is completed. */
2411 w32_msg_pump (msg_buf
);
2413 deferred_msg_head
= msg_buf
->next
;
2415 return msg_buf
->result
;
2419 complete_deferred_msg (HWND hwnd
, UINT msg
, LRESULT result
)
2421 deferred_msg
* msg_buf
= find_deferred_msg (hwnd
, msg
);
2423 if (msg_buf
== NULL
)
2424 /* Message may have been cancelled, so don't abort. */
2427 msg_buf
->result
= result
;
2428 msg_buf
->completed
= 1;
2430 /* Ensure input thread is woken so it notices the completion. */
2431 PostThreadMessage (dwWindowsThreadId
, WM_NULL
, 0, 0);
2435 cancel_all_deferred_msgs (void)
2437 deferred_msg
* item
;
2439 /* Don't actually need synchronization for read access, since
2440 modification of single pointer is always atomic. */
2441 /* enter_crit (); */
2443 for (item
= deferred_msg_head
; item
!= NULL
; item
= item
->next
)
2446 item
->completed
= 1;
2449 /* leave_crit (); */
2451 /* Ensure input thread is woken so it notices the completion. */
2452 PostThreadMessage (dwWindowsThreadId
, WM_NULL
, 0, 0);
2456 w32_msg_worker (void *arg
)
2459 deferred_msg dummy_buf
;
2461 /* Ensure our message queue is created */
2463 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
2465 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2468 memset (&dummy_buf
, 0, sizeof (dummy_buf
));
2469 dummy_buf
.w32msg
.msg
.hwnd
= NULL
;
2470 dummy_buf
.w32msg
.msg
.message
= WM_NULL
;
2472 /* This is the initial message loop which should only exit when the
2473 application quits. */
2474 w32_msg_pump (&dummy_buf
);
2480 signal_user_input (void)
2482 /* Interrupt any lisp that wants to be interrupted by input. */
2483 if (!NILP (Vthrow_on_input
))
2485 Vquit_flag
= Vthrow_on_input
;
2486 /* If we're inside a function that wants immediate quits,
2488 if (immediate_quit
&& NILP (Vinhibit_quit
))
2498 post_character_message (HWND hwnd
, UINT msg
,
2499 WPARAM wParam
, LPARAM lParam
,
2504 wmsg
.dwModifiers
= modifiers
;
2506 /* Detect quit_char and set quit-flag directly. Note that we
2507 still need to post a message to ensure the main thread will be
2508 woken up if blocked in sys_select, but we do NOT want to post
2509 the quit_char message itself (because it will usually be as if
2510 the user had typed quit_char twice). Instead, we post a dummy
2511 message that has no particular effect. */
2514 if (isalpha (c
) && wmsg
.dwModifiers
== ctrl_modifier
)
2515 c
= make_ctrl_char (c
) & 0377;
2517 || (wmsg
.dwModifiers
== 0 &&
2518 w32_quit_key
&& wParam
== w32_quit_key
))
2522 /* The choice of message is somewhat arbitrary, as long as
2523 the main thread handler just ignores it. */
2526 /* Interrupt any blocking system calls. */
2529 /* As a safety precaution, forcibly complete any deferred
2530 messages. This is a kludge, but I don't see any particularly
2531 clean way to handle the situation where a deferred message is
2532 "dropped" in the lisp thread, and will thus never be
2533 completed, eg. by the user trying to activate the menubar
2534 when the lisp thread is busy, and then typing C-g when the
2535 menubar doesn't open promptly (with the result that the
2536 menubar never responds at all because the deferred
2537 WM_INITMENU message is never completed). Another problem
2538 situation is when the lisp thread calls SendMessage (to send
2539 a window manager command) when a message has been deferred;
2540 the lisp thread gets blocked indefinitely waiting for the
2541 deferred message to be completed, which itself is waiting for
2542 the lisp thread to respond.
2544 Note that we don't want to block the input thread waiting for
2545 a reponse from the lisp thread (although that would at least
2546 solve the deadlock problem above), because we want to be able
2547 to receive C-g to interrupt the lisp thread. */
2548 cancel_all_deferred_msgs ();
2551 signal_user_input ();
2554 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2557 /* Main window procedure */
2559 static LRESULT CALLBACK
2560 w32_wnd_proc (HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
2563 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
2565 int windows_translate
;
2568 /* Note that it is okay to call x_window_to_frame, even though we are
2569 not running in the main lisp thread, because frame deletion
2570 requires the lisp thread to synchronize with this thread. Thus, if
2571 a frame struct is returned, it can be used without concern that the
2572 lisp thread might make it disappear while we are using it.
2574 NB. Walking the frame list in this thread is safe (as long as
2575 writes of Lisp_Object slots are atomic, which they are on Windows).
2576 Although delete-frame can destructively modify the frame list while
2577 we are walking it, a garbage collection cannot occur until after
2578 delete-frame has synchronized with this thread.
2580 It is also safe to use functions that make GDI calls, such as
2581 w32_clear_rect, because these functions must obtain a DC handle
2582 from the frame struct using get_frame_dc which is thread-aware. */
2587 f
= x_window_to_frame (dpyinfo
, hwnd
);
2590 HDC hdc
= get_frame_dc (f
);
2591 GetUpdateRect (hwnd
, &wmsg
.rect
, FALSE
);
2592 w32_clear_rect (f
, hdc
, &wmsg
.rect
);
2593 release_frame_dc (f
, hdc
);
2595 #if defined (W32_DEBUG_DISPLAY)
2596 DebPrint (("WM_ERASEBKGND (frame %p): erasing %d,%d-%d,%d\n",
2598 wmsg
.rect
.left
, wmsg
.rect
.top
,
2599 wmsg
.rect
.right
, wmsg
.rect
.bottom
));
2600 #endif /* W32_DEBUG_DISPLAY */
2603 case WM_PALETTECHANGED
:
2604 /* ignore our own changes */
2605 if ((HWND
)wParam
!= hwnd
)
2607 f
= x_window_to_frame (dpyinfo
, hwnd
);
2609 /* get_frame_dc will realize our palette and force all
2610 frames to be redrawn if needed. */
2611 release_frame_dc (f
, get_frame_dc (f
));
2616 PAINTSTRUCT paintStruct
;
2618 memset (&update_rect
, 0, sizeof (update_rect
));
2620 f
= x_window_to_frame (dpyinfo
, hwnd
);
2623 DebPrint (("WM_PAINT received for unknown window %p\n", hwnd
));
2627 /* MSDN Docs say not to call BeginPaint if GetUpdateRect
2628 fails. Apparently this can happen under some
2630 if (GetUpdateRect (hwnd
, &update_rect
, FALSE
) || !w32_strict_painting
)
2633 BeginPaint (hwnd
, &paintStruct
);
2635 /* The rectangles returned by GetUpdateRect and BeginPaint
2636 do not always match. Play it safe by assuming both areas
2638 UnionRect (&(wmsg
.rect
), &update_rect
, &(paintStruct
.rcPaint
));
2640 #if defined (W32_DEBUG_DISPLAY)
2641 DebPrint (("WM_PAINT (frame %p): painting %d,%d-%d,%d\n",
2643 wmsg
.rect
.left
, wmsg
.rect
.top
,
2644 wmsg
.rect
.right
, wmsg
.rect
.bottom
));
2645 DebPrint ((" [update region is %d,%d-%d,%d]\n",
2646 update_rect
.left
, update_rect
.top
,
2647 update_rect
.right
, update_rect
.bottom
));
2649 EndPaint (hwnd
, &paintStruct
);
2652 /* Change the message type to prevent Windows from
2653 combining WM_PAINT messages in the Lisp thread's queue,
2654 since Windows assumes that each message queue is
2655 dedicated to one frame and does not bother checking
2656 that hwnd matches before combining them. */
2657 my_post_msg (&wmsg
, hwnd
, WM_EMACS_PAINT
, wParam
, lParam
);
2662 /* If GetUpdateRect returns 0 (meaning there is no update
2663 region), assume the whole window needs to be repainted. */
2664 GetClientRect (hwnd
, &wmsg
.rect
);
2665 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2669 case WM_INPUTLANGCHANGE
:
2670 /* Inform lisp thread of keyboard layout changes. */
2671 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2673 /* Clear dead keys in the keyboard state; for simplicity only
2674 preserve modifier key states. */
2679 GetKeyboardState (keystate
);
2680 for (i
= 0; i
< 256; i
++)
2697 SetKeyboardState (keystate
);
2702 /* Synchronize hot keys with normal input. */
2703 PostMessage (hwnd
, WM_KEYDOWN
, HIWORD (lParam
), 0);
2708 record_keyup (wParam
, lParam
);
2713 /* Ignore keystrokes we fake ourself; see below. */
2714 if (dpyinfo
->faked_key
== wParam
)
2716 dpyinfo
->faked_key
= 0;
2717 /* Make sure TranslateMessage sees them though (as long as
2718 they don't produce WM_CHAR messages). This ensures that
2719 indicator lights are toggled promptly on Windows 9x, for
2721 if (wParam
< 256 && lispy_function_keys
[wParam
])
2723 windows_translate
= 1;
2729 /* Synchronize modifiers with current keystroke. */
2731 record_keydown (wParam
, lParam
);
2732 wParam
= map_keypad_keys (wParam
, (lParam
& 0x1000000L
) != 0);
2734 windows_translate
= 0;
2739 if (NILP (Vw32_pass_lwindow_to_system
))
2741 /* Prevent system from acting on keyup (which opens the
2742 Start menu if no other key was pressed) by simulating a
2743 press of Space which we will ignore. */
2744 if (GetAsyncKeyState (wParam
) & 1)
2746 if (NUMBERP (Vw32_phantom_key_code
))
2747 key
= XUINT (Vw32_phantom_key_code
) & 255;
2750 dpyinfo
->faked_key
= key
;
2751 keybd_event (key
, (BYTE
) MapVirtualKey (key
, 0), 0, 0);
2754 if (!NILP (Vw32_lwindow_modifier
))
2758 if (NILP (Vw32_pass_rwindow_to_system
))
2760 if (GetAsyncKeyState (wParam
) & 1)
2762 if (NUMBERP (Vw32_phantom_key_code
))
2763 key
= XUINT (Vw32_phantom_key_code
) & 255;
2766 dpyinfo
->faked_key
= key
;
2767 keybd_event (key
, (BYTE
) MapVirtualKey (key
, 0), 0, 0);
2770 if (!NILP (Vw32_rwindow_modifier
))
2774 if (!NILP (Vw32_apps_modifier
))
2778 if (NILP (Vw32_pass_alt_to_system
))
2779 /* Prevent DefWindowProc from activating the menu bar if an
2780 Alt key is pressed and released by itself. */
2782 windows_translate
= 1;
2785 /* Decide whether to treat as modifier or function key. */
2786 if (NILP (Vw32_enable_caps_lock
))
2787 goto disable_lock_key
;
2788 windows_translate
= 1;
2791 /* Decide whether to treat as modifier or function key. */
2792 if (NILP (Vw32_enable_num_lock
))
2793 goto disable_lock_key
;
2794 windows_translate
= 1;
2797 /* Decide whether to treat as modifier or function key. */
2798 if (NILP (Vw32_scroll_lock_modifier
))
2799 goto disable_lock_key
;
2800 windows_translate
= 1;
2803 /* Ensure the appropriate lock key state (and indicator light)
2804 remains in the same state. We do this by faking another
2805 press of the relevant key. Apparently, this really is the
2806 only way to toggle the state of the indicator lights. */
2807 dpyinfo
->faked_key
= wParam
;
2808 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
2809 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2810 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
2811 KEYEVENTF_EXTENDEDKEY
| 0, 0);
2812 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
2813 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2814 /* Ensure indicator lights are updated promptly on Windows 9x
2815 (TranslateMessage apparently does this), after forwarding
2817 post_character_message (hwnd
, msg
, wParam
, lParam
,
2818 w32_get_key_modifiers (wParam
, lParam
));
2819 windows_translate
= 1;
2823 case VK_PROCESSKEY
: /* Generated by IME. */
2824 windows_translate
= 1;
2827 /* Windows maps Ctrl-Pause (aka Ctrl-Break) into VK_CANCEL,
2828 which is confusing for purposes of key binding; convert
2829 VK_CANCEL events into VK_PAUSE events. */
2833 /* Windows maps Ctrl-NumLock into VK_PAUSE, which is confusing
2834 for purposes of key binding; convert these back into
2835 VK_NUMLOCK events, at least when we want to see NumLock key
2836 presses. (Note that there is never any possibility that
2837 VK_PAUSE with Ctrl really is C-Pause as per above.) */
2838 if (NILP (Vw32_enable_num_lock
) && modifier_set (VK_CONTROL
))
2839 wParam
= VK_NUMLOCK
;
2842 /* If not defined as a function key, change it to a WM_CHAR message. */
2843 if (wParam
> 255 || !lispy_function_keys
[wParam
])
2845 DWORD modifiers
= construct_console_modifiers ();
2847 if (!NILP (Vw32_recognize_altgr
)
2848 && modifier_set (VK_LCONTROL
) && modifier_set (VK_RMENU
))
2850 /* Always let TranslateMessage handle AltGr key chords;
2851 for some reason, ToAscii doesn't always process AltGr
2852 chords correctly. */
2853 windows_translate
= 1;
2855 else if ((modifiers
& (~SHIFT_PRESSED
& ~CAPSLOCK_ON
)) != 0)
2857 /* Handle key chords including any modifiers other
2858 than shift directly, in order to preserve as much
2859 modifier information as possible. */
2860 if ('A' <= wParam
&& wParam
<= 'Z')
2862 /* Don't translate modified alphabetic keystrokes,
2863 so the user doesn't need to constantly switch
2864 layout to type control or meta keystrokes when
2865 the normal layout translates alphabetic
2866 characters to non-ascii characters. */
2867 if (!modifier_set (VK_SHIFT
))
2868 wParam
+= ('a' - 'A');
2873 /* Try to handle other keystrokes by determining the
2874 base character (ie. translating the base key plus
2878 KEY_EVENT_RECORD key
;
2880 key
.bKeyDown
= TRUE
;
2881 key
.wRepeatCount
= 1;
2882 key
.wVirtualKeyCode
= wParam
;
2883 key
.wVirtualScanCode
= (lParam
& 0xFF0000) >> 16;
2884 key
.uChar
.AsciiChar
= 0;
2885 key
.dwControlKeyState
= modifiers
;
2887 add
= w32_kbd_patch_key (&key
);
2888 /* 0 means an unrecognised keycode, negative means
2889 dead key. Ignore both. */
2892 /* Forward asciified character sequence. */
2893 post_character_message
2895 (unsigned char) key
.uChar
.AsciiChar
, lParam
,
2896 w32_get_key_modifiers (wParam
, lParam
));
2897 w32_kbd_patch_key (&key
);
2904 /* Let TranslateMessage handle everything else. */
2905 windows_translate
= 1;
2911 if (windows_translate
)
2913 MSG windows_msg
= { hwnd
, msg
, wParam
, lParam
, 0, {0,0} };
2914 windows_msg
.time
= GetMessageTime ();
2915 TranslateMessage (&windows_msg
);
2923 post_character_message (hwnd
, msg
, wParam
, lParam
,
2924 w32_get_key_modifiers (wParam
, lParam
));
2928 /* WM_UNICHAR looks promising from the docs, but the exact
2929 circumstances in which TranslateMessage sends it is one of those
2930 Microsoft secret API things that EU and US courts are supposed
2931 to have put a stop to already. Spy++ shows it being sent to Notepad
2932 and other MS apps, but never to Emacs.
2934 Some third party IMEs send it in accordance with the official
2935 documentation though, so handle it here.
2937 UNICODE_NOCHAR is used to test for support for this message.
2938 TRUE indicates that the message is supported. */
2939 if (wParam
== UNICODE_NOCHAR
)
2944 wmsg
.dwModifiers
= w32_get_key_modifiers (wParam
, lParam
);
2945 signal_user_input ();
2946 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2951 /* If we can't get the IME result as unicode, use default processing,
2952 which will at least allow characters decodable in the system locale
2954 if (!get_composition_string_fn
)
2957 else if (!ignore_ime_char
)
2962 HIMC context
= get_ime_context_fn (hwnd
);
2963 wmsg
.dwModifiers
= w32_get_key_modifiers (wParam
, lParam
);
2964 /* Get buffer size. */
2965 size
= get_composition_string_fn (context
, GCS_RESULTSTR
, buffer
, 0);
2966 buffer
= alloca (size
);
2967 size
= get_composition_string_fn (context
, GCS_RESULTSTR
,
2969 release_ime_context_fn (hwnd
, context
);
2971 signal_user_input ();
2972 for (i
= 0; i
< size
/ sizeof (wchar_t); i
++)
2974 my_post_msg (&wmsg
, hwnd
, WM_UNICHAR
, (WPARAM
) buffer
[i
],
2977 /* Ignore the messages for the rest of the
2978 characters in the string that was output above. */
2979 ignore_ime_char
= (size
/ sizeof (wchar_t)) - 1;
2986 case WM_IME_STARTCOMPOSITION
:
2987 if (!set_ime_composition_window_fn
)
2991 COMPOSITIONFORM form
;
2995 f
= x_window_to_frame (dpyinfo
, hwnd
);
2996 w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
2998 form
.dwStyle
= CFS_RECT
;
2999 form
.ptCurrentPos
.x
= w32_system_caret_x
;
3000 form
.ptCurrentPos
.y
= w32_system_caret_y
;
3002 form
.rcArea
.left
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, 0);
3003 form
.rcArea
.top
= (WINDOW_TOP_EDGE_Y (w
)
3004 + WINDOW_HEADER_LINE_HEIGHT (w
));
3005 form
.rcArea
.right
= (WINDOW_BOX_RIGHT_EDGE_X (w
)
3006 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
3007 - WINDOW_RIGHT_FRINGE_WIDTH (w
));
3008 form
.rcArea
.bottom
= (WINDOW_BOTTOM_EDGE_Y (w
)
3009 - WINDOW_MODE_LINE_HEIGHT (w
));
3011 context
= get_ime_context_fn (hwnd
);
3016 set_ime_composition_window_fn (context
, &form
);
3017 release_ime_context_fn (hwnd
, context
);
3021 case WM_IME_ENDCOMPOSITION
:
3022 ignore_ime_char
= 0;
3025 /* Simulate middle mouse button events when left and right buttons
3026 are used together, but only if user has two button mouse. */
3027 case WM_LBUTTONDOWN
:
3028 case WM_RBUTTONDOWN
:
3029 if (w32_num_mouse_buttons
> 2)
3030 goto handle_plain_button
;
3033 int this = (msg
== WM_LBUTTONDOWN
) ? LMOUSE
: RMOUSE
;
3034 int other
= (msg
== WM_LBUTTONDOWN
) ? RMOUSE
: LMOUSE
;
3036 if (button_state
& this)
3039 if (button_state
== 0)
3042 button_state
|= this;
3044 if (button_state
& other
)
3046 if (mouse_button_timer
)
3048 KillTimer (hwnd
, mouse_button_timer
);
3049 mouse_button_timer
= 0;
3051 /* Generate middle mouse event instead. */
3052 msg
= WM_MBUTTONDOWN
;
3053 button_state
|= MMOUSE
;
3055 else if (button_state
& MMOUSE
)
3057 /* Ignore button event if we've already generated a
3058 middle mouse down event. This happens if the
3059 user releases and press one of the two buttons
3060 after we've faked a middle mouse event. */
3065 /* Flush out saved message. */
3066 post_msg (&saved_mouse_button_msg
);
3068 wmsg
.dwModifiers
= w32_get_modifiers ();
3069 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3070 signal_user_input ();
3072 /* Clear message buffer. */
3073 saved_mouse_button_msg
.msg
.hwnd
= 0;
3077 /* Hold onto message for now. */
3078 mouse_button_timer
=
3079 SetTimer (hwnd
, MOUSE_BUTTON_ID
,
3080 w32_mouse_button_tolerance
, NULL
);
3081 saved_mouse_button_msg
.msg
.hwnd
= hwnd
;
3082 saved_mouse_button_msg
.msg
.message
= msg
;
3083 saved_mouse_button_msg
.msg
.wParam
= wParam
;
3084 saved_mouse_button_msg
.msg
.lParam
= lParam
;
3085 saved_mouse_button_msg
.msg
.time
= GetMessageTime ();
3086 saved_mouse_button_msg
.dwModifiers
= w32_get_modifiers ();
3093 if (w32_num_mouse_buttons
> 2)
3094 goto handle_plain_button
;
3097 int this = (msg
== WM_LBUTTONUP
) ? LMOUSE
: RMOUSE
;
3098 int other
= (msg
== WM_LBUTTONUP
) ? RMOUSE
: LMOUSE
;
3100 if ((button_state
& this) == 0)
3103 button_state
&= ~this;
3105 if (button_state
& MMOUSE
)
3107 /* Only generate event when second button is released. */
3108 if ((button_state
& other
) == 0)
3111 button_state
&= ~MMOUSE
;
3113 if (button_state
) abort ();
3120 /* Flush out saved message if necessary. */
3121 if (saved_mouse_button_msg
.msg
.hwnd
)
3123 post_msg (&saved_mouse_button_msg
);
3126 wmsg
.dwModifiers
= w32_get_modifiers ();
3127 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3128 signal_user_input ();
3130 /* Always clear message buffer and cancel timer. */
3131 saved_mouse_button_msg
.msg
.hwnd
= 0;
3132 KillTimer (hwnd
, mouse_button_timer
);
3133 mouse_button_timer
= 0;
3135 if (button_state
== 0)
3140 case WM_XBUTTONDOWN
:
3142 if (w32_pass_extra_mouse_buttons_to_system
)
3144 /* else fall through and process them. */
3145 case WM_MBUTTONDOWN
:
3147 handle_plain_button
:
3152 /* Ignore middle and extra buttons as long as the menu is active. */
3153 f
= x_window_to_frame (dpyinfo
, hwnd
);
3154 if (f
&& f
->output_data
.w32
->menubar_active
)
3157 if (parse_button (msg
, HIWORD (wParam
), &button
, &up
))
3159 if (up
) ReleaseCapture ();
3160 else SetCapture (hwnd
);
3161 button
= (button
== 0) ? LMOUSE
:
3162 ((button
== 1) ? MMOUSE
: RMOUSE
);
3164 button_state
&= ~button
;
3166 button_state
|= button
;
3170 wmsg
.dwModifiers
= w32_get_modifiers ();
3171 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3172 signal_user_input ();
3174 /* Need to return true for XBUTTON messages, false for others,
3175 to indicate that we processed the message. */
3176 return (msg
== WM_XBUTTONDOWN
|| msg
== WM_XBUTTONUP
);
3179 /* Ignore mouse movements as long as the menu is active. These
3180 movements are processed by the window manager anyway, and
3181 it's wrong to handle them as if they happened on the
3182 underlying frame. */
3183 f
= x_window_to_frame (dpyinfo
, hwnd
);
3184 if (f
&& f
->output_data
.w32
->menubar_active
)
3187 /* If the mouse has just moved into the frame, start tracking
3188 it, so we will be notified when it leaves the frame. Mouse
3189 tracking only works under W98 and NT4 and later. On earlier
3190 versions, there is no way of telling when the mouse leaves the
3191 frame, so we just have to put up with help-echo and mouse
3192 highlighting remaining while the frame is not active. */
3193 if (track_mouse_event_fn
&& !track_mouse_window
)
3195 TRACKMOUSEEVENT tme
;
3196 tme
.cbSize
= sizeof (tme
);
3197 tme
.dwFlags
= TME_LEAVE
;
3198 tme
.hwndTrack
= hwnd
;
3200 track_mouse_event_fn (&tme
);
3201 track_mouse_window
= hwnd
;
3204 if (w32_mouse_move_interval
<= 0
3205 || (msg
== WM_MOUSEMOVE
&& button_state
== 0))
3207 wmsg
.dwModifiers
= w32_get_modifiers ();
3208 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3212 /* Hang onto mouse move and scroll messages for a bit, to avoid
3213 sending such events to Emacs faster than it can process them.
3214 If we get more events before the timer from the first message
3215 expires, we just replace the first message. */
3217 if (saved_mouse_move_msg
.msg
.hwnd
== 0)
3219 SetTimer (hwnd
, MOUSE_MOVE_ID
,
3220 w32_mouse_move_interval
, NULL
);
3222 /* Hold onto message for now. */
3223 saved_mouse_move_msg
.msg
.hwnd
= hwnd
;
3224 saved_mouse_move_msg
.msg
.message
= msg
;
3225 saved_mouse_move_msg
.msg
.wParam
= wParam
;
3226 saved_mouse_move_msg
.msg
.lParam
= lParam
;
3227 saved_mouse_move_msg
.msg
.time
= GetMessageTime ();
3228 saved_mouse_move_msg
.dwModifiers
= w32_get_modifiers ();
3234 wmsg
.dwModifiers
= w32_get_modifiers ();
3235 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3236 signal_user_input ();
3240 if (w32_pass_multimedia_buttons_to_system
)
3242 /* Otherwise, pass to lisp, the same way we do with mousehwheel. */
3243 case WM_MOUSEHWHEEL
:
3244 wmsg
.dwModifiers
= w32_get_modifiers ();
3245 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3246 signal_user_input ();
3247 /* Non-zero must be returned when WM_MOUSEHWHEEL messages are
3248 handled, to prevent the system trying to handle it by faking
3249 scroll bar events. */
3253 /* Flush out saved messages if necessary. */
3254 if (wParam
== mouse_button_timer
)
3256 if (saved_mouse_button_msg
.msg
.hwnd
)
3258 post_msg (&saved_mouse_button_msg
);
3259 signal_user_input ();
3260 saved_mouse_button_msg
.msg
.hwnd
= 0;
3262 KillTimer (hwnd
, mouse_button_timer
);
3263 mouse_button_timer
= 0;
3265 else if (wParam
== mouse_move_timer
)
3267 if (saved_mouse_move_msg
.msg
.hwnd
)
3269 post_msg (&saved_mouse_move_msg
);
3270 saved_mouse_move_msg
.msg
.hwnd
= 0;
3272 KillTimer (hwnd
, mouse_move_timer
);
3273 mouse_move_timer
= 0;
3275 else if (wParam
== menu_free_timer
)
3277 KillTimer (hwnd
, menu_free_timer
);
3278 menu_free_timer
= 0;
3279 f
= x_window_to_frame (dpyinfo
, hwnd
);
3280 /* If a popup menu is active, don't wipe its strings. */
3282 && current_popup_menu
== NULL
)
3284 /* Free memory used by owner-drawn and help-echo strings. */
3285 w32_free_menu_strings (hwnd
);
3286 f
->output_data
.w32
->menubar_active
= 0;
3290 else if (wParam
== hourglass_timer
)
3292 KillTimer (hwnd
, hourglass_timer
);
3293 hourglass_timer
= 0;
3294 w32_show_hourglass (x_window_to_frame (dpyinfo
, hwnd
));
3299 /* Windows doesn't send us focus messages when putting up and
3300 taking down a system popup dialog as for Ctrl-Alt-Del on Windows 95.
3301 The only indication we get that something happened is receiving
3302 this message afterwards. So this is a good time to reset our
3303 keyboard modifiers' state. */
3310 /* We must ensure menu bar is fully constructed and up to date
3311 before allowing user interaction with it. To achieve this
3312 we send this message to the lisp thread and wait for a
3313 reply (whose value is not actually needed) to indicate that
3314 the menu bar is now ready for use, so we can now return.
3316 To remain responsive in the meantime, we enter a nested message
3317 loop that can process all other messages.
3319 However, we skip all this if the message results from calling
3320 TrackPopupMenu - in fact, we must NOT attempt to send the lisp
3321 thread a message because it is blocked on us at this point. We
3322 set menubar_active before calling TrackPopupMenu to indicate
3323 this (there is no possibility of confusion with real menubar
3326 f
= x_window_to_frame (dpyinfo
, hwnd
);
3328 && (f
->output_data
.w32
->menubar_active
3329 /* We can receive this message even in the absence of a
3330 menubar (ie. when the system menu is activated) - in this
3331 case we do NOT want to forward the message, otherwise it
3332 will cause the menubar to suddenly appear when the user
3333 had requested it to be turned off! */
3334 || f
->output_data
.w32
->menubar_widget
== NULL
))
3338 deferred_msg msg_buf
;
3340 /* Detect if message has already been deferred; in this case
3341 we cannot return any sensible value to ignore this. */
3342 if (find_deferred_msg (hwnd
, msg
) != NULL
)
3347 return send_deferred_msg (&msg_buf
, hwnd
, msg
, wParam
, lParam
);
3350 case WM_EXITMENULOOP
:
3351 f
= x_window_to_frame (dpyinfo
, hwnd
);
3353 /* If a menu is still active, check again after a short delay,
3354 since Windows often (always?) sends the WM_EXITMENULOOP
3355 before the corresponding WM_COMMAND message.
3356 Don't do this if a popup menu is active, since it is only
3357 menubar menus that require cleaning up in this way.
3359 if (f
&& menubar_in_use
&& current_popup_menu
== NULL
)
3360 menu_free_timer
= SetTimer (hwnd
, MENU_FREE_ID
, MENU_FREE_DELAY
, NULL
);
3362 /* If hourglass cursor should be displayed, display it now. */
3363 if (f
&& f
->output_data
.w32
->hourglass_p
)
3364 SetCursor (f
->output_data
.w32
->hourglass_cursor
);
3369 /* Direct handling of help_echo in menus. Should be safe now
3370 that we generate the help_echo by placing a help event in the
3373 HMENU menu
= (HMENU
) lParam
;
3374 UINT menu_item
= (UINT
) LOWORD (wParam
);
3375 UINT flags
= (UINT
) HIWORD (wParam
);
3377 w32_menu_display_help (hwnd
, menu
, menu_item
, flags
);
3381 case WM_MEASUREITEM
:
3382 f
= x_window_to_frame (dpyinfo
, hwnd
);
3385 MEASUREITEMSTRUCT
* pMis
= (MEASUREITEMSTRUCT
*) lParam
;
3387 if (pMis
->CtlType
== ODT_MENU
)
3389 /* Work out dimensions for popup menu titles. */
3390 char * title
= (char *) pMis
->itemData
;
3391 HDC hdc
= GetDC (hwnd
);
3392 HFONT menu_font
= GetCurrentObject (hdc
, OBJ_FONT
);
3393 LOGFONT menu_logfont
;
3397 GetObject (menu_font
, sizeof (menu_logfont
), &menu_logfont
);
3398 menu_logfont
.lfWeight
= FW_BOLD
;
3399 menu_font
= CreateFontIndirect (&menu_logfont
);
3400 old_font
= SelectObject (hdc
, menu_font
);
3402 pMis
->itemHeight
= GetSystemMetrics (SM_CYMENUSIZE
);
3405 if (unicode_append_menu
)
3406 GetTextExtentPoint32W (hdc
, (WCHAR
*) title
,
3407 wcslen ((WCHAR
*) title
),
3410 GetTextExtentPoint32 (hdc
, title
, strlen (title
), &size
);
3412 pMis
->itemWidth
= size
.cx
;
3413 if (pMis
->itemHeight
< size
.cy
)
3414 pMis
->itemHeight
= size
.cy
;
3417 pMis
->itemWidth
= 0;
3419 SelectObject (hdc
, old_font
);
3420 DeleteObject (menu_font
);
3421 ReleaseDC (hwnd
, hdc
);
3428 f
= x_window_to_frame (dpyinfo
, hwnd
);
3431 DRAWITEMSTRUCT
* pDis
= (DRAWITEMSTRUCT
*) lParam
;
3433 if (pDis
->CtlType
== ODT_MENU
)
3435 /* Draw popup menu title. */
3436 char * title
= (char *) pDis
->itemData
;
3439 HDC hdc
= pDis
->hDC
;
3440 HFONT menu_font
= GetCurrentObject (hdc
, OBJ_FONT
);
3441 LOGFONT menu_logfont
;
3444 GetObject (menu_font
, sizeof (menu_logfont
), &menu_logfont
);
3445 menu_logfont
.lfWeight
= FW_BOLD
;
3446 menu_font
= CreateFontIndirect (&menu_logfont
);
3447 old_font
= SelectObject (hdc
, menu_font
);
3449 /* Always draw title as if not selected. */
3450 if (unicode_append_menu
)
3453 + GetSystemMetrics (SM_CXMENUCHECK
),
3455 ETO_OPAQUE
, &pDis
->rcItem
,
3457 wcslen ((WCHAR
*) title
), NULL
);
3461 + GetSystemMetrics (SM_CXMENUCHECK
),
3463 ETO_OPAQUE
, &pDis
->rcItem
,
3464 title
, strlen (title
), NULL
);
3466 SelectObject (hdc
, old_font
);
3467 DeleteObject (menu_font
);
3475 /* Still not right - can't distinguish between clicks in the
3476 client area of the frame from clicks forwarded from the scroll
3477 bars - may have to hook WM_NCHITTEST to remember the mouse
3478 position and then check if it is in the client area ourselves. */
3479 case WM_MOUSEACTIVATE
:
3480 /* Discard the mouse click that activates a frame, allowing the
3481 user to click anywhere without changing point (or worse!).
3482 Don't eat mouse clicks on scrollbars though!! */
3483 if (LOWORD (lParam
) == HTCLIENT
)
3484 return MA_ACTIVATEANDEAT
;
3489 /* No longer tracking mouse. */
3490 track_mouse_window
= NULL
;
3492 case WM_ACTIVATEAPP
:
3494 case WM_WINDOWPOSCHANGED
:
3496 /* Inform lisp thread that a frame might have just been obscured
3497 or exposed, so should recheck visibility of all frames. */
3498 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3502 dpyinfo
->faked_key
= 0;
3504 register_hot_keys (hwnd
);
3507 unregister_hot_keys (hwnd
);
3510 /* Relinquish the system caret. */
3511 if (w32_system_caret_hwnd
)
3513 w32_visible_system_caret_hwnd
= NULL
;
3514 w32_system_caret_hwnd
= NULL
;
3520 f
= x_window_to_frame (dpyinfo
, hwnd
);
3521 if (f
&& HIWORD (wParam
) == 0)
3523 if (menu_free_timer
)
3525 KillTimer (hwnd
, menu_free_timer
);
3526 menu_free_timer
= 0;
3532 wmsg
.dwModifiers
= w32_get_modifiers ();
3533 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3541 wmsg
.dwModifiers
= w32_get_modifiers ();
3542 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3545 case WM_WINDOWPOSCHANGING
:
3546 /* Don't restrict the sizing of tip frames. */
3547 if (hwnd
== tip_window
)
3551 LPWINDOWPOS lppos
= (WINDOWPOS
*) lParam
;
3553 wp
.length
= sizeof (WINDOWPLACEMENT
);
3554 GetWindowPlacement (hwnd
, &wp
);
3556 if (wp
.showCmd
!= SW_SHOWMINIMIZED
&& (lppos
->flags
& SWP_NOSIZE
) == 0)
3563 DWORD internal_border
;
3564 DWORD scrollbar_extra
;
3567 wp
.length
= sizeof (wp
);
3568 GetWindowRect (hwnd
, &wr
);
3572 font_width
= GetWindowLong (hwnd
, WND_FONTWIDTH_INDEX
);
3573 line_height
= GetWindowLong (hwnd
, WND_LINEHEIGHT_INDEX
);
3574 internal_border
= GetWindowLong (hwnd
, WND_BORDER_INDEX
);
3575 scrollbar_extra
= GetWindowLong (hwnd
, WND_SCROLLBAR_INDEX
);
3579 memset (&rect
, 0, sizeof (rect
));
3580 AdjustWindowRect (&rect
, GetWindowLong (hwnd
, GWL_STYLE
),
3581 GetMenu (hwnd
) != NULL
);
3583 /* Force width and height of client area to be exact
3584 multiples of the character cell dimensions. */
3585 wdiff
= (lppos
->cx
- (rect
.right
- rect
.left
)
3586 - 2 * internal_border
- scrollbar_extra
)
3588 hdiff
= (lppos
->cy
- (rect
.bottom
- rect
.top
)
3589 - 2 * internal_border
)
3594 /* For right/bottom sizing we can just fix the sizes.
3595 However for top/left sizing we will need to fix the X
3596 and Y positions as well. */
3598 int cx_mintrack
= GetSystemMetrics (SM_CXMINTRACK
);
3599 int cy_mintrack
= GetSystemMetrics (SM_CYMINTRACK
);
3601 lppos
->cx
= max (lppos
->cx
- wdiff
, cx_mintrack
);
3602 lppos
->cy
= max (lppos
->cy
- hdiff
, cy_mintrack
);
3604 if (wp
.showCmd
!= SW_SHOWMAXIMIZED
3605 && (lppos
->flags
& SWP_NOMOVE
) == 0)
3607 if (lppos
->x
!= wr
.left
|| lppos
->y
!= wr
.top
)
3614 lppos
->flags
|= SWP_NOMOVE
;
3625 case WM_GETMINMAXINFO
:
3626 /* Hack to allow resizing the Emacs frame above the screen size.
3627 Note that Windows 9x limits coordinates to 16-bits. */
3628 ((LPMINMAXINFO
) lParam
)->ptMaxTrackSize
.x
= 32767;
3629 ((LPMINMAXINFO
) lParam
)->ptMaxTrackSize
.y
= 32767;
3633 if (LOWORD (lParam
) == HTCLIENT
)
3635 f
= x_window_to_frame (dpyinfo
, hwnd
);
3636 if (f
->output_data
.w32
->hourglass_p
&& !menubar_in_use
3637 && !current_popup_menu
)
3638 SetCursor (f
->output_data
.w32
->hourglass_cursor
);
3640 SetCursor (f
->output_data
.w32
->current_cursor
);
3645 case WM_EMACS_SETCURSOR
:
3647 Cursor cursor
= (Cursor
) wParam
;
3648 f
= x_window_to_frame (dpyinfo
, hwnd
);
3651 f
->output_data
.w32
->current_cursor
= cursor
;
3652 if (!f
->output_data
.w32
->hourglass_p
)
3658 case WM_EMACS_CREATESCROLLBAR
:
3659 return (LRESULT
) w32_createscrollbar ((struct frame
*) wParam
,
3660 (struct scroll_bar
*) lParam
);
3662 case WM_EMACS_SHOWWINDOW
:
3663 return ShowWindow ((HWND
) wParam
, (WPARAM
) lParam
);
3665 case WM_EMACS_SETFOREGROUND
:
3667 HWND foreground_window
;
3668 DWORD foreground_thread
, retval
;
3670 /* On NT 5.0, and apparently Windows 98, it is necessary to
3671 attach to the thread that currently has focus in order to
3672 pull the focus away from it. */
3673 foreground_window
= GetForegroundWindow ();
3674 foreground_thread
= GetWindowThreadProcessId (foreground_window
, NULL
);
3675 if (!foreground_window
3676 || foreground_thread
== GetCurrentThreadId ()
3677 || !AttachThreadInput (GetCurrentThreadId (),
3678 foreground_thread
, TRUE
))
3679 foreground_thread
= 0;
3681 retval
= SetForegroundWindow ((HWND
) wParam
);
3683 /* Detach from the previous foreground thread. */
3684 if (foreground_thread
)
3685 AttachThreadInput (GetCurrentThreadId (),
3686 foreground_thread
, FALSE
);
3691 case WM_EMACS_SETWINDOWPOS
:
3693 WINDOWPOS
* pos
= (WINDOWPOS
*) wParam
;
3694 return SetWindowPos (hwnd
, pos
->hwndInsertAfter
,
3695 pos
->x
, pos
->y
, pos
->cx
, pos
->cy
, pos
->flags
);
3698 case WM_EMACS_DESTROYWINDOW
:
3699 DragAcceptFiles ((HWND
) wParam
, FALSE
);
3700 return DestroyWindow ((HWND
) wParam
);
3702 case WM_EMACS_HIDE_CARET
:
3703 return HideCaret (hwnd
);
3705 case WM_EMACS_SHOW_CARET
:
3706 return ShowCaret (hwnd
);
3708 case WM_EMACS_DESTROY_CARET
:
3709 w32_system_caret_hwnd
= NULL
;
3710 w32_visible_system_caret_hwnd
= NULL
;
3711 return DestroyCaret ();
3713 case WM_EMACS_TRACK_CARET
:
3714 /* If there is currently no system caret, create one. */
3715 if (w32_system_caret_hwnd
== NULL
)
3717 /* Use the default caret width, and avoid changing it
3718 unneccesarily, as it confuses screen reader software. */
3719 w32_system_caret_hwnd
= hwnd
;
3720 CreateCaret (hwnd
, NULL
, 0,
3721 w32_system_caret_height
);
3724 if (!SetCaretPos (w32_system_caret_x
, w32_system_caret_y
))
3726 /* Ensure visible caret gets turned on when requested. */
3727 else if (w32_use_visible_system_caret
3728 && w32_visible_system_caret_hwnd
!= hwnd
)
3730 w32_visible_system_caret_hwnd
= hwnd
;
3731 return ShowCaret (hwnd
);
3733 /* Ensure visible caret gets turned off when requested. */
3734 else if (!w32_use_visible_system_caret
3735 && w32_visible_system_caret_hwnd
)
3737 w32_visible_system_caret_hwnd
= NULL
;
3738 return HideCaret (hwnd
);
3743 case WM_EMACS_TRACKPOPUPMENU
:
3748 pos
= (POINT
*)lParam
;
3749 flags
= TPM_CENTERALIGN
;
3750 if (button_state
& LMOUSE
)
3751 flags
|= TPM_LEFTBUTTON
;
3752 else if (button_state
& RMOUSE
)
3753 flags
|= TPM_RIGHTBUTTON
;
3755 /* Remember we did a SetCapture on the initial mouse down event,
3756 so for safety, we make sure the capture is cancelled now. */
3760 /* Use menubar_active to indicate that WM_INITMENU is from
3761 TrackPopupMenu below, and should be ignored. */
3762 f
= x_window_to_frame (dpyinfo
, hwnd
);
3764 f
->output_data
.w32
->menubar_active
= 1;
3766 if (TrackPopupMenu ((HMENU
)wParam
, flags
, pos
->x
, pos
->y
,
3770 /* Eat any mouse messages during popupmenu */
3771 while (PeekMessage (&amsg
, hwnd
, WM_MOUSEFIRST
, WM_MOUSELAST
,
3773 /* Get the menu selection, if any */
3774 if (PeekMessage (&amsg
, hwnd
, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
))
3776 retval
= LOWORD (amsg
.wParam
);
3792 /* Check for messages registered at runtime. */
3793 if (msg
== msh_mousewheel
)
3795 wmsg
.dwModifiers
= w32_get_modifiers ();
3796 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3797 signal_user_input ();
3802 return DefWindowProc (hwnd
, msg
, wParam
, lParam
);
3805 /* The most common default return code for handled messages is 0. */
3810 my_create_window (struct frame
* f
)
3814 if (!PostThreadMessage (dwWindowsThreadId
, WM_EMACS_CREATEWINDOW
, (WPARAM
)f
, 0))
3816 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3820 /* Create a tooltip window. Unlike my_create_window, we do not do this
3821 indirectly via the Window thread, as we do not need to process Window
3822 messages for the tooltip. Creating tooltips indirectly also creates
3823 deadlocks when tooltips are created for menu items. */
3825 my_create_tip_window (struct frame
*f
)
3829 rect
.left
= rect
.top
= 0;
3830 rect
.right
= FRAME_PIXEL_WIDTH (f
);
3831 rect
.bottom
= FRAME_PIXEL_HEIGHT (f
);
3833 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
3834 FRAME_EXTERNAL_MENU_BAR (f
));
3836 tip_window
= FRAME_W32_WINDOW (f
)
3837 = CreateWindow (EMACS_CLASS
,
3839 f
->output_data
.w32
->dwStyle
,
3842 rect
.right
- rect
.left
,
3843 rect
.bottom
- rect
.top
,
3844 FRAME_W32_WINDOW (SELECTED_FRAME ()), /* owner */
3851 SetWindowLong (tip_window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
3852 SetWindowLong (tip_window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
3853 SetWindowLong (tip_window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
3854 SetWindowLong (tip_window
, WND_BACKGROUND_INDEX
, FRAME_BACKGROUND_PIXEL (f
));
3856 /* Tip frames have no scrollbars. */
3857 SetWindowLong (tip_window
, WND_SCROLLBAR_INDEX
, 0);
3859 /* Do this to discard the default setting specified by our parent. */
3860 ShowWindow (tip_window
, SW_HIDE
);
3865 /* Create and set up the w32 window for frame F. */
3868 w32_window (struct frame
*f
, long window_prompting
, int minibuffer_only
)
3872 /* Use the resource name as the top-level window name
3873 for looking up resources. Make a non-Lisp copy
3874 for the window manager, so GC relocation won't bother it.
3876 Elsewhere we specify the window name for the window manager. */
3879 char *str
= SSDATA (Vx_resource_name
);
3880 f
->namebuf
= (char *) xmalloc (strlen (str
) + 1);
3881 strcpy (f
->namebuf
, str
);
3884 my_create_window (f
);
3886 validate_x_resource_name ();
3888 /* x_set_name normally ignores requests to set the name if the
3889 requested name is the same as the current name. This is the one
3890 place where that assumption isn't correct; f->name is set, but
3891 the server hasn't been told. */
3894 int explicit = f
->explicit_name
;
3896 f
->explicit_name
= 0;
3899 x_set_name (f
, name
, explicit);
3904 if (!minibuffer_only
&& FRAME_EXTERNAL_MENU_BAR (f
))
3905 initialize_frame_menubar (f
);
3907 if (FRAME_W32_WINDOW (f
) == 0)
3908 error ("Unable to create window");
3911 /* Handle the icon stuff for this window. Perhaps later we might
3912 want an x_set_icon_position which can be called interactively as
3916 x_icon (struct frame
*f
, Lisp_Object parms
)
3918 Lisp_Object icon_x
, icon_y
;
3919 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
3921 /* Set the position of the icon. Note that Windows 95 groups all
3922 icons in the tray. */
3923 icon_x
= x_get_arg (dpyinfo
, parms
, Qicon_left
, 0, 0, RES_TYPE_NUMBER
);
3924 icon_y
= x_get_arg (dpyinfo
, parms
, Qicon_top
, 0, 0, RES_TYPE_NUMBER
);
3925 if (!EQ (icon_x
, Qunbound
) && !EQ (icon_y
, Qunbound
))
3927 CHECK_NUMBER (icon_x
);
3928 CHECK_NUMBER (icon_y
);
3930 else if (!EQ (icon_x
, Qunbound
) || !EQ (icon_y
, Qunbound
))
3931 error ("Both left and top icon corners of icon must be specified");
3935 if (! EQ (icon_x
, Qunbound
))
3936 x_wm_set_icon_position (f
, XINT (icon_x
), XINT (icon_y
));
3939 /* Start up iconic or window? */
3940 x_wm_set_window_state
3941 (f
, (EQ (x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
), Qicon
)
3945 x_text_icon (f
, SSDATA ((!NILP (f
->icon_name
)
3955 x_make_gc (struct frame
*f
)
3957 XGCValues gc_values
;
3961 /* Create the GC's of this frame.
3962 Note that many default values are used. */
3965 gc_values
.font
= FRAME_FONT (f
);
3967 /* Cursor has cursor-color background, background-color foreground. */
3968 gc_values
.foreground
= FRAME_BACKGROUND_PIXEL (f
);
3969 gc_values
.background
= f
->output_data
.w32
->cursor_pixel
;
3970 f
->output_data
.w32
->cursor_gc
3971 = XCreateGC (NULL
, FRAME_W32_WINDOW (f
),
3972 (GCFont
| GCForeground
| GCBackground
),
3976 f
->output_data
.w32
->white_relief
.gc
= 0;
3977 f
->output_data
.w32
->black_relief
.gc
= 0;
3983 /* Handler for signals raised during x_create_frame and
3984 x_create_top_frame. FRAME is the frame which is partially
3988 unwind_create_frame (Lisp_Object frame
)
3990 struct frame
*f
= XFRAME (frame
);
3992 /* If frame is ``official'', nothing to do. */
3993 if (!CONSP (Vframe_list
) || !EQ (XCAR (Vframe_list
), frame
))
3996 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
3999 x_free_frame_resources (f
);
4002 /* Check that reference counts are indeed correct. */
4003 xassert (dpyinfo
->reference_count
== dpyinfo_refcount
);
4004 xassert (dpyinfo
->image_cache
->refcount
== image_cache_refcount
);
4013 x_default_font_parameter (struct frame
*f
, Lisp_Object parms
)
4015 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
4016 Lisp_Object font_param
= x_get_arg (dpyinfo
, parms
, Qfont
, NULL
, NULL
,
4019 if (EQ (font_param
, Qunbound
))
4021 font
= !NILP (font_param
) ? font_param
4022 : x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
4024 if (!STRINGP (font
))
4027 static char *names
[]
4028 = { "Courier New-10",
4029 "-*-Courier-normal-r-*-*-13-*-*-*-c-*-iso8859-1",
4030 "-*-Fixedsys-normal-r-*-*-12-*-*-*-c-*-iso8859-1",
4034 for (i
= 0; names
[i
]; i
++)
4036 font
= font_open_by_name (f
, names
[i
]);
4041 error ("No suitable font was found");
4043 else if (!NILP (font_param
))
4045 /* Remember the explicit font parameter, so we can re-apply it after
4046 we've applied the `default' face settings. */
4047 x_set_frame_parameters (f
, Fcons (Fcons (Qfont_param
, font_param
), Qnil
));
4049 x_default_parameter (f
, parms
, Qfont
, font
, "font", "Font", RES_TYPE_STRING
);
4052 DEFUN ("x-create-frame", Fx_create_frame
, Sx_create_frame
,
4054 doc
: /* Make a new window, which is called a \"frame\" in Emacs terms.
4055 Return an Emacs frame object.
4056 PARAMETERS is an alist of frame parameters.
4057 If the parameters specify that the frame should not have a minibuffer,
4058 and do not specify a specific minibuffer window to use,
4059 then `default-minibuffer-frame' must be a frame whose minibuffer can
4060 be shared by the new frame.
4062 This function is an internal primitive--use `make-frame' instead. */)
4063 (Lisp_Object parameters
)
4066 Lisp_Object frame
, tem
;
4068 int minibuffer_only
= 0;
4069 long window_prompting
= 0;
4071 int count
= SPECPDL_INDEX ();
4072 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4073 Lisp_Object display
;
4074 struct w32_display_info
*dpyinfo
= NULL
;
4078 /* Make copy of frame parameters because the original is in pure
4080 parameters
= Fcopy_alist (parameters
);
4082 /* Use this general default value to start with
4083 until we know if this frame has a specified name. */
4084 Vx_resource_name
= Vinvocation_name
;
4086 display
= x_get_arg (dpyinfo
, parameters
, Qterminal
, 0, 0, RES_TYPE_NUMBER
);
4087 if (EQ (display
, Qunbound
))
4088 display
= x_get_arg (dpyinfo
, parameters
, Qdisplay
, 0, 0, RES_TYPE_STRING
);
4089 if (EQ (display
, Qunbound
))
4091 dpyinfo
= check_x_display_info (display
);
4092 kb
= dpyinfo
->terminal
->kboard
;
4094 if (!dpyinfo
->terminal
->name
)
4095 error ("Terminal is not live, can't create new frames on it");
4097 name
= x_get_arg (dpyinfo
, parameters
, Qname
, "name", "Name", RES_TYPE_STRING
);
4099 && ! EQ (name
, Qunbound
)
4101 error ("Invalid frame name--not a string or nil");
4104 Vx_resource_name
= name
;
4106 /* See if parent window is specified. */
4107 parent
= x_get_arg (dpyinfo
, parameters
, Qparent_id
, NULL
, NULL
, RES_TYPE_NUMBER
);
4108 if (EQ (parent
, Qunbound
))
4110 if (! NILP (parent
))
4111 CHECK_NUMBER (parent
);
4113 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
4114 /* No need to protect DISPLAY because that's not used after passing
4115 it to make_frame_without_minibuffer. */
4117 GCPRO4 (parameters
, parent
, name
, frame
);
4118 tem
= x_get_arg (dpyinfo
, parameters
, Qminibuffer
, "minibuffer", "Minibuffer",
4120 if (EQ (tem
, Qnone
) || NILP (tem
))
4121 f
= make_frame_without_minibuffer (Qnil
, kb
, display
);
4122 else if (EQ (tem
, Qonly
))
4124 f
= make_minibuffer_frame ();
4125 minibuffer_only
= 1;
4127 else if (WINDOWP (tem
))
4128 f
= make_frame_without_minibuffer (tem
, kb
, display
);
4132 XSETFRAME (frame
, f
);
4134 /* Note that Windows does support scroll bars. */
4135 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
4137 /* By default, make scrollbars the system standard width. */
4138 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = GetSystemMetrics (SM_CXVSCROLL
);
4140 f
->terminal
= dpyinfo
->terminal
;
4141 f
->terminal
->reference_count
++;
4143 f
->output_method
= output_w32
;
4144 f
->output_data
.w32
=
4145 (struct w32_output
*) xmalloc (sizeof (struct w32_output
));
4146 memset (f
->output_data
.w32
, 0, sizeof (struct w32_output
));
4147 FRAME_FONTSET (f
) = -1;
4150 = x_get_arg (dpyinfo
, parameters
, Qicon_name
, "iconName", "Title",
4152 if (! STRINGP (f
->icon_name
))
4153 f
->icon_name
= Qnil
;
4155 /* FRAME_W32_DISPLAY_INFO (f) = dpyinfo; */
4157 /* With FRAME_X_DISPLAY_INFO set up, this unwind-protect is safe. */
4158 record_unwind_protect (unwind_create_frame
, frame
);
4160 image_cache_refcount
= FRAME_IMAGE_CACHE (f
)->refcount
;
4161 dpyinfo_refcount
= dpyinfo
->reference_count
;
4162 #endif /* GLYPH_DEBUG */
4164 /* Specify the parent under which to make this window. */
4168 f
->output_data
.w32
->parent_desc
= (Window
) XFASTINT (parent
);
4169 f
->output_data
.w32
->explicit_parent
= 1;
4173 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
4174 f
->output_data
.w32
->explicit_parent
= 0;
4177 /* Set the name; the functions to which we pass f expect the name to
4179 if (EQ (name
, Qunbound
) || NILP (name
))
4181 f
->name
= build_string (dpyinfo
->w32_id_name
);
4182 f
->explicit_name
= 0;
4187 f
->explicit_name
= 1;
4188 /* use the frame's title when getting resources for this frame. */
4189 specbind (Qx_resource_name
, name
);
4192 f
->resx
= dpyinfo
->resx
;
4193 f
->resy
= dpyinfo
->resy
;
4195 if (uniscribe_available
)
4196 register_font_driver (&uniscribe_font_driver
, f
);
4197 register_font_driver (&w32font_driver
, f
);
4199 x_default_parameter (f
, parameters
, Qfont_backend
, Qnil
,
4200 "fontBackend", "FontBackend", RES_TYPE_STRING
);
4201 /* Extract the window parameters from the supplied values
4202 that are needed to determine window geometry. */
4203 x_default_font_parameter (f
, parameters
);
4204 x_default_parameter (f
, parameters
, Qborder_width
, make_number (2),
4205 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
4207 /* We recognize either internalBorderWidth or internalBorder
4208 (which is what xterm calls it). */
4209 if (NILP (Fassq (Qinternal_border_width
, parameters
)))
4213 value
= x_get_arg (dpyinfo
, parameters
, Qinternal_border_width
,
4214 "internalBorder", "InternalBorder", RES_TYPE_NUMBER
);
4215 if (! EQ (value
, Qunbound
))
4216 parameters
= Fcons (Fcons (Qinternal_border_width
, value
),
4219 /* Default internalBorderWidth to 0 on Windows to match other programs. */
4220 x_default_parameter (f
, parameters
, Qinternal_border_width
, make_number (0),
4221 "internalBorderWidth", "InternalBorder", RES_TYPE_NUMBER
);
4222 x_default_parameter (f
, parameters
, Qvertical_scroll_bars
, Qright
,
4223 "verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL
);
4225 /* Also do the stuff which must be set before the window exists. */
4226 x_default_parameter (f
, parameters
, Qforeground_color
, build_string ("black"),
4227 "foreground", "Foreground", RES_TYPE_STRING
);
4228 x_default_parameter (f
, parameters
, Qbackground_color
, build_string ("white"),
4229 "background", "Background", RES_TYPE_STRING
);
4230 x_default_parameter (f
, parameters
, Qmouse_color
, build_string ("black"),
4231 "pointerColor", "Foreground", RES_TYPE_STRING
);
4232 x_default_parameter (f
, parameters
, Qborder_color
, build_string ("black"),
4233 "borderColor", "BorderColor", RES_TYPE_STRING
);
4234 x_default_parameter (f
, parameters
, Qscreen_gamma
, Qnil
,
4235 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT
);
4236 x_default_parameter (f
, parameters
, Qline_spacing
, Qnil
,
4237 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER
);
4238 x_default_parameter (f
, parameters
, Qleft_fringe
, Qnil
,
4239 "leftFringe", "LeftFringe", RES_TYPE_NUMBER
);
4240 x_default_parameter (f
, parameters
, Qright_fringe
, Qnil
,
4241 "rightFringe", "RightFringe", RES_TYPE_NUMBER
);
4243 /* Init faces before x_default_parameter is called for scroll-bar
4244 parameters because that function calls x_set_scroll_bar_width,
4245 which calls change_frame_size, which calls Fset_window_buffer,
4246 which runs hooks, which call Fvertical_motion. At the end, we
4247 end up in init_iterator with a null face cache, which should not
4249 init_frame_faces (f
);
4251 /* The X resources controlling the menu-bar and tool-bar are
4252 processed specially at startup, and reflected in the mode
4253 variables; ignore them here. */
4254 x_default_parameter (f
, parameters
, Qmenu_bar_lines
,
4255 NILP (Vmenu_bar_mode
)
4256 ? make_number (0) : make_number (1),
4257 NULL
, NULL
, RES_TYPE_NUMBER
);
4258 x_default_parameter (f
, parameters
, Qtool_bar_lines
,
4259 NILP (Vtool_bar_mode
)
4260 ? make_number (0) : make_number (1),
4261 NULL
, NULL
, RES_TYPE_NUMBER
);
4263 x_default_parameter (f
, parameters
, Qbuffer_predicate
, Qnil
,
4264 "bufferPredicate", "BufferPredicate", RES_TYPE_SYMBOL
);
4265 x_default_parameter (f
, parameters
, Qtitle
, Qnil
,
4266 "title", "Title", RES_TYPE_STRING
);
4267 x_default_parameter (f
, parameters
, Qfullscreen
, Qnil
,
4268 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL
);
4270 f
->output_data
.w32
->dwStyle
= WS_OVERLAPPEDWINDOW
;
4271 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
4273 f
->output_data
.w32
->text_cursor
= w32_load_cursor (IDC_IBEAM
);
4274 f
->output_data
.w32
->nontext_cursor
= w32_load_cursor (IDC_ARROW
);
4275 f
->output_data
.w32
->modeline_cursor
= w32_load_cursor (IDC_ARROW
);
4276 f
->output_data
.w32
->hand_cursor
= w32_load_cursor (IDC_HAND
);
4277 f
->output_data
.w32
->hourglass_cursor
= w32_load_cursor (IDC_WAIT
);
4278 f
->output_data
.w32
->horizontal_drag_cursor
= w32_load_cursor (IDC_SIZEWE
);
4280 f
->output_data
.w32
->current_cursor
= f
->output_data
.w32
->nontext_cursor
;
4282 window_prompting
= x_figure_window_size (f
, parameters
, 1);
4284 tem
= x_get_arg (dpyinfo
, parameters
, Qunsplittable
, 0, 0, RES_TYPE_BOOLEAN
);
4285 f
->no_split
= minibuffer_only
|| EQ (tem
, Qt
);
4287 w32_window (f
, window_prompting
, minibuffer_only
);
4288 x_icon (f
, parameters
);
4292 /* Now consider the frame official. */
4293 FRAME_W32_DISPLAY_INFO (f
)->reference_count
++;
4294 Vframe_list
= Fcons (frame
, Vframe_list
);
4296 /* We need to do this after creating the window, so that the
4297 icon-creation functions can say whose icon they're describing. */
4298 x_default_parameter (f
, parameters
, Qicon_type
, Qnil
,
4299 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL
);
4301 x_default_parameter (f
, parameters
, Qauto_raise
, Qnil
,
4302 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
4303 x_default_parameter (f
, parameters
, Qauto_lower
, Qnil
,
4304 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
4305 x_default_parameter (f
, parameters
, Qcursor_type
, Qbox
,
4306 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
4307 x_default_parameter (f
, parameters
, Qscroll_bar_width
, Qnil
,
4308 "scrollBarWidth", "ScrollBarWidth", RES_TYPE_NUMBER
);
4309 x_default_parameter (f
, parameters
, Qalpha
, Qnil
,
4310 "alpha", "Alpha", RES_TYPE_NUMBER
);
4312 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
4313 Change will not be effected unless different from the current
4315 width
= FRAME_COLS (f
);
4316 height
= FRAME_LINES (f
);
4318 FRAME_LINES (f
) = 0;
4319 SET_FRAME_COLS (f
, 0);
4320 change_frame_size (f
, height
, width
, 1, 0, 0);
4322 /* Tell the server what size and position, etc, we want, and how
4323 badly we want them. This should be done after we have the menu
4324 bar so that its size can be taken into account. */
4326 x_wm_set_size_hint (f
, window_prompting
, 0);
4329 /* Make the window appear on the frame and enable display, unless
4330 the caller says not to. However, with explicit parent, Emacs
4331 cannot control visibility, so don't try. */
4332 if (! f
->output_data
.w32
->explicit_parent
)
4334 Lisp_Object visibility
;
4336 visibility
= x_get_arg (dpyinfo
, parameters
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
);
4337 if (EQ (visibility
, Qunbound
))
4340 if (EQ (visibility
, Qicon
))
4341 x_iconify_frame (f
);
4342 else if (! NILP (visibility
))
4343 x_make_frame_visible (f
);
4345 /* Must have been Qnil. */
4349 /* Initialize `default-minibuffer-frame' in case this is the first
4350 frame on this terminal. */
4351 if (FRAME_HAS_MINIBUF_P (f
)
4352 && (!FRAMEP (kb
->Vdefault_minibuffer_frame
)
4353 || !FRAME_LIVE_P (XFRAME (kb
->Vdefault_minibuffer_frame
))))
4354 kb
->Vdefault_minibuffer_frame
= frame
;
4356 /* All remaining specified parameters, which have not been "used"
4357 by x_get_arg and friends, now go in the misc. alist of the frame. */
4358 for (tem
= parameters
; CONSP (tem
); tem
= XCDR (tem
))
4359 if (CONSP (XCAR (tem
)) && !NILP (XCAR (XCAR (tem
))))
4360 f
->param_alist
= Fcons (XCAR (tem
), f
->param_alist
);
4364 /* Make sure windows on this frame appear in calls to next-window
4365 and similar functions. */
4366 Vwindow_list
= Qnil
;
4368 return unbind_to (count
, frame
);
4371 /* FRAME is used only to get a handle on the X display. We don't pass the
4372 display info directly because we're called from frame.c, which doesn't
4373 know about that structure. */
4375 x_get_focus_frame (struct frame
*frame
)
4377 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (frame
);
4379 if (! dpyinfo
->w32_focus_frame
)
4382 XSETFRAME (xfocus
, dpyinfo
->w32_focus_frame
);
4386 DEFUN ("x-focus-frame", Fx_focus_frame
, Sx_focus_frame
, 1, 1, 0,
4387 doc
: /* Give FRAME input focus, raising to foreground if necessary. */)
4390 x_focus_on_frame (check_x_frame (frame
));
4395 DEFUN ("xw-color-defined-p", Fxw_color_defined_p
, Sxw_color_defined_p
, 1, 2, 0,
4396 doc
: /* Internal function called by `color-defined-p', which see.
4397 \(Note that the Nextstep version of this function ignores FRAME.) */)
4398 (Lisp_Object color
, Lisp_Object frame
)
4401 FRAME_PTR f
= check_x_frame (frame
);
4403 CHECK_STRING (color
);
4405 if (w32_defined_color (f
, SDATA (color
), &foo
, 0))
4411 DEFUN ("xw-color-values", Fxw_color_values
, Sxw_color_values
, 1, 2, 0,
4412 doc
: /* Internal function called by `color-values', which see. */)
4413 (Lisp_Object color
, Lisp_Object frame
)
4416 FRAME_PTR f
= check_x_frame (frame
);
4418 CHECK_STRING (color
);
4420 if (w32_defined_color (f
, SDATA (color
), &foo
, 0))
4421 return list3 (make_number ((GetRValue (foo
.pixel
) << 8)
4422 | GetRValue (foo
.pixel
)),
4423 make_number ((GetGValue (foo
.pixel
) << 8)
4424 | GetGValue (foo
.pixel
)),
4425 make_number ((GetBValue (foo
.pixel
) << 8)
4426 | GetBValue (foo
.pixel
)));
4431 DEFUN ("xw-display-color-p", Fxw_display_color_p
, Sxw_display_color_p
, 0, 1, 0,
4432 doc
: /* Internal function called by `display-color-p', which see. */)
4433 (Lisp_Object display
)
4435 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4437 if ((dpyinfo
->n_planes
* dpyinfo
->n_cbits
) <= 2)
4443 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p
,
4444 Sx_display_grayscale_p
, 0, 1, 0,
4445 doc
: /* Return t if DISPLAY supports shades of gray.
4446 Note that color displays do support shades of gray.
4447 The optional argument DISPLAY specifies which display to ask about.
4448 DISPLAY should be either a frame or a display name (a string).
4449 If omitted or nil, that stands for the selected frame's display. */)
4450 (Lisp_Object display
)
4452 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4454 if ((dpyinfo
->n_planes
* dpyinfo
->n_cbits
) <= 1)
4460 DEFUN ("x-display-pixel-width", Fx_display_pixel_width
,
4461 Sx_display_pixel_width
, 0, 1, 0,
4462 doc
: /* Return the width in pixels of DISPLAY.
4463 The optional argument DISPLAY specifies which display to ask about.
4464 DISPLAY should be either a frame or a display name (a string).
4465 If omitted or nil, that stands for the selected frame's display. */)
4466 (Lisp_Object display
)
4468 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4470 return make_number (x_display_pixel_width (dpyinfo
));
4473 DEFUN ("x-display-pixel-height", Fx_display_pixel_height
,
4474 Sx_display_pixel_height
, 0, 1, 0,
4475 doc
: /* Return the height in pixels of DISPLAY.
4476 The optional argument DISPLAY specifies which display to ask about.
4477 DISPLAY should be either a frame or a display name (a string).
4478 If omitted or nil, that stands for the selected frame's display. */)
4479 (Lisp_Object display
)
4481 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4483 return make_number (x_display_pixel_height (dpyinfo
));
4486 DEFUN ("x-display-planes", Fx_display_planes
, Sx_display_planes
,
4488 doc
: /* Return the number of bitplanes of DISPLAY.
4489 The optional argument DISPLAY specifies which display to ask about.
4490 DISPLAY should be either a frame or a display name (a string).
4491 If omitted or nil, that stands for the selected frame's display. */)
4492 (Lisp_Object display
)
4494 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4496 return make_number (dpyinfo
->n_planes
* dpyinfo
->n_cbits
);
4499 DEFUN ("x-display-color-cells", Fx_display_color_cells
, Sx_display_color_cells
,
4501 doc
: /* Return the number of color cells of DISPLAY.
4502 The optional argument DISPLAY specifies which display to ask about.
4503 DISPLAY should be either a frame or a display name (a string).
4504 If omitted or nil, that stands for the selected frame's display. */)
4505 (Lisp_Object display
)
4507 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4511 hdc
= GetDC (dpyinfo
->root_window
);
4512 if (dpyinfo
->has_palette
)
4513 cap
= GetDeviceCaps (hdc
, SIZEPALETTE
);
4515 cap
= GetDeviceCaps (hdc
, NUMCOLORS
);
4517 /* We force 24+ bit depths to 24-bit, both to prevent an overflow
4518 and because probably is more meaningful on Windows anyway */
4520 cap
= 1 << min (dpyinfo
->n_planes
* dpyinfo
->n_cbits
, 24);
4522 ReleaseDC (dpyinfo
->root_window
, hdc
);
4524 return make_number (cap
);
4527 DEFUN ("x-server-max-request-size", Fx_server_max_request_size
,
4528 Sx_server_max_request_size
,
4530 doc
: /* Return the maximum request size of the server of DISPLAY.
4531 The optional argument DISPLAY specifies which display to ask about.
4532 DISPLAY should be either a frame or a display name (a string).
4533 If omitted or nil, that stands for the selected frame's display. */)
4534 (Lisp_Object display
)
4536 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4538 return make_number (1);
4541 DEFUN ("x-server-vendor", Fx_server_vendor
, Sx_server_vendor
, 0, 1, 0,
4542 doc
: /* Return the "vendor ID" string of the W32 system (Microsoft).
4543 The optional argument DISPLAY specifies which display to ask about.
4544 DISPLAY should be either a frame or a display name (a string).
4545 If omitted or nil, that stands for the selected frame's display. */)
4546 (Lisp_Object display
)
4548 return build_string ("Microsoft Corp.");
4551 DEFUN ("x-server-version", Fx_server_version
, Sx_server_version
, 0, 1, 0,
4552 doc
: /* Return the version numbers of the server of DISPLAY.
4553 The value is a list of three integers: the major and minor
4554 version numbers of the X Protocol in use, and the distributor-specific
4555 release number. See also the function `x-server-vendor'.
4557 The optional argument DISPLAY specifies which display to ask about.
4558 DISPLAY should be either a frame or a display name (a string).
4559 If omitted or nil, that stands for the selected frame's display. */)
4560 (Lisp_Object display
)
4562 return Fcons (make_number (w32_major_version
),
4563 Fcons (make_number (w32_minor_version
),
4564 Fcons (make_number (w32_build_number
), Qnil
)));
4567 DEFUN ("x-display-screens", Fx_display_screens
, Sx_display_screens
, 0, 1, 0,
4568 doc
: /* Return the number of screens on the server of DISPLAY.
4569 The optional argument DISPLAY specifies which display to ask about.
4570 DISPLAY should be either a frame or a display name (a string).
4571 If omitted or nil, that stands for the selected frame's display. */)
4572 (Lisp_Object display
)
4574 return make_number (1);
4577 DEFUN ("x-display-mm-height", Fx_display_mm_height
,
4578 Sx_display_mm_height
, 0, 1, 0,
4579 doc
: /* Return the height in millimeters of DISPLAY.
4580 The optional argument DISPLAY specifies which display to ask about.
4581 DISPLAY should be either a frame or a display name (a string).
4582 If omitted or nil, that stands for the selected frame's display. */)
4583 (Lisp_Object display
)
4585 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4589 hdc
= GetDC (dpyinfo
->root_window
);
4591 cap
= GetDeviceCaps (hdc
, VERTSIZE
);
4593 ReleaseDC (dpyinfo
->root_window
, hdc
);
4595 return make_number (cap
);
4598 DEFUN ("x-display-mm-width", Fx_display_mm_width
, Sx_display_mm_width
, 0, 1, 0,
4599 doc
: /* Return the width in millimeters of DISPLAY.
4600 The optional argument DISPLAY specifies which display to ask about.
4601 DISPLAY should be either a frame or a display name (a string).
4602 If omitted or nil, that stands for the selected frame's display. */)
4603 (Lisp_Object display
)
4605 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4610 hdc
= GetDC (dpyinfo
->root_window
);
4612 cap
= GetDeviceCaps (hdc
, HORZSIZE
);
4614 ReleaseDC (dpyinfo
->root_window
, hdc
);
4616 return make_number (cap
);
4619 DEFUN ("x-display-backing-store", Fx_display_backing_store
,
4620 Sx_display_backing_store
, 0, 1, 0,
4621 doc
: /* Return an indication of whether DISPLAY does backing store.
4622 The value may be `always', `when-mapped', or `not-useful'.
4623 The optional argument DISPLAY specifies which display to ask about.
4624 DISPLAY should be either a frame or a display name (a string).
4625 If omitted or nil, that stands for the selected frame's display. */)
4626 (Lisp_Object display
)
4628 return intern ("not-useful");
4631 DEFUN ("x-display-visual-class", Fx_display_visual_class
,
4632 Sx_display_visual_class
, 0, 1, 0,
4633 doc
: /* Return the visual class of DISPLAY.
4634 The value is one of the symbols `static-gray', `gray-scale',
4635 `static-color', `pseudo-color', `true-color', or `direct-color'.
4637 The optional argument DISPLAY specifies which display to ask about.
4638 DISPLAY should be either a frame or a display name (a string).
4639 If omitted or nil, that stands for the selected frame's display. */)
4640 (Lisp_Object display
)
4642 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4643 Lisp_Object result
= Qnil
;
4645 if (dpyinfo
->has_palette
)
4646 result
= intern ("pseudo-color");
4647 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
== 1)
4648 result
= intern ("static-grey");
4649 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
== 4)
4650 result
= intern ("static-color");
4651 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
> 8)
4652 result
= intern ("true-color");
4657 DEFUN ("x-display-save-under", Fx_display_save_under
,
4658 Sx_display_save_under
, 0, 1, 0,
4659 doc
: /* Return t if DISPLAY supports the save-under feature.
4660 The optional argument DISPLAY specifies which display to ask about.
4661 DISPLAY should be either a frame or a display name (a string).
4662 If omitted or nil, that stands for the selected frame's display. */)
4663 (Lisp_Object display
)
4669 x_pixel_width (register struct frame
*f
)
4671 return FRAME_PIXEL_WIDTH (f
);
4675 x_pixel_height (register struct frame
*f
)
4677 return FRAME_PIXEL_HEIGHT (f
);
4681 x_char_width (register struct frame
*f
)
4683 return FRAME_COLUMN_WIDTH (f
);
4687 x_char_height (register struct frame
*f
)
4689 return FRAME_LINE_HEIGHT (f
);
4693 x_screen_planes (register struct frame
*f
)
4695 return FRAME_W32_DISPLAY_INFO (f
)->n_planes
;
4698 /* Return the display structure for the display named NAME.
4699 Open a new connection if necessary. */
4701 struct w32_display_info
*
4702 x_display_info_for_name (Lisp_Object name
)
4705 struct w32_display_info
*dpyinfo
;
4707 CHECK_STRING (name
);
4709 for (dpyinfo
= &one_w32_display_info
, names
= w32_display_name_list
;
4711 dpyinfo
= dpyinfo
->next
, names
= XCDR (names
))
4714 tem
= Fstring_equal (XCAR (XCAR (names
)), name
);
4719 /* Use this general default value to start with. */
4720 Vx_resource_name
= Vinvocation_name
;
4722 validate_x_resource_name ();
4724 dpyinfo
= w32_term_init (name
, (unsigned char *)0,
4725 SSDATA (Vx_resource_name
));
4728 error ("Cannot connect to server %s", SDATA (name
));
4731 XSETFASTINT (Vwindow_system_version
, w32_major_version
);
4736 DEFUN ("x-open-connection", Fx_open_connection
, Sx_open_connection
,
4737 1, 3, 0, doc
: /* Open a connection to a display server.
4738 DISPLAY is the name of the display to connect to.
4739 Optional second arg XRM-STRING is a string of resources in xrdb format.
4740 If the optional third arg MUST-SUCCEED is non-nil,
4741 terminate Emacs if we can't open the connection.
4742 \(In the Nextstep version, the last two arguments are currently ignored.) */)
4743 (Lisp_Object display
, Lisp_Object xrm_string
, Lisp_Object must_succeed
)
4745 unsigned char *xrm_option
;
4746 struct w32_display_info
*dpyinfo
;
4748 /* If initialization has already been done, return now to avoid
4749 overwriting critical parts of one_w32_display_info. */
4753 CHECK_STRING (display
);
4754 if (! NILP (xrm_string
))
4755 CHECK_STRING (xrm_string
);
4758 if (! EQ (Vwindow_system
, intern ("w32")))
4759 error ("Not using Microsoft Windows");
4762 /* Allow color mapping to be defined externally; first look in user's
4763 HOME directory, then in Emacs etc dir for a file called rgb.txt. */
4765 Lisp_Object color_file
;
4766 struct gcpro gcpro1
;
4768 color_file
= build_string ("~/rgb.txt");
4770 GCPRO1 (color_file
);
4772 if (NILP (Ffile_readable_p (color_file
)))
4774 Fexpand_file_name (build_string ("rgb.txt"),
4775 Fsymbol_value (intern ("data-directory")));
4777 Vw32_color_map
= Fx_load_color_file (color_file
);
4781 if (NILP (Vw32_color_map
))
4782 Vw32_color_map
= Fw32_default_color_map ();
4784 /* Merge in system logical colors. */
4785 add_system_logical_colors_to_map (&Vw32_color_map
);
4787 if (! NILP (xrm_string
))
4788 xrm_option
= SDATA (xrm_string
);
4790 xrm_option
= (unsigned char *) 0;
4792 /* Use this general default value to start with. */
4793 /* First remove .exe suffix from invocation-name - it looks ugly. */
4795 char basename
[ MAX_PATH
], *str
;
4797 strcpy (basename
, SDATA (Vinvocation_name
));
4798 str
= strrchr (basename
, '.');
4800 Vinvocation_name
= build_string (basename
);
4802 Vx_resource_name
= Vinvocation_name
;
4804 validate_x_resource_name ();
4806 /* This is what opens the connection and sets x_current_display.
4807 This also initializes many symbols, such as those used for input. */
4808 dpyinfo
= w32_term_init (display
, xrm_option
,
4809 SSDATA (Vx_resource_name
));
4813 if (!NILP (must_succeed
))
4814 fatal ("Cannot connect to server %s.\n",
4817 error ("Cannot connect to server %s", SDATA (display
));
4822 XSETFASTINT (Vwindow_system_version
, w32_major_version
);
4826 DEFUN ("x-close-connection", Fx_close_connection
,
4827 Sx_close_connection
, 1, 1, 0,
4828 doc
: /* Close the connection to DISPLAY's server.
4829 For DISPLAY, specify either a frame or a display name (a string).
4830 If DISPLAY is nil, that stands for the selected frame's display. */)
4831 (Lisp_Object display
)
4833 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4836 if (dpyinfo
->reference_count
> 0)
4837 error ("Display still has frames on it");
4840 x_destroy_all_bitmaps (dpyinfo
);
4842 x_delete_display (dpyinfo
);
4848 DEFUN ("x-display-list", Fx_display_list
, Sx_display_list
, 0, 0, 0,
4849 doc
: /* Return the list of display names that Emacs has connections to. */)
4852 Lisp_Object tail
, result
;
4855 for (tail
= w32_display_name_list
; CONSP (tail
); tail
= XCDR (tail
))
4856 result
= Fcons (XCAR (XCAR (tail
)), result
);
4861 DEFUN ("x-synchronize", Fx_synchronize
, Sx_synchronize
, 1, 2, 0,
4862 doc
: /* If ON is non-nil, report X errors as soon as the erring request is made.
4863 This function only has an effect on X Windows. With MS Windows, it is
4864 defined but does nothing.
4866 If ON is nil, allow buffering of requests.
4867 Turning on synchronization prohibits the Xlib routines from buffering
4868 requests and seriously degrades performance, but makes debugging much
4870 The optional second argument TERMINAL specifies which display to act on.
4871 TERMINAL should be a terminal object, a frame or a display name (a string).
4872 If TERMINAL is omitted or nil, that stands for the selected frame's display. */)
4873 (Lisp_Object on
, Lisp_Object display
)
4880 /***********************************************************************
4882 ***********************************************************************/
4884 DEFUN ("x-change-window-property", Fx_change_window_property
,
4885 Sx_change_window_property
, 2, 6, 0,
4886 doc
: /* Change window property PROP to VALUE on the X window of FRAME.
4887 PROP must be a string. VALUE may be a string or a list of conses,
4888 numbers and/or strings. If an element in the list is a string, it is
4889 converted to an atom and the value of the Atom is used. If an element
4890 is a cons, it is converted to a 32 bit number where the car is the 16
4891 top bits and the cdr is the lower 16 bits.
4893 FRAME nil or omitted means use the selected frame.
4894 If TYPE is given and non-nil, it is the name of the type of VALUE.
4895 If TYPE is not given or nil, the type is STRING.
4896 FORMAT gives the size in bits of each element if VALUE is a list.
4897 It must be one of 8, 16 or 32.
4898 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
4899 If OUTER_P is non-nil, the property is changed for the outer X window of
4900 FRAME. Default is to change on the edit X window. */)
4901 (Lisp_Object prop
, Lisp_Object value
, Lisp_Object frame
, Lisp_Object type
, Lisp_Object format
, Lisp_Object outer_p
)
4903 #if 0 /* TODO : port window properties to W32 */
4904 struct frame
*f
= check_x_frame (frame
);
4907 CHECK_STRING (prop
);
4908 CHECK_STRING (value
);
4911 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
4912 XChangeProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
4913 prop_atom
, XA_STRING
, 8, PropModeReplace
,
4914 SDATA (value
), SCHARS (value
));
4916 /* Make sure the property is set when we return. */
4917 XFlush (FRAME_W32_DISPLAY (f
));
4926 DEFUN ("x-delete-window-property", Fx_delete_window_property
,
4927 Sx_delete_window_property
, 1, 2, 0,
4928 doc
: /* Remove window property PROP from X window of FRAME.
4929 FRAME nil or omitted means use the selected frame. Value is PROP. */)
4930 (Lisp_Object prop
, Lisp_Object frame
)
4932 #if 0 /* TODO : port window properties to W32 */
4934 struct frame
*f
= check_x_frame (frame
);
4937 CHECK_STRING (prop
);
4939 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
4940 XDeleteProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
), prop_atom
);
4942 /* Make sure the property is removed when we return. */
4943 XFlush (FRAME_W32_DISPLAY (f
));
4951 DEFUN ("x-window-property", Fx_window_property
, Sx_window_property
,
4953 doc
: /* Value is the value of window property PROP on FRAME.
4954 If FRAME is nil or omitted, use the selected frame.
4956 On MS Windows, this function only accepts the PROP and FRAME arguments.
4958 On X Windows, the following optional arguments are also accepted:
4959 If TYPE is nil or omitted, get the property as a string.
4960 Otherwise TYPE is the name of the atom that denotes the type expected.
4961 If SOURCE is non-nil, get the property on that window instead of from
4962 FRAME. The number 0 denotes the root window.
4963 If DELETE_P is non-nil, delete the property after retreiving it.
4964 If VECTOR_RET_P is non-nil, don't return a string but a vector of values.
4966 Value is nil if FRAME hasn't a property with name PROP or if PROP has
4967 no value of TYPE (always string in the MS Windows case). */)
4968 (Lisp_Object prop
, Lisp_Object frame
)
4970 #if 0 /* TODO : port window properties to W32 */
4972 struct frame
*f
= check_x_frame (frame
);
4975 Lisp_Object prop_value
= Qnil
;
4976 char *tmp_data
= NULL
;
4979 unsigned long actual_size
, bytes_remaining
;
4981 CHECK_STRING (prop
);
4983 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
4984 rc
= XGetWindowProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
4985 prop_atom
, 0, 0, False
, XA_STRING
,
4986 &actual_type
, &actual_format
, &actual_size
,
4987 &bytes_remaining
, (unsigned char **) &tmp_data
);
4990 int size
= bytes_remaining
;
4995 rc
= XGetWindowProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
4996 prop_atom
, 0, bytes_remaining
,
4998 &actual_type
, &actual_format
,
4999 &actual_size
, &bytes_remaining
,
5000 (unsigned char **) &tmp_data
);
5002 prop_value
= make_string (tmp_data
, size
);
5017 /***********************************************************************
5019 ***********************************************************************/
5021 /* Default number of seconds to wait before displaying an hourglass
5022 cursor. Duplicated from xdisp.c, but cannot use the version there
5023 due to lack of atimers on w32. */
5024 #define DEFAULT_HOURGLASS_DELAY 1
5025 /* Return non-zero if houglass timer has been started or hourglass is shown. */
5026 /* PENDING: if W32 can use atimers (atimer.[hc]) then the common impl in
5027 xdisp.c could be used. */
5030 hourglass_started (void)
5032 return hourglass_shown_p
|| hourglass_timer
;
5035 /* Cancel a currently active hourglass timer, and start a new one. */
5038 start_hourglass (void)
5041 int secs
, msecs
= 0;
5042 struct frame
* f
= SELECTED_FRAME ();
5044 /* No cursors on non GUI frames. */
5045 if (!FRAME_W32_P (f
))
5048 cancel_hourglass ();
5050 if (INTEGERP (Vhourglass_delay
)
5051 && XINT (Vhourglass_delay
) > 0)
5052 secs
= XFASTINT (Vhourglass_delay
);
5053 else if (FLOATP (Vhourglass_delay
)
5054 && XFLOAT_DATA (Vhourglass_delay
) > 0)
5057 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
5058 secs
= XFASTINT (tem
);
5059 msecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000;
5062 secs
= DEFAULT_HOURGLASS_DELAY
;
5064 delay
= secs
* 1000 + msecs
;
5065 hourglass_hwnd
= FRAME_W32_WINDOW (f
);
5066 hourglass_timer
= SetTimer (hourglass_hwnd
, HOURGLASS_ID
, delay
, NULL
);
5070 /* Cancel the hourglass cursor timer if active, hide an hourglass
5074 cancel_hourglass (void)
5076 if (hourglass_timer
)
5078 KillTimer (hourglass_hwnd
, hourglass_timer
);
5079 hourglass_timer
= 0;
5082 if (hourglass_shown_p
)
5083 w32_hide_hourglass ();
5087 /* Timer function of hourglass_timer.
5089 Display an hourglass cursor. Set the hourglass_p flag in display info
5090 to indicate that an hourglass cursor is shown. */
5093 w32_show_hourglass (struct frame
*f
)
5095 if (!hourglass_shown_p
)
5097 f
->output_data
.w32
->hourglass_p
= 1;
5098 if (!menubar_in_use
&& !current_popup_menu
)
5099 SetCursor (f
->output_data
.w32
->hourglass_cursor
);
5100 hourglass_shown_p
= 1;
5105 /* Hide the hourglass cursor on all frames, if it is currently shown. */
5108 w32_hide_hourglass (void)
5110 if (hourglass_shown_p
)
5112 struct frame
*f
= x_window_to_frame (&one_w32_display_info
,
5115 f
->output_data
.w32
->hourglass_p
= 0;
5117 /* If frame was deleted, restore to selected frame's cursor. */
5118 f
= SELECTED_FRAME ();
5120 if (FRAME_W32_P (f
))
5121 SetCursor (f
->output_data
.w32
->current_cursor
);
5123 /* No cursors on non GUI frames - restore to stock arrow cursor. */
5124 SetCursor (w32_load_cursor (IDC_ARROW
));
5126 hourglass_shown_p
= 0;
5132 /***********************************************************************
5134 ***********************************************************************/
5136 static Lisp_Object
x_create_tip_frame (struct w32_display_info
*,
5137 Lisp_Object
, Lisp_Object
);
5138 static void compute_tip_xy (struct frame
*, Lisp_Object
, Lisp_Object
,
5139 Lisp_Object
, int, int, int *, int *);
5141 /* The frame of a currently visible tooltip. */
5143 Lisp_Object tip_frame
;
5145 /* If non-nil, a timer started that hides the last tooltip when it
5148 Lisp_Object tip_timer
;
5151 /* If non-nil, a vector of 3 elements containing the last args
5152 with which x-show-tip was called. See there. */
5154 Lisp_Object last_show_tip_args
;
5158 unwind_create_tip_frame (Lisp_Object frame
)
5160 Lisp_Object deleted
;
5162 deleted
= unwind_create_frame (frame
);
5163 if (EQ (deleted
, Qt
))
5173 /* Create a frame for a tooltip on the display described by DPYINFO.
5174 PARMS is a list of frame parameters. TEXT is the string to
5175 display in the tip frame. Value is the frame.
5177 Note that functions called here, esp. x_default_parameter can
5178 signal errors, for instance when a specified color name is
5179 undefined. We have to make sure that we're in a consistent state
5180 when this happens. */
5183 x_create_tip_frame (struct w32_display_info
*dpyinfo
,
5184 Lisp_Object parms
, Lisp_Object text
)
5187 Lisp_Object frame
, tem
;
5189 long window_prompting
= 0;
5191 int count
= SPECPDL_INDEX ();
5192 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5194 int face_change_count_before
= face_change_count
;
5196 struct buffer
*old_buffer
;
5200 /* Use this general default value to start with until we know if
5201 this frame has a specified name. */
5202 Vx_resource_name
= Vinvocation_name
;
5204 kb
= dpyinfo
->terminal
->kboard
;
5206 /* The calls to x_get_arg remove elements from PARMS, so copy it to
5207 avoid destructive changes behind our caller's back. */
5208 parms
= Fcopy_alist (parms
);
5210 /* Get the name of the frame to use for resource lookup. */
5211 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
5213 && !EQ (name
, Qunbound
)
5215 error ("Invalid frame name--not a string or nil");
5216 Vx_resource_name
= name
;
5219 GCPRO3 (parms
, name
, frame
);
5220 /* Make a frame without minibuffer nor mode-line. */
5222 f
->wants_modeline
= 0;
5223 XSETFRAME (frame
, f
);
5225 buffer
= Fget_buffer_create (build_string (" *tip*"));
5226 Fset_window_buffer (FRAME_ROOT_WINDOW (f
), buffer
, Qnil
);
5227 old_buffer
= current_buffer
;
5228 set_buffer_internal_1 (XBUFFER (buffer
));
5229 current_buffer
->truncate_lines
= Qnil
;
5230 specbind (Qinhibit_read_only
, Qt
);
5231 specbind (Qinhibit_modification_hooks
, Qt
);
5234 set_buffer_internal_1 (old_buffer
);
5236 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
5237 record_unwind_protect (unwind_create_tip_frame
, frame
);
5239 /* By setting the output method, we're essentially saying that
5240 the frame is live, as per FRAME_LIVE_P. If we get a signal
5241 from this point on, x_destroy_window might screw up reference
5243 f
->terminal
= dpyinfo
->terminal
;
5244 f
->terminal
->reference_count
++;
5245 f
->output_method
= output_w32
;
5246 f
->output_data
.w32
=
5247 (struct w32_output
*) xmalloc (sizeof (struct w32_output
));
5248 memset (f
->output_data
.w32
, 0, sizeof (struct w32_output
));
5250 FRAME_FONTSET (f
) = -1;
5251 f
->icon_name
= Qnil
;
5254 image_cache_refcount
= FRAME_IMAGE_CACHE (f
)->refcount
;
5255 dpyinfo_refcount
= dpyinfo
->reference_count
;
5256 #endif /* GLYPH_DEBUG */
5257 FRAME_KBOARD (f
) = kb
;
5258 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
5259 f
->output_data
.w32
->explicit_parent
= 0;
5261 /* Set the name; the functions to which we pass f expect the name to
5263 if (EQ (name
, Qunbound
) || NILP (name
))
5265 f
->name
= build_string (dpyinfo
->w32_id_name
);
5266 f
->explicit_name
= 0;
5271 f
->explicit_name
= 1;
5272 /* use the frame's title when getting resources for this frame. */
5273 specbind (Qx_resource_name
, name
);
5276 f
->resx
= dpyinfo
->resx
;
5277 f
->resy
= dpyinfo
->resy
;
5279 if (uniscribe_available
)
5280 register_font_driver (&uniscribe_font_driver
, f
);
5281 register_font_driver (&w32font_driver
, f
);
5283 x_default_parameter (f
, parms
, Qfont_backend
, Qnil
,
5284 "fontBackend", "FontBackend", RES_TYPE_STRING
);
5286 /* Extract the window parameters from the supplied values
5287 that are needed to determine window geometry. */
5288 x_default_font_parameter (f
, parms
);
5290 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
5291 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
5292 /* This defaults to 2 in order to match xterm. We recognize either
5293 internalBorderWidth or internalBorder (which is what xterm calls
5295 if (NILP (Fassq (Qinternal_border_width
, parms
)))
5299 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
5300 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
5301 if (! EQ (value
, Qunbound
))
5302 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
5305 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
5306 "internalBorderWidth", "internalBorderWidth",
5309 /* Also do the stuff which must be set before the window exists. */
5310 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
5311 "foreground", "Foreground", RES_TYPE_STRING
);
5312 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
5313 "background", "Background", RES_TYPE_STRING
);
5314 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
5315 "pointerColor", "Foreground", RES_TYPE_STRING
);
5316 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
5317 "cursorColor", "Foreground", RES_TYPE_STRING
);
5318 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
5319 "borderColor", "BorderColor", RES_TYPE_STRING
);
5321 /* Init faces before x_default_parameter is called for scroll-bar
5322 parameters because that function calls x_set_scroll_bar_width,
5323 which calls change_frame_size, which calls Fset_window_buffer,
5324 which runs hooks, which call Fvertical_motion. At the end, we
5325 end up in init_iterator with a null face cache, which should not
5327 init_frame_faces (f
);
5329 f
->output_data
.w32
->dwStyle
= WS_BORDER
| WS_POPUP
| WS_DISABLED
;
5330 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
5332 window_prompting
= x_figure_window_size (f
, parms
, 0);
5334 /* No fringes on tip frame. */
5336 f
->left_fringe_width
= 0;
5337 f
->right_fringe_width
= 0;
5340 my_create_tip_window (f
);
5345 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
5346 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
5347 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
5348 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
5349 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
5350 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
5352 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
5353 Change will not be effected unless different from the current
5355 width
= FRAME_COLS (f
);
5356 height
= FRAME_LINES (f
);
5357 FRAME_LINES (f
) = 0;
5358 SET_FRAME_COLS (f
, 0);
5359 change_frame_size (f
, height
, width
, 1, 0, 0);
5361 /* Add `tooltip' frame parameter's default value. */
5362 if (NILP (Fframe_parameter (frame
, Qtooltip
)))
5363 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qtooltip
, Qt
), Qnil
));
5365 /* Set up faces after all frame parameters are known. This call
5366 also merges in face attributes specified for new frames.
5368 Frame parameters may be changed if .Xdefaults contains
5369 specifications for the default font. For example, if there is an
5370 `Emacs.default.attributeBackground: pink', the `background-color'
5371 attribute of the frame get's set, which let's the internal border
5372 of the tooltip frame appear in pink. Prevent this. */
5374 Lisp_Object bg
= Fframe_parameter (frame
, Qbackground_color
);
5375 Lisp_Object fg
= Fframe_parameter (frame
, Qforeground_color
);
5376 Lisp_Object colors
= Qnil
;
5378 /* Set tip_frame here, so that */
5380 call2 (Qface_set_after_frame_default
, frame
, Qnil
);
5382 if (!EQ (bg
, Fframe_parameter (frame
, Qbackground_color
)))
5383 colors
= Fcons (Fcons (Qbackground_color
, bg
), colors
);
5384 if (!EQ (fg
, Fframe_parameter (frame
, Qforeground_color
)))
5385 colors
= Fcons (Fcons (Qforeground_color
, fg
), colors
);
5388 Fmodify_frame_parameters (frame
, colors
);
5395 /* It is now ok to make the frame official even if we get an error
5396 below. And the frame needs to be on Vframe_list or making it
5397 visible won't work. */
5398 Vframe_list
= Fcons (frame
, Vframe_list
);
5400 /* Now that the frame is official, it counts as a reference to
5402 FRAME_W32_DISPLAY_INFO (f
)->reference_count
++;
5404 /* Setting attributes of faces of the tooltip frame from resources
5405 and similar will increment face_change_count, which leads to the
5406 clearing of all current matrices. Since this isn't necessary
5407 here, avoid it by resetting face_change_count to the value it
5408 had before we created the tip frame. */
5409 face_change_count
= face_change_count_before
;
5411 /* Discard the unwind_protect. */
5412 return unbind_to (count
, frame
);
5416 /* Compute where to display tip frame F. PARMS is the list of frame
5417 parameters for F. DX and DY are specified offsets from the current
5418 location of the mouse. WIDTH and HEIGHT are the width and height
5419 of the tooltip. Return coordinates relative to the root window of
5420 the display in *ROOT_X, and *ROOT_Y. */
5423 compute_tip_xy (struct frame
*f
,
5424 Lisp_Object parms
, Lisp_Object dx
, Lisp_Object dy
,
5425 int width
, int height
, int *root_x
, int *root_y
)
5427 Lisp_Object left
, top
;
5428 int min_x
, min_y
, max_x
, max_y
;
5430 /* User-specified position? */
5431 left
= Fcdr (Fassq (Qleft
, parms
));
5432 top
= Fcdr (Fassq (Qtop
, parms
));
5434 /* Move the tooltip window where the mouse pointer is. Resize and
5436 if (!INTEGERP (left
) || !INTEGERP (top
))
5440 /* Default min and max values. */
5443 max_x
= x_display_pixel_width (FRAME_W32_DISPLAY_INFO (f
));
5444 max_y
= x_display_pixel_height (FRAME_W32_DISPLAY_INFO (f
));
5452 /* If multiple monitor support is available, constrain the tip onto
5453 the current monitor. This improves the above by allowing negative
5454 co-ordinates if monitor positions are such that they are valid, and
5455 snaps a tooltip onto a single monitor if we are close to the edge
5456 where it would otherwise flow onto the other monitor (or into
5457 nothingness if there is a gap in the overlap). */
5458 if (monitor_from_point_fn
&& get_monitor_info_fn
)
5460 struct MONITOR_INFO info
;
5462 = monitor_from_point_fn (pt
, MONITOR_DEFAULT_TO_NEAREST
);
5463 info
.cbSize
= sizeof (info
);
5465 if (get_monitor_info_fn (monitor
, &info
))
5467 min_x
= info
.rcWork
.left
;
5468 min_y
= info
.rcWork
.top
;
5469 max_x
= info
.rcWork
.right
;
5470 max_y
= info
.rcWork
.bottom
;
5476 *root_y
= XINT (top
);
5477 else if (*root_y
+ XINT (dy
) <= min_y
)
5478 *root_y
= min_y
; /* Can happen for negative dy */
5479 else if (*root_y
+ XINT (dy
) + height
<= max_y
)
5480 /* It fits below the pointer */
5481 *root_y
+= XINT (dy
);
5482 else if (height
+ XINT (dy
) + min_y
<= *root_y
)
5483 /* It fits above the pointer. */
5484 *root_y
-= height
+ XINT (dy
);
5486 /* Put it on the top. */
5489 if (INTEGERP (left
))
5490 *root_x
= XINT (left
);
5491 else if (*root_x
+ XINT (dx
) <= min_x
)
5492 *root_x
= 0; /* Can happen for negative dx */
5493 else if (*root_x
+ XINT (dx
) + width
<= max_x
)
5494 /* It fits to the right of the pointer. */
5495 *root_x
+= XINT (dx
);
5496 else if (width
+ XINT (dx
) + min_x
<= *root_x
)
5497 /* It fits to the left of the pointer. */
5498 *root_x
-= width
+ XINT (dx
);
5500 /* Put it left justified on the screen -- it ought to fit that way. */
5505 DEFUN ("x-show-tip", Fx_show_tip
, Sx_show_tip
, 1, 6, 0,
5506 doc
: /* Show STRING in a \"tooltip\" window on frame FRAME.
5507 A tooltip window is a small window displaying a string.
5509 This is an internal function; Lisp code should call `tooltip-show'.
5511 FRAME nil or omitted means use the selected frame.
5513 PARMS is an optional list of frame parameters which can be
5514 used to change the tooltip's appearance.
5516 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
5517 means use the default timeout of 5 seconds.
5519 If the list of frame parameters PARMS contains a `left' parameter,
5520 the tooltip is displayed at that x-position. Otherwise it is
5521 displayed at the mouse position, with offset DX added (default is 5 if
5522 DX isn't specified). Likewise for the y-position; if a `top' frame
5523 parameter is specified, it determines the y-position of the tooltip
5524 window, otherwise it is displayed at the mouse position, with offset
5525 DY added (default is -10).
5527 A tooltip's maximum size is specified by `x-max-tooltip-size'.
5528 Text larger than the specified size is clipped. */)
5529 (Lisp_Object string
, Lisp_Object frame
, Lisp_Object parms
, Lisp_Object timeout
, Lisp_Object dx
, Lisp_Object dy
)
5534 struct buffer
*old_buffer
;
5535 struct text_pos pos
;
5536 int i
, width
, height
, seen_reversed_p
;
5537 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
5538 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
5539 int count
= SPECPDL_INDEX ();
5541 specbind (Qinhibit_redisplay
, Qt
);
5543 GCPRO4 (string
, parms
, frame
, timeout
);
5545 CHECK_STRING (string
);
5546 f
= check_x_frame (frame
);
5548 timeout
= make_number (5);
5550 CHECK_NATNUM (timeout
);
5553 dx
= make_number (5);
5558 dy
= make_number (-10);
5562 if (NILP (last_show_tip_args
))
5563 last_show_tip_args
= Fmake_vector (make_number (3), Qnil
);
5565 if (!NILP (tip_frame
))
5567 Lisp_Object last_string
= AREF (last_show_tip_args
, 0);
5568 Lisp_Object last_frame
= AREF (last_show_tip_args
, 1);
5569 Lisp_Object last_parms
= AREF (last_show_tip_args
, 2);
5571 if (EQ (frame
, last_frame
)
5572 && !NILP (Fequal (last_string
, string
))
5573 && !NILP (Fequal (last_parms
, parms
)))
5575 struct frame
*f
= XFRAME (tip_frame
);
5577 /* Only DX and DY have changed. */
5578 if (!NILP (tip_timer
))
5580 Lisp_Object timer
= tip_timer
;
5582 call1 (Qcancel_timer
, timer
);
5586 compute_tip_xy (f
, parms
, dx
, dy
, FRAME_PIXEL_WIDTH (f
),
5587 FRAME_PIXEL_HEIGHT (f
), &root_x
, &root_y
);
5589 /* Put tooltip in topmost group and in position. */
5590 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOPMOST
,
5591 root_x
, root_y
, 0, 0,
5592 SWP_NOSIZE
| SWP_NOACTIVATE
);
5594 /* Ensure tooltip is on top of other topmost windows (eg menus). */
5595 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOP
,
5597 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5604 /* Hide a previous tip, if any. */
5607 ASET (last_show_tip_args
, 0, string
);
5608 ASET (last_show_tip_args
, 1, frame
);
5609 ASET (last_show_tip_args
, 2, parms
);
5611 /* Add default values to frame parameters. */
5612 if (NILP (Fassq (Qname
, parms
)))
5613 parms
= Fcons (Fcons (Qname
, build_string ("tooltip")), parms
);
5614 if (NILP (Fassq (Qinternal_border_width
, parms
)))
5615 parms
= Fcons (Fcons (Qinternal_border_width
, make_number (3)), parms
);
5616 if (NILP (Fassq (Qborder_width
, parms
)))
5617 parms
= Fcons (Fcons (Qborder_width
, make_number (1)), parms
);
5618 if (NILP (Fassq (Qborder_color
, parms
)))
5619 parms
= Fcons (Fcons (Qborder_color
, build_string ("lightyellow")), parms
);
5620 if (NILP (Fassq (Qbackground_color
, parms
)))
5621 parms
= Fcons (Fcons (Qbackground_color
, build_string ("lightyellow")),
5624 /* Block input until the tip has been fully drawn, to avoid crashes
5625 when drawing tips in menus. */
5628 /* Create a frame for the tooltip, and record it in the global
5629 variable tip_frame. */
5630 frame
= x_create_tip_frame (FRAME_W32_DISPLAY_INFO (f
), parms
, string
);
5633 /* Set up the frame's root window. */
5634 w
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5635 w
->left_col
= w
->top_line
= make_number (0);
5637 if (CONSP (Vx_max_tooltip_size
)
5638 && INTEGERP (XCAR (Vx_max_tooltip_size
))
5639 && XINT (XCAR (Vx_max_tooltip_size
)) > 0
5640 && INTEGERP (XCDR (Vx_max_tooltip_size
))
5641 && XINT (XCDR (Vx_max_tooltip_size
)) > 0)
5643 w
->total_cols
= XCAR (Vx_max_tooltip_size
);
5644 w
->total_lines
= XCDR (Vx_max_tooltip_size
);
5648 w
->total_cols
= make_number (80);
5649 w
->total_lines
= make_number (40);
5652 FRAME_TOTAL_COLS (f
) = XINT (w
->total_cols
);
5654 w
->pseudo_window_p
= 1;
5656 /* Display the tooltip text in a temporary buffer. */
5657 old_buffer
= current_buffer
;
5658 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f
))->buffer
));
5659 current_buffer
->truncate_lines
= Qnil
;
5660 clear_glyph_matrix (w
->desired_matrix
);
5661 clear_glyph_matrix (w
->current_matrix
);
5662 SET_TEXT_POS (pos
, BEGV
, BEGV_BYTE
);
5663 try_window (FRAME_ROOT_WINDOW (f
), pos
, TRY_WINDOW_IGNORE_FONTS_CHANGE
);
5665 /* Compute width and height of the tooltip. */
5666 width
= height
= seen_reversed_p
= 0;
5667 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
5669 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
5673 /* Stop at the first empty row at the end. */
5674 if (!row
->enabled_p
|| !row
->displays_text_p
)
5677 /* Let the row go over the full width of the frame. */
5678 row
->full_width_p
= 1;
5680 row_width
= row
->pixel_width
;
5681 if (row
->used
[TEXT_AREA
])
5683 if (!row
->reversed_p
)
5685 /* There's a glyph at the end of rows that is used to
5686 place the cursor there. Don't include the width of
5688 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
5689 if (INTEGERP (last
->object
))
5690 row_width
-= last
->pixel_width
;
5694 /* There could be a stretch glyph at the beginning of R2L
5695 rows that is produced by extend_face_to_end_of_line.
5696 Don't count that glyph. */
5697 struct glyph
*g
= row
->glyphs
[TEXT_AREA
];
5699 if (g
->type
== STRETCH_GLYPH
&& INTEGERP (g
->object
))
5701 row_width
-= g
->pixel_width
;
5702 seen_reversed_p
= 1;
5707 height
+= row
->height
;
5708 width
= max (width
, row_width
);
5711 /* If we've seen partial-length R2L rows, we need to re-adjust the
5712 tool-tip frame width and redisplay it again, to avoid over-wide
5713 tips due to the stretch glyph that extends R2L lines to full
5714 width of the frame. */
5715 if (seen_reversed_p
)
5717 /* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
5719 width
/= WINDOW_FRAME_COLUMN_WIDTH (w
);
5720 w
->total_cols
= make_number (width
);
5721 FRAME_TOTAL_COLS (f
) = width
;
5723 w
->pseudo_window_p
= 1;
5724 clear_glyph_matrix (w
->desired_matrix
);
5725 clear_glyph_matrix (w
->current_matrix
);
5726 try_window (FRAME_ROOT_WINDOW (f
), pos
, TRY_WINDOW_IGNORE_FONTS_CHANGE
);
5728 /* Recompute width and height of the tooltip. */
5729 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
5731 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
5735 if (!row
->enabled_p
|| !row
->displays_text_p
)
5737 row
->full_width_p
= 1;
5738 row_width
= row
->pixel_width
;
5739 if (row
->used
[TEXT_AREA
] && !row
->reversed_p
)
5741 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
5742 if (INTEGERP (last
->object
))
5743 row_width
-= last
->pixel_width
;
5746 height
+= row
->height
;
5747 width
= max (width
, row_width
);
5751 /* Round up the height to an integral multiple of FRAME_LINE_HEIGHT. */
5752 if (height
% FRAME_LINE_HEIGHT (f
) != 0)
5753 height
+= FRAME_LINE_HEIGHT (f
) - height
% FRAME_LINE_HEIGHT (f
);
5754 /* Add the frame's internal border to the width and height the w32
5755 window should have. */
5756 height
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
5757 width
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
5759 /* Move the tooltip window where the mouse pointer is. Resize and
5761 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, &root_x
, &root_y
);
5764 /* Adjust Window size to take border into account. */
5766 rect
.left
= rect
.top
= 0;
5768 rect
.bottom
= height
;
5769 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
5770 FRAME_EXTERNAL_MENU_BAR (f
));
5772 /* Position and size tooltip, and put it in the topmost group.
5773 The add-on of FRAME_COLUMN_WIDTH to the 5th argument is a
5774 peculiarity of w32 display: without it, some fonts cause the
5775 last character of the tip to be truncated or wrapped around to
5777 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOPMOST
,
5779 rect
.right
- rect
.left
+ FRAME_COLUMN_WIDTH (f
),
5780 rect
.bottom
- rect
.top
, SWP_NOACTIVATE
);
5782 /* Ensure tooltip is on top of other topmost windows (eg menus). */
5783 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOP
,
5785 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5787 /* Let redisplay know that we have made the frame visible already. */
5788 f
->async_visible
= 1;
5790 ShowWindow (FRAME_W32_WINDOW (f
), SW_SHOWNOACTIVATE
);
5793 /* Draw into the window. */
5794 w
->must_be_updated_p
= 1;
5795 update_single_window (w
, 1);
5799 /* Restore original current buffer. */
5800 set_buffer_internal_1 (old_buffer
);
5801 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
5804 /* Let the tip disappear after timeout seconds. */
5805 tip_timer
= call3 (intern ("run-at-time"), timeout
, Qnil
,
5806 intern ("x-hide-tip"));
5809 return unbind_to (count
, Qnil
);
5813 DEFUN ("x-hide-tip", Fx_hide_tip
, Sx_hide_tip
, 0, 0, 0,
5814 doc
: /* Hide the current tooltip window, if there is any.
5815 Value is t if tooltip was open, nil otherwise. */)
5819 Lisp_Object deleted
, frame
, timer
;
5820 struct gcpro gcpro1
, gcpro2
;
5822 /* Return quickly if nothing to do. */
5823 if (NILP (tip_timer
) && NILP (tip_frame
))
5828 GCPRO2 (frame
, timer
);
5829 tip_frame
= tip_timer
= deleted
= Qnil
;
5831 count
= SPECPDL_INDEX ();
5832 specbind (Qinhibit_redisplay
, Qt
);
5833 specbind (Qinhibit_quit
, Qt
);
5836 call1 (Qcancel_timer
, timer
);
5840 delete_frame (frame
, Qnil
);
5845 return unbind_to (count
, deleted
);
5850 /***********************************************************************
5851 File selection dialog
5852 ***********************************************************************/
5853 extern Lisp_Object Qfile_name_history
;
5855 /* Callback for altering the behavior of the Open File dialog.
5856 Makes the Filename text field contain "Current Directory" and be
5857 read-only when "Directories" is selected in the filter. This
5858 allows us to work around the fact that the standard Open File
5859 dialog does not support directories. */
5860 static UINT CALLBACK
5861 file_dialog_callback (HWND hwnd
, UINT msg
, WPARAM wParam
, LPARAM lParam
)
5863 if (msg
== WM_NOTIFY
)
5865 OFNOTIFY
* notify
= (OFNOTIFY
*)lParam
;
5866 /* Detect when the Filter dropdown is changed. */
5867 if (notify
->hdr
.code
== CDN_TYPECHANGE
5868 || notify
->hdr
.code
== CDN_INITDONE
)
5870 HWND dialog
= GetParent (hwnd
);
5871 HWND edit_control
= GetDlgItem (dialog
, FILE_NAME_TEXT_FIELD
);
5873 /* Directories is in index 2. */
5874 if (notify
->lpOFN
->nFilterIndex
== 2)
5876 CommDlg_OpenSave_SetControlText (dialog
, FILE_NAME_TEXT_FIELD
,
5877 "Current Directory");
5878 EnableWindow (edit_control
, FALSE
);
5882 /* Don't override default filename on init done. */
5883 if (notify
->hdr
.code
== CDN_TYPECHANGE
)
5884 CommDlg_OpenSave_SetControlText (dialog
,
5885 FILE_NAME_TEXT_FIELD
, "");
5886 EnableWindow (edit_control
, TRUE
);
5893 /* Since we compile with _WIN32_WINNT set to 0x0400 (for NT4 compatibility)
5894 we end up with the old file dialogs. Define a big enough struct for the
5895 new dialog to trick GetOpenFileName into giving us the new dialogs on
5896 Windows 2000 and XP. */
5899 OPENFILENAME real_details
;
5906 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 5, 0,
5907 doc
: /* Read file name, prompting with PROMPT in directory DIR.
5908 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5909 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5910 or directory must exist.
5912 This function is only defined on MS Windows, and X Windows with the
5913 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
5914 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories. */)
5915 (Lisp_Object prompt
, Lisp_Object dir
, Lisp_Object default_filename
, Lisp_Object mustmatch
, Lisp_Object only_dir_p
)
5917 struct frame
*f
= SELECTED_FRAME ();
5918 Lisp_Object file
= Qnil
;
5919 int count
= SPECPDL_INDEX ();
5920 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
5921 char filename
[MAX_PATH
+ 1];
5922 char init_dir
[MAX_PATH
+ 1];
5923 int default_filter_index
= 1; /* 1: All Files, 2: Directories only */
5925 GCPRO6 (prompt
, dir
, default_filename
, mustmatch
, only_dir_p
, file
);
5926 CHECK_STRING (prompt
);
5929 /* Create the dialog with PROMPT as title, using DIR as initial
5930 directory and using "*" as pattern. */
5931 dir
= Fexpand_file_name (dir
, Qnil
);
5932 strncpy (init_dir
, SDATA (ENCODE_FILE (dir
)), MAX_PATH
);
5933 init_dir
[MAX_PATH
] = '\0';
5934 unixtodos_filename (init_dir
);
5936 if (STRINGP (default_filename
))
5938 char *file_name_only
;
5939 char *full_path_name
= SDATA (ENCODE_FILE (default_filename
));
5941 unixtodos_filename (full_path_name
);
5943 file_name_only
= strrchr (full_path_name
, '\\');
5944 if (!file_name_only
)
5945 file_name_only
= full_path_name
;
5949 strncpy (filename
, file_name_only
, MAX_PATH
);
5950 filename
[MAX_PATH
] = '\0';
5956 NEWOPENFILENAME new_file_details
;
5957 BOOL file_opened
= FALSE
;
5958 OPENFILENAME
* file_details
= &new_file_details
.real_details
;
5960 /* Prevent redisplay. */
5961 specbind (Qinhibit_redisplay
, Qt
);
5964 memset (&new_file_details
, 0, sizeof (new_file_details
));
5965 /* Apparently NT4 crashes if you give it an unexpected size.
5966 I'm not sure about Windows 9x, so play it safe. */
5967 if (w32_major_version
> 4 && w32_major_version
< 95)
5968 file_details
->lStructSize
= sizeof (NEWOPENFILENAME
);
5970 file_details
->lStructSize
= sizeof (OPENFILENAME
);
5972 file_details
->hwndOwner
= FRAME_W32_WINDOW (f
);
5973 /* Undocumented Bug in Common File Dialog:
5974 If a filter is not specified, shell links are not resolved. */
5975 file_details
->lpstrFilter
= "All Files (*.*)\0*.*\0Directories\0*|*\0\0";
5976 file_details
->lpstrFile
= filename
;
5977 file_details
->nMaxFile
= sizeof (filename
);
5978 file_details
->lpstrInitialDir
= init_dir
;
5979 file_details
->lpstrTitle
= SDATA (prompt
);
5981 if (! NILP (only_dir_p
))
5982 default_filter_index
= 2;
5984 file_details
->nFilterIndex
= default_filter_index
;
5986 file_details
->Flags
= (OFN_HIDEREADONLY
| OFN_NOCHANGEDIR
5987 | OFN_EXPLORER
| OFN_ENABLEHOOK
);
5988 if (!NILP (mustmatch
))
5990 /* Require that the path to the parent directory exists. */
5991 file_details
->Flags
|= OFN_PATHMUSTEXIST
;
5992 /* If we are looking for a file, require that it exists. */
5993 if (NILP (only_dir_p
))
5994 file_details
->Flags
|= OFN_FILEMUSTEXIST
;
5997 file_details
->lpfnHook
= (LPOFNHOOKPROC
) file_dialog_callback
;
5999 file_opened
= GetOpenFileName (file_details
);
6005 dostounix_filename (filename
);
6007 if (file_details
->nFilterIndex
== 2)
6009 /* "Directories" selected - strip dummy file name. */
6010 char * last
= strrchr (filename
, '/');
6014 file
= DECODE_FILE (build_string (filename
));
6016 /* User cancelled the dialog without making a selection. */
6017 else if (!CommDlgExtendedError ())
6019 /* An error occurred, fallback on reading from the mini-buffer. */
6021 file
= Fcompleting_read (prompt
, intern ("read-file-name-internal"),
6022 dir
, mustmatch
, dir
, Qfile_name_history
,
6023 default_filename
, Qnil
);
6025 file
= unbind_to (count
, file
);
6030 /* Make "Cancel" equivalent to C-g. */
6032 Fsignal (Qquit
, Qnil
);
6034 return unbind_to (count
, file
);
6038 /* Moving files to the system recycle bin.
6039 Used by `move-file-to-trash' instead of the default moving to ~/.Trash */
6040 DEFUN ("system-move-file-to-trash", Fsystem_move_file_to_trash
,
6041 Ssystem_move_file_to_trash
, 1, 1, 0,
6042 doc
: /* Move file or directory named FILENAME to the recycle bin. */)
6043 (Lisp_Object filename
)
6045 Lisp_Object handler
;
6046 Lisp_Object encoded_file
;
6047 Lisp_Object operation
;
6049 operation
= Qdelete_file
;
6050 if (!NILP (Ffile_directory_p (filename
))
6051 && NILP (Ffile_symlink_p (filename
)))
6053 operation
= intern ("delete-directory");
6054 filename
= Fdirectory_file_name (filename
);
6056 filename
= Fexpand_file_name (filename
, Qnil
);
6058 handler
= Ffind_file_name_handler (filename
, operation
);
6059 if (!NILP (handler
))
6060 return call2 (handler
, operation
, filename
);
6062 encoded_file
= ENCODE_FILE (filename
);
6066 SHFILEOPSTRUCT file_op
;
6067 char tmp_path
[MAX_PATH
+ 1];
6069 path
= map_w32_filename (SDATA (encoded_file
), NULL
);
6071 /* On Windows, write permission is required to delete/move files. */
6072 _chmod (path
, 0666);
6074 memset (tmp_path
, 0, sizeof (tmp_path
));
6075 strcpy (tmp_path
, path
);
6077 memset (&file_op
, 0, sizeof (file_op
));
6078 file_op
.hwnd
= HWND_DESKTOP
;
6079 file_op
.wFunc
= FO_DELETE
;
6080 file_op
.pFrom
= tmp_path
;
6081 file_op
.fFlags
= FOF_SILENT
| FOF_NOCONFIRMATION
| FOF_ALLOWUNDO
6082 | FOF_NOERRORUI
| FOF_NO_CONNECTED_ELEMENTS
;
6083 file_op
.fAnyOperationsAborted
= FALSE
;
6085 if (SHFileOperation (&file_op
) != 0)
6086 report_file_error ("Removing old name", list1 (filename
));
6092 /***********************************************************************
6093 w32 specialized functions
6094 ***********************************************************************/
6096 DEFUN ("w32-send-sys-command", Fw32_send_sys_command
,
6097 Sw32_send_sys_command
, 1, 2, 0,
6098 doc
: /* Send frame a Windows WM_SYSCOMMAND message of type COMMAND.
6099 Some useful values for COMMAND are #xf030 to maximize frame (#xf020
6100 to minimize), #xf120 to restore frame to original size, and #xf100
6101 to activate the menubar for keyboard access. #xf140 activates the
6102 screen saver if defined.
6104 If optional parameter FRAME is not specified, use selected frame. */)
6105 (Lisp_Object command
, Lisp_Object frame
)
6107 FRAME_PTR f
= check_x_frame (frame
);
6109 CHECK_NUMBER (command
);
6111 PostMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, XINT (command
), 0);
6116 DEFUN ("w32-shell-execute", Fw32_shell_execute
, Sw32_shell_execute
, 2, 4, 0,
6117 doc
: /* Get Windows to perform OPERATION on DOCUMENT.
6118 This is a wrapper around the ShellExecute system function, which
6119 invokes the application registered to handle OPERATION for DOCUMENT.
6121 OPERATION is either nil or a string that names a supported operation.
6122 What operations can be used depends on the particular DOCUMENT and its
6123 handler application, but typically it is one of the following common
6126 \"open\" - open DOCUMENT, which could be a file, a directory, or an
6127 executable program. If it is an application, that
6128 application is launched in the current buffer's default
6129 directory. Otherwise, the application associated with
6130 DOCUMENT is launched in the buffer's default directory.
6131 \"print\" - print DOCUMENT, which must be a file
6132 \"explore\" - start the Windows Explorer on DOCUMENT
6133 \"edit\" - launch an editor and open DOCUMENT for editing; which
6134 editor is launched depends on the association for the
6136 \"find\" - initiate search starting from DOCUMENT which must specify
6138 nil - invoke the default OPERATION, or \"open\" if default is
6139 not defined or unavailable
6141 DOCUMENT is typically the name of a document file or a URL, but can
6142 also be a program executable to run, or a directory to open in the
6145 If DOCUMENT is a program executable, the optional third arg PARAMETERS
6146 can be a string containing command line parameters that will be passed
6147 to the program; otherwise, PARAMETERS should be nil or unspecified.
6149 Optional fourth argument SHOW-FLAG can be used to control how the
6150 application will be displayed when it is invoked. If SHOW-FLAG is nil
6151 or unspecified, the application is displayed normally, otherwise it is
6152 an integer representing a ShowWindow flag:
6157 6 - start minimized */)
6158 (Lisp_Object operation
, Lisp_Object document
, Lisp_Object parameters
, Lisp_Object show_flag
)
6160 Lisp_Object current_dir
;
6163 CHECK_STRING (document
);
6165 /* Encode filename, current directory and parameters. */
6166 current_dir
= ENCODE_FILE (current_buffer
->directory
);
6167 document
= ENCODE_FILE (document
);
6168 if (STRINGP (parameters
))
6169 parameters
= ENCODE_SYSTEM (parameters
);
6171 if ((int) ShellExecute (NULL
,
6172 (STRINGP (operation
) ?
6173 SDATA (operation
) : NULL
),
6175 (STRINGP (parameters
) ?
6176 SDATA (parameters
) : NULL
),
6177 SDATA (current_dir
),
6178 (INTEGERP (show_flag
) ?
6179 XINT (show_flag
) : SW_SHOWDEFAULT
))
6182 errstr
= w32_strerror (0);
6183 /* The error string might be encoded in the locale's encoding. */
6184 if (!NILP (Vlocale_coding_system
))
6186 Lisp_Object decoded
=
6187 code_convert_string_norecord (make_unibyte_string (errstr
,
6189 Vlocale_coding_system
, 0);
6190 errstr
= SSDATA (decoded
);
6192 error ("ShellExecute failed: %s", errstr
);
6195 /* Lookup virtual keycode from string representing the name of a
6196 non-ascii keystroke into the corresponding virtual key, using
6197 lispy_function_keys. */
6199 lookup_vk_code (char *key
)
6203 for (i
= 0; i
< 256; i
++)
6204 if (lispy_function_keys
[i
]
6205 && strcmp (lispy_function_keys
[i
], key
) == 0)
6211 /* Convert a one-element vector style key sequence to a hot key
6214 w32_parse_hot_key (Lisp_Object key
)
6216 /* Copied from Fdefine_key and store_in_keymap. */
6217 register Lisp_Object c
;
6221 struct gcpro gcpro1
;
6225 if (XFASTINT (Flength (key
)) != 1)
6230 c
= Faref (key
, make_number (0));
6232 if (CONSP (c
) && lucid_event_type_list_p (c
))
6233 c
= Fevent_convert_list (c
);
6237 if (! INTEGERP (c
) && ! SYMBOLP (c
))
6238 error ("Key definition is invalid");
6240 /* Work out the base key and the modifiers. */
6243 c
= parse_modifiers (c
);
6244 lisp_modifiers
= XINT (Fcar (Fcdr (c
)));
6248 vk_code
= lookup_vk_code (SDATA (SYMBOL_NAME (c
)));
6250 else if (INTEGERP (c
))
6252 lisp_modifiers
= XINT (c
) & ~CHARACTERBITS
;
6253 /* Many ascii characters are their own virtual key code. */
6254 vk_code
= XINT (c
) & CHARACTERBITS
;
6257 if (vk_code
< 0 || vk_code
> 255)
6260 if ((lisp_modifiers
& meta_modifier
) != 0
6261 && !NILP (Vw32_alt_is_meta
))
6262 lisp_modifiers
|= alt_modifier
;
6264 /* Supply defs missing from mingw32. */
6266 #define MOD_ALT 0x0001
6267 #define MOD_CONTROL 0x0002
6268 #define MOD_SHIFT 0x0004
6269 #define MOD_WIN 0x0008
6272 /* Convert lisp modifiers to Windows hot-key form. */
6273 w32_modifiers
= (lisp_modifiers
& hyper_modifier
) ? MOD_WIN
: 0;
6274 w32_modifiers
|= (lisp_modifiers
& alt_modifier
) ? MOD_ALT
: 0;
6275 w32_modifiers
|= (lisp_modifiers
& ctrl_modifier
) ? MOD_CONTROL
: 0;
6276 w32_modifiers
|= (lisp_modifiers
& shift_modifier
) ? MOD_SHIFT
: 0;
6278 return HOTKEY (vk_code
, w32_modifiers
);
6281 DEFUN ("w32-register-hot-key", Fw32_register_hot_key
,
6282 Sw32_register_hot_key
, 1, 1, 0,
6283 doc
: /* Register KEY as a hot-key combination.
6284 Certain key combinations like Alt-Tab are reserved for system use on
6285 Windows, and therefore are normally intercepted by the system. However,
6286 most of these key combinations can be received by registering them as
6287 hot-keys, overriding their special meaning.
6289 KEY must be a one element key definition in vector form that would be
6290 acceptable to `define-key' (e.g. [A-tab] for Alt-Tab). The meta
6291 modifier is interpreted as Alt if `w32-alt-is-meta' is t, and hyper
6292 is always interpreted as the Windows modifier keys.
6294 The return value is the hotkey-id if registered, otherwise nil. */)
6297 key
= w32_parse_hot_key (key
);
6299 if (!NILP (key
) && NILP (Fmemq (key
, w32_grabbed_keys
)))
6301 /* Reuse an empty slot if possible. */
6302 Lisp_Object item
= Fmemq (Qnil
, w32_grabbed_keys
);
6304 /* Safe to add new key to list, even if we have focus. */
6306 w32_grabbed_keys
= Fcons (key
, w32_grabbed_keys
);
6308 XSETCAR (item
, key
);
6310 /* Notify input thread about new hot-key definition, so that it
6311 takes effect without needing to switch focus. */
6312 #ifdef USE_LISP_UNION_TYPE
6313 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_REGISTER_HOT_KEY
,
6316 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_REGISTER_HOT_KEY
,
6324 DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key
,
6325 Sw32_unregister_hot_key
, 1, 1, 0,
6326 doc
: /* Unregister KEY as a hot-key combination. */)
6331 if (!INTEGERP (key
))
6332 key
= w32_parse_hot_key (key
);
6334 item
= Fmemq (key
, w32_grabbed_keys
);
6338 /* Notify input thread about hot-key definition being removed, so
6339 that it takes effect without needing focus switch. */
6340 #ifdef USE_LISP_UNION_TYPE
6341 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_UNREGISTER_HOT_KEY
,
6342 (WPARAM
) XINT (XCAR (item
)), (LPARAM
) item
.i
))
6344 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_UNREGISTER_HOT_KEY
,
6345 (WPARAM
) XINT (XCAR (item
)), (LPARAM
) item
))
6349 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6356 DEFUN ("w32-registered-hot-keys", Fw32_registered_hot_keys
,
6357 Sw32_registered_hot_keys
, 0, 0, 0,
6358 doc
: /* Return list of registered hot-key IDs. */)
6361 return Fdelq (Qnil
, Fcopy_sequence (w32_grabbed_keys
));
6364 DEFUN ("w32-reconstruct-hot-key", Fw32_reconstruct_hot_key
,
6365 Sw32_reconstruct_hot_key
, 1, 1, 0,
6366 doc
: /* Convert hot-key ID to a lisp key combination.
6367 usage: (w32-reconstruct-hot-key ID) */)
6368 (Lisp_Object hotkeyid
)
6370 int vk_code
, w32_modifiers
;
6373 CHECK_NUMBER (hotkeyid
);
6375 vk_code
= HOTKEY_VK_CODE (hotkeyid
);
6376 w32_modifiers
= HOTKEY_MODIFIERS (hotkeyid
);
6378 if (vk_code
< 256 && lispy_function_keys
[vk_code
])
6379 key
= intern (lispy_function_keys
[vk_code
]);
6381 key
= make_number (vk_code
);
6383 key
= Fcons (key
, Qnil
);
6384 if (w32_modifiers
& MOD_SHIFT
)
6385 key
= Fcons (Qshift
, key
);
6386 if (w32_modifiers
& MOD_CONTROL
)
6387 key
= Fcons (Qctrl
, key
);
6388 if (w32_modifiers
& MOD_ALT
)
6389 key
= Fcons (NILP (Vw32_alt_is_meta
) ? Qalt
: Qmeta
, key
);
6390 if (w32_modifiers
& MOD_WIN
)
6391 key
= Fcons (Qhyper
, key
);
6396 DEFUN ("w32-toggle-lock-key", Fw32_toggle_lock_key
,
6397 Sw32_toggle_lock_key
, 1, 2, 0,
6398 doc
: /* Toggle the state of the lock key KEY.
6399 KEY can be `capslock', `kp-numlock', or `scroll'.
6400 If the optional parameter NEW-STATE is a number, then the state of KEY
6401 is set to off if the low bit of NEW-STATE is zero, otherwise on. */)
6402 (Lisp_Object key
, Lisp_Object new_state
)
6406 if (EQ (key
, intern ("capslock")))
6407 vk_code
= VK_CAPITAL
;
6408 else if (EQ (key
, intern ("kp-numlock")))
6409 vk_code
= VK_NUMLOCK
;
6410 else if (EQ (key
, intern ("scroll")))
6411 vk_code
= VK_SCROLL
;
6415 if (!dwWindowsThreadId
)
6416 return make_number (w32_console_toggle_lock_key (vk_code
, new_state
));
6418 #ifdef USE_LISP_UNION_TYPE
6419 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_TOGGLE_LOCK_KEY
,
6420 (WPARAM
) vk_code
, (LPARAM
) new_state
.i
))
6422 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_TOGGLE_LOCK_KEY
,
6423 (WPARAM
) vk_code
, (LPARAM
) new_state
))
6427 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6428 return make_number (msg
.wParam
);
6433 DEFUN ("w32-window-exists-p", Fw32_window_exists_p
, Sw32_window_exists_p
,
6435 doc
: /* Return non-nil if a window exists with the specified CLASS and NAME.
6437 This is a direct interface to the Windows API FindWindow function. */)
6438 (Lisp_Object
class, Lisp_Object name
)
6443 CHECK_STRING (class);
6445 CHECK_STRING (name
);
6447 hnd
= FindWindow (STRINGP (class) ? ((LPCTSTR
) SDATA (class)) : NULL
,
6448 STRINGP (name
) ? ((LPCTSTR
) SDATA (name
)) : NULL
);
6454 DEFUN ("w32-battery-status", Fw32_battery_status
, Sw32_battery_status
, 0, 0, 0,
6455 doc
: /* Get power status information from Windows system.
6457 The following %-sequences are provided:
6458 %L AC line status (verbose)
6459 %B Battery status (verbose)
6460 %b Battery status, empty means high, `-' means low,
6461 `!' means critical, and `+' means charging
6462 %p Battery load percentage
6463 %s Remaining time (to charge or discharge) in seconds
6464 %m Remaining time (to charge or discharge) in minutes
6465 %h Remaining time (to charge or discharge) in hours
6466 %t Remaining time (to charge or discharge) in the form `h:min' */)
6469 Lisp_Object status
= Qnil
;
6471 SYSTEM_POWER_STATUS system_status
;
6472 if (GetSystemPowerStatus (&system_status
))
6474 Lisp_Object line_status
, battery_status
, battery_status_symbol
;
6475 Lisp_Object load_percentage
, seconds
, minutes
, hours
, remain
;
6476 Lisp_Object sequences
[8];
6478 long seconds_left
= (long) system_status
.BatteryLifeTime
;
6480 if (system_status
.ACLineStatus
== 0)
6481 line_status
= build_string ("off-line");
6482 else if (system_status
.ACLineStatus
== 1)
6483 line_status
= build_string ("on-line");
6485 line_status
= build_string ("N/A");
6487 if (system_status
.BatteryFlag
& 128)
6489 battery_status
= build_string ("N/A");
6490 battery_status_symbol
= empty_unibyte_string
;
6492 else if (system_status
.BatteryFlag
& 8)
6494 battery_status
= build_string ("charging");
6495 battery_status_symbol
= build_string ("+");
6496 if (system_status
.BatteryFullLifeTime
!= -1L)
6497 seconds_left
= system_status
.BatteryFullLifeTime
- seconds_left
;
6499 else if (system_status
.BatteryFlag
& 4)
6501 battery_status
= build_string ("critical");
6502 battery_status_symbol
= build_string ("!");
6504 else if (system_status
.BatteryFlag
& 2)
6506 battery_status
= build_string ("low");
6507 battery_status_symbol
= build_string ("-");
6509 else if (system_status
.BatteryFlag
& 1)
6511 battery_status
= build_string ("high");
6512 battery_status_symbol
= empty_unibyte_string
;
6516 battery_status
= build_string ("medium");
6517 battery_status_symbol
= empty_unibyte_string
;
6520 if (system_status
.BatteryLifePercent
> 100)
6521 load_percentage
= build_string ("N/A");
6525 _snprintf (buffer
, 16, "%d", system_status
.BatteryLifePercent
);
6526 load_percentage
= build_string (buffer
);
6529 if (seconds_left
< 0)
6530 seconds
= minutes
= hours
= remain
= build_string ("N/A");
6536 _snprintf (buffer
, 16, "%ld", seconds_left
);
6537 seconds
= build_string (buffer
);
6539 m
= seconds_left
/ 60;
6540 _snprintf (buffer
, 16, "%ld", m
);
6541 minutes
= build_string (buffer
);
6543 h
= seconds_left
/ 3600.0;
6544 _snprintf (buffer
, 16, "%3.1f", h
);
6545 hours
= build_string (buffer
);
6547 _snprintf (buffer
, 16, "%ld:%02ld", m
/ 60, m
% 60);
6548 remain
= build_string (buffer
);
6550 sequences
[0] = Fcons (make_number ('L'), line_status
);
6551 sequences
[1] = Fcons (make_number ('B'), battery_status
);
6552 sequences
[2] = Fcons (make_number ('b'), battery_status_symbol
);
6553 sequences
[3] = Fcons (make_number ('p'), load_percentage
);
6554 sequences
[4] = Fcons (make_number ('s'), seconds
);
6555 sequences
[5] = Fcons (make_number ('m'), minutes
);
6556 sequences
[6] = Fcons (make_number ('h'), hours
);
6557 sequences
[7] = Fcons (make_number ('t'), remain
);
6559 status
= Flist (8, sequences
);
6565 DEFUN ("file-system-info", Ffile_system_info
, Sfile_system_info
, 1, 1, 0,
6566 doc
: /* Return storage information about the file system FILENAME is on.
6567 Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total
6568 storage of the file system, FREE is the free storage, and AVAIL is the
6569 storage available to a non-superuser. All 3 numbers are in bytes.
6570 If the underlying system call fails, value is nil. */)
6571 (Lisp_Object filename
)
6573 Lisp_Object encoded
, value
;
6575 CHECK_STRING (filename
);
6576 filename
= Fexpand_file_name (filename
, Qnil
);
6577 encoded
= ENCODE_FILE (filename
);
6581 /* Determining the required information on Windows turns out, sadly,
6582 to be more involved than one would hope. The original Win32 api
6583 call for this will return bogus information on some systems, but we
6584 must dynamically probe for the replacement api, since that was
6585 added rather late on. */
6587 HMODULE hKernel
= GetModuleHandle ("kernel32");
6588 BOOL (*pfn_GetDiskFreeSpaceEx
)
6589 (char *, PULARGE_INTEGER
, PULARGE_INTEGER
, PULARGE_INTEGER
)
6590 = (void *) GetProcAddress (hKernel
, "GetDiskFreeSpaceEx");
6592 /* On Windows, we may need to specify the root directory of the
6593 volume holding FILENAME. */
6594 char rootname
[MAX_PATH
];
6595 char *name
= SDATA (encoded
);
6597 /* find the root name of the volume if given */
6598 if (isalpha (name
[0]) && name
[1] == ':')
6600 rootname
[0] = name
[0];
6601 rootname
[1] = name
[1];
6605 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
6607 char *str
= rootname
;
6611 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
6621 if (pfn_GetDiskFreeSpaceEx
)
6623 /* Unsigned large integers cannot be cast to double, so
6624 use signed ones instead. */
6625 LARGE_INTEGER availbytes
;
6626 LARGE_INTEGER freebytes
;
6627 LARGE_INTEGER totalbytes
;
6629 if (pfn_GetDiskFreeSpaceEx (rootname
,
6630 (ULARGE_INTEGER
*)&availbytes
,
6631 (ULARGE_INTEGER
*)&totalbytes
,
6632 (ULARGE_INTEGER
*)&freebytes
))
6633 value
= list3 (make_float ((double) totalbytes
.QuadPart
),
6634 make_float ((double) freebytes
.QuadPart
),
6635 make_float ((double) availbytes
.QuadPart
));
6639 DWORD sectors_per_cluster
;
6640 DWORD bytes_per_sector
;
6641 DWORD free_clusters
;
6642 DWORD total_clusters
;
6644 if (GetDiskFreeSpace (rootname
,
6645 §ors_per_cluster
,
6649 value
= list3 (make_float ((double) total_clusters
6650 * sectors_per_cluster
* bytes_per_sector
),
6651 make_float ((double) free_clusters
6652 * sectors_per_cluster
* bytes_per_sector
),
6653 make_float ((double) free_clusters
6654 * sectors_per_cluster
* bytes_per_sector
));
6661 DEFUN ("default-printer-name", Fdefault_printer_name
, Sdefault_printer_name
,
6662 0, 0, 0, doc
: /* Return the name of Windows default printer device. */)
6665 static char pname_buf
[256];
6668 PRINTER_INFO_2
*ppi2
= NULL
;
6669 DWORD dwNeeded
= 0, dwReturned
= 0;
6671 /* Retrieve the default string from Win.ini (the registry).
6672 * String will be in form "printername,drivername,portname".
6673 * This is the most portable way to get the default printer. */
6674 if (GetProfileString ("windows", "device", ",,", pname_buf
, sizeof (pname_buf
)) <= 0)
6676 /* printername precedes first "," character */
6677 strtok (pname_buf
, ",");
6678 /* We want to know more than the printer name */
6679 if (!OpenPrinter (pname_buf
, &hPrn
, NULL
))
6681 GetPrinter (hPrn
, 2, NULL
, 0, &dwNeeded
);
6684 ClosePrinter (hPrn
);
6687 /* Allocate memory for the PRINTER_INFO_2 struct */
6688 ppi2
= (PRINTER_INFO_2
*) xmalloc (dwNeeded
);
6691 ClosePrinter (hPrn
);
6694 /* Call GetPrinter again with big enouth memory block */
6695 err
= GetPrinter (hPrn
, 2, (LPBYTE
)ppi2
, dwNeeded
, &dwReturned
);
6696 ClosePrinter (hPrn
);
6705 if (ppi2
->Attributes
& PRINTER_ATTRIBUTE_SHARED
&& ppi2
->pServerName
)
6707 /* a remote printer */
6708 if (*ppi2
->pServerName
== '\\')
6709 _snprintf (pname_buf
, sizeof (pname_buf
), "%s\\%s", ppi2
->pServerName
,
6712 _snprintf (pname_buf
, sizeof (pname_buf
), "\\\\%s\\%s", ppi2
->pServerName
,
6714 pname_buf
[sizeof (pname_buf
) - 1] = '\0';
6718 /* a local printer */
6719 strncpy (pname_buf
, ppi2
->pPortName
, sizeof (pname_buf
));
6720 pname_buf
[sizeof (pname_buf
) - 1] = '\0';
6721 /* `pPortName' can include several ports, delimited by ','.
6722 * we only use the first one. */
6723 strtok (pname_buf
, ",");
6728 return build_string (pname_buf
);
6731 /***********************************************************************
6733 ***********************************************************************/
6735 /* Keep this list in the same order as frame_parms in frame.c.
6736 Use 0 for unsupported frame parameters. */
6738 frame_parm_handler w32_frame_parm_handlers
[] =
6742 x_set_background_color
,
6748 x_set_foreground_color
,
6751 x_set_internal_border_width
,
6752 x_set_menu_bar_lines
,
6754 x_explicitly_set_name
,
6755 x_set_scroll_bar_width
,
6758 x_set_vertical_scroll_bars
,
6760 x_set_tool_bar_lines
,
6761 0, /* x_set_scroll_bar_foreground, */
6762 0, /* x_set_scroll_bar_background, */
6767 0, /* x_set_wait_for_wm, */
6771 0, /* x_set_sticky */
6772 0, /* x_set_tool_bar_position */
6776 syms_of_w32fns (void)
6778 globals_of_w32fns ();
6779 /* This is zero if not using MS-Windows. */
6781 track_mouse_window
= NULL
;
6783 w32_visible_system_caret_hwnd
= NULL
;
6785 DEFSYM (Qnone
, "none");
6786 DEFSYM (Qsuppress_icon
, "suppress-icon");
6787 DEFSYM (Qundefined_color
, "undefined-color");
6788 DEFSYM (Qcancel_timer
, "cancel-timer");
6789 DEFSYM (Qhyper
, "hyper");
6790 DEFSYM (Qsuper
, "super");
6791 DEFSYM (Qmeta
, "meta");
6792 DEFSYM (Qalt
, "alt");
6793 DEFSYM (Qctrl
, "ctrl");
6794 DEFSYM (Qcontrol
, "control");
6795 DEFSYM (Qshift
, "shift");
6796 DEFSYM (Qfont_param
, "font-parameter");
6797 /* This is the end of symbol initialization. */
6799 /* Text property `display' should be nonsticky by default. */
6800 Vtext_property_default_nonsticky
6801 = Fcons (Fcons (Qdisplay
, Qt
), Vtext_property_default_nonsticky
);
6804 Fput (Qundefined_color
, Qerror_conditions
,
6805 pure_cons (Qundefined_color
, pure_cons (Qerror
, Qnil
)));
6806 Fput (Qundefined_color
, Qerror_message
,
6807 make_pure_c_string ("Undefined color"));
6809 staticpro (&w32_grabbed_keys
);
6810 w32_grabbed_keys
= Qnil
;
6812 DEFVAR_LISP ("w32-color-map", Vw32_color_map
,
6813 doc
: /* An array of color name mappings for Windows. */);
6814 Vw32_color_map
= Qnil
;
6816 DEFVAR_LISP ("w32-pass-alt-to-system", Vw32_pass_alt_to_system
,
6817 doc
: /* Non-nil if Alt key presses are passed on to Windows.
6818 When non-nil, for example, Alt pressed and released and then space will
6819 open the System menu. When nil, Emacs processes the Alt key events, and
6820 then silently swallows them. */);
6821 Vw32_pass_alt_to_system
= Qnil
;
6823 DEFVAR_LISP ("w32-alt-is-meta", Vw32_alt_is_meta
,
6824 doc
: /* Non-nil if the Alt key is to be considered the same as the META key.
6825 When nil, Emacs will translate the Alt key to the ALT modifier, not to META. */);
6826 Vw32_alt_is_meta
= Qt
;
6828 DEFVAR_INT ("w32-quit-key", w32_quit_key
,
6829 doc
: /* If non-zero, the virtual key code for an alternative quit key. */);
6832 DEFVAR_LISP ("w32-pass-lwindow-to-system",
6833 Vw32_pass_lwindow_to_system
,
6834 doc
: /* If non-nil, the left \"Windows\" key is passed on to Windows.
6836 When non-nil, the Start menu is opened by tapping the key.
6837 If you set this to nil, the left \"Windows\" key is processed by Emacs
6838 according to the value of `w32-lwindow-modifier', which see.
6840 Note that some combinations of the left \"Windows\" key with other keys are
6841 caught by Windows at low level, and so binding them in Emacs will have no
6842 effect. For example, <lwindow>-r always pops up the Windows Run dialog,
6843 <lwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
6844 the doc string of `w32-phantom-key-code'. */);
6845 Vw32_pass_lwindow_to_system
= Qt
;
6847 DEFVAR_LISP ("w32-pass-rwindow-to-system",
6848 Vw32_pass_rwindow_to_system
,
6849 doc
: /* If non-nil, the right \"Windows\" key is passed on to Windows.
6851 When non-nil, the Start menu is opened by tapping the key.
6852 If you set this to nil, the right \"Windows\" key is processed by Emacs
6853 according to the value of `w32-rwindow-modifier', which see.
6855 Note that some combinations of the right \"Windows\" key with other keys are
6856 caught by Windows at low level, and so binding them in Emacs will have no
6857 effect. For example, <rwindow>-r always pops up the Windows Run dialog,
6858 <rwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
6859 the doc string of `w32-phantom-key-code'. */);
6860 Vw32_pass_rwindow_to_system
= Qt
;
6862 DEFVAR_LISP ("w32-phantom-key-code",
6863 Vw32_phantom_key_code
,
6864 doc
: /* Virtual key code used to generate \"phantom\" key presses.
6865 Value is a number between 0 and 255.
6867 Phantom key presses are generated in order to stop the system from
6868 acting on \"Windows\" key events when `w32-pass-lwindow-to-system' or
6869 `w32-pass-rwindow-to-system' is nil. */);
6870 /* Although 255 is technically not a valid key code, it works and
6871 means that this hack won't interfere with any real key code. */
6872 XSETINT (Vw32_phantom_key_code
, 255);
6874 DEFVAR_LISP ("w32-enable-num-lock",
6875 Vw32_enable_num_lock
,
6876 doc
: /* If non-nil, the Num Lock key acts normally.
6877 Set to nil to handle Num Lock as the `kp-numlock' key. */);
6878 Vw32_enable_num_lock
= Qt
;
6880 DEFVAR_LISP ("w32-enable-caps-lock",
6881 Vw32_enable_caps_lock
,
6882 doc
: /* If non-nil, the Caps Lock key acts normally.
6883 Set to nil to handle Caps Lock as the `capslock' key. */);
6884 Vw32_enable_caps_lock
= Qt
;
6886 DEFVAR_LISP ("w32-scroll-lock-modifier",
6887 Vw32_scroll_lock_modifier
,
6888 doc
: /* Modifier to use for the Scroll Lock ON state.
6889 The value can be hyper, super, meta, alt, control or shift for the
6890 respective modifier, or nil to handle Scroll Lock as the `scroll' key.
6891 Any other value will cause the Scroll Lock key to be ignored. */);
6892 Vw32_scroll_lock_modifier
= Qnil
;
6894 DEFVAR_LISP ("w32-lwindow-modifier",
6895 Vw32_lwindow_modifier
,
6896 doc
: /* Modifier to use for the left \"Windows\" key.
6897 The value can be hyper, super, meta, alt, control or shift for the
6898 respective modifier, or nil to appear as the `lwindow' key.
6899 Any other value will cause the key to be ignored. */);
6900 Vw32_lwindow_modifier
= Qnil
;
6902 DEFVAR_LISP ("w32-rwindow-modifier",
6903 Vw32_rwindow_modifier
,
6904 doc
: /* Modifier to use for the right \"Windows\" key.
6905 The value can be hyper, super, meta, alt, control or shift for the
6906 respective modifier, or nil to appear as the `rwindow' key.
6907 Any other value will cause the key to be ignored. */);
6908 Vw32_rwindow_modifier
= Qnil
;
6910 DEFVAR_LISP ("w32-apps-modifier",
6912 doc
: /* Modifier to use for the \"Apps\" key.
6913 The value can be hyper, super, meta, alt, control or shift for the
6914 respective modifier, or nil to appear as the `apps' key.
6915 Any other value will cause the key to be ignored. */);
6916 Vw32_apps_modifier
= Qnil
;
6918 DEFVAR_BOOL ("w32-enable-synthesized-fonts", w32_enable_synthesized_fonts
,
6919 doc
: /* Non-nil enables selection of artificially italicized and bold fonts. */);
6920 w32_enable_synthesized_fonts
= 0;
6922 DEFVAR_LISP ("w32-enable-palette", Vw32_enable_palette
,
6923 doc
: /* Non-nil enables Windows palette management to map colors exactly. */);
6924 Vw32_enable_palette
= Qt
;
6926 DEFVAR_INT ("w32-mouse-button-tolerance",
6927 w32_mouse_button_tolerance
,
6928 doc
: /* Analogue of double click interval for faking middle mouse events.
6929 The value is the minimum time in milliseconds that must elapse between
6930 left and right button down events before they are considered distinct events.
6931 If both mouse buttons are depressed within this interval, a middle mouse
6932 button down event is generated instead. */);
6933 w32_mouse_button_tolerance
= GetDoubleClickTime () / 2;
6935 DEFVAR_INT ("w32-mouse-move-interval",
6936 w32_mouse_move_interval
,
6937 doc
: /* Minimum interval between mouse move events.
6938 The value is the minimum time in milliseconds that must elapse between
6939 successive mouse move (or scroll bar drag) events before they are
6940 reported as lisp events. */);
6941 w32_mouse_move_interval
= 0;
6943 DEFVAR_BOOL ("w32-pass-extra-mouse-buttons-to-system",
6944 w32_pass_extra_mouse_buttons_to_system
,
6945 doc
: /* If non-nil, the fourth and fifth mouse buttons are passed to Windows.
6946 Recent versions of Windows support mice with up to five buttons.
6947 Since most applications don't support these extra buttons, most mouse
6948 drivers will allow you to map them to functions at the system level.
6949 If this variable is non-nil, Emacs will pass them on, allowing the
6950 system to handle them. */);
6951 w32_pass_extra_mouse_buttons_to_system
= 0;
6953 DEFVAR_BOOL ("w32-pass-multimedia-buttons-to-system",
6954 w32_pass_multimedia_buttons_to_system
,
6955 doc
: /* If non-nil, media buttons are passed to Windows.
6956 Some modern keyboards contain buttons for controlling media players, web
6957 browsers and other applications. Generally these buttons are handled on a
6958 system wide basis, but by setting this to nil they are made available
6959 to Emacs for binding. Depending on your keyboard, additional keys that
6960 may be available are:
6962 browser-back, browser-forward, browser-refresh, browser-stop,
6963 browser-search, browser-favorites, browser-home,
6964 mail, mail-reply, mail-forward, mail-send,
6966 help, find, new, open, close, save, print, undo, redo, copy, cut, paste,
6967 spell-check, correction-list, toggle-dictate-command,
6968 media-next, media-previous, media-stop, media-play-pause, media-select,
6969 media-play, media-pause, media-record, media-fast-forward, media-rewind,
6970 media-channel-up, media-channel-down,
6971 volume-mute, volume-up, volume-down,
6972 mic-volume-mute, mic-volume-down, mic-volume-up, mic-toggle,
6973 bass-down, bass-boost, bass-up, treble-down, treble-up */);
6974 w32_pass_multimedia_buttons_to_system
= 1;
6976 #if 0 /* TODO: Mouse cursor customization. */
6977 DEFVAR_LISP ("x-pointer-shape", Vx_pointer_shape
,
6978 doc
: /* The shape of the pointer when over text.
6979 Changing the value does not affect existing frames
6980 unless you set the mouse color. */);
6981 Vx_pointer_shape
= Qnil
;
6983 Vx_nontext_pointer_shape
= Qnil
;
6985 Vx_mode_pointer_shape
= Qnil
;
6987 DEFVAR_LISP ("x-hourglass-pointer-shape", Vx_hourglass_pointer_shape
,
6988 doc
: /* The shape of the pointer when Emacs is busy.
6989 This variable takes effect when you create a new frame
6990 or when you set the mouse color. */);
6991 Vx_hourglass_pointer_shape
= Qnil
;
6993 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
6994 Vx_sensitive_text_pointer_shape
,
6995 doc
: /* The shape of the pointer when over mouse-sensitive text.
6996 This variable takes effect when you create a new frame
6997 or when you set the mouse color. */);
6998 Vx_sensitive_text_pointer_shape
= Qnil
;
7000 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
7001 Vx_window_horizontal_drag_shape
,
7002 doc
: /* Pointer shape to use for indicating a window can be dragged horizontally.
7003 This variable takes effect when you create a new frame
7004 or when you set the mouse color. */);
7005 Vx_window_horizontal_drag_shape
= Qnil
;
7008 DEFVAR_LISP ("x-cursor-fore-pixel", Vx_cursor_fore_pixel
,
7009 doc
: /* A string indicating the foreground color of the cursor box. */);
7010 Vx_cursor_fore_pixel
= Qnil
;
7012 DEFVAR_LISP ("x-max-tooltip-size", Vx_max_tooltip_size
,
7013 doc
: /* Maximum size for tooltips.
7014 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
7015 Vx_max_tooltip_size
= Fcons (make_number (80), make_number (40));
7017 DEFVAR_LISP ("x-no-window-manager", Vx_no_window_manager
,
7018 doc
: /* Non-nil if no window manager is in use.
7019 Emacs doesn't try to figure this out; this is always nil
7020 unless you set it to something else. */);
7021 /* We don't have any way to find this out, so set it to nil
7022 and maybe the user would like to set it to t. */
7023 Vx_no_window_manager
= Qnil
;
7025 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
7026 Vx_pixel_size_width_font_regexp
,
7027 doc
: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
7029 Since Emacs gets width of a font matching with this regexp from
7030 PIXEL_SIZE field of the name, font finding mechanism gets faster for
7031 such a font. This is especially effective for such large fonts as
7032 Chinese, Japanese, and Korean. */);
7033 Vx_pixel_size_width_font_regexp
= Qnil
;
7035 DEFVAR_LISP ("w32-bdf-filename-alist",
7036 Vw32_bdf_filename_alist
,
7037 doc
: /* List of bdf fonts and their corresponding filenames. */);
7038 Vw32_bdf_filename_alist
= Qnil
;
7040 DEFVAR_BOOL ("w32-strict-fontnames",
7041 w32_strict_fontnames
,
7042 doc
: /* Non-nil means only use fonts that are exact matches for those requested.
7043 Default is nil, which allows old fontnames that are not XLFD compliant,
7044 and allows third-party CJK display to work by specifying false charset
7045 fields to trick Emacs into translating to Big5, SJIS etc.
7046 Setting this to t will prevent wrong fonts being selected when
7047 fontsets are automatically created. */);
7048 w32_strict_fontnames
= 0;
7050 DEFVAR_BOOL ("w32-strict-painting",
7051 w32_strict_painting
,
7052 doc
: /* Non-nil means use strict rules for repainting frames.
7053 Set this to nil to get the old behavior for repainting; this should
7054 only be necessary if the default setting causes problems. */);
7055 w32_strict_painting
= 1;
7057 #if 0 /* TODO: Port to W32 */
7058 defsubr (&Sx_change_window_property
);
7059 defsubr (&Sx_delete_window_property
);
7060 defsubr (&Sx_window_property
);
7062 defsubr (&Sxw_display_color_p
);
7063 defsubr (&Sx_display_grayscale_p
);
7064 defsubr (&Sxw_color_defined_p
);
7065 defsubr (&Sxw_color_values
);
7066 defsubr (&Sx_server_max_request_size
);
7067 defsubr (&Sx_server_vendor
);
7068 defsubr (&Sx_server_version
);
7069 defsubr (&Sx_display_pixel_width
);
7070 defsubr (&Sx_display_pixel_height
);
7071 defsubr (&Sx_display_mm_width
);
7072 defsubr (&Sx_display_mm_height
);
7073 defsubr (&Sx_display_screens
);
7074 defsubr (&Sx_display_planes
);
7075 defsubr (&Sx_display_color_cells
);
7076 defsubr (&Sx_display_visual_class
);
7077 defsubr (&Sx_display_backing_store
);
7078 defsubr (&Sx_display_save_under
);
7079 defsubr (&Sx_create_frame
);
7080 defsubr (&Sx_open_connection
);
7081 defsubr (&Sx_close_connection
);
7082 defsubr (&Sx_display_list
);
7083 defsubr (&Sx_synchronize
);
7084 defsubr (&Sx_focus_frame
);
7086 /* W32 specific functions */
7088 defsubr (&Sw32_define_rgb_color
);
7089 defsubr (&Sw32_default_color_map
);
7090 defsubr (&Sw32_send_sys_command
);
7091 defsubr (&Sw32_shell_execute
);
7092 defsubr (&Sw32_register_hot_key
);
7093 defsubr (&Sw32_unregister_hot_key
);
7094 defsubr (&Sw32_registered_hot_keys
);
7095 defsubr (&Sw32_reconstruct_hot_key
);
7096 defsubr (&Sw32_toggle_lock_key
);
7097 defsubr (&Sw32_window_exists_p
);
7098 defsubr (&Sw32_battery_status
);
7100 defsubr (&Sfile_system_info
);
7101 defsubr (&Sdefault_printer_name
);
7103 check_window_system_func
= check_w32
;
7106 hourglass_timer
= 0;
7107 hourglass_hwnd
= NULL
;
7109 defsubr (&Sx_show_tip
);
7110 defsubr (&Sx_hide_tip
);
7112 staticpro (&tip_timer
);
7114 staticpro (&tip_frame
);
7116 last_show_tip_args
= Qnil
;
7117 staticpro (&last_show_tip_args
);
7119 defsubr (&Sx_file_dialog
);
7120 defsubr (&Ssystem_move_file_to_trash
);
7125 globals_of_w32fns is used to initialize those global variables that
7126 must always be initialized on startup even when the global variable
7127 initialized is non zero (see the function main in emacs.c).
7128 globals_of_w32fns is called from syms_of_w32fns when the global
7129 variable initialized is 0 and directly from main when initialized
7133 globals_of_w32fns (void)
7135 HMODULE user32_lib
= GetModuleHandle ("user32.dll");
7137 TrackMouseEvent not available in all versions of Windows, so must load
7138 it dynamically. Do it once, here, instead of every time it is used.
7140 track_mouse_event_fn
= (TrackMouseEvent_Proc
)
7141 GetProcAddress (user32_lib
, "TrackMouseEvent");
7143 monitor_from_point_fn
= (MonitorFromPoint_Proc
)
7144 GetProcAddress (user32_lib
, "MonitorFromPoint");
7145 get_monitor_info_fn
= (GetMonitorInfo_Proc
)
7146 GetProcAddress (user32_lib
, "GetMonitorInfoA");
7149 HMODULE imm32_lib
= GetModuleHandle ("imm32.dll");
7150 get_composition_string_fn
= (ImmGetCompositionString_Proc
)
7151 GetProcAddress (imm32_lib
, "ImmGetCompositionStringW");
7152 get_ime_context_fn
= (ImmGetContext_Proc
)
7153 GetProcAddress (imm32_lib
, "ImmGetContext");
7154 release_ime_context_fn
= (ImmReleaseContext_Proc
)
7155 GetProcAddress (imm32_lib
, "ImmReleaseContext");
7156 set_ime_composition_window_fn
= (ImmSetCompositionWindow_Proc
)
7157 GetProcAddress (imm32_lib
, "ImmSetCompositionWindow");
7159 DEFVAR_INT ("w32-ansi-code-page",
7161 doc
: /* The ANSI code page used by the system. */);
7162 w32_ansi_code_page
= GetACP ();
7164 /* MessageBox does not work without this when linked to comctl32.dll 6.0. */
7165 InitCommonControls ();
7167 syms_of_w32uniscribe ();
7176 button
= MessageBox (NULL
,
7177 "A fatal error has occurred!\n\n"
7178 "Would you like to attach a debugger?\n\n"
7179 "Select YES to debug, NO to abort Emacs"
7181 "\n\n(type \"gdb -p <emacs-PID>\" and\n"
7182 "\"continue\" inside GDB before clicking YES.)"
7184 , "Emacs Abort Dialog",
7185 MB_ICONEXCLAMATION
| MB_TASKMODAL
7186 | MB_SETFOREGROUND
| MB_YESNO
);
7191 exit (2); /* tell the compiler we will never return */
7199 /* For convenience when debugging. */
7201 w32_last_error (void)
7203 return GetLastError ();