1 /* Graphical user interface functions for the Microsoft W32 API.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
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
, w32_major_version
);
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
, w32_major_version
);
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
);
5537 Lisp_Object fg
= Fframe_parameter (frame
, Qforeground_color
);
5538 Lisp_Object colors
= Qnil
;
5540 /* Set tip_frame here, so that */
5542 call2 (Qface_set_after_frame_default
, frame
, Qnil
);
5544 if (!EQ (bg
, Fframe_parameter (frame
, Qbackground_color
)))
5545 colors
= Fcons (Fcons (Qbackground_color
, bg
), colors
);
5546 if (!EQ (fg
, Fframe_parameter (frame
, Qforeground_color
)))
5547 colors
= Fcons (Fcons (Qforeground_color
, fg
), colors
);
5550 Fmodify_frame_parameters (frame
, colors
);
5557 /* It is now ok to make the frame official even if we get an error
5558 below. And the frame needs to be on Vframe_list or making it
5559 visible won't work. */
5560 Vframe_list
= Fcons (frame
, Vframe_list
);
5562 /* Now that the frame is official, it counts as a reference to
5564 FRAME_W32_DISPLAY_INFO (f
)->reference_count
++;
5566 /* Setting attributes of faces of the tooltip frame from resources
5567 and similar will increment face_change_count, which leads to the
5568 clearing of all current matrices. Since this isn't necessary
5569 here, avoid it by resetting face_change_count to the value it
5570 had before we created the tip frame. */
5571 face_change_count
= face_change_count_before
;
5573 /* Discard the unwind_protect. */
5574 return unbind_to (count
, frame
);
5578 /* Compute where to display tip frame F. PARMS is the list of frame
5579 parameters for F. DX and DY are specified offsets from the current
5580 location of the mouse. WIDTH and HEIGHT are the width and height
5581 of the tooltip. Return coordinates relative to the root window of
5582 the display in *ROOT_X, and *ROOT_Y. */
5585 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, root_x
, root_y
)
5587 Lisp_Object parms
, dx
, dy
;
5589 int *root_x
, *root_y
;
5591 Lisp_Object left
, top
;
5592 int min_x
, min_y
, max_x
, max_y
;
5594 /* User-specified position? */
5595 left
= Fcdr (Fassq (Qleft
, parms
));
5596 top
= Fcdr (Fassq (Qtop
, parms
));
5598 /* Move the tooltip window where the mouse pointer is. Resize and
5600 if (!INTEGERP (left
) || !INTEGERP (top
))
5604 /* Default min and max values. */
5607 max_x
= x_display_pixel_width (FRAME_W32_DISPLAY_INFO (f
));
5608 max_y
= x_display_pixel_height (FRAME_W32_DISPLAY_INFO (f
));
5616 /* If multiple monitor support is available, constrain the tip onto
5617 the current monitor. This improves the above by allowing negative
5618 co-ordinates if monitor positions are such that they are valid, and
5619 snaps a tooltip onto a single monitor if we are close to the edge
5620 where it would otherwise flow onto the other monitor (or into
5621 nothingness if there is a gap in the overlap). */
5622 if (monitor_from_point_fn
&& get_monitor_info_fn
)
5624 struct MONITOR_INFO info
;
5626 = monitor_from_point_fn (pt
, MONITOR_DEFAULT_TO_NEAREST
);
5627 info
.cbSize
= sizeof (info
);
5629 if (get_monitor_info_fn (monitor
, &info
))
5631 min_x
= info
.rcWork
.left
;
5632 min_y
= info
.rcWork
.top
;
5633 max_x
= info
.rcWork
.right
;
5634 max_y
= info
.rcWork
.bottom
;
5640 *root_y
= XINT (top
);
5641 else if (*root_y
+ XINT (dy
) <= min_y
)
5642 *root_y
= min_y
; /* Can happen for negative dy */
5643 else if (*root_y
+ XINT (dy
) + height
<= max_y
)
5644 /* It fits below the pointer */
5645 *root_y
+= XINT (dy
);
5646 else if (height
+ XINT (dy
) + min_y
<= *root_y
)
5647 /* It fits above the pointer. */
5648 *root_y
-= height
+ XINT (dy
);
5650 /* Put it on the top. */
5653 if (INTEGERP (left
))
5654 *root_x
= XINT (left
);
5655 else if (*root_x
+ XINT (dx
) <= min_x
)
5656 *root_x
= 0; /* Can happen for negative dx */
5657 else if (*root_x
+ XINT (dx
) + width
<= max_x
)
5658 /* It fits to the right of the pointer. */
5659 *root_x
+= XINT (dx
);
5660 else if (width
+ XINT (dx
) + min_x
<= *root_x
)
5661 /* It fits to the left of the pointer. */
5662 *root_x
-= width
+ XINT (dx
);
5664 /* Put it left justified on the screen -- it ought to fit that way. */
5669 DEFUN ("x-show-tip", Fx_show_tip
, Sx_show_tip
, 1, 6, 0,
5670 doc
: /* Show STRING in a \"tooltip\" window on frame FRAME.
5671 A tooltip window is a small window displaying a string.
5673 This is an internal function; Lisp code should call `tooltip-show'.
5675 FRAME nil or omitted means use the selected frame.
5677 PARMS is an optional list of frame parameters which can be
5678 used to change the tooltip's appearance.
5680 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
5681 means use the default timeout of 5 seconds.
5683 If the list of frame parameters PARMS contains a `left' parameter,
5684 the tooltip is displayed at that x-position. Otherwise it is
5685 displayed at the mouse position, with offset DX added (default is 5 if
5686 DX isn't specified). Likewise for the y-position; if a `top' frame
5687 parameter is specified, it determines the y-position of the tooltip
5688 window, otherwise it is displayed at the mouse position, with offset
5689 DY added (default is -10).
5691 A tooltip's maximum size is specified by `x-max-tooltip-size'.
5692 Text larger than the specified size is clipped. */)
5693 (string
, frame
, parms
, timeout
, dx
, dy
)
5694 Lisp_Object string
, frame
, parms
, timeout
, dx
, dy
;
5699 struct buffer
*old_buffer
;
5700 struct text_pos pos
;
5701 int i
, width
, height
;
5702 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
5703 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
5704 int count
= SPECPDL_INDEX ();
5706 specbind (Qinhibit_redisplay
, Qt
);
5708 GCPRO4 (string
, parms
, frame
, timeout
);
5710 CHECK_STRING (string
);
5711 f
= check_x_frame (frame
);
5713 timeout
= make_number (5);
5715 CHECK_NATNUM (timeout
);
5718 dx
= make_number (5);
5723 dy
= make_number (-10);
5727 if (NILP (last_show_tip_args
))
5728 last_show_tip_args
= Fmake_vector (make_number (3), Qnil
);
5730 if (!NILP (tip_frame
))
5732 Lisp_Object last_string
= AREF (last_show_tip_args
, 0);
5733 Lisp_Object last_frame
= AREF (last_show_tip_args
, 1);
5734 Lisp_Object last_parms
= AREF (last_show_tip_args
, 2);
5736 if (EQ (frame
, last_frame
)
5737 && !NILP (Fequal (last_string
, string
))
5738 && !NILP (Fequal (last_parms
, parms
)))
5740 struct frame
*f
= XFRAME (tip_frame
);
5742 /* Only DX and DY have changed. */
5743 if (!NILP (tip_timer
))
5745 Lisp_Object timer
= tip_timer
;
5747 call1 (Qcancel_timer
, timer
);
5751 compute_tip_xy (f
, parms
, dx
, dy
, FRAME_PIXEL_WIDTH (f
),
5752 FRAME_PIXEL_HEIGHT (f
), &root_x
, &root_y
);
5754 /* Put tooltip in topmost group and in position. */
5755 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOPMOST
,
5756 root_x
, root_y
, 0, 0,
5757 SWP_NOSIZE
| SWP_NOACTIVATE
);
5759 /* Ensure tooltip is on top of other topmost windows (eg menus). */
5760 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOP
,
5762 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5769 /* Hide a previous tip, if any. */
5772 ASET (last_show_tip_args
, 0, string
);
5773 ASET (last_show_tip_args
, 1, frame
);
5774 ASET (last_show_tip_args
, 2, parms
);
5776 /* Add default values to frame parameters. */
5777 if (NILP (Fassq (Qname
, parms
)))
5778 parms
= Fcons (Fcons (Qname
, build_string ("tooltip")), parms
);
5779 if (NILP (Fassq (Qinternal_border_width
, parms
)))
5780 parms
= Fcons (Fcons (Qinternal_border_width
, make_number (3)), parms
);
5781 if (NILP (Fassq (Qborder_width
, parms
)))
5782 parms
= Fcons (Fcons (Qborder_width
, make_number (1)), parms
);
5783 if (NILP (Fassq (Qborder_color
, parms
)))
5784 parms
= Fcons (Fcons (Qborder_color
, build_string ("lightyellow")), parms
);
5785 if (NILP (Fassq (Qbackground_color
, parms
)))
5786 parms
= Fcons (Fcons (Qbackground_color
, build_string ("lightyellow")),
5789 /* Block input until the tip has been fully drawn, to avoid crashes
5790 when drawing tips in menus. */
5793 /* Create a frame for the tooltip, and record it in the global
5794 variable tip_frame. */
5795 frame
= x_create_tip_frame (FRAME_W32_DISPLAY_INFO (f
), parms
, string
);
5798 /* Set up the frame's root window. */
5799 w
= XWINDOW (FRAME_ROOT_WINDOW (f
));
5800 w
->left_col
= w
->top_line
= make_number (0);
5802 if (CONSP (Vx_max_tooltip_size
)
5803 && INTEGERP (XCAR (Vx_max_tooltip_size
))
5804 && XINT (XCAR (Vx_max_tooltip_size
)) > 0
5805 && INTEGERP (XCDR (Vx_max_tooltip_size
))
5806 && XINT (XCDR (Vx_max_tooltip_size
)) > 0)
5808 w
->total_cols
= XCAR (Vx_max_tooltip_size
);
5809 w
->total_lines
= XCDR (Vx_max_tooltip_size
);
5813 w
->total_cols
= make_number (80);
5814 w
->total_lines
= make_number (40);
5817 FRAME_TOTAL_COLS (f
) = XINT (w
->total_cols
);
5819 w
->pseudo_window_p
= 1;
5821 /* Display the tooltip text in a temporary buffer. */
5822 old_buffer
= current_buffer
;
5823 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f
))->buffer
));
5824 current_buffer
->truncate_lines
= Qnil
;
5825 clear_glyph_matrix (w
->desired_matrix
);
5826 clear_glyph_matrix (w
->current_matrix
);
5827 SET_TEXT_POS (pos
, BEGV
, BEGV_BYTE
);
5828 try_window (FRAME_ROOT_WINDOW (f
), pos
, 0);
5830 /* Compute width and height of the tooltip. */
5832 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
5834 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
5838 /* Stop at the first empty row at the end. */
5839 if (!row
->enabled_p
|| !row
->displays_text_p
)
5842 /* Let the row go over the full width of the frame. */
5843 row
->full_width_p
= 1;
5845 #ifdef TODO /* Investigate why some fonts need more width than is
5846 calculated for some tooltips. */
5847 /* There's a glyph at the end of rows that is use to place
5848 the cursor there. Don't include the width of this glyph. */
5849 if (row
->used
[TEXT_AREA
])
5851 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
5852 row_width
= row
->pixel_width
- last
->pixel_width
;
5856 row_width
= row
->pixel_width
;
5858 /* TODO: find why tips do not draw along baseline as instructed. */
5859 height
+= row
->height
;
5860 width
= max (width
, row_width
);
5863 /* Add the frame's internal border to the width and height the X
5864 window should have. */
5865 height
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
5866 width
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
5868 /* Move the tooltip window where the mouse pointer is. Resize and
5870 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, &root_x
, &root_y
);
5873 /* Adjust Window size to take border into account. */
5875 rect
.left
= rect
.top
= 0;
5877 rect
.bottom
= height
;
5878 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
5879 FRAME_EXTERNAL_MENU_BAR (f
));
5881 /* Position and size tooltip, and put it in the topmost group.
5882 The add-on of 3 to the 5th argument is a kludge: without it,
5883 some fonts cause the last character of the tip to be truncated,
5884 for some obscure reason. */
5885 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOPMOST
,
5886 root_x
, root_y
, rect
.right
- rect
.left
+ 3,
5887 rect
.bottom
- rect
.top
, SWP_NOACTIVATE
);
5889 /* Ensure tooltip is on top of other topmost windows (eg menus). */
5890 SetWindowPos (FRAME_W32_WINDOW (f
), HWND_TOP
,
5892 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5894 /* Let redisplay know that we have made the frame visible already. */
5895 f
->async_visible
= 1;
5897 ShowWindow (FRAME_W32_WINDOW (f
), SW_SHOWNOACTIVATE
);
5900 /* Draw into the window. */
5901 w
->must_be_updated_p
= 1;
5902 update_single_window (w
, 1);
5906 /* Restore original current buffer. */
5907 set_buffer_internal_1 (old_buffer
);
5908 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
5911 /* Let the tip disappear after timeout seconds. */
5912 tip_timer
= call3 (intern ("run-at-time"), timeout
, Qnil
,
5913 intern ("x-hide-tip"));
5916 return unbind_to (count
, Qnil
);
5920 DEFUN ("x-hide-tip", Fx_hide_tip
, Sx_hide_tip
, 0, 0, 0,
5921 doc
: /* Hide the current tooltip window, if there is any.
5922 Value is t if tooltip was open, nil otherwise. */)
5926 Lisp_Object deleted
, frame
, timer
;
5927 struct gcpro gcpro1
, gcpro2
;
5929 /* Return quickly if nothing to do. */
5930 if (NILP (tip_timer
) && NILP (tip_frame
))
5935 GCPRO2 (frame
, timer
);
5936 tip_frame
= tip_timer
= deleted
= Qnil
;
5938 count
= SPECPDL_INDEX ();
5939 specbind (Qinhibit_redisplay
, Qt
);
5940 specbind (Qinhibit_quit
, Qt
);
5943 call1 (Qcancel_timer
, timer
);
5947 delete_frame (frame
, Qnil
);
5952 return unbind_to (count
, deleted
);
5957 /***********************************************************************
5958 File selection dialog
5959 ***********************************************************************/
5960 extern Lisp_Object Qfile_name_history
;
5962 /* Callback for altering the behavior of the Open File dialog.
5963 Makes the Filename text field contain "Current Directory" and be
5964 read-only when "Directories" is selected in the filter. This
5965 allows us to work around the fact that the standard Open File
5966 dialog does not support directories. */
5968 file_dialog_callback (hwnd
, msg
, wParam
, lParam
)
5974 if (msg
== WM_NOTIFY
)
5976 OFNOTIFY
* notify
= (OFNOTIFY
*)lParam
;
5977 /* Detect when the Filter dropdown is changed. */
5978 if (notify
->hdr
.code
== CDN_TYPECHANGE
5979 || notify
->hdr
.code
== CDN_INITDONE
)
5981 HWND dialog
= GetParent (hwnd
);
5982 HWND edit_control
= GetDlgItem (dialog
, FILE_NAME_TEXT_FIELD
);
5984 /* Directories is in index 2. */
5985 if (notify
->lpOFN
->nFilterIndex
== 2)
5987 CommDlg_OpenSave_SetControlText (dialog
, FILE_NAME_TEXT_FIELD
,
5988 "Current Directory");
5989 EnableWindow (edit_control
, FALSE
);
5993 /* Don't override default filename on init done. */
5994 if (notify
->hdr
.code
== CDN_TYPECHANGE
)
5995 CommDlg_OpenSave_SetControlText (dialog
,
5996 FILE_NAME_TEXT_FIELD
, "");
5997 EnableWindow (edit_control
, TRUE
);
6004 /* Since we compile with _WIN32_WINNT set to 0x0400 (for NT4 compatibility)
6005 we end up with the old file dialogs. Define a big enough struct for the
6006 new dialog to trick GetOpenFileName into giving us the new dialogs on
6007 Windows 2000 and XP. */
6010 OPENFILENAME real_details
;
6017 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 5, 0,
6018 doc
: /* Read file name, prompting with PROMPT in directory DIR.
6019 Use a file selection dialog.
6020 Select DEFAULT-FILENAME in the dialog's file selection box, if
6021 specified. Ensure that file exists if MUSTMATCH is non-nil.
6022 If ONLY-DIR-P is non-nil, the user can only select directories. */)
6023 (prompt
, dir
, default_filename
, mustmatch
, only_dir_p
)
6024 Lisp_Object prompt
, dir
, default_filename
, mustmatch
, only_dir_p
;
6026 struct frame
*f
= SELECTED_FRAME ();
6027 Lisp_Object file
= Qnil
;
6028 int count
= SPECPDL_INDEX ();
6029 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
, gcpro6
;
6030 char filename
[MAX_PATH
+ 1];
6031 char init_dir
[MAX_PATH
+ 1];
6032 int default_filter_index
= 1; /* 1: All Files, 2: Directories only */
6034 GCPRO6 (prompt
, dir
, default_filename
, mustmatch
, only_dir_p
, file
);
6035 CHECK_STRING (prompt
);
6038 /* Create the dialog with PROMPT as title, using DIR as initial
6039 directory and using "*" as pattern. */
6040 dir
= Fexpand_file_name (dir
, Qnil
);
6041 strncpy (init_dir
, SDATA (ENCODE_FILE (dir
)), MAX_PATH
);
6042 init_dir
[MAX_PATH
] = '\0';
6043 unixtodos_filename (init_dir
);
6045 if (STRINGP (default_filename
))
6047 char *file_name_only
;
6048 char *full_path_name
= SDATA (ENCODE_FILE (default_filename
));
6050 unixtodos_filename (full_path_name
);
6052 file_name_only
= strrchr (full_path_name
, '\\');
6053 if (!file_name_only
)
6054 file_name_only
= full_path_name
;
6058 strncpy (filename
, file_name_only
, MAX_PATH
);
6059 filename
[MAX_PATH
] = '\0';
6065 NEWOPENFILENAME new_file_details
;
6066 BOOL file_opened
= FALSE
;
6067 OPENFILENAME
* file_details
= &new_file_details
.real_details
;
6069 /* Prevent redisplay. */
6070 specbind (Qinhibit_redisplay
, Qt
);
6073 bzero (&new_file_details
, sizeof (new_file_details
));
6074 /* Apparently NT4 crashes if you give it an unexpected size.
6075 I'm not sure about Windows 9x, so play it safe. */
6076 if (w32_major_version
> 4 && w32_major_version
< 95)
6077 file_details
->lStructSize
= sizeof (NEWOPENFILENAME
);
6079 file_details
->lStructSize
= sizeof (OPENFILENAME
);
6081 file_details
->hwndOwner
= FRAME_W32_WINDOW (f
);
6082 /* Undocumented Bug in Common File Dialog:
6083 If a filter is not specified, shell links are not resolved. */
6084 file_details
->lpstrFilter
= "All Files (*.*)\0*.*\0Directories\0*|*\0\0";
6085 file_details
->lpstrFile
= filename
;
6086 file_details
->nMaxFile
= sizeof (filename
);
6087 file_details
->lpstrInitialDir
= init_dir
;
6088 file_details
->lpstrTitle
= SDATA (prompt
);
6090 if (! NILP (only_dir_p
))
6091 default_filter_index
= 2;
6093 file_details
->nFilterIndex
= default_filter_index
;
6095 file_details
->Flags
= (OFN_HIDEREADONLY
| OFN_NOCHANGEDIR
6096 | OFN_EXPLORER
| OFN_ENABLEHOOK
);
6097 if (!NILP (mustmatch
))
6099 /* Require that the path to the parent directory exists. */
6100 file_details
->Flags
|= OFN_PATHMUSTEXIST
;
6101 /* If we are looking for a file, require that it exists. */
6102 if (NILP (only_dir_p
))
6103 file_details
->Flags
|= OFN_FILEMUSTEXIST
;
6106 file_details
->lpfnHook
= (LPOFNHOOKPROC
) file_dialog_callback
;
6108 file_opened
= GetOpenFileName (file_details
);
6114 dostounix_filename (filename
);
6116 if (file_details
->nFilterIndex
== 2)
6118 /* "Directories" selected - strip dummy file name. */
6119 char * last
= strrchr (filename
, '/');
6123 file
= DECODE_FILE (build_string (filename
));
6125 /* User cancelled the dialog without making a selection. */
6126 else if (!CommDlgExtendedError ())
6128 /* An error occurred, fallback on reading from the mini-buffer. */
6130 file
= Fcompleting_read (prompt
, intern ("read-file-name-internal"),
6131 dir
, mustmatch
, dir
, Qfile_name_history
,
6132 default_filename
, Qnil
);
6134 file
= unbind_to (count
, file
);
6139 /* Make "Cancel" equivalent to C-g. */
6141 Fsignal (Qquit
, Qnil
);
6143 return unbind_to (count
, file
);
6147 /* Moving files to the system recycle bin.
6148 Used by `move-file-to-trash' instead of the default moving to ~/.Trash */
6149 DEFUN ("system-move-file-to-trash", Fsystem_move_file_to_trash
,
6150 Ssystem_move_file_to_trash
, 1, 1, 0,
6151 doc
: /* Move file or directory named FILENAME to the recycle bin. */)
6153 Lisp_Object filename
;
6155 Lisp_Object handler
;
6156 Lisp_Object encoded_file
;
6157 Lisp_Object operation
;
6159 operation
= Qdelete_file
;
6160 if (!NILP (Ffile_directory_p (filename
))
6161 && NILP (Ffile_symlink_p (filename
)))
6163 operation
= Qdelete_directory
;
6164 filename
= Fdirectory_file_name (filename
);
6166 filename
= Fexpand_file_name (filename
, Qnil
);
6168 handler
= Ffind_file_name_handler (filename
, operation
);
6169 if (!NILP (handler
))
6170 return call2 (handler
, operation
, filename
);
6172 encoded_file
= ENCODE_FILE (filename
);
6176 SHFILEOPSTRUCT file_op
;
6177 char tmp_path
[MAX_PATH
+ 1];
6179 path
= map_w32_filename (SDATA (encoded_file
), NULL
);
6181 /* On Windows, write permission is required to delete/move files. */
6182 _chmod (path
, 0666);
6184 bzero (tmp_path
, sizeof (tmp_path
));
6185 strcpy (tmp_path
, path
);
6187 bzero (&file_op
, sizeof (file_op
));
6188 file_op
.hwnd
= HWND_DESKTOP
;
6189 file_op
.wFunc
= FO_DELETE
;
6190 file_op
.pFrom
= tmp_path
;
6191 file_op
.fFlags
= FOF_SILENT
| FOF_NOCONFIRMATION
| FOF_ALLOWUNDO
6192 | FOF_NOERRORUI
| FOF_NO_CONNECTED_ELEMENTS
;
6193 file_op
.fAnyOperationsAborted
= FALSE
;
6195 if (SHFileOperation (&file_op
) != 0)
6196 report_file_error ("Removing old name", list1 (filename
));
6202 /***********************************************************************
6203 w32 specialized functions
6204 ***********************************************************************/
6206 DEFUN ("w32-send-sys-command", Fw32_send_sys_command
,
6207 Sw32_send_sys_command
, 1, 2, 0,
6208 doc
: /* Send frame a Windows WM_SYSCOMMAND message of type COMMAND.
6209 Some useful values for COMMAND are #xf030 to maximize frame (#xf020
6210 to minimize), #xf120 to restore frame to original size, and #xf100
6211 to activate the menubar for keyboard access. #xf140 activates the
6212 screen saver if defined.
6214 If optional parameter FRAME is not specified, use selected frame. */)
6216 Lisp_Object command
, frame
;
6218 FRAME_PTR f
= check_x_frame (frame
);
6220 CHECK_NUMBER (command
);
6222 PostMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, XINT (command
), 0);
6227 DEFUN ("w32-shell-execute", Fw32_shell_execute
, Sw32_shell_execute
, 2, 4, 0,
6228 doc
: /* Get Windows to perform OPERATION on DOCUMENT.
6229 This is a wrapper around the ShellExecute system function, which
6230 invokes the application registered to handle OPERATION for DOCUMENT.
6232 OPERATION is either nil or a string that names a supported operation.
6233 What operations can be used depends on the particular DOCUMENT and its
6234 handler application, but typically it is one of the following common
6237 \"open\" - open DOCUMENT, which could be a file, a directory, or an
6238 executable program. If it is an application, that
6239 application is launched in the current buffer's default
6240 directory. Otherwise, the application associated with
6241 DOCUMENT is launched in the buffer's default directory.
6242 \"print\" - print DOCUMENT, which must be a file
6243 \"explore\" - start the Windows Explorer on DOCUMENT
6244 \"edit\" - launch an editor and open DOCUMENT for editing; which
6245 editor is launched depends on the association for the
6247 \"find\" - initiate search starting from DOCUMENT which must specify
6249 nil - invoke the default OPERATION, or \"open\" if default is
6250 not defined or unavailable
6252 DOCUMENT is typically the name of a document file or a URL, but can
6253 also be a program executable to run, or a directory to open in the
6256 If DOCUMENT is a program executable, the optional third arg PARAMETERS
6257 can be a string containing command line parameters that will be passed
6258 to the program; otherwise, PARAMETERS should be nil or unspecified.
6260 Optional fourth argument SHOW-FLAG can be used to control how the
6261 application will be displayed when it is invoked. If SHOW-FLAG is nil
6262 or unspecified, the application is displayed normally, otherwise it is
6263 an integer representing a ShowWindow flag:
6268 6 - start minimized */)
6269 (operation
, document
, parameters
, show_flag
)
6270 Lisp_Object operation
, document
, parameters
, show_flag
;
6272 Lisp_Object current_dir
;
6274 CHECK_STRING (document
);
6276 /* Encode filename, current directory and parameters. */
6277 current_dir
= ENCODE_FILE (current_buffer
->directory
);
6278 document
= ENCODE_FILE (document
);
6279 if (STRINGP (parameters
))
6280 parameters
= ENCODE_SYSTEM (parameters
);
6282 if ((int) ShellExecute (NULL
,
6283 (STRINGP (operation
) ?
6284 SDATA (operation
) : NULL
),
6286 (STRINGP (parameters
) ?
6287 SDATA (parameters
) : NULL
),
6288 SDATA (current_dir
),
6289 (INTEGERP (show_flag
) ?
6290 XINT (show_flag
) : SW_SHOWDEFAULT
))
6293 error ("ShellExecute failed: %s", w32_strerror (0));
6296 /* Lookup virtual keycode from string representing the name of a
6297 non-ascii keystroke into the corresponding virtual key, using
6298 lispy_function_keys. */
6300 lookup_vk_code (char *key
)
6304 for (i
= 0; i
< 256; i
++)
6305 if (lispy_function_keys
[i
]
6306 && strcmp (lispy_function_keys
[i
], key
) == 0)
6312 /* Convert a one-element vector style key sequence to a hot key
6315 w32_parse_hot_key (key
)
6318 /* Copied from Fdefine_key and store_in_keymap. */
6319 register Lisp_Object c
;
6323 struct gcpro gcpro1
;
6327 if (XFASTINT (Flength (key
)) != 1)
6332 c
= Faref (key
, make_number (0));
6334 if (CONSP (c
) && lucid_event_type_list_p (c
))
6335 c
= Fevent_convert_list (c
);
6339 if (! INTEGERP (c
) && ! SYMBOLP (c
))
6340 error ("Key definition is invalid");
6342 /* Work out the base key and the modifiers. */
6345 c
= parse_modifiers (c
);
6346 lisp_modifiers
= XINT (Fcar (Fcdr (c
)));
6350 vk_code
= lookup_vk_code (SDATA (SYMBOL_NAME (c
)));
6352 else if (INTEGERP (c
))
6354 lisp_modifiers
= XINT (c
) & ~CHARACTERBITS
;
6355 /* Many ascii characters are their own virtual key code. */
6356 vk_code
= XINT (c
) & CHARACTERBITS
;
6359 if (vk_code
< 0 || vk_code
> 255)
6362 if ((lisp_modifiers
& meta_modifier
) != 0
6363 && !NILP (Vw32_alt_is_meta
))
6364 lisp_modifiers
|= alt_modifier
;
6366 /* Supply defs missing from mingw32. */
6368 #define MOD_ALT 0x0001
6369 #define MOD_CONTROL 0x0002
6370 #define MOD_SHIFT 0x0004
6371 #define MOD_WIN 0x0008
6374 /* Convert lisp modifiers to Windows hot-key form. */
6375 w32_modifiers
= (lisp_modifiers
& hyper_modifier
) ? MOD_WIN
: 0;
6376 w32_modifiers
|= (lisp_modifiers
& alt_modifier
) ? MOD_ALT
: 0;
6377 w32_modifiers
|= (lisp_modifiers
& ctrl_modifier
) ? MOD_CONTROL
: 0;
6378 w32_modifiers
|= (lisp_modifiers
& shift_modifier
) ? MOD_SHIFT
: 0;
6380 return HOTKEY (vk_code
, w32_modifiers
);
6383 DEFUN ("w32-register-hot-key", Fw32_register_hot_key
,
6384 Sw32_register_hot_key
, 1, 1, 0,
6385 doc
: /* Register KEY as a hot-key combination.
6386 Certain key combinations like Alt-Tab are reserved for system use on
6387 Windows, and therefore are normally intercepted by the system. However,
6388 most of these key combinations can be received by registering them as
6389 hot-keys, overriding their special meaning.
6391 KEY must be a one element key definition in vector form that would be
6392 acceptable to `define-key' (e.g. [A-tab] for Alt-Tab). The meta
6393 modifier is interpreted as Alt if `w32-alt-is-meta' is t, and hyper
6394 is always interpreted as the Windows modifier keys.
6396 The return value is the hotkey-id if registered, otherwise nil. */)
6400 key
= w32_parse_hot_key (key
);
6402 if (!NILP (key
) && NILP (Fmemq (key
, w32_grabbed_keys
)))
6404 /* Reuse an empty slot if possible. */
6405 Lisp_Object item
= Fmemq (Qnil
, w32_grabbed_keys
);
6407 /* Safe to add new key to list, even if we have focus. */
6409 w32_grabbed_keys
= Fcons (key
, w32_grabbed_keys
);
6411 XSETCAR (item
, key
);
6413 /* Notify input thread about new hot-key definition, so that it
6414 takes effect without needing to switch focus. */
6415 #ifdef USE_LISP_UNION_TYPE
6416 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_REGISTER_HOT_KEY
,
6419 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_REGISTER_HOT_KEY
,
6427 DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key
,
6428 Sw32_unregister_hot_key
, 1, 1, 0,
6429 doc
: /* Unregister KEY as a hot-key combination. */)
6435 if (!INTEGERP (key
))
6436 key
= w32_parse_hot_key (key
);
6438 item
= Fmemq (key
, w32_grabbed_keys
);
6442 /* Notify input thread about hot-key definition being removed, so
6443 that it takes effect without needing focus switch. */
6444 #ifdef USE_LISP_UNION_TYPE
6445 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_UNREGISTER_HOT_KEY
,
6446 (WPARAM
) XINT (XCAR (item
)), (LPARAM
) item
.i
))
6448 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_UNREGISTER_HOT_KEY
,
6449 (WPARAM
) XINT (XCAR (item
)), (LPARAM
) item
))
6453 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6460 DEFUN ("w32-registered-hot-keys", Fw32_registered_hot_keys
,
6461 Sw32_registered_hot_keys
, 0, 0, 0,
6462 doc
: /* Return list of registered hot-key IDs. */)
6465 return Fdelq (Qnil
, Fcopy_sequence (w32_grabbed_keys
));
6468 DEFUN ("w32-reconstruct-hot-key", Fw32_reconstruct_hot_key
,
6469 Sw32_reconstruct_hot_key
, 1, 1, 0,
6470 doc
: /* Convert hot-key ID to a lisp key combination.
6471 usage: (w32-reconstruct-hot-key ID) */)
6473 Lisp_Object hotkeyid
;
6475 int vk_code
, w32_modifiers
;
6478 CHECK_NUMBER (hotkeyid
);
6480 vk_code
= HOTKEY_VK_CODE (hotkeyid
);
6481 w32_modifiers
= HOTKEY_MODIFIERS (hotkeyid
);
6483 if (vk_code
< 256 && lispy_function_keys
[vk_code
])
6484 key
= intern (lispy_function_keys
[vk_code
]);
6486 key
= make_number (vk_code
);
6488 key
= Fcons (key
, Qnil
);
6489 if (w32_modifiers
& MOD_SHIFT
)
6490 key
= Fcons (Qshift
, key
);
6491 if (w32_modifiers
& MOD_CONTROL
)
6492 key
= Fcons (Qctrl
, key
);
6493 if (w32_modifiers
& MOD_ALT
)
6494 key
= Fcons (NILP (Vw32_alt_is_meta
) ? Qalt
: Qmeta
, key
);
6495 if (w32_modifiers
& MOD_WIN
)
6496 key
= Fcons (Qhyper
, key
);
6501 DEFUN ("w32-toggle-lock-key", Fw32_toggle_lock_key
,
6502 Sw32_toggle_lock_key
, 1, 2, 0,
6503 doc
: /* Toggle the state of the lock key KEY.
6504 KEY can be `capslock', `kp-numlock', or `scroll'.
6505 If the optional parameter NEW-STATE is a number, then the state of KEY
6506 is set to off if the low bit of NEW-STATE is zero, otherwise on. */)
6508 Lisp_Object key
, new_state
;
6512 if (EQ (key
, intern ("capslock")))
6513 vk_code
= VK_CAPITAL
;
6514 else if (EQ (key
, intern ("kp-numlock")))
6515 vk_code
= VK_NUMLOCK
;
6516 else if (EQ (key
, intern ("scroll")))
6517 vk_code
= VK_SCROLL
;
6521 if (!dwWindowsThreadId
)
6522 return make_number (w32_console_toggle_lock_key (vk_code
, new_state
));
6524 #ifdef USE_LISP_UNION_TYPE
6525 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_TOGGLE_LOCK_KEY
,
6526 (WPARAM
) vk_code
, (LPARAM
) new_state
.i
))
6528 if (PostThreadMessage (dwWindowsThreadId
, WM_EMACS_TOGGLE_LOCK_KEY
,
6529 (WPARAM
) vk_code
, (LPARAM
) new_state
))
6533 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6534 return make_number (msg
.wParam
);
6539 DEFUN ("w32-window-exists-p", Fw32_window_exists_p
, Sw32_window_exists_p
,
6541 doc
: /* Return non-nil if a window exists with the specified CLASS and NAME.
6543 This is a direct interface to the Windows API FindWindow function. */)
6545 Lisp_Object
class, name
;
6550 CHECK_STRING (class);
6552 CHECK_STRING (name
);
6554 hnd
= FindWindow (STRINGP (class) ? ((LPCTSTR
) SDATA (class)) : NULL
,
6555 STRINGP (name
) ? ((LPCTSTR
) SDATA (name
)) : NULL
);
6561 DEFUN ("w32-battery-status", Fw32_battery_status
, Sw32_battery_status
, 0, 0, 0,
6562 doc
: /* Get power status information from Windows system.
6564 The following %-sequences are provided:
6565 %L AC line status (verbose)
6566 %B Battery status (verbose)
6567 %b Battery status, empty means high, `-' means low,
6568 `!' means critical, and `+' means charging
6569 %p Battery load percentage
6570 %s Remaining time (to charge or discharge) in seconds
6571 %m Remaining time (to charge or discharge) in minutes
6572 %h Remaining time (to charge or discharge) in hours
6573 %t Remaining time (to charge or discharge) in the form `h:min' */)
6576 Lisp_Object status
= Qnil
;
6578 SYSTEM_POWER_STATUS system_status
;
6579 if (GetSystemPowerStatus (&system_status
))
6581 Lisp_Object line_status
, battery_status
, battery_status_symbol
;
6582 Lisp_Object load_percentage
, seconds
, minutes
, hours
, remain
;
6583 Lisp_Object sequences
[8];
6585 long seconds_left
= (long) system_status
.BatteryLifeTime
;
6587 if (system_status
.ACLineStatus
== 0)
6588 line_status
= build_string ("off-line");
6589 else if (system_status
.ACLineStatus
== 1)
6590 line_status
= build_string ("on-line");
6592 line_status
= build_string ("N/A");
6594 if (system_status
.BatteryFlag
& 128)
6596 battery_status
= build_string ("N/A");
6597 battery_status_symbol
= build_string ("");
6599 else if (system_status
.BatteryFlag
& 8)
6601 battery_status
= build_string ("charging");
6602 battery_status_symbol
= build_string ("+");
6603 if (system_status
.BatteryFullLifeTime
!= -1L)
6604 seconds_left
= system_status
.BatteryFullLifeTime
- seconds_left
;
6606 else if (system_status
.BatteryFlag
& 4)
6608 battery_status
= build_string ("critical");
6609 battery_status_symbol
= build_string ("!");
6611 else if (system_status
.BatteryFlag
& 2)
6613 battery_status
= build_string ("low");
6614 battery_status_symbol
= build_string ("-");
6616 else if (system_status
.BatteryFlag
& 1)
6618 battery_status
= build_string ("high");
6619 battery_status_symbol
= build_string ("");
6623 battery_status
= build_string ("medium");
6624 battery_status_symbol
= build_string ("");
6627 if (system_status
.BatteryLifePercent
> 100)
6628 load_percentage
= build_string ("N/A");
6632 _snprintf (buffer
, 16, "%d", system_status
.BatteryLifePercent
);
6633 load_percentage
= build_string (buffer
);
6636 if (seconds_left
< 0)
6637 seconds
= minutes
= hours
= remain
= build_string ("N/A");
6643 _snprintf (buffer
, 16, "%ld", seconds_left
);
6644 seconds
= build_string (buffer
);
6646 m
= seconds_left
/ 60;
6647 _snprintf (buffer
, 16, "%ld", m
);
6648 minutes
= build_string (buffer
);
6650 h
= seconds_left
/ 3600.0;
6651 _snprintf (buffer
, 16, "%3.1f", h
);
6652 hours
= build_string (buffer
);
6654 _snprintf (buffer
, 16, "%ld:%02ld", m
/ 60, m
% 60);
6655 remain
= build_string (buffer
);
6657 sequences
[0] = Fcons (make_number ('L'), line_status
);
6658 sequences
[1] = Fcons (make_number ('B'), battery_status
);
6659 sequences
[2] = Fcons (make_number ('b'), battery_status_symbol
);
6660 sequences
[3] = Fcons (make_number ('p'), load_percentage
);
6661 sequences
[4] = Fcons (make_number ('s'), seconds
);
6662 sequences
[5] = Fcons (make_number ('m'), minutes
);
6663 sequences
[6] = Fcons (make_number ('h'), hours
);
6664 sequences
[7] = Fcons (make_number ('t'), remain
);
6666 status
= Flist (8, sequences
);
6672 DEFUN ("file-system-info", Ffile_system_info
, Sfile_system_info
, 1, 1, 0,
6673 doc
: /* Return storage information about the file system FILENAME is on.
6674 Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total
6675 storage of the file system, FREE is the free storage, and AVAIL is the
6676 storage available to a non-superuser. All 3 numbers are in bytes.
6677 If the underlying system call fails, value is nil. */)
6679 Lisp_Object filename
;
6681 Lisp_Object encoded
, value
;
6683 CHECK_STRING (filename
);
6684 filename
= Fexpand_file_name (filename
, Qnil
);
6685 encoded
= ENCODE_FILE (filename
);
6689 /* Determining the required information on Windows turns out, sadly,
6690 to be more involved than one would hope. The original Win32 api
6691 call for this will return bogus information on some systems, but we
6692 must dynamically probe for the replacement api, since that was
6693 added rather late on. */
6695 HMODULE hKernel
= GetModuleHandle ("kernel32");
6696 BOOL (*pfn_GetDiskFreeSpaceEx
)
6697 (char *, PULARGE_INTEGER
, PULARGE_INTEGER
, PULARGE_INTEGER
)
6698 = (void *) GetProcAddress (hKernel
, "GetDiskFreeSpaceEx");
6700 /* On Windows, we may need to specify the root directory of the
6701 volume holding FILENAME. */
6702 char rootname
[MAX_PATH
];
6703 char *name
= SDATA (encoded
);
6705 /* find the root name of the volume if given */
6706 if (isalpha (name
[0]) && name
[1] == ':')
6708 rootname
[0] = name
[0];
6709 rootname
[1] = name
[1];
6713 else if (IS_DIRECTORY_SEP (name
[0]) && IS_DIRECTORY_SEP (name
[1]))
6715 char *str
= rootname
;
6719 if (IS_DIRECTORY_SEP (*name
) && --slashes
== 0)
6729 if (pfn_GetDiskFreeSpaceEx
)
6731 /* Unsigned large integers cannot be cast to double, so
6732 use signed ones instead. */
6733 LARGE_INTEGER availbytes
;
6734 LARGE_INTEGER freebytes
;
6735 LARGE_INTEGER totalbytes
;
6737 if (pfn_GetDiskFreeSpaceEx (rootname
,
6738 (ULARGE_INTEGER
*)&availbytes
,
6739 (ULARGE_INTEGER
*)&totalbytes
,
6740 (ULARGE_INTEGER
*)&freebytes
))
6741 value
= list3 (make_float ((double) totalbytes
.QuadPart
),
6742 make_float ((double) freebytes
.QuadPart
),
6743 make_float ((double) availbytes
.QuadPart
));
6747 DWORD sectors_per_cluster
;
6748 DWORD bytes_per_sector
;
6749 DWORD free_clusters
;
6750 DWORD total_clusters
;
6752 if (GetDiskFreeSpace (rootname
,
6753 §ors_per_cluster
,
6757 value
= list3 (make_float ((double) total_clusters
6758 * sectors_per_cluster
* bytes_per_sector
),
6759 make_float ((double) free_clusters
6760 * sectors_per_cluster
* bytes_per_sector
),
6761 make_float ((double) free_clusters
6762 * sectors_per_cluster
* bytes_per_sector
));
6769 DEFUN ("default-printer-name", Fdefault_printer_name
, Sdefault_printer_name
,
6770 0, 0, 0, doc
: /* Return the name of Windows default printer device. */)
6773 static char pname_buf
[256];
6776 PRINTER_INFO_2
*ppi2
= NULL
;
6777 DWORD dwNeeded
= 0, dwReturned
= 0;
6779 /* Retrieve the default string from Win.ini (the registry).
6780 * String will be in form "printername,drivername,portname".
6781 * This is the most portable way to get the default printer. */
6782 if (GetProfileString ("windows", "device", ",,", pname_buf
, sizeof (pname_buf
)) <= 0)
6784 /* printername precedes first "," character */
6785 strtok (pname_buf
, ",");
6786 /* We want to know more than the printer name */
6787 if (!OpenPrinter (pname_buf
, &hPrn
, NULL
))
6789 GetPrinter (hPrn
, 2, NULL
, 0, &dwNeeded
);
6792 ClosePrinter (hPrn
);
6795 /* Allocate memory for the PRINTER_INFO_2 struct */
6796 ppi2
= (PRINTER_INFO_2
*) xmalloc (dwNeeded
);
6799 ClosePrinter (hPrn
);
6802 /* Call GetPrinter again with big enouth memory block */
6803 err
= GetPrinter (hPrn
, 2, (LPBYTE
)ppi2
, dwNeeded
, &dwReturned
);
6804 ClosePrinter (hPrn
);
6813 if (ppi2
->Attributes
& PRINTER_ATTRIBUTE_SHARED
&& ppi2
->pServerName
)
6815 /* a remote printer */
6816 if (*ppi2
->pServerName
== '\\')
6817 _snprintf (pname_buf
, sizeof (pname_buf
), "%s\\%s", ppi2
->pServerName
,
6820 _snprintf (pname_buf
, sizeof (pname_buf
), "\\\\%s\\%s", ppi2
->pServerName
,
6822 pname_buf
[sizeof (pname_buf
) - 1] = '\0';
6826 /* a local printer */
6827 strncpy (pname_buf
, ppi2
->pPortName
, sizeof (pname_buf
));
6828 pname_buf
[sizeof (pname_buf
) - 1] = '\0';
6829 /* `pPortName' can include several ports, delimited by ','.
6830 * we only use the first one. */
6831 strtok (pname_buf
, ",");
6836 return build_string (pname_buf
);
6839 /***********************************************************************
6841 ***********************************************************************/
6843 /* Keep this list in the same order as frame_parms in frame.c.
6844 Use 0 for unsupported frame parameters. */
6846 frame_parm_handler w32_frame_parm_handlers
[] =
6850 x_set_background_color
,
6856 x_set_foreground_color
,
6859 x_set_internal_border_width
,
6860 x_set_menu_bar_lines
,
6862 x_explicitly_set_name
,
6863 x_set_scroll_bar_width
,
6866 x_set_vertical_scroll_bars
,
6868 x_set_tool_bar_lines
,
6869 0, /* x_set_scroll_bar_foreground, */
6870 0, /* x_set_scroll_bar_background, */
6875 0, /* x_set_wait_for_wm, */
6884 globals_of_w32fns ();
6885 /* This is zero if not using MS-Windows. */
6887 track_mouse_window
= NULL
;
6889 w32_visible_system_caret_hwnd
= NULL
;
6891 DEFSYM (Qnone
, "none");
6892 DEFSYM (Qsuppress_icon
, "suppress-icon");
6893 DEFSYM (Qundefined_color
, "undefined-color");
6894 DEFSYM (Qcancel_timer
, "cancel-timer");
6895 DEFSYM (Qhyper
, "hyper");
6896 DEFSYM (Qsuper
, "super");
6897 DEFSYM (Qmeta
, "meta");
6898 DEFSYM (Qalt
, "alt");
6899 DEFSYM (Qctrl
, "ctrl");
6900 DEFSYM (Qcontrol
, "control");
6901 DEFSYM (Qshift
, "shift");
6902 DEFSYM (Qfont_param
, "font-parameter");
6903 /* This is the end of symbol initialization. */
6905 /* Text property `display' should be nonsticky by default. */
6906 Vtext_property_default_nonsticky
6907 = Fcons (Fcons (Qdisplay
, Qt
), Vtext_property_default_nonsticky
);
6910 Fput (Qundefined_color
, Qerror_conditions
,
6911 Fcons (Qundefined_color
, Fcons (Qerror
, Qnil
)));
6912 Fput (Qundefined_color
, Qerror_message
,
6913 build_string ("Undefined color"));
6915 staticpro (&w32_grabbed_keys
);
6916 w32_grabbed_keys
= Qnil
;
6918 DEFVAR_LISP ("w32-color-map", &Vw32_color_map
,
6919 doc
: /* An array of color name mappings for Windows. */);
6920 Vw32_color_map
= Qnil
;
6922 DEFVAR_LISP ("w32-pass-alt-to-system", &Vw32_pass_alt_to_system
,
6923 doc
: /* Non-nil if Alt key presses are passed on to Windows.
6924 When non-nil, for example, Alt pressed and released and then space will
6925 open the System menu. When nil, Emacs processes the Alt key events, and
6926 then silently swallows them. */);
6927 Vw32_pass_alt_to_system
= Qnil
;
6929 DEFVAR_LISP ("w32-alt-is-meta", &Vw32_alt_is_meta
,
6930 doc
: /* Non-nil if the Alt key is to be considered the same as the META key.
6931 When nil, Emacs will translate the Alt key to the ALT modifier, not to META. */);
6932 Vw32_alt_is_meta
= Qt
;
6934 DEFVAR_INT ("w32-quit-key", &w32_quit_key
,
6935 doc
: /* If non-zero, the virtual key code for an alternative quit key. */);
6938 DEFVAR_LISP ("w32-pass-lwindow-to-system",
6939 &Vw32_pass_lwindow_to_system
,
6940 doc
: /* If non-nil, the left \"Windows\" key is passed on to Windows.
6942 When non-nil, the Start menu is opened by tapping the key.
6943 If you set this to nil, the left \"Windows\" key is processed by Emacs
6944 according to the value of `w32-lwindow-modifier', which see.
6946 Note that some combinations of the left \"Windows\" key with other keys are
6947 caught by Windows at low level, and so binding them in Emacs will have no
6948 effect. For example, <lwindow>-r always pops up the Windows Run dialog,
6949 <lwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
6950 the doc string of `w32-phantom-key-code'. */);
6951 Vw32_pass_lwindow_to_system
= Qt
;
6953 DEFVAR_LISP ("w32-pass-rwindow-to-system",
6954 &Vw32_pass_rwindow_to_system
,
6955 doc
: /* If non-nil, the right \"Windows\" key is passed on to Windows.
6957 When non-nil, the Start menu is opened by tapping the key.
6958 If you set this to nil, the right \"Windows\" key is processed by Emacs
6959 according to the value of `w32-rwindow-modifier', which see.
6961 Note that some combinations of the right \"Windows\" key with other keys are
6962 caught by Windows at low level, and so binding them in Emacs will have no
6963 effect. For example, <rwindow>-r always pops up the Windows Run dialog,
6964 <rwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
6965 the doc string of `w32-phantom-key-code'. */);
6966 Vw32_pass_rwindow_to_system
= Qt
;
6968 DEFVAR_LISP ("w32-phantom-key-code",
6969 &Vw32_phantom_key_code
,
6970 doc
: /* Virtual key code used to generate \"phantom\" key presses.
6971 Value is a number between 0 and 255.
6973 Phantom key presses are generated in order to stop the system from
6974 acting on \"Windows\" key events when `w32-pass-lwindow-to-system' or
6975 `w32-pass-rwindow-to-system' is nil. */);
6976 /* Although 255 is technically not a valid key code, it works and
6977 means that this hack won't interfere with any real key code. */
6978 XSETINT (Vw32_phantom_key_code
, 255);
6980 DEFVAR_LISP ("w32-enable-num-lock",
6981 &Vw32_enable_num_lock
,
6982 doc
: /* If non-nil, the Num Lock key acts normally.
6983 Set to nil to handle Num Lock as the `kp-numlock' key. */);
6984 Vw32_enable_num_lock
= Qt
;
6986 DEFVAR_LISP ("w32-enable-caps-lock",
6987 &Vw32_enable_caps_lock
,
6988 doc
: /* If non-nil, the Caps Lock key acts normally.
6989 Set to nil to handle Caps Lock as the `capslock' key. */);
6990 Vw32_enable_caps_lock
= Qt
;
6992 DEFVAR_LISP ("w32-scroll-lock-modifier",
6993 &Vw32_scroll_lock_modifier
,
6994 doc
: /* Modifier to use for the Scroll Lock ON state.
6995 The value can be hyper, super, meta, alt, control or shift for the
6996 respective modifier, or nil to handle Scroll Lock as the `scroll' key.
6997 Any other value will cause the Scroll Lock key to be ignored. */);
6998 Vw32_scroll_lock_modifier
= Qt
;
7000 DEFVAR_LISP ("w32-lwindow-modifier",
7001 &Vw32_lwindow_modifier
,
7002 doc
: /* Modifier to use for the left \"Windows\" key.
7003 The value can be hyper, super, meta, alt, control or shift for the
7004 respective modifier, or nil to appear as the `lwindow' key.
7005 Any other value will cause the key to be ignored. */);
7006 Vw32_lwindow_modifier
= Qnil
;
7008 DEFVAR_LISP ("w32-rwindow-modifier",
7009 &Vw32_rwindow_modifier
,
7010 doc
: /* Modifier to use for the right \"Windows\" key.
7011 The value can be hyper, super, meta, alt, control or shift for the
7012 respective modifier, or nil to appear as the `rwindow' key.
7013 Any other value will cause the key to be ignored. */);
7014 Vw32_rwindow_modifier
= Qnil
;
7016 DEFVAR_LISP ("w32-apps-modifier",
7017 &Vw32_apps_modifier
,
7018 doc
: /* Modifier to use for the \"Apps\" key.
7019 The value can be hyper, super, meta, alt, control or shift for the
7020 respective modifier, or nil to appear as the `apps' key.
7021 Any other value will cause the key to be ignored. */);
7022 Vw32_apps_modifier
= Qnil
;
7024 DEFVAR_BOOL ("w32-enable-synthesized-fonts", &w32_enable_synthesized_fonts
,
7025 doc
: /* Non-nil enables selection of artificially italicized and bold fonts. */);
7026 w32_enable_synthesized_fonts
= 0;
7028 DEFVAR_LISP ("w32-enable-palette", &Vw32_enable_palette
,
7029 doc
: /* Non-nil enables Windows palette management to map colors exactly. */);
7030 Vw32_enable_palette
= Qt
;
7032 DEFVAR_INT ("w32-mouse-button-tolerance",
7033 &w32_mouse_button_tolerance
,
7034 doc
: /* Analogue of double click interval for faking middle mouse events.
7035 The value is the minimum time in milliseconds that must elapse between
7036 left and right button down events before they are considered distinct events.
7037 If both mouse buttons are depressed within this interval, a middle mouse
7038 button down event is generated instead. */);
7039 w32_mouse_button_tolerance
= GetDoubleClickTime () / 2;
7041 DEFVAR_INT ("w32-mouse-move-interval",
7042 &w32_mouse_move_interval
,
7043 doc
: /* Minimum interval between mouse move events.
7044 The value is the minimum time in milliseconds that must elapse between
7045 successive mouse move (or scroll bar drag) events before they are
7046 reported as lisp events. */);
7047 w32_mouse_move_interval
= 0;
7049 DEFVAR_BOOL ("w32-pass-extra-mouse-buttons-to-system",
7050 &w32_pass_extra_mouse_buttons_to_system
,
7051 doc
: /* If non-nil, the fourth and fifth mouse buttons are passed to Windows.
7052 Recent versions of Windows support mice with up to five buttons.
7053 Since most applications don't support these extra buttons, most mouse
7054 drivers will allow you to map them to functions at the system level.
7055 If this variable is non-nil, Emacs will pass them on, allowing the
7056 system to handle them. */);
7057 w32_pass_extra_mouse_buttons_to_system
= 0;
7059 DEFVAR_BOOL ("w32-pass-multimedia-buttons-to-system",
7060 &w32_pass_multimedia_buttons_to_system
,
7061 doc
: /* If non-nil, media buttons are passed to Windows.
7062 Some modern keyboards contain buttons for controlling media players, web
7063 browsers and other applications. Generally these buttons are handled on a
7064 system wide basis, but by setting this to nil they are made available
7065 to Emacs for binding. Depending on your keyboard, additional keys that
7066 may be available are:
7068 browser-back, browser-forward, browser-refresh, browser-stop,
7069 browser-search, browser-favorites, browser-home,
7070 mail, mail-reply, mail-forward, mail-send,
7072 help, find, new, open, close, save, print, undo, redo, copy, cut, paste,
7073 spell-check, correction-list, toggle-dictate-command,
7074 media-next, media-previous, media-stop, media-play-pause, media-select,
7075 media-play, media-pause, media-record, media-fast-forward, media-rewind,
7076 media-channel-up, media-channel-down,
7077 volume-mute, volume-up, volume-down,
7078 mic-volume-mute, mic-volume-down, mic-volume-up, mic-toggle,
7079 bass-down, bass-boost, bass-up, treble-down, treble-up */);
7080 w32_pass_multimedia_buttons_to_system
= 1;
7082 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape
,
7083 doc
: /* The shape of the pointer when over text.
7084 Changing the value does not affect existing frames
7085 unless you set the mouse color. */);
7086 Vx_pointer_shape
= Qnil
;
7088 Vx_nontext_pointer_shape
= Qnil
;
7090 Vx_mode_pointer_shape
= Qnil
;
7092 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape
,
7093 doc
: /* The shape of the pointer when Emacs is busy.
7094 This variable takes effect when you create a new frame
7095 or when you set the mouse color. */);
7096 Vx_hourglass_pointer_shape
= Qnil
;
7098 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
7099 &Vx_sensitive_text_pointer_shape
,
7100 doc
: /* The shape of the pointer when over mouse-sensitive text.
7101 This variable takes effect when you create a new frame
7102 or when you set the mouse color. */);
7103 Vx_sensitive_text_pointer_shape
= Qnil
;
7105 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
7106 &Vx_window_horizontal_drag_shape
,
7107 doc
: /* Pointer shape to use for indicating a window can be dragged horizontally.
7108 This variable takes effect when you create a new frame
7109 or when you set the mouse color. */);
7110 Vx_window_horizontal_drag_shape
= Qnil
;
7112 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel
,
7113 doc
: /* A string indicating the foreground color of the cursor box. */);
7114 Vx_cursor_fore_pixel
= Qnil
;
7116 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size
,
7117 doc
: /* Maximum size for tooltips.
7118 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
7119 Vx_max_tooltip_size
= Fcons (make_number (80), make_number (40));
7121 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager
,
7122 doc
: /* Non-nil if no window manager is in use.
7123 Emacs doesn't try to figure this out; this is always nil
7124 unless you set it to something else. */);
7125 /* We don't have any way to find this out, so set it to nil
7126 and maybe the user would like to set it to t. */
7127 Vx_no_window_manager
= Qnil
;
7129 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
7130 &Vx_pixel_size_width_font_regexp
,
7131 doc
: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
7133 Since Emacs gets width of a font matching with this regexp from
7134 PIXEL_SIZE field of the name, font finding mechanism gets faster for
7135 such a font. This is especially effective for such large fonts as
7136 Chinese, Japanese, and Korean. */);
7137 Vx_pixel_size_width_font_regexp
= Qnil
;
7139 DEFVAR_LISP ("w32-bdf-filename-alist",
7140 &Vw32_bdf_filename_alist
,
7141 doc
: /* List of bdf fonts and their corresponding filenames. */);
7142 Vw32_bdf_filename_alist
= Qnil
;
7144 DEFVAR_BOOL ("w32-strict-fontnames",
7145 &w32_strict_fontnames
,
7146 doc
: /* Non-nil means only use fonts that are exact matches for those requested.
7147 Default is nil, which allows old fontnames that are not XLFD compliant,
7148 and allows third-party CJK display to work by specifying false charset
7149 fields to trick Emacs into translating to Big5, SJIS etc.
7150 Setting this to t will prevent wrong fonts being selected when
7151 fontsets are automatically created. */);
7152 w32_strict_fontnames
= 0;
7154 DEFVAR_BOOL ("w32-strict-painting",
7155 &w32_strict_painting
,
7156 doc
: /* Non-nil means use strict rules for repainting frames.
7157 Set this to nil to get the old behavior for repainting; this should
7158 only be necessary if the default setting causes problems. */);
7159 w32_strict_painting
= 1;
7161 #if 0 /* TODO: Port to W32 */
7162 defsubr (&Sx_change_window_property
);
7163 defsubr (&Sx_delete_window_property
);
7164 defsubr (&Sx_window_property
);
7166 defsubr (&Sxw_display_color_p
);
7167 defsubr (&Sx_display_grayscale_p
);
7168 defsubr (&Sxw_color_defined_p
);
7169 defsubr (&Sxw_color_values
);
7170 defsubr (&Sx_server_max_request_size
);
7171 defsubr (&Sx_server_vendor
);
7172 defsubr (&Sx_server_version
);
7173 defsubr (&Sx_display_pixel_width
);
7174 defsubr (&Sx_display_pixel_height
);
7175 defsubr (&Sx_display_mm_width
);
7176 defsubr (&Sx_display_mm_height
);
7177 defsubr (&Sx_display_screens
);
7178 defsubr (&Sx_display_planes
);
7179 defsubr (&Sx_display_color_cells
);
7180 defsubr (&Sx_display_visual_class
);
7181 defsubr (&Sx_display_backing_store
);
7182 defsubr (&Sx_display_save_under
);
7183 defsubr (&Sx_create_frame
);
7184 defsubr (&Sx_open_connection
);
7185 defsubr (&Sx_close_connection
);
7186 defsubr (&Sx_display_list
);
7187 defsubr (&Sx_synchronize
);
7188 defsubr (&Sx_focus_frame
);
7190 /* W32 specific functions */
7192 defsubr (&Sw32_define_rgb_color
);
7193 defsubr (&Sw32_default_color_map
);
7194 defsubr (&Sw32_send_sys_command
);
7195 defsubr (&Sw32_shell_execute
);
7196 defsubr (&Sw32_register_hot_key
);
7197 defsubr (&Sw32_unregister_hot_key
);
7198 defsubr (&Sw32_registered_hot_keys
);
7199 defsubr (&Sw32_reconstruct_hot_key
);
7200 defsubr (&Sw32_toggle_lock_key
);
7201 defsubr (&Sw32_window_exists_p
);
7202 defsubr (&Sw32_battery_status
);
7204 defsubr (&Sfile_system_info
);
7205 defsubr (&Sdefault_printer_name
);
7207 check_window_system_func
= check_w32
;
7210 hourglass_timer
= 0;
7211 hourglass_hwnd
= NULL
;
7213 defsubr (&Sx_show_tip
);
7214 defsubr (&Sx_hide_tip
);
7216 staticpro (&tip_timer
);
7218 staticpro (&tip_frame
);
7220 last_show_tip_args
= Qnil
;
7221 staticpro (&last_show_tip_args
);
7223 defsubr (&Sx_file_dialog
);
7224 defsubr (&Ssystem_move_file_to_trash
);
7229 globals_of_w32fns is used to initialize those global variables that
7230 must always be initialized on startup even when the global variable
7231 initialized is non zero (see the function main in emacs.c).
7232 globals_of_w32fns is called from syms_of_w32fns when the global
7233 variable initialized is 0 and directly from main when initialized
7237 globals_of_w32fns ()
7239 HMODULE user32_lib
= GetModuleHandle ("user32.dll");
7241 TrackMouseEvent not available in all versions of Windows, so must load
7242 it dynamically. Do it once, here, instead of every time it is used.
7244 track_mouse_event_fn
= (TrackMouseEvent_Proc
)
7245 GetProcAddress (user32_lib
, "TrackMouseEvent");
7246 /* ditto for GetClipboardSequenceNumber. */
7247 clipboard_sequence_fn
= (ClipboardSequence_Proc
)
7248 GetProcAddress (user32_lib
, "GetClipboardSequenceNumber");
7250 monitor_from_point_fn
= (MonitorFromPoint_Proc
)
7251 GetProcAddress (user32_lib
, "MonitorFromPoint");
7252 get_monitor_info_fn
= (GetMonitorInfo_Proc
)
7253 GetProcAddress (user32_lib
, "GetMonitorInfoA");
7256 HMODULE imm32_lib
= GetModuleHandle ("imm32.dll");
7257 get_composition_string_fn
= (ImmGetCompositionString_Proc
)
7258 GetProcAddress (imm32_lib
, "ImmGetCompositionStringW");
7259 get_ime_context_fn
= (ImmGetContext_Proc
)
7260 GetProcAddress (imm32_lib
, "ImmGetContext");
7262 DEFVAR_INT ("w32-ansi-code-page",
7263 &w32_ansi_code_page
,
7264 doc
: /* The ANSI code page used by the system. */);
7265 w32_ansi_code_page
= GetACP ();
7267 /* MessageBox does not work without this when linked to comctl32.dll 6.0. */
7268 InitCommonControls ();
7270 syms_of_w32uniscribe ();
7279 button
= MessageBox (NULL
,
7280 "A fatal error has occurred!\n\n"
7281 "Would you like to attach a debugger?\n\n"
7282 "Select YES to debug, NO to abort Emacs"
7284 "\n\n(type \"gdb -p <emacs-PID>\" and\n"
7285 "\"continue\" inside GDB before clicking YES.)"
7287 , "Emacs Abort Dialog",
7288 MB_ICONEXCLAMATION
| MB_TASKMODAL
7289 | MB_SETFOREGROUND
| MB_YESNO
);
7294 exit (2); /* tell the compiler we will never return */
7302 /* For convenience when debugging. */
7306 return GetLastError ();
7309 /* arch-tag: 707589ab-b9be-4638-8cdd-74629cc9b446
7310 (do not change this comment) */