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
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 */
36 #include "intervals.h"
37 #include "dispextern.h"
39 #include "blockinput.h"
41 #include "character.h"
47 #include "termhooks.h"
50 #include "bitmaps/gray.xbm"
61 #define FILE_NAME_TEXT_FIELD edt1
66 #ifndef FOF_NO_CONNECTED_ELEMENTS
67 #define FOF_NO_CONNECTED_ELEMENTS 0x2000
70 void syms_of_w32fns ();
71 void globals_of_w32fns ();
73 extern void free_frame_menubar ();
74 extern double atof ();
75 extern int w32_console_toggle_lock_key
P_ ((int, Lisp_Object
));
76 extern void w32_menu_display_help
P_ ((HWND
, HMENU
, UINT
, UINT
));
77 extern void w32_free_menu_strings
P_ ((HWND
));
78 extern const char *map_w32_filename
P_ ((const char *, const char **));
82 extern char *lispy_function_keys
[];
84 /* The colormap for converting color names to RGB values */
85 Lisp_Object Vw32_color_map
;
87 /* Non nil if alt key presses are passed on to Windows. */
88 Lisp_Object Vw32_pass_alt_to_system
;
90 /* Non nil if alt key is translated to meta_modifier, nil if it is translated
92 Lisp_Object Vw32_alt_is_meta
;
94 /* If non-zero, the windows virtual key code for an alternative quit key. */
97 /* Non nil if left window key events are passed on to Windows (this only
98 affects whether "tapping" the key opens the Start menu). */
99 Lisp_Object Vw32_pass_lwindow_to_system
;
101 /* Non nil if right window key events are passed on to Windows (this
102 only affects whether "tapping" the key opens the Start menu). */
103 Lisp_Object Vw32_pass_rwindow_to_system
;
105 /* Virtual key code used to generate "phantom" key presses in order
106 to stop system from acting on Windows key events. */
107 Lisp_Object Vw32_phantom_key_code
;
109 /* Modifier associated with the left "Windows" key, or nil to act as a
111 Lisp_Object Vw32_lwindow_modifier
;
113 /* Modifier associated with the right "Windows" key, or nil to act as a
115 Lisp_Object Vw32_rwindow_modifier
;
117 /* Modifier associated with the "Apps" key, or nil to act as a normal
119 Lisp_Object Vw32_apps_modifier
;
121 /* Value is nil if Num Lock acts as a function key. */
122 Lisp_Object Vw32_enable_num_lock
;
124 /* Value is nil if Caps Lock acts as a function key. */
125 Lisp_Object Vw32_enable_caps_lock
;
127 /* Modifier associated with Scroll Lock, or nil to act as a normal key. */
128 Lisp_Object Vw32_scroll_lock_modifier
;
130 /* Switch to control whether we inhibit requests for synthesized bold
131 and italic versions of fonts. */
132 int w32_enable_synthesized_fonts
;
134 /* Enable palette management. */
135 Lisp_Object Vw32_enable_palette
;
137 /* Control how close left/right button down events must be to
138 be converted to a middle button down event. */
139 int w32_mouse_button_tolerance
;
141 /* Minimum interval between mouse movement (and scroll bar drag)
142 events that are passed on to the event loop. */
143 int w32_mouse_move_interval
;
145 /* Flag to indicate if XBUTTON events should be passed on to Windows. */
146 static int w32_pass_extra_mouse_buttons_to_system
;
148 /* Flag to indicate if media keys should be passed on to Windows. */
149 static int w32_pass_multimedia_buttons_to_system
;
151 /* Non nil if no window manager is in use. */
152 Lisp_Object Vx_no_window_manager
;
154 /* If non-zero, a w32 timer that, when it expires, displays an
155 hourglass cursor on all frames. */
156 static unsigned hourglass_timer
= 0;
157 static HWND hourglass_hwnd
= NULL
;
159 /* The background and shape of the mouse pointer, and shape when not
160 over text or in the modeline. */
162 Lisp_Object Vx_pointer_shape
, Vx_nontext_pointer_shape
, Vx_mode_pointer_shape
;
163 Lisp_Object Vx_hourglass_pointer_shape
, Vx_window_horizontal_drag_shape
;
165 /* The shape when over mouse-sensitive text. */
167 Lisp_Object Vx_sensitive_text_pointer_shape
;
170 #define IDC_HAND MAKEINTRESOURCE(32649)
173 /* Color of chars displayed in cursor box. */
175 Lisp_Object Vx_cursor_fore_pixel
;
177 /* Nonzero if using Windows. */
179 static int w32_in_use
;
181 /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'. */
183 Lisp_Object Vx_pixel_size_width_font_regexp
;
185 /* Alist of bdf fonts and the files that define them. */
186 Lisp_Object Vw32_bdf_filename_alist
;
188 /* A flag to control whether fonts are matched strictly or not. */
189 static int w32_strict_fontnames
;
191 /* A flag to control whether we should only repaint if GetUpdateRect
192 indicates there is an update region. */
193 static int w32_strict_painting
;
196 Lisp_Object Qsuppress_icon
;
197 Lisp_Object Qundefined_color
;
198 Lisp_Object Qcancel_timer
;
199 Lisp_Object Qfont_param
;
205 Lisp_Object Qcontrol
;
209 /* The ANSI codepage. */
210 int w32_ansi_code_page
;
212 /* Prefix for system colors. */
213 #define SYSTEM_COLOR_PREFIX "System"
214 #define SYSTEM_COLOR_PREFIX_LEN (sizeof (SYSTEM_COLOR_PREFIX) - 1)
216 /* State variables for emulating a three button mouse. */
221 static int button_state
= 0;
222 static W32Msg saved_mouse_button_msg
;
223 static unsigned mouse_button_timer
= 0; /* non-zero when timer is active */
224 static W32Msg saved_mouse_move_msg
;
225 static unsigned mouse_move_timer
= 0;
227 /* Window that is tracking the mouse. */
228 static HWND track_mouse_window
;
230 /* Multi-monitor API definitions that are not pulled from the headers
231 since we are compiling for NT 4. */
232 #ifndef MONITOR_DEFAULT_TO_NEAREST
233 #define MONITOR_DEFAULT_TO_NEAREST 2
235 /* MinGW headers define MONITORINFO unconditionally, but MSVC ones don't.
236 To avoid a compile error on one or the other, redefine with a new name. */
245 /* Reportedly, VS 6 does not have this in its headers. */
246 #if defined(_MSC_VER) && _MSC_VER < 1300
247 DECLARE_HANDLE(HMONITOR
);
250 typedef BOOL (WINAPI
* TrackMouseEvent_Proc
)
251 (IN OUT LPTRACKMOUSEEVENT lpEventTrack
);
252 typedef LONG (WINAPI
* ImmGetCompositionString_Proc
)
253 (IN HIMC context
, IN DWORD index
, OUT LPVOID buffer
, IN DWORD bufLen
);
254 typedef HIMC (WINAPI
* ImmGetContext_Proc
) (IN HWND window
);
255 typedef HMONITOR (WINAPI
* MonitorFromPoint_Proc
) (IN POINT pt
, IN DWORD flags
);
256 typedef BOOL (WINAPI
* GetMonitorInfo_Proc
)
257 (IN HMONITOR monitor
, OUT
struct MONITOR_INFO
* info
);
259 TrackMouseEvent_Proc track_mouse_event_fn
= NULL
;
260 ClipboardSequence_Proc clipboard_sequence_fn
= NULL
;
261 ImmGetCompositionString_Proc get_composition_string_fn
= NULL
;
262 ImmGetContext_Proc get_ime_context_fn
= NULL
;
263 MonitorFromPoint_Proc monitor_from_point_fn
= NULL
;
264 GetMonitorInfo_Proc get_monitor_info_fn
= NULL
;
266 extern AppendMenuW_Proc unicode_append_menu
;
268 /* Flag to selectively ignore WM_IME_CHAR messages. */
269 static int ignore_ime_char
= 0;
271 /* W95 mousewheel handler */
272 unsigned int msh_mousewheel
= 0;
275 #define MOUSE_BUTTON_ID 1
276 #define MOUSE_MOVE_ID 2
277 #define MENU_FREE_ID 3
278 #define HOURGLASS_ID 4
279 /* The delay (milliseconds) before a menu is freed after WM_EXITMENULOOP
281 #define MENU_FREE_DELAY 1000
282 static unsigned menu_free_timer
= 0;
284 /* The below are defined in frame.c. */
286 extern Lisp_Object Vwindow_system_version
;
289 int image_cache_refcount
, dpyinfo_refcount
;
293 /* From w32term.c. */
294 extern int w32_num_mouse_buttons
;
295 extern Lisp_Object Vw32_recognize_altgr
;
297 extern HWND w32_system_caret_hwnd
;
299 extern int w32_system_caret_height
;
300 extern int w32_system_caret_x
;
301 extern int w32_system_caret_y
;
302 extern int w32_use_visible_system_caret
;
304 static HWND w32_visible_system_caret_hwnd
;
307 extern HMENU current_popup_menu
;
308 static int menubar_in_use
= 0;
310 /* From w32uniscribe.c */
311 extern void syms_of_w32uniscribe ();
312 extern int uniscribe_available
;
314 /* Function prototypes for hourglass support. */
315 static void w32_show_hourglass
P_ ((struct frame
*));
316 static void w32_hide_hourglass
P_ ((void));
320 /* Error if we are not connected to MS-Windows. */
325 error ("MS-Windows not in use or not initialized");
328 /* Nonzero if we can use mouse menus.
329 You should not call this unless HAVE_MENUS is defined. */
337 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
338 and checking validity for W32. */
341 check_x_frame (frame
)
347 frame
= selected_frame
;
348 CHECK_LIVE_FRAME (frame
);
350 if (! FRAME_W32_P (f
))
351 error ("Non-W32 frame used");
355 /* Let the user specify a display with a frame.
356 nil stands for the selected frame--or, if that is not a w32 frame,
357 the first display on the list. */
359 struct w32_display_info
*
360 check_x_display_info (frame
)
365 struct frame
*sf
= XFRAME (selected_frame
);
367 if (FRAME_W32_P (sf
) && FRAME_LIVE_P (sf
))
368 return FRAME_W32_DISPLAY_INFO (sf
);
370 return &one_w32_display_info
;
372 else if (STRINGP (frame
))
373 return x_display_info_for_name (frame
);
378 CHECK_LIVE_FRAME (frame
);
380 if (! FRAME_W32_P (f
))
381 error ("Non-W32 frame used");
382 return FRAME_W32_DISPLAY_INFO (f
);
386 /* Return the Emacs frame-object corresponding to an w32 window.
387 It could be the frame's main window or an icon window. */
389 /* This function can be called during GC, so use GC_xxx type test macros. */
392 x_window_to_frame (dpyinfo
, wdesc
)
393 struct w32_display_info
*dpyinfo
;
396 Lisp_Object tail
, frame
;
399 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
405 if (!FRAME_W32_P (f
) || FRAME_W32_DISPLAY_INFO (f
) != dpyinfo
)
408 if (FRAME_W32_WINDOW (f
) == wdesc
)
415 static Lisp_Object unwind_create_frame
P_ ((Lisp_Object
));
416 static Lisp_Object unwind_create_tip_frame
P_ ((Lisp_Object
));
417 static void my_create_window
P_ ((struct frame
*));
418 static void my_create_tip_window
P_ ((struct frame
*));
420 /* TODO: Native Input Method support; see x_create_im. */
421 void x_set_foreground_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
422 void x_set_background_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
423 void x_set_mouse_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
424 void x_set_cursor_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
425 void x_set_border_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
426 void x_set_cursor_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
427 void x_set_icon_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
428 void x_set_icon_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
429 void x_explicitly_set_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
430 void x_set_menu_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
431 void x_set_title
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
432 void x_set_tool_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
433 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
439 /* Store the screen positions of frame F into XPTR and YPTR.
440 These are the positions of the containing window manager window,
441 not Emacs's own window. */
444 x_real_positions (f
, xptr
, yptr
)
451 /* Get the bounds of the WM window. */
452 GetWindowRect (FRAME_W32_WINDOW (f
), &rect
);
457 /* Convert (0, 0) in the client area to screen co-ordinates. */
458 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
460 /* Remember x_pixels_diff and y_pixels_diff. */
461 f
->x_pixels_diff
= pt
.x
- rect
.left
;
462 f
->y_pixels_diff
= pt
.y
- rect
.top
;
470 DEFUN ("w32-define-rgb-color", Fw32_define_rgb_color
,
471 Sw32_define_rgb_color
, 4, 4, 0,
472 doc
: /* Convert RGB numbers to a Windows color reference and associate with NAME.
473 This adds or updates a named color to `w32-color-map', making it
474 available for use. The original entry's RGB ref is returned, or nil
475 if the entry is new. */)
476 (red
, green
, blue
, name
)
477 Lisp_Object red
, green
, blue
, name
;
480 Lisp_Object oldrgb
= Qnil
;
484 CHECK_NUMBER (green
);
488 XSETINT (rgb
, RGB (XUINT (red
), XUINT (green
), XUINT (blue
)));
492 /* replace existing entry in w32-color-map or add new entry. */
493 entry
= Fassoc (name
, Vw32_color_map
);
496 entry
= Fcons (name
, rgb
);
497 Vw32_color_map
= Fcons (entry
, Vw32_color_map
);
501 oldrgb
= Fcdr (entry
);
502 Fsetcdr (entry
, rgb
);
510 /* The default colors for the w32 color map */
511 typedef struct colormap_t
517 colormap_t w32_color_map
[] =
519 {"snow" , PALETTERGB (255,250,250)},
520 {"ghost white" , PALETTERGB (248,248,255)},
521 {"GhostWhite" , PALETTERGB (248,248,255)},
522 {"white smoke" , PALETTERGB (245,245,245)},
523 {"WhiteSmoke" , PALETTERGB (245,245,245)},
524 {"gainsboro" , PALETTERGB (220,220,220)},
525 {"floral white" , PALETTERGB (255,250,240)},
526 {"FloralWhite" , PALETTERGB (255,250,240)},
527 {"old lace" , PALETTERGB (253,245,230)},
528 {"OldLace" , PALETTERGB (253,245,230)},
529 {"linen" , PALETTERGB (250,240,230)},
530 {"antique white" , PALETTERGB (250,235,215)},
531 {"AntiqueWhite" , PALETTERGB (250,235,215)},
532 {"papaya whip" , PALETTERGB (255,239,213)},
533 {"PapayaWhip" , PALETTERGB (255,239,213)},
534 {"blanched almond" , PALETTERGB (255,235,205)},
535 {"BlanchedAlmond" , PALETTERGB (255,235,205)},
536 {"bisque" , PALETTERGB (255,228,196)},
537 {"peach puff" , PALETTERGB (255,218,185)},
538 {"PeachPuff" , PALETTERGB (255,218,185)},
539 {"navajo white" , PALETTERGB (255,222,173)},
540 {"NavajoWhite" , PALETTERGB (255,222,173)},
541 {"moccasin" , PALETTERGB (255,228,181)},
542 {"cornsilk" , PALETTERGB (255,248,220)},
543 {"ivory" , PALETTERGB (255,255,240)},
544 {"lemon chiffon" , PALETTERGB (255,250,205)},
545 {"LemonChiffon" , PALETTERGB (255,250,205)},
546 {"seashell" , PALETTERGB (255,245,238)},
547 {"honeydew" , PALETTERGB (240,255,240)},
548 {"mint cream" , PALETTERGB (245,255,250)},
549 {"MintCream" , PALETTERGB (245,255,250)},
550 {"azure" , PALETTERGB (240,255,255)},
551 {"alice blue" , PALETTERGB (240,248,255)},
552 {"AliceBlue" , PALETTERGB (240,248,255)},
553 {"lavender" , PALETTERGB (230,230,250)},
554 {"lavender blush" , PALETTERGB (255,240,245)},
555 {"LavenderBlush" , PALETTERGB (255,240,245)},
556 {"misty rose" , PALETTERGB (255,228,225)},
557 {"MistyRose" , PALETTERGB (255,228,225)},
558 {"white" , PALETTERGB (255,255,255)},
559 {"black" , PALETTERGB ( 0, 0, 0)},
560 {"dark slate gray" , PALETTERGB ( 47, 79, 79)},
561 {"DarkSlateGray" , PALETTERGB ( 47, 79, 79)},
562 {"dark slate grey" , PALETTERGB ( 47, 79, 79)},
563 {"DarkSlateGrey" , PALETTERGB ( 47, 79, 79)},
564 {"dim gray" , PALETTERGB (105,105,105)},
565 {"DimGray" , PALETTERGB (105,105,105)},
566 {"dim grey" , PALETTERGB (105,105,105)},
567 {"DimGrey" , PALETTERGB (105,105,105)},
568 {"slate gray" , PALETTERGB (112,128,144)},
569 {"SlateGray" , PALETTERGB (112,128,144)},
570 {"slate grey" , PALETTERGB (112,128,144)},
571 {"SlateGrey" , PALETTERGB (112,128,144)},
572 {"light slate gray" , PALETTERGB (119,136,153)},
573 {"LightSlateGray" , PALETTERGB (119,136,153)},
574 {"light slate grey" , PALETTERGB (119,136,153)},
575 {"LightSlateGrey" , PALETTERGB (119,136,153)},
576 {"gray" , PALETTERGB (190,190,190)},
577 {"grey" , PALETTERGB (190,190,190)},
578 {"light grey" , PALETTERGB (211,211,211)},
579 {"LightGrey" , PALETTERGB (211,211,211)},
580 {"light gray" , PALETTERGB (211,211,211)},
581 {"LightGray" , PALETTERGB (211,211,211)},
582 {"midnight blue" , PALETTERGB ( 25, 25,112)},
583 {"MidnightBlue" , PALETTERGB ( 25, 25,112)},
584 {"navy" , PALETTERGB ( 0, 0,128)},
585 {"navy blue" , PALETTERGB ( 0, 0,128)},
586 {"NavyBlue" , PALETTERGB ( 0, 0,128)},
587 {"cornflower blue" , PALETTERGB (100,149,237)},
588 {"CornflowerBlue" , PALETTERGB (100,149,237)},
589 {"dark slate blue" , PALETTERGB ( 72, 61,139)},
590 {"DarkSlateBlue" , PALETTERGB ( 72, 61,139)},
591 {"slate blue" , PALETTERGB (106, 90,205)},
592 {"SlateBlue" , PALETTERGB (106, 90,205)},
593 {"medium slate blue" , PALETTERGB (123,104,238)},
594 {"MediumSlateBlue" , PALETTERGB (123,104,238)},
595 {"light slate blue" , PALETTERGB (132,112,255)},
596 {"LightSlateBlue" , PALETTERGB (132,112,255)},
597 {"medium blue" , PALETTERGB ( 0, 0,205)},
598 {"MediumBlue" , PALETTERGB ( 0, 0,205)},
599 {"royal blue" , PALETTERGB ( 65,105,225)},
600 {"RoyalBlue" , PALETTERGB ( 65,105,225)},
601 {"blue" , PALETTERGB ( 0, 0,255)},
602 {"dodger blue" , PALETTERGB ( 30,144,255)},
603 {"DodgerBlue" , PALETTERGB ( 30,144,255)},
604 {"deep sky blue" , PALETTERGB ( 0,191,255)},
605 {"DeepSkyBlue" , PALETTERGB ( 0,191,255)},
606 {"sky blue" , PALETTERGB (135,206,235)},
607 {"SkyBlue" , PALETTERGB (135,206,235)},
608 {"light sky blue" , PALETTERGB (135,206,250)},
609 {"LightSkyBlue" , PALETTERGB (135,206,250)},
610 {"steel blue" , PALETTERGB ( 70,130,180)},
611 {"SteelBlue" , PALETTERGB ( 70,130,180)},
612 {"light steel blue" , PALETTERGB (176,196,222)},
613 {"LightSteelBlue" , PALETTERGB (176,196,222)},
614 {"light blue" , PALETTERGB (173,216,230)},
615 {"LightBlue" , PALETTERGB (173,216,230)},
616 {"powder blue" , PALETTERGB (176,224,230)},
617 {"PowderBlue" , PALETTERGB (176,224,230)},
618 {"pale turquoise" , PALETTERGB (175,238,238)},
619 {"PaleTurquoise" , PALETTERGB (175,238,238)},
620 {"dark turquoise" , PALETTERGB ( 0,206,209)},
621 {"DarkTurquoise" , PALETTERGB ( 0,206,209)},
622 {"medium turquoise" , PALETTERGB ( 72,209,204)},
623 {"MediumTurquoise" , PALETTERGB ( 72,209,204)},
624 {"turquoise" , PALETTERGB ( 64,224,208)},
625 {"cyan" , PALETTERGB ( 0,255,255)},
626 {"light cyan" , PALETTERGB (224,255,255)},
627 {"LightCyan" , PALETTERGB (224,255,255)},
628 {"cadet blue" , PALETTERGB ( 95,158,160)},
629 {"CadetBlue" , PALETTERGB ( 95,158,160)},
630 {"medium aquamarine" , PALETTERGB (102,205,170)},
631 {"MediumAquamarine" , PALETTERGB (102,205,170)},
632 {"aquamarine" , PALETTERGB (127,255,212)},
633 {"dark green" , PALETTERGB ( 0,100, 0)},
634 {"DarkGreen" , PALETTERGB ( 0,100, 0)},
635 {"dark olive green" , PALETTERGB ( 85,107, 47)},
636 {"DarkOliveGreen" , PALETTERGB ( 85,107, 47)},
637 {"dark sea green" , PALETTERGB (143,188,143)},
638 {"DarkSeaGreen" , PALETTERGB (143,188,143)},
639 {"sea green" , PALETTERGB ( 46,139, 87)},
640 {"SeaGreen" , PALETTERGB ( 46,139, 87)},
641 {"medium sea green" , PALETTERGB ( 60,179,113)},
642 {"MediumSeaGreen" , PALETTERGB ( 60,179,113)},
643 {"light sea green" , PALETTERGB ( 32,178,170)},
644 {"LightSeaGreen" , PALETTERGB ( 32,178,170)},
645 {"pale green" , PALETTERGB (152,251,152)},
646 {"PaleGreen" , PALETTERGB (152,251,152)},
647 {"spring green" , PALETTERGB ( 0,255,127)},
648 {"SpringGreen" , PALETTERGB ( 0,255,127)},
649 {"lawn green" , PALETTERGB (124,252, 0)},
650 {"LawnGreen" , PALETTERGB (124,252, 0)},
651 {"green" , PALETTERGB ( 0,255, 0)},
652 {"chartreuse" , PALETTERGB (127,255, 0)},
653 {"medium spring green" , PALETTERGB ( 0,250,154)},
654 {"MediumSpringGreen" , PALETTERGB ( 0,250,154)},
655 {"green yellow" , PALETTERGB (173,255, 47)},
656 {"GreenYellow" , PALETTERGB (173,255, 47)},
657 {"lime green" , PALETTERGB ( 50,205, 50)},
658 {"LimeGreen" , PALETTERGB ( 50,205, 50)},
659 {"yellow green" , PALETTERGB (154,205, 50)},
660 {"YellowGreen" , PALETTERGB (154,205, 50)},
661 {"forest green" , PALETTERGB ( 34,139, 34)},
662 {"ForestGreen" , PALETTERGB ( 34,139, 34)},
663 {"olive drab" , PALETTERGB (107,142, 35)},
664 {"OliveDrab" , PALETTERGB (107,142, 35)},
665 {"dark khaki" , PALETTERGB (189,183,107)},
666 {"DarkKhaki" , PALETTERGB (189,183,107)},
667 {"khaki" , PALETTERGB (240,230,140)},
668 {"pale goldenrod" , PALETTERGB (238,232,170)},
669 {"PaleGoldenrod" , PALETTERGB (238,232,170)},
670 {"light goldenrod yellow" , PALETTERGB (250,250,210)},
671 {"LightGoldenrodYellow" , PALETTERGB (250,250,210)},
672 {"light yellow" , PALETTERGB (255,255,224)},
673 {"LightYellow" , PALETTERGB (255,255,224)},
674 {"yellow" , PALETTERGB (255,255, 0)},
675 {"gold" , PALETTERGB (255,215, 0)},
676 {"light goldenrod" , PALETTERGB (238,221,130)},
677 {"LightGoldenrod" , PALETTERGB (238,221,130)},
678 {"goldenrod" , PALETTERGB (218,165, 32)},
679 {"dark goldenrod" , PALETTERGB (184,134, 11)},
680 {"DarkGoldenrod" , PALETTERGB (184,134, 11)},
681 {"rosy brown" , PALETTERGB (188,143,143)},
682 {"RosyBrown" , PALETTERGB (188,143,143)},
683 {"indian red" , PALETTERGB (205, 92, 92)},
684 {"IndianRed" , PALETTERGB (205, 92, 92)},
685 {"saddle brown" , PALETTERGB (139, 69, 19)},
686 {"SaddleBrown" , PALETTERGB (139, 69, 19)},
687 {"sienna" , PALETTERGB (160, 82, 45)},
688 {"peru" , PALETTERGB (205,133, 63)},
689 {"burlywood" , PALETTERGB (222,184,135)},
690 {"beige" , PALETTERGB (245,245,220)},
691 {"wheat" , PALETTERGB (245,222,179)},
692 {"sandy brown" , PALETTERGB (244,164, 96)},
693 {"SandyBrown" , PALETTERGB (244,164, 96)},
694 {"tan" , PALETTERGB (210,180,140)},
695 {"chocolate" , PALETTERGB (210,105, 30)},
696 {"firebrick" , PALETTERGB (178,34, 34)},
697 {"brown" , PALETTERGB (165,42, 42)},
698 {"dark salmon" , PALETTERGB (233,150,122)},
699 {"DarkSalmon" , PALETTERGB (233,150,122)},
700 {"salmon" , PALETTERGB (250,128,114)},
701 {"light salmon" , PALETTERGB (255,160,122)},
702 {"LightSalmon" , PALETTERGB (255,160,122)},
703 {"orange" , PALETTERGB (255,165, 0)},
704 {"dark orange" , PALETTERGB (255,140, 0)},
705 {"DarkOrange" , PALETTERGB (255,140, 0)},
706 {"coral" , PALETTERGB (255,127, 80)},
707 {"light coral" , PALETTERGB (240,128,128)},
708 {"LightCoral" , PALETTERGB (240,128,128)},
709 {"tomato" , PALETTERGB (255, 99, 71)},
710 {"orange red" , PALETTERGB (255, 69, 0)},
711 {"OrangeRed" , PALETTERGB (255, 69, 0)},
712 {"red" , PALETTERGB (255, 0, 0)},
713 {"hot pink" , PALETTERGB (255,105,180)},
714 {"HotPink" , PALETTERGB (255,105,180)},
715 {"deep pink" , PALETTERGB (255, 20,147)},
716 {"DeepPink" , PALETTERGB (255, 20,147)},
717 {"pink" , PALETTERGB (255,192,203)},
718 {"light pink" , PALETTERGB (255,182,193)},
719 {"LightPink" , PALETTERGB (255,182,193)},
720 {"pale violet red" , PALETTERGB (219,112,147)},
721 {"PaleVioletRed" , PALETTERGB (219,112,147)},
722 {"maroon" , PALETTERGB (176, 48, 96)},
723 {"medium violet red" , PALETTERGB (199, 21,133)},
724 {"MediumVioletRed" , PALETTERGB (199, 21,133)},
725 {"violet red" , PALETTERGB (208, 32,144)},
726 {"VioletRed" , PALETTERGB (208, 32,144)},
727 {"magenta" , PALETTERGB (255, 0,255)},
728 {"violet" , PALETTERGB (238,130,238)},
729 {"plum" , PALETTERGB (221,160,221)},
730 {"orchid" , PALETTERGB (218,112,214)},
731 {"medium orchid" , PALETTERGB (186, 85,211)},
732 {"MediumOrchid" , PALETTERGB (186, 85,211)},
733 {"dark orchid" , PALETTERGB (153, 50,204)},
734 {"DarkOrchid" , PALETTERGB (153, 50,204)},
735 {"dark violet" , PALETTERGB (148, 0,211)},
736 {"DarkViolet" , PALETTERGB (148, 0,211)},
737 {"blue violet" , PALETTERGB (138, 43,226)},
738 {"BlueViolet" , PALETTERGB (138, 43,226)},
739 {"purple" , PALETTERGB (160, 32,240)},
740 {"medium purple" , PALETTERGB (147,112,219)},
741 {"MediumPurple" , PALETTERGB (147,112,219)},
742 {"thistle" , PALETTERGB (216,191,216)},
743 {"gray0" , PALETTERGB ( 0, 0, 0)},
744 {"grey0" , PALETTERGB ( 0, 0, 0)},
745 {"dark grey" , PALETTERGB (169,169,169)},
746 {"DarkGrey" , PALETTERGB (169,169,169)},
747 {"dark gray" , PALETTERGB (169,169,169)},
748 {"DarkGray" , PALETTERGB (169,169,169)},
749 {"dark blue" , PALETTERGB ( 0, 0,139)},
750 {"DarkBlue" , PALETTERGB ( 0, 0,139)},
751 {"dark cyan" , PALETTERGB ( 0,139,139)},
752 {"DarkCyan" , PALETTERGB ( 0,139,139)},
753 {"dark magenta" , PALETTERGB (139, 0,139)},
754 {"DarkMagenta" , PALETTERGB (139, 0,139)},
755 {"dark red" , PALETTERGB (139, 0, 0)},
756 {"DarkRed" , PALETTERGB (139, 0, 0)},
757 {"light green" , PALETTERGB (144,238,144)},
758 {"LightGreen" , PALETTERGB (144,238,144)},
761 DEFUN ("w32-default-color-map", Fw32_default_color_map
, Sw32_default_color_map
,
762 0, 0, 0, doc
: /* Return the default color map. */)
766 colormap_t
*pc
= w32_color_map
;
773 for (i
= 0; i
< sizeof (w32_color_map
) / sizeof (w32_color_map
[0]);
775 cmap
= Fcons (Fcons (build_string (pc
->name
),
776 make_number (pc
->colorref
)),
794 color
= Frassq (rgb
, Vw32_color_map
);
799 return (Fcar (color
));
805 w32_color_map_lookup (colorname
)
808 Lisp_Object tail
, ret
= Qnil
;
812 for (tail
= Vw32_color_map
; CONSP (tail
); tail
= XCDR (tail
))
814 register Lisp_Object elt
, tem
;
817 if (!CONSP (elt
)) continue;
821 if (lstrcmpi (SDATA (tem
), colorname
) == 0)
838 add_system_logical_colors_to_map (system_colors
)
839 Lisp_Object
*system_colors
;
843 /* Other registry operations are done with input blocked. */
846 /* Look for "Control Panel/Colors" under User and Machine registry
848 if (RegOpenKeyEx (HKEY_CURRENT_USER
, "Control Panel\\Colors", 0,
849 KEY_READ
, &colors_key
) == ERROR_SUCCESS
850 || RegOpenKeyEx (HKEY_LOCAL_MACHINE
, "Control Panel\\Colors", 0,
851 KEY_READ
, &colors_key
) == ERROR_SUCCESS
)
854 char color_buffer
[64];
855 char full_name_buffer
[MAX_PATH
+ SYSTEM_COLOR_PREFIX_LEN
];
857 DWORD name_size
, color_size
;
858 char *name_buffer
= full_name_buffer
+ SYSTEM_COLOR_PREFIX_LEN
;
860 name_size
= sizeof (full_name_buffer
) - SYSTEM_COLOR_PREFIX_LEN
;
861 color_size
= sizeof (color_buffer
);
863 strcpy (full_name_buffer
, SYSTEM_COLOR_PREFIX
);
865 while (RegEnumValueA (colors_key
, index
, name_buffer
, &name_size
,
866 NULL
, NULL
, color_buffer
, &color_size
)
870 if (sscanf (color_buffer
, " %u %u %u", &r
, &g
, &b
) == 3)
871 *system_colors
= Fcons (Fcons (build_string (full_name_buffer
),
872 make_number (RGB (r
, g
, b
))),
875 name_size
= sizeof (full_name_buffer
) - SYSTEM_COLOR_PREFIX_LEN
;
876 color_size
= sizeof (color_buffer
);
879 RegCloseKey (colors_key
);
887 x_to_w32_color (colorname
)
890 register Lisp_Object ret
= Qnil
;
894 if (colorname
[0] == '#')
896 /* Could be an old-style RGB Device specification. */
899 color
= colorname
+ 1;
901 size
= strlen (color
);
902 if (size
== 3 || size
== 6 || size
== 9 || size
== 12)
910 for (i
= 0; i
< 3; i
++)
916 /* The check for 'x' in the following conditional takes into
917 account the fact that strtol allows a "0x" in front of
918 our numbers, and we don't. */
919 if (!isxdigit (color
[0]) || color
[1] == 'x')
923 value
= strtoul (color
, &end
, 16);
925 if (errno
== ERANGE
|| end
- color
!= size
)
930 value
= value
* 0x10;
941 colorval
|= (value
<< pos
);
946 XSETINT (ret
, colorval
);
953 else if (strnicmp (colorname
, "rgb:", 4) == 0)
961 color
= colorname
+ 4;
962 for (i
= 0; i
< 3; i
++)
967 /* The check for 'x' in the following conditional takes into
968 account the fact that strtol allows a "0x" in front of
969 our numbers, and we don't. */
970 if (!isxdigit (color
[0]) || color
[1] == 'x')
972 value
= strtoul (color
, &end
, 16);
978 value
= value
* 0x10 + value
;
991 if (value
== ULONG_MAX
)
993 colorval
|= (value
<< pos
);
1000 XSETINT (ret
, colorval
);
1008 else if (strnicmp (colorname
, "rgbi:", 5) == 0)
1010 /* This is an RGB Intensity specification. */
1017 color
= colorname
+ 5;
1018 for (i
= 0; i
< 3; i
++)
1024 value
= strtod (color
, &end
);
1025 if (errno
== ERANGE
)
1027 if (value
< 0.0 || value
> 1.0)
1029 val
= (UINT
)(0x100 * value
);
1030 /* We used 0x100 instead of 0xFF to give a continuous
1031 range between 0.0 and 1.0 inclusive. The next statement
1032 fixes the 1.0 case. */
1035 colorval
|= (val
<< pos
);
1042 XSETINT (ret
, colorval
);
1050 /* I am not going to attempt to handle any of the CIE color schemes
1051 or TekHVC, since I don't know the algorithms for conversion to
1054 /* If we fail to lookup the color name in w32_color_map, then check the
1055 colorname to see if it can be crudely approximated: If the X color
1056 ends in a number (e.g., "darkseagreen2"), strip the number and
1057 return the result of looking up the base color name. */
1058 ret
= w32_color_map_lookup (colorname
);
1061 int len
= strlen (colorname
);
1063 if (isdigit (colorname
[len
- 1]))
1065 char *ptr
, *approx
= alloca (len
+ 1);
1067 strcpy (approx
, colorname
);
1068 ptr
= &approx
[len
- 1];
1069 while (ptr
> approx
&& isdigit (*ptr
))
1072 ret
= w32_color_map_lookup (approx
);
1081 w32_regenerate_palette (FRAME_PTR f
)
1083 struct w32_palette_entry
* list
;
1084 LOGPALETTE
* log_palette
;
1085 HPALETTE new_palette
;
1088 /* don't bother trying to create palette if not supported */
1089 if (! FRAME_W32_DISPLAY_INFO (f
)->has_palette
)
1092 log_palette
= (LOGPALETTE
*)
1093 alloca (sizeof (LOGPALETTE
) +
1094 FRAME_W32_DISPLAY_INFO (f
)->num_colors
* sizeof (PALETTEENTRY
));
1095 log_palette
->palVersion
= 0x300;
1096 log_palette
->palNumEntries
= FRAME_W32_DISPLAY_INFO (f
)->num_colors
;
1098 list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1100 i
< FRAME_W32_DISPLAY_INFO (f
)->num_colors
;
1101 i
++, list
= list
->next
)
1102 log_palette
->palPalEntry
[i
] = list
->entry
;
1104 new_palette
= CreatePalette (log_palette
);
1108 if (FRAME_W32_DISPLAY_INFO (f
)->palette
)
1109 DeleteObject (FRAME_W32_DISPLAY_INFO (f
)->palette
);
1110 FRAME_W32_DISPLAY_INFO (f
)->palette
= new_palette
;
1112 /* Realize display palette and garbage all frames. */
1113 release_frame_dc (f
, get_frame_dc (f
));
1118 #define W32_COLOR(pe) RGB (pe.peRed, pe.peGreen, pe.peBlue)
1119 #define SET_W32_COLOR(pe, color) \
1122 pe.peRed = GetRValue (color); \
1123 pe.peGreen = GetGValue (color); \
1124 pe.peBlue = GetBValue (color); \
1129 /* Keep these around in case we ever want to track color usage. */
1131 w32_map_color (FRAME_PTR f
, COLORREF color
)
1133 struct w32_palette_entry
* list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1135 if (NILP (Vw32_enable_palette
))
1138 /* check if color is already mapped */
1141 if (W32_COLOR (list
->entry
) == color
)
1149 /* not already mapped, so add to list and recreate Windows palette */
1150 list
= (struct w32_palette_entry
*)
1151 xmalloc (sizeof (struct w32_palette_entry
));
1152 SET_W32_COLOR (list
->entry
, color
);
1154 list
->next
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1155 FRAME_W32_DISPLAY_INFO (f
)->color_list
= list
;
1156 FRAME_W32_DISPLAY_INFO (f
)->num_colors
++;
1158 /* set flag that palette must be regenerated */
1159 FRAME_W32_DISPLAY_INFO (f
)->regen_palette
= TRUE
;
1163 w32_unmap_color (FRAME_PTR f
, COLORREF color
)
1165 struct w32_palette_entry
* list
= FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1166 struct w32_palette_entry
**prev
= &FRAME_W32_DISPLAY_INFO (f
)->color_list
;
1168 if (NILP (Vw32_enable_palette
))
1171 /* check if color is already mapped */
1174 if (W32_COLOR (list
->entry
) == color
)
1176 if (--list
->refcount
== 0)
1180 FRAME_W32_DISPLAY_INFO (f
)->num_colors
--;
1190 /* set flag that palette must be regenerated */
1191 FRAME_W32_DISPLAY_INFO (f
)->regen_palette
= TRUE
;
1196 /* Gamma-correct COLOR on frame F. */
1199 gamma_correct (f
, color
)
1205 *color
= PALETTERGB (
1206 pow (GetRValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5,
1207 pow (GetGValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5,
1208 pow (GetBValue (*color
) / 255.0, f
->gamma
) * 255.0 + 0.5);
1213 /* Decide if color named COLOR is valid for the display associated with
1214 the selected frame; if so, return the rgb values in COLOR_DEF.
1215 If ALLOC is nonzero, allocate a new colormap cell. */
1218 w32_defined_color (f
, color
, color_def
, alloc
)
1224 register Lisp_Object tem
;
1225 COLORREF w32_color_ref
;
1227 tem
= x_to_w32_color (color
);
1233 /* Apply gamma correction. */
1234 w32_color_ref
= XUINT (tem
);
1235 gamma_correct (f
, &w32_color_ref
);
1236 XSETINT (tem
, w32_color_ref
);
1239 /* Map this color to the palette if it is enabled. */
1240 if (!NILP (Vw32_enable_palette
))
1242 struct w32_palette_entry
* entry
=
1243 one_w32_display_info
.color_list
;
1244 struct w32_palette_entry
** prev
=
1245 &one_w32_display_info
.color_list
;
1247 /* check if color is already mapped */
1250 if (W32_COLOR (entry
->entry
) == XUINT (tem
))
1252 prev
= &entry
->next
;
1253 entry
= entry
->next
;
1256 if (entry
== NULL
&& alloc
)
1258 /* not already mapped, so add to list */
1259 entry
= (struct w32_palette_entry
*)
1260 xmalloc (sizeof (struct w32_palette_entry
));
1261 SET_W32_COLOR (entry
->entry
, XUINT (tem
));
1264 one_w32_display_info
.num_colors
++;
1266 /* set flag that palette must be regenerated */
1267 one_w32_display_info
.regen_palette
= TRUE
;
1270 /* Ensure COLORREF value is snapped to nearest color in (default)
1271 palette by simulating the PALETTERGB macro. This works whether
1272 or not the display device has a palette. */
1273 w32_color_ref
= XUINT (tem
) | 0x2000000;
1275 color_def
->pixel
= w32_color_ref
;
1276 color_def
->red
= GetRValue (w32_color_ref
) * 256;
1277 color_def
->green
= GetGValue (w32_color_ref
) * 256;
1278 color_def
->blue
= GetBValue (w32_color_ref
) * 256;
1288 /* Given a string ARG naming a color, compute a pixel value from it
1289 suitable for screen F.
1290 If F is not a color screen, return DEF (default) regardless of what
1294 x_decode_color (f
, arg
, def
)
1303 if (strcmp (SDATA (arg
), "black") == 0)
1304 return BLACK_PIX_DEFAULT (f
);
1305 else if (strcmp (SDATA (arg
), "white") == 0)
1306 return WHITE_PIX_DEFAULT (f
);
1308 if ((FRAME_W32_DISPLAY_INFO (f
)->n_planes
* FRAME_W32_DISPLAY_INFO (f
)->n_cbits
) == 1)
1311 /* w32_defined_color is responsible for coping with failures
1312 by looking for a near-miss. */
1313 if (w32_defined_color (f
, SDATA (arg
), &cdef
, 1))
1316 /* defined_color failed; return an ultimate default. */
1322 /* Functions called only from `x_set_frame_param'
1323 to set individual parameters.
1325 If FRAME_W32_WINDOW (f) is 0,
1326 the frame is being created and its window does not exist yet.
1327 In that case, just record the parameter's new value
1328 in the standard place; do not attempt to change the window. */
1331 x_set_foreground_color (f
, arg
, oldval
)
1333 Lisp_Object arg
, oldval
;
1335 struct w32_output
*x
= f
->output_data
.w32
;
1336 PIX_TYPE fg
, old_fg
;
1338 fg
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1339 old_fg
= FRAME_FOREGROUND_PIXEL (f
);
1340 FRAME_FOREGROUND_PIXEL (f
) = fg
;
1342 if (FRAME_W32_WINDOW (f
) != 0)
1344 if (x
->cursor_pixel
== old_fg
)
1345 x
->cursor_pixel
= fg
;
1347 update_face_from_frame_parameter (f
, Qforeground_color
, arg
);
1348 if (FRAME_VISIBLE_P (f
))
1354 x_set_background_color (f
, arg
, oldval
)
1356 Lisp_Object arg
, oldval
;
1358 FRAME_BACKGROUND_PIXEL (f
)
1359 = x_decode_color (f
, arg
, WHITE_PIX_DEFAULT (f
));
1361 if (FRAME_W32_WINDOW (f
) != 0)
1363 SetWindowLong (FRAME_W32_WINDOW (f
), WND_BACKGROUND_INDEX
,
1364 FRAME_BACKGROUND_PIXEL (f
));
1366 update_face_from_frame_parameter (f
, Qbackground_color
, arg
);
1368 if (FRAME_VISIBLE_P (f
))
1374 x_set_mouse_color (f
, arg
, oldval
)
1376 Lisp_Object arg
, oldval
;
1378 Cursor cursor
, nontext_cursor
, mode_cursor
, hand_cursor
;
1382 if (!EQ (Qnil
, arg
))
1383 f
->output_data
.w32
->mouse_pixel
1384 = x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1385 mask_color
= FRAME_BACKGROUND_PIXEL (f
);
1387 /* Don't let pointers be invisible. */
1388 if (mask_color
== f
->output_data
.w32
->mouse_pixel
1389 && mask_color
== FRAME_BACKGROUND_PIXEL (f
))
1390 f
->output_data
.w32
->mouse_pixel
= FRAME_FOREGROUND_PIXEL (f
);
1392 #if 0 /* TODO : cursor changes */
1395 /* It's not okay to crash if the user selects a screwy cursor. */
1396 count
= x_catch_errors (FRAME_W32_DISPLAY (f
));
1398 if (!EQ (Qnil
, Vx_pointer_shape
))
1400 CHECK_NUMBER (Vx_pointer_shape
);
1401 cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XINT (Vx_pointer_shape
));
1404 cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_xterm
);
1405 x_check_errors (FRAME_W32_DISPLAY (f
), "bad text pointer cursor: %s");
1407 if (!EQ (Qnil
, Vx_nontext_pointer_shape
))
1409 CHECK_NUMBER (Vx_nontext_pointer_shape
);
1410 nontext_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1411 XINT (Vx_nontext_pointer_shape
));
1414 nontext_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_left_ptr
);
1415 x_check_errors (FRAME_W32_DISPLAY (f
), "bad nontext pointer cursor: %s");
1417 if (!EQ (Qnil
, Vx_hourglass_pointer_shape
))
1419 CHECK_NUMBER (Vx_hourglass_pointer_shape
);
1420 hourglass_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1421 XINT (Vx_hourglass_pointer_shape
));
1424 hourglass_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_watch
);
1425 x_check_errors (FRAME_W32_DISPLAY (f
), "bad busy pointer cursor: %s");
1427 x_check_errors (FRAME_W32_DISPLAY (f
), "bad nontext pointer cursor: %s");
1428 if (!EQ (Qnil
, Vx_mode_pointer_shape
))
1430 CHECK_NUMBER (Vx_mode_pointer_shape
);
1431 mode_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1432 XINT (Vx_mode_pointer_shape
));
1435 mode_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_xterm
);
1436 x_check_errors (FRAME_W32_DISPLAY (f
), "bad modeline pointer cursor: %s");
1438 if (!EQ (Qnil
, Vx_sensitive_text_pointer_shape
))
1440 CHECK_NUMBER (Vx_sensitive_text_pointer_shape
);
1442 = XCreateFontCursor (FRAME_W32_DISPLAY (f
),
1443 XINT (Vx_sensitive_text_pointer_shape
));
1446 hand_cursor
= XCreateFontCursor (FRAME_W32_DISPLAY (f
), XC_crosshair
);
1448 if (!NILP (Vx_window_horizontal_drag_shape
))
1450 CHECK_NUMBER (Vx_window_horizontal_drag_shape
);
1451 horizontal_drag_cursor
1452 = XCreateFontCursor (FRAME_X_DISPLAY (f
),
1453 XINT (Vx_window_horizontal_drag_shape
));
1456 horizontal_drag_cursor
1457 = XCreateFontCursor (FRAME_X_DISPLAY (f
), XC_sb_h_double_arrow
);
1459 /* Check and report errors with the above calls. */
1460 x_check_errors (FRAME_W32_DISPLAY (f
), "can't set cursor shape: %s");
1461 x_uncatch_errors (FRAME_W32_DISPLAY (f
), count
);
1464 XColor fore_color
, back_color
;
1466 fore_color
.pixel
= f
->output_data
.w32
->mouse_pixel
;
1467 back_color
.pixel
= mask_color
;
1468 XQueryColor (FRAME_W32_DISPLAY (f
),
1469 DefaultColormap (FRAME_W32_DISPLAY (f
),
1470 DefaultScreen (FRAME_W32_DISPLAY (f
))),
1472 XQueryColor (FRAME_W32_DISPLAY (f
),
1473 DefaultColormap (FRAME_W32_DISPLAY (f
),
1474 DefaultScreen (FRAME_W32_DISPLAY (f
))),
1476 XRecolorCursor (FRAME_W32_DISPLAY (f
), cursor
,
1477 &fore_color
, &back_color
);
1478 XRecolorCursor (FRAME_W32_DISPLAY (f
), nontext_cursor
,
1479 &fore_color
, &back_color
);
1480 XRecolorCursor (FRAME_W32_DISPLAY (f
), mode_cursor
,
1481 &fore_color
, &back_color
);
1482 XRecolorCursor (FRAME_W32_DISPLAY (f
), hand_cursor
,
1483 &fore_color
, &back_color
);
1484 XRecolorCursor (FRAME_W32_DISPLAY (f
), hourglass_cursor
,
1485 &fore_color
, &back_color
);
1488 if (FRAME_W32_WINDOW (f
) != 0)
1489 XDefineCursor (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
), cursor
);
1491 if (cursor
!= f
->output_data
.w32
->text_cursor
&& f
->output_data
.w32
->text_cursor
!= 0)
1492 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->text_cursor
);
1493 f
->output_data
.w32
->text_cursor
= cursor
;
1495 if (nontext_cursor
!= f
->output_data
.w32
->nontext_cursor
1496 && f
->output_data
.w32
->nontext_cursor
!= 0)
1497 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->nontext_cursor
);
1498 f
->output_data
.w32
->nontext_cursor
= nontext_cursor
;
1500 if (hourglass_cursor
!= f
->output_data
.w32
->hourglass_cursor
1501 && f
->output_data
.w32
->hourglass_cursor
!= 0)
1502 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->hourglass_cursor
);
1503 f
->output_data
.w32
->hourglass_cursor
= hourglass_cursor
;
1505 if (mode_cursor
!= f
->output_data
.w32
->modeline_cursor
1506 && f
->output_data
.w32
->modeline_cursor
!= 0)
1507 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->modeline_cursor
);
1508 f
->output_data
.w32
->modeline_cursor
= mode_cursor
;
1510 if (hand_cursor
!= f
->output_data
.w32
->hand_cursor
1511 && f
->output_data
.w32
->hand_cursor
!= 0)
1512 XFreeCursor (FRAME_W32_DISPLAY (f
), f
->output_data
.w32
->hand_cursor
);
1513 f
->output_data
.w32
->hand_cursor
= hand_cursor
;
1515 XFlush (FRAME_W32_DISPLAY (f
));
1518 update_face_from_frame_parameter (f
, Qmouse_color
, arg
);
1523 x_set_cursor_color (f
, arg
, oldval
)
1525 Lisp_Object arg
, oldval
;
1527 unsigned long fore_pixel
, pixel
;
1529 if (!NILP (Vx_cursor_fore_pixel
))
1530 fore_pixel
= x_decode_color (f
, Vx_cursor_fore_pixel
,
1531 WHITE_PIX_DEFAULT (f
));
1533 fore_pixel
= FRAME_BACKGROUND_PIXEL (f
);
1535 pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1537 /* Make sure that the cursor color differs from the background color. */
1538 if (pixel
== FRAME_BACKGROUND_PIXEL (f
))
1540 pixel
= f
->output_data
.w32
->mouse_pixel
;
1541 if (pixel
== fore_pixel
)
1542 fore_pixel
= FRAME_BACKGROUND_PIXEL (f
);
1545 f
->output_data
.w32
->cursor_foreground_pixel
= fore_pixel
;
1546 f
->output_data
.w32
->cursor_pixel
= pixel
;
1548 if (FRAME_W32_WINDOW (f
) != 0)
1551 /* Update frame's cursor_gc. */
1552 f
->output_data
.w32
->cursor_gc
->foreground
= fore_pixel
;
1553 f
->output_data
.w32
->cursor_gc
->background
= pixel
;
1557 if (FRAME_VISIBLE_P (f
))
1559 x_update_cursor (f
, 0);
1560 x_update_cursor (f
, 1);
1564 update_face_from_frame_parameter (f
, Qcursor_color
, arg
);
1567 /* Set the border-color of frame F to pixel value PIX.
1568 Note that this does not fully take effect if done before
1572 x_set_border_pixel (f
, pix
)
1577 f
->output_data
.w32
->border_pixel
= pix
;
1579 if (FRAME_W32_WINDOW (f
) != 0 && f
->border_width
> 0)
1581 if (FRAME_VISIBLE_P (f
))
1586 /* Set the border-color of frame F to value described by ARG.
1587 ARG can be a string naming a color.
1588 The border-color is used for the border that is drawn by the server.
1589 Note that this does not fully take effect if done before
1590 F has a window; it must be redone when the window is created. */
1593 x_set_border_color (f
, arg
, oldval
)
1595 Lisp_Object arg
, oldval
;
1600 pix
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1601 x_set_border_pixel (f
, pix
);
1602 update_face_from_frame_parameter (f
, Qborder_color
, arg
);
1607 x_set_cursor_type (f
, arg
, oldval
)
1609 Lisp_Object arg
, oldval
;
1611 set_frame_cursor_types (f
, arg
);
1613 /* Make sure the cursor gets redrawn. */
1614 cursor_type_changed
= 1;
1618 x_set_icon_type (f
, arg
, oldval
)
1620 Lisp_Object arg
, oldval
;
1624 if (NILP (arg
) && NILP (oldval
))
1627 if (STRINGP (arg
) && STRINGP (oldval
)
1628 && EQ (Fstring_equal (oldval
, arg
), Qt
))
1631 if (SYMBOLP (arg
) && SYMBOLP (oldval
) && EQ (arg
, oldval
))
1636 result
= x_bitmap_icon (f
, arg
);
1640 error ("No icon window available");
1647 x_set_icon_name (f
, arg
, oldval
)
1649 Lisp_Object arg
, oldval
;
1653 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1656 else if (!NILP (arg
) || NILP (oldval
))
1662 if (f
->output_data
.w32
->icon_bitmap
!= 0)
1667 result
= x_text_icon (f
,
1668 (char *) SDATA ((!NILP (f
->icon_name
)
1677 error ("No icon window available");
1680 /* If the window was unmapped (and its icon was mapped),
1681 the new icon is not mapped, so map the window in its stead. */
1682 if (FRAME_VISIBLE_P (f
))
1684 #ifdef USE_X_TOOLKIT
1685 XtPopup (f
->output_data
.w32
->widget
, XtGrabNone
);
1687 XMapWindow (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
));
1690 XFlush (FRAME_W32_DISPLAY (f
));
1697 x_set_menu_bar_lines (f
, value
, oldval
)
1699 Lisp_Object value
, oldval
;
1702 int olines
= FRAME_MENU_BAR_LINES (f
);
1704 /* Right now, menu bars don't work properly in minibuf-only frames;
1705 most of the commands try to apply themselves to the minibuffer
1706 frame itself, and get an error because you can't switch buffers
1707 in or split the minibuffer window. */
1708 if (FRAME_MINIBUF_ONLY_P (f
))
1711 if (INTEGERP (value
))
1712 nlines
= XINT (value
);
1716 FRAME_MENU_BAR_LINES (f
) = 0;
1718 FRAME_EXTERNAL_MENU_BAR (f
) = 1;
1721 if (FRAME_EXTERNAL_MENU_BAR (f
) == 1)
1722 free_frame_menubar (f
);
1723 FRAME_EXTERNAL_MENU_BAR (f
) = 0;
1725 /* Adjust the frame size so that the client (text) dimensions
1726 remain the same. This depends on FRAME_EXTERNAL_MENU_BAR being
1728 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
1729 do_pending_window_change (0);
1735 /* Set the number of lines used for the tool bar of frame F to VALUE.
1736 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1737 is the old number of tool bar lines. This function changes the
1738 height of all windows on frame F to match the new tool bar height.
1739 The frame's height doesn't change. */
1742 x_set_tool_bar_lines (f
, value
, oldval
)
1744 Lisp_Object value
, oldval
;
1746 int delta
, nlines
, root_height
;
1747 Lisp_Object root_window
;
1749 /* Treat tool bars like menu bars. */
1750 if (FRAME_MINIBUF_ONLY_P (f
))
1753 /* Use VALUE only if an integer >= 0. */
1754 if (INTEGERP (value
) && XINT (value
) >= 0)
1755 nlines
= XFASTINT (value
);
1759 /* Make sure we redisplay all windows in this frame. */
1760 ++windows_or_buffers_changed
;
1762 delta
= nlines
- FRAME_TOOL_BAR_LINES (f
);
1764 /* Don't resize the tool-bar to more than we have room for. */
1765 root_window
= FRAME_ROOT_WINDOW (f
);
1766 root_height
= WINDOW_TOTAL_LINES (XWINDOW (root_window
));
1767 if (root_height
- delta
< 1)
1769 delta
= root_height
- 1;
1770 nlines
= FRAME_TOOL_BAR_LINES (f
) + delta
;
1773 FRAME_TOOL_BAR_LINES (f
) = nlines
;
1774 change_window_heights (root_window
, delta
);
1777 /* We also have to make sure that the internal border at the top of
1778 the frame, below the menu bar or tool bar, is redrawn when the
1779 tool bar disappears. This is so because the internal border is
1780 below the tool bar if one is displayed, but is below the menu bar
1781 if there isn't a tool bar. The tool bar draws into the area
1782 below the menu bar. */
1783 if (FRAME_W32_WINDOW (f
) && FRAME_TOOL_BAR_LINES (f
) == 0)
1786 clear_current_matrices (f
);
1789 /* If the tool bar gets smaller, the internal border below it
1790 has to be cleared. It was formerly part of the display
1791 of the larger tool bar, and updating windows won't clear it. */
1794 int height
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1795 int width
= FRAME_PIXEL_WIDTH (f
);
1796 int y
= nlines
* FRAME_LINE_HEIGHT (f
);
1800 HDC hdc
= get_frame_dc (f
);
1801 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
1802 release_frame_dc (f
, hdc
);
1806 if (WINDOWP (f
->tool_bar_window
))
1807 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1812 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1815 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1816 name; if NAME is a string, set F's name to NAME and set
1817 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1819 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1820 suggesting a new name, which lisp code should override; if
1821 F->explicit_name is set, ignore the new name; otherwise, set it. */
1824 x_set_name (f
, name
, explicit)
1829 /* Make sure that requests from lisp code override requests from
1830 Emacs redisplay code. */
1833 /* If we're switching from explicit to implicit, we had better
1834 update the mode lines and thereby update the title. */
1835 if (f
->explicit_name
&& NILP (name
))
1836 update_mode_lines
= 1;
1838 f
->explicit_name
= ! NILP (name
);
1840 else if (f
->explicit_name
)
1843 /* If NAME is nil, set the name to the w32_id_name. */
1846 /* Check for no change needed in this very common case
1847 before we do any consing. */
1848 if (!strcmp (FRAME_W32_DISPLAY_INFO (f
)->w32_id_name
,
1851 name
= build_string (FRAME_W32_DISPLAY_INFO (f
)->w32_id_name
);
1854 CHECK_STRING (name
);
1856 /* Don't change the name if it's already NAME. */
1857 if (! NILP (Fstring_equal (name
, f
->name
)))
1862 /* For setting the frame title, the title parameter should override
1863 the name parameter. */
1864 if (! NILP (f
->title
))
1867 if (FRAME_W32_WINDOW (f
))
1869 if (STRING_MULTIBYTE (name
))
1870 name
= ENCODE_SYSTEM (name
);
1873 SetWindowText (FRAME_W32_WINDOW (f
), SDATA (name
));
1878 /* This function should be called when the user's lisp code has
1879 specified a name for the frame; the name will override any set by the
1882 x_explicitly_set_name (f
, arg
, oldval
)
1884 Lisp_Object arg
, oldval
;
1886 x_set_name (f
, arg
, 1);
1889 /* This function should be called by Emacs redisplay code to set the
1890 name; names set this way will never override names set by the user's
1893 x_implicitly_set_name (f
, arg
, oldval
)
1895 Lisp_Object arg
, oldval
;
1897 x_set_name (f
, arg
, 0);
1900 /* Change the title of frame F to NAME.
1901 If NAME is nil, use the frame name as the title. */
1904 x_set_title (f
, name
, old_name
)
1906 Lisp_Object name
, old_name
;
1908 /* Don't change the title if it's already NAME. */
1909 if (EQ (name
, f
->title
))
1912 update_mode_lines
= 1;
1919 if (FRAME_W32_WINDOW (f
))
1921 if (STRING_MULTIBYTE (name
))
1922 name
= ENCODE_SYSTEM (name
);
1925 SetWindowText (FRAME_W32_WINDOW (f
), SDATA (name
));
1931 void x_set_scroll_bar_default_width (f
)
1934 int wid
= FRAME_COLUMN_WIDTH (f
);
1936 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = GetSystemMetrics (SM_CXVSCROLL
);
1937 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) +
1942 /* Subroutines for creating a frame. */
1945 w32_load_cursor (LPCTSTR name
)
1947 /* Try first to load cursor from application resource. */
1948 Cursor cursor
= LoadImage ((HINSTANCE
) GetModuleHandle (NULL
),
1949 name
, IMAGE_CURSOR
, 0, 0,
1950 LR_DEFAULTCOLOR
| LR_DEFAULTSIZE
| LR_SHARED
);
1953 /* Then try to load a shared predefined cursor. */
1954 cursor
= LoadImage (NULL
, name
, IMAGE_CURSOR
, 0, 0,
1955 LR_DEFAULTCOLOR
| LR_DEFAULTSIZE
| LR_SHARED
);
1960 extern LRESULT CALLBACK
w32_wnd_proc ();
1963 w32_init_class (hinst
)
1968 wc
.style
= CS_HREDRAW
| CS_VREDRAW
;
1969 wc
.lpfnWndProc
= (WNDPROC
) w32_wnd_proc
;
1971 wc
.cbWndExtra
= WND_EXTRA_BYTES
;
1972 wc
.hInstance
= hinst
;
1973 wc
.hIcon
= LoadIcon (hinst
, EMACS_CLASS
);
1974 wc
.hCursor
= w32_load_cursor (IDC_ARROW
);
1975 wc
.hbrBackground
= NULL
; /* GetStockObject (WHITE_BRUSH); */
1976 wc
.lpszMenuName
= NULL
;
1977 wc
.lpszClassName
= EMACS_CLASS
;
1979 return (RegisterClass (&wc
));
1983 w32_createscrollbar (f
, bar
)
1985 struct scroll_bar
* bar
;
1987 return (CreateWindow ("SCROLLBAR", "", SBS_VERT
| WS_CHILD
| WS_VISIBLE
,
1988 /* Position and size of scroll bar. */
1989 XINT (bar
->left
) + VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
1991 XINT (bar
->width
) - VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
1993 FRAME_W32_WINDOW (f
),
2000 w32_createwindow (f
)
2005 Lisp_Object top
= Qunbound
;
2006 Lisp_Object left
= Qunbound
;
2007 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
2009 rect
.left
= rect
.top
= 0;
2010 rect
.right
= FRAME_PIXEL_WIDTH (f
);
2011 rect
.bottom
= FRAME_PIXEL_HEIGHT (f
);
2013 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
2014 FRAME_EXTERNAL_MENU_BAR (f
));
2016 /* Do first time app init */
2020 w32_init_class (hinst
);
2023 if (f
->size_hint_flags
& USPosition
|| f
->size_hint_flags
& PPosition
)
2025 XSETINT (left
, f
->left_pos
);
2026 XSETINT (top
, f
->top_pos
);
2028 else if (EQ (left
, Qunbound
) && EQ (top
, Qunbound
))
2030 /* When called with RES_TYPE_NUMBER, w32_get_arg will return zero
2031 for anything that is not a number and is not Qunbound. */
2032 left
= x_get_arg (dpyinfo
, Qnil
, Qleft
, "left", "Left", RES_TYPE_NUMBER
);
2033 top
= x_get_arg (dpyinfo
, Qnil
, Qtop
, "top", "Top", RES_TYPE_NUMBER
);
2036 FRAME_W32_WINDOW (f
) = hwnd
2037 = CreateWindow (EMACS_CLASS
,
2039 f
->output_data
.w32
->dwStyle
| WS_CLIPCHILDREN
,
2040 EQ (left
, Qunbound
) ? CW_USEDEFAULT
: XINT (left
),
2041 EQ (top
, Qunbound
) ? CW_USEDEFAULT
: XINT (top
),
2042 rect
.right
- rect
.left
,
2043 rect
.bottom
- rect
.top
,
2051 SetWindowLong (hwnd
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
2052 SetWindowLong (hwnd
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
2053 SetWindowLong (hwnd
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
2054 SetWindowLong (hwnd
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
2055 SetWindowLong (hwnd
, WND_BACKGROUND_INDEX
, FRAME_BACKGROUND_PIXEL (f
));
2057 /* Enable drag-n-drop. */
2058 DragAcceptFiles (hwnd
, TRUE
);
2060 /* Do this to discard the default setting specified by our parent. */
2061 ShowWindow (hwnd
, SW_HIDE
);
2063 /* Update frame positions. */
2064 GetWindowRect (hwnd
, &rect
);
2065 f
->left_pos
= rect
.left
;
2066 f
->top_pos
= rect
.top
;
2071 my_post_msg (wmsg
, hwnd
, msg
, wParam
, lParam
)
2078 wmsg
->msg
.hwnd
= hwnd
;
2079 wmsg
->msg
.message
= msg
;
2080 wmsg
->msg
.wParam
= wParam
;
2081 wmsg
->msg
.lParam
= lParam
;
2082 wmsg
->msg
.time
= GetMessageTime ();
2087 /* GetKeyState and MapVirtualKey on Windows 95 do not actually distinguish
2088 between left and right keys as advertised. We test for this
2089 support dynamically, and set a flag when the support is absent. If
2090 absent, we keep track of the left and right control and alt keys
2091 ourselves. This is particularly necessary on keyboards that rely
2092 upon the AltGr key, which is represented as having the left control
2093 and right alt keys pressed. For these keyboards, we need to know
2094 when the left alt key has been pressed in addition to the AltGr key
2095 so that we can properly support M-AltGr-key sequences (such as M-@
2096 on Swedish keyboards). */
2098 #define EMACS_LCONTROL 0
2099 #define EMACS_RCONTROL 1
2100 #define EMACS_LMENU 2
2101 #define EMACS_RMENU 3
2103 static int modifiers
[4];
2104 static int modifiers_recorded
;
2105 static int modifier_key_support_tested
;
2108 test_modifier_support (unsigned int wparam
)
2112 if (wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
)
2114 if (wparam
== VK_CONTROL
)
2124 if (!(GetKeyState (l
) & 0x8000) && !(GetKeyState (r
) & 0x8000))
2125 modifiers_recorded
= 1;
2127 modifiers_recorded
= 0;
2128 modifier_key_support_tested
= 1;
2132 record_keydown (unsigned int wparam
, unsigned int lparam
)
2136 if (!modifier_key_support_tested
)
2137 test_modifier_support (wparam
);
2139 if ((wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
) || !modifiers_recorded
)
2142 if (wparam
== VK_CONTROL
)
2143 i
= (lparam
& 0x1000000) ? EMACS_RCONTROL
: EMACS_LCONTROL
;
2145 i
= (lparam
& 0x1000000) ? EMACS_RMENU
: EMACS_LMENU
;
2151 record_keyup (unsigned int wparam
, unsigned int lparam
)
2155 if ((wparam
!= VK_CONTROL
&& wparam
!= VK_MENU
) || !modifiers_recorded
)
2158 if (wparam
== VK_CONTROL
)
2159 i
= (lparam
& 0x1000000) ? EMACS_RCONTROL
: EMACS_LCONTROL
;
2161 i
= (lparam
& 0x1000000) ? EMACS_RMENU
: EMACS_LMENU
;
2166 /* Emacs can lose focus while a modifier key has been pressed. When
2167 it regains focus, be conservative and clear all modifiers since
2168 we cannot reconstruct the left and right modifier state. */
2174 if (GetFocus () == NULL
)
2175 /* Emacs doesn't have keyboard focus. Do nothing. */
2178 ctrl
= GetAsyncKeyState (VK_CONTROL
);
2179 alt
= GetAsyncKeyState (VK_MENU
);
2181 if (!(ctrl
& 0x08000))
2182 /* Clear any recorded control modifier state. */
2183 modifiers
[EMACS_RCONTROL
] = modifiers
[EMACS_LCONTROL
] = 0;
2185 if (!(alt
& 0x08000))
2186 /* Clear any recorded alt modifier state. */
2187 modifiers
[EMACS_RMENU
] = modifiers
[EMACS_LMENU
] = 0;
2189 /* Update the state of all modifier keys, because modifiers used in
2190 hot-key combinations can get stuck on if Emacs loses focus as a
2191 result of a hot-key being pressed. */
2195 #define CURRENT_STATE(key) ((GetAsyncKeyState (key) & 0x8000) >> 8)
2197 GetKeyboardState (keystate
);
2198 keystate
[VK_SHIFT
] = CURRENT_STATE (VK_SHIFT
);
2199 keystate
[VK_CONTROL
] = CURRENT_STATE (VK_CONTROL
);
2200 keystate
[VK_LCONTROL
] = CURRENT_STATE (VK_LCONTROL
);
2201 keystate
[VK_RCONTROL
] = CURRENT_STATE (VK_RCONTROL
);
2202 keystate
[VK_MENU
] = CURRENT_STATE (VK_MENU
);
2203 keystate
[VK_LMENU
] = CURRENT_STATE (VK_LMENU
);
2204 keystate
[VK_RMENU
] = CURRENT_STATE (VK_RMENU
);
2205 keystate
[VK_LWIN
] = CURRENT_STATE (VK_LWIN
);
2206 keystate
[VK_RWIN
] = CURRENT_STATE (VK_RWIN
);
2207 keystate
[VK_APPS
] = CURRENT_STATE (VK_APPS
);
2208 SetKeyboardState (keystate
);
2212 /* Synchronize modifier state with what is reported with the current
2213 keystroke. Even if we cannot distinguish between left and right
2214 modifier keys, we know that, if no modifiers are set, then neither
2215 the left or right modifier should be set. */
2219 if (!modifiers_recorded
)
2222 if (!(GetKeyState (VK_CONTROL
) & 0x8000))
2223 modifiers
[EMACS_RCONTROL
] = modifiers
[EMACS_LCONTROL
] = 0;
2225 if (!(GetKeyState (VK_MENU
) & 0x8000))
2226 modifiers
[EMACS_RMENU
] = modifiers
[EMACS_LMENU
] = 0;
2230 modifier_set (int vkey
)
2232 if (vkey
== VK_CAPITAL
|| vkey
== VK_SCROLL
)
2233 return (GetKeyState (vkey
) & 0x1);
2234 if (!modifiers_recorded
)
2235 return (GetKeyState (vkey
) & 0x8000);
2240 return modifiers
[EMACS_LCONTROL
];
2242 return modifiers
[EMACS_RCONTROL
];
2244 return modifiers
[EMACS_LMENU
];
2246 return modifiers
[EMACS_RMENU
];
2248 return (GetKeyState (vkey
) & 0x8000);
2251 /* Convert between the modifier bits W32 uses and the modifier bits
2255 w32_key_to_modifier (int key
)
2257 Lisp_Object key_mapping
;
2262 key_mapping
= Vw32_lwindow_modifier
;
2265 key_mapping
= Vw32_rwindow_modifier
;
2268 key_mapping
= Vw32_apps_modifier
;
2271 key_mapping
= Vw32_scroll_lock_modifier
;
2277 /* NB. This code runs in the input thread, asychronously to the lisp
2278 thread, so we must be careful to ensure access to lisp data is
2279 thread-safe. The following code is safe because the modifier
2280 variable values are updated atomically from lisp and symbols are
2281 not relocated by GC. Also, we don't have to worry about seeing GC
2283 if (EQ (key_mapping
, Qhyper
))
2284 return hyper_modifier
;
2285 if (EQ (key_mapping
, Qsuper
))
2286 return super_modifier
;
2287 if (EQ (key_mapping
, Qmeta
))
2288 return meta_modifier
;
2289 if (EQ (key_mapping
, Qalt
))
2290 return alt_modifier
;
2291 if (EQ (key_mapping
, Qctrl
))
2292 return ctrl_modifier
;
2293 if (EQ (key_mapping
, Qcontrol
)) /* synonym for ctrl */
2294 return ctrl_modifier
;
2295 if (EQ (key_mapping
, Qshift
))
2296 return shift_modifier
;
2298 /* Don't generate any modifier if not explicitly requested. */
2303 w32_get_modifiers ()
2305 return ((modifier_set (VK_SHIFT
) ? shift_modifier
: 0) |
2306 (modifier_set (VK_CONTROL
) ? ctrl_modifier
: 0) |
2307 (modifier_set (VK_LWIN
) ? w32_key_to_modifier (VK_LWIN
) : 0) |
2308 (modifier_set (VK_RWIN
) ? w32_key_to_modifier (VK_RWIN
) : 0) |
2309 (modifier_set (VK_APPS
) ? w32_key_to_modifier (VK_APPS
) : 0) |
2310 (modifier_set (VK_SCROLL
) ? w32_key_to_modifier (VK_SCROLL
) : 0) |
2311 (modifier_set (VK_MENU
) ?
2312 ((NILP (Vw32_alt_is_meta
)) ? alt_modifier
: meta_modifier
) : 0));
2315 /* We map the VK_* modifiers into console modifier constants
2316 so that we can use the same routines to handle both console
2317 and window input. */
2320 construct_console_modifiers ()
2325 mods
|= (modifier_set (VK_SHIFT
)) ? SHIFT_PRESSED
: 0;
2326 mods
|= (modifier_set (VK_CAPITAL
)) ? CAPSLOCK_ON
: 0;
2327 mods
|= (modifier_set (VK_SCROLL
)) ? SCROLLLOCK_ON
: 0;
2328 mods
|= (modifier_set (VK_NUMLOCK
)) ? NUMLOCK_ON
: 0;
2329 mods
|= (modifier_set (VK_LCONTROL
)) ? LEFT_CTRL_PRESSED
: 0;
2330 mods
|= (modifier_set (VK_RCONTROL
)) ? RIGHT_CTRL_PRESSED
: 0;
2331 mods
|= (modifier_set (VK_LMENU
)) ? LEFT_ALT_PRESSED
: 0;
2332 mods
|= (modifier_set (VK_RMENU
)) ? RIGHT_ALT_PRESSED
: 0;
2333 mods
|= (modifier_set (VK_LWIN
)) ? LEFT_WIN_PRESSED
: 0;
2334 mods
|= (modifier_set (VK_RWIN
)) ? RIGHT_WIN_PRESSED
: 0;
2335 mods
|= (modifier_set (VK_APPS
)) ? APPS_PRESSED
: 0;
2341 w32_get_key_modifiers (unsigned int wparam
, unsigned int lparam
)
2345 /* Convert to emacs modifiers. */
2346 mods
= w32_kbd_mods_to_emacs (construct_console_modifiers (), wparam
);
2352 map_keypad_keys (unsigned int virt_key
, unsigned int extended
)
2354 if (virt_key
< VK_CLEAR
|| virt_key
> VK_DELETE
)
2357 if (virt_key
== VK_RETURN
)
2358 return (extended
? VK_NUMPAD_ENTER
: VK_RETURN
);
2360 if (virt_key
>= VK_PRIOR
&& virt_key
<= VK_DOWN
)
2361 return (!extended
? (VK_NUMPAD_PRIOR
+ (virt_key
- VK_PRIOR
)) : virt_key
);
2363 if (virt_key
== VK_INSERT
|| virt_key
== VK_DELETE
)
2364 return (!extended
? (VK_NUMPAD_INSERT
+ (virt_key
- VK_INSERT
)) : virt_key
);
2366 if (virt_key
== VK_CLEAR
)
2367 return (!extended
? VK_NUMPAD_CLEAR
: virt_key
);
2372 /* List of special key combinations which w32 would normally capture,
2373 but Emacs should grab instead. Not directly visible to lisp, to
2374 simplify synchronization. Each item is an integer encoding a virtual
2375 key code and modifier combination to capture. */
2376 static Lisp_Object w32_grabbed_keys
;
2378 #define HOTKEY(vk, mods) make_number (((vk) & 255) | ((mods) << 8))
2379 #define HOTKEY_ID(k) (XFASTINT (k) & 0xbfff)
2380 #define HOTKEY_VK_CODE(k) (XFASTINT (k) & 255)
2381 #define HOTKEY_MODIFIERS(k) (XFASTINT (k) >> 8)
2383 #define RAW_HOTKEY_ID(k) ((k) & 0xbfff)
2384 #define RAW_HOTKEY_VK_CODE(k) ((k) & 255)
2385 #define RAW_HOTKEY_MODIFIERS(k) ((k) >> 8)
2387 /* Register hot-keys for reserved key combinations when Emacs has
2388 keyboard focus, since this is the only way Emacs can receive key
2389 combinations like Alt-Tab which are used by the system. */
2392 register_hot_keys (hwnd
)
2395 Lisp_Object keylist
;
2397 /* Use CONSP, since we are called asynchronously. */
2398 for (keylist
= w32_grabbed_keys
; CONSP (keylist
); keylist
= XCDR (keylist
))
2400 Lisp_Object key
= XCAR (keylist
);
2402 /* Deleted entries get set to nil. */
2403 if (!INTEGERP (key
))
2406 RegisterHotKey (hwnd
, HOTKEY_ID (key
),
2407 HOTKEY_MODIFIERS (key
), HOTKEY_VK_CODE (key
));
2412 unregister_hot_keys (hwnd
)
2415 Lisp_Object keylist
;
2417 for (keylist
= w32_grabbed_keys
; CONSP (keylist
); keylist
= XCDR (keylist
))
2419 Lisp_Object key
= XCAR (keylist
);
2421 if (!INTEGERP (key
))
2424 UnregisterHotKey (hwnd
, HOTKEY_ID (key
));
2428 /* Main message dispatch loop. */
2431 w32_msg_pump (deferred_msg
* msg_buf
)
2437 msh_mousewheel
= RegisterWindowMessage (MSH_MOUSEWHEEL
);
2439 while (GetMessage (&msg
, NULL
, 0, 0))
2441 if (msg
.hwnd
== NULL
)
2443 switch (msg
.message
)
2446 /* Produced by complete_deferred_msg; just ignore. */
2448 case WM_EMACS_CREATEWINDOW
:
2449 /* Initialize COM for this window. Even though we don't use it,
2450 some third party shell extensions can cause it to be used in
2451 system dialogs, which causes a crash if it is not initialized.
2452 This is a known bug in Windows, which was fixed long ago, but
2453 the patch for XP is not publically available until XP SP3,
2454 and older versions will never be patched. */
2455 CoInitialize (NULL
);
2456 w32_createwindow ((struct frame
*) msg
.wParam
);
2457 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2460 case WM_EMACS_SETLOCALE
:
2461 SetThreadLocale (msg
.wParam
);
2462 /* Reply is not expected. */
2464 case WM_EMACS_SETKEYBOARDLAYOUT
:
2465 result
= (int) ActivateKeyboardLayout ((HKL
) msg
.wParam
, 0);
2466 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
,
2470 case WM_EMACS_REGISTER_HOT_KEY
:
2471 focus_window
= GetFocus ();
2472 if (focus_window
!= NULL
)
2473 RegisterHotKey (focus_window
,
2474 RAW_HOTKEY_ID (msg
.wParam
),
2475 RAW_HOTKEY_MODIFIERS (msg
.wParam
),
2476 RAW_HOTKEY_VK_CODE (msg
.wParam
));
2477 /* Reply is not expected. */
2479 case WM_EMACS_UNREGISTER_HOT_KEY
:
2480 focus_window
= GetFocus ();
2481 if (focus_window
!= NULL
)
2482 UnregisterHotKey (focus_window
, RAW_HOTKEY_ID (msg
.wParam
));
2483 /* Mark item as erased. NB: this code must be
2484 thread-safe. The next line is okay because the cons
2485 cell is never made into garbage and is not relocated by
2487 XSETCAR ((Lisp_Object
) ((EMACS_INT
) msg
.lParam
), Qnil
);
2488 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2491 case WM_EMACS_TOGGLE_LOCK_KEY
:
2493 int vk_code
= (int) msg
.wParam
;
2494 int cur_state
= (GetKeyState (vk_code
) & 1);
2495 Lisp_Object new_state
= (Lisp_Object
) ((EMACS_INT
) msg
.lParam
);
2497 /* NB: This code must be thread-safe. It is safe to
2498 call NILP because symbols are not relocated by GC,
2499 and pointer here is not touched by GC (so the markbit
2500 can't be set). Numbers are safe because they are
2501 immediate values. */
2502 if (NILP (new_state
)
2503 || (NUMBERP (new_state
)
2504 && ((XUINT (new_state
)) & 1) != cur_state
))
2506 one_w32_display_info
.faked_key
= vk_code
;
2508 keybd_event ((BYTE
) vk_code
,
2509 (BYTE
) MapVirtualKey (vk_code
, 0),
2510 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2511 keybd_event ((BYTE
) vk_code
,
2512 (BYTE
) MapVirtualKey (vk_code
, 0),
2513 KEYEVENTF_EXTENDEDKEY
| 0, 0);
2514 keybd_event ((BYTE
) vk_code
,
2515 (BYTE
) MapVirtualKey (vk_code
, 0),
2516 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2517 cur_state
= !cur_state
;
2519 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
,
2525 /* Broadcast messages make it here, so you need to be looking
2526 for something in particular for this to be useful. */
2528 DebPrint (("msg %x not expected by w32_msg_pump\n", msg
.message
));
2534 DispatchMessage (&msg
);
2537 /* Exit nested loop when our deferred message has completed. */
2538 if (msg_buf
->completed
)
2543 deferred_msg
* deferred_msg_head
;
2545 static deferred_msg
*
2546 find_deferred_msg (HWND hwnd
, UINT msg
)
2548 deferred_msg
* item
;
2550 /* Don't actually need synchronization for read access, since
2551 modification of single pointer is always atomic. */
2552 /* enter_crit (); */
2554 for (item
= deferred_msg_head
; item
!= NULL
; item
= item
->next
)
2555 if (item
->w32msg
.msg
.hwnd
== hwnd
2556 && item
->w32msg
.msg
.message
== msg
)
2559 /* leave_crit (); */
2565 send_deferred_msg (deferred_msg
* msg_buf
,
2571 /* Only input thread can send deferred messages. */
2572 if (GetCurrentThreadId () != dwWindowsThreadId
)
2575 /* It is an error to send a message that is already deferred. */
2576 if (find_deferred_msg (hwnd
, msg
) != NULL
)
2579 /* Enforced synchronization is not needed because this is the only
2580 function that alters deferred_msg_head, and the following critical
2581 section is guaranteed to only be serially reentered (since only the
2582 input thread can call us). */
2584 /* enter_crit (); */
2586 msg_buf
->completed
= 0;
2587 msg_buf
->next
= deferred_msg_head
;
2588 deferred_msg_head
= msg_buf
;
2589 my_post_msg (&msg_buf
->w32msg
, hwnd
, msg
, wParam
, lParam
);
2591 /* leave_crit (); */
2593 /* Start a new nested message loop to process other messages until
2594 this one is completed. */
2595 w32_msg_pump (msg_buf
);
2597 deferred_msg_head
= msg_buf
->next
;
2599 return msg_buf
->result
;
2603 complete_deferred_msg (HWND hwnd
, UINT msg
, LRESULT result
)
2605 deferred_msg
* msg_buf
= find_deferred_msg (hwnd
, msg
);
2607 if (msg_buf
== NULL
)
2608 /* Message may have been cancelled, so don't abort. */
2611 msg_buf
->result
= result
;
2612 msg_buf
->completed
= 1;
2614 /* Ensure input thread is woken so it notices the completion. */
2615 PostThreadMessage (dwWindowsThreadId
, WM_NULL
, 0, 0);
2619 cancel_all_deferred_msgs ()
2621 deferred_msg
* item
;
2623 /* Don't actually need synchronization for read access, since
2624 modification of single pointer is always atomic. */
2625 /* enter_crit (); */
2627 for (item
= deferred_msg_head
; item
!= NULL
; item
= item
->next
)
2630 item
->completed
= 1;
2633 /* leave_crit (); */
2635 /* Ensure input thread is woken so it notices the completion. */
2636 PostThreadMessage (dwWindowsThreadId
, WM_NULL
, 0, 0);
2640 w32_msg_worker (void *arg
)
2643 deferred_msg dummy_buf
;
2645 /* Ensure our message queue is created */
2647 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
2649 if (!PostThreadMessage (dwMainThreadId
, WM_EMACS_DONE
, 0, 0))
2652 memset (&dummy_buf
, 0, sizeof (dummy_buf
));
2653 dummy_buf
.w32msg
.msg
.hwnd
= NULL
;
2654 dummy_buf
.w32msg
.msg
.message
= WM_NULL
;
2656 /* This is the initial message loop which should only exit when the
2657 application quits. */
2658 w32_msg_pump (&dummy_buf
);
2664 signal_user_input ()
2666 /* Interrupt any lisp that wants to be interrupted by input. */
2667 if (!NILP (Vthrow_on_input
))
2669 Vquit_flag
= Vthrow_on_input
;
2670 /* If we're inside a function that wants immediate quits,
2672 if (immediate_quit
&& NILP (Vinhibit_quit
))
2682 post_character_message (hwnd
, msg
, wParam
, lParam
, modifiers
)
2692 wmsg
.dwModifiers
= modifiers
;
2694 /* Detect quit_char and set quit-flag directly. Note that we
2695 still need to post a message to ensure the main thread will be
2696 woken up if blocked in sys_select, but we do NOT want to post
2697 the quit_char message itself (because it will usually be as if
2698 the user had typed quit_char twice). Instead, we post a dummy
2699 message that has no particular effect. */
2702 if (isalpha (c
) && wmsg
.dwModifiers
== ctrl_modifier
)
2703 c
= make_ctrl_char (c
) & 0377;
2705 || (wmsg
.dwModifiers
== 0 &&
2706 w32_quit_key
&& wParam
== w32_quit_key
))
2710 /* The choice of message is somewhat arbitrary, as long as
2711 the main thread handler just ignores it. */
2714 /* Interrupt any blocking system calls. */
2717 /* As a safety precaution, forcibly complete any deferred
2718 messages. This is a kludge, but I don't see any particularly
2719 clean way to handle the situation where a deferred message is
2720 "dropped" in the lisp thread, and will thus never be
2721 completed, eg. by the user trying to activate the menubar
2722 when the lisp thread is busy, and then typing C-g when the
2723 menubar doesn't open promptly (with the result that the
2724 menubar never responds at all because the deferred
2725 WM_INITMENU message is never completed). Another problem
2726 situation is when the lisp thread calls SendMessage (to send
2727 a window manager command) when a message has been deferred;
2728 the lisp thread gets blocked indefinitely waiting for the
2729 deferred message to be completed, which itself is waiting for
2730 the lisp thread to respond.
2732 Note that we don't want to block the input thread waiting for
2733 a reponse from the lisp thread (although that would at least
2734 solve the deadlock problem above), because we want to be able
2735 to receive C-g to interrupt the lisp thread. */
2736 cancel_all_deferred_msgs ();
2739 signal_user_input ();
2742 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2745 /* Main window procedure */
2748 w32_wnd_proc (hwnd
, msg
, wParam
, lParam
)
2755 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
2757 int windows_translate
;
2760 /* Note that it is okay to call x_window_to_frame, even though we are
2761 not running in the main lisp thread, because frame deletion
2762 requires the lisp thread to synchronize with this thread. Thus, if
2763 a frame struct is returned, it can be used without concern that the
2764 lisp thread might make it disappear while we are using it.
2766 NB. Walking the frame list in this thread is safe (as long as
2767 writes of Lisp_Object slots are atomic, which they are on Windows).
2768 Although delete-frame can destructively modify the frame list while
2769 we are walking it, a garbage collection cannot occur until after
2770 delete-frame has synchronized with this thread.
2772 It is also safe to use functions that make GDI calls, such as
2773 w32_clear_rect, because these functions must obtain a DC handle
2774 from the frame struct using get_frame_dc which is thread-aware. */
2779 f
= x_window_to_frame (dpyinfo
, hwnd
);
2782 HDC hdc
= get_frame_dc (f
);
2783 GetUpdateRect (hwnd
, &wmsg
.rect
, FALSE
);
2784 w32_clear_rect (f
, hdc
, &wmsg
.rect
);
2785 release_frame_dc (f
, hdc
);
2787 #if defined (W32_DEBUG_DISPLAY)
2788 DebPrint (("WM_ERASEBKGND (frame %p): erasing %d,%d-%d,%d\n",
2790 wmsg
.rect
.left
, wmsg
.rect
.top
,
2791 wmsg
.rect
.right
, wmsg
.rect
.bottom
));
2792 #endif /* W32_DEBUG_DISPLAY */
2795 case WM_PALETTECHANGED
:
2796 /* ignore our own changes */
2797 if ((HWND
)wParam
!= hwnd
)
2799 f
= x_window_to_frame (dpyinfo
, hwnd
);
2801 /* get_frame_dc will realize our palette and force all
2802 frames to be redrawn if needed. */
2803 release_frame_dc (f
, get_frame_dc (f
));
2808 PAINTSTRUCT paintStruct
;
2810 bzero (&update_rect
, sizeof (update_rect
));
2812 f
= x_window_to_frame (dpyinfo
, hwnd
);
2815 DebPrint (("WM_PAINT received for unknown window %p\n", hwnd
));
2819 /* MSDN Docs say not to call BeginPaint if GetUpdateRect
2820 fails. Apparently this can happen under some
2822 if (GetUpdateRect (hwnd
, &update_rect
, FALSE
) || !w32_strict_painting
)
2825 BeginPaint (hwnd
, &paintStruct
);
2827 /* The rectangles returned by GetUpdateRect and BeginPaint
2828 do not always match. Play it safe by assuming both areas
2830 UnionRect (&(wmsg
.rect
), &update_rect
, &(paintStruct
.rcPaint
));
2832 #if defined (W32_DEBUG_DISPLAY)
2833 DebPrint (("WM_PAINT (frame %p): painting %d,%d-%d,%d\n",
2835 wmsg
.rect
.left
, wmsg
.rect
.top
,
2836 wmsg
.rect
.right
, wmsg
.rect
.bottom
));
2837 DebPrint ((" [update region is %d,%d-%d,%d]\n",
2838 update_rect
.left
, update_rect
.top
,
2839 update_rect
.right
, update_rect
.bottom
));
2841 EndPaint (hwnd
, &paintStruct
);
2844 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2849 /* If GetUpdateRect returns 0 (meaning there is no update
2850 region), assume the whole window needs to be repainted. */
2851 GetClientRect (hwnd
, &wmsg
.rect
);
2852 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2856 case WM_INPUTLANGCHANGE
:
2857 /* Inform lisp thread of keyboard layout changes. */
2858 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
2860 /* Clear dead keys in the keyboard state; for simplicity only
2861 preserve modifier key states. */
2866 GetKeyboardState (keystate
);
2867 for (i
= 0; i
< 256; i
++)
2884 SetKeyboardState (keystate
);
2889 /* Synchronize hot keys with normal input. */
2890 PostMessage (hwnd
, WM_KEYDOWN
, HIWORD (lParam
), 0);
2895 record_keyup (wParam
, lParam
);
2900 /* Ignore keystrokes we fake ourself; see below. */
2901 if (dpyinfo
->faked_key
== wParam
)
2903 dpyinfo
->faked_key
= 0;
2904 /* Make sure TranslateMessage sees them though (as long as
2905 they don't produce WM_CHAR messages). This ensures that
2906 indicator lights are toggled promptly on Windows 9x, for
2908 if (wParam
< 256 && lispy_function_keys
[wParam
])
2910 windows_translate
= 1;
2916 /* Synchronize modifiers with current keystroke. */
2918 record_keydown (wParam
, lParam
);
2919 wParam
= map_keypad_keys (wParam
, (lParam
& 0x1000000L
) != 0);
2921 windows_translate
= 0;
2926 if (NILP (Vw32_pass_lwindow_to_system
))
2928 /* Prevent system from acting on keyup (which opens the
2929 Start menu if no other key was pressed) by simulating a
2930 press of Space which we will ignore. */
2931 if (GetAsyncKeyState (wParam
) & 1)
2933 if (NUMBERP (Vw32_phantom_key_code
))
2934 key
= XUINT (Vw32_phantom_key_code
) & 255;
2937 dpyinfo
->faked_key
= key
;
2938 keybd_event (key
, (BYTE
) MapVirtualKey (key
, 0), 0, 0);
2941 if (!NILP (Vw32_lwindow_modifier
))
2945 if (NILP (Vw32_pass_rwindow_to_system
))
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_rwindow_modifier
))
2961 if (!NILP (Vw32_apps_modifier
))
2965 if (NILP (Vw32_pass_alt_to_system
))
2966 /* Prevent DefWindowProc from activating the menu bar if an
2967 Alt key is pressed and released by itself. */
2969 windows_translate
= 1;
2972 /* Decide whether to treat as modifier or function key. */
2973 if (NILP (Vw32_enable_caps_lock
))
2974 goto disable_lock_key
;
2975 windows_translate
= 1;
2978 /* Decide whether to treat as modifier or function key. */
2979 if (NILP (Vw32_enable_num_lock
))
2980 goto disable_lock_key
;
2981 windows_translate
= 1;
2984 /* Decide whether to treat as modifier or function key. */
2985 if (NILP (Vw32_scroll_lock_modifier
))
2986 goto disable_lock_key
;
2987 windows_translate
= 1;
2990 /* Ensure the appropriate lock key state (and indicator light)
2991 remains in the same state. We do this by faking another
2992 press of the relevant key. Apparently, this really is the
2993 only way to toggle the state of the indicator lights. */
2994 dpyinfo
->faked_key
= wParam
;
2995 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
2996 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
2997 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
2998 KEYEVENTF_EXTENDEDKEY
| 0, 0);
2999 keybd_event ((BYTE
) wParam
, (BYTE
) MapVirtualKey (wParam
, 0),
3000 KEYEVENTF_EXTENDEDKEY
| KEYEVENTF_KEYUP
, 0);
3001 /* Ensure indicator lights are updated promptly on Windows 9x
3002 (TranslateMessage apparently does this), after forwarding
3004 post_character_message (hwnd
, msg
, wParam
, lParam
,
3005 w32_get_key_modifiers (wParam
, lParam
));
3006 windows_translate
= 1;
3010 case VK_PROCESSKEY
: /* Generated by IME. */
3011 windows_translate
= 1;
3014 /* Windows maps Ctrl-Pause (aka Ctrl-Break) into VK_CANCEL,
3015 which is confusing for purposes of key binding; convert
3016 VK_CANCEL events into VK_PAUSE events. */
3020 /* Windows maps Ctrl-NumLock into VK_PAUSE, which is confusing
3021 for purposes of key binding; convert these back into
3022 VK_NUMLOCK events, at least when we want to see NumLock key
3023 presses. (Note that there is never any possibility that
3024 VK_PAUSE with Ctrl really is C-Pause as per above.) */
3025 if (NILP (Vw32_enable_num_lock
) && modifier_set (VK_CONTROL
))
3026 wParam
= VK_NUMLOCK
;
3029 /* If not defined as a function key, change it to a WM_CHAR message. */
3030 if (wParam
> 255 || !lispy_function_keys
[wParam
])
3032 DWORD modifiers
= construct_console_modifiers ();
3034 if (!NILP (Vw32_recognize_altgr
)
3035 && modifier_set (VK_LCONTROL
) && modifier_set (VK_RMENU
))
3037 /* Always let TranslateMessage handle AltGr key chords;
3038 for some reason, ToAscii doesn't always process AltGr
3039 chords correctly. */
3040 windows_translate
= 1;
3042 else if ((modifiers
& (~SHIFT_PRESSED
& ~CAPSLOCK_ON
)) != 0)
3044 /* Handle key chords including any modifiers other
3045 than shift directly, in order to preserve as much
3046 modifier information as possible. */
3047 if ('A' <= wParam
&& wParam
<= 'Z')
3049 /* Don't translate modified alphabetic keystrokes,
3050 so the user doesn't need to constantly switch
3051 layout to type control or meta keystrokes when
3052 the normal layout translates alphabetic
3053 characters to non-ascii characters. */
3054 if (!modifier_set (VK_SHIFT
))
3055 wParam
+= ('a' - 'A');
3060 /* Try to handle other keystrokes by determining the
3061 base character (ie. translating the base key plus
3065 KEY_EVENT_RECORD key
;
3067 key
.bKeyDown
= TRUE
;
3068 key
.wRepeatCount
= 1;
3069 key
.wVirtualKeyCode
= wParam
;
3070 key
.wVirtualScanCode
= (lParam
& 0xFF0000) >> 16;
3071 key
.uChar
.AsciiChar
= 0;
3072 key
.dwControlKeyState
= modifiers
;
3074 add
= w32_kbd_patch_key (&key
);
3075 /* 0 means an unrecognised keycode, negative means
3076 dead key. Ignore both. */
3079 /* Forward asciified character sequence. */
3080 post_character_message
3082 (unsigned char) key
.uChar
.AsciiChar
, lParam
,
3083 w32_get_key_modifiers (wParam
, lParam
));
3084 w32_kbd_patch_key (&key
);
3091 /* Let TranslateMessage handle everything else. */
3092 windows_translate
= 1;
3098 if (windows_translate
)
3100 MSG windows_msg
= { hwnd
, msg
, wParam
, lParam
, 0, {0,0} };
3101 windows_msg
.time
= GetMessageTime ();
3102 TranslateMessage (&windows_msg
);
3110 post_character_message (hwnd
, msg
, wParam
, lParam
,
3111 w32_get_key_modifiers (wParam
, lParam
));
3115 /* WM_UNICHAR looks promising from the docs, but the exact
3116 circumstances in which TranslateMessage sends it is one of those
3117 Microsoft secret API things that EU and US courts are supposed
3118 to have put a stop to already. Spy++ shows it being sent to Notepad
3119 and other MS apps, but never to Emacs.
3121 Some third party IMEs send it in accordance with the official
3122 documentation though, so handle it here.
3124 UNICODE_NOCHAR is used to test for support for this message.
3125 TRUE indicates that the message is supported. */
3126 if (wParam
== UNICODE_NOCHAR
)
3131 wmsg
.dwModifiers
= w32_get_key_modifiers (wParam
, lParam
);
3132 signal_user_input ();
3133 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3138 /* If we can't get the IME result as unicode, use default processing,
3139 which will at least allow characters decodable in the system locale
3141 if (!get_composition_string_fn
)
3144 else if (!ignore_ime_char
)
3149 HIMC context
= get_ime_context_fn (hwnd
);
3150 wmsg
.dwModifiers
= w32_get_key_modifiers (wParam
, lParam
);
3151 /* Get buffer size. */
3152 size
= get_composition_string_fn (context
, GCS_RESULTSTR
, buffer
, 0);
3153 buffer
= alloca(size
);
3154 size
= get_composition_string_fn (context
, GCS_RESULTSTR
,
3156 signal_user_input ();
3157 for (i
= 0; i
< size
/ sizeof (wchar_t); i
++)
3159 my_post_msg (&wmsg
, hwnd
, WM_UNICHAR
, (WPARAM
) buffer
[i
],
3162 /* We output the whole string above, so ignore following ones
3163 until we are notified of the end of composition. */
3164 ignore_ime_char
= 1;
3168 case WM_IME_ENDCOMPOSITION
:
3169 ignore_ime_char
= 0;
3172 /* Simulate middle mouse button events when left and right buttons
3173 are used together, but only if user has two button mouse. */
3174 case WM_LBUTTONDOWN
:
3175 case WM_RBUTTONDOWN
:
3176 if (w32_num_mouse_buttons
> 2)
3177 goto handle_plain_button
;
3180 int this = (msg
== WM_LBUTTONDOWN
) ? LMOUSE
: RMOUSE
;
3181 int other
= (msg
== WM_LBUTTONDOWN
) ? RMOUSE
: LMOUSE
;
3183 if (button_state
& this)
3186 if (button_state
== 0)
3189 button_state
|= this;
3191 if (button_state
& other
)
3193 if (mouse_button_timer
)
3195 KillTimer (hwnd
, mouse_button_timer
);
3196 mouse_button_timer
= 0;
3198 /* Generate middle mouse event instead. */
3199 msg
= WM_MBUTTONDOWN
;
3200 button_state
|= MMOUSE
;
3202 else if (button_state
& MMOUSE
)
3204 /* Ignore button event if we've already generated a
3205 middle mouse down event. This happens if the
3206 user releases and press one of the two buttons
3207 after we've faked a middle mouse event. */
3212 /* Flush out saved message. */
3213 post_msg (&saved_mouse_button_msg
);
3215 wmsg
.dwModifiers
= w32_get_modifiers ();
3216 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3217 signal_user_input ();
3219 /* Clear message buffer. */
3220 saved_mouse_button_msg
.msg
.hwnd
= 0;
3224 /* Hold onto message for now. */
3225 mouse_button_timer
=
3226 SetTimer (hwnd
, MOUSE_BUTTON_ID
,
3227 w32_mouse_button_tolerance
, NULL
);
3228 saved_mouse_button_msg
.msg
.hwnd
= hwnd
;
3229 saved_mouse_button_msg
.msg
.message
= msg
;
3230 saved_mouse_button_msg
.msg
.wParam
= wParam
;
3231 saved_mouse_button_msg
.msg
.lParam
= lParam
;
3232 saved_mouse_button_msg
.msg
.time
= GetMessageTime ();
3233 saved_mouse_button_msg
.dwModifiers
= w32_get_modifiers ();
3240 if (w32_num_mouse_buttons
> 2)
3241 goto handle_plain_button
;
3244 int this = (msg
== WM_LBUTTONUP
) ? LMOUSE
: RMOUSE
;
3245 int other
= (msg
== WM_LBUTTONUP
) ? RMOUSE
: LMOUSE
;
3247 if ((button_state
& this) == 0)
3250 button_state
&= ~this;
3252 if (button_state
& MMOUSE
)
3254 /* Only generate event when second button is released. */
3255 if ((button_state
& other
) == 0)
3258 button_state
&= ~MMOUSE
;
3260 if (button_state
) abort ();
3267 /* Flush out saved message if necessary. */
3268 if (saved_mouse_button_msg
.msg
.hwnd
)
3270 post_msg (&saved_mouse_button_msg
);
3273 wmsg
.dwModifiers
= w32_get_modifiers ();
3274 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3275 signal_user_input ();
3277 /* Always clear message buffer and cancel timer. */
3278 saved_mouse_button_msg
.msg
.hwnd
= 0;
3279 KillTimer (hwnd
, mouse_button_timer
);
3280 mouse_button_timer
= 0;
3282 if (button_state
== 0)
3287 case WM_XBUTTONDOWN
:
3289 if (w32_pass_extra_mouse_buttons_to_system
)
3291 /* else fall through and process them. */
3292 case WM_MBUTTONDOWN
:
3294 handle_plain_button
:
3299 /* Ignore middle and extra buttons as long as the menu is active. */
3300 f
= x_window_to_frame (dpyinfo
, hwnd
);
3301 if (f
&& f
->output_data
.w32
->menubar_active
)
3304 if (parse_button (msg
, HIWORD (wParam
), &button
, &up
))
3306 if (up
) ReleaseCapture ();
3307 else SetCapture (hwnd
);
3308 button
= (button
== 0) ? LMOUSE
:
3309 ((button
== 1) ? MMOUSE
: RMOUSE
);
3311 button_state
&= ~button
;
3313 button_state
|= button
;
3317 wmsg
.dwModifiers
= w32_get_modifiers ();
3318 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3319 signal_user_input ();
3321 /* Need to return true for XBUTTON messages, false for others,
3322 to indicate that we processed the message. */
3323 return (msg
== WM_XBUTTONDOWN
|| msg
== WM_XBUTTONUP
);
3326 /* Ignore mouse movements as long as the menu is active. These
3327 movements are processed by the window manager anyway, and
3328 it's wrong to handle them as if they happened on the
3329 underlying frame. */
3330 f
= x_window_to_frame (dpyinfo
, hwnd
);
3331 if (f
&& f
->output_data
.w32
->menubar_active
)
3334 /* If the mouse has just moved into the frame, start tracking
3335 it, so we will be notified when it leaves the frame. Mouse
3336 tracking only works under W98 and NT4 and later. On earlier
3337 versions, there is no way of telling when the mouse leaves the
3338 frame, so we just have to put up with help-echo and mouse
3339 highlighting remaining while the frame is not active. */
3340 if (track_mouse_event_fn
&& !track_mouse_window
)
3342 TRACKMOUSEEVENT tme
;
3343 tme
.cbSize
= sizeof (tme
);
3344 tme
.dwFlags
= TME_LEAVE
;
3345 tme
.hwndTrack
= hwnd
;
3347 track_mouse_event_fn (&tme
);
3348 track_mouse_window
= hwnd
;
3351 if (w32_mouse_move_interval
<= 0
3352 || (msg
== WM_MOUSEMOVE
&& button_state
== 0))
3354 wmsg
.dwModifiers
= w32_get_modifiers ();
3355 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3359 /* Hang onto mouse move and scroll messages for a bit, to avoid
3360 sending such events to Emacs faster than it can process them.
3361 If we get more events before the timer from the first message
3362 expires, we just replace the first message. */
3364 if (saved_mouse_move_msg
.msg
.hwnd
== 0)
3366 SetTimer (hwnd
, MOUSE_MOVE_ID
,
3367 w32_mouse_move_interval
, NULL
);
3369 /* Hold onto message for now. */
3370 saved_mouse_move_msg
.msg
.hwnd
= hwnd
;
3371 saved_mouse_move_msg
.msg
.message
= msg
;
3372 saved_mouse_move_msg
.msg
.wParam
= wParam
;
3373 saved_mouse_move_msg
.msg
.lParam
= lParam
;
3374 saved_mouse_move_msg
.msg
.time
= GetMessageTime ();
3375 saved_mouse_move_msg
.dwModifiers
= w32_get_modifiers ();
3381 wmsg
.dwModifiers
= w32_get_modifiers ();
3382 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3383 signal_user_input ();
3387 if (w32_pass_multimedia_buttons_to_system
)
3389 /* Otherwise, pass to lisp, the same way we do with mousehwheel. */
3390 case WM_MOUSEHWHEEL
:
3391 wmsg
.dwModifiers
= w32_get_modifiers ();
3392 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3393 signal_user_input ();
3394 /* Non-zero must be returned when WM_MOUSEHWHEEL messages are
3395 handled, to prevent the system trying to handle it by faking
3396 scroll bar events. */
3400 /* Flush out saved messages if necessary. */
3401 if (wParam
== mouse_button_timer
)
3403 if (saved_mouse_button_msg
.msg
.hwnd
)
3405 post_msg (&saved_mouse_button_msg
);
3406 signal_user_input ();
3407 saved_mouse_button_msg
.msg
.hwnd
= 0;
3409 KillTimer (hwnd
, mouse_button_timer
);
3410 mouse_button_timer
= 0;
3412 else if (wParam
== mouse_move_timer
)
3414 if (saved_mouse_move_msg
.msg
.hwnd
)
3416 post_msg (&saved_mouse_move_msg
);
3417 saved_mouse_move_msg
.msg
.hwnd
= 0;
3419 KillTimer (hwnd
, mouse_move_timer
);
3420 mouse_move_timer
= 0;
3422 else if (wParam
== menu_free_timer
)
3424 KillTimer (hwnd
, menu_free_timer
);
3425 menu_free_timer
= 0;
3426 f
= x_window_to_frame (dpyinfo
, hwnd
);
3427 /* If a popup menu is active, don't wipe its strings. */
3429 && current_popup_menu
== NULL
)
3431 /* Free memory used by owner-drawn and help-echo strings. */
3432 w32_free_menu_strings (hwnd
);
3433 f
->output_data
.w32
->menubar_active
= 0;
3437 else if (wParam
== hourglass_timer
)
3439 KillTimer (hwnd
, hourglass_timer
);
3440 hourglass_timer
= 0;
3441 w32_show_hourglass (x_window_to_frame (dpyinfo
, hwnd
));
3446 /* Windows doesn't send us focus messages when putting up and
3447 taking down a system popup dialog as for Ctrl-Alt-Del on Windows 95.
3448 The only indication we get that something happened is receiving
3449 this message afterwards. So this is a good time to reset our
3450 keyboard modifiers' state. */
3457 /* We must ensure menu bar is fully constructed and up to date
3458 before allowing user interaction with it. To achieve this
3459 we send this message to the lisp thread and wait for a
3460 reply (whose value is not actually needed) to indicate that
3461 the menu bar is now ready for use, so we can now return.
3463 To remain responsive in the meantime, we enter a nested message
3464 loop that can process all other messages.
3466 However, we skip all this if the message results from calling
3467 TrackPopupMenu - in fact, we must NOT attempt to send the lisp
3468 thread a message because it is blocked on us at this point. We
3469 set menubar_active before calling TrackPopupMenu to indicate
3470 this (there is no possibility of confusion with real menubar
3473 f
= x_window_to_frame (dpyinfo
, hwnd
);
3475 && (f
->output_data
.w32
->menubar_active
3476 /* We can receive this message even in the absence of a
3477 menubar (ie. when the system menu is activated) - in this
3478 case we do NOT want to forward the message, otherwise it
3479 will cause the menubar to suddenly appear when the user
3480 had requested it to be turned off! */
3481 || f
->output_data
.w32
->menubar_widget
== NULL
))
3485 deferred_msg msg_buf
;
3487 /* Detect if message has already been deferred; in this case
3488 we cannot return any sensible value to ignore this. */
3489 if (find_deferred_msg (hwnd
, msg
) != NULL
)
3494 return send_deferred_msg (&msg_buf
, hwnd
, msg
, wParam
, lParam
);
3497 case WM_EXITMENULOOP
:
3498 f
= x_window_to_frame (dpyinfo
, hwnd
);
3500 /* If a menu is still active, check again after a short delay,
3501 since Windows often (always?) sends the WM_EXITMENULOOP
3502 before the corresponding WM_COMMAND message.
3503 Don't do this if a popup menu is active, since it is only
3504 menubar menus that require cleaning up in this way.
3506 if (f
&& menubar_in_use
&& current_popup_menu
== NULL
)
3507 menu_free_timer
= SetTimer (hwnd
, MENU_FREE_ID
, MENU_FREE_DELAY
, NULL
);
3509 /* If hourglass cursor should be displayed, display it now. */
3510 if (f
&& f
->output_data
.w32
->hourglass_p
)
3511 SetCursor (f
->output_data
.w32
->hourglass_cursor
);
3516 /* Direct handling of help_echo in menus. Should be safe now
3517 that we generate the help_echo by placing a help event in the
3520 HMENU menu
= (HMENU
) lParam
;
3521 UINT menu_item
= (UINT
) LOWORD (wParam
);
3522 UINT flags
= (UINT
) HIWORD (wParam
);
3524 w32_menu_display_help (hwnd
, menu
, menu_item
, flags
);
3528 case WM_MEASUREITEM
:
3529 f
= x_window_to_frame (dpyinfo
, hwnd
);
3532 MEASUREITEMSTRUCT
* pMis
= (MEASUREITEMSTRUCT
*) lParam
;
3534 if (pMis
->CtlType
== ODT_MENU
)
3536 /* Work out dimensions for popup menu titles. */
3537 char * title
= (char *) pMis
->itemData
;
3538 HDC hdc
= GetDC (hwnd
);
3539 HFONT menu_font
= GetCurrentObject (hdc
, OBJ_FONT
);
3540 LOGFONT menu_logfont
;
3544 GetObject (menu_font
, sizeof (menu_logfont
), &menu_logfont
);
3545 menu_logfont
.lfWeight
= FW_BOLD
;
3546 menu_font
= CreateFontIndirect (&menu_logfont
);
3547 old_font
= SelectObject (hdc
, menu_font
);
3549 pMis
->itemHeight
= GetSystemMetrics (SM_CYMENUSIZE
);
3552 if (unicode_append_menu
)
3553 GetTextExtentPoint32W (hdc
, (WCHAR
*) title
,
3554 wcslen ((WCHAR
*) title
),
3557 GetTextExtentPoint32 (hdc
, title
, strlen (title
), &size
);
3559 pMis
->itemWidth
= size
.cx
;
3560 if (pMis
->itemHeight
< size
.cy
)
3561 pMis
->itemHeight
= size
.cy
;
3564 pMis
->itemWidth
= 0;
3566 SelectObject (hdc
, old_font
);
3567 DeleteObject (menu_font
);
3568 ReleaseDC (hwnd
, hdc
);
3575 f
= x_window_to_frame (dpyinfo
, hwnd
);
3578 DRAWITEMSTRUCT
* pDis
= (DRAWITEMSTRUCT
*) lParam
;
3580 if (pDis
->CtlType
== ODT_MENU
)
3582 /* Draw popup menu title. */
3583 char * title
= (char *) pDis
->itemData
;
3586 HDC hdc
= pDis
->hDC
;
3587 HFONT menu_font
= GetCurrentObject (hdc
, OBJ_FONT
);
3588 LOGFONT menu_logfont
;
3591 GetObject (menu_font
, sizeof (menu_logfont
), &menu_logfont
);
3592 menu_logfont
.lfWeight
= FW_BOLD
;
3593 menu_font
= CreateFontIndirect (&menu_logfont
);
3594 old_font
= SelectObject (hdc
, menu_font
);
3596 /* Always draw title as if not selected. */
3597 if (unicode_append_menu
)
3600 + GetSystemMetrics (SM_CXMENUCHECK
),
3602 ETO_OPAQUE
, &pDis
->rcItem
,
3604 wcslen ((WCHAR
*) title
), NULL
);
3608 + GetSystemMetrics (SM_CXMENUCHECK
),
3610 ETO_OPAQUE
, &pDis
->rcItem
,
3611 title
, strlen (title
), NULL
);
3613 SelectObject (hdc
, old_font
);
3614 DeleteObject (menu_font
);
3622 /* Still not right - can't distinguish between clicks in the
3623 client area of the frame from clicks forwarded from the scroll
3624 bars - may have to hook WM_NCHITTEST to remember the mouse
3625 position and then check if it is in the client area ourselves. */
3626 case WM_MOUSEACTIVATE
:
3627 /* Discard the mouse click that activates a frame, allowing the
3628 user to click anywhere without changing point (or worse!).
3629 Don't eat mouse clicks on scrollbars though!! */
3630 if (LOWORD (lParam
) == HTCLIENT
)
3631 return MA_ACTIVATEANDEAT
;
3636 /* No longer tracking mouse. */
3637 track_mouse_window
= NULL
;
3639 case WM_ACTIVATEAPP
:
3641 case WM_WINDOWPOSCHANGED
:
3643 /* Inform lisp thread that a frame might have just been obscured
3644 or exposed, so should recheck visibility of all frames. */
3645 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3649 dpyinfo
->faked_key
= 0;
3651 register_hot_keys (hwnd
);
3654 unregister_hot_keys (hwnd
);
3657 /* Relinquish the system caret. */
3658 if (w32_system_caret_hwnd
)
3660 w32_visible_system_caret_hwnd
= NULL
;
3661 w32_system_caret_hwnd
= NULL
;
3667 f
= x_window_to_frame (dpyinfo
, hwnd
);
3668 if (f
&& HIWORD (wParam
) == 0)
3670 if (menu_free_timer
)
3672 KillTimer (hwnd
, menu_free_timer
);
3673 menu_free_timer
= 0;
3679 wmsg
.dwModifiers
= w32_get_modifiers ();
3680 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3688 wmsg
.dwModifiers
= w32_get_modifiers ();
3689 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3692 case WM_WINDOWPOSCHANGING
:
3693 /* Don't restrict the sizing of tip frames. */
3694 if (hwnd
== tip_window
)
3698 LPWINDOWPOS lppos
= (WINDOWPOS
*) lParam
;
3700 wp
.length
= sizeof (WINDOWPLACEMENT
);
3701 GetWindowPlacement (hwnd
, &wp
);
3703 if (wp
.showCmd
!= SW_SHOWMINIMIZED
&& (lppos
->flags
& SWP_NOSIZE
) == 0)
3710 DWORD internal_border
;
3711 DWORD scrollbar_extra
;
3714 wp
.length
= sizeof (wp
);
3715 GetWindowRect (hwnd
, &wr
);
3719 font_width
= GetWindowLong (hwnd
, WND_FONTWIDTH_INDEX
);
3720 line_height
= GetWindowLong (hwnd
, WND_LINEHEIGHT_INDEX
);
3721 internal_border
= GetWindowLong (hwnd
, WND_BORDER_INDEX
);
3722 scrollbar_extra
= GetWindowLong (hwnd
, WND_SCROLLBAR_INDEX
);
3726 memset (&rect
, 0, sizeof (rect
));
3727 AdjustWindowRect (&rect
, GetWindowLong (hwnd
, GWL_STYLE
),
3728 GetMenu (hwnd
) != NULL
);
3730 /* Force width and height of client area to be exact
3731 multiples of the character cell dimensions. */
3732 wdiff
= (lppos
->cx
- (rect
.right
- rect
.left
)
3733 - 2 * internal_border
- scrollbar_extra
)
3735 hdiff
= (lppos
->cy
- (rect
.bottom
- rect
.top
)
3736 - 2 * internal_border
)
3741 /* For right/bottom sizing we can just fix the sizes.
3742 However for top/left sizing we will need to fix the X
3743 and Y positions as well. */
3745 int cx_mintrack
= GetSystemMetrics (SM_CXMINTRACK
);
3746 int cy_mintrack
= GetSystemMetrics (SM_CYMINTRACK
);
3748 lppos
->cx
= max (lppos
->cx
- wdiff
, cx_mintrack
);
3749 lppos
->cy
= max (lppos
->cy
- hdiff
, cy_mintrack
);
3751 if (wp
.showCmd
!= SW_SHOWMAXIMIZED
3752 && (lppos
->flags
& SWP_NOMOVE
) == 0)
3754 if (lppos
->x
!= wr
.left
|| lppos
->y
!= wr
.top
)
3761 lppos
->flags
|= SWP_NOMOVE
;
3772 case WM_GETMINMAXINFO
:
3773 /* Hack to allow resizing the Emacs frame above the screen size.
3774 Note that Windows 9x limits coordinates to 16-bits. */
3775 ((LPMINMAXINFO
) lParam
)->ptMaxTrackSize
.x
= 32767;
3776 ((LPMINMAXINFO
) lParam
)->ptMaxTrackSize
.y
= 32767;
3780 if (LOWORD (lParam
) == HTCLIENT
)
3782 f
= x_window_to_frame (dpyinfo
, hwnd
);
3783 if (f
->output_data
.w32
->hourglass_p
&& !menubar_in_use
3784 && !current_popup_menu
)
3785 SetCursor (f
->output_data
.w32
->hourglass_cursor
);
3787 SetCursor (f
->output_data
.w32
->current_cursor
);
3792 case WM_EMACS_SETCURSOR
:
3794 Cursor cursor
= (Cursor
) wParam
;
3795 f
= x_window_to_frame (dpyinfo
, hwnd
);
3798 f
->output_data
.w32
->current_cursor
= cursor
;
3799 if (!f
->output_data
.w32
->hourglass_p
)
3805 case WM_EMACS_CREATESCROLLBAR
:
3806 return (LRESULT
) w32_createscrollbar ((struct frame
*) wParam
,
3807 (struct scroll_bar
*) lParam
);
3809 case WM_EMACS_SHOWWINDOW
:
3810 return ShowWindow ((HWND
) wParam
, (WPARAM
) lParam
);
3812 case WM_EMACS_SETFOREGROUND
:
3814 HWND foreground_window
;
3815 DWORD foreground_thread
, retval
;
3817 /* On NT 5.0, and apparently Windows 98, it is necessary to
3818 attach to the thread that currently has focus in order to
3819 pull the focus away from it. */
3820 foreground_window
= GetForegroundWindow ();
3821 foreground_thread
= GetWindowThreadProcessId (foreground_window
, NULL
);
3822 if (!foreground_window
3823 || foreground_thread
== GetCurrentThreadId ()
3824 || !AttachThreadInput (GetCurrentThreadId (),
3825 foreground_thread
, TRUE
))
3826 foreground_thread
= 0;
3828 retval
= SetForegroundWindow ((HWND
) wParam
);
3830 /* Detach from the previous foreground thread. */
3831 if (foreground_thread
)
3832 AttachThreadInput (GetCurrentThreadId (),
3833 foreground_thread
, FALSE
);
3838 case WM_EMACS_SETWINDOWPOS
:
3840 WINDOWPOS
* pos
= (WINDOWPOS
*) wParam
;
3841 return SetWindowPos (hwnd
, pos
->hwndInsertAfter
,
3842 pos
->x
, pos
->y
, pos
->cx
, pos
->cy
, pos
->flags
);
3845 case WM_EMACS_DESTROYWINDOW
:
3846 DragAcceptFiles ((HWND
) wParam
, FALSE
);
3847 return DestroyWindow ((HWND
) wParam
);
3849 case WM_EMACS_HIDE_CARET
:
3850 return HideCaret (hwnd
);
3852 case WM_EMACS_SHOW_CARET
:
3853 return ShowCaret (hwnd
);
3855 case WM_EMACS_DESTROY_CARET
:
3856 w32_system_caret_hwnd
= NULL
;
3857 w32_visible_system_caret_hwnd
= NULL
;
3858 return DestroyCaret ();
3860 case WM_EMACS_TRACK_CARET
:
3861 /* If there is currently no system caret, create one. */
3862 if (w32_system_caret_hwnd
== NULL
)
3864 /* Use the default caret width, and avoid changing it
3865 unneccesarily, as it confuses screen reader software. */
3866 w32_system_caret_hwnd
= hwnd
;
3867 CreateCaret (hwnd
, NULL
, 0,
3868 w32_system_caret_height
);
3871 if (!SetCaretPos (w32_system_caret_x
, w32_system_caret_y
))
3873 /* Ensure visible caret gets turned on when requested. */
3874 else if (w32_use_visible_system_caret
3875 && w32_visible_system_caret_hwnd
!= hwnd
)
3877 w32_visible_system_caret_hwnd
= hwnd
;
3878 return ShowCaret (hwnd
);
3880 /* Ensure visible caret gets turned off when requested. */
3881 else if (!w32_use_visible_system_caret
3882 && w32_visible_system_caret_hwnd
)
3884 w32_visible_system_caret_hwnd
= NULL
;
3885 return HideCaret (hwnd
);
3890 case WM_EMACS_TRACKPOPUPMENU
:
3895 pos
= (POINT
*)lParam
;
3896 flags
= TPM_CENTERALIGN
;
3897 if (button_state
& LMOUSE
)
3898 flags
|= TPM_LEFTBUTTON
;
3899 else if (button_state
& RMOUSE
)
3900 flags
|= TPM_RIGHTBUTTON
;
3902 /* Remember we did a SetCapture on the initial mouse down event,
3903 so for safety, we make sure the capture is cancelled now. */
3907 /* Use menubar_active to indicate that WM_INITMENU is from
3908 TrackPopupMenu below, and should be ignored. */
3909 f
= x_window_to_frame (dpyinfo
, hwnd
);
3911 f
->output_data
.w32
->menubar_active
= 1;
3913 if (TrackPopupMenu ((HMENU
)wParam
, flags
, pos
->x
, pos
->y
,
3917 /* Eat any mouse messages during popupmenu */
3918 while (PeekMessage (&amsg
, hwnd
, WM_MOUSEFIRST
, WM_MOUSELAST
,
3920 /* Get the menu selection, if any */
3921 if (PeekMessage (&amsg
, hwnd
, WM_COMMAND
, WM_COMMAND
, PM_REMOVE
))
3923 retval
= LOWORD (amsg
.wParam
);
3939 /* Check for messages registered at runtime. */
3940 if (msg
== msh_mousewheel
)
3942 wmsg
.dwModifiers
= w32_get_modifiers ();
3943 my_post_msg (&wmsg
, hwnd
, msg
, wParam
, lParam
);
3944 signal_user_input ();
3949 return DefWindowProc (hwnd
, msg
, wParam
, lParam
);
3953 /* The most common default return code for handled messages is 0. */
3958 my_create_window (f
)
3963 if (!PostThreadMessage (dwWindowsThreadId
, WM_EMACS_CREATEWINDOW
, (WPARAM
)f
, 0))
3965 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3969 /* Create a tooltip window. Unlike my_create_window, we do not do this
3970 indirectly via the Window thread, as we do not need to process Window
3971 messages for the tooltip. Creating tooltips indirectly also creates
3972 deadlocks when tooltips are created for menu items. */
3974 my_create_tip_window (f
)
3979 rect
.left
= rect
.top
= 0;
3980 rect
.right
= FRAME_PIXEL_WIDTH (f
);
3981 rect
.bottom
= FRAME_PIXEL_HEIGHT (f
);
3983 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
3984 FRAME_EXTERNAL_MENU_BAR (f
));
3986 tip_window
= FRAME_W32_WINDOW (f
)
3987 = CreateWindow (EMACS_CLASS
,
3989 f
->output_data
.w32
->dwStyle
,
3992 rect
.right
- rect
.left
,
3993 rect
.bottom
- rect
.top
,
3994 FRAME_W32_WINDOW (SELECTED_FRAME ()), /* owner */
4001 SetWindowLong (tip_window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
4002 SetWindowLong (tip_window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
4003 SetWindowLong (tip_window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
4004 SetWindowLong (tip_window
, WND_BACKGROUND_INDEX
, FRAME_BACKGROUND_PIXEL (f
));
4006 /* Tip frames have no scrollbars. */
4007 SetWindowLong (tip_window
, WND_SCROLLBAR_INDEX
, 0);
4009 /* Do this to discard the default setting specified by our parent. */
4010 ShowWindow (tip_window
, SW_HIDE
);
4015 /* Create and set up the w32 window for frame F. */
4018 w32_window (f
, window_prompting
, minibuffer_only
)
4020 long window_prompting
;
4021 int minibuffer_only
;
4025 /* Use the resource name as the top-level window name
4026 for looking up resources. Make a non-Lisp copy
4027 for the window manager, so GC relocation won't bother it.
4029 Elsewhere we specify the window name for the window manager. */
4032 char *str
= (char *) SDATA (Vx_resource_name
);
4033 f
->namebuf
= (char *) xmalloc (strlen (str
) + 1);
4034 strcpy (f
->namebuf
, str
);
4037 my_create_window (f
);
4039 validate_x_resource_name ();
4041 /* x_set_name normally ignores requests to set the name if the
4042 requested name is the same as the current name. This is the one
4043 place where that assumption isn't correct; f->name is set, but
4044 the server hasn't been told. */
4047 int explicit = f
->explicit_name
;
4049 f
->explicit_name
= 0;
4052 x_set_name (f
, name
, explicit);
4057 if (!minibuffer_only
&& FRAME_EXTERNAL_MENU_BAR (f
))
4058 initialize_frame_menubar (f
);
4060 if (FRAME_W32_WINDOW (f
) == 0)
4061 error ("Unable to create window");
4064 /* Handle the icon stuff for this window. Perhaps later we might
4065 want an x_set_icon_position which can be called interactively as
4073 Lisp_Object icon_x
, icon_y
;
4074 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4076 /* Set the position of the icon. Note that Windows 95 groups all
4077 icons in the tray. */
4078 icon_x
= x_get_arg (dpyinfo
, parms
, Qicon_left
, 0, 0, RES_TYPE_NUMBER
);
4079 icon_y
= x_get_arg (dpyinfo
, parms
, Qicon_top
, 0, 0, RES_TYPE_NUMBER
);
4080 if (!EQ (icon_x
, Qunbound
) && !EQ (icon_y
, Qunbound
))
4082 CHECK_NUMBER (icon_x
);
4083 CHECK_NUMBER (icon_y
);
4085 else if (!EQ (icon_x
, Qunbound
) || !EQ (icon_y
, Qunbound
))
4086 error ("Both left and top icon corners of icon must be specified");
4090 if (! EQ (icon_x
, Qunbound
))
4091 x_wm_set_icon_position (f
, XINT (icon_x
), XINT (icon_y
));
4094 /* Start up iconic or window? */
4095 x_wm_set_window_state
4096 (f
, (EQ (x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
), Qicon
)
4100 x_text_icon (f
, (char *) SDATA ((!NILP (f
->icon_name
)
4113 XGCValues gc_values
;
4117 /* Create the GC's of this frame.
4118 Note that many default values are used. */
4121 gc_values
.font
= FRAME_FONT (f
);
4123 /* Cursor has cursor-color background, background-color foreground. */
4124 gc_values
.foreground
= FRAME_BACKGROUND_PIXEL (f
);
4125 gc_values
.background
= f
->output_data
.w32
->cursor_pixel
;
4126 f
->output_data
.w32
->cursor_gc
4127 = XCreateGC (NULL
, FRAME_W32_WINDOW (f
),
4128 (GCFont
| GCForeground
| GCBackground
),
4132 f
->output_data
.w32
->white_relief
.gc
= 0;
4133 f
->output_data
.w32
->black_relief
.gc
= 0;
4139 /* Handler for signals raised during x_create_frame and
4140 x_create_top_frame. FRAME is the frame which is partially
4144 unwind_create_frame (frame
)
4147 struct frame
*f
= XFRAME (frame
);
4149 /* If frame is ``official'', nothing to do. */
4150 if (!CONSP (Vframe_list
) || !EQ (XCAR (Vframe_list
), frame
))
4153 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
4156 x_free_frame_resources (f
);
4159 /* Check that reference counts are indeed correct. */
4160 xassert (dpyinfo
->reference_count
== dpyinfo_refcount
);
4161 xassert (dpyinfo
->image_cache
->refcount
== image_cache_refcount
);
4170 x_default_font_parameter (f
, parms
)
4174 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
4175 Lisp_Object font_param
= x_get_arg (dpyinfo
, parms
, Qfont
, NULL
, NULL
,
4178 if (EQ (font_param
, Qunbound
))
4180 font
= !NILP (font_param
) ? font_param
4181 : x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
4183 if (!STRINGP (font
))
4186 static char *names
[]
4187 = { "Courier New-10",
4188 "-*-Courier-normal-r-*-*-13-*-*-*-c-*-iso8859-1",
4189 "-*-Fixedsys-normal-r-*-*-12-*-*-*-c-*-iso8859-1",
4193 for (i
= 0; names
[i
]; i
++)
4195 font
= font_open_by_name (f
, names
[i
]);
4200 error ("No suitable font was found");
4202 else if (!NILP (font_param
))
4204 /* Remember the explicit font parameter, so we can re-apply it after
4205 we've applied the `default' face settings. */
4206 x_set_frame_parameters (f
, Fcons (Fcons (Qfont_param
, font_param
), Qnil
));
4208 x_default_parameter (f
, parms
, Qfont
, font
, "font", "Font", RES_TYPE_STRING
);
4211 DEFUN ("x-create-frame", Fx_create_frame
, Sx_create_frame
,
4213 doc
: /* Make a new window, which is called a \"frame\" in Emacs terms.
4214 Return an Emacs frame object.
4215 PARAMETERS is an alist of frame parameters.
4216 If the parameters specify that the frame should not have a minibuffer,
4217 and do not specify a specific minibuffer window to use,
4218 then `default-minibuffer-frame' must be a frame whose minibuffer can
4219 be shared by the new frame.
4221 This function is an internal primitive--use `make-frame' instead. */)
4223 Lisp_Object parameters
;
4226 Lisp_Object frame
, tem
;
4228 int minibuffer_only
= 0;
4229 long window_prompting
= 0;
4231 int count
= SPECPDL_INDEX ();
4232 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
4233 Lisp_Object display
;
4234 struct w32_display_info
*dpyinfo
= NULL
;
4238 /* Make copy of frame parameters because the original is in pure
4240 parameters
= Fcopy_alist (parameters
);
4242 /* Use this general default value to start with
4243 until we know if this frame has a specified name. */
4244 Vx_resource_name
= Vinvocation_name
;
4246 display
= x_get_arg (dpyinfo
, parameters
, Qterminal
, 0, 0, RES_TYPE_NUMBER
);
4247 if (EQ (display
, Qunbound
))
4248 display
= x_get_arg (dpyinfo
, parameters
, Qdisplay
, 0, 0, RES_TYPE_STRING
);
4249 if (EQ (display
, Qunbound
))
4251 dpyinfo
= check_x_display_info (display
);
4252 kb
= dpyinfo
->terminal
->kboard
;
4254 if (!dpyinfo
->terminal
->name
)
4255 error ("Terminal is not live, can't create new frames on it");
4257 name
= x_get_arg (dpyinfo
, parameters
, Qname
, "name", "Name", RES_TYPE_STRING
);
4259 && ! EQ (name
, Qunbound
)
4261 error ("Invalid frame name--not a string or nil");
4264 Vx_resource_name
= name
;
4266 /* See if parent window is specified. */
4267 parent
= x_get_arg (dpyinfo
, parameters
, Qparent_id
, NULL
, NULL
, RES_TYPE_NUMBER
);
4268 if (EQ (parent
, Qunbound
))
4270 if (! NILP (parent
))
4271 CHECK_NUMBER (parent
);
4273 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
4274 /* No need to protect DISPLAY because that's not used after passing
4275 it to make_frame_without_minibuffer. */
4277 GCPRO4 (parameters
, parent
, name
, frame
);
4278 tem
= x_get_arg (dpyinfo
, parameters
, Qminibuffer
, "minibuffer", "Minibuffer",
4280 if (EQ (tem
, Qnone
) || NILP (tem
))
4281 f
= make_frame_without_minibuffer (Qnil
, kb
, display
);
4282 else if (EQ (tem
, Qonly
))
4284 f
= make_minibuffer_frame ();
4285 minibuffer_only
= 1;
4287 else if (WINDOWP (tem
))
4288 f
= make_frame_without_minibuffer (tem
, kb
, display
);
4292 XSETFRAME (frame
, f
);
4294 /* Note that Windows does support scroll bars. */
4295 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
4297 /* By default, make scrollbars the system standard width. */
4298 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = GetSystemMetrics (SM_CXVSCROLL
);
4300 f
->terminal
= dpyinfo
->terminal
;
4301 f
->terminal
->reference_count
++;
4303 f
->output_method
= output_w32
;
4304 f
->output_data
.w32
=
4305 (struct w32_output
*) xmalloc (sizeof (struct w32_output
));
4306 bzero (f
->output_data
.w32
, sizeof (struct w32_output
));
4307 FRAME_FONTSET (f
) = -1;
4310 = x_get_arg (dpyinfo
, parameters
, Qicon_name
, "iconName", "Title",
4312 if (! STRINGP (f
->icon_name
))
4313 f
->icon_name
= Qnil
;
4315 /* FRAME_W32_DISPLAY_INFO (f) = dpyinfo; */
4317 /* With FRAME_X_DISPLAY_INFO set up, this unwind-protect is safe. */
4318 record_unwind_protect (unwind_create_frame
, frame
);
4320 image_cache_refcount
= FRAME_IMAGE_CACHE (f
)->refcount
;
4321 dpyinfo_refcount
= dpyinfo
->reference_count
;
4322 #endif /* GLYPH_DEBUG */
4324 /* Specify the parent under which to make this window. */
4328 f
->output_data
.w32
->parent_desc
= (Window
) XFASTINT (parent
);
4329 f
->output_data
.w32
->explicit_parent
= 1;
4333 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
4334 f
->output_data
.w32
->explicit_parent
= 0;
4337 /* Set the name; the functions to which we pass f expect the name to
4339 if (EQ (name
, Qunbound
) || NILP (name
))
4341 f
->name
= build_string (dpyinfo
->w32_id_name
);
4342 f
->explicit_name
= 0;
4347 f
->explicit_name
= 1;
4348 /* use the frame's title when getting resources for this frame. */
4349 specbind (Qx_resource_name
, name
);
4352 f
->resx
= dpyinfo
->resx
;
4353 f
->resy
= dpyinfo
->resy
;
4355 if (uniscribe_available
)
4356 register_font_driver (&uniscribe_font_driver
, f
);
4357 register_font_driver (&w32font_driver
, f
);
4359 x_default_parameter (f
, parameters
, Qfont_backend
, Qnil
,
4360 "fontBackend", "FontBackend", RES_TYPE_STRING
);
4361 /* Extract the window parameters from the supplied values
4362 that are needed to determine window geometry. */
4363 x_default_font_parameter (f
, parameters
);
4364 x_default_parameter (f
, parameters
, Qborder_width
, make_number (2),
4365 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
4367 /* We recognize either internalBorderWidth or internalBorder
4368 (which is what xterm calls it). */
4369 if (NILP (Fassq (Qinternal_border_width
, parameters
)))
4373 value
= x_get_arg (dpyinfo
, parameters
, Qinternal_border_width
,
4374 "internalBorder", "InternalBorder", RES_TYPE_NUMBER
);
4375 if (! EQ (value
, Qunbound
))
4376 parameters
= Fcons (Fcons (Qinternal_border_width
, value
),
4379 /* Default internalBorderWidth to 0 on Windows to match other programs. */
4380 x_default_parameter (f
, parameters
, Qinternal_border_width
, make_number (0),
4381 "internalBorderWidth", "InternalBorder", RES_TYPE_NUMBER
);
4382 x_default_parameter (f
, parameters
, Qvertical_scroll_bars
, Qright
,
4383 "verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL
);
4385 /* Also do the stuff which must be set before the window exists. */
4386 x_default_parameter (f
, parameters
, Qforeground_color
, build_string ("black"),
4387 "foreground", "Foreground", RES_TYPE_STRING
);
4388 x_default_parameter (f
, parameters
, Qbackground_color
, build_string ("white"),
4389 "background", "Background", RES_TYPE_STRING
);
4390 x_default_parameter (f
, parameters
, Qmouse_color
, build_string ("black"),
4391 "pointerColor", "Foreground", RES_TYPE_STRING
);
4392 x_default_parameter (f
, parameters
, Qcursor_color
, build_string ("black"),
4393 "cursorColor", "Foreground", RES_TYPE_STRING
);
4394 x_default_parameter (f
, parameters
, Qborder_color
, build_string ("black"),
4395 "borderColor", "BorderColor", RES_TYPE_STRING
);
4396 x_default_parameter (f
, parameters
, Qscreen_gamma
, Qnil
,
4397 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT
);
4398 x_default_parameter (f
, parameters
, Qline_spacing
, Qnil
,
4399 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER
);
4400 x_default_parameter (f
, parameters
, Qleft_fringe
, Qnil
,
4401 "leftFringe", "LeftFringe", RES_TYPE_NUMBER
);
4402 x_default_parameter (f
, parameters
, Qright_fringe
, Qnil
,
4403 "rightFringe", "RightFringe", RES_TYPE_NUMBER
);
4406 /* Init faces before x_default_parameter is called for scroll-bar
4407 parameters because that function calls x_set_scroll_bar_width,
4408 which calls change_frame_size, which calls Fset_window_buffer,
4409 which runs hooks, which call Fvertical_motion. At the end, we
4410 end up in init_iterator with a null face cache, which should not
4412 init_frame_faces (f
);
4414 x_default_parameter (f
, parameters
, Qmenu_bar_lines
, make_number (1),
4415 "menuBar", "MenuBar", RES_TYPE_NUMBER
);
4416 x_default_parameter (f
, parameters
, Qtool_bar_lines
, make_number (1),
4417 "toolBar", "ToolBar", RES_TYPE_NUMBER
);
4419 x_default_parameter (f
, parameters
, Qbuffer_predicate
, Qnil
,
4420 "bufferPredicate", "BufferPredicate", RES_TYPE_SYMBOL
);
4421 x_default_parameter (f
, parameters
, Qtitle
, Qnil
,
4422 "title", "Title", RES_TYPE_STRING
);
4423 x_default_parameter (f
, parameters
, Qfullscreen
, Qnil
,
4424 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL
);
4426 f
->output_data
.w32
->dwStyle
= WS_OVERLAPPEDWINDOW
;
4427 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
4429 f
->output_data
.w32
->text_cursor
= w32_load_cursor (IDC_IBEAM
);
4430 f
->output_data
.w32
->nontext_cursor
= w32_load_cursor (IDC_ARROW
);
4431 f
->output_data
.w32
->modeline_cursor
= w32_load_cursor (IDC_ARROW
);
4432 f
->output_data
.w32
->hand_cursor
= w32_load_cursor (IDC_HAND
);
4433 f
->output_data
.w32
->hourglass_cursor
= w32_load_cursor (IDC_WAIT
);
4434 f
->output_data
.w32
->horizontal_drag_cursor
= w32_load_cursor (IDC_SIZEWE
);
4436 f
->output_data
.w32
->current_cursor
= f
->output_data
.w32
->nontext_cursor
;
4438 window_prompting
= x_figure_window_size (f
, parameters
, 1);
4440 tem
= x_get_arg (dpyinfo
, parameters
, Qunsplittable
, 0, 0, RES_TYPE_BOOLEAN
);
4441 f
->no_split
= minibuffer_only
|| EQ (tem
, Qt
);
4443 w32_window (f
, window_prompting
, minibuffer_only
);
4444 x_icon (f
, parameters
);
4448 /* Now consider the frame official. */
4449 FRAME_W32_DISPLAY_INFO (f
)->reference_count
++;
4450 Vframe_list
= Fcons (frame
, Vframe_list
);
4452 /* We need to do this after creating the window, so that the
4453 icon-creation functions can say whose icon they're describing. */
4454 x_default_parameter (f
, parameters
, Qicon_type
, Qnil
,
4455 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL
);
4457 x_default_parameter (f
, parameters
, Qauto_raise
, Qnil
,
4458 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
4459 x_default_parameter (f
, parameters
, Qauto_lower
, Qnil
,
4460 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
4461 x_default_parameter (f
, parameters
, Qcursor_type
, Qbox
,
4462 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
4463 x_default_parameter (f
, parameters
, Qscroll_bar_width
, Qnil
,
4464 "scrollBarWidth", "ScrollBarWidth", RES_TYPE_NUMBER
);
4465 x_default_parameter (f
, parameters
, Qalpha
, Qnil
,
4466 "alpha", "Alpha", RES_TYPE_NUMBER
);
4468 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
4469 Change will not be effected unless different from the current
4471 width
= FRAME_COLS (f
);
4472 height
= FRAME_LINES (f
);
4474 FRAME_LINES (f
) = 0;
4475 SET_FRAME_COLS (f
, 0);
4476 change_frame_size (f
, height
, width
, 1, 0, 0);
4478 /* Tell the server what size and position, etc, we want, and how
4479 badly we want them. This should be done after we have the menu
4480 bar so that its size can be taken into account. */
4482 x_wm_set_size_hint (f
, window_prompting
, 0);
4485 /* Make the window appear on the frame and enable display, unless
4486 the caller says not to. However, with explicit parent, Emacs
4487 cannot control visibility, so don't try. */
4488 if (! f
->output_data
.w32
->explicit_parent
)
4490 Lisp_Object visibility
;
4492 visibility
= x_get_arg (dpyinfo
, parameters
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
);
4493 if (EQ (visibility
, Qunbound
))
4496 if (EQ (visibility
, Qicon
))
4497 x_iconify_frame (f
);
4498 else if (! NILP (visibility
))
4499 x_make_frame_visible (f
);
4501 /* Must have been Qnil. */
4505 /* Initialize `default-minibuffer-frame' in case this is the first
4506 frame on this terminal. */
4507 if (FRAME_HAS_MINIBUF_P (f
)
4508 && (!FRAMEP (kb
->Vdefault_minibuffer_frame
)
4509 || !FRAME_LIVE_P (XFRAME (kb
->Vdefault_minibuffer_frame
))))
4510 kb
->Vdefault_minibuffer_frame
= frame
;
4512 /* All remaining specified parameters, which have not been "used"
4513 by x_get_arg and friends, now go in the misc. alist of the frame. */
4514 for (tem
= parameters
; CONSP (tem
); tem
= XCDR (tem
))
4515 if (CONSP (XCAR (tem
)) && !NILP (XCAR (XCAR (tem
))))
4516 f
->param_alist
= Fcons (XCAR (tem
), f
->param_alist
);
4520 /* Make sure windows on this frame appear in calls to next-window
4521 and similar functions. */
4522 Vwindow_list
= Qnil
;
4524 return unbind_to (count
, frame
);
4527 /* FRAME is used only to get a handle on the X display. We don't pass the
4528 display info directly because we're called from frame.c, which doesn't
4529 know about that structure. */
4531 x_get_focus_frame (frame
)
4532 struct frame
*frame
;
4534 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (frame
);
4536 if (! dpyinfo
->w32_focus_frame
)
4539 XSETFRAME (xfocus
, dpyinfo
->w32_focus_frame
);
4543 DEFUN ("x-focus-frame", Fx_focus_frame
, Sx_focus_frame
, 1, 1, 0,
4544 doc
: /* Give FRAME input focus, raising to foreground if necessary. */)
4548 x_focus_on_frame (check_x_frame (frame
));
4553 DEFUN ("xw-color-defined-p", Fxw_color_defined_p
, Sxw_color_defined_p
, 1, 2, 0,
4554 doc
: /* Internal function called by `color-defined-p', which see. */)
4556 Lisp_Object color
, frame
;
4559 FRAME_PTR f
= check_x_frame (frame
);
4561 CHECK_STRING (color
);
4563 if (w32_defined_color (f
, SDATA (color
), &foo
, 0))
4569 DEFUN ("xw-color-values", Fxw_color_values
, Sxw_color_values
, 1, 2, 0,
4570 doc
: /* Internal function called by `color-values', which see. */)
4572 Lisp_Object color
, frame
;
4575 FRAME_PTR f
= check_x_frame (frame
);
4577 CHECK_STRING (color
);
4579 if (w32_defined_color (f
, SDATA (color
), &foo
, 0))
4580 return list3 (make_number ((GetRValue (foo
.pixel
) << 8)
4581 | GetRValue (foo
.pixel
)),
4582 make_number ((GetGValue (foo
.pixel
) << 8)
4583 | GetGValue (foo
.pixel
)),
4584 make_number ((GetBValue (foo
.pixel
) << 8)
4585 | GetBValue (foo
.pixel
)));
4590 DEFUN ("xw-display-color-p", Fxw_display_color_p
, Sxw_display_color_p
, 0, 1, 0,
4591 doc
: /* Internal function called by `display-color-p', which see. */)
4593 Lisp_Object display
;
4595 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4597 if ((dpyinfo
->n_planes
* dpyinfo
->n_cbits
) <= 2)
4603 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p
,
4604 Sx_display_grayscale_p
, 0, 1, 0,
4605 doc
: /* Return t if DISPLAY supports shades of gray.
4606 Note that color displays do support shades of gray.
4607 The optional argument DISPLAY specifies which display to ask about.
4608 DISPLAY should be either a frame or a display name (a string).
4609 If omitted or nil, that stands for the selected frame's display. */)
4611 Lisp_Object display
;
4613 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4615 if ((dpyinfo
->n_planes
* dpyinfo
->n_cbits
) <= 1)
4621 DEFUN ("x-display-pixel-width", Fx_display_pixel_width
,
4622 Sx_display_pixel_width
, 0, 1, 0,
4623 doc
: /* Return the width in pixels of DISPLAY.
4624 The optional argument DISPLAY specifies which display to ask about.
4625 DISPLAY should be either a frame or a display name (a string).
4626 If omitted or nil, that stands for the selected frame's display. */)
4628 Lisp_Object display
;
4630 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4632 return make_number (x_display_pixel_width (dpyinfo
));
4635 DEFUN ("x-display-pixel-height", Fx_display_pixel_height
,
4636 Sx_display_pixel_height
, 0, 1, 0,
4637 doc
: /* Return the height in pixels of DISPLAY.
4638 The optional argument DISPLAY specifies which display to ask about.
4639 DISPLAY should be either a frame or a display name (a string).
4640 If omitted or nil, that stands for the selected frame's display. */)
4642 Lisp_Object display
;
4644 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4646 return make_number (x_display_pixel_height (dpyinfo
));
4649 DEFUN ("x-display-planes", Fx_display_planes
, Sx_display_planes
,
4651 doc
: /* Return the number of bitplanes of DISPLAY.
4652 The optional argument DISPLAY specifies which display to ask about.
4653 DISPLAY should be either a frame or a display name (a string).
4654 If omitted or nil, that stands for the selected frame's display. */)
4656 Lisp_Object display
;
4658 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4660 return make_number (dpyinfo
->n_planes
* dpyinfo
->n_cbits
);
4663 DEFUN ("x-display-color-cells", Fx_display_color_cells
, Sx_display_color_cells
,
4665 doc
: /* Return the number of color cells of DISPLAY.
4666 The optional argument DISPLAY specifies which display to ask about.
4667 DISPLAY should be either a frame or a display name (a string).
4668 If omitted or nil, that stands for the selected frame's display. */)
4670 Lisp_Object display
;
4672 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4676 hdc
= GetDC (dpyinfo
->root_window
);
4677 if (dpyinfo
->has_palette
)
4678 cap
= GetDeviceCaps (hdc
, SIZEPALETTE
);
4680 cap
= GetDeviceCaps (hdc
, NUMCOLORS
);
4682 /* We force 24+ bit depths to 24-bit, both to prevent an overflow
4683 and because probably is more meaningful on Windows anyway */
4685 cap
= 1 << min (dpyinfo
->n_planes
* dpyinfo
->n_cbits
, 24);
4687 ReleaseDC (dpyinfo
->root_window
, hdc
);
4689 return make_number (cap
);
4692 DEFUN ("x-server-max-request-size", Fx_server_max_request_size
,
4693 Sx_server_max_request_size
,
4695 doc
: /* Return the maximum request size of the server of DISPLAY.
4696 The optional argument DISPLAY specifies which display to ask about.
4697 DISPLAY should be either a frame or a display name (a string).
4698 If omitted or nil, that stands for the selected frame's display. */)
4700 Lisp_Object display
;
4702 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4704 return make_number (1);
4707 DEFUN ("x-server-vendor", Fx_server_vendor
, Sx_server_vendor
, 0, 1, 0,
4708 doc
: /* Return the "vendor ID" string of the W32 system (Microsoft).
4709 The optional argument DISPLAY specifies which display to ask about.
4710 DISPLAY should be either a frame or a display name (a string).
4711 If omitted or nil, that stands for the selected frame's display. */)
4713 Lisp_Object display
;
4715 return build_string ("Microsoft Corp.");
4718 DEFUN ("x-server-version", Fx_server_version
, Sx_server_version
, 0, 1, 0,
4719 doc
: /* Return the version numbers of the server of DISPLAY.
4720 The value is a list of three integers: the major and minor
4721 version numbers of the X Protocol in use, and the distributor-specific
4722 release number. See also the function `x-server-vendor'.
4724 The optional argument DISPLAY specifies which display to ask about.
4725 DISPLAY should be either a frame or a display name (a string).
4726 If omitted or nil, that stands for the selected frame's display. */)
4728 Lisp_Object display
;
4730 return Fcons (make_number (w32_major_version
),
4731 Fcons (make_number (w32_minor_version
),
4732 Fcons (make_number (w32_build_number
), Qnil
)));
4735 DEFUN ("x-display-screens", Fx_display_screens
, Sx_display_screens
, 0, 1, 0,
4736 doc
: /* Return the number of screens on the server of DISPLAY.
4737 The optional argument DISPLAY specifies which display to ask about.
4738 DISPLAY should be either a frame or a display name (a string).
4739 If omitted or nil, that stands for the selected frame's display. */)
4741 Lisp_Object display
;
4743 return make_number (1);
4746 DEFUN ("x-display-mm-height", Fx_display_mm_height
,
4747 Sx_display_mm_height
, 0, 1, 0,
4748 doc
: /* Return the height in millimeters of DISPLAY.
4749 The optional argument DISPLAY specifies which display to ask about.
4750 DISPLAY should be either a frame or a display name (a string).
4751 If omitted or nil, that stands for the selected frame's display. */)
4753 Lisp_Object display
;
4755 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4759 hdc
= GetDC (dpyinfo
->root_window
);
4761 cap
= GetDeviceCaps (hdc
, VERTSIZE
);
4763 ReleaseDC (dpyinfo
->root_window
, hdc
);
4765 return make_number (cap
);
4768 DEFUN ("x-display-mm-width", Fx_display_mm_width
, Sx_display_mm_width
, 0, 1, 0,
4769 doc
: /* Return the width in millimeters of DISPLAY.
4770 The optional argument DISPLAY specifies which display to ask about.
4771 DISPLAY should be either a frame or a display name (a string).
4772 If omitted or nil, that stands for the selected frame's display. */)
4774 Lisp_Object display
;
4776 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4781 hdc
= GetDC (dpyinfo
->root_window
);
4783 cap
= GetDeviceCaps (hdc
, HORZSIZE
);
4785 ReleaseDC (dpyinfo
->root_window
, hdc
);
4787 return make_number (cap
);
4790 DEFUN ("x-display-backing-store", Fx_display_backing_store
,
4791 Sx_display_backing_store
, 0, 1, 0,
4792 doc
: /* Return an indication of whether DISPLAY does backing store.
4793 The value may be `always', `when-mapped', or `not-useful'.
4794 The optional argument DISPLAY specifies which display to ask about.
4795 DISPLAY should be either a frame or a display name (a string).
4796 If omitted or nil, that stands for the selected frame's display. */)
4798 Lisp_Object display
;
4800 return intern ("not-useful");
4803 DEFUN ("x-display-visual-class", Fx_display_visual_class
,
4804 Sx_display_visual_class
, 0, 1, 0,
4805 doc
: /* Return the visual class of DISPLAY.
4806 The value is one of the symbols `static-gray', `gray-scale',
4807 `static-color', `pseudo-color', `true-color', or `direct-color'.
4809 The optional argument DISPLAY specifies which display to ask about.
4810 DISPLAY should be either a frame or a display name (a string).
4811 If omitted or nil, that stands for the selected frame's display. */)
4813 Lisp_Object display
;
4815 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
4816 Lisp_Object result
= Qnil
;
4818 if (dpyinfo
->has_palette
)
4819 result
= intern ("pseudo-color");
4820 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
== 1)
4821 result
= intern ("static-grey");
4822 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
== 4)
4823 result
= intern ("static-color");
4824 else if (dpyinfo
->n_planes
* dpyinfo
->n_cbits
> 8)
4825 result
= intern ("true-color");
4830 DEFUN ("x-display-save-under", Fx_display_save_under
,
4831 Sx_display_save_under
, 0, 1, 0,
4832 doc
: /* Return t if DISPLAY supports the save-under feature.
4833 The optional argument DISPLAY specifies which display to ask about.
4834 DISPLAY should be either a frame or a display name (a string).
4835 If omitted or nil, that stands for the selected frame's display. */)
4837 Lisp_Object display
;
4844 register struct frame
*f
;
4846 return FRAME_PIXEL_WIDTH (f
);
4851 register struct frame
*f
;
4853 return FRAME_PIXEL_HEIGHT (f
);
4858 register struct frame
*f
;
4860 return FRAME_COLUMN_WIDTH (f
);
4865 register struct frame
*f
;
4867 return FRAME_LINE_HEIGHT (f
);
4872 register struct frame
*f
;
4874 return FRAME_W32_DISPLAY_INFO (f
)->n_planes
;
4877 /* Return the display structure for the display named NAME.
4878 Open a new connection if necessary. */
4880 struct w32_display_info
*
4881 x_display_info_for_name (name
)
4885 struct w32_display_info
*dpyinfo
;
4887 CHECK_STRING (name
);
4889 for (dpyinfo
= &one_w32_display_info
, names
= w32_display_name_list
;
4891 dpyinfo
= dpyinfo
->next
, names
= XCDR (names
))
4894 tem
= Fstring_equal (XCAR (XCAR (names
)), name
);
4899 /* Use this general default value to start with. */
4900 Vx_resource_name
= Vinvocation_name
;
4902 validate_x_resource_name ();
4904 dpyinfo
= w32_term_init (name
, (unsigned char *)0,
4905 (char *) SDATA (Vx_resource_name
));
4908 error ("Cannot connect to server %s", SDATA (name
));
4911 XSETFASTINT (Vwindow_system_version
, 3);
4916 DEFUN ("x-open-connection", Fx_open_connection
, Sx_open_connection
,
4917 1, 3, 0, doc
: /* Open a connection to a server.
4918 DISPLAY is the name of the display to connect to.
4919 Optional second arg XRM-STRING is a string of resources in xrdb format.
4920 If the optional third arg MUST-SUCCEED is non-nil,
4921 terminate Emacs if we can't open the connection. */)
4922 (display
, xrm_string
, must_succeed
)
4923 Lisp_Object display
, xrm_string
, must_succeed
;
4925 unsigned char *xrm_option
;
4926 struct w32_display_info
*dpyinfo
;
4928 /* If initialization has already been done, return now to avoid
4929 overwriting critical parts of one_w32_display_info. */
4933 CHECK_STRING (display
);
4934 if (! NILP (xrm_string
))
4935 CHECK_STRING (xrm_string
);
4938 if (! EQ (Vwindow_system
, intern ("w32")))
4939 error ("Not using Microsoft Windows");
4942 /* Allow color mapping to be defined externally; first look in user's
4943 HOME directory, then in Emacs etc dir for a file called rgb.txt. */
4945 Lisp_Object color_file
;
4946 struct gcpro gcpro1
;
4948 color_file
= build_string ("~/rgb.txt");
4950 GCPRO1 (color_file
);
4952 if (NILP (Ffile_readable_p (color_file
)))
4954 Fexpand_file_name (build_string ("rgb.txt"),
4955 Fsymbol_value (intern ("data-directory")));
4957 Vw32_color_map
= Fx_load_color_file (color_file
);
4961 if (NILP (Vw32_color_map
))
4962 Vw32_color_map
= Fw32_default_color_map ();
4964 /* Merge in system logical colors. */
4965 add_system_logical_colors_to_map (&Vw32_color_map
);
4967 if (! NILP (xrm_string
))
4968 xrm_option
= (unsigned char *) SDATA (xrm_string
);
4970 xrm_option
= (unsigned char *) 0;
4972 /* Use this general default value to start with. */
4973 /* First remove .exe suffix from invocation-name - it looks ugly. */
4975 char basename
[ MAX_PATH
], *str
;
4977 strcpy (basename
, SDATA (Vinvocation_name
));
4978 str
= strrchr (basename
, '.');
4980 Vinvocation_name
= build_string (basename
);
4982 Vx_resource_name
= Vinvocation_name
;
4984 validate_x_resource_name ();
4986 /* This is what opens the connection and sets x_current_display.
4987 This also initializes many symbols, such as those used for input. */
4988 dpyinfo
= w32_term_init (display
, xrm_option
,
4989 (char *) SDATA (Vx_resource_name
));
4993 if (!NILP (must_succeed
))
4994 fatal ("Cannot connect to server %s.\n",
4997 error ("Cannot connect to server %s", SDATA (display
));
5002 XSETFASTINT (Vwindow_system_version
, 3);
5006 DEFUN ("x-close-connection", Fx_close_connection
,
5007 Sx_close_connection
, 1, 1, 0,
5008 doc
: /* Close the connection to DISPLAY's server.
5009 For DISPLAY, specify either a frame or a display name (a string).
5010 If DISPLAY is nil, that stands for the selected frame's display. */)
5012 Lisp_Object display
;
5014 struct w32_display_info
*dpyinfo
= check_x_display_info (display
);
5017 if (dpyinfo
->reference_count
> 0)
5018 error ("Display still has frames on it");
5021 x_destroy_all_bitmaps (dpyinfo
);
5023 x_delete_display (dpyinfo
);
5029 DEFUN ("x-display-list", Fx_display_list
, Sx_display_list
, 0, 0, 0,
5030 doc
: /* Return the list of display names that Emacs has connections to. */)
5033 Lisp_Object tail
, result
;
5036 for (tail
= w32_display_name_list
; CONSP (tail
); tail
= XCDR (tail
))
5037 result
= Fcons (XCAR (XCAR (tail
)), result
);
5042 DEFUN ("x-synchronize", Fx_synchronize
, Sx_synchronize
, 1, 2, 0,
5043 doc
: /* This is a noop on W32 systems. */)
5045 Lisp_Object display
, on
;
5052 /***********************************************************************
5054 ***********************************************************************/
5056 DEFUN ("x-change-window-property", Fx_change_window_property
,
5057 Sx_change_window_property
, 2, 6, 0,
5058 doc
: /* Change window property PROP to VALUE on the X window of FRAME.
5059 VALUE may be a string or a list of conses, numbers and/or strings.
5060 If an element in the list is a string, it is converted to
5061 an Atom and the value of the Atom is used. If an element is a cons,
5062 it is converted to a 32 bit number where the car is the 16 top bits and the
5063 cdr is the lower 16 bits.
5064 FRAME nil or omitted means use the selected frame.
5065 If TYPE is given and non-nil, it is the name of the type of VALUE.
5066 If TYPE is not given or nil, the type is STRING.
5067 FORMAT gives the size in bits of each element if VALUE is a list.
5068 It must be one of 8, 16 or 32.
5069 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
5070 If OUTER_P is non-nil, the property is changed for the outer X window of
5071 FRAME. Default is to change on the edit X window.
5074 (prop
, value
, frame
, type
, format
, outer_p
)
5075 Lisp_Object prop
, value
, frame
, type
, format
, outer_p
;
5077 #if 0 /* TODO : port window properties to W32 */
5078 struct frame
*f
= check_x_frame (frame
);
5081 CHECK_STRING (prop
);
5082 CHECK_STRING (value
);
5085 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
5086 XChangeProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
5087 prop_atom
, XA_STRING
, 8, PropModeReplace
,
5088 SDATA (value
), SCHARS (value
));
5090 /* Make sure the property is set when we return. */
5091 XFlush (FRAME_W32_DISPLAY (f
));
5100 DEFUN ("x-delete-window-property", Fx_delete_window_property
,
5101 Sx_delete_window_property
, 1, 2, 0,
5102 doc
: /* Remove window property PROP from X window of FRAME.
5103 FRAME nil or omitted means use the selected frame. Value is PROP. */)
5105 Lisp_Object prop
, frame
;
5107 #if 0 /* TODO : port window properties to W32 */
5109 struct frame
*f
= check_x_frame (frame
);
5112 CHECK_STRING (prop
);
5114 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
5115 XDeleteProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
), prop_atom
);
5117 /* Make sure the property is removed when we return. */
5118 XFlush (FRAME_W32_DISPLAY (f
));
5126 DEFUN ("x-window-property", Fx_window_property
, Sx_window_property
,
5128 doc
: /* Value is the value of window property PROP on FRAME.
5129 If FRAME is nil or omitted, use the selected frame. Value is nil
5130 if FRAME hasn't a property with name PROP or if PROP has no string
5133 Lisp_Object prop
, frame
;
5135 #if 0 /* TODO : port window properties to W32 */
5137 struct frame
*f
= check_x_frame (frame
);
5140 Lisp_Object prop_value
= Qnil
;
5141 char *tmp_data
= NULL
;
5144 unsigned long actual_size
, bytes_remaining
;
5146 CHECK_STRING (prop
);
5148 prop_atom
= XInternAtom (FRAME_W32_DISPLAY (f
), SDATA (prop
), False
);
5149 rc
= XGetWindowProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
5150 prop_atom
, 0, 0, False
, XA_STRING
,
5151 &actual_type
, &actual_format
, &actual_size
,
5152 &bytes_remaining
, (unsigned char **) &tmp_data
);
5155 int size
= bytes_remaining
;
5160 rc
= XGetWindowProperty (FRAME_W32_DISPLAY (f
), FRAME_W32_WINDOW (f
),
5161 prop_atom
, 0, bytes_remaining
,
5163 &actual_type
, &actual_format
,
5164 &actual_size
, &bytes_remaining
,
5165 (unsigned char **) &tmp_data
);
5167 prop_value
= make_string (tmp_data
, size
);
5182 /***********************************************************************
5184 ***********************************************************************/
5186 /* Default number of seconds to wait before displaying an hourglass
5187 cursor. Duplicated from xdisp.c, but cannot use the version there
5188 due to lack of atimers on w32. */
5189 #define DEFAULT_HOURGLASS_DELAY 1
5190 extern Lisp_Object Vhourglass_delay
;
5192 /* Return non-zero if houglass timer has been started or hourglass is shown. */
5193 /* PENDING: if W32 can use atimers (atimer.[hc]) then the common impl in
5194 xdisp.c could be used. */
5197 hourglass_started ()
5199 return hourglass_shown_p
|| hourglass_timer
;
5202 /* Cancel a currently active hourglass timer, and start a new one. */
5208 int secs
, msecs
= 0;
5209 struct frame
* f
= SELECTED_FRAME ();
5211 /* No cursors on non GUI frames. */
5212 if (!FRAME_W32_P (f
))
5215 cancel_hourglass ();
5217 if (INTEGERP (Vhourglass_delay
)
5218 && XINT (Vhourglass_delay
) > 0)
5219 secs
= XFASTINT (Vhourglass_delay
);
5220 else if (FLOATP (Vhourglass_delay
)
5221 && XFLOAT_DATA (Vhourglass_delay
) > 0)
5224 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
5225 secs
= XFASTINT (tem
);
5226 msecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000;
5229 secs
= DEFAULT_HOURGLASS_DELAY
;
5231 delay
= secs
* 1000 + msecs
;
5232 hourglass_hwnd
= FRAME_W32_WINDOW (f
);
5233 hourglass_timer
= SetTimer (hourglass_hwnd
, HOURGLASS_ID
, delay
, NULL
);
5237 /* Cancel the hourglass cursor timer if active, hide an hourglass
5243 if (hourglass_timer
)
5245 KillTimer (hourglass_hwnd
, hourglass_timer
);
5246 hourglass_timer
= 0;
5249 if (hourglass_shown_p
)
5250 w32_hide_hourglass ();
5254 /* Timer function of hourglass_timer.
5256 Display an hourglass cursor. Set the hourglass_p flag in display info
5257 to indicate that an hourglass cursor is shown. */
5260 w32_show_hourglass (f
)
5263 if (!hourglass_shown_p
)
5265 f
->output_data
.w32
->hourglass_p
= 1;
5266 if (!menubar_in_use
&& !current_popup_menu
)
5267 SetCursor (f
->output_data
.w32
->hourglass_cursor
);
5268 hourglass_shown_p
= 1;
5273 /* Hide the hourglass cursor on all frames, if it is currently shown. */
5276 w32_hide_hourglass ()
5278 if (hourglass_shown_p
)
5280 struct frame
*f
= x_window_to_frame (&one_w32_display_info
,
5283 f
->output_data
.w32
->hourglass_p
= 0;
5284 SetCursor (f
->output_data
.w32
->current_cursor
);
5285 hourglass_shown_p
= 0;
5291 /***********************************************************************
5293 ***********************************************************************/
5295 static Lisp_Object x_create_tip_frame
P_ ((struct w32_display_info
*,
5296 Lisp_Object
, Lisp_Object
));
5297 static void compute_tip_xy
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
,
5298 Lisp_Object
, int, int, int *, int *));
5300 /* The frame of a currently visible tooltip. */
5302 Lisp_Object tip_frame
;
5304 /* If non-nil, a timer started that hides the last tooltip when it
5307 Lisp_Object tip_timer
;
5310 /* If non-nil, a vector of 3 elements containing the last args
5311 with which x-show-tip was called. See there. */
5313 Lisp_Object last_show_tip_args
;
5315 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
5317 Lisp_Object Vx_max_tooltip_size
;
5321 unwind_create_tip_frame (frame
)
5324 Lisp_Object deleted
;
5326 deleted
= unwind_create_frame (frame
);
5327 if (EQ (deleted
, Qt
))
5337 /* Create a frame for a tooltip on the display described by DPYINFO.
5338 PARMS is a list of frame parameters. TEXT is the string to
5339 display in the tip frame. Value is the frame.
5341 Note that functions called here, esp. x_default_parameter can
5342 signal errors, for instance when a specified color name is
5343 undefined. We have to make sure that we're in a consistent state
5344 when this happens. */
5347 x_create_tip_frame (dpyinfo
, parms
, text
)
5348 struct w32_display_info
*dpyinfo
;
5349 Lisp_Object parms
, text
;
5352 Lisp_Object frame
, tem
;
5354 long window_prompting
= 0;
5356 int count
= SPECPDL_INDEX ();
5357 struct gcpro gcpro1
, gcpro2
, gcpro3
;
5359 int face_change_count_before
= face_change_count
;
5361 struct buffer
*old_buffer
;
5365 /* Use this general default value to start with until we know if
5366 this frame has a specified name. */
5367 Vx_resource_name
= Vinvocation_name
;
5369 kb
= dpyinfo
->terminal
->kboard
;
5371 /* Get the name of the frame to use for resource lookup. */
5372 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
5374 && !EQ (name
, Qunbound
)
5376 error ("Invalid frame name--not a string or nil");
5377 Vx_resource_name
= name
;
5380 GCPRO3 (parms
, name
, frame
);
5381 /* Make a frame without minibuffer nor mode-line. */
5383 f
->wants_modeline
= 0;
5384 XSETFRAME (frame
, f
);
5386 buffer
= Fget_buffer_create (build_string (" *tip*"));
5387 Fset_window_buffer (FRAME_ROOT_WINDOW (f
), buffer
, Qnil
);
5388 old_buffer
= current_buffer
;
5389 set_buffer_internal_1 (XBUFFER (buffer
));
5390 current_buffer
->truncate_lines
= Qnil
;
5391 specbind (Qinhibit_read_only
, Qt
);
5392 specbind (Qinhibit_modification_hooks
, Qt
);
5395 set_buffer_internal_1 (old_buffer
);
5397 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
5398 record_unwind_protect (unwind_create_tip_frame
, frame
);
5400 /* By setting the output method, we're essentially saying that
5401 the frame is live, as per FRAME_LIVE_P. If we get a signal
5402 from this point on, x_destroy_window might screw up reference
5404 f
->terminal
= dpyinfo
->terminal
;
5405 f
->terminal
->reference_count
++;
5406 f
->output_method
= output_w32
;
5407 f
->output_data
.w32
=
5408 (struct w32_output
*) xmalloc (sizeof (struct w32_output
));
5409 bzero (f
->output_data
.w32
, sizeof (struct w32_output
));
5411 FRAME_FONTSET (f
) = -1;
5412 f
->icon_name
= Qnil
;
5414 #if 0 /* GLYPH_DEBUG TODO: image support. */
5415 image_cache_refcount
= FRAME_IMAGE_CACHE (f
)->refcount
;
5416 dpyinfo_refcount
= dpyinfo
->reference_count
;
5417 #endif /* GLYPH_DEBUG */
5418 FRAME_KBOARD (f
) = kb
;
5419 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
5420 f
->output_data
.w32
->explicit_parent
= 0;
5422 /* Set the name; the functions to which we pass f expect the name to
5424 if (EQ (name
, Qunbound
) || NILP (name
))
5426 f
->name
= build_string (dpyinfo
->w32_id_name
);
5427 f
->explicit_name
= 0;
5432 f
->explicit_name
= 1;
5433 /* use the frame's title when getting resources for this frame. */
5434 specbind (Qx_resource_name
, name
);
5437 f
->resx
= dpyinfo
->resx
;
5438 f
->resy
= dpyinfo
->resy
;
5440 /* Perhaps, we must allow frame parameter, say `font-backend',
5441 to specify which font backends to use. */
5442 register_font_driver (&w32font_driver
, f
);
5444 x_default_parameter (f
, parms
, Qfont_backend
, Qnil
,
5445 "fontBackend", "FontBackend", RES_TYPE_STRING
);
5447 /* Extract the window parameters from the supplied values
5448 that are needed to determine window geometry. */
5449 x_default_font_parameter (f
, parms
);
5451 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
5452 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
5453 /* This defaults to 2 in order to match xterm. We recognize either
5454 internalBorderWidth or internalBorder (which is what xterm calls
5456 if (NILP (Fassq (Qinternal_border_width
, parms
)))
5460 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
5461 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
5462 if (! EQ (value
, Qunbound
))
5463 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
5466 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
5467 "internalBorderWidth", "internalBorderWidth",
5470 /* Also do the stuff which must be set before the window exists. */
5471 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
5472 "foreground", "Foreground", RES_TYPE_STRING
);
5473 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
5474 "background", "Background", RES_TYPE_STRING
);
5475 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
5476 "pointerColor", "Foreground", RES_TYPE_STRING
);
5477 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
5478 "cursorColor", "Foreground", RES_TYPE_STRING
);
5479 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
5480 "borderColor", "BorderColor", RES_TYPE_STRING
);
5482 /* Init faces before x_default_parameter is called for scroll-bar
5483 parameters because that function calls x_set_scroll_bar_width,
5484 which calls change_frame_size, which calls Fset_window_buffer,
5485 which runs hooks, which call Fvertical_motion. At the end, we
5486 end up in init_iterator with a null face cache, which should not
5488 init_frame_faces (f
);
5490 f
->output_data
.w32
->dwStyle
= WS_BORDER
| WS_POPUP
| WS_DISABLED
;
5491 f
->output_data
.w32
->parent_desc
= FRAME_W32_DISPLAY_INFO (f
)->root_window
;
5493 window_prompting
= x_figure_window_size (f
, parms
, 0);
5495 /* No fringes on tip frame. */
5497 f
->left_fringe_width
= 0;
5498 f
->right_fringe_width
= 0;
5501 my_create_tip_window (f
);
5506 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
5507 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
5508 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
5509 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
5510 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
5511 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
5513 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
5514 Change will not be effected unless different from the current
5516 width
= FRAME_COLS (f
);
5517 height
= FRAME_LINES (f
);
5518 FRAME_LINES (f
) = 0;
5519 SET_FRAME_COLS (f
, 0);
5520 change_frame_size (f
, height
, width
, 1, 0, 0);
5522 /* Add `tooltip' frame parameter's default value. */
5523 if (NILP (Fframe_parameter (frame
, intern ("tooltip"))))
5524 Fmodify_frame_parameters (frame
, Fcons (Fcons (intern ("tooltip"), Qt
),
5527 /* Set up faces after all frame parameters are known. This call
5528 also merges in face attributes specified for new frames.
5530 Frame parameters may be changed if .Xdefaults contains
5531 specifications for the default font. For example, if there is an
5532 `Emacs.default.attributeBackground: pink', the `background-color'
5533 attribute of the frame get's set, which let's the internal border
5534 of the tooltip frame appear in pink. Prevent this. */
5536 Lisp_Object bg
= Fframe_parameter (frame
, Qbackground_color
);
5538 /* Set tip_frame here, so that */
5540 call2 (Qface_set_after_frame_default
, frame
, Qnil
);
5542 if (!EQ (bg
, Fframe_parameter (frame
, Qbackground_color
)))
5543 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qbackground_color
, bg
),
5551 /* It is now ok to make the frame official even if we get an error
5552 below. And the frame needs to be on Vframe_list or making it
5553 visible won't work. */
5554 Vframe_list
= Fcons (frame
, Vframe_list
);
5556 /* Now that the frame is official, it counts as a reference to
5558 FRAME_W32_DISPLAY_INFO (f
)->reference_count
++;
5560 /* Setting attributes of faces of the tooltip frame from resources
5561 and similar will increment face_change_count, which leads to the
5562 clearing of all current matrices. Since this isn't necessary
5563 here, avoid it by resetting face_change_count to the value it
5564 had before we created the tip frame. */
5565 face_change_count
= face_change_count_before
;
5567 /* Discard the unwind_protect. */
5568 return unbind_to (count
, frame
);
5572 /* Compute where to display tip frame F. PARMS is the list of frame
5573 parameters for F. DX and DY are specified offsets from the current
5574 location of the mouse. WIDTH and HEIGHT are the width and height
5575 of the tooltip. Return coordinates relative to the root window of
5576 the display in *ROOT_X, and *ROOT_Y. */
5579 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, root_x
, root_y
)
5581 Lisp_Object parms
, dx
, dy
;
5583 int *root_x
, *root_y
;
5585 Lisp_Object left
, top
;
5586 int min_x
, min_y
, max_x
, max_y
;
5588 /* User-specified position? */
5589 left
= Fcdr (Fassq (Qleft
, parms
));
5590 top
= Fcdr (Fassq (Qtop
, parms
));
5592 /* Move the tooltip window where the mouse pointer is. Resize and
5594 if (!INTEGERP (left
) || !INTEGERP (top
))
5598 /* Default min and max values. */
5601 max_x
= x_display_pixel_width (FRAME_W32_DISPLAY_INFO (f
));
5602 max_y
= x_display_pixel_height (FRAME_W32_DISPLAY_INFO (f
));
5610 /* If multiple monitor support is available, constrain the tip onto
5611 the current monitor. This improves the above by allowing negative
5612 co-ordinates if monitor positions are such that they are valid, and
5613 snaps a tooltip onto a single monitor if we are close to the edge
5614 where it would otherwise flow onto the other monitor (or into
5615 nothingness if there is a gap in the overlap). */
5616 if (monitor_from_point_fn
&& get_monitor_info_fn
)
5618 struct MONITOR_INFO info
;
5620 = monitor_from_point_fn (pt
, MONITOR_DEFAULT_TO_NEAREST
);
5621 info
.cbSize
= sizeof (info
);
5623 if (get_monitor_info_fn (monitor
, &info
))
5625 min_x
= info
.rcWork
.left
;
5626 min_y
= info
.rcWork
.top
;
5627 max_x
= info
.rcWork
.right
;
5628 max_y
= info
.rcWork
.bottom
;
5634 *root_y
= XINT (top
);
5635 else if (*root_y
+ XINT (dy
) <= min_y
)
5636 *root_y
= min_y
; /* Can happen for negative dy */
5637 else if (*root_y
+ XINT (dy
) + height
<= max_y
)
5638 /* It fits below the pointer */
5639 *root_y
+= XINT (dy
);
5640 else if (height
+ XINT (dy
) + min_y
<= *root_y
)
5641 /* It fits above the pointer. */
5642 *root_y
-= height
+ XINT (dy
);
5644 /* Put it on the top. */
5647 if (INTEGERP (left
))
5648 *root_x
= XINT (left
);
5649 else if (*root_x
+ XINT (dx
) <= min_x
)
5650 *root_x
= 0; /* Can happen for negative dx */
5651 else if (*root_x
+ XINT (dx
) + width
<= max_x
)
5652 /* It fits to the right of the pointer. */
5653 *root_x
+= XINT (dx
);
5654 else if (width
+ XINT (dx
) + min_x
<= *root_x
)
5655 /* It fits to the left of the pointer. */
5656 *root_x
-= width
+ XINT (dx
);
5658 /* Put it left justified on the screen -- it ought to fit that way. */
5663 DEFUN ("x-show-tip", Fx_show_tip
, Sx_show_tip
, 1, 6, 0,
5664 doc
: /* Show STRING in a \"tooltip\" window on frame FRAME.
5665 A tooltip window is a small window displaying a string.
5667 This is an internal function; Lisp code should call `tooltip-show'.
5669 FRAME nil or omitted means use the selected frame.
5671 PARMS is an optional list of frame parameters which can be
5672 used to change the tooltip's appearance.
5674 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
5675 means use the default timeout of 5 seconds.
5677 If the list of frame parameters PARMS contains a `left' parameter,
5678 the tooltip is displayed at that x-position. Otherwise it is
5679 displayed at the mouse position, with offset DX added (default is 5 if
5680 DX isn't specified). Likewise for the y-position; if a `top' frame
5681 parameter is specified, it determines the y-position of the tooltip
5682 window, otherwise it is displayed at the mouse position, with offset
5683 DY added (default is -10).
5685 A tooltip's maximum size is specified by `x-max-tooltip-size'.
5686 Text larger than the specified size is clipped. */)
5687 (string
, frame
, parms
, timeout
, dx
, dy
)
5688 Lisp_Object string
, frame
, parms
, timeout
, dx
, dy
;
5693 struct buffer
*old_buffer
;
5694 struct text_pos pos
;
5695 int i
, width
, height
;
5696 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
5697 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
5698 int count
= SPECPDL_INDEX ();
5700 specbind (Qinhibit_redisplay
, Qt
);
5702 GCPRO4 (string
, parms
, frame
, timeout
);
5704 CHECK_STRING (string
);
5705 f
= check_x_frame (frame
);
5707 timeout
= make_number (5);
5709 CHECK_NATNUM (timeout
);
5712 dx
= make_number (5);
5717 dy
= make_number (-10);
5721 if (NILP (last_show_tip_args
))
5722 last_show_tip_args
= Fmake_vector (make_number (3), Qnil
);
5724 if (!NILP (tip_frame
))
5726 Lisp_Object last_string
= AREF (last_show_tip_args
, 0);
5727 Lisp_Object last_frame
= AREF (last_show_tip_args
, 1);
5728 Lisp_Object last_parms
= AREF (last_show_tip_args
, 2);
5730 if (EQ (frame
, last_frame
)
5731 && !NILP (Fequal (last_string
, string
))
5732 && !NILP (Fequal (last_parms
, parms
)))
5734 struct frame
*f
= XFRAME (tip_frame
);
5736 /* Only DX and DY have changed. */
5737 if (!NILP (tip_timer
))
5739 Lisp_Object timer
= tip_timer
;
5741 call1 (Qcancel_timer
, timer
);
5745 compute_tip_xy (f
, parms
, dx
, dy
, FRAME_PIXEL_WIDTH (f
),
5746 FRAME_PIXEL_HEIGHT (f
), &root_x
, &root_y
);
5748 /* Put tooltip in topmost group and in position. */
5749 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOPMOST
,
5750 root_x
, root_y
, 0, 0,
5751 SWP_NOSIZE
| SWP_NOACTIVATE
);
5753 /* Ensure tooltip is on top of other topmost windows (eg menus). */
5754 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOP
,
5756 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5763 /* Hide a previous tip, if any. */
5766 ASET (last_show_tip_args
, 0, string
);
5767 ASET (last_show_tip_args
, 1, frame
);
5768 ASET (last_show_tip_args
, 2, parms
);
5770 /* Add default values to frame parameters. */
5771 if (NILP (Fassq (Qname
, parms
)))
5772 parms
= Fcons (Fcons (Qname
, build_string ("tooltip")), parms
);
5773 if (NILP (Fassq (Qinternal_border_width
, parms
)))
5774 parms
= Fcons (Fcons (Qinternal_border_width
, make_number (3)), parms
);
5775 if (NILP (Fassq (Qborder_width
, parms
)))
5776 parms
= Fcons (Fcons (Qborder_width
, make_number (1)), parms
);
5777 if (NILP (Fassq (Qborder_color
, parms
)))
5778 parms
= Fcons (Fcons (Qborder_color
, build_string ("lightyellow")), parms
);
5779 if (NILP (Fassq (Qbackground_color
, parms
)))
5780 parms
= Fcons (Fcons (Qbackground_color
, build_string ("lightyellow")),
5783 /* Block input until the tip has been fully drawn, to avoid crashes
5784 when drawing tips in menus. */
5787 /* Create a frame for the tooltip, and record it in the global
5788 variable tip_frame. */
5789 frame
= x_create_tip_frame (FRAME_W32_DISPLAY_INFO (f
), parms
, string
);
5792 /* Set up the frame's root window. */
5793 w
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5794 w
->left_col
= w
->top_line
= make_number (0);
5796 if (CONSP (Vx_max_tooltip_size
)
5797 && INTEGERP (XCAR (Vx_max_tooltip_size
))
5798 && XINT (XCAR (Vx_max_tooltip_size
)) > 0
5799 && INTEGERP (XCDR (Vx_max_tooltip_size
))
5800 && XINT (XCDR (Vx_max_tooltip_size
)) > 0)
5802 w
->total_cols
= XCAR (Vx_max_tooltip_size
);
5803 w
->total_lines
= XCDR (Vx_max_tooltip_size
);
5807 w
->total_cols
= make_number (80);
5808 w
->total_lines
= make_number (40);
5811 FRAME_TOTAL_COLS (f
) = XINT (w
->total_cols
);
5813 w
->pseudo_window_p
= 1;
5815 /* Display the tooltip text in a temporary buffer. */
5816 old_buffer
= current_buffer
;
5817 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f
))->buffer
));
5818 current_buffer
->truncate_lines
= Qnil
;
5819 clear_glyph_matrix (w
->desired_matrix
);
5820 clear_glyph_matrix (w
->current_matrix
);
5821 SET_TEXT_POS (pos
, BEGV
, BEGV_BYTE
);
5822 try_window (FRAME_ROOT_WINDOW (f
), pos
, 0);
5824 /* Compute width and height of the tooltip. */
5826 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
5828 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
5832 /* Stop at the first empty row at the end. */
5833 if (!row
->enabled_p
|| !row
->displays_text_p
)
5836 /* Let the row go over the full width of the frame. */
5837 row
->full_width_p
= 1;
5839 #ifdef TODO /* Investigate why some fonts need more width than is
5840 calculated for some tooltips. */
5841 /* There's a glyph at the end of rows that is use to place
5842 the cursor there. Don't include the width of this glyph. */
5843 if (row
->used
[TEXT_AREA
])
5845 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
5846 row_width
= row
->pixel_width
- last
->pixel_width
;
5850 row_width
= row
->pixel_width
;
5852 /* TODO: find why tips do not draw along baseline as instructed. */
5853 height
+= row
->height
;
5854 width
= max (width
, row_width
);
5857 /* Add the frame's internal border to the width and height the X
5858 window should have. */
5859 height
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
5860 width
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
5862 /* Move the tooltip window where the mouse pointer is. Resize and
5864 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, &root_x
, &root_y
);
5867 /* Adjust Window size to take border into account. */
5869 rect
.left
= rect
.top
= 0;
5871 rect
.bottom
= height
;
5872 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
5873 FRAME_EXTERNAL_MENU_BAR (f
));
5875 /* Position and size tooltip, and put it in the topmost group.
5876 The add-on of 3 to the 5th argument is a kludge: without it,
5877 some fonts cause the last character of the tip to be truncated,
5878 for some obscure reason. */
5879 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOPMOST
,
5880 root_x
, root_y
, rect
.right
- rect
.left
+ 3,
5881 rect
.bottom
- rect
.top
, SWP_NOACTIVATE
);
5883 /* Ensure tooltip is on top of other topmost windows (eg menus). */
5884 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOP
,
5886 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5888 /* Let redisplay know that we have made the frame visible already. */
5889 f
->async_visible
= 1;
5891 ShowWindow (FRAME_W32_WINDOW (f
), SW_SHOWNOACTIVATE
);
5894 /* Draw into the window. */
5895 w
->must_be_updated_p
= 1;
5896 update_single_window (w
, 1);
5900 /* Restore original current buffer. */
5901 set_buffer_internal_1 (old_buffer
);
5902 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
5905 /* Let the tip disappear after timeout seconds. */
5906 tip_timer
= call3 (intern ("run-at-time"), timeout
, Qnil
,
5907 intern ("x-hide-tip"));
5910 return unbind_to (count
, Qnil
);
5914 DEFUN ("x-hide-tip", Fx_hide_tip
, Sx_hide_tip
, 0, 0, 0,
5915 doc
: /* Hide the current tooltip window, if there is any.
5916 Value is t if tooltip was open, nil otherwise. */)
5920 Lisp_Object deleted
, frame
, timer
;
5921 struct gcpro gcpro1
, gcpro2
;
5923 /* Return quickly if nothing to do. */
5924 if (NILP (tip_timer
) && NILP (tip_frame
))
5929 GCPRO2 (frame
, timer
);
5930 tip_frame
= tip_timer
= deleted
= Qnil
;
5932 count
= SPECPDL_INDEX ();
5933 specbind (Qinhibit_redisplay
, Qt
);
5934 specbind (Qinhibit_quit
, Qt
);
5937 call1 (Qcancel_timer
, timer
);
5941 Fdelete_frame (frame
, Qnil
);
5946 return unbind_to (count
, deleted
);
5951 /***********************************************************************
5952 File selection dialog
5953 ***********************************************************************/
5954 extern Lisp_Object Qfile_name_history
;
5956 /* Callback for altering the behavior of the Open File dialog.
5957 Makes the Filename text field contain "Current Directory" and be
5958 read-only when "Directories" is selected in the filter. This
5959 allows us to work around the fact that the standard Open File
5960 dialog does not support directories. */
5962 file_dialog_callback (hwnd
, msg
, wParam
, lParam
)
5968 if (msg
== WM_NOTIFY
)
5970 OFNOTIFY
* notify
= (OFNOTIFY
*)lParam
;
5971 /* Detect when the Filter dropdown is changed. */
5972 if (notify
->hdr
.code
== CDN_TYPECHANGE
5973 || notify
->hdr
.code
== CDN_INITDONE
)
5975 HWND dialog
= GetParent (hwnd
);
5976 HWND edit_control
= GetDlgItem (dialog
, FILE_NAME_TEXT_FIELD
);
5978 /* Directories is in index 2. */
5979 if (notify
->lpOFN
->nFilterIndex
== 2)
5981 CommDlg_OpenSave_SetControlText (dialog
, FILE_NAME_TEXT_FIELD
,
5982 "Current Directory");
5983 EnableWindow (edit_control
, FALSE
);
5987 /* Don't override default filename on init done. */
5988 if (notify
->hdr
.code
== CDN_TYPECHANGE
)
5989 CommDlg_OpenSave_SetControlText (dialog
,
5990 FILE_NAME_TEXT_FIELD
, "");
5991 EnableWindow (edit_control
, TRUE
);
5998 /* Since we compile with _WIN32_WINNT set to 0x0400 (for NT4 compatibility)
5999 we end up with the old file dialogs. Define a big enough struct for the
6000 new dialog to trick GetOpenFileName into giving us the new dialogs on
6001 Windows 2000 and XP. */
6004 OPENFILENAME real_details
;
6011 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 5, 0,
6012 doc
: /* Read file name, prompting with PROMPT in directory DIR.
6013 Use a file selection dialog.
6014 Select DEFAULT-FILENAME in the dialog's file selection box, if
6015 specified. Ensure that file exists if MUSTMATCH is non-nil.
6016 If ONLY-DIR-P is non-nil, the user can only select directories. */)
6017 (prompt
, dir
, default_filename
, mustmatch
, only_dir_p
)
6018 Lisp_Object prompt
, dir
, default_filename
, mustmatch
, only_dir_p
;
6020 struct frame
*f
= SELECTED_FRAME ();
6021 Lisp_Object file
= Qnil
;
6022 int count
= SPECPDL_INDEX ();
6023 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
6024 char filename
[MAX_PATH
+ 1];
6025 char init_dir
[MAX_PATH
+ 1];
6026 int default_filter_index
= 1; /* 1: All Files, 2: Directories only */
6028 GCPRO6 (prompt
, dir
, default_filename
, mustmatch
, only_dir_p
, file
);
6029 CHECK_STRING (prompt
);
6032 /* Create the dialog with PROMPT as title, using DIR as initial
6033 directory and using "*" as pattern. */
6034 dir
= Fexpand_file_name (dir
, Qnil
);
6035 strncpy (init_dir
, SDATA (ENCODE_FILE (dir
)), MAX_PATH
);
6036 init_dir
[MAX_PATH
] = '\0';
6037 unixtodos_filename (init_dir
);
6039 if (STRINGP (default_filename
))
6041 char *file_name_only
;
6042 char *full_path_name
= SDATA (ENCODE_FILE (default_filename
));
6044 unixtodos_filename (full_path_name
);
6046 file_name_only
= strrchr (full_path_name
, '\\');
6047 if (!file_name_only
)
6048 file_name_only
= full_path_name
;
6052 strncpy (filename
, file_name_only
, MAX_PATH
);
6053 filename
[MAX_PATH
] = '\0';
6059 NEWOPENFILENAME new_file_details
;
6060 BOOL file_opened
= FALSE
;
6061 OPENFILENAME
* file_details
= &new_file_details
.real_details
;
6063 /* Prevent redisplay. */
6064 specbind (Qinhibit_redisplay
, Qt
);
6067 bzero (&new_file_details
, sizeof (new_file_details
));
6068 /* Apparently NT4 crashes if you give it an unexpected size.
6069 I'm not sure about Windows 9x, so play it safe. */
6070 if (w32_major_version
> 4 && w32_major_version
< 95)
6071 file_details
->lStructSize
= sizeof (NEWOPENFILENAME
);
6073 file_details
->lStructSize
= sizeof (OPENFILENAME
);
6075 file_details
->hwndOwner
= FRAME_W32_WINDOW (f
);
6076 /* Undocumented Bug in Common File Dialog:
6077 If a filter is not specified, shell links are not resolved. */
6078 file_details
->lpstrFilter
= "All Files (*.*)\0*.*\0Directories\0*|*\0\0";
6079 file_details
->lpstrFile
= filename
;
6080 file_details
->nMaxFile
= sizeof (filename
);
6081 file_details
->lpstrInitialDir
= init_dir
;
6082 file_details
->lpstrTitle
= SDATA (prompt
);
6084 if (! NILP (only_dir_p
))
6085 default_filter_index
= 2;
6087 file_details
->nFilterIndex
= default_filter_index
;
6089 file_details
->Flags
= (OFN_HIDEREADONLY
| OFN_NOCHANGEDIR
6090 | OFN_EXPLORER
| OFN_ENABLEHOOK
);
6091 if (!NILP (mustmatch
))
6093 /* Require that the path to the parent directory exists. */
6094 file_details
->Flags
|= OFN_PATHMUSTEXIST
;
6095 /* If we are looking for a file, require that it exists. */
6096 if (NILP (only_dir_p
))
6097 file_details
->Flags
|= OFN_FILEMUSTEXIST
;
6100 file_details
->lpfnHook
= (LPOFNHOOKPROC
) file_dialog_callback
;
6102 file_opened
= GetOpenFileName (file_details
);
6108 dostounix_filename (filename
);
6110 if (file_details
->nFilterIndex
== 2)
6112 /* "Directories" selected - strip dummy file name. */
6113 char * last
= strrchr (filename
, '/');
6117 file
= DECODE_FILE (build_string (filename
));
6119 /* User cancelled the dialog without making a selection. */
6120 else if (!CommDlgExtendedError ())
6122 /* An error occurred, fallback on reading from the mini-buffer. */
6124 file
= Fcompleting_read (prompt
, intern ("read-file-name-internal"),
6125 dir
, mustmatch
, dir
, Qfile_name_history
,
6126 default_filename
, Qnil
);
6128 file
= unbind_to (count
, file
);
6133 /* Make "Cancel" equivalent to C-g. */
6135 Fsignal (Qquit
, Qnil
);
6137 return unbind_to (count
, file
);
6141 /* Moving files to the system recycle bin.
6142 Used by `move-file-to-trash' instead of the default moving to ~/.Trash */
6143 DEFUN ("system-move-file-to-trash", Fsystem_move_file_to_trash
,
6144 Ssystem_move_file_to_trash
, 1, 1, 0,
6145 doc
: /* Move file or directory named FILENAME to the recycle bin. */)
6147 Lisp_Object filename
;
6149 Lisp_Object handler
;
6150 Lisp_Object encoded_file
;
6151 Lisp_Object operation
;
6153 operation
= Qdelete_file
;
6154 if (!NILP (Ffile_directory_p (filename
))
6155 && NILP (Ffile_symlink_p (filename
)))
6157 operation
= Qdelete_directory
;
6158 filename
= Fdirectory_file_name (filename
);
6160 filename
= Fexpand_file_name (filename
, Qnil
);
6162 handler
= Ffind_file_name_handler (filename
, operation
);
6163 if (!NILP (handler
))
6164 return call2 (handler
, operation
, filename
);
6166 encoded_file
= ENCODE_FILE (filename
);
6170 SHFILEOPSTRUCT file_op
;
6171 char tmp_path
[MAX_PATH
+ 1];
6173 path
= map_w32_filename (SDATA (encoded_file
), NULL
);
6175 /* On Windows, write permission is required to delete/move files. */
6176 _chmod (path
, 0666);
6178 bzero (tmp_path
, sizeof (tmp_path
));
6179 strcpy (tmp_path
, path
);
6181 bzero (&file_op
, sizeof (file_op
));
6182 file_op
.hwnd
= HWND_DESKTOP
;
6183 file_op
.wFunc
= FO_DELETE
;
6184 file_op
.pFrom
= tmp_path
;
6185 file_op
.fFlags
= FOF_SILENT
| FOF_NOCONFIRMATION
| FOF_ALLOWUNDO
6186 | FOF_NOERRORUI
| FOF_NO_CONNECTED_ELEMENTS
;
6187 file_op
.fAnyOperationsAborted
= FALSE
;
6189 if (SHFileOperation (&file_op
) != 0)
6190 report_file_error ("Removing old name", list1 (filename
));
6196 /***********************************************************************
6197 w32 specialized functions
6198 ***********************************************************************/
6200 DEFUN ("w32-send-sys-command", Fw32_send_sys_command
,
6201 Sw32_send_sys_command
, 1, 2, 0,
6202 doc
: /* Send frame a Windows WM_SYSCOMMAND message of type COMMAND.
6203 Some useful values for COMMAND are #xf030 to maximize frame (#xf020
6204 to minimize), #xf120 to restore frame to original size, and #xf100
6205 to activate the menubar for keyboard access. #xf140 activates the
6206 screen saver if defined.
6208 If optional parameter FRAME is not specified, use selected frame. */)
6210 Lisp_Object command
, frame
;
6212 FRAME_PTR f
= check_x_frame (frame
);
6214 CHECK_NUMBER (command
);
6216 PostMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, XINT (command
), 0);
6221 DEFUN ("w32-shell-execute", Fw32_shell_execute
, Sw32_shell_execute
, 2, 4, 0,
6222 doc
: /* Get Windows to perform OPERATION on DOCUMENT.
6223 This is a wrapper around the ShellExecute system function, which
6224 invokes the application registered to handle OPERATION for DOCUMENT.
6226 OPERATION is either nil or a string that names a supported operation.
6227 What operations can be used depends on the particular DOCUMENT and its
6228 handler application, but typically it is one of the following common
6231 \"open\" - open DOCUMENT, which could be a file, a directory, or an
6232 executable program. If it is an application, that
6233 application is launched in the current buffer's default
6234 directory. Otherwise, the application associated with
6235 DOCUMENT is launched in the buffer's default directory.
6236 \"print\" - print DOCUMENT, which must be a file
6237 \"explore\" - start the Windows Explorer on DOCUMENT
6238 \"edit\" - launch an editor and open DOCUMENT for editing; which
6239 editor is launched depends on the association for the
6241 \"find\" - initiate search starting from DOCUMENT which must specify
6243 nil - invoke the default OPERATION, or \"open\" if default is
6244 not defined or unavailable
6246 DOCUMENT is typically the name of a document file or a URL, but can
6247 also be a program executable to run, or a directory to open in the
6250 If DOCUMENT is a program executable, the optional third arg PARAMETERS
6251 can be a string containing command line parameters that will be passed
6252 to the program; otherwise, PARAMETERS should be nil or unspecified.
6254 Optional fourth argument SHOW-FLAG can be used to control how the
6255 application will be displayed when it is invoked. If SHOW-FLAG is nil
6256 or unspecified, the application is displayed normally, otherwise it is
6257 an integer representing a ShowWindow flag:
6262 6 - start minimized */)
6263 (operation
, document
, parameters
, show_flag
)
6264 Lisp_Object operation
, document
, parameters
, show_flag
;
6266 Lisp_Object current_dir
;
6268 CHECK_STRING (document
);
6270 /* Encode filename, current directory and parameters. */
6271 current_dir
= ENCODE_FILE (current_buffer
->directory
);
6272 document
= ENCODE_FILE (document
);
6273 if (STRINGP (parameters
))
6274 parameters
= ENCODE_SYSTEM (parameters
);
6276 if ((int) ShellExecute (NULL
,
6277 (STRINGP (operation
) ?
6278 SDATA (operation
) : NULL
),
6280 (STRINGP (parameters
) ?
6281 SDATA (parameters
) : NULL
),
6282 SDATA (current_dir
),
6283 (INTEGERP (show_flag
) ?
6284 XINT (show_flag
) : SW_SHOWDEFAULT
))
6287 error ("ShellExecute failed: %s", w32_strerror (0));
6290 /* Lookup virtual keycode from string representing the name of a
6291 non-ascii keystroke into the corresponding virtual key, using
6292 lispy_function_keys. */
6294 lookup_vk_code (char *key
)
6298 for (i
= 0; i
< 256; i
++)
6299 if (lispy_function_keys
[i
]
6300 && strcmp (lispy_function_keys
[i
], key
) == 0)
6306 /* Convert a one-element vector style key sequence to a hot key
6309 w32_parse_hot_key (key
)
6312 /* Copied from Fdefine_key and store_in_keymap. */
6313 register Lisp_Object c
;
6317 struct gcpro gcpro1
;
6321 if (XFASTINT (Flength (key
)) != 1)
6326 c
= Faref (key
, make_number (0));
6328 if (CONSP (c
) && lucid_event_type_list_p (c
))
6329 c
= Fevent_convert_list (c
);
6333 if (! INTEGERP (c
) && ! SYMBOLP (c
))
6334 error ("Key definition is invalid");
6336 /* Work out the base key and the modifiers. */
6339 c
= parse_modifiers (c
);
6340 lisp_modifiers
= XINT (Fcar (Fcdr (c
)));
6344 vk_code
= lookup_vk_code (SDATA (SYMBOL_NAME (c
)));
6346 else if (INTEGERP (c
))
6348 lisp_modifiers
= XINT (c
) & ~CHARACTERBITS
;
6349 /* Many ascii characters are their own virtual key code. */
6350 vk_code
= XINT (c
) & CHARACTERBITS
;
6353 if (vk_code
< 0 || vk_code
> 255)
6356 if ((lisp_modifiers
& meta_modifier
) != 0
6357 && !NILP (Vw32_alt_is_meta
))
6358 lisp_modifiers
|= alt_modifier
;
6360 /* Supply defs missing from mingw32. */
6362 #define MOD_ALT 0x0001
6363 #define MOD_CONTROL 0x0002
6364 #define MOD_SHIFT 0x0004
6365 #define MOD_WIN 0x0008
6368 /* Convert lisp modifiers to Windows hot-key form. */
6369 w32_modifiers
= (lisp_modifiers
& hyper_modifier
) ? MOD_WIN
: 0;
6370 w32_modifiers
|= (lisp_modifiers
& alt_modifier
) ? MOD_ALT
: 0;
6371 w32_modifiers
|= (lisp_modifiers
& ctrl_modifier
) ? MOD_CONTROL
: 0;
6372 w32_modifiers
|= (lisp_modifiers
& shift_modifier
) ? MOD_SHIFT
: 0;
6374 return HOTKEY (vk_code
, w32_modifiers
);
6377 DEFUN ("w32-register-hot-key", Fw32_register_hot_key
,
6378 Sw32_register_hot_key
, 1, 1, 0,
6379 doc
: /* Register KEY as a hot-key combination.
6380 Certain key combinations like Alt-Tab are reserved for system use on
6381 Windows, and therefore are normally intercepted by the system. However,
6382 most of these key combinations can be received by registering them as
6383 hot-keys, overriding their special meaning.
6385 KEY must be a one element key definition in vector form that would be
6386 acceptable to `define-key' (e.g. [A-tab] for Alt-Tab). The meta
6387 modifier is interpreted as Alt if `w32-alt-is-meta' is t, and hyper
6388 is always interpreted as the Windows modifier keys.
6390 The return value is the hotkey-id if registered, otherwise nil. */)
6394 key
= w32_parse_hot_key (key
);
6396 if (!NILP (key
) && NILP (Fmemq (key
, w32_grabbed_keys
)))
6398 /* Reuse an empty slot if possible. */
6399 Lisp_Object item
= Fmemq (Qnil
, w32_grabbed_keys
);
6401 /* Safe to add new key to list, even if we have focus. */
6403 w32_grabbed_keys
= Fcons (key
, w32_grabbed_keys
);
6405 XSETCAR (item
, key
);
6407 /* Notify input thread about new hot-key definition, so that it
6408 takes effect without needing to switch focus. */
6409 #ifdef USE_LISP_UNION_TYPE
6410 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_REGISTER_HOT_KEY
,
6413 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_REGISTER_HOT_KEY
,
6421 DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key
,
6422 Sw32_unregister_hot_key
, 1, 1, 0,
6423 doc
: /* Unregister KEY as a hot-key combination. */)
6429 if (!INTEGERP (key
))
6430 key
= w32_parse_hot_key (key
);
6432 item
= Fmemq (key
, w32_grabbed_keys
);
6436 /* Notify input thread about hot-key definition being removed, so
6437 that it takes effect without needing focus switch. */
6438 #ifdef USE_LISP_UNION_TYPE
6439 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_UNREGISTER_HOT_KEY
,
6440 (WPARAM
) XINT (XCAR (item
)), (LPARAM
) item
.i
))
6442 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_UNREGISTER_HOT_KEY
,
6443 (WPARAM
) XINT (XCAR (item
)), (LPARAM
) item
))
6447 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6454 DEFUN ("w32-registered-hot-keys", Fw32_registered_hot_keys
,
6455 Sw32_registered_hot_keys
, 0, 0, 0,
6456 doc
: /* Return list of registered hot-key IDs. */)
6459 return Fdelq (Qnil
, Fcopy_sequence (w32_grabbed_keys
));
6462 DEFUN ("w32-reconstruct-hot-key", Fw32_reconstruct_hot_key
,
6463 Sw32_reconstruct_hot_key
, 1, 1, 0,
6464 doc
: /* Convert hot-key ID to a lisp key combination.
6465 usage: (w32-reconstruct-hot-key ID) */)
6467 Lisp_Object hotkeyid
;
6469 int vk_code
, w32_modifiers
;
6472 CHECK_NUMBER (hotkeyid
);
6474 vk_code
= HOTKEY_VK_CODE (hotkeyid
);
6475 w32_modifiers
= HOTKEY_MODIFIERS (hotkeyid
);
6477 if (vk_code
< 256 && lispy_function_keys
[vk_code
])
6478 key
= intern (lispy_function_keys
[vk_code
]);
6480 key
= make_number (vk_code
);
6482 key
= Fcons (key
, Qnil
);
6483 if (w32_modifiers
& MOD_SHIFT
)
6484 key
= Fcons (Qshift
, key
);
6485 if (w32_modifiers
& MOD_CONTROL
)
6486 key
= Fcons (Qctrl
, key
);
6487 if (w32_modifiers
& MOD_ALT
)
6488 key
= Fcons (NILP (Vw32_alt_is_meta
) ? Qalt
: Qmeta
, key
);
6489 if (w32_modifiers
& MOD_WIN
)
6490 key
= Fcons (Qhyper
, key
);
6495 DEFUN ("w32-toggle-lock-key", Fw32_toggle_lock_key
,
6496 Sw32_toggle_lock_key
, 1, 2, 0,
6497 doc
: /* Toggle the state of the lock key KEY.
6498 KEY can be `capslock', `kp-numlock', or `scroll'.
6499 If the optional parameter NEW-STATE is a number, then the state of KEY
6500 is set to off if the low bit of NEW-STATE is zero, otherwise on. */)
6502 Lisp_Object key
, new_state
;
6506 if (EQ (key
, intern ("capslock")))
6507 vk_code
= VK_CAPITAL
;
6508 else if (EQ (key
, intern ("kp-numlock")))
6509 vk_code
= VK_NUMLOCK
;
6510 else if (EQ (key
, intern ("scroll")))
6511 vk_code
= VK_SCROLL
;
6515 if (!dwWindowsThreadId
)
6516 return make_number (w32_console_toggle_lock_key (vk_code
, new_state
));
6518 #ifdef USE_LISP_UNION_TYPE
6519 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_TOGGLE_LOCK_KEY
,
6520 (WPARAM
) vk_code
, (LPARAM
) new_state
.i
))
6522 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_TOGGLE_LOCK_KEY
,
6523 (WPARAM
) vk_code
, (LPARAM
) new_state
))
6527 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6528 return make_number (msg
.wParam
);
6533 DEFUN ("w32-window-exists-p", Fw32_window_exists_p
, Sw32_window_exists_p
,
6535 doc
: /* Return non-nil if a window exists with the specified CLASS and NAME.
6537 This is a direct interface to the Windows API FindWindow function. */)
6539 Lisp_Object
class, name
;
6544 CHECK_STRING (class);
6546 CHECK_STRING (name
);
6548 hnd
= FindWindow (STRINGP (class) ? ((LPCTSTR
) SDATA (class)) : NULL
,
6549 STRINGP (name
) ? ((LPCTSTR
) SDATA (name
)) : NULL
);
6555 DEFUN ("w32-battery-status", Fw32_battery_status
, Sw32_battery_status
, 0, 0, 0,
6556 doc
: /* Get power status information from Windows system.
6558 The following %-sequences are provided:
6559 %L AC line status (verbose)
6560 %B Battery status (verbose)
6561 %b Battery status, empty means high, `-' means low,
6562 `!' means critical, and `+' means charging
6563 %p Battery load percentage
6564 %s Remaining time (to charge or discharge) in seconds
6565 %m Remaining time (to charge or discharge) in minutes
6566 %h Remaining time (to charge or discharge) in hours
6567 %t Remaining time (to charge or discharge) in the form `h:min' */)
6570 Lisp_Object status
= Qnil
;
6572 SYSTEM_POWER_STATUS system_status
;
6573 if (GetSystemPowerStatus (&system_status
))
6575 Lisp_Object line_status
, battery_status
, battery_status_symbol
;
6576 Lisp_Object load_percentage
, seconds
, minutes
, hours
, remain
;
6577 Lisp_Object sequences
[8];
6579 long seconds_left
= (long) system_status
.BatteryLifeTime
;
6581 if (system_status
.ACLineStatus
== 0)
6582 line_status
= build_string ("off-line");
6583 else if (system_status
.ACLineStatus
== 1)
6584 line_status
= build_string ("on-line");
6586 line_status
= build_string ("N/A");
6588 if (system_status
.BatteryFlag
& 128)
6590 battery_status
= build_string ("N/A");
6591 battery_status_symbol
= build_string ("");
6593 else if (system_status
.BatteryFlag
& 8)
6595 battery_status
= build_string ("charging");
6596 battery_status_symbol
= build_string ("+");
6597 if (system_status
.BatteryFullLifeTime
!= -1L)
6598 seconds_left
= system_status
.BatteryFullLifeTime
- seconds_left
;
6600 else if (system_status
.BatteryFlag
& 4)
6602 battery_status
= build_string ("critical");
6603 battery_status_symbol
= build_string ("!");
6605 else if (system_status
.BatteryFlag
& 2)
6607 battery_status
= build_string ("low");
6608 battery_status_symbol
= build_string ("-");
6610 else if (system_status
.BatteryFlag
& 1)
6612 battery_status
= build_string ("high");
6613 battery_status_symbol
= build_string ("");
6617 battery_status
= build_string ("medium");
6618 battery_status_symbol
= build_string ("");
6621 if (system_status
.BatteryLifePercent
> 100)
6622 load_percentage
= build_string ("N/A");
6626 _snprintf (buffer
, 16, "%d", system_status
.BatteryLifePercent
);
6627 load_percentage
= build_string (buffer
);
6630 if (seconds_left
< 0)
6631 seconds
= minutes
= hours
= remain
= build_string ("N/A");
6637 _snprintf (buffer
, 16, "%ld", seconds_left
);
6638 seconds
= build_string (buffer
);
6640 m
= seconds_left
/ 60;
6641 _snprintf (buffer
, 16, "%ld", m
);
6642 minutes
= build_string (buffer
);
6644 h
= seconds_left
/ 3600.0;
6645 _snprintf (buffer
, 16, "%3.1f", h
);
6646 hours
= build_string (buffer
);
6648 _snprintf (buffer
, 16, "%ld:%02ld", m
/ 60, m
% 60);
6649 remain
= build_string (buffer
);
6651 sequences
[0] = Fcons (make_number ('L'), line_status
);
6652 sequences
[1] = Fcons (make_number ('B'), battery_status
);
6653 sequences
[2] = Fcons (make_number ('b'), battery_status_symbol
);
6654 sequences
[3] = Fcons (make_number ('p'), load_percentage
);
6655 sequences
[4] = Fcons (make_number ('s'), seconds
);
6656 sequences
[5] = Fcons (make_number ('m'), minutes
);
6657 sequences
[6] = Fcons (make_number ('h'), hours
);
6658 sequences
[7] = Fcons (make_number ('t'), remain
);
6660 status
= Flist (8, sequences
);
6666 DEFUN ("file-system-info", Ffile_system_info
, Sfile_system_info
, 1, 1, 0,
6667 doc
: /* Return storage information about the file system FILENAME is on.
6668 Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total
6669 storage of the file system, FREE is the free storage, and AVAIL is the
6670 storage available to a non-superuser. All 3 numbers are in bytes.
6671 If the underlying system call fails, value is nil. */)
6673 Lisp_Object filename
;
6675 Lisp_Object encoded
, value
;
6677 CHECK_STRING (filename
);
6678 filename
= Fexpand_file_name (filename
, Qnil
);
6679 encoded
= ENCODE_FILE (filename
);
6683 /* Determining the required information on Windows turns out, sadly,
6684 to be more involved than one would hope. The original Win32 api
6685 call for this will return bogus information on some systems, but we
6686 must dynamically probe for the replacement api, since that was
6687 added rather late on. */
6689 HMODULE hKernel
= GetModuleHandle ("kernel32");
6690 BOOL (*pfn_GetDiskFreeSpaceEx
)
6691 (char *, PULARGE_INTEGER
, PULARGE_INTEGER
, PULARGE_INTEGER
)
6692 = (void *) GetProcAddress (hKernel
, "GetDiskFreeSpaceEx");
6694 /* On Windows, we may need to specify the root directory of the
6695 volume holding FILENAME. */
6696 char rootname
[MAX_PATH
];
6697 char *name
= SDATA (encoded
);
6699 /* find the root name of the volume if given */
6700 if (isalpha (name
[0]) && name
[1] == ':')
6702 rootname
[0] = name
[0];
6703 rootname
[1] = name
[1];
6707 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
6709 char *str
= rootname
;
6713 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
6723 if (pfn_GetDiskFreeSpaceEx
)
6725 /* Unsigned large integers cannot be cast to double, so
6726 use signed ones instead. */
6727 LARGE_INTEGER availbytes
;
6728 LARGE_INTEGER freebytes
;
6729 LARGE_INTEGER totalbytes
;
6731 if (pfn_GetDiskFreeSpaceEx (rootname
,
6732 (ULARGE_INTEGER
*)&availbytes
,
6733 (ULARGE_INTEGER
*)&totalbytes
,
6734 (ULARGE_INTEGER
*)&freebytes
))
6735 value
= list3 (make_float ((double) totalbytes
.QuadPart
),
6736 make_float ((double) freebytes
.QuadPart
),
6737 make_float ((double) availbytes
.QuadPart
));
6741 DWORD sectors_per_cluster
;
6742 DWORD bytes_per_sector
;
6743 DWORD free_clusters
;
6744 DWORD total_clusters
;
6746 if (GetDiskFreeSpace (rootname
,
6747 §ors_per_cluster
,
6751 value
= list3 (make_float ((double) total_clusters
6752 * sectors_per_cluster
* bytes_per_sector
),
6753 make_float ((double) free_clusters
6754 * sectors_per_cluster
* bytes_per_sector
),
6755 make_float ((double) free_clusters
6756 * sectors_per_cluster
* bytes_per_sector
));
6763 DEFUN ("default-printer-name", Fdefault_printer_name
, Sdefault_printer_name
,
6764 0, 0, 0, doc
: /* Return the name of Windows default printer device. */)
6767 static char pname_buf
[256];
6770 PRINTER_INFO_2
*ppi2
= NULL
;
6771 DWORD dwNeeded
= 0, dwReturned
= 0;
6773 /* Retrieve the default string from Win.ini (the registry).
6774 * String will be in form "printername,drivername,portname".
6775 * This is the most portable way to get the default printer. */
6776 if (GetProfileString ("windows", "device", ",,", pname_buf
, sizeof (pname_buf
)) <= 0)
6778 /* printername precedes first "," character */
6779 strtok (pname_buf
, ",");
6780 /* We want to know more than the printer name */
6781 if (!OpenPrinter (pname_buf
, &hPrn
, NULL
))
6783 GetPrinter (hPrn
, 2, NULL
, 0, &dwNeeded
);
6786 ClosePrinter (hPrn
);
6789 /* Allocate memory for the PRINTER_INFO_2 struct */
6790 ppi2
= (PRINTER_INFO_2
*) xmalloc (dwNeeded
);
6793 ClosePrinter (hPrn
);
6796 /* Call GetPrinter again with big enouth memory block */
6797 err
= GetPrinter (hPrn
, 2, (LPBYTE
)ppi2
, dwNeeded
, &dwReturned
);
6798 ClosePrinter (hPrn
);
6807 if (ppi2
->Attributes
& PRINTER_ATTRIBUTE_SHARED
&& ppi2
->pServerName
)
6809 /* a remote printer */
6810 if (*ppi2
->pServerName
== '\\')
6811 _snprintf (pname_buf
, sizeof (pname_buf
), "%s\\%s", ppi2
->pServerName
,
6814 _snprintf (pname_buf
, sizeof (pname_buf
), "\\\\%s\\%s", ppi2
->pServerName
,
6816 pname_buf
[sizeof (pname_buf
) - 1] = '\0';
6820 /* a local printer */
6821 strncpy (pname_buf
, ppi2
->pPortName
, sizeof (pname_buf
));
6822 pname_buf
[sizeof (pname_buf
) - 1] = '\0';
6823 /* `pPortName' can include several ports, delimited by ','.
6824 * we only use the first one. */
6825 strtok (pname_buf
, ",");
6830 return build_string (pname_buf
);
6833 /***********************************************************************
6835 ***********************************************************************/
6837 /* Keep this list in the same order as frame_parms in frame.c.
6838 Use 0 for unsupported frame parameters. */
6840 frame_parm_handler w32_frame_parm_handlers
[] =
6844 x_set_background_color
,
6850 x_set_foreground_color
,
6853 x_set_internal_border_width
,
6854 x_set_menu_bar_lines
,
6856 x_explicitly_set_name
,
6857 x_set_scroll_bar_width
,
6860 x_set_vertical_scroll_bars
,
6862 x_set_tool_bar_lines
,
6863 0, /* x_set_scroll_bar_foreground, */
6864 0, /* x_set_scroll_bar_background, */
6869 0, /* x_set_wait_for_wm, */
6878 globals_of_w32fns ();
6879 /* This is zero if not using MS-Windows. */
6881 track_mouse_window
= NULL
;
6883 w32_visible_system_caret_hwnd
= NULL
;
6885 DEFSYM (Qnone
, "none");
6886 DEFSYM (Qsuppress_icon
, "suppress-icon");
6887 DEFSYM (Qundefined_color
, "undefined-color");
6888 DEFSYM (Qcancel_timer
, "cancel-timer");
6889 DEFSYM (Qhyper
, "hyper");
6890 DEFSYM (Qsuper
, "super");
6891 DEFSYM (Qmeta
, "meta");
6892 DEFSYM (Qalt
, "alt");
6893 DEFSYM (Qctrl
, "ctrl");
6894 DEFSYM (Qcontrol
, "control");
6895 DEFSYM (Qshift
, "shift");
6896 DEFSYM (Qfont_param
, "font-parameter");
6897 /* This is the end of symbol initialization. */
6899 /* Text property `display' should be nonsticky by default. */
6900 Vtext_property_default_nonsticky
6901 = Fcons (Fcons (Qdisplay
, Qt
), Vtext_property_default_nonsticky
);
6904 Fput (Qundefined_color
, Qerror_conditions
,
6905 Fcons (Qundefined_color
, Fcons (Qerror
, Qnil
)));
6906 Fput (Qundefined_color
, Qerror_message
,
6907 build_string ("Undefined color"));
6909 staticpro (&w32_grabbed_keys
);
6910 w32_grabbed_keys
= Qnil
;
6912 DEFVAR_LISP ("w32-color-map", &Vw32_color_map
,
6913 doc
: /* An array of color name mappings for Windows. */);
6914 Vw32_color_map
= Qnil
;
6916 DEFVAR_LISP ("w32-pass-alt-to-system", &Vw32_pass_alt_to_system
,
6917 doc
: /* Non-nil if Alt key presses are passed on to Windows.
6918 When non-nil, for example, Alt pressed and released and then space will
6919 open the System menu. When nil, Emacs processes the Alt key events, and
6920 then silently swallows them. */);
6921 Vw32_pass_alt_to_system
= Qnil
;
6923 DEFVAR_LISP ("w32-alt-is-meta", &Vw32_alt_is_meta
,
6924 doc
: /* Non-nil if the Alt key is to be considered the same as the META key.
6925 When nil, Emacs will translate the Alt key to the ALT modifier, not to META. */);
6926 Vw32_alt_is_meta
= Qt
;
6928 DEFVAR_INT ("w32-quit-key", &w32_quit_key
,
6929 doc
: /* If non-zero, the virtual key code for an alternative quit key. */);
6932 DEFVAR_LISP ("w32-pass-lwindow-to-system",
6933 &Vw32_pass_lwindow_to_system
,
6934 doc
: /* If non-nil, the left \"Windows\" key is passed on to Windows.
6936 When non-nil, the Start menu is opened by tapping the key.
6937 If you set this to nil, the left \"Windows\" key is processed by Emacs
6938 according to the value of `w32-lwindow-modifier', which see.
6940 Note that some combinations of the left \"Windows\" key with other keys are
6941 caught by Windows at low level, and so binding them in Emacs will have no
6942 effect. For example, <lwindow>-r always pops up the Windows Run dialog,
6943 <lwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
6944 the doc string of `w32-phantom-key-code'. */);
6945 Vw32_pass_lwindow_to_system
= Qt
;
6947 DEFVAR_LISP ("w32-pass-rwindow-to-system",
6948 &Vw32_pass_rwindow_to_system
,
6949 doc
: /* If non-nil, the right \"Windows\" key is passed on to Windows.
6951 When non-nil, the Start menu is opened by tapping the key.
6952 If you set this to nil, the right \"Windows\" key is processed by Emacs
6953 according to the value of `w32-rwindow-modifier', which see.
6955 Note that some combinations of the right \"Windows\" key with other keys are
6956 caught by Windows at low level, and so binding them in Emacs will have no
6957 effect. For example, <rwindow>-r always pops up the Windows Run dialog,
6958 <rwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
6959 the doc string of `w32-phantom-key-code'. */);
6960 Vw32_pass_rwindow_to_system
= Qt
;
6962 DEFVAR_LISP ("w32-phantom-key-code",
6963 &Vw32_phantom_key_code
,
6964 doc
: /* Virtual key code used to generate \"phantom\" key presses.
6965 Value is a number between 0 and 255.
6967 Phantom key presses are generated in order to stop the system from
6968 acting on \"Windows\" key events when `w32-pass-lwindow-to-system' or
6969 `w32-pass-rwindow-to-system' is nil. */);
6970 /* Although 255 is technically not a valid key code, it works and
6971 means that this hack won't interfere with any real key code. */
6972 XSETINT (Vw32_phantom_key_code
, 255);
6974 DEFVAR_LISP ("w32-enable-num-lock",
6975 &Vw32_enable_num_lock
,
6976 doc
: /* If non-nil, the Num Lock key acts normally.
6977 Set to nil to handle Num Lock as the `kp-numlock' key. */);
6978 Vw32_enable_num_lock
= Qt
;
6980 DEFVAR_LISP ("w32-enable-caps-lock",
6981 &Vw32_enable_caps_lock
,
6982 doc
: /* If non-nil, the Caps Lock key acts normally.
6983 Set to nil to handle Caps Lock as the `capslock' key. */);
6984 Vw32_enable_caps_lock
= Qt
;
6986 DEFVAR_LISP ("w32-scroll-lock-modifier",
6987 &Vw32_scroll_lock_modifier
,
6988 doc
: /* Modifier to use for the Scroll Lock ON state.
6989 The value can be hyper, super, meta, alt, control or shift for the
6990 respective modifier, or nil to handle Scroll Lock as the `scroll' key.
6991 Any other value will cause the Scroll Lock key to be ignored. */);
6992 Vw32_scroll_lock_modifier
= Qt
;
6994 DEFVAR_LISP ("w32-lwindow-modifier",
6995 &Vw32_lwindow_modifier
,
6996 doc
: /* Modifier to use for the left \"Windows\" key.
6997 The value can be hyper, super, meta, alt, control or shift for the
6998 respective modifier, or nil to appear as the `lwindow' key.
6999 Any other value will cause the key to be ignored. */);
7000 Vw32_lwindow_modifier
= Qnil
;
7002 DEFVAR_LISP ("w32-rwindow-modifier",
7003 &Vw32_rwindow_modifier
,
7004 doc
: /* Modifier to use for the right \"Windows\" key.
7005 The value can be hyper, super, meta, alt, control or shift for the
7006 respective modifier, or nil to appear as the `rwindow' key.
7007 Any other value will cause the key to be ignored. */);
7008 Vw32_rwindow_modifier
= Qnil
;
7010 DEFVAR_LISP ("w32-apps-modifier",
7011 &Vw32_apps_modifier
,
7012 doc
: /* Modifier to use for the \"Apps\" key.
7013 The value can be hyper, super, meta, alt, control or shift for the
7014 respective modifier, or nil to appear as the `apps' key.
7015 Any other value will cause the key to be ignored. */);
7016 Vw32_apps_modifier
= Qnil
;
7018 DEFVAR_BOOL ("w32-enable-synthesized-fonts", &w32_enable_synthesized_fonts
,
7019 doc
: /* Non-nil enables selection of artificially italicized and bold fonts. */);
7020 w32_enable_synthesized_fonts
= 0;
7022 DEFVAR_LISP ("w32-enable-palette", &Vw32_enable_palette
,
7023 doc
: /* Non-nil enables Windows palette management to map colors exactly. */);
7024 Vw32_enable_palette
= Qt
;
7026 DEFVAR_INT ("w32-mouse-button-tolerance",
7027 &w32_mouse_button_tolerance
,
7028 doc
: /* Analogue of double click interval for faking middle mouse events.
7029 The value is the minimum time in milliseconds that must elapse between
7030 left and right button down events before they are considered distinct events.
7031 If both mouse buttons are depressed within this interval, a middle mouse
7032 button down event is generated instead. */);
7033 w32_mouse_button_tolerance
= GetDoubleClickTime () / 2;
7035 DEFVAR_INT ("w32-mouse-move-interval",
7036 &w32_mouse_move_interval
,
7037 doc
: /* Minimum interval between mouse move events.
7038 The value is the minimum time in milliseconds that must elapse between
7039 successive mouse move (or scroll bar drag) events before they are
7040 reported as lisp events. */);
7041 w32_mouse_move_interval
= 0;
7043 DEFVAR_BOOL ("w32-pass-extra-mouse-buttons-to-system",
7044 &w32_pass_extra_mouse_buttons_to_system
,
7045 doc
: /* If non-nil, the fourth and fifth mouse buttons are passed to Windows.
7046 Recent versions of Windows support mice with up to five buttons.
7047 Since most applications don't support these extra buttons, most mouse
7048 drivers will allow you to map them to functions at the system level.
7049 If this variable is non-nil, Emacs will pass them on, allowing the
7050 system to handle them. */);
7051 w32_pass_extra_mouse_buttons_to_system
= 0;
7053 DEFVAR_BOOL ("w32-pass-multimedia-buttons-to-system",
7054 &w32_pass_multimedia_buttons_to_system
,
7055 doc
: /* If non-nil, media buttons are passed to Windows.
7056 Some modern keyboards contain buttons for controlling media players, web
7057 browsers and other applications. Generally these buttons are handled on a
7058 system wide basis, but by setting this to nil they are made available
7059 to Emacs for binding. Depending on your keyboard, additional keys that
7060 may be available are:
7062 browser-back, browser-forward, browser-refresh, browser-stop,
7063 browser-search, browser-favorites, browser-home,
7064 mail, mail-reply, mail-forward, mail-send,
7066 help, find, new, open, close, save, print, undo, redo, copy, cut, paste,
7067 spell-check, correction-list, toggle-dictate-command,
7068 media-next, media-previous, media-stop, media-play-pause, media-select,
7069 media-play, media-pause, media-record, media-fast-forward, media-rewind,
7070 media-channel-up, media-channel-down,
7071 volume-mute, volume-up, volume-down,
7072 mic-volume-mute, mic-volume-down, mic-volume-up, mic-toggle,
7073 bass-down, bass-boost, bass-up, treble-down, treble-up */);
7074 w32_pass_multimedia_buttons_to_system
= 1;
7076 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape
,
7077 doc
: /* The shape of the pointer when over text.
7078 Changing the value does not affect existing frames
7079 unless you set the mouse color. */);
7080 Vx_pointer_shape
= Qnil
;
7082 Vx_nontext_pointer_shape
= Qnil
;
7084 Vx_mode_pointer_shape
= Qnil
;
7086 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape
,
7087 doc
: /* The shape of the pointer when Emacs is busy.
7088 This variable takes effect when you create a new frame
7089 or when you set the mouse color. */);
7090 Vx_hourglass_pointer_shape
= Qnil
;
7092 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
7093 &Vx_sensitive_text_pointer_shape
,
7094 doc
: /* The shape of the pointer when over mouse-sensitive text.
7095 This variable takes effect when you create a new frame
7096 or when you set the mouse color. */);
7097 Vx_sensitive_text_pointer_shape
= Qnil
;
7099 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
7100 &Vx_window_horizontal_drag_shape
,
7101 doc
: /* Pointer shape to use for indicating a window can be dragged horizontally.
7102 This variable takes effect when you create a new frame
7103 or when you set the mouse color. */);
7104 Vx_window_horizontal_drag_shape
= Qnil
;
7106 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel
,
7107 doc
: /* A string indicating the foreground color of the cursor box. */);
7108 Vx_cursor_fore_pixel
= Qnil
;
7110 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size
,
7111 doc
: /* Maximum size for tooltips.
7112 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
7113 Vx_max_tooltip_size
= Fcons (make_number (80), make_number (40));
7115 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager
,
7116 doc
: /* Non-nil if no window manager is in use.
7117 Emacs doesn't try to figure this out; this is always nil
7118 unless you set it to something else. */);
7119 /* We don't have any way to find this out, so set it to nil
7120 and maybe the user would like to set it to t. */
7121 Vx_no_window_manager
= Qnil
;
7123 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
7124 &Vx_pixel_size_width_font_regexp
,
7125 doc
: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
7127 Since Emacs gets width of a font matching with this regexp from
7128 PIXEL_SIZE field of the name, font finding mechanism gets faster for
7129 such a font. This is especially effective for such large fonts as
7130 Chinese, Japanese, and Korean. */);
7131 Vx_pixel_size_width_font_regexp
= Qnil
;
7133 DEFVAR_LISP ("w32-bdf-filename-alist",
7134 &Vw32_bdf_filename_alist
,
7135 doc
: /* List of bdf fonts and their corresponding filenames. */);
7136 Vw32_bdf_filename_alist
= Qnil
;
7138 DEFVAR_BOOL ("w32-strict-fontnames",
7139 &w32_strict_fontnames
,
7140 doc
: /* Non-nil means only use fonts that are exact matches for those requested.
7141 Default is nil, which allows old fontnames that are not XLFD compliant,
7142 and allows third-party CJK display to work by specifying false charset
7143 fields to trick Emacs into translating to Big5, SJIS etc.
7144 Setting this to t will prevent wrong fonts being selected when
7145 fontsets are automatically created. */);
7146 w32_strict_fontnames
= 0;
7148 DEFVAR_BOOL ("w32-strict-painting",
7149 &w32_strict_painting
,
7150 doc
: /* Non-nil means use strict rules for repainting frames.
7151 Set this to nil to get the old behavior for repainting; this should
7152 only be necessary if the default setting causes problems. */);
7153 w32_strict_painting
= 1;
7155 #if 0 /* TODO: Port to W32 */
7156 defsubr (&Sx_change_window_property
);
7157 defsubr (&Sx_delete_window_property
);
7158 defsubr (&Sx_window_property
);
7160 defsubr (&Sxw_display_color_p
);
7161 defsubr (&Sx_display_grayscale_p
);
7162 defsubr (&Sxw_color_defined_p
);
7163 defsubr (&Sxw_color_values
);
7164 defsubr (&Sx_server_max_request_size
);
7165 defsubr (&Sx_server_vendor
);
7166 defsubr (&Sx_server_version
);
7167 defsubr (&Sx_display_pixel_width
);
7168 defsubr (&Sx_display_pixel_height
);
7169 defsubr (&Sx_display_mm_width
);
7170 defsubr (&Sx_display_mm_height
);
7171 defsubr (&Sx_display_screens
);
7172 defsubr (&Sx_display_planes
);
7173 defsubr (&Sx_display_color_cells
);
7174 defsubr (&Sx_display_visual_class
);
7175 defsubr (&Sx_display_backing_store
);
7176 defsubr (&Sx_display_save_under
);
7177 defsubr (&Sx_create_frame
);
7178 defsubr (&Sx_open_connection
);
7179 defsubr (&Sx_close_connection
);
7180 defsubr (&Sx_display_list
);
7181 defsubr (&Sx_synchronize
);
7182 defsubr (&Sx_focus_frame
);
7184 /* W32 specific functions */
7186 defsubr (&Sw32_define_rgb_color
);
7187 defsubr (&Sw32_default_color_map
);
7188 defsubr (&Sw32_send_sys_command
);
7189 defsubr (&Sw32_shell_execute
);
7190 defsubr (&Sw32_register_hot_key
);
7191 defsubr (&Sw32_unregister_hot_key
);
7192 defsubr (&Sw32_registered_hot_keys
);
7193 defsubr (&Sw32_reconstruct_hot_key
);
7194 defsubr (&Sw32_toggle_lock_key
);
7195 defsubr (&Sw32_window_exists_p
);
7196 defsubr (&Sw32_battery_status
);
7198 defsubr (&Sfile_system_info
);
7199 defsubr (&Sdefault_printer_name
);
7201 check_window_system_func
= check_w32
;
7204 hourglass_timer
= 0;
7205 hourglass_hwnd
= NULL
;
7207 defsubr (&Sx_show_tip
);
7208 defsubr (&Sx_hide_tip
);
7210 staticpro (&tip_timer
);
7212 staticpro (&tip_frame
);
7214 last_show_tip_args
= Qnil
;
7215 staticpro (&last_show_tip_args
);
7217 defsubr (&Sx_file_dialog
);
7218 defsubr (&Ssystem_move_file_to_trash
);
7223 globals_of_w32fns is used to initialize those global variables that
7224 must always be initialized on startup even when the global variable
7225 initialized is non zero (see the function main in emacs.c).
7226 globals_of_w32fns is called from syms_of_w32fns when the global
7227 variable initialized is 0 and directly from main when initialized
7231 globals_of_w32fns ()
7233 HMODULE user32_lib
= GetModuleHandle ("user32.dll");
7235 TrackMouseEvent not available in all versions of Windows, so must load
7236 it dynamically. Do it once, here, instead of every time it is used.
7238 track_mouse_event_fn
= (TrackMouseEvent_Proc
)
7239 GetProcAddress (user32_lib
, "TrackMouseEvent");
7240 /* ditto for GetClipboardSequenceNumber. */
7241 clipboard_sequence_fn
= (ClipboardSequence_Proc
)
7242 GetProcAddress (user32_lib
, "GetClipboardSequenceNumber");
7244 monitor_from_point_fn
= (MonitorFromPoint_Proc
)
7245 GetProcAddress (user32_lib
, "MonitorFromPoint");
7246 get_monitor_info_fn
= (GetMonitorInfo_Proc
)
7247 GetProcAddress (user32_lib
, "GetMonitorInfoA");
7250 HMODULE imm32_lib
= GetModuleHandle ("imm32.dll");
7251 get_composition_string_fn
= (ImmGetCompositionString_Proc
)
7252 GetProcAddress (imm32_lib
, "ImmGetCompositionStringW");
7253 get_ime_context_fn
= (ImmGetContext_Proc
)
7254 GetProcAddress (imm32_lib
, "ImmGetContext");
7256 DEFVAR_INT ("w32-ansi-code-page",
7257 &w32_ansi_code_page
,
7258 doc
: /* The ANSI code page used by the system. */);
7259 w32_ansi_code_page
= GetACP ();
7261 /* MessageBox does not work without this when linked to comctl32.dll 6.0. */
7262 InitCommonControls ();
7264 syms_of_w32uniscribe ();
7273 button
= MessageBox (NULL
,
7274 "A fatal error has occurred!\n\n"
7275 "Would you like to attach a debugger?\n\n"
7276 "Select YES to debug, NO to abort Emacs"
7278 "\n\n(type \"gdb -p <emacs-PID>\" and\n"
7279 "\"continue\" inside GDB before clicking YES.)"
7281 , "Emacs Abort Dialog",
7282 MB_ICONEXCLAMATION
| MB_TASKMODAL
7283 | MB_SETFOREGROUND
| MB_YESNO
);
7288 exit (2); /* tell the compiler we will never return */
7296 /* For convenience when debugging. */
7300 return GetLastError ();
7303 /* arch-tag: 707589ab-b9be-4638-8cdd-74629cc9b446
7304 (do not change this comment) */