1 /* Graphical user interface functions for the Microsoft W32 API.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 ();
73 void globals_of_w32fns ();
75 extern void free_frame_menubar ();
76 extern double atof ();
77 extern int w32_console_toggle_lock_key
P_ ((int, Lisp_Object
));
78 extern void w32_menu_display_help
P_ ((HWND
, HMENU
, UINT
, UINT
));
79 extern void w32_free_menu_strings
P_ ((HWND
));
80 extern const char *map_w32_filename
P_ ((const char *, const char **));
84 extern char *lispy_function_keys
[];
86 /* The colormap for converting color names to RGB values */
87 Lisp_Object Vw32_color_map
;
89 /* Non nil if alt key presses are passed on to Windows. */
90 Lisp_Object Vw32_pass_alt_to_system
;
92 /* Non nil if alt key is translated to meta_modifier, nil if it is translated
94 Lisp_Object Vw32_alt_is_meta
;
96 /* If non-zero, the windows virtual key code for an alternative quit key. */
99 /* Non nil if left window key events are passed on to Windows (this only
100 affects whether "tapping" the key opens the Start menu). */
101 Lisp_Object Vw32_pass_lwindow_to_system
;
103 /* Non nil if right window key events are passed on to Windows (this
104 only affects whether "tapping" the key opens the Start menu). */
105 Lisp_Object Vw32_pass_rwindow_to_system
;
107 /* Virtual key code used to generate "phantom" key presses in order
108 to stop system from acting on Windows key events. */
109 Lisp_Object Vw32_phantom_key_code
;
111 /* Modifier associated with the left "Windows" key, or nil to act as a
113 Lisp_Object Vw32_lwindow_modifier
;
115 /* Modifier associated with the right "Windows" key, or nil to act as a
117 Lisp_Object Vw32_rwindow_modifier
;
119 /* Modifier associated with the "Apps" key, or nil to act as a normal
121 Lisp_Object Vw32_apps_modifier
;
123 /* Value is nil if Num Lock acts as a function key. */
124 Lisp_Object Vw32_enable_num_lock
;
126 /* Value is nil if Caps Lock acts as a function key. */
127 Lisp_Object Vw32_enable_caps_lock
;
129 /* Modifier associated with Scroll Lock, or nil to act as a normal key. */
130 Lisp_Object Vw32_scroll_lock_modifier
;
132 /* Switch to control whether we inhibit requests for synthesized bold
133 and italic versions of fonts. */
134 int w32_enable_synthesized_fonts
;
136 /* Enable palette management. */
137 Lisp_Object Vw32_enable_palette
;
139 /* Control how close left/right button down events must be to
140 be converted to a middle button down event. */
141 int w32_mouse_button_tolerance
;
143 /* Minimum interval between mouse movement (and scroll bar drag)
144 events that are passed on to the event loop. */
145 int w32_mouse_move_interval
;
147 /* Flag to indicate if XBUTTON events should be passed on to Windows. */
148 static int w32_pass_extra_mouse_buttons_to_system
;
150 /* Flag to indicate if media keys should be passed on to Windows. */
151 static int w32_pass_multimedia_buttons_to_system
;
153 /* Non nil if no window manager is in use. */
154 Lisp_Object Vx_no_window_manager
;
156 /* If non-zero, a w32 timer that, when it expires, displays an
157 hourglass cursor on all frames. */
158 static unsigned hourglass_timer
= 0;
159 static HWND hourglass_hwnd
= NULL
;
161 #if 0 /* TODO: Mouse cursor customization. */
162 /* The background and shape of the mouse pointer, and shape when not
163 over text or in the modeline. */
164 Lisp_Object Vx_pointer_shape
, Vx_nontext_pointer_shape
, Vx_mode_pointer_shape
;
165 Lisp_Object Vx_hourglass_pointer_shape
, Vx_window_horizontal_drag_shape
;
167 /* The shape when over mouse-sensitive text. */
169 Lisp_Object Vx_sensitive_text_pointer_shape
;
173 #define IDC_HAND MAKEINTRESOURCE(32649)
176 /* Color of chars displayed in cursor box. */
177 Lisp_Object Vx_cursor_fore_pixel
;
179 /* Nonzero if using Windows. */
181 static int w32_in_use
;
183 /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'. */
185 Lisp_Object Vx_pixel_size_width_font_regexp
;
187 /* Alist of bdf fonts and the files that define them. */
188 Lisp_Object Vw32_bdf_filename_alist
;
190 /* A flag to control whether fonts are matched strictly or not. */
191 static int w32_strict_fontnames
;
193 /* A flag to control whether we should only repaint if GetUpdateRect
194 indicates there is an update region. */
195 static int w32_strict_painting
;
198 Lisp_Object Qsuppress_icon
;
199 Lisp_Object Qundefined_color
;
200 Lisp_Object Qcancel_timer
;
201 Lisp_Object Qfont_param
;
207 Lisp_Object Qcontrol
;
211 /* The ANSI codepage. */
212 int w32_ansi_code_page
;
214 /* Prefix for system colors. */
215 #define SYSTEM_COLOR_PREFIX "System"
216 #define SYSTEM_COLOR_PREFIX_LEN (sizeof (SYSTEM_COLOR_PREFIX) - 1)
218 /* State variables for emulating a three button mouse. */
223 static int button_state
= 0;
224 static W32Msg saved_mouse_button_msg
;
225 static unsigned mouse_button_timer
= 0; /* non-zero when timer is active */
226 static W32Msg saved_mouse_move_msg
;
227 static unsigned mouse_move_timer
= 0;
229 /* Window that is tracking the mouse. */
230 static HWND track_mouse_window
;
232 /* Multi-monitor API definitions that are not pulled from the headers
233 since we are compiling for NT 4. */
234 #ifndef MONITOR_DEFAULT_TO_NEAREST
235 #define MONITOR_DEFAULT_TO_NEAREST 2
237 /* MinGW headers define MONITORINFO unconditionally, but MSVC ones don't.
238 To avoid a compile error on one or the other, redefine with a new name. */
247 /* Reportedly, VS 6 does not have this in its headers. */
248 #if defined(_MSC_VER) && _MSC_VER < 1300
249 DECLARE_HANDLE(HMONITOR
);
252 typedef BOOL (WINAPI
* TrackMouseEvent_Proc
)
253 (IN OUT LPTRACKMOUSEEVENT lpEventTrack
);
254 typedef LONG (WINAPI
* ImmGetCompositionString_Proc
)
255 (IN HIMC context
, IN DWORD index
, OUT LPVOID buffer
, IN DWORD bufLen
);
256 typedef HIMC (WINAPI
* ImmGetContext_Proc
) (IN HWND window
);
257 typedef HWND (WINAPI
* ImmReleaseContext_Proc
) (IN HWND wnd
, IN HIMC context
);
258 typedef HWND (WINAPI
* ImmSetCompositionWindow_Proc
) (IN HIMC context
,
259 IN COMPOSITIONFORM
*form
);
260 typedef HMONITOR (WINAPI
* MonitorFromPoint_Proc
) (IN POINT pt
, IN DWORD flags
);
261 typedef BOOL (WINAPI
* GetMonitorInfo_Proc
)
262 (IN HMONITOR monitor
, OUT
struct MONITOR_INFO
* info
);
264 TrackMouseEvent_Proc track_mouse_event_fn
= NULL
;
265 ClipboardSequence_Proc clipboard_sequence_fn
= NULL
;
266 ImmGetCompositionString_Proc get_composition_string_fn
= NULL
;
267 ImmGetContext_Proc get_ime_context_fn
= NULL
;
268 ImmReleaseContext_Proc release_ime_context_fn
= NULL
;
269 ImmSetCompositionWindow_Proc set_ime_composition_window_fn
= NULL
;
270 MonitorFromPoint_Proc monitor_from_point_fn
= NULL
;
271 GetMonitorInfo_Proc get_monitor_info_fn
= NULL
;
273 extern AppendMenuW_Proc unicode_append_menu
;
275 /* Flag to selectively ignore WM_IME_CHAR messages. */
276 static int ignore_ime_char
= 0;
278 /* W95 mousewheel handler */
279 unsigned int msh_mousewheel
= 0;
282 #define MOUSE_BUTTON_ID 1
283 #define MOUSE_MOVE_ID 2
284 #define MENU_FREE_ID 3
285 #define HOURGLASS_ID 4
286 /* The delay (milliseconds) before a menu is freed after WM_EXITMENULOOP
288 #define MENU_FREE_DELAY 1000
289 static unsigned menu_free_timer
= 0;
293 extern Lisp_Object Vwindow_system_version
;
295 /* The below are defined in frame.c. */
297 extern Lisp_Object Qtooltip
;
300 int image_cache_refcount
, dpyinfo_refcount
;
304 /* From w32term.c. */
305 extern int w32_num_mouse_buttons
;
306 extern Lisp_Object Vw32_recognize_altgr
;
308 extern HWND w32_system_caret_hwnd
;
310 extern int w32_system_caret_height
;
311 extern int w32_system_caret_x
;
312 extern int w32_system_caret_y
;
313 extern int w32_use_visible_system_caret
;
315 static HWND w32_visible_system_caret_hwnd
;
318 extern HMENU current_popup_menu
;
319 static int menubar_in_use
= 0;
321 /* From w32uniscribe.c */
322 extern void syms_of_w32uniscribe ();
323 extern int uniscribe_available
;
325 /* Function prototypes for hourglass support. */
326 static void w32_show_hourglass
P_ ((struct frame
*));
327 static void w32_hide_hourglass
P_ ((void));
331 /* Error if we are not connected to MS-Windows. */
336 error ("MS-Windows not in use or not initialized");
339 /* Nonzero if we can use mouse menus.
340 You should not call this unless HAVE_MENUS is defined. */
348 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
349 and checking validity for W32. */
352 check_x_frame (frame
)
358 frame
= selected_frame
;
359 CHECK_LIVE_FRAME (frame
);
361 if (! FRAME_W32_P (f
))
362 error ("Non-W32 frame used");
366 /* Let the user specify a display with a frame.
367 nil stands for the selected frame--or, if that is not a w32 frame,
368 the first display on the list. */
370 struct w32_display_info
*
371 check_x_display_info (frame
)
376 struct frame
*sf
= XFRAME (selected_frame
);
378 if (FRAME_W32_P (sf
) && FRAME_LIVE_P (sf
))
379 return FRAME_W32_DISPLAY_INFO (sf
);
381 return &one_w32_display_info
;
383 else if (STRINGP (frame
))
384 return x_display_info_for_name (frame
);
389 CHECK_LIVE_FRAME (frame
);
391 if (! FRAME_W32_P (f
))
392 error ("Non-W32 frame used");
393 return FRAME_W32_DISPLAY_INFO (f
);
397 /* Return the Emacs frame-object corresponding to an w32 window.
398 It could be the frame's main window or an icon window. */
400 /* This function can be called during GC, so use GC_xxx type test macros. */
403 x_window_to_frame (dpyinfo
, wdesc
)
404 struct w32_display_info
*dpyinfo
;
407 Lisp_Object tail
, frame
;
410 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
416 if (!FRAME_W32_P (f
) || FRAME_W32_DISPLAY_INFO (f
) != dpyinfo
)
419 if (FRAME_W32_WINDOW (f
) == wdesc
)
426 static Lisp_Object unwind_create_frame
P_ ((Lisp_Object
));
427 static Lisp_Object unwind_create_tip_frame
P_ ((Lisp_Object
));
428 static void my_create_window
P_ ((struct frame
*));
429 static void my_create_tip_window
P_ ((struct frame
*));
431 /* TODO: Native Input Method support; see x_create_im. */
432 void x_set_foreground_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
433 void x_set_background_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
434 void x_set_mouse_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
435 void x_set_cursor_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
436 void x_set_border_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
437 void x_set_cursor_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
438 void x_set_icon_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
439 void x_set_icon_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
440 void x_explicitly_set_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
441 void x_set_menu_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
442 void x_set_title
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
443 void x_set_tool_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
444 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
450 /* Store the screen positions of frame F into XPTR and YPTR.
451 These are the positions of the containing window manager window,
452 not Emacs's own window. */
455 x_real_positions (f
, xptr
, yptr
)
462 /* Get the bounds of the WM window. */
463 GetWindowRect (FRAME_W32_WINDOW (f
), &rect
);
468 /* Convert (0, 0) in the client area to screen co-ordinates. */
469 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
471 /* Remember x_pixels_diff and y_pixels_diff. */
472 f
->x_pixels_diff
= pt
.x
- rect
.left
;
473 f
->y_pixels_diff
= pt
.y
- rect
.top
;
481 DEFUN ("w32-define-rgb-color", Fw32_define_rgb_color
,
482 Sw32_define_rgb_color
, 4, 4, 0,
483 doc
: /* Convert RGB numbers to a Windows color reference and associate with NAME.
484 This adds or updates a named color to `w32-color-map', making it
485 available for use. The original entry's RGB ref is returned, or nil
486 if the entry is new. */)
487 (red
, green
, blue
, name
)
488 Lisp_Object red
, green
, blue
, name
;
491 Lisp_Object oldrgb
= Qnil
;
495 CHECK_NUMBER (green
);
499 XSETINT (rgb
, RGB (XUINT (red
), XUINT (green
), XUINT (blue
)));
503 /* replace existing entry in w32-color-map or add new entry. */
504 entry
= Fassoc (name
, Vw32_color_map
);
507 entry
= Fcons (name
, rgb
);
508 Vw32_color_map
= Fcons (entry
, Vw32_color_map
);
512 oldrgb
= Fcdr (entry
);
513 Fsetcdr (entry
, rgb
);
521 /* The default colors for the w32 color map */
522 typedef struct colormap_t
528 colormap_t w32_color_map
[] =
530 {"snow" , PALETTERGB (255,250,250)},
531 {"ghost white" , PALETTERGB (248,248,255)},
532 {"GhostWhite" , PALETTERGB (248,248,255)},
533 {"white smoke" , PALETTERGB (245,245,245)},
534 {"WhiteSmoke" , PALETTERGB (245,245,245)},
535 {"gainsboro" , PALETTERGB (220,220,220)},
536 {"floral white" , PALETTERGB (255,250,240)},
537 {"FloralWhite" , PALETTERGB (255,250,240)},
538 {"old lace" , PALETTERGB (253,245,230)},
539 {"OldLace" , PALETTERGB (253,245,230)},
540 {"linen" , PALETTERGB (250,240,230)},
541 {"antique white" , PALETTERGB (250,235,215)},
542 {"AntiqueWhite" , PALETTERGB (250,235,215)},
543 {"papaya whip" , PALETTERGB (255,239,213)},
544 {"PapayaWhip" , PALETTERGB (255,239,213)},
545 {"blanched almond" , PALETTERGB (255,235,205)},
546 {"BlanchedAlmond" , PALETTERGB (255,235,205)},
547 {"bisque" , PALETTERGB (255,228,196)},
548 {"peach puff" , PALETTERGB (255,218,185)},
549 {"PeachPuff" , PALETTERGB (255,218,185)},
550 {"navajo white" , PALETTERGB (255,222,173)},
551 {"NavajoWhite" , PALETTERGB (255,222,173)},
552 {"moccasin" , PALETTERGB (255,228,181)},
553 {"cornsilk" , PALETTERGB (255,248,220)},
554 {"ivory" , PALETTERGB (255,255,240)},
555 {"lemon chiffon" , PALETTERGB (255,250,205)},
556 {"LemonChiffon" , PALETTERGB (255,250,205)},
557 {"seashell" , PALETTERGB (255,245,238)},
558 {"honeydew" , PALETTERGB (240,255,240)},
559 {"mint cream" , PALETTERGB (245,255,250)},
560 {"MintCream" , PALETTERGB (245,255,250)},
561 {"azure" , PALETTERGB (240,255,255)},
562 {"alice blue" , PALETTERGB (240,248,255)},
563 {"AliceBlue" , PALETTERGB (240,248,255)},
564 {"lavender" , PALETTERGB (230,230,250)},
565 {"lavender blush" , PALETTERGB (255,240,245)},
566 {"LavenderBlush" , PALETTERGB (255,240,245)},
567 {"misty rose" , PALETTERGB (255,228,225)},
568 {"MistyRose" , PALETTERGB (255,228,225)},
569 {"white" , PALETTERGB (255,255,255)},
570 {"black" , PALETTERGB ( 0, 0, 0)},
571 {"dark slate gray" , PALETTERGB ( 47, 79, 79)},
572 {"DarkSlateGray" , PALETTERGB ( 47, 79, 79)},
573 {"dark slate grey" , PALETTERGB ( 47, 79, 79)},
574 {"DarkSlateGrey" , PALETTERGB ( 47, 79, 79)},
575 {"dim gray" , PALETTERGB (105,105,105)},
576 {"DimGray" , PALETTERGB (105,105,105)},
577 {"dim grey" , PALETTERGB (105,105,105)},
578 {"DimGrey" , PALETTERGB (105,105,105)},
579 {"slate gray" , PALETTERGB (112,128,144)},
580 {"SlateGray" , PALETTERGB (112,128,144)},
581 {"slate grey" , PALETTERGB (112,128,144)},
582 {"SlateGrey" , PALETTERGB (112,128,144)},
583 {"light slate gray" , PALETTERGB (119,136,153)},
584 {"LightSlateGray" , PALETTERGB (119,136,153)},
585 {"light slate grey" , PALETTERGB (119,136,153)},
586 {"LightSlateGrey" , PALETTERGB (119,136,153)},
587 {"gray" , PALETTERGB (190,190,190)},
588 {"grey" , PALETTERGB (190,190,190)},
589 {"light grey" , PALETTERGB (211,211,211)},
590 {"LightGrey" , PALETTERGB (211,211,211)},
591 {"light gray" , PALETTERGB (211,211,211)},
592 {"LightGray" , PALETTERGB (211,211,211)},
593 {"midnight blue" , PALETTERGB ( 25, 25,112)},
594 {"MidnightBlue" , PALETTERGB ( 25, 25,112)},
595 {"navy" , PALETTERGB ( 0, 0,128)},
596 {"navy blue" , PALETTERGB ( 0, 0,128)},
597 {"NavyBlue" , PALETTERGB ( 0, 0,128)},
598 {"cornflower blue" , PALETTERGB (100,149,237)},
599 {"CornflowerBlue" , PALETTERGB (100,149,237)},
600 {"dark slate blue" , PALETTERGB ( 72, 61,139)},
601 {"DarkSlateBlue" , PALETTERGB ( 72, 61,139)},
602 {"slate blue" , PALETTERGB (106, 90,205)},
603 {"SlateBlue" , PALETTERGB (106, 90,205)},
604 {"medium slate blue" , PALETTERGB (123,104,238)},
605 {"MediumSlateBlue" , PALETTERGB (123,104,238)},
606 {"light slate blue" , PALETTERGB (132,112,255)},
607 {"LightSlateBlue" , PALETTERGB (132,112,255)},
608 {"medium blue" , PALETTERGB ( 0, 0,205)},
609 {"MediumBlue" , PALETTERGB ( 0, 0,205)},
610 {"royal blue" , PALETTERGB ( 65,105,225)},
611 {"RoyalBlue" , PALETTERGB ( 65,105,225)},
612 {"blue" , PALETTERGB ( 0, 0,255)},
613 {"dodger blue" , PALETTERGB ( 30,144,255)},
614 {"DodgerBlue" , PALETTERGB ( 30,144,255)},
615 {"deep sky blue" , PALETTERGB ( 0,191,255)},
616 {"DeepSkyBlue" , PALETTERGB ( 0,191,255)},
617 {"sky blue" , PALETTERGB (135,206,235)},
618 {"SkyBlue" , PALETTERGB (135,206,235)},
619 {"light sky blue" , PALETTERGB (135,206,250)},
620 {"LightSkyBlue" , PALETTERGB (135,206,250)},
621 {"steel blue" , PALETTERGB ( 70,130,180)},
622 {"SteelBlue" , PALETTERGB ( 70,130,180)},
623 {"light steel blue" , PALETTERGB (176,196,222)},
624 {"LightSteelBlue" , PALETTERGB (176,196,222)},
625 {"light blue" , PALETTERGB (173,216,230)},
626 {"LightBlue" , PALETTERGB (173,216,230)},
627 {"powder blue" , PALETTERGB (176,224,230)},
628 {"PowderBlue" , PALETTERGB (176,224,230)},
629 {"pale turquoise" , PALETTERGB (175,238,238)},
630 {"PaleTurquoise" , PALETTERGB (175,238,238)},
631 {"dark turquoise" , PALETTERGB ( 0,206,209)},
632 {"DarkTurquoise" , PALETTERGB ( 0,206,209)},
633 {"medium turquoise" , PALETTERGB ( 72,209,204)},
634 {"MediumTurquoise" , PALETTERGB ( 72,209,204)},
635 {"turquoise" , PALETTERGB ( 64,224,208)},
636 {"cyan" , PALETTERGB ( 0,255,255)},
637 {"light cyan" , PALETTERGB (224,255,255)},
638 {"LightCyan" , PALETTERGB (224,255,255)},
639 {"cadet blue" , PALETTERGB ( 95,158,160)},
640 {"CadetBlue" , PALETTERGB ( 95,158,160)},
641 {"medium aquamarine" , PALETTERGB (102,205,170)},
642 {"MediumAquamarine" , PALETTERGB (102,205,170)},
643 {"aquamarine" , PALETTERGB (127,255,212)},
644 {"dark green" , PALETTERGB ( 0,100, 0)},
645 {"DarkGreen" , PALETTERGB ( 0,100, 0)},
646 {"dark olive green" , PALETTERGB ( 85,107, 47)},
647 {"DarkOliveGreen" , PALETTERGB ( 85,107, 47)},
648 {"dark sea green" , PALETTERGB (143,188,143)},
649 {"DarkSeaGreen" , PALETTERGB (143,188,143)},
650 {"sea green" , PALETTERGB ( 46,139, 87)},
651 {"SeaGreen" , PALETTERGB ( 46,139, 87)},
652 {"medium sea green" , PALETTERGB ( 60,179,113)},
653 {"MediumSeaGreen" , PALETTERGB ( 60,179,113)},
654 {"light sea green" , PALETTERGB ( 32,178,170)},
655 {"LightSeaGreen" , PALETTERGB ( 32,178,170)},
656 {"pale green" , PALETTERGB (152,251,152)},
657 {"PaleGreen" , PALETTERGB (152,251,152)},
658 {"spring green" , PALETTERGB ( 0,255,127)},
659 {"SpringGreen" , PALETTERGB ( 0,255,127)},
660 {"lawn green" , PALETTERGB (124,252, 0)},
661 {"LawnGreen" , PALETTERGB (124,252, 0)},
662 {"green" , PALETTERGB ( 0,255, 0)},
663 {"chartreuse" , PALETTERGB (127,255, 0)},
664 {"medium spring green" , PALETTERGB ( 0,250,154)},
665 {"MediumSpringGreen" , PALETTERGB ( 0,250,154)},
666 {"green yellow" , PALETTERGB (173,255, 47)},
667 {"GreenYellow" , PALETTERGB (173,255, 47)},
668 {"lime green" , PALETTERGB ( 50,205, 50)},
669 {"LimeGreen" , PALETTERGB ( 50,205, 50)},
670 {"yellow green" , PALETTERGB (154,205, 50)},
671 {"YellowGreen" , PALETTERGB (154,205, 50)},
672 {"forest green" , PALETTERGB ( 34,139, 34)},
673 {"ForestGreen" , PALETTERGB ( 34,139, 34)},
674 {"olive drab" , PALETTERGB (107,142, 35)},
675 {"OliveDrab" , PALETTERGB (107,142, 35)},
676 {"dark khaki" , PALETTERGB (189,183,107)},
677 {"DarkKhaki" , PALETTERGB (189,183,107)},
678 {"khaki" , PALETTERGB (240,230,140)},
679 {"pale goldenrod" , PALETTERGB (238,232,170)},
680 {"PaleGoldenrod" , PALETTERGB (238,232,170)},
681 {"light goldenrod yellow" , PALETTERGB (250,250,210)},
682 {"LightGoldenrodYellow" , PALETTERGB (250,250,210)},
683 {"light yellow" , PALETTERGB (255,255,224)},
684 {"LightYellow" , PALETTERGB (255,255,224)},
685 {"yellow" , PALETTERGB (255,255, 0)},
686 {"gold" , PALETTERGB (255,215, 0)},
687 {"light goldenrod" , PALETTERGB (238,221,130)},
688 {"LightGoldenrod" , PALETTERGB (238,221,130)},
689 {"goldenrod" , PALETTERGB (218,165, 32)},
690 {"dark goldenrod" , PALETTERGB (184,134, 11)},
691 {"DarkGoldenrod" , PALETTERGB (184,134, 11)},
692 {"rosy brown" , PALETTERGB (188,143,143)},
693 {"RosyBrown" , PALETTERGB (188,143,143)},
694 {"indian red" , PALETTERGB (205, 92, 92)},
695 {"IndianRed" , PALETTERGB (205, 92, 92)},
696 {"saddle brown" , PALETTERGB (139, 69, 19)},
697 {"SaddleBrown" , PALETTERGB (139, 69, 19)},
698 {"sienna" , PALETTERGB (160, 82, 45)},
699 {"peru" , PALETTERGB (205,133, 63)},
700 {"burlywood" , PALETTERGB (222,184,135)},
701 {"beige" , PALETTERGB (245,245,220)},
702 {"wheat" , PALETTERGB (245,222,179)},
703 {"sandy brown" , PALETTERGB (244,164, 96)},
704 {"SandyBrown" , PALETTERGB (244,164, 96)},
705 {"tan" , PALETTERGB (210,180,140)},
706 {"chocolate" , PALETTERGB (210,105, 30)},
707 {"firebrick" , PALETTERGB (178,34, 34)},
708 {"brown" , PALETTERGB (165,42, 42)},
709 {"dark salmon" , PALETTERGB (233,150,122)},
710 {"DarkSalmon" , PALETTERGB (233,150,122)},
711 {"salmon" , PALETTERGB (250,128,114)},
712 {"light salmon" , PALETTERGB (255,160,122)},
713 {"LightSalmon" , PALETTERGB (255,160,122)},
714 {"orange" , PALETTERGB (255,165, 0)},
715 {"dark orange" , PALETTERGB (255,140, 0)},
716 {"DarkOrange" , PALETTERGB (255,140, 0)},
717 {"coral" , PALETTERGB (255,127, 80)},
718 {"light coral" , PALETTERGB (240,128,128)},
719 {"LightCoral" , PALETTERGB (240,128,128)},
720 {"tomato" , PALETTERGB (255, 99, 71)},
721 {"orange red" , PALETTERGB (255, 69, 0)},
722 {"OrangeRed" , PALETTERGB (255, 69, 0)},
723 {"red" , PALETTERGB (255, 0, 0)},
724 {"hot pink" , PALETTERGB (255,105,180)},
725 {"HotPink" , PALETTERGB (255,105,180)},
726 {"deep pink" , PALETTERGB (255, 20,147)},
727 {"DeepPink" , PALETTERGB (255, 20,147)},
728 {"pink" , PALETTERGB (255,192,203)},
729 {"light pink" , PALETTERGB (255,182,193)},
730 {"LightPink" , PALETTERGB (255,182,193)},
731 {"pale violet red" , PALETTERGB (219,112,147)},
732 {"PaleVioletRed" , PALETTERGB (219,112,147)},
733 {"maroon" , PALETTERGB (176, 48, 96)},
734 {"medium violet red" , PALETTERGB (199, 21,133)},
735 {"MediumVioletRed" , PALETTERGB (199, 21,133)},
736 {"violet red" , PALETTERGB (208, 32,144)},
737 {"VioletRed" , PALETTERGB (208, 32,144)},
738 {"magenta" , PALETTERGB (255, 0,255)},
739 {"violet" , PALETTERGB (238,130,238)},
740 {"plum" , PALETTERGB (221,160,221)},
741 {"orchid" , PALETTERGB (218,112,214)},
742 {"medium orchid" , PALETTERGB (186, 85,211)},
743 {"MediumOrchid" , PALETTERGB (186, 85,211)},
744 {"dark orchid" , PALETTERGB (153, 50,204)},
745 {"DarkOrchid" , PALETTERGB (153, 50,204)},
746 {"dark violet" , PALETTERGB (148, 0,211)},
747 {"DarkViolet" , PALETTERGB (148, 0,211)},
748 {"blue violet" , PALETTERGB (138, 43,226)},
749 {"BlueViolet" , PALETTERGB (138, 43,226)},
750 {"purple" , PALETTERGB (160, 32,240)},
751 {"medium purple" , PALETTERGB (147,112,219)},
752 {"MediumPurple" , PALETTERGB (147,112,219)},
753 {"thistle" , PALETTERGB (216,191,216)},
754 {"gray0" , PALETTERGB ( 0, 0, 0)},
755 {"grey0" , PALETTERGB ( 0, 0, 0)},
756 {"dark grey" , PALETTERGB (169,169,169)},
757 {"DarkGrey" , PALETTERGB (169,169,169)},
758 {"dark gray" , PALETTERGB (169,169,169)},
759 {"DarkGray" , PALETTERGB (169,169,169)},
760 {"dark blue" , PALETTERGB ( 0, 0,139)},
761 {"DarkBlue" , PALETTERGB ( 0, 0,139)},
762 {"dark cyan" , PALETTERGB ( 0,139,139)},
763 {"DarkCyan" , PALETTERGB ( 0,139,139)},
764 {"dark magenta" , PALETTERGB (139, 0,139)},
765 {"DarkMagenta" , PALETTERGB (139, 0,139)},
766 {"dark red" , PALETTERGB (139, 0, 0)},
767 {"DarkRed" , PALETTERGB (139, 0, 0)},
768 {"light green" , PALETTERGB (144,238,144)},
769 {"LightGreen" , PALETTERGB (144,238,144)},
772 DEFUN ("w32-default-color-map", Fw32_default_color_map
, Sw32_default_color_map
,
773 0, 0, 0, doc
: /* Return the default color map. */)
777 colormap_t
*pc
= w32_color_map
;
784 for (i
= 0; i
< sizeof (w32_color_map
) / sizeof (w32_color_map
[0]);
786 cmap
= Fcons (Fcons (build_string (pc
->name
),
787 make_number (pc
->colorref
)),
805 color
= Frassq (rgb
, Vw32_color_map
);
810 return (Fcar (color
));
816 w32_color_map_lookup (colorname
)
819 Lisp_Object tail
, ret
= Qnil
;
823 for (tail
= Vw32_color_map
; CONSP (tail
); tail
= XCDR (tail
))
825 register Lisp_Object elt
, tem
;
828 if (!CONSP (elt
)) continue;
832 if (lstrcmpi (SDATA (tem
), colorname
) == 0)
849 add_system_logical_colors_to_map (system_colors
)
850 Lisp_Object
*system_colors
;
854 /* Other registry operations are done with input blocked. */
857 /* Look for "Control Panel/Colors" under User and Machine registry
859 if (RegOpenKeyEx (HKEY_CURRENT_USER
, "Control Panel\\Colors", 0,
860 KEY_READ
, &colors_key
) == ERROR_SUCCESS
861 || RegOpenKeyEx (HKEY_LOCAL_MACHINE
, "Control Panel\\Colors", 0,
862 KEY_READ
, &colors_key
) == ERROR_SUCCESS
)
865 char color_buffer
[64];
866 char full_name_buffer
[MAX_PATH
+ SYSTEM_COLOR_PREFIX_LEN
];
868 DWORD name_size
, color_size
;
869 char *name_buffer
= full_name_buffer
+ SYSTEM_COLOR_PREFIX_LEN
;
871 name_size
= sizeof (full_name_buffer
) - SYSTEM_COLOR_PREFIX_LEN
;
872 color_size
= sizeof (color_buffer
);
874 strcpy (full_name_buffer
, SYSTEM_COLOR_PREFIX
);
876 while (RegEnumValueA (colors_key
, index
, name_buffer
, &name_size
,
877 NULL
, NULL
, color_buffer
, &color_size
)
881 if (sscanf (color_buffer
, " %u %u %u", &r
, &g
, &b
) == 3)
882 *system_colors
= Fcons (Fcons (build_string (full_name_buffer
),
883 make_number (RGB (r
, g
, b
))),
886 name_size
= sizeof (full_name_buffer
) - SYSTEM_COLOR_PREFIX_LEN
;
887 color_size
= sizeof (color_buffer
);
890 RegCloseKey (colors_key
);
898 x_to_w32_color (colorname
)
901 register Lisp_Object ret
= Qnil
;
905 if (colorname
[0] == '#')
907 /* Could be an old-style RGB Device specification. */
910 color
= colorname
+ 1;
912 size
= strlen (color
);
913 if (size
== 3 || size
== 6 || size
== 9 || size
== 12)
921 for (i
= 0; i
< 3; i
++)
927 /* The check for 'x' in the following conditional takes into
928 account the fact that strtol allows a "0x" in front of
929 our numbers, and we don't. */
930 if (!isxdigit (color
[0]) || color
[1] == 'x')
934 value
= strtoul (color
, &end
, 16);
936 if (errno
== ERANGE
|| end
- color
!= size
)
941 value
= value
* 0x10;
952 colorval
|= (value
<< pos
);
957 XSETINT (ret
, colorval
);
964 else if (strnicmp (colorname
, "rgb:", 4) == 0)
972 color
= colorname
+ 4;
973 for (i
= 0; i
< 3; i
++)
978 /* The check for 'x' in the following conditional takes into
979 account the fact that strtol allows a "0x" in front of
980 our numbers, and we don't. */
981 if (!isxdigit (color
[0]) || color
[1] == 'x')
983 value
= strtoul (color
, &end
, 16);
989 value
= value
* 0x10 + value
;
1002 if (value
== ULONG_MAX
)
1004 colorval
|= (value
<< pos
);
1011 XSETINT (ret
, colorval
);
1019 else if (strnicmp (colorname
, "rgbi:", 5) == 0)
1021 /* This is an RGB Intensity specification. */
1028 color
= colorname
+ 5;
1029 for (i
= 0; i
< 3; i
++)
1035 value
= strtod (color
, &end
);
1036 if (errno
== ERANGE
)
1038 if (value
< 0.0 || value
> 1.0)
1040 val
= (UINT
)(0x100 * value
);
1041 /* We used 0x100 instead of 0xFF to give a continuous
1042 range between 0.0 and 1.0 inclusive. The next statement
1043 fixes the 1.0 case. */
1046 colorval
|= (val
<< pos
);
1053 XSETINT (ret
, colorval
);
1061 /* I am not going to attempt to handle any of the CIE color schemes
1062 or TekHVC, since I don't know the algorithms for conversion to
1065 /* If we fail to lookup the color name in w32_color_map, then check the
1066 colorname to see if it can be crudely approximated: If the X color
1067 ends in a number (e.g., "darkseagreen2"), strip the number and
1068 return the result of looking up the base color name. */
1069 ret
= w32_color_map_lookup (colorname
);
1072 int len
= strlen (colorname
);
1074 if (isdigit (colorname
[len
- 1]))
1076 char *ptr
, *approx
= alloca (len
+ 1);
1078 strcpy (approx
, colorname
);
1079 ptr
= &approx
[len
- 1];
1080 while (ptr
> approx
&& isdigit (*ptr
))
1083 ret
= w32_color_map_lookup (approx
);
1092 w32_regenerate_palette (FRAME_PTR f
)
1094 struct w32_palette_entry
* list
;
1095 LOGPALETTE
* log_palette
;
1096 HPALETTE new_palette
;
1099 /* don't bother trying to create palette if not supported */
1100 if (! FRAME_W32_DISPLAY_INFO (f
)->has_palette
)
1103 log_palette
= (LOGPALETTE
*)
1104 alloca (sizeof (LOGPALETTE
) +
1105 FRAME_W32_DISPLAY_INFO (f
)->num_colors
* sizeof (PALETTEENTRY
));
1106 log_palette
->palVersion
= 0x300;
1107 log_palette
->palNumEntries
= FRAME_W32_DISPLAY_INFO (f
)->num_colors
;
1109 list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1111 i
< FRAME_W32_DISPLAY_INFO (f
)->num_colors
;
1112 i
++, list
= list
->next
)
1113 log_palette
->palPalEntry
[i
] = list
->entry
;
1115 new_palette
= CreatePalette (log_palette
);
1119 if (FRAME_W32_DISPLAY_INFO (f
)->palette
)
1120 DeleteObject (FRAME_W32_DISPLAY_INFO (f
)->palette
);
1121 FRAME_W32_DISPLAY_INFO (f
)->palette
= new_palette
;
1123 /* Realize display palette and garbage all frames. */
1124 release_frame_dc (f
, get_frame_dc (f
));
1129 #define W32_COLOR(pe) RGB (pe.peRed, pe.peGreen, pe.peBlue)
1130 #define SET_W32_COLOR(pe, color) \
1133 pe.peRed = GetRValue (color); \
1134 pe.peGreen = GetGValue (color); \
1135 pe.peBlue = GetBValue (color); \
1140 /* Keep these around in case we ever want to track color usage. */
1142 w32_map_color (FRAME_PTR f
, COLORREF color
)
1144 struct w32_palette_entry
* list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1146 if (NILP (Vw32_enable_palette
))
1149 /* check if color is already mapped */
1152 if (W32_COLOR (list
->entry
) == color
)
1160 /* not already mapped, so add to list and recreate Windows palette */
1161 list
= (struct w32_palette_entry
*)
1162 xmalloc (sizeof (struct w32_palette_entry
));
1163 SET_W32_COLOR (list
->entry
, color
);
1165 list
->next
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1166 FRAME_W32_DISPLAY_INFO (f
)->color_list
= list
;
1167 FRAME_W32_DISPLAY_INFO (f
)->num_colors
++;
1169 /* set flag that palette must be regenerated */
1170 FRAME_W32_DISPLAY_INFO (f
)->regen_palette
= TRUE
;
1174 w32_unmap_color (FRAME_PTR f
, COLORREF color
)
1176 struct w32_palette_entry
* list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1177 struct w32_palette_entry
**prev
= &FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1179 if (NILP (Vw32_enable_palette
))
1182 /* check if color is already mapped */
1185 if (W32_COLOR (list
->entry
) == color
)
1187 if (--list
->refcount
== 0)
1191 FRAME_W32_DISPLAY_INFO (f
)->num_colors
--;
1201 /* set flag that palette must be regenerated */
1202 FRAME_W32_DISPLAY_INFO (f
)->regen_palette
= TRUE
;
1207 /* Gamma-correct COLOR on frame F. */
1210 gamma_correct (f
, color
)
1216 *color
= PALETTERGB (
1217 pow (GetRValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5,
1218 pow (GetGValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5,
1219 pow (GetBValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5);
1224 /* Decide if color named COLOR is valid for the display associated with
1225 the selected frame; if so, return the rgb values in COLOR_DEF.
1226 If ALLOC is nonzero, allocate a new colormap cell. */
1229 w32_defined_color (f
, color
, color_def
, alloc
)
1235 register Lisp_Object tem
;
1236 COLORREF w32_color_ref
;
1238 tem
= x_to_w32_color (color
);
1244 /* Apply gamma correction. */
1245 w32_color_ref
= XUINT (tem
);
1246 gamma_correct (f
, &w32_color_ref
);
1247 XSETINT (tem
, w32_color_ref
);
1250 /* Map this color to the palette if it is enabled. */
1251 if (!NILP (Vw32_enable_palette
))
1253 struct w32_palette_entry
* entry
=
1254 one_w32_display_info
.color_list
;
1255 struct w32_palette_entry
** prev
=
1256 &one_w32_display_info
.color_list
;
1258 /* check if color is already mapped */
1261 if (W32_COLOR (entry
->entry
) == XUINT (tem
))
1263 prev
= &entry
->next
;
1264 entry
= entry
->next
;
1267 if (entry
== NULL
&& alloc
)
1269 /* not already mapped, so add to list */
1270 entry
= (struct w32_palette_entry
*)
1271 xmalloc (sizeof (struct w32_palette_entry
));
1272 SET_W32_COLOR (entry
->entry
, XUINT (tem
));
1275 one_w32_display_info
.num_colors
++;
1277 /* set flag that palette must be regenerated */
1278 one_w32_display_info
.regen_palette
= TRUE
;
1281 /* Ensure COLORREF value is snapped to nearest color in (default)
1282 palette by simulating the PALETTERGB macro. This works whether
1283 or not the display device has a palette. */
1284 w32_color_ref
= XUINT (tem
) | 0x2000000;
1286 color_def
->pixel
= w32_color_ref
;
1287 color_def
->red
= GetRValue (w32_color_ref
) * 256;
1288 color_def
->green
= GetGValue (w32_color_ref
) * 256;
1289 color_def
->blue
= GetBValue (w32_color_ref
) * 256;
1299 /* Given a string ARG naming a color, compute a pixel value from it
1300 suitable for screen F.
1301 If F is not a color screen, return DEF (default) regardless of what
1305 x_decode_color (f
, arg
, def
)
1314 if (strcmp (SDATA (arg
), "black") == 0)
1315 return BLACK_PIX_DEFAULT (f
);
1316 else if (strcmp (SDATA (arg
), "white") == 0)
1317 return WHITE_PIX_DEFAULT (f
);
1319 if ((FRAME_W32_DISPLAY_INFO (f
)->n_planes
* FRAME_W32_DISPLAY_INFO (f
)->n_cbits
) == 1)
1322 /* w32_defined_color is responsible for coping with failures
1323 by looking for a near-miss. */
1324 if (w32_defined_color (f
, SDATA (arg
), &cdef
, 1))
1327 /* defined_color failed; return an ultimate default. */
1333 /* Functions called only from `x_set_frame_param'
1334 to set individual parameters.
1336 If FRAME_W32_WINDOW (f) is 0,
1337 the frame is being created and its window does not exist yet.
1338 In that case, just record the parameter's new value
1339 in the standard place; do not attempt to change the window. */
1342 x_set_foreground_color (f
, arg
, oldval
)
1344 Lisp_Object arg
, oldval
;
1346 struct w32_output
*x
= f
->output_data
.w32
;
1347 PIX_TYPE fg
, old_fg
;
1349 fg
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1350 old_fg
= FRAME_FOREGROUND_PIXEL (f
);
1351 FRAME_FOREGROUND_PIXEL (f
) = fg
;
1353 if (FRAME_W32_WINDOW (f
) != 0)
1355 if (x
->cursor_pixel
== old_fg
)
1356 x
->cursor_pixel
= fg
;
1358 update_face_from_frame_parameter (f
, Qforeground_color
, arg
);
1359 if (FRAME_VISIBLE_P (f
))
1365 x_set_background_color (f
, arg
, oldval
)
1367 Lisp_Object arg
, oldval
;
1369 FRAME_BACKGROUND_PIXEL (f
)
1370 = x_decode_color (f
, arg
, WHITE_PIX_DEFAULT (f
));
1372 if (FRAME_W32_WINDOW (f
) != 0)
1374 SetWindowLong (FRAME_W32_WINDOW (f
), WND_BACKGROUND_INDEX
,
1375 FRAME_BACKGROUND_PIXEL (f
));
1377 update_face_from_frame_parameter (f
, Qbackground_color
, arg
);
1379 if (FRAME_VISIBLE_P (f
))
1385 x_set_mouse_color (f
, arg
, oldval
)
1387 Lisp_Object arg
, oldval
;
1389 Cursor cursor
, nontext_cursor
, mode_cursor
, hand_cursor
;
1393 if (!EQ (Qnil
, arg
))
1394 f
->output_data
.w32
->mouse_pixel
1395 = x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1396 mask_color
= FRAME_BACKGROUND_PIXEL (f
);
1398 /* Don't let pointers be invisible. */
1399 if (mask_color
== f
->output_data
.w32
->mouse_pixel
1400 && mask_color
== FRAME_BACKGROUND_PIXEL (f
))
1401 f
->output_data
.w32
->mouse_pixel
= FRAME_FOREGROUND_PIXEL (f
);
1403 #if 0 /* TODO : Mouse cursor customization. */
1406 /* It's not okay to crash if the user selects a screwy cursor. */
1407 count
= x_catch_errors (FRAME_W32_DISPLAY (f
));
1409 if (!EQ (Qnil
, Vx_pointer_shape
))
1411 CHECK_NUMBER (Vx_pointer_shape
);
1412 cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XINT (Vx_pointer_shape
));
1415 cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_xterm
);
1416 x_check_errors (FRAME_W32_DISPLAY (f
), "bad text pointer cursor: %s");
1418 if (!EQ (Qnil
, Vx_nontext_pointer_shape
))
1420 CHECK_NUMBER (Vx_nontext_pointer_shape
);
1421 nontext_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1422 XINT (Vx_nontext_pointer_shape
));
1425 nontext_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_left_ptr
);
1426 x_check_errors (FRAME_W32_DISPLAY (f
), "bad nontext pointer cursor: %s");
1428 if (!EQ (Qnil
, Vx_hourglass_pointer_shape
))
1430 CHECK_NUMBER (Vx_hourglass_pointer_shape
);
1431 hourglass_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1432 XINT (Vx_hourglass_pointer_shape
));
1435 hourglass_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_watch
);
1436 x_check_errors (FRAME_W32_DISPLAY (f
), "bad busy pointer cursor: %s");
1438 x_check_errors (FRAME_W32_DISPLAY (f
), "bad nontext pointer cursor: %s");
1439 if (!EQ (Qnil
, Vx_mode_pointer_shape
))
1441 CHECK_NUMBER (Vx_mode_pointer_shape
);
1442 mode_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1443 XINT (Vx_mode_pointer_shape
));
1446 mode_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_xterm
);
1447 x_check_errors (FRAME_W32_DISPLAY (f
), "bad modeline pointer cursor: %s");
1449 if (!EQ (Qnil
, Vx_sensitive_text_pointer_shape
))
1451 CHECK_NUMBER (Vx_sensitive_text_pointer_shape
);
1453 = XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1454 XINT (Vx_sensitive_text_pointer_shape
));
1457 hand_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_crosshair
);
1459 if (!NILP (Vx_window_horizontal_drag_shape
))
1461 CHECK_NUMBER (Vx_window_horizontal_drag_shape
);
1462 horizontal_drag_cursor
1463 = XCreateFontCursor (FRAME_X_DISPLAY (f
),
1464 XINT (Vx_window_horizontal_drag_shape
));
1467 horizontal_drag_cursor
1468 = XCreateFontCursor (FRAME_X_DISPLAY (f
), XC_sb_h_double_arrow
);
1470 /* Check and report errors with the above calls. */
1471 x_check_errors (FRAME_W32_DISPLAY (f
), "can't set cursor shape: %s");
1472 x_uncatch_errors (FRAME_W32_DISPLAY (f
), count
);
1475 XColor fore_color
, back_color
;
1477 fore_color
.pixel
= f
->output_data
.w32
->mouse_pixel
;
1478 back_color
.pixel
= mask_color
;
1479 XQueryColor (FRAME_W32_DISPLAY (f
),
1480 DefaultColormap (FRAME_W32_DISPLAY (f
),
1481 DefaultScreen (FRAME_W32_DISPLAY (f
))),
1483 XQueryColor (FRAME_W32_DISPLAY (f
),
1484 DefaultColormap (FRAME_W32_DISPLAY (f
),
1485 DefaultScreen (FRAME_W32_DISPLAY (f
))),
1487 XRecolorCursor (FRAME_W32_DISPLAY (f
), cursor
,
1488 &fore_color
, &back_color
);
1489 XRecolorCursor (FRAME_W32_DISPLAY (f
), nontext_cursor
,
1490 &fore_color
, &back_color
);
1491 XRecolorCursor (FRAME_W32_DISPLAY (f
), mode_cursor
,
1492 &fore_color
, &back_color
);
1493 XRecolorCursor (FRAME_W32_DISPLAY (f
), hand_cursor
,
1494 &fore_color
, &back_color
);
1495 XRecolorCursor (FRAME_W32_DISPLAY (f
), hourglass_cursor
,
1496 &fore_color
, &back_color
);
1499 if (FRAME_W32_WINDOW (f
) != 0)
1500 XDefineCursor (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
), cursor
);
1502 if (cursor
!= f
->output_data
.w32
->text_cursor
&& f
->output_data
.w32
->text_cursor
!= 0)
1503 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->text_cursor
);
1504 f
->output_data
.w32
->text_cursor
= cursor
;
1506 if (nontext_cursor
!= f
->output_data
.w32
->nontext_cursor
1507 && f
->output_data
.w32
->nontext_cursor
!= 0)
1508 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->nontext_cursor
);
1509 f
->output_data
.w32
->nontext_cursor
= nontext_cursor
;
1511 if (hourglass_cursor
!= f
->output_data
.w32
->hourglass_cursor
1512 && f
->output_data
.w32
->hourglass_cursor
!= 0)
1513 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->hourglass_cursor
);
1514 f
->output_data
.w32
->hourglass_cursor
= hourglass_cursor
;
1516 if (mode_cursor
!= f
->output_data
.w32
->modeline_cursor
1517 && f
->output_data
.w32
->modeline_cursor
!= 0)
1518 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->modeline_cursor
);
1519 f
->output_data
.w32
->modeline_cursor
= mode_cursor
;
1521 if (hand_cursor
!= f
->output_data
.w32
->hand_cursor
1522 && f
->output_data
.w32
->hand_cursor
!= 0)
1523 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->hand_cursor
);
1524 f
->output_data
.w32
->hand_cursor
= hand_cursor
;
1526 XFlush (FRAME_W32_DISPLAY (f
));
1529 update_face_from_frame_parameter (f
, Qmouse_color
, arg
);
1534 x_set_cursor_color (f
, arg
, oldval
)
1536 Lisp_Object arg
, oldval
;
1538 unsigned long fore_pixel
, pixel
;
1540 if (!NILP (Vx_cursor_fore_pixel
))
1541 fore_pixel
= x_decode_color (f
, Vx_cursor_fore_pixel
,
1542 WHITE_PIX_DEFAULT (f
));
1544 fore_pixel
= FRAME_BACKGROUND_PIXEL (f
);
1546 pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1548 /* Make sure that the cursor color differs from the background color. */
1549 if (pixel
== FRAME_BACKGROUND_PIXEL (f
))
1551 pixel
= f
->output_data
.w32
->mouse_pixel
;
1552 if (pixel
== fore_pixel
)
1553 fore_pixel
= FRAME_BACKGROUND_PIXEL (f
);
1556 f
->output_data
.w32
->cursor_foreground_pixel
= fore_pixel
;
1557 f
->output_data
.w32
->cursor_pixel
= pixel
;
1559 if (FRAME_W32_WINDOW (f
) != 0)
1562 /* Update frame's cursor_gc. */
1563 f
->output_data
.w32
->cursor_gc
->foreground
= fore_pixel
;
1564 f
->output_data
.w32
->cursor_gc
->background
= pixel
;
1568 if (FRAME_VISIBLE_P (f
))
1570 x_update_cursor (f
, 0);
1571 x_update_cursor (f
, 1);
1575 update_face_from_frame_parameter (f
, Qcursor_color
, arg
);
1578 /* Set the border-color of frame F to pixel value PIX.
1579 Note that this does not fully take effect if done before
1583 x_set_border_pixel (f
, pix
)
1588 f
->output_data
.w32
->border_pixel
= pix
;
1590 if (FRAME_W32_WINDOW (f
) != 0 && f
->border_width
> 0)
1592 if (FRAME_VISIBLE_P (f
))
1597 /* Set the border-color of frame F to value described by ARG.
1598 ARG can be a string naming a color.
1599 The border-color is used for the border that is drawn by the server.
1600 Note that this does not fully take effect if done before
1601 F has a window; it must be redone when the window is created. */
1604 x_set_border_color (f
, arg
, oldval
)
1606 Lisp_Object arg
, oldval
;
1611 pix
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1612 x_set_border_pixel (f
, pix
);
1613 update_face_from_frame_parameter (f
, Qborder_color
, arg
);
1618 x_set_cursor_type (f
, arg
, oldval
)
1620 Lisp_Object arg
, oldval
;
1622 set_frame_cursor_types (f
, arg
);
1624 /* Make sure the cursor gets redrawn. */
1625 cursor_type_changed
= 1;
1629 x_set_icon_type (f
, arg
, oldval
)
1631 Lisp_Object arg
, oldval
;
1635 if (NILP (arg
) && NILP (oldval
))
1638 if (STRINGP (arg
) && STRINGP (oldval
)
1639 && EQ (Fstring_equal (oldval
, arg
), Qt
))
1642 if (SYMBOLP (arg
) && SYMBOLP (oldval
) && EQ (arg
, oldval
))
1647 result
= x_bitmap_icon (f
, arg
);
1651 error ("No icon window available");
1658 x_set_icon_name (f
, arg
, oldval
)
1660 Lisp_Object arg
, oldval
;
1664 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1667 else if (!NILP (arg
) || NILP (oldval
))
1673 if (f
->output_data
.w32
->icon_bitmap
!= 0)
1678 result
= x_text_icon (f
,
1679 (char *) SDATA ((!NILP (f
->icon_name
)
1688 error ("No icon window available");
1691 /* If the window was unmapped (and its icon was mapped),
1692 the new icon is not mapped, so map the window in its stead. */
1693 if (FRAME_VISIBLE_P (f
))
1695 #ifdef USE_X_TOOLKIT
1696 XtPopup (f
->output_data
.w32
->widget
, XtGrabNone
);
1698 XMapWindow (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
));
1701 XFlush (FRAME_W32_DISPLAY (f
));
1708 x_set_menu_bar_lines (f
, value
, oldval
)
1710 Lisp_Object value
, oldval
;
1713 int olines
= FRAME_MENU_BAR_LINES (f
);
1715 /* Right now, menu bars don't work properly in minibuf-only frames;
1716 most of the commands try to apply themselves to the minibuffer
1717 frame itself, and get an error because you can't switch buffers
1718 in or split the minibuffer window. */
1719 if (FRAME_MINIBUF_ONLY_P (f
))
1722 if (INTEGERP (value
))
1723 nlines
= XINT (value
);
1727 FRAME_MENU_BAR_LINES (f
) = 0;
1729 FRAME_EXTERNAL_MENU_BAR (f
) = 1;
1732 if (FRAME_EXTERNAL_MENU_BAR (f
) == 1)
1733 free_frame_menubar (f
);
1734 FRAME_EXTERNAL_MENU_BAR (f
) = 0;
1736 /* Adjust the frame size so that the client (text) dimensions
1737 remain the same. This depends on FRAME_EXTERNAL_MENU_BAR being
1739 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1740 do_pending_window_change (0);
1746 /* Set the number of lines used for the tool bar of frame F to VALUE.
1747 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1748 is the old number of tool bar lines. This function changes the
1749 height of all windows on frame F to match the new tool bar height.
1750 The frame's height doesn't change. */
1753 x_set_tool_bar_lines (f
, value
, oldval
)
1755 Lisp_Object value
, oldval
;
1757 int delta
, nlines
, root_height
;
1758 Lisp_Object root_window
;
1760 /* Treat tool bars like menu bars. */
1761 if (FRAME_MINIBUF_ONLY_P (f
))
1764 /* Use VALUE only if an integer >= 0. */
1765 if (INTEGERP (value
) && XINT (value
) >= 0)
1766 nlines
= XFASTINT (value
);
1770 /* Make sure we redisplay all windows in this frame. */
1771 ++windows_or_buffers_changed
;
1773 delta
= nlines
- FRAME_TOOL_BAR_LINES (f
);
1775 /* Don't resize the tool-bar to more than we have room for. */
1776 root_window
= FRAME_ROOT_WINDOW (f
);
1777 root_height
= WINDOW_TOTAL_LINES (XWINDOW (root_window
));
1778 if (root_height
- delta
< 1)
1780 delta
= root_height
- 1;
1781 nlines
= FRAME_TOOL_BAR_LINES (f
) + delta
;
1784 FRAME_TOOL_BAR_LINES (f
) = nlines
;
1785 change_window_heights (root_window
, delta
);
1788 /* We also have to make sure that the internal border at the top of
1789 the frame, below the menu bar or tool bar, is redrawn when the
1790 tool bar disappears. This is so because the internal border is
1791 below the tool bar if one is displayed, but is below the menu bar
1792 if there isn't a tool bar. The tool bar draws into the area
1793 below the menu bar. */
1794 if (FRAME_W32_WINDOW (f
) && FRAME_TOOL_BAR_LINES (f
) == 0)
1797 clear_current_matrices (f
);
1800 /* If the tool bar gets smaller, the internal border below it
1801 has to be cleared. It was formerly part of the display
1802 of the larger tool bar, and updating windows won't clear it. */
1805 int height
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1806 int width
= FRAME_PIXEL_WIDTH (f
);
1807 int y
= nlines
* FRAME_LINE_HEIGHT (f
);
1811 HDC hdc
= get_frame_dc (f
);
1812 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
1813 release_frame_dc (f
, hdc
);
1817 if (WINDOWP (f
->tool_bar_window
))
1818 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1823 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1826 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1827 name; if NAME is a string, set F's name to NAME and set
1828 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1830 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1831 suggesting a new name, which lisp code should override; if
1832 F->explicit_name is set, ignore the new name; otherwise, set it. */
1835 x_set_name (f
, name
, explicit)
1840 /* Make sure that requests from lisp code override requests from
1841 Emacs redisplay code. */
1844 /* If we're switching from explicit to implicit, we had better
1845 update the mode lines and thereby update the title. */
1846 if (f
->explicit_name
&& NILP (name
))
1847 update_mode_lines
= 1;
1849 f
->explicit_name
= ! NILP (name
);
1851 else if (f
->explicit_name
)
1854 /* If NAME is nil, set the name to the w32_id_name. */
1857 /* Check for no change needed in this very common case
1858 before we do any consing. */
1859 if (!strcmp (FRAME_W32_DISPLAY_INFO (f
)->w32_id_name
,
1862 name
= build_string (FRAME_W32_DISPLAY_INFO (f
)->w32_id_name
);
1865 CHECK_STRING (name
);
1867 /* Don't change the name if it's already NAME. */
1868 if (! NILP (Fstring_equal (name
, f
->name
)))
1873 /* For setting the frame title, the title parameter should override
1874 the name parameter. */
1875 if (! NILP (f
->title
))
1878 if (FRAME_W32_WINDOW (f
))
1880 if (STRING_MULTIBYTE (name
))
1881 name
= ENCODE_SYSTEM (name
);
1884 SetWindowText (FRAME_W32_WINDOW (f
), SDATA (name
));
1889 /* This function should be called when the user's lisp code has
1890 specified a name for the frame; the name will override any set by the
1893 x_explicitly_set_name (f
, arg
, oldval
)
1895 Lisp_Object arg
, oldval
;
1897 x_set_name (f
, arg
, 1);
1900 /* This function should be called by Emacs redisplay code to set the
1901 name; names set this way will never override names set by the user's
1904 x_implicitly_set_name (f
, arg
, oldval
)
1906 Lisp_Object arg
, oldval
;
1908 x_set_name (f
, arg
, 0);
1911 /* Change the title of frame F to NAME.
1912 If NAME is nil, use the frame name as the title. */
1915 x_set_title (f
, name
, old_name
)
1917 Lisp_Object name
, old_name
;
1919 /* Don't change the title if it's already NAME. */
1920 if (EQ (name
, f
->title
))
1923 update_mode_lines
= 1;
1930 if (FRAME_W32_WINDOW (f
))
1932 if (STRING_MULTIBYTE (name
))
1933 name
= ENCODE_SYSTEM (name
);
1936 SetWindowText (FRAME_W32_WINDOW (f
), SDATA (name
));
1942 void x_set_scroll_bar_default_width (f
)
1945 int wid
= FRAME_COLUMN_WIDTH (f
);
1947 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = GetSystemMetrics (SM_CXVSCROLL
);
1948 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) +
1953 /* Subroutines for creating a frame. */
1956 w32_load_cursor (LPCTSTR name
)
1958 /* Try first to load cursor from application resource. */
1959 Cursor cursor
= LoadImage ((HINSTANCE
) GetModuleHandle (NULL
),
1960 name
, IMAGE_CURSOR
, 0, 0,
1961 LR_DEFAULTCOLOR
| LR_DEFAULTSIZE
| LR_SHARED
);
1964 /* Then try to load a shared predefined cursor. */
1965 cursor
= LoadImage (NULL
, name
, IMAGE_CURSOR
, 0, 0,
1966 LR_DEFAULTCOLOR
| LR_DEFAULTSIZE
| LR_SHARED
);
1971 extern LRESULT CALLBACK
w32_wnd_proc ();
1974 w32_init_class (hinst
)
1979 wc
.style
= CS_HREDRAW
| CS_VREDRAW
;
1980 wc
.lpfnWndProc
= (WNDPROC
) w32_wnd_proc
;
1982 wc
.cbWndExtra
= WND_EXTRA_BYTES
;
1983 wc
.hInstance
= hinst
;
1984 wc
.hIcon
= LoadIcon (hinst
, EMACS_CLASS
);
1985 wc
.hCursor
= w32_load_cursor (IDC_ARROW
);
1986 wc
.hbrBackground
= NULL
; /* GetStockObject (WHITE_BRUSH); */
1987 wc
.lpszMenuName
= NULL
;
1988 wc
.lpszClassName
= EMACS_CLASS
;
1990 return (RegisterClass (&wc
));
1994 w32_createscrollbar (f
, bar
)
1996 struct scroll_bar
* bar
;
1998 return (CreateWindow ("SCROLLBAR", "", SBS_VERT
| WS_CHILD
| WS_VISIBLE
,
1999 /* Position and size of scroll bar. */
2000 XINT (bar
->left
) + VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
2002 XINT (bar
->width
) - VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
2004 FRAME_W32_WINDOW (f
),
2011 w32_createwindow (f
)
2016 Lisp_Object top
= Qunbound
;
2017 Lisp_Object left
= Qunbound
;
2018 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
2020 rect
.left
= rect
.top
= 0;
2021 rect
.right
= FRAME_PIXEL_WIDTH (f
);
2022 rect
.bottom
= FRAME_PIXEL_HEIGHT (f
);
2024 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
2025 FRAME_EXTERNAL_MENU_BAR (f
));
2027 /* Do first time app init */
2031 w32_init_class (hinst
);
2034 if (f
->size_hint_flags
& USPosition
|| f
->size_hint_flags
& PPosition
)
2036 XSETINT (left
, f
->left_pos
);
2037 XSETINT (top
, f
->top_pos
);
2039 else if (EQ (left
, Qunbound
) && EQ (top
, Qunbound
))
2041 /* When called with RES_TYPE_NUMBER, w32_get_arg will return zero
2042 for anything that is not a number and is not Qunbound. */
2043 left
= x_get_arg (dpyinfo
, Qnil
, Qleft
, "left", "Left", RES_TYPE_NUMBER
);
2044 top
= x_get_arg (dpyinfo
, Qnil
, Qtop
, "top", "Top", RES_TYPE_NUMBER
);
2047 FRAME_W32_WINDOW (f
) = hwnd
2048 = CreateWindow (EMACS_CLASS
,
2050 f
->output_data
.w32
->dwStyle
| WS_CLIPCHILDREN
,
2051 EQ (left
, Qunbound
) ? CW_USEDEFAULT
: XINT (left
),
2052 EQ (top
, Qunbound
) ? CW_USEDEFAULT
: XINT (top
),
2053 rect
.right
- rect
.left
,
2054 rect
.bottom
- rect
.top
,
2062 SetWindowLong (hwnd
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
2063 SetWindowLong (hwnd
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
2064 SetWindowLong (hwnd
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
2065 SetWindowLong (hwnd
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
2066 SetWindowLong (hwnd
, WND_BACKGROUND_INDEX
, FRAME_BACKGROUND_PIXEL (f
));
2068 /* Enable drag-n-drop. */
2069 DragAcceptFiles (hwnd
, TRUE
);
2071 /* Do this to discard the default setting specified by our parent. */
2072 ShowWindow (hwnd
, SW_HIDE
);
2074 /* Update frame positions. */
2075 GetWindowRect (hwnd
, &rect
);
2076 f
->left_pos
= rect
.left
;
2077 f
->top_pos
= rect
.top
;
2082 my_post_msg (wmsg
, hwnd
, msg
, wParam
, lParam
)
2089 wmsg
->msg
.hwnd
= hwnd
;
2090 wmsg
->msg
.message
= msg
;
2091 wmsg
->msg
.wParam
= wParam
;
2092 wmsg
->msg
.lParam
= lParam
;
2093 wmsg
->msg
.time
= GetMessageTime ();
2098 /* GetKeyState and MapVirtualKey on Windows 95 do not actually distinguish
2099 between left and right keys as advertised. We test for this
2100 support dynamically, and set a flag when the support is absent. If
2101 absent, we keep track of the left and right control and alt keys
2102 ourselves. This is particularly necessary on keyboards that rely
2103 upon the AltGr key, which is represented as having the left control
2104 and right alt keys pressed. For these keyboards, we need to know
2105 when the left alt key has been pressed in addition to the AltGr key
2106 so that we can properly support M-AltGr-key sequences (such as M-@
2107 on Swedish keyboards). */
2109 #define EMACS_LCONTROL 0
2110 #define EMACS_RCONTROL 1
2111 #define EMACS_LMENU 2
2112 #define EMACS_RMENU 3
2114 static int modifiers
[4];
2115 static int modifiers_recorded
;
2116 static int modifier_key_support_tested
;
2119 test_modifier_support (unsigned int wparam
)
2123 if (wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
)
2125 if (wparam
== VK_CONTROL
)
2135 if (!(GetKeyState (l
) & 0x8000) && !(GetKeyState (r
) & 0x8000))
2136 modifiers_recorded
= 1;
2138 modifiers_recorded
= 0;
2139 modifier_key_support_tested
= 1;
2143 record_keydown (unsigned int wparam
, unsigned int lparam
)
2147 if (!modifier_key_support_tested
)
2148 test_modifier_support (wparam
);
2150 if ((wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
) || !modifiers_recorded
)
2153 if (wparam
== VK_CONTROL
)
2154 i
= (lparam
& 0x1000000) ? EMACS_RCONTROL
: EMACS_LCONTROL
;
2156 i
= (lparam
& 0x1000000) ? EMACS_RMENU
: EMACS_LMENU
;
2162 record_keyup (unsigned int wparam
, unsigned int lparam
)
2166 if ((wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
) || !modifiers_recorded
)
2169 if (wparam
== VK_CONTROL
)
2170 i
= (lparam
& 0x1000000) ? EMACS_RCONTROL
: EMACS_LCONTROL
;
2172 i
= (lparam
& 0x1000000) ? EMACS_RMENU
: EMACS_LMENU
;
2177 /* Emacs can lose focus while a modifier key has been pressed. When
2178 it regains focus, be conservative and clear all modifiers since
2179 we cannot reconstruct the left and right modifier state. */
2185 if (GetFocus () == NULL
)
2186 /* Emacs doesn't have keyboard focus. Do nothing. */
2189 ctrl
= GetAsyncKeyState (VK_CONTROL
);
2190 alt
= GetAsyncKeyState (VK_MENU
);
2192 if (!(ctrl
& 0x08000))
2193 /* Clear any recorded control modifier state. */
2194 modifiers
[EMACS_RCONTROL
] = modifiers
[EMACS_LCONTROL
] = 0;
2196 if (!(alt
& 0x08000))
2197 /* Clear any recorded alt modifier state. */
2198 modifiers
[EMACS_RMENU
] = modifiers
[EMACS_LMENU
] = 0;
2200 /* Update the state of all modifier keys, because modifiers used in
2201 hot-key combinations can get stuck on if Emacs loses focus as a
2202 result of a hot-key being pressed. */
2206 #define CURRENT_STATE(key) ((GetAsyncKeyState (key) & 0x8000) >> 8)
2208 GetKeyboardState (keystate
);
2209 keystate
[VK_SHIFT
] = CURRENT_STATE (VK_SHIFT
);
2210 keystate
[VK_CONTROL
] = CURRENT_STATE (VK_CONTROL
);
2211 keystate
[VK_LCONTROL
] = CURRENT_STATE (VK_LCONTROL
);
2212 keystate
[VK_RCONTROL
] = CURRENT_STATE (VK_RCONTROL
);
2213 keystate
[VK_MENU
] = CURRENT_STATE (VK_MENU
);
2214 keystate
[VK_LMENU
] = CURRENT_STATE (VK_LMENU
);
2215 keystate
[VK_RMENU
] = CURRENT_STATE (VK_RMENU
);
2216 keystate
[VK_LWIN
] = CURRENT_STATE (VK_LWIN
);
2217 keystate
[VK_RWIN
] = CURRENT_STATE (VK_RWIN
);
2218 keystate
[VK_APPS
] = CURRENT_STATE (VK_APPS
);
2219 SetKeyboardState (keystate
);
2223 /* Synchronize modifier state with what is reported with the current
2224 keystroke. Even if we cannot distinguish between left and right
2225 modifier keys, we know that, if no modifiers are set, then neither
2226 the left or right modifier should be set. */
2230 if (!modifiers_recorded
)
2233 if (!(GetKeyState (VK_CONTROL
) & 0x8000))
2234 modifiers
[EMACS_RCONTROL
] = modifiers
[EMACS_LCONTROL
] = 0;
2236 if (!(GetKeyState (VK_MENU
) & 0x8000))
2237 modifiers
[EMACS_RMENU
] = modifiers
[EMACS_LMENU
] = 0;
2241 modifier_set (int vkey
)
2243 if (vkey
== VK_CAPITAL
|| vkey
== VK_SCROLL
)
2244 return (GetKeyState (vkey
) & 0x1);
2245 if (!modifiers_recorded
)
2246 return (GetKeyState (vkey
) & 0x8000);
2251 return modifiers
[EMACS_LCONTROL
];
2253 return modifiers
[EMACS_RCONTROL
];
2255 return modifiers
[EMACS_LMENU
];
2257 return modifiers
[EMACS_RMENU
];
2259 return (GetKeyState (vkey
) & 0x8000);
2262 /* Convert between the modifier bits W32 uses and the modifier bits
2266 w32_key_to_modifier (int key
)
2268 Lisp_Object key_mapping
;
2273 key_mapping
= Vw32_lwindow_modifier
;
2276 key_mapping
= Vw32_rwindow_modifier
;
2279 key_mapping
= Vw32_apps_modifier
;
2282 key_mapping
= Vw32_scroll_lock_modifier
;
2288 /* NB. This code runs in the input thread, asychronously to the lisp
2289 thread, so we must be careful to ensure access to lisp data is
2290 thread-safe. The following code is safe because the modifier
2291 variable values are updated atomically from lisp and symbols are
2292 not relocated by GC. Also, we don't have to worry about seeing GC
2294 if (EQ (key_mapping
, Qhyper
))
2295 return hyper_modifier
;
2296 if (EQ (key_mapping
, Qsuper
))
2297 return super_modifier
;
2298 if (EQ (key_mapping
, Qmeta
))
2299 return meta_modifier
;
2300 if (EQ (key_mapping
, Qalt
))
2301 return alt_modifier
;
2302 if (EQ (key_mapping
, Qctrl
))
2303 return ctrl_modifier
;
2304 if (EQ (key_mapping
, Qcontrol
)) /* synonym for ctrl */
2305 return ctrl_modifier
;
2306 if (EQ (key_mapping
, Qshift
))
2307 return shift_modifier
;
2309 /* Don't generate any modifier if not explicitly requested. */
2314 w32_get_modifiers ()
2316 return ((modifier_set (VK_SHIFT
) ? shift_modifier
: 0) |
2317 (modifier_set (VK_CONTROL
) ? ctrl_modifier
: 0) |
2318 (modifier_set (VK_LWIN
) ? w32_key_to_modifier (VK_LWIN
) : 0) |
2319 (modifier_set (VK_RWIN
) ? w32_key_to_modifier (VK_RWIN
) : 0) |
2320 (modifier_set (VK_APPS
) ? w32_key_to_modifier (VK_APPS
) : 0) |
2321 (modifier_set (VK_SCROLL
) ? w32_key_to_modifier (VK_SCROLL
) : 0) |
2322 (modifier_set (VK_MENU
) ?
2323 ((NILP (Vw32_alt_is_meta
)) ? alt_modifier
: meta_modifier
) : 0));
2326 /* We map the VK_* modifiers into console modifier constants
2327 so that we can use the same routines to handle both console
2328 and window input. */
2331 construct_console_modifiers ()
2336 mods
|= (modifier_set (VK_SHIFT
)) ? SHIFT_PRESSED
: 0;
2337 mods
|= (modifier_set (VK_CAPITAL
)) ? CAPSLOCK_ON
: 0;
2338 mods
|= (modifier_set (VK_SCROLL
)) ? SCROLLLOCK_ON
: 0;
2339 mods
|= (modifier_set (VK_NUMLOCK
)) ? NUMLOCK_ON
: 0;
2340 mods
|= (modifier_set (VK_LCONTROL
)) ? LEFT_CTRL_PRESSED
: 0;
2341 mods
|= (modifier_set (VK_RCONTROL
)) ? RIGHT_CTRL_PRESSED
: 0;
2342 mods
|= (modifier_set (VK_LMENU
)) ? LEFT_ALT_PRESSED
: 0;
2343 mods
|= (modifier_set (VK_RMENU
)) ? RIGHT_ALT_PRESSED
: 0;
2344 mods
|= (modifier_set (VK_LWIN
)) ? LEFT_WIN_PRESSED
: 0;
2345 mods
|= (modifier_set (VK_RWIN
)) ? RIGHT_WIN_PRESSED
: 0;
2346 mods
|= (modifier_set (VK_APPS
)) ? APPS_PRESSED
: 0;
2352 w32_get_key_modifiers (unsigned int wparam
, unsigned int lparam
)
2356 /* Convert to emacs modifiers. */
2357 mods
= w32_kbd_mods_to_emacs (construct_console_modifiers (), wparam
);
2363 map_keypad_keys (unsigned int virt_key
, unsigned int extended
)
2365 if (virt_key
< VK_CLEAR
|| virt_key
> VK_DELETE
)
2368 if (virt_key
== VK_RETURN
)
2369 return (extended
? VK_NUMPAD_ENTER
: VK_RETURN
);
2371 if (virt_key
>= VK_PRIOR
&& virt_key
<= VK_DOWN
)
2372 return (!extended
? (VK_NUMPAD_PRIOR
+ (virt_key
- VK_PRIOR
)) : virt_key
);
2374 if (virt_key
== VK_INSERT
|| virt_key
== VK_DELETE
)
2375 return (!extended
? (VK_NUMPAD_INSERT
+ (virt_key
- VK_INSERT
)) : virt_key
);
2377 if (virt_key
== VK_CLEAR
)
2378 return (!extended
? VK_NUMPAD_CLEAR
: virt_key
);
2383 /* List of special key combinations which w32 would normally capture,
2384 but Emacs should grab instead. Not directly visible to lisp, to
2385 simplify synchronization. Each item is an integer encoding a virtual
2386 key code and modifier combination to capture. */
2387 static Lisp_Object w32_grabbed_keys
;
2389 #define HOTKEY(vk, mods) make_number (((vk) & 255) | ((mods) << 8))
2390 #define HOTKEY_ID(k) (XFASTINT (k) & 0xbfff)
2391 #define HOTKEY_VK_CODE(k) (XFASTINT (k) & 255)
2392 #define HOTKEY_MODIFIERS(k) (XFASTINT (k) >> 8)
2394 #define RAW_HOTKEY_ID(k) ((k) & 0xbfff)
2395 #define RAW_HOTKEY_VK_CODE(k) ((k) & 255)
2396 #define RAW_HOTKEY_MODIFIERS(k) ((k) >> 8)
2398 /* Register hot-keys for reserved key combinations when Emacs has
2399 keyboard focus, since this is the only way Emacs can receive key
2400 combinations like Alt-Tab which are used by the system. */
2403 register_hot_keys (hwnd
)
2406 Lisp_Object keylist
;
2408 /* Use CONSP, since we are called asynchronously. */
2409 for (keylist
= w32_grabbed_keys
; CONSP (keylist
); keylist
= XCDR (keylist
))
2411 Lisp_Object key
= XCAR (keylist
);
2413 /* Deleted entries get set to nil. */
2414 if (!INTEGERP (key
))
2417 RegisterHotKey (hwnd
, HOTKEY_ID (key
),
2418 HOTKEY_MODIFIERS (key
), HOTKEY_VK_CODE (key
));
2423 unregister_hot_keys (hwnd
)
2426 Lisp_Object keylist
;
2428 for (keylist
= w32_grabbed_keys
; CONSP (keylist
); keylist
= XCDR (keylist
))
2430 Lisp_Object key
= XCAR (keylist
);
2432 if (!INTEGERP (key
))
2435 UnregisterHotKey (hwnd
, HOTKEY_ID (key
));
2439 /* Main message dispatch loop. */
2442 w32_msg_pump (deferred_msg
* msg_buf
)
2448 msh_mousewheel
= RegisterWindowMessage (MSH_MOUSEWHEEL
);
2450 while (GetMessage (&msg
, NULL
, 0, 0))
2452 if (msg
.hwnd
== NULL
)
2454 switch (msg
.message
)
2457 /* Produced by complete_deferred_msg; just ignore. */
2459 case WM_EMACS_CREATEWINDOW
:
2460 /* Initialize COM for this window. Even though we don't use it,
2461 some third party shell extensions can cause it to be used in
2462 system dialogs, which causes a crash if it is not initialized.
2463 This is a known bug in Windows, which was fixed long ago, but
2464 the patch for XP is not publically available until XP SP3,
2465 and older versions will never be patched. */
2466 CoInitialize (NULL
);
2467 w32_createwindow ((struct frame
*) msg
.wParam
);
2468 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2471 case WM_EMACS_SETLOCALE
:
2472 SetThreadLocale (msg
.wParam
);
2473 /* Reply is not expected. */
2475 case WM_EMACS_SETKEYBOARDLAYOUT
:
2476 result
= (int) ActivateKeyboardLayout ((HKL
) msg
.wParam
, 0);
2477 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
,
2481 case WM_EMACS_REGISTER_HOT_KEY
:
2482 focus_window
= GetFocus ();
2483 if (focus_window
!= NULL
)
2484 RegisterHotKey (focus_window
,
2485 RAW_HOTKEY_ID (msg
.wParam
),
2486 RAW_HOTKEY_MODIFIERS (msg
.wParam
),
2487 RAW_HOTKEY_VK_CODE (msg
.wParam
));
2488 /* Reply is not expected. */
2490 case WM_EMACS_UNREGISTER_HOT_KEY
:
2491 focus_window
= GetFocus ();
2492 if (focus_window
!= NULL
)
2493 UnregisterHotKey (focus_window
, RAW_HOTKEY_ID (msg
.wParam
));
2494 /* Mark item as erased. NB: this code must be
2495 thread-safe. The next line is okay because the cons
2496 cell is never made into garbage and is not relocated by
2498 XSETCAR ((Lisp_Object
) ((EMACS_INT
) msg
.lParam
), Qnil
);
2499 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2502 case WM_EMACS_TOGGLE_LOCK_KEY
:
2504 int vk_code
= (int) msg
.wParam
;
2505 int cur_state
= (GetKeyState (vk_code
) & 1);
2506 Lisp_Object new_state
= (Lisp_Object
) ((EMACS_INT
) msg
.lParam
);
2508 /* NB: This code must be thread-safe. It is safe to
2509 call NILP because symbols are not relocated by GC,
2510 and pointer here is not touched by GC (so the markbit
2511 can't be set). Numbers are safe because they are
2512 immediate values. */
2513 if (NILP (new_state
)
2514 || (NUMBERP (new_state
)
2515 && ((XUINT (new_state
)) & 1) != cur_state
))
2517 one_w32_display_info
.faked_key
= vk_code
;
2519 keybd_event ((BYTE
) vk_code
,
2520 (BYTE
) MapVirtualKey (vk_code
, 0),
2521 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2522 keybd_event ((BYTE
) vk_code
,
2523 (BYTE
) MapVirtualKey (vk_code
, 0),
2524 KEYEVENTF_EXTENDEDKEY
| 0, 0);
2525 keybd_event ((BYTE
) vk_code
,
2526 (BYTE
) MapVirtualKey (vk_code
, 0),
2527 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2528 cur_state
= !cur_state
;
2530 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
,
2536 /* Broadcast messages make it here, so you need to be looking
2537 for something in particular for this to be useful. */
2539 DebPrint (("msg %x not expected by w32_msg_pump\n", msg
.message
));
2545 DispatchMessage (&msg
);
2548 /* Exit nested loop when our deferred message has completed. */
2549 if (msg_buf
->completed
)
2554 deferred_msg
* deferred_msg_head
;
2556 static deferred_msg
*
2557 find_deferred_msg (HWND hwnd
, UINT msg
)
2559 deferred_msg
* item
;
2561 /* Don't actually need synchronization for read access, since
2562 modification of single pointer is always atomic. */
2563 /* enter_crit (); */
2565 for (item
= deferred_msg_head
; item
!= NULL
; item
= item
->next
)
2566 if (item
->w32msg
.msg
.hwnd
== hwnd
2567 && item
->w32msg
.msg
.message
== msg
)
2570 /* leave_crit (); */
2576 send_deferred_msg (deferred_msg
* msg_buf
,
2582 /* Only input thread can send deferred messages. */
2583 if (GetCurrentThreadId () != dwWindowsThreadId
)
2586 /* It is an error to send a message that is already deferred. */
2587 if (find_deferred_msg (hwnd
, msg
) != NULL
)
2590 /* Enforced synchronization is not needed because this is the only
2591 function that alters deferred_msg_head, and the following critical
2592 section is guaranteed to only be serially reentered (since only the
2593 input thread can call us). */
2595 /* enter_crit (); */
2597 msg_buf
->completed
= 0;
2598 msg_buf
->next
= deferred_msg_head
;
2599 deferred_msg_head
= msg_buf
;
2600 my_post_msg (&msg_buf
->w32msg
, hwnd
, msg
, wParam
, lParam
);
2602 /* leave_crit (); */
2604 /* Start a new nested message loop to process other messages until
2605 this one is completed. */
2606 w32_msg_pump (msg_buf
);
2608 deferred_msg_head
= msg_buf
->next
;
2610 return msg_buf
->result
;
2614 complete_deferred_msg (HWND hwnd
, UINT msg
, LRESULT result
)
2616 deferred_msg
* msg_buf
= find_deferred_msg (hwnd
, msg
);
2618 if (msg_buf
== NULL
)
2619 /* Message may have been cancelled, so don't abort. */
2622 msg_buf
->result
= result
;
2623 msg_buf
->completed
= 1;
2625 /* Ensure input thread is woken so it notices the completion. */
2626 PostThreadMessage (dwWindowsThreadId
, WM_NULL
, 0, 0);
2630 cancel_all_deferred_msgs ()
2632 deferred_msg
* item
;
2634 /* Don't actually need synchronization for read access, since
2635 modification of single pointer is always atomic. */
2636 /* enter_crit (); */
2638 for (item
= deferred_msg_head
; item
!= NULL
; item
= item
->next
)
2641 item
->completed
= 1;
2644 /* leave_crit (); */
2646 /* Ensure input thread is woken so it notices the completion. */
2647 PostThreadMessage (dwWindowsThreadId
, WM_NULL
, 0, 0);
2651 w32_msg_worker (void *arg
)
2654 deferred_msg dummy_buf
;
2656 /* Ensure our message queue is created */
2658 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
2660 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2663 memset (&dummy_buf
, 0, sizeof (dummy_buf
));
2664 dummy_buf
.w32msg
.msg
.hwnd
= NULL
;
2665 dummy_buf
.w32msg
.msg
.message
= WM_NULL
;
2667 /* This is the initial message loop which should only exit when the
2668 application quits. */
2669 w32_msg_pump (&dummy_buf
);
2675 signal_user_input ()
2677 /* Interrupt any lisp that wants to be interrupted by input. */
2678 if (!NILP (Vthrow_on_input
))
2680 Vquit_flag
= Vthrow_on_input
;
2681 /* If we're inside a function that wants immediate quits,
2683 if (immediate_quit
&& NILP (Vinhibit_quit
))
2693 post_character_message (hwnd
, msg
, wParam
, lParam
, modifiers
)
2703 wmsg
.dwModifiers
= modifiers
;
2705 /* Detect quit_char and set quit-flag directly. Note that we
2706 still need to post a message to ensure the main thread will be
2707 woken up if blocked in sys_select, but we do NOT want to post
2708 the quit_char message itself (because it will usually be as if
2709 the user had typed quit_char twice). Instead, we post a dummy
2710 message that has no particular effect. */
2713 if (isalpha (c
) && wmsg
.dwModifiers
== ctrl_modifier
)
2714 c
= make_ctrl_char (c
) & 0377;
2716 || (wmsg
.dwModifiers
== 0 &&
2717 w32_quit_key
&& wParam
== w32_quit_key
))
2721 /* The choice of message is somewhat arbitrary, as long as
2722 the main thread handler just ignores it. */
2725 /* Interrupt any blocking system calls. */
2728 /* As a safety precaution, forcibly complete any deferred
2729 messages. This is a kludge, but I don't see any particularly
2730 clean way to handle the situation where a deferred message is
2731 "dropped" in the lisp thread, and will thus never be
2732 completed, eg. by the user trying to activate the menubar
2733 when the lisp thread is busy, and then typing C-g when the
2734 menubar doesn't open promptly (with the result that the
2735 menubar never responds at all because the deferred
2736 WM_INITMENU message is never completed). Another problem
2737 situation is when the lisp thread calls SendMessage (to send
2738 a window manager command) when a message has been deferred;
2739 the lisp thread gets blocked indefinitely waiting for the
2740 deferred message to be completed, which itself is waiting for
2741 the lisp thread to respond.
2743 Note that we don't want to block the input thread waiting for
2744 a reponse from the lisp thread (although that would at least
2745 solve the deadlock problem above), because we want to be able
2746 to receive C-g to interrupt the lisp thread. */
2747 cancel_all_deferred_msgs ();
2750 signal_user_input ();
2753 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2756 /* Main window procedure */
2759 w32_wnd_proc (hwnd
, msg
, wParam
, lParam
)
2766 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
2768 int windows_translate
;
2771 /* Note that it is okay to call x_window_to_frame, even though we are
2772 not running in the main lisp thread, because frame deletion
2773 requires the lisp thread to synchronize with this thread. Thus, if
2774 a frame struct is returned, it can be used without concern that the
2775 lisp thread might make it disappear while we are using it.
2777 NB. Walking the frame list in this thread is safe (as long as
2778 writes of Lisp_Object slots are atomic, which they are on Windows).
2779 Although delete-frame can destructively modify the frame list while
2780 we are walking it, a garbage collection cannot occur until after
2781 delete-frame has synchronized with this thread.
2783 It is also safe to use functions that make GDI calls, such as
2784 w32_clear_rect, because these functions must obtain a DC handle
2785 from the frame struct using get_frame_dc which is thread-aware. */
2790 f
= x_window_to_frame (dpyinfo
, hwnd
);
2793 HDC hdc
= get_frame_dc (f
);
2794 GetUpdateRect (hwnd
, &wmsg
.rect
, FALSE
);
2795 w32_clear_rect (f
, hdc
, &wmsg
.rect
);
2796 release_frame_dc (f
, hdc
);
2798 #if defined (W32_DEBUG_DISPLAY)
2799 DebPrint (("WM_ERASEBKGND (frame %p): erasing %d,%d-%d,%d\n",
2801 wmsg
.rect
.left
, wmsg
.rect
.top
,
2802 wmsg
.rect
.right
, wmsg
.rect
.bottom
));
2803 #endif /* W32_DEBUG_DISPLAY */
2806 case WM_PALETTECHANGED
:
2807 /* ignore our own changes */
2808 if ((HWND
)wParam
!= hwnd
)
2810 f
= x_window_to_frame (dpyinfo
, hwnd
);
2812 /* get_frame_dc will realize our palette and force all
2813 frames to be redrawn if needed. */
2814 release_frame_dc (f
, get_frame_dc (f
));
2819 PAINTSTRUCT paintStruct
;
2821 bzero (&update_rect
, sizeof (update_rect
));
2823 f
= x_window_to_frame (dpyinfo
, hwnd
);
2826 DebPrint (("WM_PAINT received for unknown window %p\n", hwnd
));
2830 /* MSDN Docs say not to call BeginPaint if GetUpdateRect
2831 fails. Apparently this can happen under some
2833 if (GetUpdateRect (hwnd
, &update_rect
, FALSE
) || !w32_strict_painting
)
2836 BeginPaint (hwnd
, &paintStruct
);
2838 /* The rectangles returned by GetUpdateRect and BeginPaint
2839 do not always match. Play it safe by assuming both areas
2841 UnionRect (&(wmsg
.rect
), &update_rect
, &(paintStruct
.rcPaint
));
2843 #if defined (W32_DEBUG_DISPLAY)
2844 DebPrint (("WM_PAINT (frame %p): painting %d,%d-%d,%d\n",
2846 wmsg
.rect
.left
, wmsg
.rect
.top
,
2847 wmsg
.rect
.right
, wmsg
.rect
.bottom
));
2848 DebPrint ((" [update region is %d,%d-%d,%d]\n",
2849 update_rect
.left
, update_rect
.top
,
2850 update_rect
.right
, update_rect
.bottom
));
2852 EndPaint (hwnd
, &paintStruct
);
2855 /* Change the message type to prevent Windows from
2856 combining WM_PAINT messages in the Lisp thread's queue,
2857 since Windows assumes that each message queue is
2858 dedicated to one frame and does not bother checking
2859 that hwnd matches before combining them. */
2860 my_post_msg (&wmsg
, hwnd
, WM_EMACS_PAINT
, wParam
, lParam
);
2865 /* If GetUpdateRect returns 0 (meaning there is no update
2866 region), assume the whole window needs to be repainted. */
2867 GetClientRect (hwnd
, &wmsg
.rect
);
2868 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2872 case WM_INPUTLANGCHANGE
:
2873 /* Inform lisp thread of keyboard layout changes. */
2874 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2876 /* Clear dead keys in the keyboard state; for simplicity only
2877 preserve modifier key states. */
2882 GetKeyboardState (keystate
);
2883 for (i
= 0; i
< 256; i
++)
2900 SetKeyboardState (keystate
);
2905 /* Synchronize hot keys with normal input. */
2906 PostMessage (hwnd
, WM_KEYDOWN
, HIWORD (lParam
), 0);
2911 record_keyup (wParam
, lParam
);
2916 /* Ignore keystrokes we fake ourself; see below. */
2917 if (dpyinfo
->faked_key
== wParam
)
2919 dpyinfo
->faked_key
= 0;
2920 /* Make sure TranslateMessage sees them though (as long as
2921 they don't produce WM_CHAR messages). This ensures that
2922 indicator lights are toggled promptly on Windows 9x, for
2924 if (wParam
< 256 && lispy_function_keys
[wParam
])
2926 windows_translate
= 1;
2932 /* Synchronize modifiers with current keystroke. */
2934 record_keydown (wParam
, lParam
);
2935 wParam
= map_keypad_keys (wParam
, (lParam
& 0x1000000L
) != 0);
2937 windows_translate
= 0;
2942 if (NILP (Vw32_pass_lwindow_to_system
))
2944 /* Prevent system from acting on keyup (which opens the
2945 Start menu if no other key was pressed) by simulating a
2946 press of Space which we will ignore. */
2947 if (GetAsyncKeyState (wParam
) & 1)
2949 if (NUMBERP (Vw32_phantom_key_code
))
2950 key
= XUINT (Vw32_phantom_key_code
) & 255;
2953 dpyinfo
->faked_key
= key
;
2954 keybd_event (key
, (BYTE
) MapVirtualKey (key
, 0), 0, 0);
2957 if (!NILP (Vw32_lwindow_modifier
))
2961 if (NILP (Vw32_pass_rwindow_to_system
))
2963 if (GetAsyncKeyState (wParam
) & 1)
2965 if (NUMBERP (Vw32_phantom_key_code
))
2966 key
= XUINT (Vw32_phantom_key_code
) & 255;
2969 dpyinfo
->faked_key
= key
;
2970 keybd_event (key
, (BYTE
) MapVirtualKey (key
, 0), 0, 0);
2973 if (!NILP (Vw32_rwindow_modifier
))
2977 if (!NILP (Vw32_apps_modifier
))
2981 if (NILP (Vw32_pass_alt_to_system
))
2982 /* Prevent DefWindowProc from activating the menu bar if an
2983 Alt key is pressed and released by itself. */
2985 windows_translate
= 1;
2988 /* Decide whether to treat as modifier or function key. */
2989 if (NILP (Vw32_enable_caps_lock
))
2990 goto disable_lock_key
;
2991 windows_translate
= 1;
2994 /* Decide whether to treat as modifier or function key. */
2995 if (NILP (Vw32_enable_num_lock
))
2996 goto disable_lock_key
;
2997 windows_translate
= 1;
3000 /* Decide whether to treat as modifier or function key. */
3001 if (NILP (Vw32_scroll_lock_modifier
))
3002 goto disable_lock_key
;
3003 windows_translate
= 1;
3006 /* Ensure the appropriate lock key state (and indicator light)
3007 remains in the same state. We do this by faking another
3008 press of the relevant key. Apparently, this really is the
3009 only way to toggle the state of the indicator lights. */
3010 dpyinfo
->faked_key
= wParam
;
3011 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
3012 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
3013 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
3014 KEYEVENTF_EXTENDEDKEY
| 0, 0);
3015 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
3016 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
3017 /* Ensure indicator lights are updated promptly on Windows 9x
3018 (TranslateMessage apparently does this), after forwarding
3020 post_character_message (hwnd
, msg
, wParam
, lParam
,
3021 w32_get_key_modifiers (wParam
, lParam
));
3022 windows_translate
= 1;
3026 case VK_PROCESSKEY
: /* Generated by IME. */
3027 windows_translate
= 1;
3030 /* Windows maps Ctrl-Pause (aka Ctrl-Break) into VK_CANCEL,
3031 which is confusing for purposes of key binding; convert
3032 VK_CANCEL events into VK_PAUSE events. */
3036 /* Windows maps Ctrl-NumLock into VK_PAUSE, which is confusing
3037 for purposes of key binding; convert these back into
3038 VK_NUMLOCK events, at least when we want to see NumLock key
3039 presses. (Note that there is never any possibility that
3040 VK_PAUSE with Ctrl really is C-Pause as per above.) */
3041 if (NILP (Vw32_enable_num_lock
) && modifier_set (VK_CONTROL
))
3042 wParam
= VK_NUMLOCK
;
3045 /* If not defined as a function key, change it to a WM_CHAR message. */
3046 if (wParam
> 255 || !lispy_function_keys
[wParam
])
3048 DWORD modifiers
= construct_console_modifiers ();
3050 if (!NILP (Vw32_recognize_altgr
)
3051 && modifier_set (VK_LCONTROL
) && modifier_set (VK_RMENU
))
3053 /* Always let TranslateMessage handle AltGr key chords;
3054 for some reason, ToAscii doesn't always process AltGr
3055 chords correctly. */
3056 windows_translate
= 1;
3058 else if ((modifiers
& (~SHIFT_PRESSED
& ~CAPSLOCK_ON
)) != 0)
3060 /* Handle key chords including any modifiers other
3061 than shift directly, in order to preserve as much
3062 modifier information as possible. */
3063 if ('A' <= wParam
&& wParam
<= 'Z')
3065 /* Don't translate modified alphabetic keystrokes,
3066 so the user doesn't need to constantly switch
3067 layout to type control or meta keystrokes when
3068 the normal layout translates alphabetic
3069 characters to non-ascii characters. */
3070 if (!modifier_set (VK_SHIFT
))
3071 wParam
+= ('a' - 'A');
3076 /* Try to handle other keystrokes by determining the
3077 base character (ie. translating the base key plus
3081 KEY_EVENT_RECORD key
;
3083 key
.bKeyDown
= TRUE
;
3084 key
.wRepeatCount
= 1;
3085 key
.wVirtualKeyCode
= wParam
;
3086 key
.wVirtualScanCode
= (lParam
& 0xFF0000) >> 16;
3087 key
.uChar
.AsciiChar
= 0;
3088 key
.dwControlKeyState
= modifiers
;
3090 add
= w32_kbd_patch_key (&key
);
3091 /* 0 means an unrecognised keycode, negative means
3092 dead key. Ignore both. */
3095 /* Forward asciified character sequence. */
3096 post_character_message
3098 (unsigned char) key
.uChar
.AsciiChar
, lParam
,
3099 w32_get_key_modifiers (wParam
, lParam
));
3100 w32_kbd_patch_key (&key
);
3107 /* Let TranslateMessage handle everything else. */
3108 windows_translate
= 1;
3114 if (windows_translate
)
3116 MSG windows_msg
= { hwnd
, msg
, wParam
, lParam
, 0, {0,0} };
3117 windows_msg
.time
= GetMessageTime ();
3118 TranslateMessage (&windows_msg
);
3126 post_character_message (hwnd
, msg
, wParam
, lParam
,
3127 w32_get_key_modifiers (wParam
, lParam
));
3131 /* WM_UNICHAR looks promising from the docs, but the exact
3132 circumstances in which TranslateMessage sends it is one of those
3133 Microsoft secret API things that EU and US courts are supposed
3134 to have put a stop to already. Spy++ shows it being sent to Notepad
3135 and other MS apps, but never to Emacs.
3137 Some third party IMEs send it in accordance with the official
3138 documentation though, so handle it here.
3140 UNICODE_NOCHAR is used to test for support for this message.
3141 TRUE indicates that the message is supported. */
3142 if (wParam
== UNICODE_NOCHAR
)
3147 wmsg
.dwModifiers
= w32_get_key_modifiers (wParam
, lParam
);
3148 signal_user_input ();
3149 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3154 /* If we can't get the IME result as unicode, use default processing,
3155 which will at least allow characters decodable in the system locale
3157 if (!get_composition_string_fn
)
3160 else if (!ignore_ime_char
)
3165 HIMC context
= get_ime_context_fn (hwnd
);
3166 wmsg
.dwModifiers
= w32_get_key_modifiers (wParam
, lParam
);
3167 /* Get buffer size. */
3168 size
= get_composition_string_fn (context
, GCS_RESULTSTR
, buffer
, 0);
3169 buffer
= alloca(size
);
3170 size
= get_composition_string_fn (context
, GCS_RESULTSTR
,
3172 release_ime_context_fn (hwnd
, context
);
3174 signal_user_input ();
3175 for (i
= 0; i
< size
/ sizeof (wchar_t); i
++)
3177 my_post_msg (&wmsg
, hwnd
, WM_UNICHAR
, (WPARAM
) buffer
[i
],
3180 /* Ignore the messages for the rest of the
3181 characters in the string that was output above. */
3182 ignore_ime_char
= (size
/ sizeof (wchar_t)) - 1;
3189 case WM_IME_STARTCOMPOSITION
:
3190 if (!set_ime_composition_window_fn
)
3194 COMPOSITIONFORM form
;
3201 f
= x_window_to_frame (dpyinfo
, hwnd
);
3202 w
= XWINDOW (FRAME_SELECTED_WINDOW (f
));
3204 form
.dwStyle
= CFS_RECT
;
3205 form
.ptCurrentPos
.x
= w32_system_caret_x
;
3206 form
.ptCurrentPos
.y
= w32_system_caret_y
;
3208 form
.rcArea
.left
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, 0);
3209 form
.rcArea
.top
= (WINDOW_TOP_EDGE_Y (w
)
3210 + WINDOW_HEADER_LINE_HEIGHT (w
));
3211 form
.rcArea
.right
= (WINDOW_BOX_RIGHT_EDGE_X (w
)
3212 - WINDOW_RIGHT_MARGIN_WIDTH (w
)
3213 - WINDOW_RIGHT_FRINGE_WIDTH (w
));
3214 form
.rcArea
.bottom
= (WINDOW_BOTTOM_EDGE_Y (w
)
3215 - WINDOW_MODE_LINE_HEIGHT (w
));
3217 context
= get_ime_context_fn (hwnd
);
3218 set_ime_composition_window_fn (context
, &form
);
3219 release_ime_context_fn (hwnd
, context
);
3223 case WM_IME_ENDCOMPOSITION
:
3224 ignore_ime_char
= 0;
3227 /* Simulate middle mouse button events when left and right buttons
3228 are used together, but only if user has two button mouse. */
3229 case WM_LBUTTONDOWN
:
3230 case WM_RBUTTONDOWN
:
3231 if (w32_num_mouse_buttons
> 2)
3232 goto handle_plain_button
;
3235 int this = (msg
== WM_LBUTTONDOWN
) ? LMOUSE
: RMOUSE
;
3236 int other
= (msg
== WM_LBUTTONDOWN
) ? RMOUSE
: LMOUSE
;
3238 if (button_state
& this)
3241 if (button_state
== 0)
3244 button_state
|= this;
3246 if (button_state
& other
)
3248 if (mouse_button_timer
)
3250 KillTimer (hwnd
, mouse_button_timer
);
3251 mouse_button_timer
= 0;
3253 /* Generate middle mouse event instead. */
3254 msg
= WM_MBUTTONDOWN
;
3255 button_state
|= MMOUSE
;
3257 else if (button_state
& MMOUSE
)
3259 /* Ignore button event if we've already generated a
3260 middle mouse down event. This happens if the
3261 user releases and press one of the two buttons
3262 after we've faked a middle mouse event. */
3267 /* Flush out saved message. */
3268 post_msg (&saved_mouse_button_msg
);
3270 wmsg
.dwModifiers
= w32_get_modifiers ();
3271 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3272 signal_user_input ();
3274 /* Clear message buffer. */
3275 saved_mouse_button_msg
.msg
.hwnd
= 0;
3279 /* Hold onto message for now. */
3280 mouse_button_timer
=
3281 SetTimer (hwnd
, MOUSE_BUTTON_ID
,
3282 w32_mouse_button_tolerance
, NULL
);
3283 saved_mouse_button_msg
.msg
.hwnd
= hwnd
;
3284 saved_mouse_button_msg
.msg
.message
= msg
;
3285 saved_mouse_button_msg
.msg
.wParam
= wParam
;
3286 saved_mouse_button_msg
.msg
.lParam
= lParam
;
3287 saved_mouse_button_msg
.msg
.time
= GetMessageTime ();
3288 saved_mouse_button_msg
.dwModifiers
= w32_get_modifiers ();
3295 if (w32_num_mouse_buttons
> 2)
3296 goto handle_plain_button
;
3299 int this = (msg
== WM_LBUTTONUP
) ? LMOUSE
: RMOUSE
;
3300 int other
= (msg
== WM_LBUTTONUP
) ? RMOUSE
: LMOUSE
;
3302 if ((button_state
& this) == 0)
3305 button_state
&= ~this;
3307 if (button_state
& MMOUSE
)
3309 /* Only generate event when second button is released. */
3310 if ((button_state
& other
) == 0)
3313 button_state
&= ~MMOUSE
;
3315 if (button_state
) abort ();
3322 /* Flush out saved message if necessary. */
3323 if (saved_mouse_button_msg
.msg
.hwnd
)
3325 post_msg (&saved_mouse_button_msg
);
3328 wmsg
.dwModifiers
= w32_get_modifiers ();
3329 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3330 signal_user_input ();
3332 /* Always clear message buffer and cancel timer. */
3333 saved_mouse_button_msg
.msg
.hwnd
= 0;
3334 KillTimer (hwnd
, mouse_button_timer
);
3335 mouse_button_timer
= 0;
3337 if (button_state
== 0)
3342 case WM_XBUTTONDOWN
:
3344 if (w32_pass_extra_mouse_buttons_to_system
)
3346 /* else fall through and process them. */
3347 case WM_MBUTTONDOWN
:
3349 handle_plain_button
:
3354 /* Ignore middle and extra buttons as long as the menu is active. */
3355 f
= x_window_to_frame (dpyinfo
, hwnd
);
3356 if (f
&& f
->output_data
.w32
->menubar_active
)
3359 if (parse_button (msg
, HIWORD (wParam
), &button
, &up
))
3361 if (up
) ReleaseCapture ();
3362 else SetCapture (hwnd
);
3363 button
= (button
== 0) ? LMOUSE
:
3364 ((button
== 1) ? MMOUSE
: RMOUSE
);
3366 button_state
&= ~button
;
3368 button_state
|= button
;
3372 wmsg
.dwModifiers
= w32_get_modifiers ();
3373 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3374 signal_user_input ();
3376 /* Need to return true for XBUTTON messages, false for others,
3377 to indicate that we processed the message. */
3378 return (msg
== WM_XBUTTONDOWN
|| msg
== WM_XBUTTONUP
);
3381 /* Ignore mouse movements as long as the menu is active. These
3382 movements are processed by the window manager anyway, and
3383 it's wrong to handle them as if they happened on the
3384 underlying frame. */
3385 f
= x_window_to_frame (dpyinfo
, hwnd
);
3386 if (f
&& f
->output_data
.w32
->menubar_active
)
3389 /* If the mouse has just moved into the frame, start tracking
3390 it, so we will be notified when it leaves the frame. Mouse
3391 tracking only works under W98 and NT4 and later. On earlier
3392 versions, there is no way of telling when the mouse leaves the
3393 frame, so we just have to put up with help-echo and mouse
3394 highlighting remaining while the frame is not active. */
3395 if (track_mouse_event_fn
&& !track_mouse_window
)
3397 TRACKMOUSEEVENT tme
;
3398 tme
.cbSize
= sizeof (tme
);
3399 tme
.dwFlags
= TME_LEAVE
;
3400 tme
.hwndTrack
= hwnd
;
3402 track_mouse_event_fn (&tme
);
3403 track_mouse_window
= hwnd
;
3406 if (w32_mouse_move_interval
<= 0
3407 || (msg
== WM_MOUSEMOVE
&& button_state
== 0))
3409 wmsg
.dwModifiers
= w32_get_modifiers ();
3410 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3414 /* Hang onto mouse move and scroll messages for a bit, to avoid
3415 sending such events to Emacs faster than it can process them.
3416 If we get more events before the timer from the first message
3417 expires, we just replace the first message. */
3419 if (saved_mouse_move_msg
.msg
.hwnd
== 0)
3421 SetTimer (hwnd
, MOUSE_MOVE_ID
,
3422 w32_mouse_move_interval
, NULL
);
3424 /* Hold onto message for now. */
3425 saved_mouse_move_msg
.msg
.hwnd
= hwnd
;
3426 saved_mouse_move_msg
.msg
.message
= msg
;
3427 saved_mouse_move_msg
.msg
.wParam
= wParam
;
3428 saved_mouse_move_msg
.msg
.lParam
= lParam
;
3429 saved_mouse_move_msg
.msg
.time
= GetMessageTime ();
3430 saved_mouse_move_msg
.dwModifiers
= w32_get_modifiers ();
3436 wmsg
.dwModifiers
= w32_get_modifiers ();
3437 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3438 signal_user_input ();
3442 if (w32_pass_multimedia_buttons_to_system
)
3444 /* Otherwise, pass to lisp, the same way we do with mousehwheel. */
3445 case WM_MOUSEHWHEEL
:
3446 wmsg
.dwModifiers
= w32_get_modifiers ();
3447 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3448 signal_user_input ();
3449 /* Non-zero must be returned when WM_MOUSEHWHEEL messages are
3450 handled, to prevent the system trying to handle it by faking
3451 scroll bar events. */
3455 /* Flush out saved messages if necessary. */
3456 if (wParam
== mouse_button_timer
)
3458 if (saved_mouse_button_msg
.msg
.hwnd
)
3460 post_msg (&saved_mouse_button_msg
);
3461 signal_user_input ();
3462 saved_mouse_button_msg
.msg
.hwnd
= 0;
3464 KillTimer (hwnd
, mouse_button_timer
);
3465 mouse_button_timer
= 0;
3467 else if (wParam
== mouse_move_timer
)
3469 if (saved_mouse_move_msg
.msg
.hwnd
)
3471 post_msg (&saved_mouse_move_msg
);
3472 saved_mouse_move_msg
.msg
.hwnd
= 0;
3474 KillTimer (hwnd
, mouse_move_timer
);
3475 mouse_move_timer
= 0;
3477 else if (wParam
== menu_free_timer
)
3479 KillTimer (hwnd
, menu_free_timer
);
3480 menu_free_timer
= 0;
3481 f
= x_window_to_frame (dpyinfo
, hwnd
);
3482 /* If a popup menu is active, don't wipe its strings. */
3484 && current_popup_menu
== NULL
)
3486 /* Free memory used by owner-drawn and help-echo strings. */
3487 w32_free_menu_strings (hwnd
);
3488 f
->output_data
.w32
->menubar_active
= 0;
3492 else if (wParam
== hourglass_timer
)
3494 KillTimer (hwnd
, hourglass_timer
);
3495 hourglass_timer
= 0;
3496 w32_show_hourglass (x_window_to_frame (dpyinfo
, hwnd
));
3501 /* Windows doesn't send us focus messages when putting up and
3502 taking down a system popup dialog as for Ctrl-Alt-Del on Windows 95.
3503 The only indication we get that something happened is receiving
3504 this message afterwards. So this is a good time to reset our
3505 keyboard modifiers' state. */
3512 /* We must ensure menu bar is fully constructed and up to date
3513 before allowing user interaction with it. To achieve this
3514 we send this message to the lisp thread and wait for a
3515 reply (whose value is not actually needed) to indicate that
3516 the menu bar is now ready for use, so we can now return.
3518 To remain responsive in the meantime, we enter a nested message
3519 loop that can process all other messages.
3521 However, we skip all this if the message results from calling
3522 TrackPopupMenu - in fact, we must NOT attempt to send the lisp
3523 thread a message because it is blocked on us at this point. We
3524 set menubar_active before calling TrackPopupMenu to indicate
3525 this (there is no possibility of confusion with real menubar
3528 f
= x_window_to_frame (dpyinfo
, hwnd
);
3530 && (f
->output_data
.w32
->menubar_active
3531 /* We can receive this message even in the absence of a
3532 menubar (ie. when the system menu is activated) - in this
3533 case we do NOT want to forward the message, otherwise it
3534 will cause the menubar to suddenly appear when the user
3535 had requested it to be turned off! */
3536 || f
->output_data
.w32
->menubar_widget
== NULL
))
3540 deferred_msg msg_buf
;
3542 /* Detect if message has already been deferred; in this case
3543 we cannot return any sensible value to ignore this. */
3544 if (find_deferred_msg (hwnd
, msg
) != NULL
)
3549 return send_deferred_msg (&msg_buf
, hwnd
, msg
, wParam
, lParam
);
3552 case WM_EXITMENULOOP
:
3553 f
= x_window_to_frame (dpyinfo
, hwnd
);
3555 /* If a menu is still active, check again after a short delay,
3556 since Windows often (always?) sends the WM_EXITMENULOOP
3557 before the corresponding WM_COMMAND message.
3558 Don't do this if a popup menu is active, since it is only
3559 menubar menus that require cleaning up in this way.
3561 if (f
&& menubar_in_use
&& current_popup_menu
== NULL
)
3562 menu_free_timer
= SetTimer (hwnd
, MENU_FREE_ID
, MENU_FREE_DELAY
, NULL
);
3564 /* If hourglass cursor should be displayed, display it now. */
3565 if (f
&& f
->output_data
.w32
->hourglass_p
)
3566 SetCursor (f
->output_data
.w32
->hourglass_cursor
);
3571 /* Direct handling of help_echo in menus. Should be safe now
3572 that we generate the help_echo by placing a help event in the
3575 HMENU menu
= (HMENU
) lParam
;
3576 UINT menu_item
= (UINT
) LOWORD (wParam
);
3577 UINT flags
= (UINT
) HIWORD (wParam
);
3579 w32_menu_display_help (hwnd
, menu
, menu_item
, flags
);
3583 case WM_MEASUREITEM
:
3584 f
= x_window_to_frame (dpyinfo
, hwnd
);
3587 MEASUREITEMSTRUCT
* pMis
= (MEASUREITEMSTRUCT
*) lParam
;
3589 if (pMis
->CtlType
== ODT_MENU
)
3591 /* Work out dimensions for popup menu titles. */
3592 char * title
= (char *) pMis
->itemData
;
3593 HDC hdc
= GetDC (hwnd
);
3594 HFONT menu_font
= GetCurrentObject (hdc
, OBJ_FONT
);
3595 LOGFONT menu_logfont
;
3599 GetObject (menu_font
, sizeof (menu_logfont
), &menu_logfont
);
3600 menu_logfont
.lfWeight
= FW_BOLD
;
3601 menu_font
= CreateFontIndirect (&menu_logfont
);
3602 old_font
= SelectObject (hdc
, menu_font
);
3604 pMis
->itemHeight
= GetSystemMetrics (SM_CYMENUSIZE
);
3607 if (unicode_append_menu
)
3608 GetTextExtentPoint32W (hdc
, (WCHAR
*) title
,
3609 wcslen ((WCHAR
*) title
),
3612 GetTextExtentPoint32 (hdc
, title
, strlen (title
), &size
);
3614 pMis
->itemWidth
= size
.cx
;
3615 if (pMis
->itemHeight
< size
.cy
)
3616 pMis
->itemHeight
= size
.cy
;
3619 pMis
->itemWidth
= 0;
3621 SelectObject (hdc
, old_font
);
3622 DeleteObject (menu_font
);
3623 ReleaseDC (hwnd
, hdc
);
3630 f
= x_window_to_frame (dpyinfo
, hwnd
);
3633 DRAWITEMSTRUCT
* pDis
= (DRAWITEMSTRUCT
*) lParam
;
3635 if (pDis
->CtlType
== ODT_MENU
)
3637 /* Draw popup menu title. */
3638 char * title
= (char *) pDis
->itemData
;
3641 HDC hdc
= pDis
->hDC
;
3642 HFONT menu_font
= GetCurrentObject (hdc
, OBJ_FONT
);
3643 LOGFONT menu_logfont
;
3646 GetObject (menu_font
, sizeof (menu_logfont
), &menu_logfont
);
3647 menu_logfont
.lfWeight
= FW_BOLD
;
3648 menu_font
= CreateFontIndirect (&menu_logfont
);
3649 old_font
= SelectObject (hdc
, menu_font
);
3651 /* Always draw title as if not selected. */
3652 if (unicode_append_menu
)
3655 + GetSystemMetrics (SM_CXMENUCHECK
),
3657 ETO_OPAQUE
, &pDis
->rcItem
,
3659 wcslen ((WCHAR
*) title
), NULL
);
3663 + GetSystemMetrics (SM_CXMENUCHECK
),
3665 ETO_OPAQUE
, &pDis
->rcItem
,
3666 title
, strlen (title
), NULL
);
3668 SelectObject (hdc
, old_font
);
3669 DeleteObject (menu_font
);
3677 /* Still not right - can't distinguish between clicks in the
3678 client area of the frame from clicks forwarded from the scroll
3679 bars - may have to hook WM_NCHITTEST to remember the mouse
3680 position and then check if it is in the client area ourselves. */
3681 case WM_MOUSEACTIVATE
:
3682 /* Discard the mouse click that activates a frame, allowing the
3683 user to click anywhere without changing point (or worse!).
3684 Don't eat mouse clicks on scrollbars though!! */
3685 if (LOWORD (lParam
) == HTCLIENT
)
3686 return MA_ACTIVATEANDEAT
;
3691 /* No longer tracking mouse. */
3692 track_mouse_window
= NULL
;
3694 case WM_ACTIVATEAPP
:
3696 case WM_WINDOWPOSCHANGED
:
3698 /* Inform lisp thread that a frame might have just been obscured
3699 or exposed, so should recheck visibility of all frames. */
3700 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3704 dpyinfo
->faked_key
= 0;
3706 register_hot_keys (hwnd
);
3709 unregister_hot_keys (hwnd
);
3712 /* Relinquish the system caret. */
3713 if (w32_system_caret_hwnd
)
3715 w32_visible_system_caret_hwnd
= NULL
;
3716 w32_system_caret_hwnd
= NULL
;
3722 f
= x_window_to_frame (dpyinfo
, hwnd
);
3723 if (f
&& HIWORD (wParam
) == 0)
3725 if (menu_free_timer
)
3727 KillTimer (hwnd
, menu_free_timer
);
3728 menu_free_timer
= 0;
3734 wmsg
.dwModifiers
= w32_get_modifiers ();
3735 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3743 wmsg
.dwModifiers
= w32_get_modifiers ();
3744 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3747 case WM_WINDOWPOSCHANGING
:
3748 /* Don't restrict the sizing of tip frames. */
3749 if (hwnd
== tip_window
)
3753 LPWINDOWPOS lppos
= (WINDOWPOS
*) lParam
;
3755 wp
.length
= sizeof (WINDOWPLACEMENT
);
3756 GetWindowPlacement (hwnd
, &wp
);
3758 if (wp
.showCmd
!= SW_SHOWMINIMIZED
&& (lppos
->flags
& SWP_NOSIZE
) == 0)
3765 DWORD internal_border
;
3766 DWORD scrollbar_extra
;
3769 wp
.length
= sizeof (wp
);
3770 GetWindowRect (hwnd
, &wr
);
3774 font_width
= GetWindowLong (hwnd
, WND_FONTWIDTH_INDEX
);
3775 line_height
= GetWindowLong (hwnd
, WND_LINEHEIGHT_INDEX
);
3776 internal_border
= GetWindowLong (hwnd
, WND_BORDER_INDEX
);
3777 scrollbar_extra
= GetWindowLong (hwnd
, WND_SCROLLBAR_INDEX
);
3781 memset (&rect
, 0, sizeof (rect
));
3782 AdjustWindowRect (&rect
, GetWindowLong (hwnd
, GWL_STYLE
),
3783 GetMenu (hwnd
) != NULL
);
3785 /* Force width and height of client area to be exact
3786 multiples of the character cell dimensions. */
3787 wdiff
= (lppos
->cx
- (rect
.right
- rect
.left
)
3788 - 2 * internal_border
- scrollbar_extra
)
3790 hdiff
= (lppos
->cy
- (rect
.bottom
- rect
.top
)
3791 - 2 * internal_border
)
3796 /* For right/bottom sizing we can just fix the sizes.
3797 However for top/left sizing we will need to fix the X
3798 and Y positions as well. */
3800 int cx_mintrack
= GetSystemMetrics (SM_CXMINTRACK
);
3801 int cy_mintrack
= GetSystemMetrics (SM_CYMINTRACK
);
3803 lppos
->cx
= max (lppos
->cx
- wdiff
, cx_mintrack
);
3804 lppos
->cy
= max (lppos
->cy
- hdiff
, cy_mintrack
);
3806 if (wp
.showCmd
!= SW_SHOWMAXIMIZED
3807 && (lppos
->flags
& SWP_NOMOVE
) == 0)
3809 if (lppos
->x
!= wr
.left
|| lppos
->y
!= wr
.top
)
3816 lppos
->flags
|= SWP_NOMOVE
;
3827 case WM_GETMINMAXINFO
:
3828 /* Hack to allow resizing the Emacs frame above the screen size.
3829 Note that Windows 9x limits coordinates to 16-bits. */
3830 ((LPMINMAXINFO
) lParam
)->ptMaxTrackSize
.x
= 32767;
3831 ((LPMINMAXINFO
) lParam
)->ptMaxTrackSize
.y
= 32767;
3835 if (LOWORD (lParam
) == HTCLIENT
)
3837 f
= x_window_to_frame (dpyinfo
, hwnd
);
3838 if (f
->output_data
.w32
->hourglass_p
&& !menubar_in_use
3839 && !current_popup_menu
)
3840 SetCursor (f
->output_data
.w32
->hourglass_cursor
);
3842 SetCursor (f
->output_data
.w32
->current_cursor
);
3847 case WM_EMACS_SETCURSOR
:
3849 Cursor cursor
= (Cursor
) wParam
;
3850 f
= x_window_to_frame (dpyinfo
, hwnd
);
3853 f
->output_data
.w32
->current_cursor
= cursor
;
3854 if (!f
->output_data
.w32
->hourglass_p
)
3860 case WM_EMACS_CREATESCROLLBAR
:
3861 return (LRESULT
) w32_createscrollbar ((struct frame
*) wParam
,
3862 (struct scroll_bar
*) lParam
);
3864 case WM_EMACS_SHOWWINDOW
:
3865 return ShowWindow ((HWND
) wParam
, (WPARAM
) lParam
);
3867 case WM_EMACS_SETFOREGROUND
:
3869 HWND foreground_window
;
3870 DWORD foreground_thread
, retval
;
3872 /* On NT 5.0, and apparently Windows 98, it is necessary to
3873 attach to the thread that currently has focus in order to
3874 pull the focus away from it. */
3875 foreground_window
= GetForegroundWindow ();
3876 foreground_thread
= GetWindowThreadProcessId (foreground_window
, NULL
);
3877 if (!foreground_window
3878 || foreground_thread
== GetCurrentThreadId ()
3879 || !AttachThreadInput (GetCurrentThreadId (),
3880 foreground_thread
, TRUE
))
3881 foreground_thread
= 0;
3883 retval
= SetForegroundWindow ((HWND
) wParam
);
3885 /* Detach from the previous foreground thread. */
3886 if (foreground_thread
)
3887 AttachThreadInput (GetCurrentThreadId (),
3888 foreground_thread
, FALSE
);
3893 case WM_EMACS_SETWINDOWPOS
:
3895 WINDOWPOS
* pos
= (WINDOWPOS
*) wParam
;
3896 return SetWindowPos (hwnd
, pos
->hwndInsertAfter
,
3897 pos
->x
, pos
->y
, pos
->cx
, pos
->cy
, pos
->flags
);
3900 case WM_EMACS_DESTROYWINDOW
:
3901 DragAcceptFiles ((HWND
) wParam
, FALSE
);
3902 return DestroyWindow ((HWND
) wParam
);
3904 case WM_EMACS_HIDE_CARET
:
3905 return HideCaret (hwnd
);
3907 case WM_EMACS_SHOW_CARET
:
3908 return ShowCaret (hwnd
);
3910 case WM_EMACS_DESTROY_CARET
:
3911 w32_system_caret_hwnd
= NULL
;
3912 w32_visible_system_caret_hwnd
= NULL
;
3913 return DestroyCaret ();
3915 case WM_EMACS_TRACK_CARET
:
3916 /* If there is currently no system caret, create one. */
3917 if (w32_system_caret_hwnd
== NULL
)
3919 /* Use the default caret width, and avoid changing it
3920 unneccesarily, as it confuses screen reader software. */
3921 w32_system_caret_hwnd
= hwnd
;
3922 CreateCaret (hwnd
, NULL
, 0,
3923 w32_system_caret_height
);
3926 if (!SetCaretPos (w32_system_caret_x
, w32_system_caret_y
))
3928 /* Ensure visible caret gets turned on when requested. */
3929 else if (w32_use_visible_system_caret
3930 && w32_visible_system_caret_hwnd
!= hwnd
)
3932 w32_visible_system_caret_hwnd
= hwnd
;
3933 return ShowCaret (hwnd
);
3935 /* Ensure visible caret gets turned off when requested. */
3936 else if (!w32_use_visible_system_caret
3937 && w32_visible_system_caret_hwnd
)
3939 w32_visible_system_caret_hwnd
= NULL
;
3940 return HideCaret (hwnd
);
3945 case WM_EMACS_TRACKPOPUPMENU
:
3950 pos
= (POINT
*)lParam
;
3951 flags
= TPM_CENTERALIGN
;
3952 if (button_state
& LMOUSE
)
3953 flags
|= TPM_LEFTBUTTON
;
3954 else if (button_state
& RMOUSE
)
3955 flags
|= TPM_RIGHTBUTTON
;
3957 /* Remember we did a SetCapture on the initial mouse down event,
3958 so for safety, we make sure the capture is cancelled now. */
3962 /* Use menubar_active to indicate that WM_INITMENU is from
3963 TrackPopupMenu below, and should be ignored. */
3964 f
= x_window_to_frame (dpyinfo
, hwnd
);
3966 f
->output_data
.w32
->menubar_active
= 1;
3968 if (TrackPopupMenu ((HMENU
)wParam
, flags
, pos
->x
, pos
->y
,
3972 /* Eat any mouse messages during popupmenu */
3973 while (PeekMessage (&amsg
, hwnd
, WM_MOUSEFIRST
, WM_MOUSELAST
,
3975 /* Get the menu selection, if any */
3976 if (PeekMessage (&amsg
, hwnd
, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
))
3978 retval
= LOWORD (amsg
.wParam
);
3994 /* Check for messages registered at runtime. */
3995 if (msg
== msh_mousewheel
)
3997 wmsg
.dwModifiers
= w32_get_modifiers ();
3998 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3999 signal_user_input ();
4004 return DefWindowProc (hwnd
, msg
, wParam
, lParam
);
4008 /* The most common default return code for handled messages is 0. */
4013 my_create_window (f
)
4018 if (!PostThreadMessage (dwWindowsThreadId
, WM_EMACS_CREATEWINDOW
, (WPARAM
)f
, 0))
4020 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
4024 /* Create a tooltip window. Unlike my_create_window, we do not do this
4025 indirectly via the Window thread, as we do not need to process Window
4026 messages for the tooltip. Creating tooltips indirectly also creates
4027 deadlocks when tooltips are created for menu items. */
4029 my_create_tip_window (f
)
4034 rect
.left
= rect
.top
= 0;
4035 rect
.right
= FRAME_PIXEL_WIDTH (f
);
4036 rect
.bottom
= FRAME_PIXEL_HEIGHT (f
);
4038 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
4039 FRAME_EXTERNAL_MENU_BAR (f
));
4041 tip_window
= FRAME_W32_WINDOW (f
)
4042 = CreateWindow (EMACS_CLASS
,
4044 f
->output_data
.w32
->dwStyle
,
4047 rect
.right
- rect
.left
,
4048 rect
.bottom
- rect
.top
,
4049 FRAME_W32_WINDOW (SELECTED_FRAME ()), /* owner */
4056 SetWindowLong (tip_window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
4057 SetWindowLong (tip_window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
4058 SetWindowLong (tip_window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
4059 SetWindowLong (tip_window
, WND_BACKGROUND_INDEX
, FRAME_BACKGROUND_PIXEL (f
));
4061 /* Tip frames have no scrollbars. */
4062 SetWindowLong (tip_window
, WND_SCROLLBAR_INDEX
, 0);
4064 /* Do this to discard the default setting specified by our parent. */
4065 ShowWindow (tip_window
, SW_HIDE
);
4070 /* Create and set up the w32 window for frame F. */
4073 w32_window (f
, window_prompting
, minibuffer_only
)
4075 long window_prompting
;
4076 int minibuffer_only
;
4080 /* Use the resource name as the top-level window name
4081 for looking up resources. Make a non-Lisp copy
4082 for the window manager, so GC relocation won't bother it.
4084 Elsewhere we specify the window name for the window manager. */
4087 char *str
= (char *) SDATA (Vx_resource_name
);
4088 f
->namebuf
= (char *) xmalloc (strlen (str
) + 1);
4089 strcpy (f
->namebuf
, str
);
4092 my_create_window (f
);
4094 validate_x_resource_name ();
4096 /* x_set_name normally ignores requests to set the name if the
4097 requested name is the same as the current name. This is the one
4098 place where that assumption isn't correct; f->name is set, but
4099 the server hasn't been told. */
4102 int explicit = f
->explicit_name
;
4104 f
->explicit_name
= 0;
4107 x_set_name (f
, name
, explicit);
4112 if (!minibuffer_only
&& FRAME_EXTERNAL_MENU_BAR (f
))
4113 initialize_frame_menubar (f
);
4115 if (FRAME_W32_WINDOW (f
) == 0)
4116 error ("Unable to create window");
4119 /* Handle the icon stuff for this window. Perhaps later we might
4120 want an x_set_icon_position which can be called interactively as
4128 Lisp_Object icon_x
, icon_y
;
4129 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4131 /* Set the position of the icon. Note that Windows 95 groups all
4132 icons in the tray. */
4133 icon_x
= x_get_arg (dpyinfo
, parms
, Qicon_left
, 0, 0, RES_TYPE_NUMBER
);
4134 icon_y
= x_get_arg (dpyinfo
, parms
, Qicon_top
, 0, 0, RES_TYPE_NUMBER
);
4135 if (!EQ (icon_x
, Qunbound
) && !EQ (icon_y
, Qunbound
))
4137 CHECK_NUMBER (icon_x
);
4138 CHECK_NUMBER (icon_y
);
4140 else if (!EQ (icon_x
, Qunbound
) || !EQ (icon_y
, Qunbound
))
4141 error ("Both left and top icon corners of icon must be specified");
4145 if (! EQ (icon_x
, Qunbound
))
4146 x_wm_set_icon_position (f
, XINT (icon_x
), XINT (icon_y
));
4149 /* Start up iconic or window? */
4150 x_wm_set_window_state
4151 (f
, (EQ (x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
), Qicon
)
4155 x_text_icon (f
, (char *) SDATA ((!NILP (f
->icon_name
)
4168 XGCValues gc_values
;
4172 /* Create the GC's of this frame.
4173 Note that many default values are used. */
4176 gc_values
.font
= FRAME_FONT (f
);
4178 /* Cursor has cursor-color background, background-color foreground. */
4179 gc_values
.foreground
= FRAME_BACKGROUND_PIXEL (f
);
4180 gc_values
.background
= f
->output_data
.w32
->cursor_pixel
;
4181 f
->output_data
.w32
->cursor_gc
4182 = XCreateGC (NULL
, FRAME_W32_WINDOW (f
),
4183 (GCFont
| GCForeground
| GCBackground
),
4187 f
->output_data
.w32
->white_relief
.gc
= 0;
4188 f
->output_data
.w32
->black_relief
.gc
= 0;
4194 /* Handler for signals raised during x_create_frame and
4195 x_create_top_frame. FRAME is the frame which is partially
4199 unwind_create_frame (frame
)
4202 struct frame
*f
= XFRAME (frame
);
4204 /* If frame is ``official'', nothing to do. */
4205 if (!CONSP (Vframe_list
) || !EQ (XCAR (Vframe_list
), frame
))
4208 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
4211 x_free_frame_resources (f
);
4214 /* Check that reference counts are indeed correct. */
4215 xassert (dpyinfo
->reference_count
== dpyinfo_refcount
);
4216 xassert (dpyinfo
->image_cache
->refcount
== image_cache_refcount
);
4225 x_default_font_parameter (f
, parms
)
4229 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
4230 Lisp_Object font_param
= x_get_arg (dpyinfo
, parms
, Qfont
, NULL
, NULL
,
4233 if (EQ (font_param
, Qunbound
))
4235 font
= !NILP (font_param
) ? font_param
4236 : x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
4238 if (!STRINGP (font
))
4241 static char *names
[]
4242 = { "Courier New-10",
4243 "-*-Courier-normal-r-*-*-13-*-*-*-c-*-iso8859-1",
4244 "-*-Fixedsys-normal-r-*-*-12-*-*-*-c-*-iso8859-1",
4248 for (i
= 0; names
[i
]; i
++)
4250 font
= font_open_by_name (f
, names
[i
]);
4255 error ("No suitable font was found");
4257 else if (!NILP (font_param
))
4259 /* Remember the explicit font parameter, so we can re-apply it after
4260 we've applied the `default' face settings. */
4261 x_set_frame_parameters (f
, Fcons (Fcons (Qfont_param
, font_param
), Qnil
));
4263 x_default_parameter (f
, parms
, Qfont
, font
, "font", "Font", RES_TYPE_STRING
);
4266 DEFUN ("x-create-frame", Fx_create_frame
, Sx_create_frame
,
4268 doc
: /* Make a new window, which is called a \"frame\" in Emacs terms.
4269 Return an Emacs frame object.
4270 PARAMETERS is an alist of frame parameters.
4271 If the parameters specify that the frame should not have a minibuffer,
4272 and do not specify a specific minibuffer window to use,
4273 then `default-minibuffer-frame' must be a frame whose minibuffer can
4274 be shared by the new frame.
4276 This function is an internal primitive--use `make-frame' instead. */)
4278 Lisp_Object parameters
;
4281 Lisp_Object frame
, tem
;
4283 int minibuffer_only
= 0;
4284 long window_prompting
= 0;
4286 int count
= SPECPDL_INDEX ();
4287 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4288 Lisp_Object display
;
4289 struct w32_display_info
*dpyinfo
= NULL
;
4293 /* Make copy of frame parameters because the original is in pure
4295 parameters
= Fcopy_alist (parameters
);
4297 /* Use this general default value to start with
4298 until we know if this frame has a specified name. */
4299 Vx_resource_name
= Vinvocation_name
;
4301 display
= x_get_arg (dpyinfo
, parameters
, Qterminal
, 0, 0, RES_TYPE_NUMBER
);
4302 if (EQ (display
, Qunbound
))
4303 display
= x_get_arg (dpyinfo
, parameters
, Qdisplay
, 0, 0, RES_TYPE_STRING
);
4304 if (EQ (display
, Qunbound
))
4306 dpyinfo
= check_x_display_info (display
);
4307 kb
= dpyinfo
->terminal
->kboard
;
4309 if (!dpyinfo
->terminal
->name
)
4310 error ("Terminal is not live, can't create new frames on it");
4312 name
= x_get_arg (dpyinfo
, parameters
, Qname
, "name", "Name", RES_TYPE_STRING
);
4314 && ! EQ (name
, Qunbound
)
4316 error ("Invalid frame name--not a string or nil");
4319 Vx_resource_name
= name
;
4321 /* See if parent window is specified. */
4322 parent
= x_get_arg (dpyinfo
, parameters
, Qparent_id
, NULL
, NULL
, RES_TYPE_NUMBER
);
4323 if (EQ (parent
, Qunbound
))
4325 if (! NILP (parent
))
4326 CHECK_NUMBER (parent
);
4328 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
4329 /* No need to protect DISPLAY because that's not used after passing
4330 it to make_frame_without_minibuffer. */
4332 GCPRO4 (parameters
, parent
, name
, frame
);
4333 tem
= x_get_arg (dpyinfo
, parameters
, Qminibuffer
, "minibuffer", "Minibuffer",
4335 if (EQ (tem
, Qnone
) || NILP (tem
))
4336 f
= make_frame_without_minibuffer (Qnil
, kb
, display
);
4337 else if (EQ (tem
, Qonly
))
4339 f
= make_minibuffer_frame ();
4340 minibuffer_only
= 1;
4342 else if (WINDOWP (tem
))
4343 f
= make_frame_without_minibuffer (tem
, kb
, display
);
4347 XSETFRAME (frame
, f
);
4349 /* Note that Windows does support scroll bars. */
4350 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
4352 /* By default, make scrollbars the system standard width. */
4353 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = GetSystemMetrics (SM_CXVSCROLL
);
4355 f
->terminal
= dpyinfo
->terminal
;
4356 f
->terminal
->reference_count
++;
4358 f
->output_method
= output_w32
;
4359 f
->output_data
.w32
=
4360 (struct w32_output
*) xmalloc (sizeof (struct w32_output
));
4361 bzero (f
->output_data
.w32
, sizeof (struct w32_output
));
4362 FRAME_FONTSET (f
) = -1;
4365 = x_get_arg (dpyinfo
, parameters
, Qicon_name
, "iconName", "Title",
4367 if (! STRINGP (f
->icon_name
))
4368 f
->icon_name
= Qnil
;
4370 /* FRAME_W32_DISPLAY_INFO (f) = dpyinfo; */
4372 /* With FRAME_X_DISPLAY_INFO set up, this unwind-protect is safe. */
4373 record_unwind_protect (unwind_create_frame
, frame
);
4375 image_cache_refcount
= FRAME_IMAGE_CACHE (f
)->refcount
;
4376 dpyinfo_refcount
= dpyinfo
->reference_count
;
4377 #endif /* GLYPH_DEBUG */
4379 /* Specify the parent under which to make this window. */
4383 f
->output_data
.w32
->parent_desc
= (Window
) XFASTINT (parent
);
4384 f
->output_data
.w32
->explicit_parent
= 1;
4388 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
4389 f
->output_data
.w32
->explicit_parent
= 0;
4392 /* Set the name; the functions to which we pass f expect the name to
4394 if (EQ (name
, Qunbound
) || NILP (name
))
4396 f
->name
= build_string (dpyinfo
->w32_id_name
);
4397 f
->explicit_name
= 0;
4402 f
->explicit_name
= 1;
4403 /* use the frame's title when getting resources for this frame. */
4404 specbind (Qx_resource_name
, name
);
4407 f
->resx
= dpyinfo
->resx
;
4408 f
->resy
= dpyinfo
->resy
;
4410 if (uniscribe_available
)
4411 register_font_driver (&uniscribe_font_driver
, f
);
4412 register_font_driver (&w32font_driver
, f
);
4414 x_default_parameter (f
, parameters
, Qfont_backend
, Qnil
,
4415 "fontBackend", "FontBackend", RES_TYPE_STRING
);
4416 /* Extract the window parameters from the supplied values
4417 that are needed to determine window geometry. */
4418 x_default_font_parameter (f
, parameters
);
4419 x_default_parameter (f
, parameters
, Qborder_width
, make_number (2),
4420 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
4422 /* We recognize either internalBorderWidth or internalBorder
4423 (which is what xterm calls it). */
4424 if (NILP (Fassq (Qinternal_border_width
, parameters
)))
4428 value
= x_get_arg (dpyinfo
, parameters
, Qinternal_border_width
,
4429 "internalBorder", "InternalBorder", RES_TYPE_NUMBER
);
4430 if (! EQ (value
, Qunbound
))
4431 parameters
= Fcons (Fcons (Qinternal_border_width
, value
),
4434 /* Default internalBorderWidth to 0 on Windows to match other programs. */
4435 x_default_parameter (f
, parameters
, Qinternal_border_width
, make_number (0),
4436 "internalBorderWidth", "InternalBorder", RES_TYPE_NUMBER
);
4437 x_default_parameter (f
, parameters
, Qvertical_scroll_bars
, Qright
,
4438 "verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL
);
4440 /* Also do the stuff which must be set before the window exists. */
4441 x_default_parameter (f
, parameters
, Qforeground_color
, build_string ("black"),
4442 "foreground", "Foreground", RES_TYPE_STRING
);
4443 x_default_parameter (f
, parameters
, Qbackground_color
, build_string ("white"),
4444 "background", "Background", RES_TYPE_STRING
);
4445 x_default_parameter (f
, parameters
, Qmouse_color
, build_string ("black"),
4446 "pointerColor", "Foreground", RES_TYPE_STRING
);
4447 x_default_parameter (f
, parameters
, Qcursor_color
, build_string ("black"),
4448 "cursorColor", "Foreground", RES_TYPE_STRING
);
4449 x_default_parameter (f
, parameters
, Qborder_color
, build_string ("black"),
4450 "borderColor", "BorderColor", RES_TYPE_STRING
);
4451 x_default_parameter (f
, parameters
, Qscreen_gamma
, Qnil
,
4452 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT
);
4453 x_default_parameter (f
, parameters
, Qline_spacing
, Qnil
,
4454 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER
);
4455 x_default_parameter (f
, parameters
, Qleft_fringe
, Qnil
,
4456 "leftFringe", "LeftFringe", RES_TYPE_NUMBER
);
4457 x_default_parameter (f
, parameters
, Qright_fringe
, Qnil
,
4458 "rightFringe", "RightFringe", RES_TYPE_NUMBER
);
4461 /* Init faces before x_default_parameter is called for scroll-bar
4462 parameters because that function calls x_set_scroll_bar_width,
4463 which calls change_frame_size, which calls Fset_window_buffer,
4464 which runs hooks, which call Fvertical_motion. At the end, we
4465 end up in init_iterator with a null face cache, which should not
4467 init_frame_faces (f
);
4469 x_default_parameter (f
, parameters
, Qmenu_bar_lines
, make_number (1),
4470 "menuBar", "MenuBar", RES_TYPE_NUMBER
);
4471 x_default_parameter (f
, parameters
, Qtool_bar_lines
, make_number (1),
4472 "toolBar", "ToolBar", RES_TYPE_NUMBER
);
4474 x_default_parameter (f
, parameters
, Qbuffer_predicate
, Qnil
,
4475 "bufferPredicate", "BufferPredicate", RES_TYPE_SYMBOL
);
4476 x_default_parameter (f
, parameters
, Qtitle
, Qnil
,
4477 "title", "Title", RES_TYPE_STRING
);
4478 x_default_parameter (f
, parameters
, Qfullscreen
, Qnil
,
4479 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL
);
4481 f
->output_data
.w32
->dwStyle
= WS_OVERLAPPEDWINDOW
;
4482 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
4484 f
->output_data
.w32
->text_cursor
= w32_load_cursor (IDC_IBEAM
);
4485 f
->output_data
.w32
->nontext_cursor
= w32_load_cursor (IDC_ARROW
);
4486 f
->output_data
.w32
->modeline_cursor
= w32_load_cursor (IDC_ARROW
);
4487 f
->output_data
.w32
->hand_cursor
= w32_load_cursor (IDC_HAND
);
4488 f
->output_data
.w32
->hourglass_cursor
= w32_load_cursor (IDC_WAIT
);
4489 f
->output_data
.w32
->horizontal_drag_cursor
= w32_load_cursor (IDC_SIZEWE
);
4491 f
->output_data
.w32
->current_cursor
= f
->output_data
.w32
->nontext_cursor
;
4493 window_prompting
= x_figure_window_size (f
, parameters
, 1);
4495 tem
= x_get_arg (dpyinfo
, parameters
, Qunsplittable
, 0, 0, RES_TYPE_BOOLEAN
);
4496 f
->no_split
= minibuffer_only
|| EQ (tem
, Qt
);
4498 w32_window (f
, window_prompting
, minibuffer_only
);
4499 x_icon (f
, parameters
);
4503 /* Now consider the frame official. */
4504 FRAME_W32_DISPLAY_INFO (f
)->reference_count
++;
4505 Vframe_list
= Fcons (frame
, Vframe_list
);
4507 /* We need to do this after creating the window, so that the
4508 icon-creation functions can say whose icon they're describing. */
4509 x_default_parameter (f
, parameters
, Qicon_type
, Qnil
,
4510 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL
);
4512 x_default_parameter (f
, parameters
, Qauto_raise
, Qnil
,
4513 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
4514 x_default_parameter (f
, parameters
, Qauto_lower
, Qnil
,
4515 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
4516 x_default_parameter (f
, parameters
, Qcursor_type
, Qbox
,
4517 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
4518 x_default_parameter (f
, parameters
, Qscroll_bar_width
, Qnil
,
4519 "scrollBarWidth", "ScrollBarWidth", RES_TYPE_NUMBER
);
4520 x_default_parameter (f
, parameters
, Qalpha
, Qnil
,
4521 "alpha", "Alpha", RES_TYPE_NUMBER
);
4523 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
4524 Change will not be effected unless different from the current
4526 width
= FRAME_COLS (f
);
4527 height
= FRAME_LINES (f
);
4529 FRAME_LINES (f
) = 0;
4530 SET_FRAME_COLS (f
, 0);
4531 change_frame_size (f
, height
, width
, 1, 0, 0);
4533 /* Tell the server what size and position, etc, we want, and how
4534 badly we want them. This should be done after we have the menu
4535 bar so that its size can be taken into account. */
4537 x_wm_set_size_hint (f
, window_prompting
, 0);
4540 /* Make the window appear on the frame and enable display, unless
4541 the caller says not to. However, with explicit parent, Emacs
4542 cannot control visibility, so don't try. */
4543 if (! f
->output_data
.w32
->explicit_parent
)
4545 Lisp_Object visibility
;
4547 visibility
= x_get_arg (dpyinfo
, parameters
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
);
4548 if (EQ (visibility
, Qunbound
))
4551 if (EQ (visibility
, Qicon
))
4552 x_iconify_frame (f
);
4553 else if (! NILP (visibility
))
4554 x_make_frame_visible (f
);
4556 /* Must have been Qnil. */
4560 /* Initialize `default-minibuffer-frame' in case this is the first
4561 frame on this terminal. */
4562 if (FRAME_HAS_MINIBUF_P (f
)
4563 && (!FRAMEP (kb
->Vdefault_minibuffer_frame
)
4564 || !FRAME_LIVE_P (XFRAME (kb
->Vdefault_minibuffer_frame
))))
4565 kb
->Vdefault_minibuffer_frame
= frame
;
4567 /* All remaining specified parameters, which have not been "used"
4568 by x_get_arg and friends, now go in the misc. alist of the frame. */
4569 for (tem
= parameters
; CONSP (tem
); tem
= XCDR (tem
))
4570 if (CONSP (XCAR (tem
)) && !NILP (XCAR (XCAR (tem
))))
4571 f
->param_alist
= Fcons (XCAR (tem
), f
->param_alist
);
4575 /* Make sure windows on this frame appear in calls to next-window
4576 and similar functions. */
4577 Vwindow_list
= Qnil
;
4579 return unbind_to (count
, frame
);
4582 /* FRAME is used only to get a handle on the X display. We don't pass the
4583 display info directly because we're called from frame.c, which doesn't
4584 know about that structure. */
4586 x_get_focus_frame (frame
)
4587 struct frame
*frame
;
4589 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (frame
);
4591 if (! dpyinfo
->w32_focus_frame
)
4594 XSETFRAME (xfocus
, dpyinfo
->w32_focus_frame
);
4598 DEFUN ("x-focus-frame", Fx_focus_frame
, Sx_focus_frame
, 1, 1, 0,
4599 doc
: /* Give FRAME input focus, raising to foreground if necessary. */)
4603 x_focus_on_frame (check_x_frame (frame
));
4608 DEFUN ("xw-color-defined-p", Fxw_color_defined_p
, Sxw_color_defined_p
, 1, 2, 0,
4609 doc
: /* Internal function called by `color-defined-p', which see. */)
4611 Lisp_Object color
, frame
;
4614 FRAME_PTR f
= check_x_frame (frame
);
4616 CHECK_STRING (color
);
4618 if (w32_defined_color (f
, SDATA (color
), &foo
, 0))
4624 DEFUN ("xw-color-values", Fxw_color_values
, Sxw_color_values
, 1, 2, 0,
4625 doc
: /* Internal function called by `color-values', which see. */)
4627 Lisp_Object color
, frame
;
4630 FRAME_PTR f
= check_x_frame (frame
);
4632 CHECK_STRING (color
);
4634 if (w32_defined_color (f
, SDATA (color
), &foo
, 0))
4635 return list3 (make_number ((GetRValue (foo
.pixel
) << 8)
4636 | GetRValue (foo
.pixel
)),
4637 make_number ((GetGValue (foo
.pixel
) << 8)
4638 | GetGValue (foo
.pixel
)),
4639 make_number ((GetBValue (foo
.pixel
) << 8)
4640 | GetBValue (foo
.pixel
)));
4645 DEFUN ("xw-display-color-p", Fxw_display_color_p
, Sxw_display_color_p
, 0, 1, 0,
4646 doc
: /* Internal function called by `display-color-p', which see. */)
4648 Lisp_Object display
;
4650 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4652 if ((dpyinfo
->n_planes
* dpyinfo
->n_cbits
) <= 2)
4658 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p
,
4659 Sx_display_grayscale_p
, 0, 1, 0,
4660 doc
: /* Return t if DISPLAY supports shades of gray.
4661 Note that color displays do support shades of gray.
4662 The optional argument DISPLAY specifies which display to ask about.
4663 DISPLAY should be either a frame or a display name (a string).
4664 If omitted or nil, that stands for the selected frame's display. */)
4666 Lisp_Object display
;
4668 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4670 if ((dpyinfo
->n_planes
* dpyinfo
->n_cbits
) <= 1)
4676 DEFUN ("x-display-pixel-width", Fx_display_pixel_width
,
4677 Sx_display_pixel_width
, 0, 1, 0,
4678 doc
: /* Return the width in pixels of DISPLAY.
4679 The optional argument DISPLAY specifies which display to ask about.
4680 DISPLAY should be either a frame or a display name (a string).
4681 If omitted or nil, that stands for the selected frame's display. */)
4683 Lisp_Object display
;
4685 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4687 return make_number (x_display_pixel_width (dpyinfo
));
4690 DEFUN ("x-display-pixel-height", Fx_display_pixel_height
,
4691 Sx_display_pixel_height
, 0, 1, 0,
4692 doc
: /* Return the height in pixels of DISPLAY.
4693 The optional argument DISPLAY specifies which display to ask about.
4694 DISPLAY should be either a frame or a display name (a string).
4695 If omitted or nil, that stands for the selected frame's display. */)
4697 Lisp_Object display
;
4699 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4701 return make_number (x_display_pixel_height (dpyinfo
));
4704 DEFUN ("x-display-planes", Fx_display_planes
, Sx_display_planes
,
4706 doc
: /* Return the number of bitplanes of DISPLAY.
4707 The optional argument DISPLAY specifies which display to ask about.
4708 DISPLAY should be either a frame or a display name (a string).
4709 If omitted or nil, that stands for the selected frame's display. */)
4711 Lisp_Object display
;
4713 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4715 return make_number (dpyinfo
->n_planes
* dpyinfo
->n_cbits
);
4718 DEFUN ("x-display-color-cells", Fx_display_color_cells
, Sx_display_color_cells
,
4720 doc
: /* Return the number of color cells of DISPLAY.
4721 The optional argument DISPLAY specifies which display to ask about.
4722 DISPLAY should be either a frame or a display name (a string).
4723 If omitted or nil, that stands for the selected frame's display. */)
4725 Lisp_Object display
;
4727 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4731 hdc
= GetDC (dpyinfo
->root_window
);
4732 if (dpyinfo
->has_palette
)
4733 cap
= GetDeviceCaps (hdc
, SIZEPALETTE
);
4735 cap
= GetDeviceCaps (hdc
, NUMCOLORS
);
4737 /* We force 24+ bit depths to 24-bit, both to prevent an overflow
4738 and because probably is more meaningful on Windows anyway */
4740 cap
= 1 << min (dpyinfo
->n_planes
* dpyinfo
->n_cbits
, 24);
4742 ReleaseDC (dpyinfo
->root_window
, hdc
);
4744 return make_number (cap
);
4747 DEFUN ("x-server-max-request-size", Fx_server_max_request_size
,
4748 Sx_server_max_request_size
,
4750 doc
: /* Return the maximum request size of the server of DISPLAY.
4751 The optional argument DISPLAY specifies which display to ask about.
4752 DISPLAY should be either a frame or a display name (a string).
4753 If omitted or nil, that stands for the selected frame's display. */)
4755 Lisp_Object display
;
4757 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4759 return make_number (1);
4762 DEFUN ("x-server-vendor", Fx_server_vendor
, Sx_server_vendor
, 0, 1, 0,
4763 doc
: /* Return the "vendor ID" string of the W32 system (Microsoft).
4764 The optional argument DISPLAY specifies which display to ask about.
4765 DISPLAY should be either a frame or a display name (a string).
4766 If omitted or nil, that stands for the selected frame's display. */)
4768 Lisp_Object display
;
4770 return build_string ("Microsoft Corp.");
4773 DEFUN ("x-server-version", Fx_server_version
, Sx_server_version
, 0, 1, 0,
4774 doc
: /* Return the version numbers of the server of DISPLAY.
4775 The value is a list of three integers: the major and minor
4776 version numbers of the X Protocol in use, and the distributor-specific
4777 release number. See also the function `x-server-vendor'.
4779 The optional argument DISPLAY specifies which display to ask about.
4780 DISPLAY should be either a frame or a display name (a string).
4781 If omitted or nil, that stands for the selected frame's display. */)
4783 Lisp_Object display
;
4785 return Fcons (make_number (w32_major_version
),
4786 Fcons (make_number (w32_minor_version
),
4787 Fcons (make_number (w32_build_number
), Qnil
)));
4790 DEFUN ("x-display-screens", Fx_display_screens
, Sx_display_screens
, 0, 1, 0,
4791 doc
: /* Return the number of screens on the server of DISPLAY.
4792 The optional argument DISPLAY specifies which display to ask about.
4793 DISPLAY should be either a frame or a display name (a string).
4794 If omitted or nil, that stands for the selected frame's display. */)
4796 Lisp_Object display
;
4798 return make_number (1);
4801 DEFUN ("x-display-mm-height", Fx_display_mm_height
,
4802 Sx_display_mm_height
, 0, 1, 0,
4803 doc
: /* Return the height in millimeters of DISPLAY.
4804 The optional argument DISPLAY specifies which display to ask about.
4805 DISPLAY should be either a frame or a display name (a string).
4806 If omitted or nil, that stands for the selected frame's display. */)
4808 Lisp_Object display
;
4810 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4814 hdc
= GetDC (dpyinfo
->root_window
);
4816 cap
= GetDeviceCaps (hdc
, VERTSIZE
);
4818 ReleaseDC (dpyinfo
->root_window
, hdc
);
4820 return make_number (cap
);
4823 DEFUN ("x-display-mm-width", Fx_display_mm_width
, Sx_display_mm_width
, 0, 1, 0,
4824 doc
: /* Return the width in millimeters of DISPLAY.
4825 The optional argument DISPLAY specifies which display to ask about.
4826 DISPLAY should be either a frame or a display name (a string).
4827 If omitted or nil, that stands for the selected frame's display. */)
4829 Lisp_Object display
;
4831 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4836 hdc
= GetDC (dpyinfo
->root_window
);
4838 cap
= GetDeviceCaps (hdc
, HORZSIZE
);
4840 ReleaseDC (dpyinfo
->root_window
, hdc
);
4842 return make_number (cap
);
4845 DEFUN ("x-display-backing-store", Fx_display_backing_store
,
4846 Sx_display_backing_store
, 0, 1, 0,
4847 doc
: /* Return an indication of whether DISPLAY does backing store.
4848 The value may be `always', `when-mapped', or `not-useful'.
4849 The optional argument DISPLAY specifies which display to ask about.
4850 DISPLAY should be either a frame or a display name (a string).
4851 If omitted or nil, that stands for the selected frame's display. */)
4853 Lisp_Object display
;
4855 return intern ("not-useful");
4858 DEFUN ("x-display-visual-class", Fx_display_visual_class
,
4859 Sx_display_visual_class
, 0, 1, 0,
4860 doc
: /* Return the visual class of DISPLAY.
4861 The value is one of the symbols `static-gray', `gray-scale',
4862 `static-color', `pseudo-color', `true-color', or `direct-color'.
4864 The optional argument DISPLAY specifies which display to ask about.
4865 DISPLAY should be either a frame or a display name (a string).
4866 If omitted or nil, that stands for the selected frame's display. */)
4868 Lisp_Object display
;
4870 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4871 Lisp_Object result
= Qnil
;
4873 if (dpyinfo
->has_palette
)
4874 result
= intern ("pseudo-color");
4875 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
== 1)
4876 result
= intern ("static-grey");
4877 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
== 4)
4878 result
= intern ("static-color");
4879 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
> 8)
4880 result
= intern ("true-color");
4885 DEFUN ("x-display-save-under", Fx_display_save_under
,
4886 Sx_display_save_under
, 0, 1, 0,
4887 doc
: /* Return t if DISPLAY supports the save-under feature.
4888 The optional argument DISPLAY specifies which display to ask about.
4889 DISPLAY should be either a frame or a display name (a string).
4890 If omitted or nil, that stands for the selected frame's display. */)
4892 Lisp_Object display
;
4899 register struct frame
*f
;
4901 return FRAME_PIXEL_WIDTH (f
);
4906 register struct frame
*f
;
4908 return FRAME_PIXEL_HEIGHT (f
);
4913 register struct frame
*f
;
4915 return FRAME_COLUMN_WIDTH (f
);
4920 register struct frame
*f
;
4922 return FRAME_LINE_HEIGHT (f
);
4927 register struct frame
*f
;
4929 return FRAME_W32_DISPLAY_INFO (f
)->n_planes
;
4932 /* Return the display structure for the display named NAME.
4933 Open a new connection if necessary. */
4935 struct w32_display_info
*
4936 x_display_info_for_name (name
)
4940 struct w32_display_info
*dpyinfo
;
4942 CHECK_STRING (name
);
4944 for (dpyinfo
= &one_w32_display_info
, names
= w32_display_name_list
;
4946 dpyinfo
= dpyinfo
->next
, names
= XCDR (names
))
4949 tem
= Fstring_equal (XCAR (XCAR (names
)), name
);
4954 /* Use this general default value to start with. */
4955 Vx_resource_name
= Vinvocation_name
;
4957 validate_x_resource_name ();
4959 dpyinfo
= w32_term_init (name
, (unsigned char *)0,
4960 (char *) SDATA (Vx_resource_name
));
4963 error ("Cannot connect to server %s", SDATA (name
));
4966 XSETFASTINT (Vwindow_system_version
, w32_major_version
);
4971 DEFUN ("x-open-connection", Fx_open_connection
, Sx_open_connection
,
4972 1, 3, 0, doc
: /* Open a connection to a server.
4973 DISPLAY is the name of the display to connect to.
4974 Optional second arg XRM-STRING is a string of resources in xrdb format.
4975 If the optional third arg MUST-SUCCEED is non-nil,
4976 terminate Emacs if we can't open the connection. */)
4977 (display
, xrm_string
, must_succeed
)
4978 Lisp_Object display
, xrm_string
, must_succeed
;
4980 unsigned char *xrm_option
;
4981 struct w32_display_info
*dpyinfo
;
4983 /* If initialization has already been done, return now to avoid
4984 overwriting critical parts of one_w32_display_info. */
4988 CHECK_STRING (display
);
4989 if (! NILP (xrm_string
))
4990 CHECK_STRING (xrm_string
);
4993 if (! EQ (Vwindow_system
, intern ("w32")))
4994 error ("Not using Microsoft Windows");
4997 /* Allow color mapping to be defined externally; first look in user's
4998 HOME directory, then in Emacs etc dir for a file called rgb.txt. */
5000 Lisp_Object color_file
;
5001 struct gcpro gcpro1
;
5003 color_file
= build_string ("~/rgb.txt");
5005 GCPRO1 (color_file
);
5007 if (NILP (Ffile_readable_p (color_file
)))
5009 Fexpand_file_name (build_string ("rgb.txt"),
5010 Fsymbol_value (intern ("data-directory")));
5012 Vw32_color_map
= Fx_load_color_file (color_file
);
5016 if (NILP (Vw32_color_map
))
5017 Vw32_color_map
= Fw32_default_color_map ();
5019 /* Merge in system logical colors. */
5020 add_system_logical_colors_to_map (&Vw32_color_map
);
5022 if (! NILP (xrm_string
))
5023 xrm_option
= (unsigned char *) SDATA (xrm_string
);
5025 xrm_option
= (unsigned char *) 0;
5027 /* Use this general default value to start with. */
5028 /* First remove .exe suffix from invocation-name - it looks ugly. */
5030 char basename
[ MAX_PATH
], *str
;
5032 strcpy (basename
, SDATA (Vinvocation_name
));
5033 str
= strrchr (basename
, '.');
5035 Vinvocation_name
= build_string (basename
);
5037 Vx_resource_name
= Vinvocation_name
;
5039 validate_x_resource_name ();
5041 /* This is what opens the connection and sets x_current_display.
5042 This also initializes many symbols, such as those used for input. */
5043 dpyinfo
= w32_term_init (display
, xrm_option
,
5044 (char *) SDATA (Vx_resource_name
));
5048 if (!NILP (must_succeed
))
5049 fatal ("Cannot connect to server %s.\n",
5052 error ("Cannot connect to server %s", SDATA (display
));
5057 XSETFASTINT (Vwindow_system_version
, w32_major_version
);
5061 DEFUN ("x-close-connection", Fx_close_connection
,
5062 Sx_close_connection
, 1, 1, 0,
5063 doc
: /* Close the connection to DISPLAY's server.
5064 For DISPLAY, specify either a frame or a display name (a string).
5065 If DISPLAY is nil, that stands for the selected frame's display. */)
5067 Lisp_Object display
;
5069 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
5072 if (dpyinfo
->reference_count
> 0)
5073 error ("Display still has frames on it");
5076 x_destroy_all_bitmaps (dpyinfo
);
5078 x_delete_display (dpyinfo
);
5084 DEFUN ("x-display-list", Fx_display_list
, Sx_display_list
, 0, 0, 0,
5085 doc
: /* Return the list of display names that Emacs has connections to. */)
5088 Lisp_Object tail
, result
;
5091 for (tail
= w32_display_name_list
; CONSP (tail
); tail
= XCDR (tail
))
5092 result
= Fcons (XCAR (XCAR (tail
)), result
);
5097 DEFUN ("x-synchronize", Fx_synchronize
, Sx_synchronize
, 1, 2, 0,
5098 doc
: /* This is a noop on W32 systems. */)
5100 Lisp_Object display
, on
;
5107 /***********************************************************************
5109 ***********************************************************************/
5111 DEFUN ("x-change-window-property", Fx_change_window_property
,
5112 Sx_change_window_property
, 2, 6, 0,
5113 doc
: /* Change window property PROP to VALUE on the X window of FRAME.
5114 VALUE may be a string or a list of conses, numbers and/or strings.
5115 If an element in the list is a string, it is converted to
5116 an Atom and the value of the Atom is used. If an element is a cons,
5117 it is converted to a 32 bit number where the car is the 16 top bits and the
5118 cdr is the lower 16 bits.
5119 FRAME nil or omitted means use the selected frame.
5120 If TYPE is given and non-nil, it is the name of the type of VALUE.
5121 If TYPE is not given or nil, the type is STRING.
5122 FORMAT gives the size in bits of each element if VALUE is a list.
5123 It must be one of 8, 16 or 32.
5124 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
5125 If OUTER_P is non-nil, the property is changed for the outer X window of
5126 FRAME. Default is to change on the edit X window.
5129 (prop
, value
, frame
, type
, format
, outer_p
)
5130 Lisp_Object prop
, value
, frame
, type
, format
, outer_p
;
5132 #if 0 /* TODO : port window properties to W32 */
5133 struct frame
*f
= check_x_frame (frame
);
5136 CHECK_STRING (prop
);
5137 CHECK_STRING (value
);
5140 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
5141 XChangeProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
5142 prop_atom
, XA_STRING
, 8, PropModeReplace
,
5143 SDATA (value
), SCHARS (value
));
5145 /* Make sure the property is set when we return. */
5146 XFlush (FRAME_W32_DISPLAY (f
));
5155 DEFUN ("x-delete-window-property", Fx_delete_window_property
,
5156 Sx_delete_window_property
, 1, 2, 0,
5157 doc
: /* Remove window property PROP from X window of FRAME.
5158 FRAME nil or omitted means use the selected frame. Value is PROP. */)
5160 Lisp_Object prop
, frame
;
5162 #if 0 /* TODO : port window properties to W32 */
5164 struct frame
*f
= check_x_frame (frame
);
5167 CHECK_STRING (prop
);
5169 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
5170 XDeleteProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
), prop_atom
);
5172 /* Make sure the property is removed when we return. */
5173 XFlush (FRAME_W32_DISPLAY (f
));
5181 DEFUN ("x-window-property", Fx_window_property
, Sx_window_property
,
5183 doc
: /* Value is the value of window property PROP on FRAME.
5184 If FRAME is nil or omitted, use the selected frame. Value is nil
5185 if FRAME hasn't a property with name PROP or if PROP has no string
5188 Lisp_Object prop
, frame
;
5190 #if 0 /* TODO : port window properties to W32 */
5192 struct frame
*f
= check_x_frame (frame
);
5195 Lisp_Object prop_value
= Qnil
;
5196 char *tmp_data
= NULL
;
5199 unsigned long actual_size
, bytes_remaining
;
5201 CHECK_STRING (prop
);
5203 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
5204 rc
= XGetWindowProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
5205 prop_atom
, 0, 0, False
, XA_STRING
,
5206 &actual_type
, &actual_format
, &actual_size
,
5207 &bytes_remaining
, (unsigned char **) &tmp_data
);
5210 int size
= bytes_remaining
;
5215 rc
= XGetWindowProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
5216 prop_atom
, 0, bytes_remaining
,
5218 &actual_type
, &actual_format
,
5219 &actual_size
, &bytes_remaining
,
5220 (unsigned char **) &tmp_data
);
5222 prop_value
= make_string (tmp_data
, size
);
5237 /***********************************************************************
5239 ***********************************************************************/
5241 /* Default number of seconds to wait before displaying an hourglass
5242 cursor. Duplicated from xdisp.c, but cannot use the version there
5243 due to lack of atimers on w32. */
5244 #define DEFAULT_HOURGLASS_DELAY 1
5245 extern Lisp_Object Vhourglass_delay
;
5247 /* Return non-zero if houglass timer has been started or hourglass is shown. */
5248 /* PENDING: if W32 can use atimers (atimer.[hc]) then the common impl in
5249 xdisp.c could be used. */
5252 hourglass_started ()
5254 return hourglass_shown_p
|| hourglass_timer
;
5257 /* Cancel a currently active hourglass timer, and start a new one. */
5263 int secs
, msecs
= 0;
5264 struct frame
* f
= SELECTED_FRAME ();
5266 /* No cursors on non GUI frames. */
5267 if (!FRAME_W32_P (f
))
5270 cancel_hourglass ();
5272 if (INTEGERP (Vhourglass_delay
)
5273 && XINT (Vhourglass_delay
) > 0)
5274 secs
= XFASTINT (Vhourglass_delay
);
5275 else if (FLOATP (Vhourglass_delay
)
5276 && XFLOAT_DATA (Vhourglass_delay
) > 0)
5279 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
5280 secs
= XFASTINT (tem
);
5281 msecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000;
5284 secs
= DEFAULT_HOURGLASS_DELAY
;
5286 delay
= secs
* 1000 + msecs
;
5287 hourglass_hwnd
= FRAME_W32_WINDOW (f
);
5288 hourglass_timer
= SetTimer (hourglass_hwnd
, HOURGLASS_ID
, delay
, NULL
);
5292 /* Cancel the hourglass cursor timer if active, hide an hourglass
5298 if (hourglass_timer
)
5300 KillTimer (hourglass_hwnd
, hourglass_timer
);
5301 hourglass_timer
= 0;
5304 if (hourglass_shown_p
)
5305 w32_hide_hourglass ();
5309 /* Timer function of hourglass_timer.
5311 Display an hourglass cursor. Set the hourglass_p flag in display info
5312 to indicate that an hourglass cursor is shown. */
5315 w32_show_hourglass (f
)
5318 if (!hourglass_shown_p
)
5320 f
->output_data
.w32
->hourglass_p
= 1;
5321 if (!menubar_in_use
&& !current_popup_menu
)
5322 SetCursor (f
->output_data
.w32
->hourglass_cursor
);
5323 hourglass_shown_p
= 1;
5328 /* Hide the hourglass cursor on all frames, if it is currently shown. */
5331 w32_hide_hourglass ()
5333 if (hourglass_shown_p
)
5335 struct frame
*f
= x_window_to_frame (&one_w32_display_info
,
5338 f
->output_data
.w32
->hourglass_p
= 0;
5340 /* If frame was deleted, restore to selected frame's cursor. */
5341 f
= SELECTED_FRAME ();
5343 if (FRAME_W32_P (f
))
5344 SetCursor (f
->output_data
.w32
->current_cursor
);
5346 /* No cursors on non GUI frames - restore to stock arrow cursor. */
5347 SetCursor (w32_load_cursor (IDC_ARROW
));
5349 hourglass_shown_p
= 0;
5355 /***********************************************************************
5357 ***********************************************************************/
5359 static Lisp_Object x_create_tip_frame
P_ ((struct w32_display_info
*,
5360 Lisp_Object
, Lisp_Object
));
5361 static void compute_tip_xy
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
,
5362 Lisp_Object
, int, int, int *, int *));
5364 /* The frame of a currently visible tooltip. */
5366 Lisp_Object tip_frame
;
5368 /* If non-nil, a timer started that hides the last tooltip when it
5371 Lisp_Object tip_timer
;
5374 /* If non-nil, a vector of 3 elements containing the last args
5375 with which x-show-tip was called. See there. */
5377 Lisp_Object last_show_tip_args
;
5379 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
5381 Lisp_Object Vx_max_tooltip_size
;
5385 unwind_create_tip_frame (frame
)
5388 Lisp_Object deleted
;
5390 deleted
= unwind_create_frame (frame
);
5391 if (EQ (deleted
, Qt
))
5401 /* Create a frame for a tooltip on the display described by DPYINFO.
5402 PARMS is a list of frame parameters. TEXT is the string to
5403 display in the tip frame. Value is the frame.
5405 Note that functions called here, esp. x_default_parameter can
5406 signal errors, for instance when a specified color name is
5407 undefined. We have to make sure that we're in a consistent state
5408 when this happens. */
5411 x_create_tip_frame (dpyinfo
, parms
, text
)
5412 struct w32_display_info
*dpyinfo
;
5413 Lisp_Object parms
, text
;
5416 Lisp_Object frame
, tem
;
5418 long window_prompting
= 0;
5420 int count
= SPECPDL_INDEX ();
5421 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5423 int face_change_count_before
= face_change_count
;
5425 struct buffer
*old_buffer
;
5429 /* Use this general default value to start with until we know if
5430 this frame has a specified name. */
5431 Vx_resource_name
= Vinvocation_name
;
5433 kb
= dpyinfo
->terminal
->kboard
;
5435 /* The calls to x_get_arg remove elements from PARMS, so copy it to
5436 avoid destructive changes behind our caller's back. */
5437 parms
= Fcopy_alist (parms
);
5439 /* Get the name of the frame to use for resource lookup. */
5440 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
5442 && !EQ (name
, Qunbound
)
5444 error ("Invalid frame name--not a string or nil");
5445 Vx_resource_name
= name
;
5448 GCPRO3 (parms
, name
, frame
);
5449 /* Make a frame without minibuffer nor mode-line. */
5451 f
->wants_modeline
= 0;
5452 XSETFRAME (frame
, f
);
5454 buffer
= Fget_buffer_create (build_string (" *tip*"));
5455 Fset_window_buffer (FRAME_ROOT_WINDOW (f
), buffer
, Qnil
);
5456 old_buffer
= current_buffer
;
5457 set_buffer_internal_1 (XBUFFER (buffer
));
5458 current_buffer
->truncate_lines
= Qnil
;
5459 specbind (Qinhibit_read_only
, Qt
);
5460 specbind (Qinhibit_modification_hooks
, Qt
);
5463 set_buffer_internal_1 (old_buffer
);
5465 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
5466 record_unwind_protect (unwind_create_tip_frame
, frame
);
5468 /* By setting the output method, we're essentially saying that
5469 the frame is live, as per FRAME_LIVE_P. If we get a signal
5470 from this point on, x_destroy_window might screw up reference
5472 f
->terminal
= dpyinfo
->terminal
;
5473 f
->terminal
->reference_count
++;
5474 f
->output_method
= output_w32
;
5475 f
->output_data
.w32
=
5476 (struct w32_output
*) xmalloc (sizeof (struct w32_output
));
5477 bzero (f
->output_data
.w32
, sizeof (struct w32_output
));
5479 FRAME_FONTSET (f
) = -1;
5480 f
->icon_name
= Qnil
;
5483 image_cache_refcount
= FRAME_IMAGE_CACHE (f
)->refcount
;
5484 dpyinfo_refcount
= dpyinfo
->reference_count
;
5485 #endif /* GLYPH_DEBUG */
5486 FRAME_KBOARD (f
) = kb
;
5487 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
5488 f
->output_data
.w32
->explicit_parent
= 0;
5490 /* Set the name; the functions to which we pass f expect the name to
5492 if (EQ (name
, Qunbound
) || NILP (name
))
5494 f
->name
= build_string (dpyinfo
->w32_id_name
);
5495 f
->explicit_name
= 0;
5500 f
->explicit_name
= 1;
5501 /* use the frame's title when getting resources for this frame. */
5502 specbind (Qx_resource_name
, name
);
5505 f
->resx
= dpyinfo
->resx
;
5506 f
->resy
= dpyinfo
->resy
;
5508 if (uniscribe_available
)
5509 register_font_driver (&uniscribe_font_driver
, f
);
5510 register_font_driver (&w32font_driver
, f
);
5512 x_default_parameter (f
, parms
, Qfont_backend
, Qnil
,
5513 "fontBackend", "FontBackend", RES_TYPE_STRING
);
5515 /* Extract the window parameters from the supplied values
5516 that are needed to determine window geometry. */
5517 x_default_font_parameter (f
, parms
);
5519 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
5520 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
5521 /* This defaults to 2 in order to match xterm. We recognize either
5522 internalBorderWidth or internalBorder (which is what xterm calls
5524 if (NILP (Fassq (Qinternal_border_width
, parms
)))
5528 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
5529 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
5530 if (! EQ (value
, Qunbound
))
5531 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
5534 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
5535 "internalBorderWidth", "internalBorderWidth",
5538 /* Also do the stuff which must be set before the window exists. */
5539 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
5540 "foreground", "Foreground", RES_TYPE_STRING
);
5541 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
5542 "background", "Background", RES_TYPE_STRING
);
5543 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
5544 "pointerColor", "Foreground", RES_TYPE_STRING
);
5545 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
5546 "cursorColor", "Foreground", RES_TYPE_STRING
);
5547 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
5548 "borderColor", "BorderColor", RES_TYPE_STRING
);
5550 /* Init faces before x_default_parameter is called for scroll-bar
5551 parameters because that function calls x_set_scroll_bar_width,
5552 which calls change_frame_size, which calls Fset_window_buffer,
5553 which runs hooks, which call Fvertical_motion. At the end, we
5554 end up in init_iterator with a null face cache, which should not
5556 init_frame_faces (f
);
5558 f
->output_data
.w32
->dwStyle
= WS_BORDER
| WS_POPUP
| WS_DISABLED
;
5559 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
5561 window_prompting
= x_figure_window_size (f
, parms
, 0);
5563 /* No fringes on tip frame. */
5565 f
->left_fringe_width
= 0;
5566 f
->right_fringe_width
= 0;
5569 my_create_tip_window (f
);
5574 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
5575 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
5576 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
5577 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
5578 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
5579 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
5581 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
5582 Change will not be effected unless different from the current
5584 width
= FRAME_COLS (f
);
5585 height
= FRAME_LINES (f
);
5586 FRAME_LINES (f
) = 0;
5587 SET_FRAME_COLS (f
, 0);
5588 change_frame_size (f
, height
, width
, 1, 0, 0);
5590 /* Add `tooltip' frame parameter's default value. */
5591 if (NILP (Fframe_parameter (frame
, Qtooltip
)))
5592 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qtooltip
, Qt
), Qnil
));
5594 /* Set up faces after all frame parameters are known. This call
5595 also merges in face attributes specified for new frames.
5597 Frame parameters may be changed if .Xdefaults contains
5598 specifications for the default font. For example, if there is an
5599 `Emacs.default.attributeBackground: pink', the `background-color'
5600 attribute of the frame get's set, which let's the internal border
5601 of the tooltip frame appear in pink. Prevent this. */
5603 Lisp_Object bg
= Fframe_parameter (frame
, Qbackground_color
);
5604 Lisp_Object fg
= Fframe_parameter (frame
, Qforeground_color
);
5605 Lisp_Object colors
= Qnil
;
5607 /* Set tip_frame here, so that */
5609 call2 (Qface_set_after_frame_default
, frame
, Qnil
);
5611 if (!EQ (bg
, Fframe_parameter (frame
, Qbackground_color
)))
5612 colors
= Fcons (Fcons (Qbackground_color
, bg
), colors
);
5613 if (!EQ (fg
, Fframe_parameter (frame
, Qforeground_color
)))
5614 colors
= Fcons (Fcons (Qforeground_color
, fg
), colors
);
5617 Fmodify_frame_parameters (frame
, colors
);
5624 /* It is now ok to make the frame official even if we get an error
5625 below. And the frame needs to be on Vframe_list or making it
5626 visible won't work. */
5627 Vframe_list
= Fcons (frame
, Vframe_list
);
5629 /* Now that the frame is official, it counts as a reference to
5631 FRAME_W32_DISPLAY_INFO (f
)->reference_count
++;
5633 /* Setting attributes of faces of the tooltip frame from resources
5634 and similar will increment face_change_count, which leads to the
5635 clearing of all current matrices. Since this isn't necessary
5636 here, avoid it by resetting face_change_count to the value it
5637 had before we created the tip frame. */
5638 face_change_count
= face_change_count_before
;
5640 /* Discard the unwind_protect. */
5641 return unbind_to (count
, frame
);
5645 /* Compute where to display tip frame F. PARMS is the list of frame
5646 parameters for F. DX and DY are specified offsets from the current
5647 location of the mouse. WIDTH and HEIGHT are the width and height
5648 of the tooltip. Return coordinates relative to the root window of
5649 the display in *ROOT_X, and *ROOT_Y. */
5652 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, root_x
, root_y
)
5654 Lisp_Object parms
, dx
, dy
;
5656 int *root_x
, *root_y
;
5658 Lisp_Object left
, top
;
5659 int min_x
, min_y
, max_x
, max_y
;
5661 /* User-specified position? */
5662 left
= Fcdr (Fassq (Qleft
, parms
));
5663 top
= Fcdr (Fassq (Qtop
, parms
));
5665 /* Move the tooltip window where the mouse pointer is. Resize and
5667 if (!INTEGERP (left
) || !INTEGERP (top
))
5671 /* Default min and max values. */
5674 max_x
= x_display_pixel_width (FRAME_W32_DISPLAY_INFO (f
));
5675 max_y
= x_display_pixel_height (FRAME_W32_DISPLAY_INFO (f
));
5683 /* If multiple monitor support is available, constrain the tip onto
5684 the current monitor. This improves the above by allowing negative
5685 co-ordinates if monitor positions are such that they are valid, and
5686 snaps a tooltip onto a single monitor if we are close to the edge
5687 where it would otherwise flow onto the other monitor (or into
5688 nothingness if there is a gap in the overlap). */
5689 if (monitor_from_point_fn
&& get_monitor_info_fn
)
5691 struct MONITOR_INFO info
;
5693 = monitor_from_point_fn (pt
, MONITOR_DEFAULT_TO_NEAREST
);
5694 info
.cbSize
= sizeof (info
);
5696 if (get_monitor_info_fn (monitor
, &info
))
5698 min_x
= info
.rcWork
.left
;
5699 min_y
= info
.rcWork
.top
;
5700 max_x
= info
.rcWork
.right
;
5701 max_y
= info
.rcWork
.bottom
;
5707 *root_y
= XINT (top
);
5708 else if (*root_y
+ XINT (dy
) <= min_y
)
5709 *root_y
= min_y
; /* Can happen for negative dy */
5710 else if (*root_y
+ XINT (dy
) + height
<= max_y
)
5711 /* It fits below the pointer */
5712 *root_y
+= XINT (dy
);
5713 else if (height
+ XINT (dy
) + min_y
<= *root_y
)
5714 /* It fits above the pointer. */
5715 *root_y
-= height
+ XINT (dy
);
5717 /* Put it on the top. */
5720 if (INTEGERP (left
))
5721 *root_x
= XINT (left
);
5722 else if (*root_x
+ XINT (dx
) <= min_x
)
5723 *root_x
= 0; /* Can happen for negative dx */
5724 else if (*root_x
+ XINT (dx
) + width
<= max_x
)
5725 /* It fits to the right of the pointer. */
5726 *root_x
+= XINT (dx
);
5727 else if (width
+ XINT (dx
) + min_x
<= *root_x
)
5728 /* It fits to the left of the pointer. */
5729 *root_x
-= width
+ XINT (dx
);
5731 /* Put it left justified on the screen -- it ought to fit that way. */
5736 DEFUN ("x-show-tip", Fx_show_tip
, Sx_show_tip
, 1, 6, 0,
5737 doc
: /* Show STRING in a \"tooltip\" window on frame FRAME.
5738 A tooltip window is a small window displaying a string.
5740 This is an internal function; Lisp code should call `tooltip-show'.
5742 FRAME nil or omitted means use the selected frame.
5744 PARMS is an optional list of frame parameters which can be
5745 used to change the tooltip's appearance.
5747 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
5748 means use the default timeout of 5 seconds.
5750 If the list of frame parameters PARMS contains a `left' parameter,
5751 the tooltip is displayed at that x-position. Otherwise it is
5752 displayed at the mouse position, with offset DX added (default is 5 if
5753 DX isn't specified). Likewise for the y-position; if a `top' frame
5754 parameter is specified, it determines the y-position of the tooltip
5755 window, otherwise it is displayed at the mouse position, with offset
5756 DY added (default is -10).
5758 A tooltip's maximum size is specified by `x-max-tooltip-size'.
5759 Text larger than the specified size is clipped. */)
5760 (string
, frame
, parms
, timeout
, dx
, dy
)
5761 Lisp_Object string
, frame
, parms
, timeout
, dx
, dy
;
5766 struct buffer
*old_buffer
;
5767 struct text_pos pos
;
5768 int i
, width
, height
;
5769 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
5770 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
5771 int count
= SPECPDL_INDEX ();
5773 specbind (Qinhibit_redisplay
, Qt
);
5775 GCPRO4 (string
, parms
, frame
, timeout
);
5777 CHECK_STRING (string
);
5778 f
= check_x_frame (frame
);
5780 timeout
= make_number (5);
5782 CHECK_NATNUM (timeout
);
5785 dx
= make_number (5);
5790 dy
= make_number (-10);
5794 if (NILP (last_show_tip_args
))
5795 last_show_tip_args
= Fmake_vector (make_number (3), Qnil
);
5797 if (!NILP (tip_frame
))
5799 Lisp_Object last_string
= AREF (last_show_tip_args
, 0);
5800 Lisp_Object last_frame
= AREF (last_show_tip_args
, 1);
5801 Lisp_Object last_parms
= AREF (last_show_tip_args
, 2);
5803 if (EQ (frame
, last_frame
)
5804 && !NILP (Fequal (last_string
, string
))
5805 && !NILP (Fequal (last_parms
, parms
)))
5807 struct frame
*f
= XFRAME (tip_frame
);
5809 /* Only DX and DY have changed. */
5810 if (!NILP (tip_timer
))
5812 Lisp_Object timer
= tip_timer
;
5814 call1 (Qcancel_timer
, timer
);
5818 compute_tip_xy (f
, parms
, dx
, dy
, FRAME_PIXEL_WIDTH (f
),
5819 FRAME_PIXEL_HEIGHT (f
), &root_x
, &root_y
);
5821 /* Put tooltip in topmost group and in position. */
5822 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOPMOST
,
5823 root_x
, root_y
, 0, 0,
5824 SWP_NOSIZE
| SWP_NOACTIVATE
);
5826 /* Ensure tooltip is on top of other topmost windows (eg menus). */
5827 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOP
,
5829 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5836 /* Hide a previous tip, if any. */
5839 ASET (last_show_tip_args
, 0, string
);
5840 ASET (last_show_tip_args
, 1, frame
);
5841 ASET (last_show_tip_args
, 2, parms
);
5843 /* Add default values to frame parameters. */
5844 if (NILP (Fassq (Qname
, parms
)))
5845 parms
= Fcons (Fcons (Qname
, build_string ("tooltip")), parms
);
5846 if (NILP (Fassq (Qinternal_border_width
, parms
)))
5847 parms
= Fcons (Fcons (Qinternal_border_width
, make_number (3)), parms
);
5848 if (NILP (Fassq (Qborder_width
, parms
)))
5849 parms
= Fcons (Fcons (Qborder_width
, make_number (1)), parms
);
5850 if (NILP (Fassq (Qborder_color
, parms
)))
5851 parms
= Fcons (Fcons (Qborder_color
, build_string ("lightyellow")), parms
);
5852 if (NILP (Fassq (Qbackground_color
, parms
)))
5853 parms
= Fcons (Fcons (Qbackground_color
, build_string ("lightyellow")),
5856 /* Block input until the tip has been fully drawn, to avoid crashes
5857 when drawing tips in menus. */
5860 /* Create a frame for the tooltip, and record it in the global
5861 variable tip_frame. */
5862 frame
= x_create_tip_frame (FRAME_W32_DISPLAY_INFO (f
), parms
, string
);
5865 /* Set up the frame's root window. */
5866 w
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5867 w
->left_col
= w
->top_line
= make_number (0);
5869 if (CONSP (Vx_max_tooltip_size
)
5870 && INTEGERP (XCAR (Vx_max_tooltip_size
))
5871 && XINT (XCAR (Vx_max_tooltip_size
)) > 0
5872 && INTEGERP (XCDR (Vx_max_tooltip_size
))
5873 && XINT (XCDR (Vx_max_tooltip_size
)) > 0)
5875 w
->total_cols
= XCAR (Vx_max_tooltip_size
);
5876 w
->total_lines
= XCDR (Vx_max_tooltip_size
);
5880 w
->total_cols
= make_number (80);
5881 w
->total_lines
= make_number (40);
5884 FRAME_TOTAL_COLS (f
) = XINT (w
->total_cols
);
5886 w
->pseudo_window_p
= 1;
5888 /* Display the tooltip text in a temporary buffer. */
5889 old_buffer
= current_buffer
;
5890 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f
))->buffer
));
5891 current_buffer
->truncate_lines
= Qnil
;
5892 clear_glyph_matrix (w
->desired_matrix
);
5893 clear_glyph_matrix (w
->current_matrix
);
5894 SET_TEXT_POS (pos
, BEGV
, BEGV_BYTE
);
5895 try_window (FRAME_ROOT_WINDOW (f
), pos
, 0);
5897 /* Compute width and height of the tooltip. */
5899 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
5901 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
5905 /* Stop at the first empty row at the end. */
5906 if (!row
->enabled_p
|| !row
->displays_text_p
)
5909 /* Let the row go over the full width of the frame. */
5910 row
->full_width_p
= 1;
5912 #ifdef TODO /* Investigate why some fonts need more width than is
5913 calculated for some tooltips. */
5914 /* There's a glyph at the end of rows that is use to place
5915 the cursor there. Don't include the width of this glyph. */
5916 if (row
->used
[TEXT_AREA
])
5918 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
5919 row_width
= row
->pixel_width
- last
->pixel_width
;
5923 row_width
= row
->pixel_width
;
5925 /* TODO: find why tips do not draw along baseline as instructed. */
5926 height
+= row
->height
;
5927 width
= max (width
, row_width
);
5930 /* Add the frame's internal border to the width and height the X
5931 window should have. */
5932 height
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
5933 width
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
5935 /* Move the tooltip window where the mouse pointer is. Resize and
5937 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, &root_x
, &root_y
);
5940 /* Adjust Window size to take border into account. */
5942 rect
.left
= rect
.top
= 0;
5944 rect
.bottom
= height
;
5945 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
5946 FRAME_EXTERNAL_MENU_BAR (f
));
5948 /* Position and size tooltip, and put it in the topmost group.
5949 The add-on of 3 to the 5th argument is a kludge: without it,
5950 some fonts cause the last character of the tip to be truncated,
5951 for some obscure reason. */
5952 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOPMOST
,
5953 root_x
, root_y
, rect
.right
- rect
.left
+ 3,
5954 rect
.bottom
- rect
.top
, SWP_NOACTIVATE
);
5956 /* Ensure tooltip is on top of other topmost windows (eg menus). */
5957 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOP
,
5959 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5961 /* Let redisplay know that we have made the frame visible already. */
5962 f
->async_visible
= 1;
5964 ShowWindow (FRAME_W32_WINDOW (f
), SW_SHOWNOACTIVATE
);
5967 /* Draw into the window. */
5968 w
->must_be_updated_p
= 1;
5969 update_single_window (w
, 1);
5973 /* Restore original current buffer. */
5974 set_buffer_internal_1 (old_buffer
);
5975 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
5978 /* Let the tip disappear after timeout seconds. */
5979 tip_timer
= call3 (intern ("run-at-time"), timeout
, Qnil
,
5980 intern ("x-hide-tip"));
5983 return unbind_to (count
, Qnil
);
5987 DEFUN ("x-hide-tip", Fx_hide_tip
, Sx_hide_tip
, 0, 0, 0,
5988 doc
: /* Hide the current tooltip window, if there is any.
5989 Value is t if tooltip was open, nil otherwise. */)
5993 Lisp_Object deleted
, frame
, timer
;
5994 struct gcpro gcpro1
, gcpro2
;
5996 /* Return quickly if nothing to do. */
5997 if (NILP (tip_timer
) && NILP (tip_frame
))
6002 GCPRO2 (frame
, timer
);
6003 tip_frame
= tip_timer
= deleted
= Qnil
;
6005 count
= SPECPDL_INDEX ();
6006 specbind (Qinhibit_redisplay
, Qt
);
6007 specbind (Qinhibit_quit
, Qt
);
6010 call1 (Qcancel_timer
, timer
);
6014 delete_frame (frame
, Qnil
);
6019 return unbind_to (count
, deleted
);
6024 /***********************************************************************
6025 File selection dialog
6026 ***********************************************************************/
6027 extern Lisp_Object Qfile_name_history
;
6029 /* Callback for altering the behavior of the Open File dialog.
6030 Makes the Filename text field contain "Current Directory" and be
6031 read-only when "Directories" is selected in the filter. This
6032 allows us to work around the fact that the standard Open File
6033 dialog does not support directories. */
6035 file_dialog_callback (hwnd
, msg
, wParam
, lParam
)
6041 if (msg
== WM_NOTIFY
)
6043 OFNOTIFY
* notify
= (OFNOTIFY
*)lParam
;
6044 /* Detect when the Filter dropdown is changed. */
6045 if (notify
->hdr
.code
== CDN_TYPECHANGE
6046 || notify
->hdr
.code
== CDN_INITDONE
)
6048 HWND dialog
= GetParent (hwnd
);
6049 HWND edit_control
= GetDlgItem (dialog
, FILE_NAME_TEXT_FIELD
);
6051 /* Directories is in index 2. */
6052 if (notify
->lpOFN
->nFilterIndex
== 2)
6054 CommDlg_OpenSave_SetControlText (dialog
, FILE_NAME_TEXT_FIELD
,
6055 "Current Directory");
6056 EnableWindow (edit_control
, FALSE
);
6060 /* Don't override default filename on init done. */
6061 if (notify
->hdr
.code
== CDN_TYPECHANGE
)
6062 CommDlg_OpenSave_SetControlText (dialog
,
6063 FILE_NAME_TEXT_FIELD
, "");
6064 EnableWindow (edit_control
, TRUE
);
6071 /* Since we compile with _WIN32_WINNT set to 0x0400 (for NT4 compatibility)
6072 we end up with the old file dialogs. Define a big enough struct for the
6073 new dialog to trick GetOpenFileName into giving us the new dialogs on
6074 Windows 2000 and XP. */
6077 OPENFILENAME real_details
;
6084 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 5, 0,
6085 doc
: /* Read file name, prompting with PROMPT in directory DIR.
6086 Use a file selection dialog.
6087 Select DEFAULT-FILENAME in the dialog's file selection box, if
6088 specified. Ensure that file exists if MUSTMATCH is non-nil.
6089 If ONLY-DIR-P is non-nil, the user can only select directories. */)
6090 (prompt
, dir
, default_filename
, mustmatch
, only_dir_p
)
6091 Lisp_Object prompt
, dir
, default_filename
, mustmatch
, only_dir_p
;
6093 struct frame
*f
= SELECTED_FRAME ();
6094 Lisp_Object file
= Qnil
;
6095 int count
= SPECPDL_INDEX ();
6096 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
6097 char filename
[MAX_PATH
+ 1];
6098 char init_dir
[MAX_PATH
+ 1];
6099 int default_filter_index
= 1; /* 1: All Files, 2: Directories only */
6101 GCPRO6 (prompt
, dir
, default_filename
, mustmatch
, only_dir_p
, file
);
6102 CHECK_STRING (prompt
);
6105 /* Create the dialog with PROMPT as title, using DIR as initial
6106 directory and using "*" as pattern. */
6107 dir
= Fexpand_file_name (dir
, Qnil
);
6108 strncpy (init_dir
, SDATA (ENCODE_FILE (dir
)), MAX_PATH
);
6109 init_dir
[MAX_PATH
] = '\0';
6110 unixtodos_filename (init_dir
);
6112 if (STRINGP (default_filename
))
6114 char *file_name_only
;
6115 char *full_path_name
= SDATA (ENCODE_FILE (default_filename
));
6117 unixtodos_filename (full_path_name
);
6119 file_name_only
= strrchr (full_path_name
, '\\');
6120 if (!file_name_only
)
6121 file_name_only
= full_path_name
;
6125 strncpy (filename
, file_name_only
, MAX_PATH
);
6126 filename
[MAX_PATH
] = '\0';
6132 NEWOPENFILENAME new_file_details
;
6133 BOOL file_opened
= FALSE
;
6134 OPENFILENAME
* file_details
= &new_file_details
.real_details
;
6136 /* Prevent redisplay. */
6137 specbind (Qinhibit_redisplay
, Qt
);
6140 bzero (&new_file_details
, sizeof (new_file_details
));
6141 /* Apparently NT4 crashes if you give it an unexpected size.
6142 I'm not sure about Windows 9x, so play it safe. */
6143 if (w32_major_version
> 4 && w32_major_version
< 95)
6144 file_details
->lStructSize
= sizeof (NEWOPENFILENAME
);
6146 file_details
->lStructSize
= sizeof (OPENFILENAME
);
6148 file_details
->hwndOwner
= FRAME_W32_WINDOW (f
);
6149 /* Undocumented Bug in Common File Dialog:
6150 If a filter is not specified, shell links are not resolved. */
6151 file_details
->lpstrFilter
= "All Files (*.*)\0*.*\0Directories\0*|*\0\0";
6152 file_details
->lpstrFile
= filename
;
6153 file_details
->nMaxFile
= sizeof (filename
);
6154 file_details
->lpstrInitialDir
= init_dir
;
6155 file_details
->lpstrTitle
= SDATA (prompt
);
6157 if (! NILP (only_dir_p
))
6158 default_filter_index
= 2;
6160 file_details
->nFilterIndex
= default_filter_index
;
6162 file_details
->Flags
= (OFN_HIDEREADONLY
| OFN_NOCHANGEDIR
6163 | OFN_EXPLORER
| OFN_ENABLEHOOK
);
6164 if (!NILP (mustmatch
))
6166 /* Require that the path to the parent directory exists. */
6167 file_details
->Flags
|= OFN_PATHMUSTEXIST
;
6168 /* If we are looking for a file, require that it exists. */
6169 if (NILP (only_dir_p
))
6170 file_details
->Flags
|= OFN_FILEMUSTEXIST
;
6173 file_details
->lpfnHook
= (LPOFNHOOKPROC
) file_dialog_callback
;
6175 file_opened
= GetOpenFileName (file_details
);
6181 dostounix_filename (filename
);
6183 if (file_details
->nFilterIndex
== 2)
6185 /* "Directories" selected - strip dummy file name. */
6186 char * last
= strrchr (filename
, '/');
6190 file
= DECODE_FILE (build_string (filename
));
6192 /* User cancelled the dialog without making a selection. */
6193 else if (!CommDlgExtendedError ())
6195 /* An error occurred, fallback on reading from the mini-buffer. */
6197 file
= Fcompleting_read (prompt
, intern ("read-file-name-internal"),
6198 dir
, mustmatch
, dir
, Qfile_name_history
,
6199 default_filename
, Qnil
);
6201 file
= unbind_to (count
, file
);
6206 /* Make "Cancel" equivalent to C-g. */
6208 Fsignal (Qquit
, Qnil
);
6210 return unbind_to (count
, file
);
6214 /* Moving files to the system recycle bin.
6215 Used by `move-file-to-trash' instead of the default moving to ~/.Trash */
6216 DEFUN ("system-move-file-to-trash", Fsystem_move_file_to_trash
,
6217 Ssystem_move_file_to_trash
, 1, 1, 0,
6218 doc
: /* Move file or directory named FILENAME to the recycle bin. */)
6220 Lisp_Object filename
;
6222 Lisp_Object handler
;
6223 Lisp_Object encoded_file
;
6224 Lisp_Object operation
;
6226 operation
= Qdelete_file
;
6227 if (!NILP (Ffile_directory_p (filename
))
6228 && NILP (Ffile_symlink_p (filename
)))
6230 operation
= intern ("delete-directory");
6231 filename
= Fdirectory_file_name (filename
);
6233 filename
= Fexpand_file_name (filename
, Qnil
);
6235 handler
= Ffind_file_name_handler (filename
, operation
);
6236 if (!NILP (handler
))
6237 return call2 (handler
, operation
, filename
);
6239 encoded_file
= ENCODE_FILE (filename
);
6243 SHFILEOPSTRUCT file_op
;
6244 char tmp_path
[MAX_PATH
+ 1];
6246 path
= map_w32_filename (SDATA (encoded_file
), NULL
);
6248 /* On Windows, write permission is required to delete/move files. */
6249 _chmod (path
, 0666);
6251 bzero (tmp_path
, sizeof (tmp_path
));
6252 strcpy (tmp_path
, path
);
6254 bzero (&file_op
, sizeof (file_op
));
6255 file_op
.hwnd
= HWND_DESKTOP
;
6256 file_op
.wFunc
= FO_DELETE
;
6257 file_op
.pFrom
= tmp_path
;
6258 file_op
.fFlags
= FOF_SILENT
| FOF_NOCONFIRMATION
| FOF_ALLOWUNDO
6259 | FOF_NOERRORUI
| FOF_NO_CONNECTED_ELEMENTS
;
6260 file_op
.fAnyOperationsAborted
= FALSE
;
6262 if (SHFileOperation (&file_op
) != 0)
6263 report_file_error ("Removing old name", list1 (filename
));
6269 /***********************************************************************
6270 w32 specialized functions
6271 ***********************************************************************/
6273 DEFUN ("w32-send-sys-command", Fw32_send_sys_command
,
6274 Sw32_send_sys_command
, 1, 2, 0,
6275 doc
: /* Send frame a Windows WM_SYSCOMMAND message of type COMMAND.
6276 Some useful values for COMMAND are #xf030 to maximize frame (#xf020
6277 to minimize), #xf120 to restore frame to original size, and #xf100
6278 to activate the menubar for keyboard access. #xf140 activates the
6279 screen saver if defined.
6281 If optional parameter FRAME is not specified, use selected frame. */)
6283 Lisp_Object command
, frame
;
6285 FRAME_PTR f
= check_x_frame (frame
);
6287 CHECK_NUMBER (command
);
6289 PostMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, XINT (command
), 0);
6294 DEFUN ("w32-shell-execute", Fw32_shell_execute
, Sw32_shell_execute
, 2, 4, 0,
6295 doc
: /* Get Windows to perform OPERATION on DOCUMENT.
6296 This is a wrapper around the ShellExecute system function, which
6297 invokes the application registered to handle OPERATION for DOCUMENT.
6299 OPERATION is either nil or a string that names a supported operation.
6300 What operations can be used depends on the particular DOCUMENT and its
6301 handler application, but typically it is one of the following common
6304 \"open\" - open DOCUMENT, which could be a file, a directory, or an
6305 executable program. If it is an application, that
6306 application is launched in the current buffer's default
6307 directory. Otherwise, the application associated with
6308 DOCUMENT is launched in the buffer's default directory.
6309 \"print\" - print DOCUMENT, which must be a file
6310 \"explore\" - start the Windows Explorer on DOCUMENT
6311 \"edit\" - launch an editor and open DOCUMENT for editing; which
6312 editor is launched depends on the association for the
6314 \"find\" - initiate search starting from DOCUMENT which must specify
6316 nil - invoke the default OPERATION, or \"open\" if default is
6317 not defined or unavailable
6319 DOCUMENT is typically the name of a document file or a URL, but can
6320 also be a program executable to run, or a directory to open in the
6323 If DOCUMENT is a program executable, the optional third arg PARAMETERS
6324 can be a string containing command line parameters that will be passed
6325 to the program; otherwise, PARAMETERS should be nil or unspecified.
6327 Optional fourth argument SHOW-FLAG can be used to control how the
6328 application will be displayed when it is invoked. If SHOW-FLAG is nil
6329 or unspecified, the application is displayed normally, otherwise it is
6330 an integer representing a ShowWindow flag:
6335 6 - start minimized */)
6336 (operation
, document
, parameters
, show_flag
)
6337 Lisp_Object operation
, document
, parameters
, show_flag
;
6339 Lisp_Object current_dir
;
6342 CHECK_STRING (document
);
6344 /* Encode filename, current directory and parameters. */
6345 current_dir
= ENCODE_FILE (current_buffer
->directory
);
6346 document
= ENCODE_FILE (document
);
6347 if (STRINGP (parameters
))
6348 parameters
= ENCODE_SYSTEM (parameters
);
6350 if ((int) ShellExecute (NULL
,
6351 (STRINGP (operation
) ?
6352 SDATA (operation
) : NULL
),
6354 (STRINGP (parameters
) ?
6355 SDATA (parameters
) : NULL
),
6356 SDATA (current_dir
),
6357 (INTEGERP (show_flag
) ?
6358 XINT (show_flag
) : SW_SHOWDEFAULT
))
6361 errstr
= w32_strerror (0);
6362 /* The error string might be encoded in the locale's encoding. */
6363 if (!NILP (Vlocale_coding_system
))
6365 Lisp_Object decoded
=
6366 code_convert_string_norecord (make_unibyte_string (errstr
,
6368 Vlocale_coding_system
, 0);
6369 errstr
= (char *)SDATA (decoded
);
6371 error ("ShellExecute failed: %s", errstr
);
6374 /* Lookup virtual keycode from string representing the name of a
6375 non-ascii keystroke into the corresponding virtual key, using
6376 lispy_function_keys. */
6378 lookup_vk_code (char *key
)
6382 for (i
= 0; i
< 256; i
++)
6383 if (lispy_function_keys
[i
]
6384 && strcmp (lispy_function_keys
[i
], key
) == 0)
6390 /* Convert a one-element vector style key sequence to a hot key
6393 w32_parse_hot_key (key
)
6396 /* Copied from Fdefine_key and store_in_keymap. */
6397 register Lisp_Object c
;
6401 struct gcpro gcpro1
;
6405 if (XFASTINT (Flength (key
)) != 1)
6410 c
= Faref (key
, make_number (0));
6412 if (CONSP (c
) && lucid_event_type_list_p (c
))
6413 c
= Fevent_convert_list (c
);
6417 if (! INTEGERP (c
) && ! SYMBOLP (c
))
6418 error ("Key definition is invalid");
6420 /* Work out the base key and the modifiers. */
6423 c
= parse_modifiers (c
);
6424 lisp_modifiers
= XINT (Fcar (Fcdr (c
)));
6428 vk_code
= lookup_vk_code (SDATA (SYMBOL_NAME (c
)));
6430 else if (INTEGERP (c
))
6432 lisp_modifiers
= XINT (c
) & ~CHARACTERBITS
;
6433 /* Many ascii characters are their own virtual key code. */
6434 vk_code
= XINT (c
) & CHARACTERBITS
;
6437 if (vk_code
< 0 || vk_code
> 255)
6440 if ((lisp_modifiers
& meta_modifier
) != 0
6441 && !NILP (Vw32_alt_is_meta
))
6442 lisp_modifiers
|= alt_modifier
;
6444 /* Supply defs missing from mingw32. */
6446 #define MOD_ALT 0x0001
6447 #define MOD_CONTROL 0x0002
6448 #define MOD_SHIFT 0x0004
6449 #define MOD_WIN 0x0008
6452 /* Convert lisp modifiers to Windows hot-key form. */
6453 w32_modifiers
= (lisp_modifiers
& hyper_modifier
) ? MOD_WIN
: 0;
6454 w32_modifiers
|= (lisp_modifiers
& alt_modifier
) ? MOD_ALT
: 0;
6455 w32_modifiers
|= (lisp_modifiers
& ctrl_modifier
) ? MOD_CONTROL
: 0;
6456 w32_modifiers
|= (lisp_modifiers
& shift_modifier
) ? MOD_SHIFT
: 0;
6458 return HOTKEY (vk_code
, w32_modifiers
);
6461 DEFUN ("w32-register-hot-key", Fw32_register_hot_key
,
6462 Sw32_register_hot_key
, 1, 1, 0,
6463 doc
: /* Register KEY as a hot-key combination.
6464 Certain key combinations like Alt-Tab are reserved for system use on
6465 Windows, and therefore are normally intercepted by the system. However,
6466 most of these key combinations can be received by registering them as
6467 hot-keys, overriding their special meaning.
6469 KEY must be a one element key definition in vector form that would be
6470 acceptable to `define-key' (e.g. [A-tab] for Alt-Tab). The meta
6471 modifier is interpreted as Alt if `w32-alt-is-meta' is t, and hyper
6472 is always interpreted as the Windows modifier keys.
6474 The return value is the hotkey-id if registered, otherwise nil. */)
6478 key
= w32_parse_hot_key (key
);
6480 if (!NILP (key
) && NILP (Fmemq (key
, w32_grabbed_keys
)))
6482 /* Reuse an empty slot if possible. */
6483 Lisp_Object item
= Fmemq (Qnil
, w32_grabbed_keys
);
6485 /* Safe to add new key to list, even if we have focus. */
6487 w32_grabbed_keys
= Fcons (key
, w32_grabbed_keys
);
6489 XSETCAR (item
, key
);
6491 /* Notify input thread about new hot-key definition, so that it
6492 takes effect without needing to switch focus. */
6493 #ifdef USE_LISP_UNION_TYPE
6494 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_REGISTER_HOT_KEY
,
6497 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_REGISTER_HOT_KEY
,
6505 DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key
,
6506 Sw32_unregister_hot_key
, 1, 1, 0,
6507 doc
: /* Unregister KEY as a hot-key combination. */)
6513 if (!INTEGERP (key
))
6514 key
= w32_parse_hot_key (key
);
6516 item
= Fmemq (key
, w32_grabbed_keys
);
6520 /* Notify input thread about hot-key definition being removed, so
6521 that it takes effect without needing focus switch. */
6522 #ifdef USE_LISP_UNION_TYPE
6523 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_UNREGISTER_HOT_KEY
,
6524 (WPARAM
) XINT (XCAR (item
)), (LPARAM
) item
.i
))
6526 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_UNREGISTER_HOT_KEY
,
6527 (WPARAM
) XINT (XCAR (item
)), (LPARAM
) item
))
6531 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6538 DEFUN ("w32-registered-hot-keys", Fw32_registered_hot_keys
,
6539 Sw32_registered_hot_keys
, 0, 0, 0,
6540 doc
: /* Return list of registered hot-key IDs. */)
6543 return Fdelq (Qnil
, Fcopy_sequence (w32_grabbed_keys
));
6546 DEFUN ("w32-reconstruct-hot-key", Fw32_reconstruct_hot_key
,
6547 Sw32_reconstruct_hot_key
, 1, 1, 0,
6548 doc
: /* Convert hot-key ID to a lisp key combination.
6549 usage: (w32-reconstruct-hot-key ID) */)
6551 Lisp_Object hotkeyid
;
6553 int vk_code
, w32_modifiers
;
6556 CHECK_NUMBER (hotkeyid
);
6558 vk_code
= HOTKEY_VK_CODE (hotkeyid
);
6559 w32_modifiers
= HOTKEY_MODIFIERS (hotkeyid
);
6561 if (vk_code
< 256 && lispy_function_keys
[vk_code
])
6562 key
= intern (lispy_function_keys
[vk_code
]);
6564 key
= make_number (vk_code
);
6566 key
= Fcons (key
, Qnil
);
6567 if (w32_modifiers
& MOD_SHIFT
)
6568 key
= Fcons (Qshift
, key
);
6569 if (w32_modifiers
& MOD_CONTROL
)
6570 key
= Fcons (Qctrl
, key
);
6571 if (w32_modifiers
& MOD_ALT
)
6572 key
= Fcons (NILP (Vw32_alt_is_meta
) ? Qalt
: Qmeta
, key
);
6573 if (w32_modifiers
& MOD_WIN
)
6574 key
= Fcons (Qhyper
, key
);
6579 DEFUN ("w32-toggle-lock-key", Fw32_toggle_lock_key
,
6580 Sw32_toggle_lock_key
, 1, 2, 0,
6581 doc
: /* Toggle the state of the lock key KEY.
6582 KEY can be `capslock', `kp-numlock', or `scroll'.
6583 If the optional parameter NEW-STATE is a number, then the state of KEY
6584 is set to off if the low bit of NEW-STATE is zero, otherwise on. */)
6586 Lisp_Object key
, new_state
;
6590 if (EQ (key
, intern ("capslock")))
6591 vk_code
= VK_CAPITAL
;
6592 else if (EQ (key
, intern ("kp-numlock")))
6593 vk_code
= VK_NUMLOCK
;
6594 else if (EQ (key
, intern ("scroll")))
6595 vk_code
= VK_SCROLL
;
6599 if (!dwWindowsThreadId
)
6600 return make_number (w32_console_toggle_lock_key (vk_code
, new_state
));
6602 #ifdef USE_LISP_UNION_TYPE
6603 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_TOGGLE_LOCK_KEY
,
6604 (WPARAM
) vk_code
, (LPARAM
) new_state
.i
))
6606 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_TOGGLE_LOCK_KEY
,
6607 (WPARAM
) vk_code
, (LPARAM
) new_state
))
6611 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6612 return make_number (msg
.wParam
);
6617 DEFUN ("w32-window-exists-p", Fw32_window_exists_p
, Sw32_window_exists_p
,
6619 doc
: /* Return non-nil if a window exists with the specified CLASS and NAME.
6621 This is a direct interface to the Windows API FindWindow function. */)
6623 Lisp_Object
class, name
;
6628 CHECK_STRING (class);
6630 CHECK_STRING (name
);
6632 hnd
= FindWindow (STRINGP (class) ? ((LPCTSTR
) SDATA (class)) : NULL
,
6633 STRINGP (name
) ? ((LPCTSTR
) SDATA (name
)) : NULL
);
6639 DEFUN ("w32-battery-status", Fw32_battery_status
, Sw32_battery_status
, 0, 0, 0,
6640 doc
: /* Get power status information from Windows system.
6642 The following %-sequences are provided:
6643 %L AC line status (verbose)
6644 %B Battery status (verbose)
6645 %b Battery status, empty means high, `-' means low,
6646 `!' means critical, and `+' means charging
6647 %p Battery load percentage
6648 %s Remaining time (to charge or discharge) in seconds
6649 %m Remaining time (to charge or discharge) in minutes
6650 %h Remaining time (to charge or discharge) in hours
6651 %t Remaining time (to charge or discharge) in the form `h:min' */)
6654 Lisp_Object status
= Qnil
;
6656 SYSTEM_POWER_STATUS system_status
;
6657 if (GetSystemPowerStatus (&system_status
))
6659 Lisp_Object line_status
, battery_status
, battery_status_symbol
;
6660 Lisp_Object load_percentage
, seconds
, minutes
, hours
, remain
;
6661 Lisp_Object sequences
[8];
6663 long seconds_left
= (long) system_status
.BatteryLifeTime
;
6665 if (system_status
.ACLineStatus
== 0)
6666 line_status
= build_string ("off-line");
6667 else if (system_status
.ACLineStatus
== 1)
6668 line_status
= build_string ("on-line");
6670 line_status
= build_string ("N/A");
6672 if (system_status
.BatteryFlag
& 128)
6674 battery_status
= build_string ("N/A");
6675 battery_status_symbol
= empty_unibyte_string
;
6677 else if (system_status
.BatteryFlag
& 8)
6679 battery_status
= build_string ("charging");
6680 battery_status_symbol
= build_string ("+");
6681 if (system_status
.BatteryFullLifeTime
!= -1L)
6682 seconds_left
= system_status
.BatteryFullLifeTime
- seconds_left
;
6684 else if (system_status
.BatteryFlag
& 4)
6686 battery_status
= build_string ("critical");
6687 battery_status_symbol
= build_string ("!");
6689 else if (system_status
.BatteryFlag
& 2)
6691 battery_status
= build_string ("low");
6692 battery_status_symbol
= build_string ("-");
6694 else if (system_status
.BatteryFlag
& 1)
6696 battery_status
= build_string ("high");
6697 battery_status_symbol
= empty_unibyte_string
;
6701 battery_status
= build_string ("medium");
6702 battery_status_symbol
= empty_unibyte_string
;
6705 if (system_status
.BatteryLifePercent
> 100)
6706 load_percentage
= build_string ("N/A");
6710 _snprintf (buffer
, 16, "%d", system_status
.BatteryLifePercent
);
6711 load_percentage
= build_string (buffer
);
6714 if (seconds_left
< 0)
6715 seconds
= minutes
= hours
= remain
= build_string ("N/A");
6721 _snprintf (buffer
, 16, "%ld", seconds_left
);
6722 seconds
= build_string (buffer
);
6724 m
= seconds_left
/ 60;
6725 _snprintf (buffer
, 16, "%ld", m
);
6726 minutes
= build_string (buffer
);
6728 h
= seconds_left
/ 3600.0;
6729 _snprintf (buffer
, 16, "%3.1f", h
);
6730 hours
= build_string (buffer
);
6732 _snprintf (buffer
, 16, "%ld:%02ld", m
/ 60, m
% 60);
6733 remain
= build_string (buffer
);
6735 sequences
[0] = Fcons (make_number ('L'), line_status
);
6736 sequences
[1] = Fcons (make_number ('B'), battery_status
);
6737 sequences
[2] = Fcons (make_number ('b'), battery_status_symbol
);
6738 sequences
[3] = Fcons (make_number ('p'), load_percentage
);
6739 sequences
[4] = Fcons (make_number ('s'), seconds
);
6740 sequences
[5] = Fcons (make_number ('m'), minutes
);
6741 sequences
[6] = Fcons (make_number ('h'), hours
);
6742 sequences
[7] = Fcons (make_number ('t'), remain
);
6744 status
= Flist (8, sequences
);
6750 DEFUN ("file-system-info", Ffile_system_info
, Sfile_system_info
, 1, 1, 0,
6751 doc
: /* Return storage information about the file system FILENAME is on.
6752 Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total
6753 storage of the file system, FREE is the free storage, and AVAIL is the
6754 storage available to a non-superuser. All 3 numbers are in bytes.
6755 If the underlying system call fails, value is nil. */)
6757 Lisp_Object filename
;
6759 Lisp_Object encoded
, value
;
6761 CHECK_STRING (filename
);
6762 filename
= Fexpand_file_name (filename
, Qnil
);
6763 encoded
= ENCODE_FILE (filename
);
6767 /* Determining the required information on Windows turns out, sadly,
6768 to be more involved than one would hope. The original Win32 api
6769 call for this will return bogus information on some systems, but we
6770 must dynamically probe for the replacement api, since that was
6771 added rather late on. */
6773 HMODULE hKernel
= GetModuleHandle ("kernel32");
6774 BOOL (*pfn_GetDiskFreeSpaceEx
)
6775 (char *, PULARGE_INTEGER
, PULARGE_INTEGER
, PULARGE_INTEGER
)
6776 = (void *) GetProcAddress (hKernel
, "GetDiskFreeSpaceEx");
6778 /* On Windows, we may need to specify the root directory of the
6779 volume holding FILENAME. */
6780 char rootname
[MAX_PATH
];
6781 char *name
= SDATA (encoded
);
6783 /* find the root name of the volume if given */
6784 if (isalpha (name
[0]) && name
[1] == ':')
6786 rootname
[0] = name
[0];
6787 rootname
[1] = name
[1];
6791 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
6793 char *str
= rootname
;
6797 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
6807 if (pfn_GetDiskFreeSpaceEx
)
6809 /* Unsigned large integers cannot be cast to double, so
6810 use signed ones instead. */
6811 LARGE_INTEGER availbytes
;
6812 LARGE_INTEGER freebytes
;
6813 LARGE_INTEGER totalbytes
;
6815 if (pfn_GetDiskFreeSpaceEx (rootname
,
6816 (ULARGE_INTEGER
*)&availbytes
,
6817 (ULARGE_INTEGER
*)&totalbytes
,
6818 (ULARGE_INTEGER
*)&freebytes
))
6819 value
= list3 (make_float ((double) totalbytes
.QuadPart
),
6820 make_float ((double) freebytes
.QuadPart
),
6821 make_float ((double) availbytes
.QuadPart
));
6825 DWORD sectors_per_cluster
;
6826 DWORD bytes_per_sector
;
6827 DWORD free_clusters
;
6828 DWORD total_clusters
;
6830 if (GetDiskFreeSpace (rootname
,
6831 §ors_per_cluster
,
6835 value
= list3 (make_float ((double) total_clusters
6836 * sectors_per_cluster
* bytes_per_sector
),
6837 make_float ((double) free_clusters
6838 * sectors_per_cluster
* bytes_per_sector
),
6839 make_float ((double) free_clusters
6840 * sectors_per_cluster
* bytes_per_sector
));
6847 DEFUN ("default-printer-name", Fdefault_printer_name
, Sdefault_printer_name
,
6848 0, 0, 0, doc
: /* Return the name of Windows default printer device. */)
6851 static char pname_buf
[256];
6854 PRINTER_INFO_2
*ppi2
= NULL
;
6855 DWORD dwNeeded
= 0, dwReturned
= 0;
6857 /* Retrieve the default string from Win.ini (the registry).
6858 * String will be in form "printername,drivername,portname".
6859 * This is the most portable way to get the default printer. */
6860 if (GetProfileString ("windows", "device", ",,", pname_buf
, sizeof (pname_buf
)) <= 0)
6862 /* printername precedes first "," character */
6863 strtok (pname_buf
, ",");
6864 /* We want to know more than the printer name */
6865 if (!OpenPrinter (pname_buf
, &hPrn
, NULL
))
6867 GetPrinter (hPrn
, 2, NULL
, 0, &dwNeeded
);
6870 ClosePrinter (hPrn
);
6873 /* Allocate memory for the PRINTER_INFO_2 struct */
6874 ppi2
= (PRINTER_INFO_2
*) xmalloc (dwNeeded
);
6877 ClosePrinter (hPrn
);
6880 /* Call GetPrinter again with big enouth memory block */
6881 err
= GetPrinter (hPrn
, 2, (LPBYTE
)ppi2
, dwNeeded
, &dwReturned
);
6882 ClosePrinter (hPrn
);
6891 if (ppi2
->Attributes
& PRINTER_ATTRIBUTE_SHARED
&& ppi2
->pServerName
)
6893 /* a remote printer */
6894 if (*ppi2
->pServerName
== '\\')
6895 _snprintf (pname_buf
, sizeof (pname_buf
), "%s\\%s", ppi2
->pServerName
,
6898 _snprintf (pname_buf
, sizeof (pname_buf
), "\\\\%s\\%s", ppi2
->pServerName
,
6900 pname_buf
[sizeof (pname_buf
) - 1] = '\0';
6904 /* a local printer */
6905 strncpy (pname_buf
, ppi2
->pPortName
, sizeof (pname_buf
));
6906 pname_buf
[sizeof (pname_buf
) - 1] = '\0';
6907 /* `pPortName' can include several ports, delimited by ','.
6908 * we only use the first one. */
6909 strtok (pname_buf
, ",");
6914 return build_string (pname_buf
);
6917 /***********************************************************************
6919 ***********************************************************************/
6921 /* Keep this list in the same order as frame_parms in frame.c.
6922 Use 0 for unsupported frame parameters. */
6924 frame_parm_handler w32_frame_parm_handlers
[] =
6928 x_set_background_color
,
6934 x_set_foreground_color
,
6937 x_set_internal_border_width
,
6938 x_set_menu_bar_lines
,
6940 x_explicitly_set_name
,
6941 x_set_scroll_bar_width
,
6944 x_set_vertical_scroll_bars
,
6946 x_set_tool_bar_lines
,
6947 0, /* x_set_scroll_bar_foreground, */
6948 0, /* x_set_scroll_bar_background, */
6953 0, /* x_set_wait_for_wm, */
6957 0, /* x_set_sticky */
6963 globals_of_w32fns ();
6964 /* This is zero if not using MS-Windows. */
6966 track_mouse_window
= NULL
;
6968 w32_visible_system_caret_hwnd
= NULL
;
6970 DEFSYM (Qnone
, "none");
6971 DEFSYM (Qsuppress_icon
, "suppress-icon");
6972 DEFSYM (Qundefined_color
, "undefined-color");
6973 DEFSYM (Qcancel_timer
, "cancel-timer");
6974 DEFSYM (Qhyper
, "hyper");
6975 DEFSYM (Qsuper
, "super");
6976 DEFSYM (Qmeta
, "meta");
6977 DEFSYM (Qalt
, "alt");
6978 DEFSYM (Qctrl
, "ctrl");
6979 DEFSYM (Qcontrol
, "control");
6980 DEFSYM (Qshift
, "shift");
6981 DEFSYM (Qfont_param
, "font-parameter");
6982 /* This is the end of symbol initialization. */
6984 /* Text property `display' should be nonsticky by default. */
6985 Vtext_property_default_nonsticky
6986 = Fcons (Fcons (Qdisplay
, Qt
), Vtext_property_default_nonsticky
);
6989 Fput (Qundefined_color
, Qerror_conditions
,
6990 pure_cons (Qundefined_color
, pure_cons (Qerror
, Qnil
)));
6991 Fput (Qundefined_color
, Qerror_message
,
6992 make_pure_c_string ("Undefined color"));
6994 staticpro (&w32_grabbed_keys
);
6995 w32_grabbed_keys
= Qnil
;
6997 DEFVAR_LISP ("w32-color-map", &Vw32_color_map
,
6998 doc
: /* An array of color name mappings for Windows. */);
6999 Vw32_color_map
= Qnil
;
7001 DEFVAR_LISP ("w32-pass-alt-to-system", &Vw32_pass_alt_to_system
,
7002 doc
: /* Non-nil if Alt key presses are passed on to Windows.
7003 When non-nil, for example, Alt pressed and released and then space will
7004 open the System menu. When nil, Emacs processes the Alt key events, and
7005 then silently swallows them. */);
7006 Vw32_pass_alt_to_system
= Qnil
;
7008 DEFVAR_LISP ("w32-alt-is-meta", &Vw32_alt_is_meta
,
7009 doc
: /* Non-nil if the Alt key is to be considered the same as the META key.
7010 When nil, Emacs will translate the Alt key to the ALT modifier, not to META. */);
7011 Vw32_alt_is_meta
= Qt
;
7013 DEFVAR_INT ("w32-quit-key", &w32_quit_key
,
7014 doc
: /* If non-zero, the virtual key code for an alternative quit key. */);
7017 DEFVAR_LISP ("w32-pass-lwindow-to-system",
7018 &Vw32_pass_lwindow_to_system
,
7019 doc
: /* If non-nil, the left \"Windows\" key is passed on to Windows.
7021 When non-nil, the Start menu is opened by tapping the key.
7022 If you set this to nil, the left \"Windows\" key is processed by Emacs
7023 according to the value of `w32-lwindow-modifier', which see.
7025 Note that some combinations of the left \"Windows\" key with other keys are
7026 caught by Windows at low level, and so binding them in Emacs will have no
7027 effect. For example, <lwindow>-r always pops up the Windows Run dialog,
7028 <lwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
7029 the doc string of `w32-phantom-key-code'. */);
7030 Vw32_pass_lwindow_to_system
= Qt
;
7032 DEFVAR_LISP ("w32-pass-rwindow-to-system",
7033 &Vw32_pass_rwindow_to_system
,
7034 doc
: /* If non-nil, the right \"Windows\" key is passed on to Windows.
7036 When non-nil, the Start menu is opened by tapping the key.
7037 If you set this to nil, the right \"Windows\" key is processed by Emacs
7038 according to the value of `w32-rwindow-modifier', which see.
7040 Note that some combinations of the right \"Windows\" key with other keys are
7041 caught by Windows at low level, and so binding them in Emacs will have no
7042 effect. For example, <rwindow>-r always pops up the Windows Run dialog,
7043 <rwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
7044 the doc string of `w32-phantom-key-code'. */);
7045 Vw32_pass_rwindow_to_system
= Qt
;
7047 DEFVAR_LISP ("w32-phantom-key-code",
7048 &Vw32_phantom_key_code
,
7049 doc
: /* Virtual key code used to generate \"phantom\" key presses.
7050 Value is a number between 0 and 255.
7052 Phantom key presses are generated in order to stop the system from
7053 acting on \"Windows\" key events when `w32-pass-lwindow-to-system' or
7054 `w32-pass-rwindow-to-system' is nil. */);
7055 /* Although 255 is technically not a valid key code, it works and
7056 means that this hack won't interfere with any real key code. */
7057 XSETINT (Vw32_phantom_key_code
, 255);
7059 DEFVAR_LISP ("w32-enable-num-lock",
7060 &Vw32_enable_num_lock
,
7061 doc
: /* If non-nil, the Num Lock key acts normally.
7062 Set to nil to handle Num Lock as the `kp-numlock' key. */);
7063 Vw32_enable_num_lock
= Qt
;
7065 DEFVAR_LISP ("w32-enable-caps-lock",
7066 &Vw32_enable_caps_lock
,
7067 doc
: /* If non-nil, the Caps Lock key acts normally.
7068 Set to nil to handle Caps Lock as the `capslock' key. */);
7069 Vw32_enable_caps_lock
= Qt
;
7071 DEFVAR_LISP ("w32-scroll-lock-modifier",
7072 &Vw32_scroll_lock_modifier
,
7073 doc
: /* Modifier to use for the Scroll Lock ON state.
7074 The value can be hyper, super, meta, alt, control or shift for the
7075 respective modifier, or nil to handle Scroll Lock as the `scroll' key.
7076 Any other value will cause the Scroll Lock key to be ignored. */);
7077 Vw32_scroll_lock_modifier
= Qnil
;
7079 DEFVAR_LISP ("w32-lwindow-modifier",
7080 &Vw32_lwindow_modifier
,
7081 doc
: /* Modifier to use for the left \"Windows\" key.
7082 The value can be hyper, super, meta, alt, control or shift for the
7083 respective modifier, or nil to appear as the `lwindow' key.
7084 Any other value will cause the key to be ignored. */);
7085 Vw32_lwindow_modifier
= Qnil
;
7087 DEFVAR_LISP ("w32-rwindow-modifier",
7088 &Vw32_rwindow_modifier
,
7089 doc
: /* Modifier to use for the right \"Windows\" key.
7090 The value can be hyper, super, meta, alt, control or shift for the
7091 respective modifier, or nil to appear as the `rwindow' key.
7092 Any other value will cause the key to be ignored. */);
7093 Vw32_rwindow_modifier
= Qnil
;
7095 DEFVAR_LISP ("w32-apps-modifier",
7096 &Vw32_apps_modifier
,
7097 doc
: /* Modifier to use for the \"Apps\" key.
7098 The value can be hyper, super, meta, alt, control or shift for the
7099 respective modifier, or nil to appear as the `apps' key.
7100 Any other value will cause the key to be ignored. */);
7101 Vw32_apps_modifier
= Qnil
;
7103 DEFVAR_BOOL ("w32-enable-synthesized-fonts", &w32_enable_synthesized_fonts
,
7104 doc
: /* Non-nil enables selection of artificially italicized and bold fonts. */);
7105 w32_enable_synthesized_fonts
= 0;
7107 DEFVAR_LISP ("w32-enable-palette", &Vw32_enable_palette
,
7108 doc
: /* Non-nil enables Windows palette management to map colors exactly. */);
7109 Vw32_enable_palette
= Qt
;
7111 DEFVAR_INT ("w32-mouse-button-tolerance",
7112 &w32_mouse_button_tolerance
,
7113 doc
: /* Analogue of double click interval for faking middle mouse events.
7114 The value is the minimum time in milliseconds that must elapse between
7115 left and right button down events before they are considered distinct events.
7116 If both mouse buttons are depressed within this interval, a middle mouse
7117 button down event is generated instead. */);
7118 w32_mouse_button_tolerance
= GetDoubleClickTime () / 2;
7120 DEFVAR_INT ("w32-mouse-move-interval",
7121 &w32_mouse_move_interval
,
7122 doc
: /* Minimum interval between mouse move events.
7123 The value is the minimum time in milliseconds that must elapse between
7124 successive mouse move (or scroll bar drag) events before they are
7125 reported as lisp events. */);
7126 w32_mouse_move_interval
= 0;
7128 DEFVAR_BOOL ("w32-pass-extra-mouse-buttons-to-system",
7129 &w32_pass_extra_mouse_buttons_to_system
,
7130 doc
: /* If non-nil, the fourth and fifth mouse buttons are passed to Windows.
7131 Recent versions of Windows support mice with up to five buttons.
7132 Since most applications don't support these extra buttons, most mouse
7133 drivers will allow you to map them to functions at the system level.
7134 If this variable is non-nil, Emacs will pass them on, allowing the
7135 system to handle them. */);
7136 w32_pass_extra_mouse_buttons_to_system
= 0;
7138 DEFVAR_BOOL ("w32-pass-multimedia-buttons-to-system",
7139 &w32_pass_multimedia_buttons_to_system
,
7140 doc
: /* If non-nil, media buttons are passed to Windows.
7141 Some modern keyboards contain buttons for controlling media players, web
7142 browsers and other applications. Generally these buttons are handled on a
7143 system wide basis, but by setting this to nil they are made available
7144 to Emacs for binding. Depending on your keyboard, additional keys that
7145 may be available are:
7147 browser-back, browser-forward, browser-refresh, browser-stop,
7148 browser-search, browser-favorites, browser-home,
7149 mail, mail-reply, mail-forward, mail-send,
7151 help, find, new, open, close, save, print, undo, redo, copy, cut, paste,
7152 spell-check, correction-list, toggle-dictate-command,
7153 media-next, media-previous, media-stop, media-play-pause, media-select,
7154 media-play, media-pause, media-record, media-fast-forward, media-rewind,
7155 media-channel-up, media-channel-down,
7156 volume-mute, volume-up, volume-down,
7157 mic-volume-mute, mic-volume-down, mic-volume-up, mic-toggle,
7158 bass-down, bass-boost, bass-up, treble-down, treble-up */);
7159 w32_pass_multimedia_buttons_to_system
= 1;
7161 #if 0 /* TODO: Mouse cursor customization. */
7162 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape
,
7163 doc
: /* The shape of the pointer when over text.
7164 Changing the value does not affect existing frames
7165 unless you set the mouse color. */);
7166 Vx_pointer_shape
= Qnil
;
7168 Vx_nontext_pointer_shape
= Qnil
;
7170 Vx_mode_pointer_shape
= Qnil
;
7172 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape
,
7173 doc
: /* The shape of the pointer when Emacs is busy.
7174 This variable takes effect when you create a new frame
7175 or when you set the mouse color. */);
7176 Vx_hourglass_pointer_shape
= Qnil
;
7178 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
7179 &Vx_sensitive_text_pointer_shape
,
7180 doc
: /* The shape of the pointer when over mouse-sensitive text.
7181 This variable takes effect when you create a new frame
7182 or when you set the mouse color. */);
7183 Vx_sensitive_text_pointer_shape
= Qnil
;
7185 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
7186 &Vx_window_horizontal_drag_shape
,
7187 doc
: /* Pointer shape to use for indicating a window can be dragged horizontally.
7188 This variable takes effect when you create a new frame
7189 or when you set the mouse color. */);
7190 Vx_window_horizontal_drag_shape
= Qnil
;
7193 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel
,
7194 doc
: /* A string indicating the foreground color of the cursor box. */);
7195 Vx_cursor_fore_pixel
= Qnil
;
7197 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size
,
7198 doc
: /* Maximum size for tooltips.
7199 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
7200 Vx_max_tooltip_size
= Fcons (make_number (80), make_number (40));
7202 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager
,
7203 doc
: /* Non-nil if no window manager is in use.
7204 Emacs doesn't try to figure this out; this is always nil
7205 unless you set it to something else. */);
7206 /* We don't have any way to find this out, so set it to nil
7207 and maybe the user would like to set it to t. */
7208 Vx_no_window_manager
= Qnil
;
7210 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
7211 &Vx_pixel_size_width_font_regexp
,
7212 doc
: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
7214 Since Emacs gets width of a font matching with this regexp from
7215 PIXEL_SIZE field of the name, font finding mechanism gets faster for
7216 such a font. This is especially effective for such large fonts as
7217 Chinese, Japanese, and Korean. */);
7218 Vx_pixel_size_width_font_regexp
= Qnil
;
7220 DEFVAR_LISP ("w32-bdf-filename-alist",
7221 &Vw32_bdf_filename_alist
,
7222 doc
: /* List of bdf fonts and their corresponding filenames. */);
7223 Vw32_bdf_filename_alist
= Qnil
;
7225 DEFVAR_BOOL ("w32-strict-fontnames",
7226 &w32_strict_fontnames
,
7227 doc
: /* Non-nil means only use fonts that are exact matches for those requested.
7228 Default is nil, which allows old fontnames that are not XLFD compliant,
7229 and allows third-party CJK display to work by specifying false charset
7230 fields to trick Emacs into translating to Big5, SJIS etc.
7231 Setting this to t will prevent wrong fonts being selected when
7232 fontsets are automatically created. */);
7233 w32_strict_fontnames
= 0;
7235 DEFVAR_BOOL ("w32-strict-painting",
7236 &w32_strict_painting
,
7237 doc
: /* Non-nil means use strict rules for repainting frames.
7238 Set this to nil to get the old behavior for repainting; this should
7239 only be necessary if the default setting causes problems. */);
7240 w32_strict_painting
= 1;
7242 #if 0 /* TODO: Port to W32 */
7243 defsubr (&Sx_change_window_property
);
7244 defsubr (&Sx_delete_window_property
);
7245 defsubr (&Sx_window_property
);
7247 defsubr (&Sxw_display_color_p
);
7248 defsubr (&Sx_display_grayscale_p
);
7249 defsubr (&Sxw_color_defined_p
);
7250 defsubr (&Sxw_color_values
);
7251 defsubr (&Sx_server_max_request_size
);
7252 defsubr (&Sx_server_vendor
);
7253 defsubr (&Sx_server_version
);
7254 defsubr (&Sx_display_pixel_width
);
7255 defsubr (&Sx_display_pixel_height
);
7256 defsubr (&Sx_display_mm_width
);
7257 defsubr (&Sx_display_mm_height
);
7258 defsubr (&Sx_display_screens
);
7259 defsubr (&Sx_display_planes
);
7260 defsubr (&Sx_display_color_cells
);
7261 defsubr (&Sx_display_visual_class
);
7262 defsubr (&Sx_display_backing_store
);
7263 defsubr (&Sx_display_save_under
);
7264 defsubr (&Sx_create_frame
);
7265 defsubr (&Sx_open_connection
);
7266 defsubr (&Sx_close_connection
);
7267 defsubr (&Sx_display_list
);
7268 defsubr (&Sx_synchronize
);
7269 defsubr (&Sx_focus_frame
);
7271 /* W32 specific functions */
7273 defsubr (&Sw32_define_rgb_color
);
7274 defsubr (&Sw32_default_color_map
);
7275 defsubr (&Sw32_send_sys_command
);
7276 defsubr (&Sw32_shell_execute
);
7277 defsubr (&Sw32_register_hot_key
);
7278 defsubr (&Sw32_unregister_hot_key
);
7279 defsubr (&Sw32_registered_hot_keys
);
7280 defsubr (&Sw32_reconstruct_hot_key
);
7281 defsubr (&Sw32_toggle_lock_key
);
7282 defsubr (&Sw32_window_exists_p
);
7283 defsubr (&Sw32_battery_status
);
7285 defsubr (&Sfile_system_info
);
7286 defsubr (&Sdefault_printer_name
);
7288 check_window_system_func
= check_w32
;
7291 hourglass_timer
= 0;
7292 hourglass_hwnd
= NULL
;
7294 defsubr (&Sx_show_tip
);
7295 defsubr (&Sx_hide_tip
);
7297 staticpro (&tip_timer
);
7299 staticpro (&tip_frame
);
7301 last_show_tip_args
= Qnil
;
7302 staticpro (&last_show_tip_args
);
7304 defsubr (&Sx_file_dialog
);
7305 defsubr (&Ssystem_move_file_to_trash
);
7310 globals_of_w32fns is used to initialize those global variables that
7311 must always be initialized on startup even when the global variable
7312 initialized is non zero (see the function main in emacs.c).
7313 globals_of_w32fns is called from syms_of_w32fns when the global
7314 variable initialized is 0 and directly from main when initialized
7318 globals_of_w32fns ()
7320 HMODULE user32_lib
= GetModuleHandle ("user32.dll");
7322 TrackMouseEvent not available in all versions of Windows, so must load
7323 it dynamically. Do it once, here, instead of every time it is used.
7325 track_mouse_event_fn
= (TrackMouseEvent_Proc
)
7326 GetProcAddress (user32_lib
, "TrackMouseEvent");
7327 /* ditto for GetClipboardSequenceNumber. */
7328 clipboard_sequence_fn
= (ClipboardSequence_Proc
)
7329 GetProcAddress (user32_lib
, "GetClipboardSequenceNumber");
7331 monitor_from_point_fn
= (MonitorFromPoint_Proc
)
7332 GetProcAddress (user32_lib
, "MonitorFromPoint");
7333 get_monitor_info_fn
= (GetMonitorInfo_Proc
)
7334 GetProcAddress (user32_lib
, "GetMonitorInfoA");
7337 HMODULE imm32_lib
= GetModuleHandle ("imm32.dll");
7338 get_composition_string_fn
= (ImmGetCompositionString_Proc
)
7339 GetProcAddress (imm32_lib
, "ImmGetCompositionStringW");
7340 get_ime_context_fn
= (ImmGetContext_Proc
)
7341 GetProcAddress (imm32_lib
, "ImmGetContext");
7342 release_ime_context_fn
= (ImmReleaseContext_Proc
)
7343 GetProcAddress (imm32_lib
, "ImmReleaseContext");
7344 set_ime_composition_window_fn
= (ImmSetCompositionWindow_Proc
)
7345 GetProcAddress (imm32_lib
, "ImmSetCompositionWindow");
7347 DEFVAR_INT ("w32-ansi-code-page",
7348 &w32_ansi_code_page
,
7349 doc
: /* The ANSI code page used by the system. */);
7350 w32_ansi_code_page
= GetACP ();
7352 /* MessageBox does not work without this when linked to comctl32.dll 6.0. */
7353 InitCommonControls ();
7355 syms_of_w32uniscribe ();
7364 button
= MessageBox (NULL
,
7365 "A fatal error has occurred!\n\n"
7366 "Would you like to attach a debugger?\n\n"
7367 "Select YES to debug, NO to abort Emacs"
7369 "\n\n(type \"gdb -p <emacs-PID>\" and\n"
7370 "\"continue\" inside GDB before clicking YES.)"
7372 , "Emacs Abort Dialog",
7373 MB_ICONEXCLAMATION
| MB_TASKMODAL
7374 | MB_SETFOREGROUND
| MB_YESNO
);
7379 exit (2); /* tell the compiler we will never return */
7387 /* For convenience when debugging. */
7391 return GetLastError ();
7394 /* arch-tag: 707589ab-b9be-4638-8cdd-74629cc9b446
7395 (do not change this comment) */