]> code.delx.au - gnu-emacs/blob - src/w32fns.c
delx.au / code / gnu-emacs / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge from origin/emacs-25
[gnu-emacs] / src / w32fns.c
1 /* Graphical user interface functions for the Microsoft Windows API.
2
3 Copyright (C) 1989, 1992-2016 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or (at
10 your option) any later version.
11
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* Added by Kevin Gallo */
21
22 #include <config.h>
23 /* Override API version to get the latest functionality. */
24 #undef _WIN32_WINNT
25 #define _WIN32_WINNT 0x0600
26
27 #include <signal.h>
28 #include <stdio.h>
29 #include <limits.h>
30 #include <errno.h>
31 #include <math.h>
32 #include <fcntl.h>
33 #include <unistd.h>
34
35 #include <c-ctype.h>
36
37 #include "lisp.h"
38 #include "w32term.h"
39 #include "frame.h"
40 #include "window.h"
41 #include "buffer.h"
42 #include "keyboard.h"
43 #include "blockinput.h"
44 #include "coding.h"
45
46 #include "w32common.h"
47 #include "w32inevt.h"
48
49 #ifdef WINDOWSNT
50 #include <mbstring.h>
51 #endif /* WINDOWSNT */
52
53 #if CYGWIN
54 #include "cygw32.h"
55 #else
56 #include "w32.h"
57 #endif
58
59 #include <basetyps.h>
60 #include <unknwn.h>
61 #include <commctrl.h>
62 #include <commdlg.h>
63 #include <shellapi.h>
64 #include <shlwapi.h>
65 #include <ctype.h>
66 #include <winspool.h>
67 #include <objbase.h>
68
69 #include <dlgs.h>
70 #include <imm.h>
71 #include <windowsx.h>
72
73 #ifndef FOF_NO_CONNECTED_ELEMENTS
74 #define FOF_NO_CONNECTED_ELEMENTS 0x2000
75 #endif
76
77 void syms_of_w32fns (void);
78 void globals_of_w32fns (void);
79
80 extern void free_frame_menubar (struct frame *);
81 extern int w32_console_toggle_lock_key (int, Lisp_Object);
82 extern void w32_menu_display_help (HWND, HMENU, UINT, UINT);
83 extern void w32_free_menu_strings (HWND);
84 extern const char *map_w32_filename (const char *, const char **);
85 extern char * w32_strerror (int error_no);
86
87 #ifndef IDC_HAND
88 #define IDC_HAND MAKEINTRESOURCE(32649)
89 #endif
90
91 /* Prefix for system colors. */
92 #define SYSTEM_COLOR_PREFIX "System"
93 #define SYSTEM_COLOR_PREFIX_LEN (sizeof (SYSTEM_COLOR_PREFIX) - 1)
94
95 /* State variables for emulating a three button mouse. */
96 #define LMOUSE 1
97 #define MMOUSE 2
98 #define RMOUSE 4
99
100 static int button_state = 0;
101 static W32Msg saved_mouse_button_msg;
102 static unsigned mouse_button_timer = 0; /* non-zero when timer is active */
103 static W32Msg saved_mouse_move_msg;
104 static unsigned mouse_move_timer = 0;
105
106 /* Window that is tracking the mouse. */
107 static HWND track_mouse_window;
108
109 /* Multi-monitor API definitions that are not pulled from the headers
110 since we are compiling for NT 4. */
111 #ifndef MONITOR_DEFAULT_TO_NEAREST
112 #define MONITOR_DEFAULT_TO_NEAREST 2
113 #endif
114 #ifndef MONITORINFOF_PRIMARY
115 #define MONITORINFOF_PRIMARY 1
116 #endif
117 #ifndef SM_XVIRTUALSCREEN
118 #define SM_XVIRTUALSCREEN 76
119 #endif
120 #ifndef SM_YVIRTUALSCREEN
121 #define SM_YVIRTUALSCREEN 77
122 #endif
123 /* MinGW headers define MONITORINFO unconditionally, but MSVC ones don't.
124 To avoid a compile error on one or the other, redefine with a new name. */
125 struct MONITOR_INFO
126 {
127 DWORD cbSize;
128 RECT rcMonitor;
129 RECT rcWork;
130 DWORD dwFlags;
131 };
132
133 #if _WIN32_WINDOWS >= 0x0410
134 #define C_CHILDREN_TITLEBAR CCHILDREN_TITLEBAR
135 typedef TITLEBARINFO TITLEBAR_INFO;
136 #else
137 #define C_CHILDREN_TITLEBAR 5
138 typedef struct
139 {
140 DWORD cbSize;
141 RECT rcTitleBar;
142 DWORD rgstate[C_CHILDREN_TITLEBAR+1];
143 } TITLEBAR_INFO, *PTITLEBAR_INFO;
144 #endif
145
146 #ifndef CCHDEVICENAME
147 #define CCHDEVICENAME 32
148 #endif
149 struct MONITOR_INFO_EX
150 {
151 DWORD cbSize;
152 RECT rcMonitor;
153 RECT rcWork;
154 DWORD dwFlags;
155 char szDevice[CCHDEVICENAME];
156 };
157
158 /* Reportedly, MSVC does not have this in its headers. */
159 #if defined (_MSC_VER) && _WIN32_WINNT < 0x0500
160 DECLARE_HANDLE(HMONITOR);
161 #endif
162
163 typedef BOOL (WINAPI * TrackMouseEvent_Proc)
164 (IN OUT LPTRACKMOUSEEVENT lpEventTrack);
165 typedef LONG (WINAPI * ImmGetCompositionString_Proc)
166 (IN HIMC context, IN DWORD index, OUT LPVOID buffer, IN DWORD bufLen);
167 typedef HIMC (WINAPI * ImmGetContext_Proc) (IN HWND window);
168 typedef BOOL (WINAPI * ImmReleaseContext_Proc) (IN HWND wnd, IN HIMC context);
169 typedef BOOL (WINAPI * ImmSetCompositionWindow_Proc) (IN HIMC context,
170 IN COMPOSITIONFORM *form);
171 typedef HMONITOR (WINAPI * MonitorFromPoint_Proc) (IN POINT pt, IN DWORD flags);
172 typedef BOOL (WINAPI * GetMonitorInfo_Proc)
173 (IN HMONITOR monitor, OUT struct MONITOR_INFO* info);
174 typedef HMONITOR (WINAPI * MonitorFromWindow_Proc)
175 (IN HWND hwnd, IN DWORD dwFlags);
176 typedef BOOL CALLBACK (* MonitorEnum_Proc)
177 (IN HMONITOR monitor, IN HDC hdc, IN RECT *rcMonitor, IN LPARAM dwData);
178 typedef BOOL (WINAPI * EnumDisplayMonitors_Proc)
179 (IN HDC hdc, IN RECT *rcClip, IN MonitorEnum_Proc fnEnum, IN LPARAM dwData);
180 typedef BOOL (WINAPI * GetTitleBarInfo_Proc)
181 (IN HWND hwnd, OUT TITLEBAR_INFO* info);
182
183 TrackMouseEvent_Proc track_mouse_event_fn = NULL;
184 ImmGetCompositionString_Proc get_composition_string_fn = NULL;
185 ImmGetContext_Proc get_ime_context_fn = NULL;
186 ImmReleaseContext_Proc release_ime_context_fn = NULL;
187 ImmSetCompositionWindow_Proc set_ime_composition_window_fn = NULL;
188 MonitorFromPoint_Proc monitor_from_point_fn = NULL;
189 GetMonitorInfo_Proc get_monitor_info_fn = NULL;
190 MonitorFromWindow_Proc monitor_from_window_fn = NULL;
191 EnumDisplayMonitors_Proc enum_display_monitors_fn = NULL;
192 GetTitleBarInfo_Proc get_title_bar_info_fn = NULL;
193
194 #ifdef NTGUI_UNICODE
195 #define unicode_append_menu AppendMenuW
196 #else /* !NTGUI_UNICODE */
197 extern AppendMenuW_Proc unicode_append_menu;
198 #endif /* NTGUI_UNICODE */
199
200 /* Flag to selectively ignore WM_IME_CHAR messages. */
201 static int ignore_ime_char = 0;
202
203 /* W95 mousewheel handler */
204 unsigned int msh_mousewheel = 0;
205
206 /* Timers */
207 #define MOUSE_BUTTON_ID 1
208 #define MOUSE_MOVE_ID 2
209 #define MENU_FREE_ID 3
210 /* The delay (milliseconds) before a menu is freed after WM_EXITMENULOOP
211 is received. */
212 #define MENU_FREE_DELAY 1000
213 static unsigned menu_free_timer = 0;
214
215 #ifdef GLYPH_DEBUG
216 static ptrdiff_t image_cache_refcount;
217 static int dpyinfo_refcount;
218 #endif
219
220 static HWND w32_visible_system_caret_hwnd;
221
222 static int w32_unicode_gui;
223
224 /* From w32menu.c */
225 extern HMENU current_popup_menu;
226 int menubar_in_use = 0;
227
228 /* From w32uniscribe.c */
229 extern void syms_of_w32uniscribe (void);
230 extern int uniscribe_available;
231
232 #ifdef WINDOWSNT
233 /* From w32inevt.c */
234 extern int faked_key;
235 #endif /* WINDOWSNT */
236
237 /* This gives us the page size and the size of the allocation unit on NT. */
238 SYSTEM_INFO sysinfo_cache;
239
240 /* This gives us version, build, and platform identification. */
241 OSVERSIONINFO osinfo_cache;
242
243 DWORD_PTR syspage_mask = 0;
244
245 /* The major and minor versions of NT. */
246 int w32_major_version;
247 int w32_minor_version;
248 int w32_build_number;
249
250 /* Distinguish between Windows NT and Windows 95. */
251 int os_subtype;
252
253 #ifdef HAVE_NTGUI
254 HINSTANCE hinst = NULL;
255 #endif
256
257 static unsigned int sound_type = 0xFFFFFFFF;
258 #define MB_EMACS_SILENT (0xFFFFFFFF - 1)
259
260 /* Special virtual key code for indicating "any" key. */
261 #define VK_ANY 0xFF
262
263 #ifndef WM_WTSSESSION_CHANGE
264 /* 32-bit MinGW does not define these constants. */
265 # define WM_WTSSESSION_CHANGE 0x02B1
266 # define WTS_SESSION_LOCK 0x7
267 #endif
268
269 /* Keyboard hook state data. */
270 static struct
271 {
272 int hook_count; /* counter, if several windows are created */
273 HHOOK hook; /* hook handle */
274 HWND console; /* console window handle */
275
276 int lwindown; /* Left Windows key currently pressed (and hooked) */
277 int rwindown; /* Right Windows key currently pressed (and hooked) */
278 int winsdown; /* Number of handled keys currently pressed */
279 int send_win_up; /* Pass through the keyup for this Windows key press? */
280 int suppress_lone; /* Suppress simulated Windows keydown-keyup for this press? */
281 int winseen; /* Windows keys seen during this press? */
282
283 char alt_hooked[256]; /* hook Alt+[this key]? */
284 char lwin_hooked[256]; /* hook left Win+[this key]? */
285 char rwin_hooked[256]; /* hook right Win+[this key]? */
286 } kbdhook;
287 typedef HWND (WINAPI *GetConsoleWindow_Proc) (void);
288
289 /* stdin, from w32console.c */
290 extern HANDLE keyboard_handle;
291
292 /* Let the user specify a display with a frame.
293 nil stands for the selected frame--or, if that is not a w32 frame,
294 the first display on the list. */
295
296 struct w32_display_info *
297 check_x_display_info (Lisp_Object object)
298 {
299 if (NILP (object))
300 {
301 struct frame *sf = XFRAME (selected_frame);
302
303 if (FRAME_W32_P (sf) && FRAME_LIVE_P (sf))
304 return FRAME_DISPLAY_INFO (sf);
305 else
306 return &one_w32_display_info;
307 }
308 else if (TERMINALP (object))
309 {
310 struct terminal *t = decode_live_terminal (object);
311
312 if (t->type != output_w32)
313 error ("Terminal %d is not a W32 display", t->id);
314
315 return t->display_info.w32;
316 }
317 else if (STRINGP (object))
318 return x_display_info_for_name (object);
319 else
320 {
321 struct frame *f;
322
323 CHECK_LIVE_FRAME (object);
324 f = XFRAME (object);
325 if (! FRAME_W32_P (f))
326 error ("Non-W32 frame used");
327 return FRAME_DISPLAY_INFO (f);
328 }
329 }
330 \f
331 /* Return the Emacs frame-object corresponding to an w32 window.
332 It could be the frame's main window or an icon window. */
333
334 struct frame *
335 x_window_to_frame (struct w32_display_info *dpyinfo, HWND wdesc)
336 {
337 Lisp_Object tail, frame;
338 struct frame *f;
339
340 FOR_EACH_FRAME (tail, frame)
341 {
342 f = XFRAME (frame);
343 if (!FRAME_W32_P (f) || FRAME_DISPLAY_INFO (f) != dpyinfo)
344 continue;
345
346 if (FRAME_W32_WINDOW (f) == wdesc)
347 return f;
348 }
349 return 0;
350 }
351
352 \f
353 static Lisp_Object unwind_create_frame (Lisp_Object);
354 static void unwind_create_tip_frame (Lisp_Object);
355 static void my_create_window (struct frame *);
356 static void my_create_tip_window (struct frame *);
357
358 /* TODO: Native Input Method support; see x_create_im. */
359 void x_set_foreground_color (struct frame *, Lisp_Object, Lisp_Object);
360 void x_set_background_color (struct frame *, Lisp_Object, Lisp_Object);
361 void x_set_mouse_color (struct frame *, Lisp_Object, Lisp_Object);
362 void x_set_cursor_color (struct frame *, Lisp_Object, Lisp_Object);
363 void x_set_border_color (struct frame *, Lisp_Object, Lisp_Object);
364 void x_set_cursor_type (struct frame *, Lisp_Object, Lisp_Object);
365 void x_set_icon_type (struct frame *, Lisp_Object, Lisp_Object);
366 void x_set_icon_name (struct frame *, Lisp_Object, Lisp_Object);
367 void x_explicitly_set_name (struct frame *, Lisp_Object, Lisp_Object);
368 void x_set_menu_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
369 void x_set_title (struct frame *, Lisp_Object, Lisp_Object);
370 void x_set_tool_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
371 void x_set_internal_border_width (struct frame *f, Lisp_Object, Lisp_Object);
372 \f
373
374 /* Store the screen positions of frame F into XPTR and YPTR.
375 These are the positions of the containing window manager window,
376 not Emacs's own window. */
377
378 void
379 x_real_positions (struct frame *f, int *xptr, int *yptr)
380 {
381 POINT pt;
382 RECT rect;
383
384 /* Get the bounds of the WM window. */
385 GetWindowRect (FRAME_W32_WINDOW (f), &rect);
386
387 pt.x = 0;
388 pt.y = 0;
389
390 /* Convert (0, 0) in the client area to screen co-ordinates. */
391 ClientToScreen (FRAME_W32_WINDOW (f), &pt);
392
393 *xptr = rect.left;
394 *yptr = rect.top;
395 }
396
397 /* Returns the window rectangle appropriate for the given fullscreen mode.
398 The normal rect parameter was the window's rectangle prior to entering
399 fullscreen mode. If multiple monitor support is available, the nearest
400 monitor to the window is chosen. */
401
402 void
403 w32_fullscreen_rect (HWND hwnd, int fsmode, RECT normal, RECT *rect)
404 {
405 struct MONITOR_INFO mi = { sizeof(mi) };
406 if (monitor_from_window_fn && get_monitor_info_fn)
407 {
408 HMONITOR monitor =
409 monitor_from_window_fn (hwnd, MONITOR_DEFAULT_TO_NEAREST);
410 get_monitor_info_fn (monitor, &mi);
411 }
412 else
413 {
414 mi.rcMonitor.left = 0;
415 mi.rcMonitor.top = 0;
416 mi.rcMonitor.right = GetSystemMetrics (SM_CXSCREEN);
417 mi.rcMonitor.bottom = GetSystemMetrics (SM_CYSCREEN);
418 mi.rcWork.left = 0;
419 mi.rcWork.top = 0;
420 mi.rcWork.right = GetSystemMetrics (SM_CXMAXIMIZED);
421 mi.rcWork.bottom = GetSystemMetrics (SM_CYMAXIMIZED);
422 }
423
424 switch (fsmode)
425 {
426 case FULLSCREEN_BOTH:
427 rect->left = mi.rcMonitor.left;
428 rect->top = mi.rcMonitor.top;
429 rect->right = mi.rcMonitor.right;
430 rect->bottom = mi.rcMonitor.bottom;
431 break;
432 case FULLSCREEN_WIDTH:
433 rect->left = mi.rcWork.left;
434 rect->top = normal.top;
435 rect->right = mi.rcWork.right;
436 rect->bottom = normal.bottom;
437 break;
438 case FULLSCREEN_HEIGHT:
439 rect->left = normal.left;
440 rect->top = mi.rcWork.top;
441 rect->right = normal.right;
442 rect->bottom = mi.rcWork.bottom;
443 break;
444 default:
445 *rect = normal;
446 break;
447 }
448 }
449
450 \f
451
452 DEFUN ("w32-define-rgb-color", Fw32_define_rgb_color,
453 Sw32_define_rgb_color, 4, 4, 0,
454 doc: /* Convert RGB numbers to a Windows color reference and associate with NAME.
455 This adds or updates a named color to `w32-color-map', making it
456 available for use. The original entry's RGB ref is returned, or nil
457 if the entry is new. */)
458 (Lisp_Object red, Lisp_Object green, Lisp_Object blue, Lisp_Object name)
459 {
460 Lisp_Object rgb;
461 Lisp_Object oldrgb = Qnil;
462 Lisp_Object entry;
463
464 CHECK_NUMBER (red);
465 CHECK_NUMBER (green);
466 CHECK_NUMBER (blue);
467 CHECK_STRING (name);
468
469 XSETINT (rgb, RGB (XUINT (red), XUINT (green), XUINT (blue)));
470
471 block_input ();
472
473 /* replace existing entry in w32-color-map or add new entry. */
474 entry = Fassoc (name, Vw32_color_map);
475 if (NILP (entry))
476 {
477 entry = Fcons (name, rgb);
478 Vw32_color_map = Fcons (entry, Vw32_color_map);
479 }
480 else
481 {
482 oldrgb = Fcdr (entry);
483 Fsetcdr (entry, rgb);
484 }
485
486 unblock_input ();
487
488 return (oldrgb);
489 }
490
491 /* The default colors for the w32 color map */
492 typedef struct colormap_t
493 {
494 char *name;
495 COLORREF colorref;
496 } colormap_t;
497
498 colormap_t w32_color_map[] =
499 {
500 {"snow" , PALETTERGB (255,250,250)},
501 {"ghost white" , PALETTERGB (248,248,255)},
502 {"GhostWhite" , PALETTERGB (248,248,255)},
503 {"white smoke" , PALETTERGB (245,245,245)},
504 {"WhiteSmoke" , PALETTERGB (245,245,245)},
505 {"gainsboro" , PALETTERGB (220,220,220)},
506 {"floral white" , PALETTERGB (255,250,240)},
507 {"FloralWhite" , PALETTERGB (255,250,240)},
508 {"old lace" , PALETTERGB (253,245,230)},
509 {"OldLace" , PALETTERGB (253,245,230)},
510 {"linen" , PALETTERGB (250,240,230)},
511 {"antique white" , PALETTERGB (250,235,215)},
512 {"AntiqueWhite" , PALETTERGB (250,235,215)},
513 {"papaya whip" , PALETTERGB (255,239,213)},
514 {"PapayaWhip" , PALETTERGB (255,239,213)},
515 {"blanched almond" , PALETTERGB (255,235,205)},
516 {"BlanchedAlmond" , PALETTERGB (255,235,205)},
517 {"bisque" , PALETTERGB (255,228,196)},
518 {"peach puff" , PALETTERGB (255,218,185)},
519 {"PeachPuff" , PALETTERGB (255,218,185)},
520 {"navajo white" , PALETTERGB (255,222,173)},
521 {"NavajoWhite" , PALETTERGB (255,222,173)},
522 {"moccasin" , PALETTERGB (255,228,181)},
523 {"cornsilk" , PALETTERGB (255,248,220)},
524 {"ivory" , PALETTERGB (255,255,240)},
525 {"lemon chiffon" , PALETTERGB (255,250,205)},
526 {"LemonChiffon" , PALETTERGB (255,250,205)},
527 {"seashell" , PALETTERGB (255,245,238)},
528 {"honeydew" , PALETTERGB (240,255,240)},
529 {"mint cream" , PALETTERGB (245,255,250)},
530 {"MintCream" , PALETTERGB (245,255,250)},
531 {"azure" , PALETTERGB (240,255,255)},
532 {"alice blue" , PALETTERGB (240,248,255)},
533 {"AliceBlue" , PALETTERGB (240,248,255)},
534 {"lavender" , PALETTERGB (230,230,250)},
535 {"lavender blush" , PALETTERGB (255,240,245)},
536 {"LavenderBlush" , PALETTERGB (255,240,245)},
537 {"misty rose" , PALETTERGB (255,228,225)},
538 {"MistyRose" , PALETTERGB (255,228,225)},
539 {"white" , PALETTERGB (255,255,255)},
540 {"black" , PALETTERGB ( 0, 0, 0)},
541 {"dark slate gray" , PALETTERGB ( 47, 79, 79)},
542 {"DarkSlateGray" , PALETTERGB ( 47, 79, 79)},
543 {"dark slate grey" , PALETTERGB ( 47, 79, 79)},
544 {"DarkSlateGrey" , PALETTERGB ( 47, 79, 79)},
545 {"dim gray" , PALETTERGB (105,105,105)},
546 {"DimGray" , PALETTERGB (105,105,105)},
547 {"dim grey" , PALETTERGB (105,105,105)},
548 {"DimGrey" , PALETTERGB (105,105,105)},
549 {"slate gray" , PALETTERGB (112,128,144)},
550 {"SlateGray" , PALETTERGB (112,128,144)},
551 {"slate grey" , PALETTERGB (112,128,144)},
552 {"SlateGrey" , PALETTERGB (112,128,144)},
553 {"light slate gray" , PALETTERGB (119,136,153)},
554 {"LightSlateGray" , PALETTERGB (119,136,153)},
555 {"light slate grey" , PALETTERGB (119,136,153)},
556 {"LightSlateGrey" , PALETTERGB (119,136,153)},
557 {"gray" , PALETTERGB (190,190,190)},
558 {"grey" , PALETTERGB (190,190,190)},
559 {"light grey" , PALETTERGB (211,211,211)},
560 {"LightGrey" , PALETTERGB (211,211,211)},
561 {"light gray" , PALETTERGB (211,211,211)},
562 {"LightGray" , PALETTERGB (211,211,211)},
563 {"midnight blue" , PALETTERGB ( 25, 25,112)},
564 {"MidnightBlue" , PALETTERGB ( 25, 25,112)},
565 {"navy" , PALETTERGB ( 0, 0,128)},
566 {"navy blue" , PALETTERGB ( 0, 0,128)},
567 {"NavyBlue" , PALETTERGB ( 0, 0,128)},
568 {"cornflower blue" , PALETTERGB (100,149,237)},
569 {"CornflowerBlue" , PALETTERGB (100,149,237)},
570 {"dark slate blue" , PALETTERGB ( 72, 61,139)},
571 {"DarkSlateBlue" , PALETTERGB ( 72, 61,139)},
572 {"slate blue" , PALETTERGB (106, 90,205)},
573 {"SlateBlue" , PALETTERGB (106, 90,205)},
574 {"medium slate blue" , PALETTERGB (123,104,238)},
575 {"MediumSlateBlue" , PALETTERGB (123,104,238)},
576 {"light slate blue" , PALETTERGB (132,112,255)},
577 {"LightSlateBlue" , PALETTERGB (132,112,255)},
578 {"medium blue" , PALETTERGB ( 0, 0,205)},
579 {"MediumBlue" , PALETTERGB ( 0, 0,205)},
580 {"royal blue" , PALETTERGB ( 65,105,225)},
581 {"RoyalBlue" , PALETTERGB ( 65,105,225)},
582 {"blue" , PALETTERGB ( 0, 0,255)},
583 {"dodger blue" , PALETTERGB ( 30,144,255)},
584 {"DodgerBlue" , PALETTERGB ( 30,144,255)},
585 {"deep sky blue" , PALETTERGB ( 0,191,255)},
586 {"DeepSkyBlue" , PALETTERGB ( 0,191,255)},
587 {"sky blue" , PALETTERGB (135,206,235)},
588 {"SkyBlue" , PALETTERGB (135,206,235)},
589 {"light sky blue" , PALETTERGB (135,206,250)},
590 {"LightSkyBlue" , PALETTERGB (135,206,250)},
591 {"steel blue" , PALETTERGB ( 70,130,180)},
592 {"SteelBlue" , PALETTERGB ( 70,130,180)},
593 {"light steel blue" , PALETTERGB (176,196,222)},
594 {"LightSteelBlue" , PALETTERGB (176,196,222)},
595 {"light blue" , PALETTERGB (173,216,230)},
596 {"LightBlue" , PALETTERGB (173,216,230)},
597 {"powder blue" , PALETTERGB (176,224,230)},
598 {"PowderBlue" , PALETTERGB (176,224,230)},
599 {"pale turquoise" , PALETTERGB (175,238,238)},
600 {"PaleTurquoise" , PALETTERGB (175,238,238)},
601 {"dark turquoise" , PALETTERGB ( 0,206,209)},
602 {"DarkTurquoise" , PALETTERGB ( 0,206,209)},
603 {"medium turquoise" , PALETTERGB ( 72,209,204)},
604 {"MediumTurquoise" , PALETTERGB ( 72,209,204)},
605 {"turquoise" , PALETTERGB ( 64,224,208)},
606 {"cyan" , PALETTERGB ( 0,255,255)},
607 {"light cyan" , PALETTERGB (224,255,255)},
608 {"LightCyan" , PALETTERGB (224,255,255)},
609 {"cadet blue" , PALETTERGB ( 95,158,160)},
610 {"CadetBlue" , PALETTERGB ( 95,158,160)},
611 {"medium aquamarine" , PALETTERGB (102,205,170)},
612 {"MediumAquamarine" , PALETTERGB (102,205,170)},
613 {"aquamarine" , PALETTERGB (127,255,212)},
614 {"dark green" , PALETTERGB ( 0,100, 0)},
615 {"DarkGreen" , PALETTERGB ( 0,100, 0)},
616 {"dark olive green" , PALETTERGB ( 85,107, 47)},
617 {"DarkOliveGreen" , PALETTERGB ( 85,107, 47)},
618 {"dark sea green" , PALETTERGB (143,188,143)},
619 {"DarkSeaGreen" , PALETTERGB (143,188,143)},
620 {"sea green" , PALETTERGB ( 46,139, 87)},
621 {"SeaGreen" , PALETTERGB ( 46,139, 87)},
622 {"medium sea green" , PALETTERGB ( 60,179,113)},
623 {"MediumSeaGreen" , PALETTERGB ( 60,179,113)},
624 {"light sea green" , PALETTERGB ( 32,178,170)},
625 {"LightSeaGreen" , PALETTERGB ( 32,178,170)},
626 {"pale green" , PALETTERGB (152,251,152)},
627 {"PaleGreen" , PALETTERGB (152,251,152)},
628 {"spring green" , PALETTERGB ( 0,255,127)},
629 {"SpringGreen" , PALETTERGB ( 0,255,127)},
630 {"lawn green" , PALETTERGB (124,252, 0)},
631 {"LawnGreen" , PALETTERGB (124,252, 0)},
632 {"green" , PALETTERGB ( 0,255, 0)},
633 {"chartreuse" , PALETTERGB (127,255, 0)},
634 {"medium spring green" , PALETTERGB ( 0,250,154)},
635 {"MediumSpringGreen" , PALETTERGB ( 0,250,154)},
636 {"green yellow" , PALETTERGB (173,255, 47)},
637 {"GreenYellow" , PALETTERGB (173,255, 47)},
638 {"lime green" , PALETTERGB ( 50,205, 50)},
639 {"LimeGreen" , PALETTERGB ( 50,205, 50)},
640 {"yellow green" , PALETTERGB (154,205, 50)},
641 {"YellowGreen" , PALETTERGB (154,205, 50)},
642 {"forest green" , PALETTERGB ( 34,139, 34)},
643 {"ForestGreen" , PALETTERGB ( 34,139, 34)},
644 {"olive drab" , PALETTERGB (107,142, 35)},
645 {"OliveDrab" , PALETTERGB (107,142, 35)},
646 {"dark khaki" , PALETTERGB (189,183,107)},
647 {"DarkKhaki" , PALETTERGB (189,183,107)},
648 {"khaki" , PALETTERGB (240,230,140)},
649 {"pale goldenrod" , PALETTERGB (238,232,170)},
650 {"PaleGoldenrod" , PALETTERGB (238,232,170)},
651 {"light goldenrod yellow" , PALETTERGB (250,250,210)},
652 {"LightGoldenrodYellow" , PALETTERGB (250,250,210)},
653 {"light yellow" , PALETTERGB (255,255,224)},
654 {"LightYellow" , PALETTERGB (255,255,224)},
655 {"yellow" , PALETTERGB (255,255, 0)},
656 {"gold" , PALETTERGB (255,215, 0)},
657 {"light goldenrod" , PALETTERGB (238,221,130)},
658 {"LightGoldenrod" , PALETTERGB (238,221,130)},
659 {"goldenrod" , PALETTERGB (218,165, 32)},
660 {"dark goldenrod" , PALETTERGB (184,134, 11)},
661 {"DarkGoldenrod" , PALETTERGB (184,134, 11)},
662 {"rosy brown" , PALETTERGB (188,143,143)},
663 {"RosyBrown" , PALETTERGB (188,143,143)},
664 {"indian red" , PALETTERGB (205, 92, 92)},
665 {"IndianRed" , PALETTERGB (205, 92, 92)},
666 {"saddle brown" , PALETTERGB (139, 69, 19)},
667 {"SaddleBrown" , PALETTERGB (139, 69, 19)},
668 {"sienna" , PALETTERGB (160, 82, 45)},
669 {"peru" , PALETTERGB (205,133, 63)},
670 {"burlywood" , PALETTERGB (222,184,135)},
671 {"beige" , PALETTERGB (245,245,220)},
672 {"wheat" , PALETTERGB (245,222,179)},
673 {"sandy brown" , PALETTERGB (244,164, 96)},
674 {"SandyBrown" , PALETTERGB (244,164, 96)},
675 {"tan" , PALETTERGB (210,180,140)},
676 {"chocolate" , PALETTERGB (210,105, 30)},
677 {"firebrick" , PALETTERGB (178,34, 34)},
678 {"brown" , PALETTERGB (165,42, 42)},
679 {"dark salmon" , PALETTERGB (233,150,122)},
680 {"DarkSalmon" , PALETTERGB (233,150,122)},
681 {"salmon" , PALETTERGB (250,128,114)},
682 {"light salmon" , PALETTERGB (255,160,122)},
683 {"LightSalmon" , PALETTERGB (255,160,122)},
684 {"orange" , PALETTERGB (255,165, 0)},
685 {"dark orange" , PALETTERGB (255,140, 0)},
686 {"DarkOrange" , PALETTERGB (255,140, 0)},
687 {"coral" , PALETTERGB (255,127, 80)},
688 {"light coral" , PALETTERGB (240,128,128)},
689 {"LightCoral" , PALETTERGB (240,128,128)},
690 {"tomato" , PALETTERGB (255, 99, 71)},
691 {"orange red" , PALETTERGB (255, 69, 0)},
692 {"OrangeRed" , PALETTERGB (255, 69, 0)},
693 {"red" , PALETTERGB (255, 0, 0)},
694 {"hot pink" , PALETTERGB (255,105,180)},
695 {"HotPink" , PALETTERGB (255,105,180)},
696 {"deep pink" , PALETTERGB (255, 20,147)},
697 {"DeepPink" , PALETTERGB (255, 20,147)},
698 {"pink" , PALETTERGB (255,192,203)},
699 {"light pink" , PALETTERGB (255,182,193)},
700 {"LightPink" , PALETTERGB (255,182,193)},
701 {"pale violet red" , PALETTERGB (219,112,147)},
702 {"PaleVioletRed" , PALETTERGB (219,112,147)},
703 {"maroon" , PALETTERGB (176, 48, 96)},
704 {"medium violet red" , PALETTERGB (199, 21,133)},
705 {"MediumVioletRed" , PALETTERGB (199, 21,133)},
706 {"violet red" , PALETTERGB (208, 32,144)},
707 {"VioletRed" , PALETTERGB (208, 32,144)},
708 {"magenta" , PALETTERGB (255, 0,255)},
709 {"violet" , PALETTERGB (238,130,238)},
710 {"plum" , PALETTERGB (221,160,221)},
711 {"orchid" , PALETTERGB (218,112,214)},
712 {"medium orchid" , PALETTERGB (186, 85,211)},
713 {"MediumOrchid" , PALETTERGB (186, 85,211)},
714 {"dark orchid" , PALETTERGB (153, 50,204)},
715 {"DarkOrchid" , PALETTERGB (153, 50,204)},
716 {"dark violet" , PALETTERGB (148, 0,211)},
717 {"DarkViolet" , PALETTERGB (148, 0,211)},
718 {"blue violet" , PALETTERGB (138, 43,226)},
719 {"BlueViolet" , PALETTERGB (138, 43,226)},
720 {"purple" , PALETTERGB (160, 32,240)},
721 {"medium purple" , PALETTERGB (147,112,219)},
722 {"MediumPurple" , PALETTERGB (147,112,219)},
723 {"thistle" , PALETTERGB (216,191,216)},
724 {"gray0" , PALETTERGB ( 0, 0, 0)},
725 {"grey0" , PALETTERGB ( 0, 0, 0)},
726 {"dark grey" , PALETTERGB (169,169,169)},
727 {"DarkGrey" , PALETTERGB (169,169,169)},
728 {"dark gray" , PALETTERGB (169,169,169)},
729 {"DarkGray" , PALETTERGB (169,169,169)},
730 {"dark blue" , PALETTERGB ( 0, 0,139)},
731 {"DarkBlue" , PALETTERGB ( 0, 0,139)},
732 {"dark cyan" , PALETTERGB ( 0,139,139)},
733 {"DarkCyan" , PALETTERGB ( 0,139,139)},
734 {"dark magenta" , PALETTERGB (139, 0,139)},
735 {"DarkMagenta" , PALETTERGB (139, 0,139)},
736 {"dark red" , PALETTERGB (139, 0, 0)},
737 {"DarkRed" , PALETTERGB (139, 0, 0)},
738 {"light green" , PALETTERGB (144,238,144)},
739 {"LightGreen" , PALETTERGB (144,238,144)},
740 };
741
742 static Lisp_Object
743 w32_default_color_map (void)
744 {
745 int i;
746 colormap_t *pc = w32_color_map;
747 Lisp_Object cmap;
748
749 block_input ();
750
751 cmap = Qnil;
752
753 for (i = 0; i < ARRAYELTS (w32_color_map); pc++, i++)
754 cmap = Fcons (Fcons (build_string (pc->name),
755 make_number (pc->colorref)),
756 cmap);
757
758 unblock_input ();
759
760 return (cmap);
761 }
762
763 DEFUN ("w32-default-color-map", Fw32_default_color_map, Sw32_default_color_map,
764 0, 0, 0, doc: /* Return the default color map. */)
765 (void)
766 {
767 return w32_default_color_map ();
768 }
769
770 static Lisp_Object
771 w32_color_map_lookup (const char *colorname)
772 {
773 Lisp_Object tail, ret = Qnil;
774
775 block_input ();
776
777 for (tail = Vw32_color_map; CONSP (tail); tail = XCDR (tail))
778 {
779 register Lisp_Object elt, tem;
780
781 elt = XCAR (tail);
782 if (!CONSP (elt)) continue;
783
784 tem = XCAR (elt);
785
786 if (lstrcmpi (SSDATA (tem), colorname) == 0)
787 {
788 ret = Fcdr (elt);
789 break;
790 }
791
792 QUIT;
793 }
794
795 unblock_input ();
796
797 return ret;
798 }
799
800
801 static void
802 add_system_logical_colors_to_map (Lisp_Object *system_colors)
803 {
804 HKEY colors_key;
805
806 /* Other registry operations are done with input blocked. */
807 block_input ();
808
809 /* Look for "Control Panel/Colors" under User and Machine registry
810 settings. */
811 if (RegOpenKeyEx (HKEY_CURRENT_USER, "Control Panel\\Colors", 0,
812 KEY_READ, &colors_key) == ERROR_SUCCESS
813 || RegOpenKeyEx (HKEY_LOCAL_MACHINE, "Control Panel\\Colors", 0,
814 KEY_READ, &colors_key) == ERROR_SUCCESS)
815 {
816 /* List all keys. */
817 char color_buffer[64];
818 char full_name_buffer[MAX_PATH + SYSTEM_COLOR_PREFIX_LEN];
819 int index = 0;
820 DWORD name_size, color_size;
821 char *name_buffer = full_name_buffer + SYSTEM_COLOR_PREFIX_LEN;
822
823 name_size = sizeof (full_name_buffer) - SYSTEM_COLOR_PREFIX_LEN;
824 color_size = sizeof (color_buffer);
825
826 strcpy (full_name_buffer, SYSTEM_COLOR_PREFIX);
827
828 while (RegEnumValueA (colors_key, index, name_buffer, &name_size,
829 NULL, NULL, (LPBYTE)color_buffer, &color_size)
830 == ERROR_SUCCESS)
831 {
832 int r, g, b;
833 if (sscanf (color_buffer, " %u %u %u", &r, &g, &b) == 3)
834 *system_colors = Fcons (Fcons (build_string (full_name_buffer),
835 make_number (RGB (r, g, b))),
836 *system_colors);
837
838 name_size = sizeof (full_name_buffer) - SYSTEM_COLOR_PREFIX_LEN;
839 color_size = sizeof (color_buffer);
840 index++;
841 }
842 RegCloseKey (colors_key);
843 }
844
845 unblock_input ();
846 }
847
848
849 static Lisp_Object
850 x_to_w32_color (const char * colorname)
851 {
852 register Lisp_Object ret = Qnil;
853
854 block_input ();
855
856 if (colorname[0] == '#')
857 {
858 /* Could be an old-style RGB Device specification. */
859 int size = strlen (colorname + 1);
860 char *color = alloca (size + 1);
861
862 strcpy (color, colorname + 1);
863 if (size == 3 || size == 6 || size == 9 || size == 12)
864 {
865 UINT colorval;
866 int i, pos;
867 pos = 0;
868 size /= 3;
869 colorval = 0;
870
871 for (i = 0; i < 3; i++)
872 {
873 char *end;
874 char t;
875 unsigned long value;
876
877 /* The check for 'x' in the following conditional takes into
878 account the fact that strtol allows a "0x" in front of
879 our numbers, and we don't. */
880 if (!isxdigit (color[0]) || color[1] == 'x')
881 break;
882 t = color[size];
883 color[size] = '\0';
884 value = strtoul (color, &end, 16);
885 color[size] = t;
886 if (errno == ERANGE || end - color != size)
887 break;
888 switch (size)
889 {
890 case 1:
891 value = value * 0x10;
892 break;
893 case 2:
894 break;
895 case 3:
896 value /= 0x10;
897 break;
898 case 4:
899 value /= 0x100;
900 break;
901 }
902 colorval |= (value << pos);
903 pos += 0x8;
904 if (i == 2)
905 {
906 unblock_input ();
907 XSETINT (ret, colorval);
908 return ret;
909 }
910 color = end;
911 }
912 }
913 }
914 else if (strnicmp (colorname, "rgb:", 4) == 0)
915 {
916 const char *color;
917 UINT colorval;
918 int i, pos;
919 pos = 0;
920
921 colorval = 0;
922 color = colorname + 4;
923 for (i = 0; i < 3; i++)
924 {
925 char *end;
926 unsigned long value;
927
928 /* The check for 'x' in the following conditional takes into
929 account the fact that strtol allows a "0x" in front of
930 our numbers, and we don't. */
931 if (!isxdigit (color[0]) || color[1] == 'x')
932 break;
933 value = strtoul (color, &end, 16);
934 if (errno == ERANGE)
935 break;
936 switch (end - color)
937 {
938 case 1:
939 value = value * 0x10 + value;
940 break;
941 case 2:
942 break;
943 case 3:
944 value /= 0x10;
945 break;
946 case 4:
947 value /= 0x100;
948 break;
949 default:
950 value = ULONG_MAX;
951 }
952 if (value == ULONG_MAX)
953 break;
954 colorval |= (value << pos);
955 pos += 0x8;
956 if (i == 2)
957 {
958 if (*end != '\0')
959 break;
960 unblock_input ();
961 XSETINT (ret, colorval);
962 return ret;
963 }
964 if (*end != '/')
965 break;
966 color = end + 1;
967 }
968 }
969 else if (strnicmp (colorname, "rgbi:", 5) == 0)
970 {
971 /* This is an RGB Intensity specification. */
972 const char *color;
973 UINT colorval;
974 int i, pos;
975 pos = 0;
976
977 colorval = 0;
978 color = colorname + 5;
979 for (i = 0; i < 3; i++)
980 {
981 char *end;
982 double value;
983 UINT val;
984
985 value = strtod (color, &end);
986 if (errno == ERANGE)
987 break;
988 if (value < 0.0 || value > 1.0)
989 break;
990 val = (UINT)(0x100 * value);
991 /* We used 0x100 instead of 0xFF to give a continuous
992 range between 0.0 and 1.0 inclusive. The next statement
993 fixes the 1.0 case. */
994 if (val == 0x100)
995 val = 0xFF;
996 colorval |= (val << pos);
997 pos += 0x8;
998 if (i == 2)
999 {
1000 if (*end != '\0')
1001 break;
1002 unblock_input ();
1003 XSETINT (ret, colorval);
1004 return ret;
1005 }
1006 if (*end != '/')
1007 break;
1008 color = end + 1;
1009 }
1010 }
1011 /* I am not going to attempt to handle any of the CIE color schemes
1012 or TekHVC, since I don't know the algorithms for conversion to
1013 RGB. */
1014
1015 /* If we fail to lookup the color name in w32_color_map, then check the
1016 colorname to see if it can be crudely approximated: If the X color
1017 ends in a number (e.g., "darkseagreen2"), strip the number and
1018 return the result of looking up the base color name. */
1019 ret = w32_color_map_lookup (colorname);
1020 if (NILP (ret))
1021 {
1022 int len = strlen (colorname);
1023
1024 if (isdigit (colorname[len - 1]))
1025 {
1026 char *ptr, *approx = alloca (len + 1);
1027
1028 strcpy (approx, colorname);
1029 ptr = &approx[len - 1];
1030 while (ptr > approx && isdigit (*ptr))
1031 *ptr-- = '\0';
1032
1033 ret = w32_color_map_lookup (approx);
1034 }
1035 }
1036
1037 unblock_input ();
1038 return ret;
1039 }
1040
1041 void
1042 w32_regenerate_palette (struct frame *f)
1043 {
1044 struct w32_palette_entry * list;
1045 LOGPALETTE * log_palette;
1046 HPALETTE new_palette;
1047 int i;
1048
1049 /* don't bother trying to create palette if not supported */
1050 if (! FRAME_DISPLAY_INFO (f)->has_palette)
1051 return;
1052
1053 log_palette = (LOGPALETTE *)
1054 alloca (sizeof (LOGPALETTE) +
1055 FRAME_DISPLAY_INFO (f)->num_colors * sizeof (PALETTEENTRY));
1056 log_palette->palVersion = 0x300;
1057 log_palette->palNumEntries = FRAME_DISPLAY_INFO (f)->num_colors;
1058
1059 list = FRAME_DISPLAY_INFO (f)->color_list;
1060 for (i = 0;
1061 i < FRAME_DISPLAY_INFO (f)->num_colors;
1062 i++, list = list->next)
1063 log_palette->palPalEntry[i] = list->entry;
1064
1065 new_palette = CreatePalette (log_palette);
1066
1067 enter_crit ();
1068
1069 if (FRAME_DISPLAY_INFO (f)->palette)
1070 DeleteObject (FRAME_DISPLAY_INFO (f)->palette);
1071 FRAME_DISPLAY_INFO (f)->palette = new_palette;
1072
1073 /* Realize display palette and garbage all frames. */
1074 release_frame_dc (f, get_frame_dc (f));
1075
1076 leave_crit ();
1077 }
1078
1079 #define W32_COLOR(pe) RGB (pe.peRed, pe.peGreen, pe.peBlue)
1080 #define SET_W32_COLOR(pe, color) \
1081 do \
1082 { \
1083 pe.peRed = GetRValue (color); \
1084 pe.peGreen = GetGValue (color); \
1085 pe.peBlue = GetBValue (color); \
1086 pe.peFlags = 0; \
1087 } while (0)
1088
1089 #if 0
1090 /* Keep these around in case we ever want to track color usage. */
1091 void
1092 w32_map_color (struct frame *f, COLORREF color)
1093 {
1094 struct w32_palette_entry * list = FRAME_DISPLAY_INFO (f)->color_list;
1095
1096 if (NILP (Vw32_enable_palette))
1097 return;
1098
1099 /* check if color is already mapped */
1100 while (list)
1101 {
1102 if (W32_COLOR (list->entry) == color)
1103 {
1104 ++list->refcount;
1105 return;
1106 }
1107 list = list->next;
1108 }
1109
1110 /* not already mapped, so add to list and recreate Windows palette */
1111 list = xmalloc (sizeof (struct w32_palette_entry));
1112 SET_W32_COLOR (list->entry, color);
1113 list->refcount = 1;
1114 list->next = FRAME_DISPLAY_INFO (f)->color_list;
1115 FRAME_DISPLAY_INFO (f)->color_list = list;
1116 FRAME_DISPLAY_INFO (f)->num_colors++;
1117
1118 /* set flag that palette must be regenerated */
1119 FRAME_DISPLAY_INFO (f)->regen_palette = TRUE;
1120 }
1121
1122 void
1123 w32_unmap_color (struct frame *f, COLORREF color)
1124 {
1125 struct w32_palette_entry * list = FRAME_DISPLAY_INFO (f)->color_list;
1126 struct w32_palette_entry **prev = &FRAME_DISPLAY_INFO (f)->color_list;
1127
1128 if (NILP (Vw32_enable_palette))
1129 return;
1130
1131 /* check if color is already mapped */
1132 while (list)
1133 {
1134 if (W32_COLOR (list->entry) == color)
1135 {
1136 if (--list->refcount == 0)
1137 {
1138 *prev = list->next;
1139 xfree (list);
1140 FRAME_DISPLAY_INFO (f)->num_colors--;
1141 break;
1142 }
1143 else
1144 return;
1145 }
1146 prev = &list->next;
1147 list = list->next;
1148 }
1149
1150 /* set flag that palette must be regenerated */
1151 FRAME_DISPLAY_INFO (f)->regen_palette = TRUE;
1152 }
1153 #endif
1154
1155
1156 /* Gamma-correct COLOR on frame F. */
1157
1158 void
1159 gamma_correct (struct frame *f, COLORREF *color)
1160 {
1161 if (f->gamma)
1162 {
1163 *color = PALETTERGB (
1164 pow (GetRValue (*color) / 255.0, f->gamma) * 255.0 + 0.5,
1165 pow (GetGValue (*color) / 255.0, f->gamma) * 255.0 + 0.5,
1166 pow (GetBValue (*color) / 255.0, f->gamma) * 255.0 + 0.5);
1167 }
1168 }
1169
1170
1171 /* Decide if color named COLOR is valid for the display associated with
1172 the selected frame; if so, return the rgb values in COLOR_DEF.
1173 If ALLOC is nonzero, allocate a new colormap cell. */
1174
1175 int
1176 w32_defined_color (struct frame *f, const char *color, XColor *color_def,
1177 bool alloc_p)
1178 {
1179 register Lisp_Object tem;
1180 COLORREF w32_color_ref;
1181
1182 tem = x_to_w32_color (color);
1183
1184 if (!NILP (tem))
1185 {
1186 if (f)
1187 {
1188 /* Apply gamma correction. */
1189 w32_color_ref = XUINT (tem);
1190 gamma_correct (f, &w32_color_ref);
1191 XSETINT (tem, w32_color_ref);
1192 }
1193
1194 /* Map this color to the palette if it is enabled. */
1195 if (!NILP (Vw32_enable_palette))
1196 {
1197 struct w32_palette_entry * entry =
1198 one_w32_display_info.color_list;
1199 struct w32_palette_entry ** prev =
1200 &one_w32_display_info.color_list;
1201
1202 /* check if color is already mapped */
1203 while (entry)
1204 {
1205 if (W32_COLOR (entry->entry) == XUINT (tem))
1206 break;
1207 prev = &entry->next;
1208 entry = entry->next;
1209 }
1210
1211 if (entry == NULL && alloc_p)
1212 {
1213 /* not already mapped, so add to list */
1214 entry = xmalloc (sizeof (struct w32_palette_entry));
1215 SET_W32_COLOR (entry->entry, XUINT (tem));
1216 entry->next = NULL;
1217 *prev = entry;
1218 one_w32_display_info.num_colors++;
1219
1220 /* set flag that palette must be regenerated */
1221 one_w32_display_info.regen_palette = TRUE;
1222 }
1223 }
1224 /* Ensure COLORREF value is snapped to nearest color in (default)
1225 palette by simulating the PALETTERGB macro. This works whether
1226 or not the display device has a palette. */
1227 w32_color_ref = XUINT (tem) | 0x2000000;
1228
1229 color_def->pixel = w32_color_ref;
1230 color_def->red = GetRValue (w32_color_ref) * 256;
1231 color_def->green = GetGValue (w32_color_ref) * 256;
1232 color_def->blue = GetBValue (w32_color_ref) * 256;
1233
1234 return 1;
1235 }
1236 else
1237 {
1238 return 0;
1239 }
1240 }
1241
1242 /* Given a string ARG naming a color, compute a pixel value from it
1243 suitable for screen F.
1244 If F is not a color screen, return DEF (default) regardless of what
1245 ARG says. */
1246
1247 int
1248 x_decode_color (struct frame *f, Lisp_Object arg, int def)
1249 {
1250 XColor cdef;
1251
1252 CHECK_STRING (arg);
1253
1254 if (strcmp (SSDATA (arg), "black") == 0)
1255 return BLACK_PIX_DEFAULT (f);
1256 else if (strcmp (SSDATA (arg), "white") == 0)
1257 return WHITE_PIX_DEFAULT (f);
1258
1259 if ((FRAME_DISPLAY_INFO (f)->n_planes * FRAME_DISPLAY_INFO (f)->n_cbits) == 1)
1260 return def;
1261
1262 /* w32_defined_color is responsible for coping with failures
1263 by looking for a near-miss. */
1264 if (w32_defined_color (f, SSDATA (arg), &cdef, true))
1265 return cdef.pixel;
1266
1267 /* defined_color failed; return an ultimate default. */
1268 return def;
1269 }
1270 \f
1271
1272
1273 /* Functions called only from `x_set_frame_param'
1274 to set individual parameters.
1275
1276 If FRAME_W32_WINDOW (f) is 0,
1277 the frame is being created and its window does not exist yet.
1278 In that case, just record the parameter's new value
1279 in the standard place; do not attempt to change the window. */
1280
1281 void
1282 x_set_foreground_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1283 {
1284 struct w32_output *x = f->output_data.w32;
1285 PIX_TYPE fg, old_fg;
1286
1287 fg = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1288 old_fg = FRAME_FOREGROUND_PIXEL (f);
1289 FRAME_FOREGROUND_PIXEL (f) = fg;
1290
1291 if (FRAME_W32_WINDOW (f) != 0)
1292 {
1293 if (x->cursor_pixel == old_fg)
1294 {
1295 x->cursor_pixel = fg;
1296 x->cursor_gc->background = fg;
1297 }
1298
1299 update_face_from_frame_parameter (f, Qforeground_color, arg);
1300 if (FRAME_VISIBLE_P (f))
1301 redraw_frame (f);
1302 }
1303 }
1304
1305 void
1306 x_set_background_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1307 {
1308 FRAME_BACKGROUND_PIXEL (f)
1309 = x_decode_color (f, arg, WHITE_PIX_DEFAULT (f));
1310
1311 if (FRAME_W32_WINDOW (f) != 0)
1312 {
1313 SetWindowLong (FRAME_W32_WINDOW (f), WND_BACKGROUND_INDEX,
1314 FRAME_BACKGROUND_PIXEL (f));
1315
1316 update_face_from_frame_parameter (f, Qbackground_color, arg);
1317
1318 if (FRAME_VISIBLE_P (f))
1319 redraw_frame (f);
1320 }
1321 }
1322
1323 void
1324 x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1325 {
1326 #if 0
1327 Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
1328 int count;
1329 #endif
1330 int mask_color;
1331
1332 if (!EQ (Qnil, arg))
1333 f->output_data.w32->mouse_pixel
1334 = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1335 mask_color = FRAME_BACKGROUND_PIXEL (f);
1336
1337 /* Don't let pointers be invisible. */
1338 if (mask_color == f->output_data.w32->mouse_pixel
1339 && mask_color == FRAME_BACKGROUND_PIXEL (f))
1340 f->output_data.w32->mouse_pixel = FRAME_FOREGROUND_PIXEL (f);
1341
1342 #if 0 /* TODO : Mouse cursor customization. */
1343 block_input ();
1344
1345 /* It's not okay to crash if the user selects a screwy cursor. */
1346 count = x_catch_errors (FRAME_W32_DISPLAY (f));
1347
1348 if (!EQ (Qnil, Vx_pointer_shape))
1349 {
1350 CHECK_NUMBER (Vx_pointer_shape);
1351 cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XINT (Vx_pointer_shape));
1352 }
1353 else
1354 cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_xterm);
1355 x_check_errors (FRAME_W32_DISPLAY (f), "bad text pointer cursor: %s");
1356
1357 if (!EQ (Qnil, Vx_nontext_pointer_shape))
1358 {
1359 CHECK_NUMBER (Vx_nontext_pointer_shape);
1360 nontext_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f),
1361 XINT (Vx_nontext_pointer_shape));
1362 }
1363 else
1364 nontext_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_left_ptr);
1365 x_check_errors (FRAME_W32_DISPLAY (f), "bad nontext pointer cursor: %s");
1366
1367 if (!EQ (Qnil, Vx_hourglass_pointer_shape))
1368 {
1369 CHECK_NUMBER (Vx_hourglass_pointer_shape);
1370 hourglass_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f),
1371 XINT (Vx_hourglass_pointer_shape));
1372 }
1373 else
1374 hourglass_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_watch);
1375 x_check_errors (FRAME_W32_DISPLAY (f), "bad busy pointer cursor: %s");
1376
1377 x_check_errors (FRAME_W32_DISPLAY (f), "bad nontext pointer cursor: %s");
1378 if (!EQ (Qnil, Vx_mode_pointer_shape))
1379 {
1380 CHECK_NUMBER (Vx_mode_pointer_shape);
1381 mode_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f),
1382 XINT (Vx_mode_pointer_shape));
1383 }
1384 else
1385 mode_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_xterm);
1386 x_check_errors (FRAME_W32_DISPLAY (f), "bad modeline pointer cursor: %s");
1387
1388 if (!EQ (Qnil, Vx_sensitive_text_pointer_shape))
1389 {
1390 CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
1391 hand_cursor
1392 = XCreateFontCursor (FRAME_W32_DISPLAY (f),
1393 XINT (Vx_sensitive_text_pointer_shape));
1394 }
1395 else
1396 hand_cursor = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_crosshair);
1397
1398 if (!NILP (Vx_window_horizontal_drag_shape))
1399 {
1400 CHECK_NUMBER (Vx_window_horizontal_drag_shape);
1401 horizontal_drag_cursor
1402 = XCreateFontCursor (FRAME_W32_DISPLAY (f),
1403 XINT (Vx_window_horizontal_drag_shape));
1404 }
1405 else
1406 horizontal_drag_cursor
1407 = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_sb_h_double_arrow);
1408
1409 if (!NILP (Vx_window_vertical_drag_shape))
1410 {
1411 CHECK_NUMBER (Vx_window_vertical_drag_shape);
1412 vertical_drag_cursor
1413 = XCreateFontCursor (FRAME_W32_DISPLAY (f),
1414 XINT (Vx_window_vertical_drag_shape));
1415 }
1416 else
1417 vertical_drag_cursor
1418 = XCreateFontCursor (FRAME_W32_DISPLAY (f), XC_sb_v_double_arrow);
1419
1420 /* Check and report errors with the above calls. */
1421 x_check_errors (FRAME_W32_DISPLAY (f), "can't set cursor shape: %s");
1422 x_uncatch_errors (FRAME_W32_DISPLAY (f), count);
1423
1424 {
1425 XColor fore_color, back_color;
1426
1427 fore_color.pixel = f->output_data.w32->mouse_pixel;
1428 back_color.pixel = mask_color;
1429 XQueryColor (FRAME_W32_DISPLAY (f),
1430 DefaultColormap (FRAME_W32_DISPLAY (f),
1431 DefaultScreen (FRAME_W32_DISPLAY (f))),
1432 &fore_color);
1433 XQueryColor (FRAME_W32_DISPLAY (f),
1434 DefaultColormap (FRAME_W32_DISPLAY (f),
1435 DefaultScreen (FRAME_W32_DISPLAY (f))),
1436 &back_color);
1437 XRecolorCursor (FRAME_W32_DISPLAY (f), cursor,
1438 &fore_color, &back_color);
1439 XRecolorCursor (FRAME_W32_DISPLAY (f), nontext_cursor,
1440 &fore_color, &back_color);
1441 XRecolorCursor (FRAME_W32_DISPLAY (f), mode_cursor,
1442 &fore_color, &back_color);
1443 XRecolorCursor (FRAME_W32_DISPLAY (f), hand_cursor,
1444 &fore_color, &back_color);
1445 XRecolorCursor (FRAME_W32_DISPLAY (f), hourglass_cursor,
1446 &fore_color, &back_color);
1447 }
1448
1449 if (FRAME_W32_WINDOW (f) != 0)
1450 XDefineCursor (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f), cursor);
1451
1452 if (cursor != f->output_data.w32->text_cursor && f->output_data.w32->text_cursor != 0)
1453 XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->text_cursor);
1454 f->output_data.w32->text_cursor = cursor;
1455
1456 if (nontext_cursor != f->output_data.w32->nontext_cursor
1457 && f->output_data.w32->nontext_cursor != 0)
1458 XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->nontext_cursor);
1459 f->output_data.w32->nontext_cursor = nontext_cursor;
1460
1461 if (hourglass_cursor != f->output_data.w32->hourglass_cursor
1462 && f->output_data.w32->hourglass_cursor != 0)
1463 XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->hourglass_cursor);
1464 f->output_data.w32->hourglass_cursor = hourglass_cursor;
1465
1466 if (mode_cursor != f->output_data.w32->modeline_cursor
1467 && f->output_data.w32->modeline_cursor != 0)
1468 XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->modeline_cursor);
1469 f->output_data.w32->modeline_cursor = mode_cursor;
1470
1471 if (hand_cursor != f->output_data.w32->hand_cursor
1472 && f->output_data.w32->hand_cursor != 0)
1473 XFreeCursor (FRAME_W32_DISPLAY (f), f->output_data.w32->hand_cursor);
1474 f->output_data.w32->hand_cursor = hand_cursor;
1475
1476 XFlush (FRAME_W32_DISPLAY (f));
1477 unblock_input ();
1478
1479 update_face_from_frame_parameter (f, Qmouse_color, arg);
1480 #endif /* TODO */
1481 }
1482
1483 void
1484 x_set_cursor_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1485 {
1486 unsigned long fore_pixel, pixel;
1487
1488 if (!NILP (Vx_cursor_fore_pixel))
1489 fore_pixel = x_decode_color (f, Vx_cursor_fore_pixel,
1490 WHITE_PIX_DEFAULT (f));
1491 else
1492 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1493
1494 pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1495
1496 /* Make sure that the cursor color differs from the background color. */
1497 if (pixel == FRAME_BACKGROUND_PIXEL (f))
1498 {
1499 pixel = f->output_data.w32->mouse_pixel;
1500 if (pixel == fore_pixel)
1501 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1502 }
1503
1504 f->output_data.w32->cursor_foreground_pixel = fore_pixel;
1505 f->output_data.w32->cursor_pixel = pixel;
1506
1507 if (FRAME_W32_WINDOW (f) != 0)
1508 {
1509 block_input ();
1510 /* Update frame's cursor_gc. */
1511 f->output_data.w32->cursor_gc->foreground = fore_pixel;
1512 f->output_data.w32->cursor_gc->background = pixel;
1513
1514 unblock_input ();
1515
1516 if (FRAME_VISIBLE_P (f))
1517 {
1518 x_update_cursor (f, 0);
1519 x_update_cursor (f, 1);
1520 }
1521 }
1522
1523 update_face_from_frame_parameter (f, Qcursor_color, arg);
1524 }
1525
1526 /* Set the border-color of frame F to pixel value PIX.
1527 Note that this does not fully take effect if done before
1528 F has a window. */
1529
1530 void
1531 x_set_border_pixel (struct frame *f, int pix)
1532 {
1533
1534 f->output_data.w32->border_pixel = pix;
1535
1536 if (FRAME_W32_WINDOW (f) != 0 && f->border_width > 0)
1537 {
1538 if (FRAME_VISIBLE_P (f))
1539 redraw_frame (f);
1540 }
1541 }
1542
1543 /* Set the border-color of frame F to value described by ARG.
1544 ARG can be a string naming a color.
1545 The border-color is used for the border that is drawn by the server.
1546 Note that this does not fully take effect if done before
1547 F has a window; it must be redone when the window is created. */
1548
1549 void
1550 x_set_border_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1551 {
1552 int pix;
1553
1554 CHECK_STRING (arg);
1555 pix = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1556 x_set_border_pixel (f, pix);
1557 update_face_from_frame_parameter (f, Qborder_color, arg);
1558 }
1559
1560
1561 void
1562 x_set_cursor_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1563 {
1564 set_frame_cursor_types (f, arg);
1565 }
1566
1567 void
1568 x_set_icon_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1569 {
1570 bool result;
1571
1572 if (NILP (arg) && NILP (oldval))
1573 return;
1574
1575 if (STRINGP (arg) && STRINGP (oldval)
1576 && EQ (Fstring_equal (oldval, arg), Qt))
1577 return;
1578
1579 if (SYMBOLP (arg) && SYMBOLP (oldval) && EQ (arg, oldval))
1580 return;
1581
1582 block_input ();
1583
1584 result = x_bitmap_icon (f, arg);
1585 if (result)
1586 {
1587 unblock_input ();
1588 error ("No icon window available");
1589 }
1590
1591 unblock_input ();
1592 }
1593
1594 void
1595 x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1596 {
1597 if (STRINGP (arg))
1598 {
1599 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1600 return;
1601 }
1602 else if (!NILP (arg) || NILP (oldval))
1603 return;
1604
1605 fset_icon_name (f, arg);
1606
1607 #if 0
1608 if (f->output_data.w32->icon_bitmap != 0)
1609 return;
1610
1611 block_input ();
1612
1613 result = x_text_icon (f,
1614 SSDATA ((!NILP (f->icon_name)
1615 ? f->icon_name
1616 : !NILP (f->title)
1617 ? f->title
1618 : f->name)));
1619
1620 if (result)
1621 {
1622 unblock_input ();
1623 error ("No icon window available");
1624 }
1625
1626 /* If the window was unmapped (and its icon was mapped),
1627 the new icon is not mapped, so map the window in its stead. */
1628 if (FRAME_VISIBLE_P (f))
1629 {
1630 #ifdef USE_X_TOOLKIT
1631 XtPopup (f->output_data.w32->widget, XtGrabNone);
1632 #endif
1633 XMapWindow (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f));
1634 }
1635
1636 XFlush (FRAME_W32_DISPLAY (f));
1637 unblock_input ();
1638 #endif
1639 }
1640 \f
1641 void
1642 x_clear_under_internal_border (struct frame *f)
1643 {
1644 int border = FRAME_INTERNAL_BORDER_WIDTH (f);
1645
1646 /* Clear border if it's larger than before. */
1647 if (border != 0)
1648 {
1649 HDC hdc = get_frame_dc (f);
1650 int width = FRAME_PIXEL_WIDTH (f);
1651 int height = FRAME_PIXEL_HEIGHT (f);
1652
1653 block_input ();
1654 w32_clear_area (f, hdc, 0, FRAME_TOP_MARGIN_HEIGHT (f), width, border);
1655 w32_clear_area (f, hdc, 0, 0, border, height);
1656 w32_clear_area (f, hdc, width - border, 0, border, height);
1657 w32_clear_area (f, hdc, 0, height - border, width, border);
1658 release_frame_dc (f, hdc);
1659 unblock_input ();
1660 }
1661 }
1662
1663
1664 void
1665 x_set_internal_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1666 {
1667 int border;
1668
1669 CHECK_TYPE_RANGED_INTEGER (int, arg);
1670 border = max (XINT (arg), 0);
1671
1672 if (border != FRAME_INTERNAL_BORDER_WIDTH (f))
1673 {
1674 FRAME_INTERNAL_BORDER_WIDTH (f) = border;
1675
1676 if (FRAME_X_WINDOW (f) != 0)
1677 {
1678 adjust_frame_size (f, -1, -1, 3, false, Qinternal_border_width);
1679
1680 if (FRAME_VISIBLE_P (f))
1681 x_clear_under_internal_border (f);
1682 }
1683 }
1684 }
1685
1686
1687 void
1688 x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1689 {
1690 int nlines;
1691
1692 /* Right now, menu bars don't work properly in minibuf-only frames;
1693 most of the commands try to apply themselves to the minibuffer
1694 frame itself, and get an error because you can't switch buffers
1695 in or split the minibuffer window. */
1696 if (FRAME_MINIBUF_ONLY_P (f))
1697 return;
1698
1699 if (INTEGERP (value))
1700 nlines = XINT (value);
1701 else
1702 nlines = 0;
1703
1704 FRAME_MENU_BAR_LINES (f) = 0;
1705 FRAME_MENU_BAR_HEIGHT (f) = 0;
1706 if (nlines)
1707 FRAME_EXTERNAL_MENU_BAR (f) = 1;
1708 else
1709 {
1710 if (FRAME_EXTERNAL_MENU_BAR (f) == 1)
1711 free_frame_menubar (f);
1712 FRAME_EXTERNAL_MENU_BAR (f) = 0;
1713
1714 /* Adjust the frame size so that the client (text) dimensions
1715 remain the same. This depends on FRAME_EXTERNAL_MENU_BAR being
1716 set correctly. Note that we resize twice: The first time upon
1717 a request from the window manager who wants to keep the height
1718 of the outer rectangle (including decorations) unchanged, and a
1719 second time because we want to keep the height of the inner
1720 rectangle (without the decorations unchanged). */
1721 adjust_frame_size (f, -1, -1, 2, true, Qmenu_bar_lines);
1722
1723 /* Not sure whether this is needed. */
1724 x_clear_under_internal_border (f);
1725 }
1726 }
1727
1728
1729 /* Set the number of lines used for the tool bar of frame F to VALUE.
1730 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL is
1731 the old number of tool bar lines (and is unused). This function may
1732 change the height of all windows on frame F to match the new tool bar
1733 height. By design, the frame's height doesn't change (but maybe it
1734 should if we don't get enough space otherwise). */
1735
1736 void
1737 x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1738 {
1739 int nlines;
1740
1741 /* Treat tool bars like menu bars. */
1742 if (FRAME_MINIBUF_ONLY_P (f))
1743 return;
1744
1745 /* Use VALUE only if an integer >= 0. */
1746 if (INTEGERP (value) && XINT (value) >= 0)
1747 nlines = XFASTINT (value);
1748 else
1749 nlines = 0;
1750
1751 x_change_tool_bar_height (f, nlines * FRAME_LINE_HEIGHT (f));
1752 }
1753
1754
1755 /* Set the pixel height of the tool bar of frame F to HEIGHT. */
1756 void
1757 x_change_tool_bar_height (struct frame *f, int height)
1758 {
1759 int unit = FRAME_LINE_HEIGHT (f);
1760 int old_height = FRAME_TOOL_BAR_HEIGHT (f);
1761 int lines = (height + unit - 1) / unit;
1762 Lisp_Object fullscreen;
1763
1764 /* Make sure we redisplay all windows in this frame. */
1765 windows_or_buffers_changed = 23;
1766
1767 /* Recalculate tool bar and frame text sizes. */
1768 FRAME_TOOL_BAR_HEIGHT (f) = height;
1769 FRAME_TOOL_BAR_LINES (f) = lines;
1770 /* Store `tool-bar-lines' and `height' frame parameters. */
1771 store_frame_param (f, Qtool_bar_lines, make_number (lines));
1772 store_frame_param (f, Qheight, make_number (FRAME_LINES (f)));
1773
1774 if (FRAME_W32_WINDOW (f) && FRAME_TOOL_BAR_HEIGHT (f) == 0)
1775 {
1776 clear_frame (f);
1777 clear_current_matrices (f);
1778 }
1779
1780 if ((height < old_height) && WINDOWP (f->tool_bar_window))
1781 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
1782
1783 /* Recalculate toolbar height. */
1784 f->n_tool_bar_rows = 0;
1785 if (old_height == 0
1786 && (!f->after_make_frame
1787 || NILP (frame_inhibit_implied_resize)
1788 || (CONSP (frame_inhibit_implied_resize)
1789 && NILP (Fmemq (Qtool_bar_lines, frame_inhibit_implied_resize)))))
1790 f->tool_bar_redisplayed = f->tool_bar_resized = false;
1791
1792 adjust_frame_size (f, -1, -1,
1793 ((!f->tool_bar_resized
1794 && (NILP (fullscreen =
1795 get_frame_param (f, Qfullscreen))
1796 || EQ (fullscreen, Qfullwidth))) ? 1
1797 : (old_height == 0 || height == 0) ? 2
1798 : 4),
1799 false, Qtool_bar_lines);
1800
1801 f->tool_bar_resized = f->tool_bar_redisplayed;
1802
1803 /* adjust_frame_size might not have done anything, garbage frame
1804 here. */
1805 adjust_frame_glyphs (f);
1806 SET_FRAME_GARBAGED (f);
1807 if (FRAME_X_WINDOW (f))
1808 x_clear_under_internal_border (f);
1809 }
1810
1811 static void
1812 w32_set_title_bar_text (struct frame *f, Lisp_Object name)
1813 {
1814 if (FRAME_W32_WINDOW (f))
1815 {
1816 block_input ();
1817 #ifdef __CYGWIN__
1818 GUI_FN (SetWindowText) (FRAME_W32_WINDOW (f),
1819 GUI_SDATA (GUI_ENCODE_SYSTEM (name)));
1820 #else
1821 /* The frame's title many times shows the name of the file
1822 visited in the selected window's buffer, so it makes sense to
1823 support non-ASCII characters outside of the current system
1824 codepage in the title. */
1825 if (w32_unicode_filenames)
1826 {
1827 Lisp_Object encoded_title = ENCODE_UTF_8 (name);
1828 wchar_t *title_w;
1829 int tlen = pMultiByteToWideChar (CP_UTF8, 0, SSDATA (encoded_title),
1830 -1, NULL, 0);
1831
1832 if (tlen > 0)
1833 {
1834 /* Windows truncates the title text beyond what fits on
1835 a single line, so we can limit the length to some
1836 reasonably large value, and use alloca. */
1837 if (tlen > 10000)
1838 tlen = 10000;
1839 title_w = alloca ((tlen + 1) * sizeof (wchar_t));
1840 pMultiByteToWideChar (CP_UTF8, 0, SSDATA (encoded_title), -1,
1841 title_w, tlen);
1842 title_w[tlen] = L'\0';
1843 SetWindowTextW (FRAME_W32_WINDOW (f), title_w);
1844 }
1845 else /* Conversion to UTF-16 failed, so we punt. */
1846 SetWindowTextA (FRAME_W32_WINDOW (f),
1847 SSDATA (ENCODE_SYSTEM (name)));
1848 }
1849 else
1850 SetWindowTextA (FRAME_W32_WINDOW (f), SSDATA (ENCODE_SYSTEM (name)));
1851 #endif
1852 unblock_input ();
1853 }
1854 }
1855
1856 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1857 w32_id_name.
1858
1859 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1860 name; if NAME is a string, set F's name to NAME and set
1861 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1862
1863 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1864 suggesting a new name, which lisp code should override; if
1865 F->explicit_name is set, ignore the new name; otherwise, set it. */
1866
1867 void
1868 x_set_name (struct frame *f, Lisp_Object name, bool explicit)
1869 {
1870 /* Make sure that requests from lisp code override requests from
1871 Emacs redisplay code. */
1872 if (explicit)
1873 {
1874 /* If we're switching from explicit to implicit, we had better
1875 update the mode lines and thereby update the title. */
1876 if (f->explicit_name && NILP (name))
1877 update_mode_lines = 25;
1878
1879 f->explicit_name = ! NILP (name);
1880 }
1881 else if (f->explicit_name)
1882 return;
1883
1884 /* If NAME is nil, set the name to the w32_id_name. */
1885 if (NILP (name))
1886 {
1887 /* Check for no change needed in this very common case
1888 before we do any consing. */
1889 if (!strcmp (FRAME_DISPLAY_INFO (f)->w32_id_name,
1890 SSDATA (f->name)))
1891 return;
1892 name = build_string (FRAME_DISPLAY_INFO (f)->w32_id_name);
1893 }
1894 else
1895 CHECK_STRING (name);
1896
1897 /* Don't change the name if it's already NAME. */
1898 if (! NILP (Fstring_equal (name, f->name)))
1899 return;
1900
1901 fset_name (f, name);
1902
1903 /* For setting the frame title, the title parameter should override
1904 the name parameter. */
1905 if (! NILP (f->title))
1906 name = f->title;
1907
1908 w32_set_title_bar_text (f, name);
1909 }
1910
1911 /* This function should be called when the user's lisp code has
1912 specified a name for the frame; the name will override any set by the
1913 redisplay code. */
1914 void
1915 x_explicitly_set_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1916 {
1917 x_set_name (f, arg, true);
1918 }
1919
1920 /* This function should be called by Emacs redisplay code to set the
1921 name; names set this way will never override names set by the user's
1922 lisp code. */
1923 void
1924 x_implicitly_set_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1925 {
1926 x_set_name (f, arg, false);
1927 }
1928 \f
1929 /* Change the title of frame F to NAME.
1930 If NAME is nil, use the frame name as the title. */
1931
1932 void
1933 x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
1934 {
1935 /* Don't change the title if it's already NAME. */
1936 if (EQ (name, f->title))
1937 return;
1938
1939 update_mode_lines = 26;
1940
1941 fset_title (f, name);
1942
1943 if (NILP (name))
1944 name = f->name;
1945
1946 w32_set_title_bar_text (f, name);
1947 }
1948
1949 void
1950 x_set_scroll_bar_default_width (struct frame *f)
1951 {
1952 int unit = FRAME_COLUMN_WIDTH (f);
1953
1954 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = GetSystemMetrics (SM_CXVSCROLL);
1955 FRAME_CONFIG_SCROLL_BAR_COLS (f)
1956 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + unit - 1) / unit;
1957 }
1958
1959
1960 void
1961 x_set_scroll_bar_default_height (struct frame *f)
1962 {
1963 int unit = FRAME_LINE_HEIGHT (f);
1964
1965 FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = GetSystemMetrics (SM_CXHSCROLL);
1966 FRAME_CONFIG_SCROLL_BAR_LINES (f)
1967 = (FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) + unit - 1) / unit;
1968 }
1969 \f
1970 /* Subroutines for creating a frame. */
1971
1972 Cursor
1973 w32_load_cursor (LPCTSTR name)
1974 {
1975 /* Try first to load cursor from application resource. */
1976 Cursor cursor = LoadImage ((HINSTANCE) GetModuleHandle (NULL),
1977 name, IMAGE_CURSOR, 0, 0,
1978 LR_DEFAULTCOLOR | LR_DEFAULTSIZE | LR_SHARED);
1979 if (!cursor)
1980 {
1981 /* Then try to load a shared predefined cursor. */
1982 cursor = LoadImage (NULL, name, IMAGE_CURSOR, 0, 0,
1983 LR_DEFAULTCOLOR | LR_DEFAULTSIZE | LR_SHARED);
1984 }
1985 return cursor;
1986 }
1987
1988 static LRESULT CALLBACK w32_wnd_proc (HWND, UINT, WPARAM, LPARAM);
1989
1990 #define INIT_WINDOW_CLASS(WC) \
1991 (WC).style = CS_HREDRAW | CS_VREDRAW; \
1992 (WC).lpfnWndProc = (WNDPROC) w32_wnd_proc; \
1993 (WC).cbClsExtra = 0; \
1994 (WC).cbWndExtra = WND_EXTRA_BYTES; \
1995 (WC).hInstance = hinst; \
1996 (WC).hIcon = LoadIcon (hinst, EMACS_CLASS); \
1997 (WC).hCursor = w32_load_cursor (IDC_ARROW); \
1998 (WC).hbrBackground = NULL; \
1999 (WC).lpszMenuName = NULL; \
2000
2001 static BOOL
2002 w32_init_class (HINSTANCE hinst)
2003 {
2004 if (w32_unicode_gui)
2005 {
2006 WNDCLASSW uwc;
2007 INIT_WINDOW_CLASS(uwc);
2008 uwc.lpszClassName = L"Emacs";
2009
2010 return RegisterClassW (&uwc);
2011 }
2012 else
2013 {
2014 WNDCLASS wc;
2015 INIT_WINDOW_CLASS(wc);
2016 wc.lpszClassName = EMACS_CLASS;
2017
2018 return RegisterClassA (&wc);
2019 }
2020 }
2021
2022 static HWND
2023 w32_createvscrollbar (struct frame *f, struct scroll_bar * bar)
2024 {
2025 return CreateWindow ("SCROLLBAR", "", SBS_VERT | WS_CHILD | WS_VISIBLE,
2026 /* Position and size of scroll bar. */
2027 bar->left, bar->top, bar->width, bar->height,
2028 FRAME_W32_WINDOW (f), NULL, hinst, NULL);
2029 }
2030
2031 static HWND
2032 w32_createhscrollbar (struct frame *f, struct scroll_bar * bar)
2033 {
2034 return CreateWindow ("SCROLLBAR", "", SBS_HORZ | WS_CHILD | WS_VISIBLE,
2035 /* Position and size of scroll bar. */
2036 bar->left, bar->top, bar->width, bar->height,
2037 FRAME_W32_WINDOW (f), NULL, hinst, NULL);
2038 }
2039
2040 static void
2041 w32_createwindow (struct frame *f, int *coords)
2042 {
2043 HWND hwnd;
2044 RECT rect;
2045 int top;
2046 int left;
2047
2048 rect.left = rect.top = 0;
2049 rect.right = FRAME_PIXEL_WIDTH (f);
2050 rect.bottom = FRAME_PIXEL_HEIGHT (f);
2051
2052 AdjustWindowRect (&rect, f->output_data.w32->dwStyle,
2053 FRAME_EXTERNAL_MENU_BAR (f));
2054
2055 /* Do first time app init */
2056
2057 w32_init_class (hinst);
2058
2059 if (f->size_hint_flags & USPosition || f->size_hint_flags & PPosition)
2060 {
2061 left = f->left_pos;
2062 top = f->top_pos;
2063 }
2064 else
2065 {
2066 left = coords[0];
2067 top = coords[1];
2068 }
2069
2070 FRAME_W32_WINDOW (f) = hwnd
2071 = CreateWindow (EMACS_CLASS,
2072 f->namebuf,
2073 f->output_data.w32->dwStyle | WS_CLIPCHILDREN,
2074 left, top,
2075 rect.right - rect.left, rect.bottom - rect.top,
2076 NULL,
2077 NULL,
2078 hinst,
2079 NULL);
2080
2081 if (hwnd)
2082 {
2083 SetWindowLong (hwnd, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
2084 SetWindowLong (hwnd, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
2085 SetWindowLong (hwnd, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
2086 SetWindowLong (hwnd, WND_VSCROLLBAR_INDEX, FRAME_SCROLL_BAR_AREA_WIDTH (f));
2087 SetWindowLong (hwnd, WND_HSCROLLBAR_INDEX, FRAME_SCROLL_BAR_AREA_HEIGHT (f));
2088 SetWindowLong (hwnd, WND_BACKGROUND_INDEX, FRAME_BACKGROUND_PIXEL (f));
2089
2090 /* Enable drag-n-drop. */
2091 DragAcceptFiles (hwnd, TRUE);
2092
2093 /* Do this to discard the default setting specified by our parent. */
2094 ShowWindow (hwnd, SW_HIDE);
2095
2096 /* Update frame positions. */
2097 GetWindowRect (hwnd, &rect);
2098 f->left_pos = rect.left;
2099 f->top_pos = rect.top;
2100 }
2101 }
2102
2103 static void
2104 my_post_msg (W32Msg * wmsg, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
2105 {
2106 wmsg->msg.hwnd = hwnd;
2107 wmsg->msg.message = msg;
2108 wmsg->msg.wParam = wParam;
2109 wmsg->msg.lParam = lParam;
2110 wmsg->msg.time = GetMessageTime ();
2111
2112 post_msg (wmsg);
2113 }
2114
2115 #ifdef WINDOWSNT
2116 /* The Windows keyboard hook callback. */
2117 static LRESULT CALLBACK
2118 funhook (int code, WPARAM w, LPARAM l)
2119 {
2120 INPUT inputs[2];
2121 HWND focus = GetFocus ();
2122 int console = 0;
2123 KBDLLHOOKSTRUCT const *hs = (KBDLLHOOKSTRUCT*)l;
2124
2125 if (code < 0 || (hs->flags & LLKHF_INJECTED))
2126 return CallNextHookEx (0, code, w, l);
2127
2128 /* The keyboard hook sees keyboard input on all processes (except
2129 elevated ones, when Emacs itself is not elevated). As such,
2130 care must be taken to only filter out keyboard input when Emacs
2131 itself is on the foreground.
2132
2133 GetFocus returns a non-NULL window if another application is active,
2134 and always for a console Emacs process. For a console Emacs, determine
2135 focus by checking if the current foreground window is the process's
2136 console window. */
2137 if (focus == NULL && kbdhook.console != NULL)
2138 {
2139 if (GetForegroundWindow () == kbdhook.console)
2140 {
2141 focus = kbdhook.console;
2142 console = 1;
2143 }
2144 }
2145
2146 /* First, check hooks for the left and right Windows keys. */
2147 if (hs->vkCode == VK_LWIN || hs->vkCode == VK_RWIN)
2148 {
2149 if (focus != NULL && (w == WM_KEYDOWN || w == WM_SYSKEYDOWN))
2150 {
2151 /* The key is being pressed in an Emacs window. */
2152 if (hs->vkCode == VK_LWIN && !kbdhook.lwindown)
2153 {
2154 kbdhook.lwindown = 1;
2155 kbdhook.winseen = 1;
2156 kbdhook.winsdown++;
2157 }
2158 else if (hs->vkCode == VK_RWIN && !kbdhook.rwindown)
2159 {
2160 kbdhook.rwindown = 1;
2161 kbdhook.winseen = 1;
2162 kbdhook.winsdown++;
2163 }
2164 /* Returning 1 here drops the keypress without further processing.
2165 If the keypress was allowed to go through, the normal Windows
2166 hotkeys would take over. */
2167 return 1;
2168 }
2169 else if (kbdhook.winsdown > 0 && (w == WM_KEYUP || w == WM_SYSKEYUP))
2170 {
2171 /* A key that has been captured earlier is being released now. */
2172 if (hs->vkCode == VK_LWIN && kbdhook.lwindown)
2173 {
2174 kbdhook.lwindown = 0;
2175 kbdhook.winsdown--;
2176 }
2177 else if (hs->vkCode == VK_RWIN && kbdhook.rwindown)
2178 {
2179 kbdhook.rwindown = 0;
2180 kbdhook.winsdown--;
2181 }
2182 if (kbdhook.winsdown == 0 && kbdhook.winseen)
2183 {
2184 if (!kbdhook.suppress_lone)
2185 {
2186 /* The Windows key was pressed, then released,
2187 without any other key pressed simultaneously.
2188 Normally, this opens the Start menu, but the user
2189 can prevent this by setting the
2190 w32-pass-[lr]window-to-system variable to
2191 NIL. */
2192 if (hs->vkCode == VK_LWIN && !NILP (Vw32_pass_lwindow_to_system) ||
2193 hs->vkCode == VK_RWIN && !NILP (Vw32_pass_rwindow_to_system))
2194 {
2195 /* Not prevented - Simulate the keypress to the system. */
2196 memset (inputs, 0, sizeof (inputs));
2197 inputs[0].type = INPUT_KEYBOARD;
2198 inputs[0].ki.wVk = hs->vkCode;
2199 inputs[0].ki.wScan = hs->vkCode;
2200 inputs[0].ki.dwFlags = KEYEVENTF_EXTENDEDKEY;
2201 inputs[0].ki.time = 0;
2202 inputs[1].type = INPUT_KEYBOARD;
2203 inputs[1].ki.wVk = hs->vkCode;
2204 inputs[1].ki.wScan = hs->vkCode;
2205 inputs[1].ki.dwFlags
2206 = KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP;
2207 inputs[1].ki.time = 0;
2208 SendInput (2, inputs, sizeof (INPUT));
2209 }
2210 else if (focus != NULL)
2211 {
2212 /* When not passed to system, must simulate privately to Emacs. */
2213 PostMessage (focus, WM_SYSKEYDOWN, hs->vkCode, 0);
2214 PostMessage (focus, WM_SYSKEYUP, hs->vkCode, 0);
2215 }
2216 }
2217 }
2218 if (kbdhook.winsdown == 0)
2219 {
2220 /* No Windows keys pressed anymore - clear the state flags. */
2221 kbdhook.suppress_lone = 0;
2222 kbdhook.winseen = 0;
2223 }
2224 if (!kbdhook.send_win_up)
2225 {
2226 /* Swallow this release message, as not to confuse
2227 applications who did not get to see the original
2228 WM_KEYDOWN message either. */
2229 return 1;
2230 }
2231 kbdhook.send_win_up = 0;
2232 }
2233 }
2234 else if (kbdhook.winsdown > 0)
2235 {
2236 /* Some other key was pressed while a captured Win key is down.
2237 This is either an Emacs registered hotkey combination, or a
2238 system hotkey. */
2239 if (kbdhook.lwindown && kbdhook.lwin_hooked[hs->vkCode] ||
2240 kbdhook.rwindown && kbdhook.rwin_hooked[hs->vkCode])
2241 {
2242 /* Hooked Win-x combination, do not pass the keypress to Windows. */
2243 kbdhook.suppress_lone = 1;
2244 }
2245 else if (!kbdhook.suppress_lone)
2246 {
2247 /* Unhooked S-x combination; simulate the combination now
2248 (will be seen by the system). */
2249 memset (inputs, 0, sizeof (inputs));
2250 inputs[0].type = INPUT_KEYBOARD;
2251 inputs[0].ki.wVk = kbdhook.lwindown ? VK_LWIN : VK_RWIN;
2252 inputs[0].ki.wScan = kbdhook.lwindown ? VK_LWIN : VK_RWIN;
2253 inputs[0].ki.dwFlags = KEYEVENTF_EXTENDEDKEY;
2254 inputs[0].ki.time = 0;
2255 inputs[1].type = INPUT_KEYBOARD;
2256 inputs[1].ki.wVk = hs->vkCode;
2257 inputs[1].ki.wScan = hs->scanCode;
2258 inputs[1].ki.dwFlags =
2259 (hs->flags & LLKHF_EXTENDED) ? KEYEVENTF_EXTENDEDKEY : 0;
2260 inputs[1].ki.time = 0;
2261 SendInput (2, inputs, sizeof (INPUT));
2262 /* Stop processing of this Win sequence here; the
2263 corresponding keyup messages will come through the normal
2264 channel when the keys are released. */
2265 kbdhook.suppress_lone = 1;
2266 kbdhook.send_win_up = 1;
2267 /* Swallow the original keypress (as we want the Win key
2268 down message simulated above to precede this real message). */
2269 return 1;
2270 }
2271 }
2272
2273 /* Next, handle the registered Alt-* combinations. */
2274 if ((w == WM_SYSKEYDOWN || w == WM_KEYDOWN)
2275 && kbdhook.alt_hooked[hs->vkCode]
2276 && focus != NULL
2277 && (GetAsyncKeyState (VK_MENU) & 0x8000))
2278 {
2279 /* Prevent the system from getting this Alt-* key - suppress the
2280 message and post as a normal keypress to Emacs. */
2281 if (console)
2282 {
2283 INPUT_RECORD rec;
2284 DWORD n;
2285 rec.EventType = KEY_EVENT;
2286 rec.Event.KeyEvent.bKeyDown = TRUE;
2287 rec.Event.KeyEvent.wVirtualKeyCode = hs->vkCode;
2288 rec.Event.KeyEvent.wVirtualScanCode = hs->scanCode;
2289 rec.Event.KeyEvent.uChar.UnicodeChar = 0;
2290 rec.Event.KeyEvent.dwControlKeyState =
2291 ((GetAsyncKeyState (VK_LMENU) & 0x8000) ? LEFT_ALT_PRESSED : 0)
2292 | ((GetAsyncKeyState (VK_RMENU) & 0x8000) ? RIGHT_ALT_PRESSED : 0)
2293 | ((GetAsyncKeyState (VK_LCONTROL) & 0x8000) ? LEFT_CTRL_PRESSED : 0)
2294 | ((GetAsyncKeyState (VK_RCONTROL) & 0x8000) ? RIGHT_CTRL_PRESSED : 0)
2295 | ((GetAsyncKeyState (VK_SHIFT) & 0x8000) ? SHIFT_PRESSED : 0)
2296 | ((hs->flags & LLKHF_EXTENDED) ? ENHANCED_KEY : 0);
2297 if (w32_console_unicode_input)
2298 WriteConsoleInputW (keyboard_handle, &rec, 1, &n);
2299 else
2300 WriteConsoleInputA (keyboard_handle, &rec, 1, &n);
2301 }
2302 else
2303 PostMessage (focus, w, hs->vkCode, 1 | (1<<29));
2304 return 1;
2305 }
2306
2307 /* The normal case - pass the message through. */
2308 return CallNextHookEx (0, code, w, l);
2309 }
2310
2311 /* Set up the hook; can be called several times, with matching
2312 remove_w32_kbdhook calls. */
2313 void
2314 setup_w32_kbdhook (void)
2315 {
2316 kbdhook.hook_count++;
2317
2318 /* Hooking is only available on NT architecture systems, as
2319 indicated by the w32_kbdhook_active variable. */
2320 if (kbdhook.hook_count == 1 && w32_kbdhook_active)
2321 {
2322 /* Get the handle of the Emacs console window. As the
2323 GetConsoleWindow function is only available on Win2000+, a
2324 hackish workaround described in Microsoft KB article 124103
2325 (https://support.microsoft.com/en-us/kb/124103) is used for
2326 NT 4 systems. */
2327 GetConsoleWindow_Proc get_console = (GetConsoleWindow_Proc)
2328 GetProcAddress (GetModuleHandle ("kernel32.dll"), "GetConsoleWindow");
2329
2330 if (get_console != NULL)
2331 kbdhook.console = get_console ();
2332 else
2333 {
2334 GUID guid;
2335 wchar_t *oldTitle = malloc (1024 * sizeof(wchar_t));
2336 wchar_t newTitle[64];
2337 int i;
2338
2339 CoCreateGuid (&guid);
2340 StringFromGUID2 (&guid, newTitle, 64);
2341 if (newTitle != NULL)
2342 {
2343 GetConsoleTitleW (oldTitle, 1024);
2344 SetConsoleTitleW (newTitle);
2345 for (i = 0; i < 25; i++)
2346 {
2347 Sleep (40);
2348 kbdhook.console = FindWindowW (NULL, newTitle);
2349 if (kbdhook.console != NULL)
2350 break;
2351 }
2352 SetConsoleTitleW (oldTitle);
2353 }
2354 free (oldTitle);
2355 }
2356
2357 /* Set the hook. */
2358 kbdhook.hook = SetWindowsHookEx (WH_KEYBOARD_LL, funhook,
2359 GetModuleHandle (NULL), 0);
2360 }
2361 }
2362
2363 /* Remove the hook. */
2364 void
2365 remove_w32_kbdhook (void)
2366 {
2367 kbdhook.hook_count--;
2368 if (kbdhook.hook_count == 0 && w32_kbdhook_active)
2369 {
2370 UnhookWindowsHookEx (kbdhook.hook);
2371 kbdhook.hook = NULL;
2372 }
2373 }
2374 #endif /* WINDOWSNT */
2375
2376 /* Mark a specific key combination as hooked, preventing it to be
2377 handled by the system. */
2378 void
2379 hook_w32_key (int hook, int modifier, int vkey)
2380 {
2381 char *tbl = NULL;
2382
2383 switch (modifier)
2384 {
2385 case VK_MENU:
2386 tbl = kbdhook.alt_hooked;
2387 break;
2388 case VK_LWIN:
2389 tbl = kbdhook.lwin_hooked;
2390 break;
2391 case VK_RWIN:
2392 tbl = kbdhook.rwin_hooked;
2393 break;
2394 }
2395
2396 if (tbl != NULL && vkey >= 0 && vkey <= 255)
2397 {
2398 /* VK_ANY hooks all keys for this modifier */
2399 if (vkey == VK_ANY)
2400 memset (tbl, (char)hook, 256);
2401 else
2402 tbl[vkey] = (char)hook;
2403 /* Alt-<modifier>s should go through */
2404 kbdhook.alt_hooked[VK_MENU] = 0;
2405 kbdhook.alt_hooked[VK_LMENU] = 0;
2406 kbdhook.alt_hooked[VK_RMENU] = 0;
2407 kbdhook.alt_hooked[VK_CONTROL] = 0;
2408 kbdhook.alt_hooked[VK_LCONTROL] = 0;
2409 kbdhook.alt_hooked[VK_RCONTROL] = 0;
2410 kbdhook.alt_hooked[VK_SHIFT] = 0;
2411 kbdhook.alt_hooked[VK_LSHIFT] = 0;
2412 kbdhook.alt_hooked[VK_RSHIFT] = 0;
2413 }
2414 }
2415
2416 /* Check the current Win key pressed state. */
2417 int
2418 check_w32_winkey_state (int vkey)
2419 {
2420 /* The hook code handles grabbing of the Windows keys and Alt-* key
2421 combinations reserved by the system. Handling Alt is a bit
2422 easier, as Windows intends Alt-* shortcuts for application use in
2423 Windows; hotkeys such as Alt-tab and Alt-escape are special
2424 cases. Win-* hotkeys, on the other hand, are primarily meant for
2425 system use.
2426
2427 As a result, when we want Emacs to be able to grab the Win-*
2428 keys, we must swallow all Win key presses in a low-level keyboard
2429 hook. Unfortunately, this means that the Emacs window procedure
2430 (and console input handler) never see the keypresses either.
2431 Thus, to check the modifier states properly, Emacs code must use
2432 the check_w32_winkey_state function that uses the flags directly
2433 updated by the hook callback. */
2434 switch (vkey)
2435 {
2436 case VK_LWIN:
2437 return kbdhook.lwindown;
2438 case VK_RWIN:
2439 return kbdhook.rwindown;
2440 }
2441 return 0;
2442 }
2443
2444 /* Reset the keyboard hook state. Locking the workstation with Win-L
2445 leaves the Win key(s) "down" from the hook's point of view - the
2446 keyup event is never seen. Thus, this function must be called when
2447 the system is locked. */
2448 void
2449 reset_w32_kbdhook_state (void)
2450 {
2451 kbdhook.lwindown = 0;
2452 kbdhook.rwindown = 0;
2453 kbdhook.winsdown = 0;
2454 kbdhook.send_win_up = 0;
2455 kbdhook.suppress_lone = 0;
2456 kbdhook.winseen = 0;
2457 }
2458
2459 /* GetKeyState and MapVirtualKey on Windows 95 do not actually distinguish
2460 between left and right keys as advertised. We test for this
2461 support dynamically, and set a flag when the support is absent. If
2462 absent, we keep track of the left and right control and alt keys
2463 ourselves. This is particularly necessary on keyboards that rely
2464 upon the AltGr key, which is represented as having the left control
2465 and right alt keys pressed. For these keyboards, we need to know
2466 when the left alt key has been pressed in addition to the AltGr key
2467 so that we can properly support M-AltGr-key sequences (such as M-@
2468 on Swedish keyboards). */
2469
2470 #define EMACS_LCONTROL 0
2471 #define EMACS_RCONTROL 1
2472 #define EMACS_LMENU 2
2473 #define EMACS_RMENU 3
2474
2475 static int modifiers[4];
2476 static int modifiers_recorded;
2477 static int modifier_key_support_tested;
2478
2479 static void
2480 test_modifier_support (unsigned int wparam)
2481 {
2482 unsigned int l, r;
2483
2484 if (wparam != VK_CONTROL && wparam != VK_MENU)
2485 return;
2486 if (wparam == VK_CONTROL)
2487 {
2488 l = VK_LCONTROL;
2489 r = VK_RCONTROL;
2490 }
2491 else
2492 {
2493 l = VK_LMENU;
2494 r = VK_RMENU;
2495 }
2496 if (!(GetKeyState (l) & 0x8000) && !(GetKeyState (r) & 0x8000))
2497 modifiers_recorded = 1;
2498 else
2499 modifiers_recorded = 0;
2500 modifier_key_support_tested = 1;
2501 }
2502
2503 static void
2504 record_keydown (unsigned int wparam, unsigned int lparam)
2505 {
2506 int i;
2507
2508 if (!modifier_key_support_tested)
2509 test_modifier_support (wparam);
2510
2511 if ((wparam != VK_CONTROL && wparam != VK_MENU) || !modifiers_recorded)
2512 return;
2513
2514 if (wparam == VK_CONTROL)
2515 i = (lparam & 0x1000000) ? EMACS_RCONTROL : EMACS_LCONTROL;
2516 else
2517 i = (lparam & 0x1000000) ? EMACS_RMENU : EMACS_LMENU;
2518
2519 modifiers[i] = 1;
2520 }
2521
2522 static void
2523 record_keyup (unsigned int wparam, unsigned int lparam)
2524 {
2525 int i;
2526
2527 if ((wparam != VK_CONTROL && wparam != VK_MENU) || !modifiers_recorded)
2528 return;
2529
2530 if (wparam == VK_CONTROL)
2531 i = (lparam & 0x1000000) ? EMACS_RCONTROL : EMACS_LCONTROL;
2532 else
2533 i = (lparam & 0x1000000) ? EMACS_RMENU : EMACS_LMENU;
2534
2535 modifiers[i] = 0;
2536 }
2537
2538 /* Emacs can lose focus while a modifier key has been pressed. When
2539 it regains focus, be conservative and clear all modifiers since
2540 we cannot reconstruct the left and right modifier state. */
2541 static void
2542 reset_modifiers (void)
2543 {
2544 SHORT ctrl, alt;
2545
2546 if (GetFocus () == NULL)
2547 /* Emacs doesn't have keyboard focus. Do nothing. */
2548 return;
2549
2550 ctrl = GetAsyncKeyState (VK_CONTROL);
2551 alt = GetAsyncKeyState (VK_MENU);
2552
2553 if (!(ctrl & 0x08000))
2554 /* Clear any recorded control modifier state. */
2555 modifiers[EMACS_RCONTROL] = modifiers[EMACS_LCONTROL] = 0;
2556
2557 if (!(alt & 0x08000))
2558 /* Clear any recorded alt modifier state. */
2559 modifiers[EMACS_RMENU] = modifiers[EMACS_LMENU] = 0;
2560
2561 /* Update the state of all modifier keys, because modifiers used in
2562 hot-key combinations can get stuck on if Emacs loses focus as a
2563 result of a hot-key being pressed. */
2564 {
2565 BYTE keystate[256];
2566
2567 #define CURRENT_STATE(key) ((GetAsyncKeyState (key) & 0x8000) >> 8)
2568
2569 memset (keystate, 0, sizeof (keystate));
2570 GetKeyboardState (keystate);
2571 keystate[VK_SHIFT] = CURRENT_STATE (VK_SHIFT);
2572 keystate[VK_CONTROL] = CURRENT_STATE (VK_CONTROL);
2573 keystate[VK_LCONTROL] = CURRENT_STATE (VK_LCONTROL);
2574 keystate[VK_RCONTROL] = CURRENT_STATE (VK_RCONTROL);
2575 keystate[VK_MENU] = CURRENT_STATE (VK_MENU);
2576 keystate[VK_LMENU] = CURRENT_STATE (VK_LMENU);
2577 keystate[VK_RMENU] = CURRENT_STATE (VK_RMENU);
2578 keystate[VK_LWIN] = CURRENT_STATE (VK_LWIN);
2579 keystate[VK_RWIN] = CURRENT_STATE (VK_RWIN);
2580 keystate[VK_APPS] = CURRENT_STATE (VK_APPS);
2581 SetKeyboardState (keystate);
2582 }
2583 }
2584
2585 /* Synchronize modifier state with what is reported with the current
2586 keystroke. Even if we cannot distinguish between left and right
2587 modifier keys, we know that, if no modifiers are set, then neither
2588 the left or right modifier should be set. */
2589 static void
2590 sync_modifiers (void)
2591 {
2592 if (!modifiers_recorded)
2593 return;
2594
2595 if (!(GetKeyState (VK_CONTROL) & 0x8000))
2596 modifiers[EMACS_RCONTROL] = modifiers[EMACS_LCONTROL] = 0;
2597
2598 if (!(GetKeyState (VK_MENU) & 0x8000))
2599 modifiers[EMACS_RMENU] = modifiers[EMACS_LMENU] = 0;
2600 }
2601
2602 static int
2603 modifier_set (int vkey)
2604 {
2605 /* Warning: The fact that VK_NUMLOCK is not treated as the other 2
2606 toggle keys is not an omission! If you want to add it, you will
2607 have to make changes in the default sub-case of the WM_KEYDOWN
2608 switch, because if the NUMLOCK modifier is set, the code there
2609 will directly convert any key that looks like an ASCII letter,
2610 and also downcase those that look like upper-case ASCII. */
2611 if (vkey == VK_CAPITAL)
2612 {
2613 if (NILP (Vw32_enable_caps_lock))
2614 return 0;
2615 else
2616 return (GetKeyState (vkey) & 0x1);
2617 }
2618 if (vkey == VK_SCROLL)
2619 {
2620 if (NILP (Vw32_scroll_lock_modifier)
2621 /* w32-scroll-lock-modifier can be any non-nil value that is
2622 not one of the modifiers, in which case it shall be ignored. */
2623 || !( EQ (Vw32_scroll_lock_modifier, Qhyper)
2624 || EQ (Vw32_scroll_lock_modifier, Qsuper)
2625 || EQ (Vw32_scroll_lock_modifier, Qmeta)
2626 || EQ (Vw32_scroll_lock_modifier, Qalt)
2627 || EQ (Vw32_scroll_lock_modifier, Qcontrol)
2628 || EQ (Vw32_scroll_lock_modifier, Qshift)))
2629 return 0;
2630 else
2631 return (GetKeyState (vkey) & 0x1);
2632 }
2633 if (w32_kbdhook_active && (vkey == VK_LWIN || vkey == VK_RWIN))
2634 return check_w32_winkey_state (vkey);
2635
2636 if (!modifiers_recorded)
2637 return (GetKeyState (vkey) & 0x8000);
2638
2639 switch (vkey)
2640 {
2641 case VK_LCONTROL:
2642 return modifiers[EMACS_LCONTROL];
2643 case VK_RCONTROL:
2644 return modifiers[EMACS_RCONTROL];
2645 case VK_LMENU:
2646 return modifiers[EMACS_LMENU];
2647 case VK_RMENU:
2648 return modifiers[EMACS_RMENU];
2649 }
2650 return (GetKeyState (vkey) & 0x8000);
2651 }
2652
2653 /* Convert between the modifier bits W32 uses and the modifier bits
2654 Emacs uses. */
2655
2656 unsigned int
2657 w32_key_to_modifier (int key)
2658 {
2659 Lisp_Object key_mapping;
2660
2661 switch (key)
2662 {
2663 case VK_LWIN:
2664 key_mapping = Vw32_lwindow_modifier;
2665 break;
2666 case VK_RWIN:
2667 key_mapping = Vw32_rwindow_modifier;
2668 break;
2669 case VK_APPS:
2670 key_mapping = Vw32_apps_modifier;
2671 break;
2672 case VK_SCROLL:
2673 key_mapping = Vw32_scroll_lock_modifier;
2674 break;
2675 default:
2676 key_mapping = Qnil;
2677 }
2678
2679 /* NB. This code runs in the input thread, asynchronously to the lisp
2680 thread, so we must be careful to ensure access to lisp data is
2681 thread-safe. The following code is safe because the modifier
2682 variable values are updated atomically from lisp and symbols are
2683 not relocated by GC. Also, we don't have to worry about seeing GC
2684 markbits here. */
2685 if (EQ (key_mapping, Qhyper))
2686 return hyper_modifier;
2687 if (EQ (key_mapping, Qsuper))
2688 return super_modifier;
2689 if (EQ (key_mapping, Qmeta))
2690 return meta_modifier;
2691 if (EQ (key_mapping, Qalt))
2692 return alt_modifier;
2693 if (EQ (key_mapping, Qctrl))
2694 return ctrl_modifier;
2695 if (EQ (key_mapping, Qcontrol)) /* synonym for ctrl */
2696 return ctrl_modifier;
2697 if (EQ (key_mapping, Qshift))
2698 return shift_modifier;
2699
2700 /* Don't generate any modifier if not explicitly requested. */
2701 return 0;
2702 }
2703
2704 static unsigned int
2705 w32_get_modifiers (void)
2706 {
2707 return ((modifier_set (VK_SHIFT) ? shift_modifier : 0) |
2708 (modifier_set (VK_CONTROL) ? ctrl_modifier : 0) |
2709 (modifier_set (VK_LWIN) ? w32_key_to_modifier (VK_LWIN) : 0) |
2710 (modifier_set (VK_RWIN) ? w32_key_to_modifier (VK_RWIN) : 0) |
2711 (modifier_set (VK_APPS) ? w32_key_to_modifier (VK_APPS) : 0) |
2712 (modifier_set (VK_SCROLL) ? w32_key_to_modifier (VK_SCROLL) : 0) |
2713 (modifier_set (VK_MENU) ?
2714 ((NILP (Vw32_alt_is_meta)) ? alt_modifier : meta_modifier) : 0));
2715 }
2716
2717 /* We map the VK_* modifiers into console modifier constants
2718 so that we can use the same routines to handle both console
2719 and window input. */
2720
2721 static int
2722 construct_console_modifiers (void)
2723 {
2724 int mods;
2725
2726 mods = 0;
2727 mods |= (modifier_set (VK_SHIFT)) ? SHIFT_PRESSED : 0;
2728 mods |= (modifier_set (VK_CAPITAL)) ? CAPSLOCK_ON : 0;
2729 mods |= (modifier_set (VK_SCROLL)) ? SCROLLLOCK_ON : 0;
2730 mods |= (modifier_set (VK_NUMLOCK)) ? NUMLOCK_ON : 0;
2731 mods |= (modifier_set (VK_LCONTROL)) ? LEFT_CTRL_PRESSED : 0;
2732 mods |= (modifier_set (VK_RCONTROL)) ? RIGHT_CTRL_PRESSED : 0;
2733 mods |= (modifier_set (VK_LMENU)) ? LEFT_ALT_PRESSED : 0;
2734 mods |= (modifier_set (VK_RMENU)) ? RIGHT_ALT_PRESSED : 0;
2735 mods |= (modifier_set (VK_LWIN)) ? LEFT_WIN_PRESSED : 0;
2736 mods |= (modifier_set (VK_RWIN)) ? RIGHT_WIN_PRESSED : 0;
2737 mods |= (modifier_set (VK_APPS)) ? APPS_PRESSED : 0;
2738
2739 return mods;
2740 }
2741
2742 static int
2743 w32_get_key_modifiers (unsigned int wparam, unsigned int lparam)
2744 {
2745 int mods;
2746
2747 /* Convert to emacs modifiers. */
2748 mods = w32_kbd_mods_to_emacs (construct_console_modifiers (), wparam);
2749
2750 return mods;
2751 }
2752
2753 unsigned int
2754 map_keypad_keys (unsigned int virt_key, unsigned int extended)
2755 {
2756 if (virt_key < VK_CLEAR || virt_key > VK_DELETE)
2757 return virt_key;
2758
2759 if (virt_key == VK_RETURN)
2760 return (extended ? VK_NUMPAD_ENTER : VK_RETURN);
2761
2762 if (virt_key >= VK_PRIOR && virt_key <= VK_DOWN)
2763 return (!extended ? (VK_NUMPAD_PRIOR + (virt_key - VK_PRIOR)) : virt_key);
2764
2765 if (virt_key == VK_INSERT || virt_key == VK_DELETE)
2766 return (!extended ? (VK_NUMPAD_INSERT + (virt_key - VK_INSERT)) : virt_key);
2767
2768 if (virt_key == VK_CLEAR)
2769 return (!extended ? VK_NUMPAD_CLEAR : virt_key);
2770
2771 return virt_key;
2772 }
2773
2774 /* List of special key combinations which w32 would normally capture,
2775 but Emacs should grab instead. Not directly visible to lisp, to
2776 simplify synchronization. Each item is an integer encoding a virtual
2777 key code and modifier combination to capture.
2778 Note: This code is not used if keyboard hooks are active
2779 (Windows 2000 and later). */
2780 static Lisp_Object w32_grabbed_keys;
2781
2782 #define HOTKEY(vk, mods) make_number (((vk) & 255) | ((mods) << 8))
2783 #define HOTKEY_ID(k) (XFASTINT (k) & 0xbfff)
2784 #define HOTKEY_VK_CODE(k) (XFASTINT (k) & 255)
2785 #define HOTKEY_MODIFIERS(k) (XFASTINT (k) >> 8)
2786
2787 #define RAW_HOTKEY_ID(k) ((k) & 0xbfff)
2788 #define RAW_HOTKEY_VK_CODE(k) ((k) & 255)
2789 #define RAW_HOTKEY_MODIFIERS(k) ((k) >> 8)
2790
2791 /* Register hot-keys for reserved key combinations when Emacs has
2792 keyboard focus, since this is the only way Emacs can receive key
2793 combinations like Alt-Tab which are used by the system. */
2794
2795 static void
2796 register_hot_keys (HWND hwnd)
2797 {
2798 Lisp_Object keylist;
2799
2800 /* Use CONSP, since we are called asynchronously. */
2801 for (keylist = w32_grabbed_keys; CONSP (keylist); keylist = XCDR (keylist))
2802 {
2803 Lisp_Object key = XCAR (keylist);
2804
2805 /* Deleted entries get set to nil. */
2806 if (!INTEGERP (key))
2807 continue;
2808
2809 RegisterHotKey (hwnd, HOTKEY_ID (key),
2810 HOTKEY_MODIFIERS (key), HOTKEY_VK_CODE (key));
2811 }
2812 }
2813
2814 static void
2815 unregister_hot_keys (HWND hwnd)
2816 {
2817 Lisp_Object keylist;
2818
2819 for (keylist = w32_grabbed_keys; CONSP (keylist); keylist = XCDR (keylist))
2820 {
2821 Lisp_Object key = XCAR (keylist);
2822
2823 if (!INTEGERP (key))
2824 continue;
2825
2826 UnregisterHotKey (hwnd, HOTKEY_ID (key));
2827 }
2828 }
2829
2830 #if EMACSDEBUG
2831 const char*
2832 w32_name_of_message (UINT msg)
2833 {
2834 unsigned i;
2835 static char buf[64];
2836 static const struct {
2837 UINT msg;
2838 const char* name;
2839 } msgnames[] = {
2840 #define M(msg) { msg, # msg }
2841 M (WM_PAINT),
2842 M (WM_TIMER),
2843 M (WM_USER),
2844 M (WM_MOUSEMOVE),
2845 M (WM_LBUTTONUP),
2846 M (WM_KEYDOWN),
2847 M (WM_EMACS_KILL),
2848 M (WM_EMACS_CREATEWINDOW),
2849 M (WM_EMACS_DONE),
2850 M (WM_EMACS_CREATEVSCROLLBAR),
2851 M (WM_EMACS_CREATEHSCROLLBAR),
2852 M (WM_EMACS_SHOWWINDOW),
2853 M (WM_EMACS_SETWINDOWPOS),
2854 M (WM_EMACS_DESTROYWINDOW),
2855 M (WM_EMACS_TRACKPOPUPMENU),
2856 M (WM_EMACS_SETFOCUS),
2857 M (WM_EMACS_SETFOREGROUND),
2858 M (WM_EMACS_SETLOCALE),
2859 M (WM_EMACS_SETKEYBOARDLAYOUT),
2860 M (WM_EMACS_REGISTER_HOT_KEY),
2861 M (WM_EMACS_UNREGISTER_HOT_KEY),
2862 M (WM_EMACS_TOGGLE_LOCK_KEY),
2863 M (WM_EMACS_TRACK_CARET),
2864 M (WM_EMACS_DESTROY_CARET),
2865 M (WM_EMACS_SHOW_CARET),
2866 M (WM_EMACS_HIDE_CARET),
2867 M (WM_EMACS_SETCURSOR),
2868 M (WM_EMACS_SHOWCURSOR),
2869 M (WM_EMACS_PAINT),
2870 M (WM_CHAR),
2871 #undef M
2872 { 0, 0 }
2873 };
2874
2875 for (i = 0; msgnames[i].name; ++i)
2876 if (msgnames[i].msg == msg)
2877 return msgnames[i].name;
2878
2879 sprintf (buf, "message 0x%04x", (unsigned)msg);
2880 return buf;
2881 }
2882 #endif /* EMACSDEBUG */
2883
2884 /* Here's an overview of how Emacs input works in GUI sessions on
2885 MS-Windows. (For description of non-GUI input, see the commentary
2886 before w32_console_read_socket in w32inevt.c.)
2887
2888 System messages are read and processed by w32_msg_pump below. This
2889 function runs in a separate thread. It handles a small number of
2890 custom WM_EMACS_* messages (posted by the main thread, look for
2891 PostMessage calls), and dispatches the rest to w32_wnd_proc, which
2892 is the main window procedure for the entire Emacs application.
2893
2894 w32_wnd_proc also runs in the same separate input thread. It
2895 handles some messages, mostly those that need GDI calls, by itself.
2896 For the others, it calls my_post_msg, which inserts the messages
2897 into the input queue serviced by w32_read_socket.
2898
2899 w32_read_socket runs in the main (a.k.a. "Lisp") thread, and is
2900 called synchronously from keyboard.c when it is known or suspected
2901 that some input is available. w32_read_socket either handles
2902 messages immediately, or converts them into Emacs input events and
2903 stuffs them into kbd_buffer, where kbd_buffer_get_event can get at
2904 them and process them when read_char and its callers require
2905 input.
2906
2907 Under Cygwin with the W32 toolkit, the use of /dev/windows with
2908 select(2) takes the place of w32_read_socket.
2909
2910 */
2911
2912 /* Main message dispatch loop. */
2913
2914 static void
2915 w32_msg_pump (deferred_msg * msg_buf)
2916 {
2917 MSG msg;
2918 WPARAM result;
2919 HWND focus_window;
2920
2921 msh_mousewheel = RegisterWindowMessage (MSH_MOUSEWHEEL);
2922
2923 while ((w32_unicode_gui ? GetMessageW : GetMessageA) (&msg, NULL, 0, 0))
2924 {
2925
2926 /* DebPrint (("w32_msg_pump: %s time:%u\n", */
2927 /* w32_name_of_message (msg.message), msg.time)); */
2928
2929 if (msg.hwnd == NULL)
2930 {
2931 switch (msg.message)
2932 {
2933 case WM_NULL:
2934 /* Produced by complete_deferred_msg; just ignore. */
2935 break;
2936 case WM_EMACS_CREATEWINDOW:
2937 /* Initialize COM for this window. Even though we don't use it,
2938 some third party shell extensions can cause it to be used in
2939 system dialogs, which causes a crash if it is not initialized.
2940 This is a known bug in Windows, which was fixed long ago, but
2941 the patch for XP is not publicly available until XP SP3,
2942 and older versions will never be patched. */
2943 CoInitialize (NULL);
2944 w32_createwindow ((struct frame *) msg.wParam,
2945 (int *) msg.lParam);
2946 if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
2947 emacs_abort ();
2948 break;
2949 case WM_EMACS_SETLOCALE:
2950 SetThreadLocale (msg.wParam);
2951 /* Reply is not expected. */
2952 break;
2953 case WM_EMACS_SETKEYBOARDLAYOUT:
2954 result = (WPARAM) ActivateKeyboardLayout ((HKL) msg.wParam, 0);
2955 if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE,
2956 result, 0))
2957 emacs_abort ();
2958 break;
2959 case WM_EMACS_REGISTER_HOT_KEY:
2960 focus_window = GetFocus ();
2961 if (focus_window != NULL)
2962 RegisterHotKey (focus_window,
2963 RAW_HOTKEY_ID (msg.wParam),
2964 RAW_HOTKEY_MODIFIERS (msg.wParam),
2965 RAW_HOTKEY_VK_CODE (msg.wParam));
2966 /* Reply is not expected. */
2967 break;
2968 case WM_EMACS_UNREGISTER_HOT_KEY:
2969 focus_window = GetFocus ();
2970 if (focus_window != NULL)
2971 UnregisterHotKey (focus_window, RAW_HOTKEY_ID (msg.wParam));
2972 /* Mark item as erased. NB: this code must be
2973 thread-safe. The next line is okay because the cons
2974 cell is never made into garbage and is not relocated by
2975 GC. */
2976 XSETCAR (make_lisp_ptr ((void *)msg.lParam, Lisp_Cons), Qnil);
2977 if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
2978 emacs_abort ();
2979 break;
2980 case WM_EMACS_TOGGLE_LOCK_KEY:
2981 {
2982 int vk_code = (int) msg.wParam;
2983 int cur_state = (GetKeyState (vk_code) & 1);
2984 int new_state = msg.lParam;
2985
2986 if (new_state == -1
2987 || ((new_state & 1) != cur_state))
2988 {
2989 one_w32_display_info.faked_key = vk_code;
2990
2991 keybd_event ((BYTE) vk_code,
2992 (BYTE) MapVirtualKey (vk_code, 0),
2993 KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
2994 keybd_event ((BYTE) vk_code,
2995 (BYTE) MapVirtualKey (vk_code, 0),
2996 KEYEVENTF_EXTENDEDKEY | 0, 0);
2997 keybd_event ((BYTE) vk_code,
2998 (BYTE) MapVirtualKey (vk_code, 0),
2999 KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
3000 cur_state = !cur_state;
3001 }
3002 if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE,
3003 cur_state, 0))
3004 emacs_abort ();
3005 }
3006 break;
3007 #ifdef MSG_DEBUG
3008 /* Broadcast messages make it here, so you need to be looking
3009 for something in particular for this to be useful. */
3010 default:
3011 DebPrint (("msg %x not expected by w32_msg_pump\n", msg.message));
3012 #endif
3013 }
3014 }
3015 else
3016 {
3017 if (w32_unicode_gui)
3018 DispatchMessageW (&msg);
3019 else
3020 DispatchMessageA (&msg);
3021 }
3022
3023 /* Exit nested loop when our deferred message has completed. */
3024 if (msg_buf->completed)
3025 break;
3026 }
3027 }
3028
3029 deferred_msg * deferred_msg_head;
3030
3031 static deferred_msg *
3032 find_deferred_msg (HWND hwnd, UINT msg)
3033 {
3034 deferred_msg * item;
3035
3036 /* Don't actually need synchronization for read access, since
3037 modification of single pointer is always atomic. */
3038 /* enter_crit (); */
3039
3040 for (item = deferred_msg_head; item != NULL; item = item->next)
3041 if (item->w32msg.msg.hwnd == hwnd
3042 && item->w32msg.msg.message == msg)
3043 break;
3044
3045 /* leave_crit (); */
3046
3047 return item;
3048 }
3049
3050 static LRESULT
3051 send_deferred_msg (deferred_msg * msg_buf,
3052 HWND hwnd,
3053 UINT msg,
3054 WPARAM wParam,
3055 LPARAM lParam)
3056 {
3057 /* Only input thread can send deferred messages. */
3058 if (GetCurrentThreadId () != dwWindowsThreadId)
3059 emacs_abort ();
3060
3061 /* It is an error to send a message that is already deferred. */
3062 if (find_deferred_msg (hwnd, msg) != NULL)
3063 emacs_abort ();
3064
3065 /* Enforced synchronization is not needed because this is the only
3066 function that alters deferred_msg_head, and the following critical
3067 section is guaranteed to only be serially reentered (since only the
3068 input thread can call us). */
3069
3070 /* enter_crit (); */
3071
3072 msg_buf->completed = 0;
3073 msg_buf->next = deferred_msg_head;
3074 deferred_msg_head = msg_buf;
3075 my_post_msg (&msg_buf->w32msg, hwnd, msg, wParam, lParam);
3076
3077 /* leave_crit (); */
3078
3079 /* Start a new nested message loop to process other messages until
3080 this one is completed. */
3081 w32_msg_pump (msg_buf);
3082
3083 deferred_msg_head = msg_buf->next;
3084
3085 return msg_buf->result;
3086 }
3087
3088 void
3089 complete_deferred_msg (HWND hwnd, UINT msg, LRESULT result)
3090 {
3091 deferred_msg * msg_buf = find_deferred_msg (hwnd, msg);
3092
3093 if (msg_buf == NULL)
3094 /* Message may have been canceled, so don't abort. */
3095 return;
3096
3097 msg_buf->result = result;
3098 msg_buf->completed = 1;
3099
3100 /* Ensure input thread is woken so it notices the completion. */
3101 PostThreadMessage (dwWindowsThreadId, WM_NULL, 0, 0);
3102 }
3103
3104 static void
3105 cancel_all_deferred_msgs (void)
3106 {
3107 deferred_msg * item;
3108
3109 /* Don't actually need synchronization for read access, since
3110 modification of single pointer is always atomic. */
3111 /* enter_crit (); */
3112
3113 for (item = deferred_msg_head; item != NULL; item = item->next)
3114 {
3115 item->result = 0;
3116 item->completed = 1;
3117 }
3118
3119 /* leave_crit (); */
3120
3121 /* Ensure input thread is woken so it notices the completion. */
3122 PostThreadMessage (dwWindowsThreadId, WM_NULL, 0, 0);
3123 }
3124
3125 DWORD WINAPI
3126 w32_msg_worker (void *arg)
3127 {
3128 MSG msg;
3129 deferred_msg dummy_buf;
3130
3131 /* Ensure our message queue is created */
3132
3133 PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
3134
3135 if (!PostThreadMessage (dwMainThreadId, WM_EMACS_DONE, 0, 0))
3136 emacs_abort ();
3137
3138 memset (&dummy_buf, 0, sizeof (dummy_buf));
3139 dummy_buf.w32msg.msg.hwnd = NULL;
3140 dummy_buf.w32msg.msg.message = WM_NULL;
3141
3142 /* This is the initial message loop which should only exit when the
3143 application quits. */
3144 w32_msg_pump (&dummy_buf);
3145
3146 return 0;
3147 }
3148
3149 static void
3150 signal_user_input (void)
3151 {
3152 /* Interrupt any lisp that wants to be interrupted by input. */
3153 if (!NILP (Vthrow_on_input))
3154 {
3155 Vquit_flag = Vthrow_on_input;
3156 /* Doing a QUIT from this thread is a bad idea, since this
3157 unwinds the stack of the Lisp thread, and the Windows runtime
3158 rightfully barfs. Disabled. */
3159 #if 0
3160 /* If we're inside a function that wants immediate quits,
3161 do it now. */
3162 if (immediate_quit && NILP (Vinhibit_quit))
3163 {
3164 immediate_quit = 0;
3165 QUIT;
3166 }
3167 #endif
3168 }
3169 }
3170
3171
3172 static void
3173 post_character_message (HWND hwnd, UINT msg,
3174 WPARAM wParam, LPARAM lParam,
3175 DWORD modifiers)
3176 {
3177 W32Msg wmsg;
3178
3179 wmsg.dwModifiers = modifiers;
3180
3181 /* Detect quit_char and set quit-flag directly. Note that we
3182 still need to post a message to ensure the main thread will be
3183 woken up if blocked in sys_select, but we do NOT want to post
3184 the quit_char message itself (because it will usually be as if
3185 the user had typed quit_char twice). Instead, we post a dummy
3186 message that has no particular effect. */
3187 {
3188 int c = wParam;
3189 if (isalpha (c) && wmsg.dwModifiers == ctrl_modifier)
3190 c = make_ctrl_char (c) & 0377;
3191 if (c == quit_char
3192 || (wmsg.dwModifiers == 0
3193 && w32_quit_key && wParam == w32_quit_key))
3194 {
3195 Vquit_flag = Qt;
3196
3197 /* The choice of message is somewhat arbitrary, as long as
3198 the main thread handler just ignores it. */
3199 msg = WM_NULL;
3200
3201 /* Interrupt any blocking system calls. */
3202 signal_quit ();
3203
3204 /* As a safety precaution, forcibly complete any deferred
3205 messages. This is a kludge, but I don't see any particularly
3206 clean way to handle the situation where a deferred message is
3207 "dropped" in the lisp thread, and will thus never be
3208 completed, eg. by the user trying to activate the menubar
3209 when the lisp thread is busy, and then typing C-g when the
3210 menubar doesn't open promptly (with the result that the
3211 menubar never responds at all because the deferred
3212 WM_INITMENU message is never completed). Another problem
3213 situation is when the lisp thread calls SendMessage (to send
3214 a window manager command) when a message has been deferred;
3215 the lisp thread gets blocked indefinitely waiting for the
3216 deferred message to be completed, which itself is waiting for
3217 the lisp thread to respond.
3218
3219 Note that we don't want to block the input thread waiting for
3220 a response from the lisp thread (although that would at least
3221 solve the deadlock problem above), because we want to be able
3222 to receive C-g to interrupt the lisp thread. */
3223 cancel_all_deferred_msgs ();
3224 }
3225 else
3226 signal_user_input ();
3227 }
3228
3229 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3230 }
3231
3232 static int
3233 get_wm_chars (HWND aWnd, int *buf, int buflen, int ignore_ctrl, int ctrl,
3234 int *ctrl_cnt, int *is_dead, int vk, int exp)
3235 {
3236 MSG msg;
3237 /* If doubled is at the end, ignore it. */
3238 int i = buflen, doubled = 0, code_unit;
3239
3240 if (ctrl_cnt)
3241 *ctrl_cnt = 0;
3242 if (is_dead)
3243 *is_dead = -1;
3244 eassert (w32_unicode_gui);
3245 while (buflen
3246 /* Should be called only when w32_unicode_gui: */
3247 && PeekMessageW (&msg, aWnd, WM_KEYFIRST, WM_KEYLAST,
3248 PM_NOREMOVE | PM_NOYIELD)
3249 && (msg.message == WM_CHAR || msg.message == WM_SYSCHAR
3250 || msg.message == WM_DEADCHAR || msg.message == WM_SYSDEADCHAR
3251 || msg.message == WM_UNICHAR))
3252 {
3253 /* We extract character payload, but in this call we handle only the
3254 characters which come BEFORE the next keyup/keydown message. */
3255 int dead;
3256
3257 GetMessageW (&msg, aWnd, msg.message, msg.message);
3258 dead = (msg.message == WM_DEADCHAR || msg.message == WM_SYSDEADCHAR);
3259 if (is_dead)
3260 *is_dead = (dead ? msg.wParam : -1);
3261 if (dead)
3262 continue;
3263 code_unit = msg.wParam;
3264 if (doubled)
3265 {
3266 /* Had surrogate. */
3267 if (msg.message == WM_UNICHAR
3268 || code_unit < 0xDC00 || code_unit > 0xDFFF)
3269 { /* Mismatched first surrogate.
3270 Pass both code units as if they were two characters. */
3271 *buf++ = doubled;
3272 if (!--buflen)
3273 return i; /* Drop the 2nd char if at the end of the buffer. */
3274 }
3275 else /* see https://en.wikipedia.org/wiki/UTF-16 */
3276 code_unit = (doubled << 10) + code_unit - 0x35FDC00;
3277 doubled = 0;
3278 }
3279 else if (code_unit >= 0xD800 && code_unit <= 0xDBFF)
3280 {
3281 /* Handle mismatched 2nd surrogate the same as a normal character. */
3282 doubled = code_unit;
3283 continue;
3284 }
3285
3286 /* The only "fake" characters delivered by ToUnicode() or
3287 TranslateMessage() are:
3288 0x01 .. 0x1a for Ctrl-letter, Enter, Tab, Ctrl-Break, Esc, Backspace
3289 0x00 and 0x1b .. 0x1f for Control- []\@^_
3290 0x7f for Control-BackSpace
3291 0x20 for Control-Space */
3292 if (ignore_ctrl
3293 && (code_unit < 0x20 || code_unit == 0x7f
3294 || (code_unit == 0x20 && ctrl)))
3295 {
3296 /* Non-character payload in a WM_CHAR
3297 (Ctrl-something pressed, see above). Ignore, and report. */
3298 if (ctrl_cnt)
3299 (*ctrl_cnt)++;
3300 continue;
3301 }
3302 /* Traditionally, Emacs would ignore the character payload of VK_NUMPAD*
3303 keys, and would treat them later via `function-key-map'. In addition
3304 to usual 102-key NUMPAD keys, this map also treats `kp-'-variants of
3305 space, tab, enter, separator, equal. TAB and EQUAL, apparently,
3306 cannot be generated on Win-GUI branch. ENTER is already handled
3307 by the code above. According to `lispy_function_keys', kp_space is
3308 generated by not-extended VK_CLEAR. (kp-tab != VK_OEM_NEC_EQUAL!).
3309
3310 We do similarly for backward-compatibility, but ignore only the
3311 characters restorable later by `function-key-map'. */
3312 if (code_unit < 0x7f
3313 && ((vk >= VK_NUMPAD0 && vk <= VK_DIVIDE)
3314 || (exp && ((vk >= VK_PRIOR && vk <= VK_DOWN) ||
3315 vk == VK_INSERT || vk == VK_DELETE || vk == VK_CLEAR)))
3316 && strchr ("0123456789/*-+.,", code_unit))
3317 continue;
3318 *buf++ = code_unit;
3319 buflen--;
3320 }
3321 return i - buflen;
3322 }
3323
3324 #ifdef DBG_WM_CHARS
3325 # define FPRINTF_WM_CHARS(ARG) fprintf ARG
3326 #else
3327 # define FPRINTF_WM_CHARS(ARG) (void)0
3328 #endif
3329
3330 /* This is a heuristic only. This is supposed to track the state of the
3331 finite automaton in the language environment of Windows.
3332
3333 However, separate windows (if with the same different language
3334 environments!) should have different values. Moreover, switching to a
3335 non-Emacs window with the same language environment, and using (dead)keys
3336 there would change the value stored in the kernel, but not this value. */
3337 /* A layout may emit deadkey=0. It looks like this would reset the state
3338 of the kernel's finite automaton (equivalent to emiting 0-length string,
3339 which is otherwise impossible in the dead-key map of a layout).
3340 Be ready to treat the case when this delivers WM_(SYS)DEADCHAR. */
3341 static int after_deadkey = -1;
3342
3343 int
3344 deliver_wm_chars (int do_translate, HWND hwnd, UINT msg, UINT wParam,
3345 UINT lParam, int legacy_alt_meta)
3346 {
3347 /* An "old style" keyboard description may assign up to 125 UTF-16 code
3348 points to a keypress.
3349 (However, the "old style" TranslateMessage() would deliver at most 16 of
3350 them.) Be on a safe side, and prepare to treat many more. */
3351 int ctrl_cnt, buf[1024], count, is_dead, after_dead = (after_deadkey > 0);
3352
3353 /* Since the keypress processing logic of Windows has a lot of state, it
3354 is important to call TranslateMessage() for every keyup/keydown, AND
3355 do it exactly once. (The actual change of state is done by
3356 ToUnicode[Ex](), which is called by TranslateMessage(). So one can
3357 call ToUnicode[Ex]() instead.)
3358
3359 The "usual" message pump calls TranslateMessage() for EVERY event.
3360 Emacs calls TranslateMessage() very selectively (is it needed for doing
3361 some tricky stuff with Win95??? With newer Windows, selectiveness is,
3362 most probably, not needed -- and harms a lot).
3363
3364 So, with the usual message pump, the following call to TranslateMessage()
3365 is not needed (and is going to be VERY harmful). With Emacs' message
3366 pump, the call is needed. */
3367 if (do_translate)
3368 {
3369 MSG windows_msg = { hwnd, msg, wParam, lParam, 0, {0,0} };
3370
3371 windows_msg.time = GetMessageTime ();
3372 TranslateMessage (&windows_msg);
3373 }
3374 count = get_wm_chars (hwnd, buf, sizeof (buf)/sizeof (*buf), 1,
3375 /* The message may have been synthesized by
3376 who knows what; be conservative. */
3377 modifier_set (VK_LCONTROL)
3378 || modifier_set (VK_RCONTROL)
3379 || modifier_set (VK_CONTROL),
3380 &ctrl_cnt, &is_dead, wParam,
3381 (lParam & 0x1000000L) != 0);
3382 if (count)
3383 {
3384 W32Msg wmsg;
3385 DWORD console_modifiers = construct_console_modifiers ();
3386 int *b = buf, strip_ExtraMods = 1, hairy = 0;
3387 char *type_CtrlAlt = NULL;
3388
3389 /* XXXX In fact, there may be another case when we need to do the same:
3390 What happens if the string defined in the LIGATURES has length
3391 0? Probably, we will get count==0, but the state of the finite
3392 automaton would reset to 0??? */
3393 after_deadkey = -1;
3394
3395 /* wParam is checked when converting CapsLock to Shift; this is a clone
3396 of w32_get_key_modifiers (). */
3397 wmsg.dwModifiers = w32_kbd_mods_to_emacs (console_modifiers, wParam);
3398
3399 /* What follows is just heuristics; the correct treatement requires
3400 non-destructive ToUnicode():
3401 http://search.cpan.org/~ilyaz/UI-KeyboardLayout/lib/UI/KeyboardLayout.pm#Can_an_application_on_Windows_accept_keyboard_events?_Part_IV:_application-specific_modifiers
3402
3403 What one needs to find is:
3404 * which of the present modifiers AFFECT the resulting char(s)
3405 (so should be stripped, since their EFFECT is "already
3406 taken into account" in the string in buf), and
3407 * which modifiers are not affecting buf, so should be reported to
3408 the application for further treatment.
3409
3410 Example: assume that we know:
3411 (A) lCtrl+rCtrl+rAlt modifiers with VK_A key produce a Latin "f"
3412 ("may be logical" in JCUKEN-flavored Russian keyboard flavors);
3413 (B) removing any of lCtrl, rCtrl, rAlt changes the produced char;
3414 (C) Win-modifier is not affecting the produced character
3415 (this is the common case: happens with all "standard" layouts).
3416
3417 Suppose the user presses Win+lCtrl+rCtrl+rAlt modifiers with VK_A.
3418 What is the intent of the user? We need to guess the intent to decide
3419 which event to deliver to the application.
3420
3421 This looks like a reasonable logic: since Win- modifier doesn't affect
3422 the output string, the user was pressing Win for SOME OTHER purpose.
3423 So the user wanted to generate Win-SOMETHING event. Now, what is
3424 something? If one takes the mantra that "character payload is more
3425 important than the combination of keypresses which resulted in this
3426 payload", then one should ignore lCtrl+rCtrl+rAlt, ignore VK_A, and
3427 assume that the user wanted to generate Win-f.
3428
3429 Unfortunately, without non-destructive ToUnicode(), checking (B),(C)
3430 is out of question. So we use heuristics (hopefully, covering
3431 99.9999% of cases). */
3432
3433 /* Another thing to watch for is a possibility to use AltGr-* and
3434 Ctrl-Alt-* with different semantic.
3435
3436 Background: the layout defining the KLLF_ALTGR bit are treated
3437 specially by the kernel: when VK_RMENU (=rightAlt, =AltGr) is pressed
3438 (released), a press (release) of VK_LCONTROL is emulated (unless Ctrl
3439 is already down). As a result, any press/release of AltGr is seen
3440 by applications as a press/release of lCtrl AND rAlt. This is
3441 applicable, in particular, to ToUnicode[Ex](). (Keyrepeat is covered
3442 the same way!)
3443
3444 NOTE: it IS possible to see bare rAlt even with KLLF_ALTGR; but this
3445 requires a good finger coordination: doing (physically)
3446 Down-lCtrl Down-rAlt Up-lCtrl Down-a
3447 (doing quick enough, so that key repeat of rAlt [which would
3448 generate new "fake" Down-lCtrl events] does not happens before 'a'
3449 is down) results in no "fake" events, so the application will see
3450 only rAlt down when 'a' is pressed. (However, fake Up-lCtrl WILL
3451 be generated when rAlt goes UP.)
3452
3453 In fact, note also that KLLF_ALTGR does not prohibit construction of
3454 rCtrl-rAlt (just press them in this order!).
3455
3456 Moreover: "traditional" layouts do not define distinct modifier-masks
3457 for VK_LMENU and VK_RMENU (same for VK_L/RCONTROL). Instead, they
3458 rely on the KLLF_ALTGR bit to make the behavior of VK_LMENU and
3459 VK_RMENU distinct. As a corollary, for such layouts, the produced
3460 character is the same for AltGr-* (=rAlt-*) and Ctrl-Alt-* (in any
3461 combination of handedness). For description of masks, see
3462
3463 http://search.cpan.org/~ilyaz/UI-KeyboardLayout/lib/UI/KeyboardLayout.pm#Keyboard_input_on_Windows,_Part_I:_what_is_the_kernel_doing?
3464
3465 By default, Emacs was using these coincidences via the following
3466 heuristics: it was treating:
3467 (*) keypresses with lCtrl-rAlt modifiers as if they are carrying
3468 ONLY the character payload (no matter what the actual keyboard
3469 was defining: if lCtrl-lAlt-b was delivering U+05df=beta, then
3470 Emacs saw [beta]; if lCtrl-lAlt-b was undefined in the layout,
3471 the keypress was completely ignored), and
3472 (*) keypresses with the other combinations of handedness of Ctrl-Alt
3473 modifiers (e.g., lCtrl-lAlt) as if they NEVER carry a character
3474 payload (so they were reported "raw": if lCtrl-lAlt-b was
3475 delivering beta, then Emacs saw event [C-A-b], and not [beta]).
3476 This worked good for "traditional" layouts: users could type both
3477 AltGr-x and Ctrl-Alt-x, and one was a character, another a bindable
3478 event.
3479
3480 However, for layouts which deliver different characters for AltGr-x
3481 and lCtrl-lAlt-x, this scheme makes the latter character unaccessible
3482 in Emacs. While it is easy to access functionality of [C-M-x] in
3483 Emacs by other means (for example, by the `controlify' prefix, or
3484 using lCtrl-rCtrl-x, or rCtrl-rAlt-x [in this order]), missing
3485 characters cannot be reconstructed without a tedious manual work. */
3486
3487 /* These two cases are often going to be distinguishable, since at most
3488 one of these character is defined with KBDCTRL | KBDMENU modifier
3489 bitmap. (This heuristic breaks if both lCtrl-lAlt- AND lCtrl-rAlt-
3490 are translated to modifier bitmaps distinct from KBDCTRL | KBDMENU,
3491 or in the cases when lCtrl-lAlt-* and lCtrl-rAlt-* are generally
3492 different, but lCtrl-lAlt-x and lCtrl-rAlt-x happen to deliver the
3493 same character.)
3494
3495 So we have 2 chunks of info:
3496 (A) is it lCtrl-rAlt-, or lCtrl-lAlt, or some other combination?
3497 (B) is the delivered character defined with KBDCTRL | KBDMENU bits?
3498 Basing on (A) and (B), we should decide whether to ignore the
3499 delivered character. (Before, Emacs was completely ignoring (B), and
3500 was treating the 3-state of (A) as a bit.) This means that we have 6
3501 bits of customization.
3502
3503 Additionally, a presence of two Ctrl down may be AltGr-rCtrl-. */
3504
3505 /* Strip all non-Shift modifiers if:
3506 - more than one UTF-16 code point delivered (can't call VkKeyScanW ())
3507 - or the character is a result of combining with a prefix key. */
3508 if (!after_dead && count == 1 && *b < 0x10000)
3509 {
3510 if (console_modifiers & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED)
3511 && console_modifiers & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
3512 {
3513 type_CtrlAlt = "bB"; /* generic bindable Ctrl-Alt- modifiers */
3514 if ((console_modifiers & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
3515 == (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
3516 /* double-Ctrl:
3517 e.g. AltGr-rCtrl on some layouts (in this order!) */
3518 type_CtrlAlt = "dD";
3519 else if ((console_modifiers
3520 & (LEFT_CTRL_PRESSED | LEFT_ALT_PRESSED))
3521 == (LEFT_CTRL_PRESSED | LEFT_ALT_PRESSED))
3522 type_CtrlAlt = "lL"; /* Ctrl-Alt- modifiers on the left */
3523 else if (!NILP (Vw32_recognize_altgr)
3524 && ((console_modifiers
3525 & (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED)))
3526 == (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
3527 type_CtrlAlt = "gG"; /* modifiers as in AltGr */
3528 }
3529 else if (wmsg.dwModifiers & (alt_modifier | meta_modifier)
3530 || ((console_modifiers
3531 & (LEFT_WIN_PRESSED | RIGHT_WIN_PRESSED
3532 | APPS_PRESSED | SCROLLLOCK_ON))))
3533 {
3534 /* Pure Alt (or combination of Alt, Win, APPS, scrolllock. */
3535 type_CtrlAlt = "aA";
3536 }
3537 if (type_CtrlAlt)
3538 {
3539 /* Out of bound bitmap: */
3540 SHORT r = VkKeyScanW (*b), bitmap = 0x1FF;
3541
3542 FPRINTF_WM_CHARS((stderr, "VkKeyScanW %#06x %#04x\n", (int)r,
3543 wParam));
3544 if ((r & 0xFF) == wParam)
3545 bitmap = r>>8; /* *b is reachable via simple interface */
3546 if (*type_CtrlAlt == 'a') /* Simple Alt seen */
3547 {
3548 if ((bitmap & ~1) == 0) /* 1: KBDSHIFT */
3549 {
3550 /* In "traditional" layouts, Alt without Ctrl does not
3551 change the delivered character. This detects this
3552 situation; it is safe to report this as Alt-something
3553 -- as opposed to delivering the reported character
3554 without modifiers. */
3555 if (legacy_alt_meta
3556 && *b > 0x7f && ('A' <= wParam && wParam <= 'Z'))
3557 /* For backward-compatibility with older Emacsen, let
3558 this be processed by another branch below (which
3559 would convert it to Alt-Latin char via wParam). */
3560 return 0;
3561 }
3562 else
3563 hairy = 1;
3564 }
3565 /* Check whether the delivered character(s) is accessible via
3566 KBDCTRL | KBDALT ( | KBDSHIFT ) modifier mask (which is 7). */
3567 else if ((bitmap & ~1) != 6)
3568 {
3569 /* The character is not accessible via plain Ctrl-Alt(-Shift)
3570 (which is, probably, same as AltGr) modifiers.
3571 Either it was after a prefix key, or is combined with
3572 modifier keys which we don't see, or there is an asymmetry
3573 between left-hand and right-hand modifiers, or other hairy
3574 stuff. */
3575 hairy = 1;
3576 }
3577 /* The best solution is to delegate these tough (but rarely
3578 needed) choices to the user. Temporarily (???), it is
3579 implemented as C macros.
3580
3581 Essentially, there are 3 things to do: return 0 (handle to the
3582 legacy processing code [ignoring the character payload]; keep
3583 some modifiers (so that they will be processed by the binding
3584 system [on top of the character payload]; strip modifiers [so
3585 that `self-insert' is going to be triggered with the character
3586 payload]).
3587
3588 The default below should cover 99.9999% of cases:
3589 (a) strip Alt- in the hairy case only;
3590 (stripping = not ignoring)
3591 (l) for lAlt-lCtrl, ignore the char in simple cases only;
3592 (g) for what looks like AltGr, ignore the modifiers;
3593 (d) for what looks like lCtrl-rCtrl-Alt (probably
3594 AltGr-rCtrl), ignore the character in simple cases only;
3595 (b) for other cases of Ctrl-Alt, ignore the character in
3596 simple cases only.
3597
3598 Essentially, in all hairy cases, and in looks-like-AltGr case,
3599 we keep the character, ignoring the modifiers. In all the
3600 other cases, we ignore the delivered character. */
3601 #define S_TYPES_TO_IGNORE_CHARACTER_PAYLOAD "aldb"
3602 #define S_TYPES_TO_REPORT_CHARACTER_PAYLOAD_WITH_MODIFIERS ""
3603 if (strchr (S_TYPES_TO_IGNORE_CHARACTER_PAYLOAD,
3604 type_CtrlAlt[hairy]))
3605 return 0;
3606 /* If in neither list, report all the modifiers we see COMBINED
3607 WITH the reported character. */
3608 if (strchr (S_TYPES_TO_REPORT_CHARACTER_PAYLOAD_WITH_MODIFIERS,
3609 type_CtrlAlt[hairy]))
3610 strip_ExtraMods = 0;
3611 }
3612 }
3613 if (strip_ExtraMods)
3614 wmsg.dwModifiers = wmsg.dwModifiers & shift_modifier;
3615
3616 signal_user_input ();
3617 while (count--)
3618 {
3619 FPRINTF_WM_CHARS((stderr, "unichar %#06x\n", *b));
3620 my_post_msg (&wmsg, hwnd, WM_UNICHAR, *b++, lParam);
3621 }
3622 if (!ctrl_cnt) /* Process ALSO as ctrl */
3623 return 1;
3624 else
3625 FPRINTF_WM_CHARS((stderr, "extra ctrl char\n"));
3626 return -1;
3627 }
3628 else if (is_dead >= 0)
3629 {
3630 FPRINTF_WM_CHARS((stderr, "dead %#06x\n", is_dead));
3631 after_deadkey = is_dead;
3632 return 1;
3633 }
3634 return 0;
3635 }
3636
3637 /* Main window procedure */
3638
3639 static LRESULT CALLBACK
3640 w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
3641 {
3642 struct frame *f;
3643 struct w32_display_info *dpyinfo = &one_w32_display_info;
3644 W32Msg wmsg;
3645 int windows_translate;
3646 int key;
3647
3648 /* Note that it is okay to call x_window_to_frame, even though we are
3649 not running in the main lisp thread, because frame deletion
3650 requires the lisp thread to synchronize with this thread. Thus, if
3651 a frame struct is returned, it can be used without concern that the
3652 lisp thread might make it disappear while we are using it.
3653
3654 NB. Walking the frame list in this thread is safe (as long as
3655 writes of Lisp_Object slots are atomic, which they are on Windows).
3656 Although delete-frame can destructively modify the frame list while
3657 we are walking it, a garbage collection cannot occur until after
3658 delete-frame has synchronized with this thread.
3659
3660 It is also safe to use functions that make GDI calls, such as
3661 w32_clear_rect, because these functions must obtain a DC handle
3662 from the frame struct using get_frame_dc which is thread-aware. */
3663
3664 switch (msg)
3665 {
3666 case WM_ERASEBKGND:
3667 f = x_window_to_frame (dpyinfo, hwnd);
3668 if (f)
3669 {
3670 HDC hdc = get_frame_dc (f);
3671 GetUpdateRect (hwnd, &wmsg.rect, FALSE);
3672 w32_clear_rect (f, hdc, &wmsg.rect);
3673 release_frame_dc (f, hdc);
3674
3675 #if defined (W32_DEBUG_DISPLAY)
3676 DebPrint (("WM_ERASEBKGND (frame %p): erasing %d,%d-%d,%d\n",
3677 f,
3678 wmsg.rect.left, wmsg.rect.top,
3679 wmsg.rect.right, wmsg.rect.bottom));
3680 #endif /* W32_DEBUG_DISPLAY */
3681 }
3682 return 1;
3683 case WM_PALETTECHANGED:
3684 /* ignore our own changes */
3685 if ((HWND)wParam != hwnd)
3686 {
3687 f = x_window_to_frame (dpyinfo, hwnd);
3688 if (f)
3689 /* get_frame_dc will realize our palette and force all
3690 frames to be redrawn if needed. */
3691 release_frame_dc (f, get_frame_dc (f));
3692 }
3693 return 0;
3694 case WM_PAINT:
3695 {
3696 PAINTSTRUCT paintStruct;
3697 RECT update_rect;
3698 memset (&update_rect, 0, sizeof (update_rect));
3699
3700 f = x_window_to_frame (dpyinfo, hwnd);
3701 if (f == 0)
3702 {
3703 DebPrint (("WM_PAINT received for unknown window %p\n", hwnd));
3704 return 0;
3705 }
3706
3707 /* MSDN Docs say not to call BeginPaint if GetUpdateRect
3708 fails. Apparently this can happen under some
3709 circumstances. */
3710 if (GetUpdateRect (hwnd, &update_rect, FALSE) || !w32_strict_painting)
3711 {
3712 enter_crit ();
3713 BeginPaint (hwnd, &paintStruct);
3714
3715 /* The rectangles returned by GetUpdateRect and BeginPaint
3716 do not always match. Play it safe by assuming both areas
3717 are invalid. */
3718 UnionRect (&(wmsg.rect), &update_rect, &(paintStruct.rcPaint));
3719
3720 #if defined (W32_DEBUG_DISPLAY)
3721 DebPrint (("WM_PAINT (frame %p): painting %d,%d-%d,%d\n",
3722 f,
3723 wmsg.rect.left, wmsg.rect.top,
3724 wmsg.rect.right, wmsg.rect.bottom));
3725 DebPrint ((" [update region is %d,%d-%d,%d]\n",
3726 update_rect.left, update_rect.top,
3727 update_rect.right, update_rect.bottom));
3728 #endif
3729 EndPaint (hwnd, &paintStruct);
3730 leave_crit ();
3731
3732 /* Change the message type to prevent Windows from
3733 combining WM_PAINT messages in the Lisp thread's queue,
3734 since Windows assumes that each message queue is
3735 dedicated to one frame and does not bother checking
3736 that hwnd matches before combining them. */
3737 my_post_msg (&wmsg, hwnd, WM_EMACS_PAINT, wParam, lParam);
3738
3739 return 0;
3740 }
3741
3742 /* If GetUpdateRect returns 0 (meaning there is no update
3743 region), assume the whole window needs to be repainted. */
3744 GetClientRect (hwnd, &wmsg.rect);
3745 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3746 return 0;
3747 }
3748
3749 case WM_INPUTLANGCHANGE:
3750 /* Inform lisp thread of keyboard layout changes. */
3751 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3752
3753 /* The state of the finite automaton is separate per every input
3754 language environment (so it does not change when one switches
3755 to a different window with the same environment). Moreover,
3756 the experiments show that the state is not remembered when
3757 one switches back to the pre-previous environment. */
3758 after_deadkey = -1;
3759
3760 /* XXXX??? What follows is a COMPLETE misunderstanding of Windows! */
3761
3762 /* Clear dead keys in the keyboard state; for simplicity only
3763 preserve modifier key states. */
3764 {
3765 int i;
3766 BYTE keystate[256];
3767
3768 GetKeyboardState (keystate);
3769 for (i = 0; i < 256; i++)
3770 if (1
3771 && i != VK_SHIFT
3772 && i != VK_LSHIFT
3773 && i != VK_RSHIFT
3774 && i != VK_CAPITAL
3775 && i != VK_NUMLOCK
3776 && i != VK_SCROLL
3777 && i != VK_CONTROL
3778 && i != VK_LCONTROL
3779 && i != VK_RCONTROL
3780 && i != VK_MENU
3781 && i != VK_LMENU
3782 && i != VK_RMENU
3783 && i != VK_LWIN
3784 && i != VK_RWIN)
3785 keystate[i] = 0;
3786 SetKeyboardState (keystate);
3787 }
3788 goto dflt;
3789
3790 case WM_HOTKEY:
3791 /* Synchronize hot keys with normal input. */
3792 PostMessage (hwnd, WM_KEYDOWN, HIWORD (lParam), 0);
3793 return (0);
3794
3795 case WM_KEYUP:
3796 case WM_SYSKEYUP:
3797 record_keyup (wParam, lParam);
3798 goto dflt;
3799
3800 case WM_KEYDOWN:
3801 case WM_SYSKEYDOWN:
3802 /* Ignore keystrokes we fake ourself; see below. */
3803 if (dpyinfo->faked_key == wParam)
3804 {
3805 dpyinfo->faked_key = 0;
3806 /* Make sure TranslateMessage sees them though (as long as
3807 they don't produce WM_CHAR messages). This ensures that
3808 indicator lights are toggled promptly on Windows 9x, for
3809 example. */
3810 if (wParam < 256 && lispy_function_keys[wParam])
3811 {
3812 windows_translate = 1;
3813 goto translate;
3814 }
3815 return 0;
3816 }
3817
3818 /* Synchronize modifiers with current keystroke. */
3819 sync_modifiers ();
3820 record_keydown (wParam, lParam);
3821 if (w32_use_fallback_wm_chars_method)
3822 wParam = map_keypad_keys (wParam, (lParam & 0x1000000L) != 0);
3823
3824 windows_translate = 0;
3825
3826 switch (wParam)
3827 {
3828 case VK_LWIN:
3829 if (!w32_kbdhook_active && NILP (Vw32_pass_lwindow_to_system))
3830 {
3831 /* Prevent system from acting on keyup (which opens the
3832 Start menu if no other key was pressed) by simulating a
3833 press of Space which we will ignore. */
3834 if (GetAsyncKeyState (wParam) & 1)
3835 {
3836 if (NUMBERP (Vw32_phantom_key_code))
3837 key = XUINT (Vw32_phantom_key_code) & 255;
3838 else
3839 key = VK_SPACE;
3840 dpyinfo->faked_key = key;
3841 keybd_event (key, (BYTE) MapVirtualKey (key, 0), 0, 0);
3842 }
3843 }
3844 if (!NILP (Vw32_lwindow_modifier))
3845 return 0;
3846 break;
3847 case VK_RWIN:
3848 if (!w32_kbdhook_active && NILP (Vw32_pass_rwindow_to_system))
3849 {
3850 if (GetAsyncKeyState (wParam) & 1)
3851 {
3852 if (NUMBERP (Vw32_phantom_key_code))
3853 key = XUINT (Vw32_phantom_key_code) & 255;
3854 else
3855 key = VK_SPACE;
3856 dpyinfo->faked_key = key;
3857 keybd_event (key, (BYTE) MapVirtualKey (key, 0), 0, 0);
3858 }
3859 }
3860 if (!NILP (Vw32_rwindow_modifier))
3861 return 0;
3862 break;
3863 case VK_APPS:
3864 if (!NILP (Vw32_apps_modifier))
3865 return 0;
3866 break;
3867 case VK_MENU:
3868 if (NILP (Vw32_pass_alt_to_system))
3869 /* Prevent DefWindowProc from activating the menu bar if an
3870 Alt key is pressed and released by itself. */
3871 return 0;
3872 windows_translate = 1;
3873 break;
3874 case VK_CAPITAL:
3875 /* Decide whether to treat as modifier or function key. */
3876 if (NILP (Vw32_enable_caps_lock))
3877 goto disable_lock_key;
3878 windows_translate = 1;
3879 break;
3880 case VK_NUMLOCK:
3881 /* Decide whether to treat as modifier or function key. */
3882 if (NILP (Vw32_enable_num_lock))
3883 goto disable_lock_key;
3884 windows_translate = 1;
3885 break;
3886 case VK_SCROLL:
3887 /* Decide whether to treat as modifier or function key. */
3888 if (NILP (Vw32_scroll_lock_modifier))
3889 goto disable_lock_key;
3890 windows_translate = 1;
3891 break;
3892 disable_lock_key:
3893 /* Ensure the appropriate lock key state (and indicator light)
3894 remains in the same state. We do this by faking another
3895 press of the relevant key. Apparently, this really is the
3896 only way to toggle the state of the indicator lights. */
3897 dpyinfo->faked_key = wParam;
3898 keybd_event ((BYTE) wParam, (BYTE) MapVirtualKey (wParam, 0),
3899 KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
3900 keybd_event ((BYTE) wParam, (BYTE) MapVirtualKey (wParam, 0),
3901 KEYEVENTF_EXTENDEDKEY | 0, 0);
3902 keybd_event ((BYTE) wParam, (BYTE) MapVirtualKey (wParam, 0),
3903 KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
3904 /* Ensure indicator lights are updated promptly on Windows 9x
3905 (TranslateMessage apparently does this), after forwarding
3906 input event. */
3907 post_character_message (hwnd, msg, wParam, lParam,
3908 w32_get_key_modifiers (wParam, lParam));
3909 windows_translate = 1;
3910 break;
3911 case VK_CONTROL:
3912 case VK_SHIFT:
3913 case VK_PROCESSKEY: /* Generated by IME. */
3914 windows_translate = 1;
3915 break;
3916 case VK_CANCEL:
3917 /* Windows maps Ctrl-Pause (aka Ctrl-Break) into VK_CANCEL,
3918 which is confusing for purposes of key binding; convert
3919 VK_CANCEL events into VK_PAUSE events. */
3920 wParam = VK_PAUSE;
3921 break;
3922 case VK_PAUSE:
3923 /* Windows maps Ctrl-NumLock into VK_PAUSE, which is confusing
3924 for purposes of key binding; convert these back into
3925 VK_NUMLOCK events, at least when we want to see NumLock key
3926 presses. (Note that there is never any possibility that
3927 VK_PAUSE with Ctrl really is C-Pause as per above.) */
3928 if (NILP (Vw32_enable_num_lock) && modifier_set (VK_CONTROL))
3929 wParam = VK_NUMLOCK;
3930 break;
3931 default:
3932 if (w32_unicode_gui && !w32_use_fallback_wm_chars_method)
3933 {
3934 /* If this event generates characters or deadkeys, do
3935 not interpret it as a "raw combination of modifiers
3936 and keysym". Hide deadkeys, and use the generated
3937 character(s) instead of the keysym. (Backward
3938 compatibility: exceptions for numpad keys generating
3939 0-9 . , / * - +, and for extra-Alt combined with a
3940 non-Latin char.)
3941
3942 Try to not report modifiers which have effect on
3943 which character or deadkey is generated.
3944
3945 Example (contrived): if rightAlt-? generates f (on a
3946 Cyrillic keyboard layout), and Ctrl, leftAlt do not
3947 affect the generated character, one wants to report
3948 Ctrl-leftAlt-f if the user presses
3949 Ctrl-leftAlt-rightAlt-?. */
3950 int res;
3951 #if 0
3952 /* Some of WM_CHAR may be fed to us directly, some are
3953 results of TranslateMessage(). Using 0 as the first
3954 argument (in a separate call) might help us
3955 distinguish these two cases.
3956
3957 However, the keypress feeders would most probably
3958 expect the "standard" message pump, when
3959 TranslateMessage() is called on EVERY KeyDown/KeyUp
3960 event. So they may feed us Down-Ctrl Down-FAKE
3961 Char-o and expect us to recognize it as Ctrl-o.
3962 Using 0 as the first argument would interfere with
3963 this. */
3964 deliver_wm_chars (0, hwnd, msg, wParam, lParam, 1);
3965 #endif
3966 /* Processing the generated WM_CHAR messages *WHILE* we
3967 handle KEYDOWN/UP event is the best choice, since
3968 without any fuss, we know all 3 of: scancode, virtual
3969 keycode, and expansion. (Additionally, one knows
3970 boundaries of expansion of different keypresses.) */
3971 res = deliver_wm_chars (1, hwnd, msg, wParam, lParam, 1);
3972 windows_translate = -(res != 0);
3973 if (res > 0) /* Bound to character(s) or a deadkey */
3974 break;
3975 /* deliver_wm_chars may make some branches after this vestigal. */
3976 }
3977 wParam = map_keypad_keys (wParam, (lParam & 0x1000000L) != 0);
3978 /* If not defined as a function key, change it to a WM_CHAR message. */
3979 if (wParam > 255 || !lispy_function_keys[wParam])
3980 {
3981 DWORD modifiers = construct_console_modifiers ();
3982
3983 if (!NILP (Vw32_recognize_altgr)
3984 && modifier_set (VK_LCONTROL) && modifier_set (VK_RMENU))
3985 {
3986 /* Always let TranslateMessage handle AltGr key chords;
3987 for some reason, ToAscii doesn't always process AltGr
3988 chords correctly. */
3989 windows_translate = 1;
3990 }
3991 else if ((modifiers & (~SHIFT_PRESSED & ~CAPSLOCK_ON)) != 0)
3992 {
3993 /* Handle key chords including any modifiers other
3994 than shift directly, in order to preserve as much
3995 modifier information as possible. */
3996 if ('A' <= wParam && wParam <= 'Z')
3997 {
3998 /* Don't translate modified alphabetic keystrokes,
3999 so the user doesn't need to constantly switch
4000 layout to type control or meta keystrokes when
4001 the normal layout translates alphabetic
4002 characters to non-ascii characters. */
4003 if (!modifier_set (VK_SHIFT))
4004 wParam += ('a' - 'A');
4005 msg = WM_CHAR;
4006 }
4007 else
4008 {
4009 /* Try to handle other keystrokes by determining the
4010 base character (ie. translating the base key plus
4011 shift modifier). */
4012 int add;
4013 KEY_EVENT_RECORD key;
4014
4015 key.bKeyDown = TRUE;
4016 key.wRepeatCount = 1;
4017 key.wVirtualKeyCode = wParam;
4018 key.wVirtualScanCode = (lParam & 0xFF0000) >> 16;
4019 key.uChar.AsciiChar = 0;
4020 key.dwControlKeyState = modifiers;
4021
4022 add = w32_kbd_patch_key (&key, w32_keyboard_codepage);
4023 /* 0 means an unrecognized keycode, negative means
4024 dead key. Ignore both. */
4025 while (--add >= 0)
4026 {
4027 /* Forward asciified character sequence. */
4028 post_character_message
4029 (hwnd, WM_CHAR,
4030 (unsigned char) key.uChar.AsciiChar, lParam,
4031 w32_get_key_modifiers (wParam, lParam));
4032 w32_kbd_patch_key (&key, w32_keyboard_codepage);
4033 }
4034 return 0;
4035 }
4036 }
4037 else
4038 {
4039 /* Let TranslateMessage handle everything else. */
4040 windows_translate = 1;
4041 }
4042 }
4043 }
4044
4045 if (windows_translate == -1)
4046 break;
4047 translate:
4048 if (windows_translate)
4049 {
4050 MSG windows_msg = { hwnd, msg, wParam, lParam, 0, {0,0} };
4051 windows_msg.time = GetMessageTime ();
4052 TranslateMessage (&windows_msg);
4053 goto dflt;
4054 }
4055
4056 /* Fall through */
4057
4058 case WM_SYSCHAR:
4059 case WM_CHAR:
4060 if (wParam > 255 )
4061 {
4062 W32Msg wmsg;
4063
4064 wmsg.dwModifiers = w32_get_key_modifiers (wParam, lParam);
4065 signal_user_input ();
4066 my_post_msg (&wmsg, hwnd, WM_UNICHAR, wParam, lParam);
4067
4068 }
4069 else
4070 post_character_message (hwnd, msg, wParam, lParam,
4071 w32_get_key_modifiers (wParam, lParam));
4072 break;
4073
4074 case WM_UNICHAR:
4075 /* WM_UNICHAR looks promising from the docs, but the exact
4076 circumstances in which TranslateMessage sends it is one of those
4077 Microsoft secret API things that EU and US courts are supposed
4078 to have put a stop to already. Spy++ shows it being sent to Notepad
4079 and other MS apps, but never to Emacs.
4080
4081 Some third party IMEs send it in accordance with the official
4082 documentation though, so handle it here.
4083
4084 UNICODE_NOCHAR is used to test for support for this message.
4085 TRUE indicates that the message is supported. */
4086 if (wParam == UNICODE_NOCHAR)
4087 return TRUE;
4088
4089 {
4090 W32Msg wmsg;
4091 wmsg.dwModifiers = w32_get_key_modifiers (wParam, lParam);
4092 signal_user_input ();
4093 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4094 }
4095 break;
4096
4097 case WM_IME_CHAR:
4098 /* If we can't get the IME result as Unicode, use default processing,
4099 which will at least allow characters decodable in the system locale
4100 get through. */
4101 if (!get_composition_string_fn)
4102 goto dflt;
4103
4104 else if (!ignore_ime_char)
4105 {
4106 wchar_t * buffer;
4107 int size, i;
4108 W32Msg wmsg;
4109 HIMC context = get_ime_context_fn (hwnd);
4110 wmsg.dwModifiers = w32_get_key_modifiers (wParam, lParam);
4111 /* Get buffer size. */
4112 size = get_composition_string_fn (context, GCS_RESULTSTR, NULL, 0);
4113 buffer = alloca (size);
4114 size = get_composition_string_fn (context, GCS_RESULTSTR,
4115 buffer, size);
4116 release_ime_context_fn (hwnd, context);
4117
4118 signal_user_input ();
4119 for (i = 0; i < size / sizeof (wchar_t); i++)
4120 {
4121 my_post_msg (&wmsg, hwnd, WM_UNICHAR, (WPARAM) buffer[i],
4122 lParam);
4123 }
4124 /* Ignore the messages for the rest of the
4125 characters in the string that was output above. */
4126 ignore_ime_char = (size / sizeof (wchar_t)) - 1;
4127 }
4128 else
4129 ignore_ime_char--;
4130
4131 break;
4132
4133 case WM_IME_STARTCOMPOSITION:
4134 if (!set_ime_composition_window_fn)
4135 goto dflt;
4136 else
4137 {
4138 COMPOSITIONFORM form;
4139 HIMC context;
4140 struct window *w;
4141
4142 /* Implementation note: The code below does something that
4143 one shouldn't do: it accesses the window object from a
4144 separate thread, while the main (a.k.a. "Lisp") thread
4145 runs and can legitimately delete and even GC it. That is
4146 why we are extra careful not to futz with a window that
4147 is different from the one recorded when the system caret
4148 coordinates were last modified. That is also why we are
4149 careful not to move the IME window if the window
4150 described by W was deleted, as indicated by its buffer
4151 field being reset to nil. */
4152 f = x_window_to_frame (dpyinfo, hwnd);
4153 if (!(f && FRAME_LIVE_P (f)))
4154 goto dflt;
4155 w = XWINDOW (FRAME_SELECTED_WINDOW (f));
4156 /* Punt if someone changed the frame's selected window
4157 behind our back. */
4158 if (w != w32_system_caret_window)
4159 goto dflt;
4160
4161 form.dwStyle = CFS_RECT;
4162 form.ptCurrentPos.x = w32_system_caret_x;
4163 form.ptCurrentPos.y = w32_system_caret_y;
4164
4165 form.rcArea.left = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, 0);
4166 form.rcArea.top = (WINDOW_TOP_EDGE_Y (w)
4167 + w32_system_caret_hdr_height);
4168 form.rcArea.right = (WINDOW_BOX_RIGHT_EDGE_X (w)
4169 - WINDOW_RIGHT_MARGIN_WIDTH (w)
4170 - WINDOW_RIGHT_FRINGE_WIDTH (w));
4171 form.rcArea.bottom = (WINDOW_BOTTOM_EDGE_Y (w)
4172 - WINDOW_BOTTOM_DIVIDER_WIDTH (w)
4173 - w32_system_caret_mode_height);
4174
4175 /* Punt if the window was deleted behind our back. */
4176 if (!BUFFERP (w->contents))
4177 goto dflt;
4178
4179 context = get_ime_context_fn (hwnd);
4180
4181 if (!context)
4182 goto dflt;
4183
4184 set_ime_composition_window_fn (context, &form);
4185 release_ime_context_fn (hwnd, context);
4186 }
4187 /* We should "goto dflt" here to pass WM_IME_STARTCOMPOSITION to
4188 DefWindowProc, so that the composition window will actually
4189 be displayed. But doing so causes trouble with displaying
4190 dialog boxes, such as the file selection dialog or font
4191 selection dialog. So something else is needed to fix the
4192 former without breaking the latter. See bug#11732. */
4193 break;
4194
4195 case WM_IME_ENDCOMPOSITION:
4196 ignore_ime_char = 0;
4197 goto dflt;
4198
4199 /* Simulate middle mouse button events when left and right buttons
4200 are used together, but only if user has two button mouse. */
4201 case WM_LBUTTONDOWN:
4202 case WM_RBUTTONDOWN:
4203 if (w32_num_mouse_buttons > 2)
4204 goto handle_plain_button;
4205
4206 {
4207 int this = (msg == WM_LBUTTONDOWN) ? LMOUSE : RMOUSE;
4208 int other = (msg == WM_LBUTTONDOWN) ? RMOUSE : LMOUSE;
4209
4210 if (button_state & this)
4211 return 0;
4212
4213 if (button_state == 0)
4214 SetCapture (hwnd);
4215
4216 button_state |= this;
4217
4218 if (button_state & other)
4219 {
4220 if (mouse_button_timer)
4221 {
4222 KillTimer (hwnd, mouse_button_timer);
4223 mouse_button_timer = 0;
4224
4225 /* Generate middle mouse event instead. */
4226 msg = WM_MBUTTONDOWN;
4227 button_state |= MMOUSE;
4228 }
4229 else if (button_state & MMOUSE)
4230 {
4231 /* Ignore button event if we've already generated a
4232 middle mouse down event. This happens if the
4233 user releases and press one of the two buttons
4234 after we've faked a middle mouse event. */
4235 return 0;
4236 }
4237 else
4238 {
4239 /* Flush out saved message. */
4240 post_msg (&saved_mouse_button_msg);
4241 }
4242 wmsg.dwModifiers = w32_get_modifiers ();
4243 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4244 signal_user_input ();
4245
4246 /* Clear message buffer. */
4247 saved_mouse_button_msg.msg.hwnd = 0;
4248 }
4249 else
4250 {
4251 /* Hold onto message for now. */
4252 mouse_button_timer =
4253 SetTimer (hwnd, MOUSE_BUTTON_ID,
4254 w32_mouse_button_tolerance, NULL);
4255 saved_mouse_button_msg.msg.hwnd = hwnd;
4256 saved_mouse_button_msg.msg.message = msg;
4257 saved_mouse_button_msg.msg.wParam = wParam;
4258 saved_mouse_button_msg.msg.lParam = lParam;
4259 saved_mouse_button_msg.msg.time = GetMessageTime ();
4260 saved_mouse_button_msg.dwModifiers = w32_get_modifiers ();
4261 }
4262 }
4263 return 0;
4264
4265 case WM_LBUTTONUP:
4266 case WM_RBUTTONUP:
4267 if (w32_num_mouse_buttons > 2)
4268 goto handle_plain_button;
4269
4270 {
4271 int this = (msg == WM_LBUTTONUP) ? LMOUSE : RMOUSE;
4272 int other = (msg == WM_LBUTTONUP) ? RMOUSE : LMOUSE;
4273
4274 if ((button_state & this) == 0)
4275 return 0;
4276
4277 button_state &= ~this;
4278
4279 if (button_state & MMOUSE)
4280 {
4281 /* Only generate event when second button is released. */
4282 if ((button_state & other) == 0)
4283 {
4284 msg = WM_MBUTTONUP;
4285 button_state &= ~MMOUSE;
4286
4287 if (button_state) emacs_abort ();
4288 }
4289 else
4290 return 0;
4291 }
4292 else
4293 {
4294 /* Flush out saved message if necessary. */
4295 if (saved_mouse_button_msg.msg.hwnd)
4296 {
4297 post_msg (&saved_mouse_button_msg);
4298 }
4299 }
4300 wmsg.dwModifiers = w32_get_modifiers ();
4301 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4302 signal_user_input ();
4303
4304 /* Always clear message buffer and cancel timer. */
4305 saved_mouse_button_msg.msg.hwnd = 0;
4306 KillTimer (hwnd, mouse_button_timer);
4307 mouse_button_timer = 0;
4308
4309 if (button_state == 0)
4310 ReleaseCapture ();
4311 }
4312 return 0;
4313
4314 case WM_XBUTTONDOWN:
4315 case WM_XBUTTONUP:
4316 if (w32_pass_extra_mouse_buttons_to_system)
4317 goto dflt;
4318 /* else fall through and process them. */
4319 case WM_MBUTTONDOWN:
4320 case WM_MBUTTONUP:
4321 handle_plain_button:
4322 {
4323 BOOL up;
4324 int button;
4325
4326 /* Ignore middle and extra buttons as long as the menu is active. */
4327 f = x_window_to_frame (dpyinfo, hwnd);
4328 if (f && f->output_data.w32->menubar_active)
4329 return 0;
4330
4331 if (parse_button (msg, HIWORD (wParam), &button, &up))
4332 {
4333 if (up) ReleaseCapture ();
4334 else SetCapture (hwnd);
4335 button = (button == 0) ? LMOUSE :
4336 ((button == 1) ? MMOUSE : RMOUSE);
4337 if (up)
4338 button_state &= ~button;
4339 else
4340 button_state |= button;
4341 }
4342 }
4343
4344 wmsg.dwModifiers = w32_get_modifiers ();
4345 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4346 signal_user_input ();
4347
4348 /* Need to return true for XBUTTON messages, false for others,
4349 to indicate that we processed the message. */
4350 return (msg == WM_XBUTTONDOWN || msg == WM_XBUTTONUP);
4351
4352 case WM_MOUSEMOVE:
4353 f = x_window_to_frame (dpyinfo, hwnd);
4354 if (f)
4355 {
4356 /* Ignore mouse movements as long as the menu is active.
4357 These movements are processed by the window manager
4358 anyway, and it's wrong to handle them as if they happened
4359 on the underlying frame. */
4360 if (f->output_data.w32->menubar_active)
4361 return 0;
4362
4363 /* If the mouse moved, and the mouse pointer is invisible,
4364 make it visible again. We do this here so as to be able
4365 to show the mouse pointer even when the main
4366 (a.k.a. "Lisp") thread is busy doing something. */
4367 static int last_x, last_y;
4368 int x = GET_X_LPARAM (lParam);
4369 int y = GET_Y_LPARAM (lParam);
4370
4371 if (f->pointer_invisible
4372 && (x != last_x || y != last_y))
4373 f->pointer_invisible = false;
4374
4375 last_x = x;
4376 last_y = y;
4377 }
4378
4379 /* If the mouse has just moved into the frame, start tracking
4380 it, so we will be notified when it leaves the frame. Mouse
4381 tracking only works under W98 and NT4 and later. On earlier
4382 versions, there is no way of telling when the mouse leaves the
4383 frame, so we just have to put up with help-echo and mouse
4384 highlighting remaining while the frame is not active. */
4385 if (track_mouse_event_fn && !track_mouse_window
4386 /* If the menu bar is active, turning on tracking of mouse
4387 movement events might send these events to the tooltip
4388 frame, if the user happens to move the mouse pointer over
4389 the tooltip. But since we don't process events for
4390 tooltip frames, this causes Windows to present a
4391 hourglass cursor, which is ugly and unexpected. So don't
4392 enable tracking mouse events in this case; they will be
4393 restarted when the menu pops down. (Confusingly, the
4394 menubar_active member of f->output_data.w32, tested
4395 above, is only set when a menu was popped up _not_ from
4396 the frame's menu bar, but via x-popup-menu.) */
4397 && !menubar_in_use)
4398 {
4399 TRACKMOUSEEVENT tme;
4400 tme.cbSize = sizeof (tme);
4401 tme.dwFlags = TME_LEAVE;
4402 tme.hwndTrack = hwnd;
4403 tme.dwHoverTime = HOVER_DEFAULT;
4404
4405 track_mouse_event_fn (&tme);
4406 track_mouse_window = hwnd;
4407 }
4408 case WM_HSCROLL:
4409 case WM_VSCROLL:
4410 if (w32_mouse_move_interval <= 0
4411 || (msg == WM_MOUSEMOVE && button_state == 0))
4412 {
4413 wmsg.dwModifiers = w32_get_modifiers ();
4414 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4415 return 0;
4416 }
4417
4418 /* Hang onto mouse move and scroll messages for a bit, to avoid
4419 sending such events to Emacs faster than it can process them.
4420 If we get more events before the timer from the first message
4421 expires, we just replace the first message. */
4422
4423 if (saved_mouse_move_msg.msg.hwnd == 0)
4424 mouse_move_timer =
4425 SetTimer (hwnd, MOUSE_MOVE_ID,
4426 w32_mouse_move_interval, NULL);
4427
4428 /* Hold onto message for now. */
4429 saved_mouse_move_msg.msg.hwnd = hwnd;
4430 saved_mouse_move_msg.msg.message = msg;
4431 saved_mouse_move_msg.msg.wParam = wParam;
4432 saved_mouse_move_msg.msg.lParam = lParam;
4433 saved_mouse_move_msg.msg.time = GetMessageTime ();
4434 saved_mouse_move_msg.dwModifiers = w32_get_modifiers ();
4435
4436 return 0;
4437
4438 case WM_MOUSEWHEEL:
4439 case WM_DROPFILES:
4440 wmsg.dwModifiers = w32_get_modifiers ();
4441 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4442 signal_user_input ();
4443 return 0;
4444
4445 case WM_APPCOMMAND:
4446 if (w32_pass_multimedia_buttons_to_system)
4447 goto dflt;
4448 /* Otherwise, pass to lisp, the same way we do with mousehwheel. */
4449 case WM_MOUSEHWHEEL:
4450 wmsg.dwModifiers = w32_get_modifiers ();
4451 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4452 signal_user_input ();
4453 /* Non-zero must be returned when WM_MOUSEHWHEEL messages are
4454 handled, to prevent the system trying to handle it by faking
4455 scroll bar events. */
4456 return 1;
4457
4458 case WM_TIMER:
4459 /* Flush out saved messages if necessary. */
4460 if (wParam == mouse_button_timer)
4461 {
4462 if (saved_mouse_button_msg.msg.hwnd)
4463 {
4464 post_msg (&saved_mouse_button_msg);
4465 signal_user_input ();
4466 saved_mouse_button_msg.msg.hwnd = 0;
4467 }
4468 KillTimer (hwnd, mouse_button_timer);
4469 mouse_button_timer = 0;
4470 }
4471 else if (wParam == mouse_move_timer)
4472 {
4473 if (saved_mouse_move_msg.msg.hwnd)
4474 {
4475 post_msg (&saved_mouse_move_msg);
4476 saved_mouse_move_msg.msg.hwnd = 0;
4477 }
4478 KillTimer (hwnd, mouse_move_timer);
4479 mouse_move_timer = 0;
4480 }
4481 else if (wParam == menu_free_timer)
4482 {
4483 KillTimer (hwnd, menu_free_timer);
4484 menu_free_timer = 0;
4485 f = x_window_to_frame (dpyinfo, hwnd);
4486 /* If a popup menu is active, don't wipe its strings. */
4487 if (menubar_in_use
4488 && current_popup_menu == NULL)
4489 {
4490 /* Free memory used by owner-drawn and help-echo strings. */
4491 w32_free_menu_strings (hwnd);
4492 if (f)
4493 f->output_data.w32->menubar_active = 0;
4494 menubar_in_use = 0;
4495 }
4496 }
4497 return 0;
4498
4499 case WM_NCACTIVATE:
4500 /* Windows doesn't send us focus messages when putting up and
4501 taking down a system popup dialog as for Ctrl-Alt-Del on Windows 95.
4502 The only indication we get that something happened is receiving
4503 this message afterwards. So this is a good time to reset our
4504 keyboard modifiers' state. */
4505 reset_modifiers ();
4506 goto dflt;
4507
4508 case WM_INITMENU:
4509 button_state = 0;
4510 ReleaseCapture ();
4511 /* We must ensure menu bar is fully constructed and up to date
4512 before allowing user interaction with it. To achieve this
4513 we send this message to the lisp thread and wait for a
4514 reply (whose value is not actually needed) to indicate that
4515 the menu bar is now ready for use, so we can now return.
4516
4517 To remain responsive in the meantime, we enter a nested message
4518 loop that can process all other messages.
4519
4520 However, we skip all this if the message results from calling
4521 TrackPopupMenu - in fact, we must NOT attempt to send the lisp
4522 thread a message because it is blocked on us at this point. We
4523 set menubar_active before calling TrackPopupMenu to indicate
4524 this (there is no possibility of confusion with real menubar
4525 being active). */
4526
4527 f = x_window_to_frame (dpyinfo, hwnd);
4528 if (f
4529 && (f->output_data.w32->menubar_active
4530 /* We can receive this message even in the absence of a
4531 menubar (ie. when the system menu is activated) - in this
4532 case we do NOT want to forward the message, otherwise it
4533 will cause the menubar to suddenly appear when the user
4534 had requested it to be turned off! */
4535 || f->output_data.w32->menubar_widget == NULL))
4536 return 0;
4537
4538 {
4539 deferred_msg msg_buf;
4540
4541 /* Detect if message has already been deferred; in this case
4542 we cannot return any sensible value to ignore this. */
4543 if (find_deferred_msg (hwnd, msg) != NULL)
4544 emacs_abort ();
4545
4546 menubar_in_use = 1;
4547
4548 return send_deferred_msg (&msg_buf, hwnd, msg, wParam, lParam);
4549 }
4550
4551 case WM_EXITMENULOOP:
4552 f = x_window_to_frame (dpyinfo, hwnd);
4553
4554 /* If a menu is still active, check again after a short delay,
4555 since Windows often (always?) sends the WM_EXITMENULOOP
4556 before the corresponding WM_COMMAND message.
4557 Don't do this if a popup menu is active, since it is only
4558 menubar menus that require cleaning up in this way.
4559 */
4560 if (f && menubar_in_use && current_popup_menu == NULL)
4561 menu_free_timer = SetTimer (hwnd, MENU_FREE_ID, MENU_FREE_DELAY, NULL);
4562
4563 /* If hourglass cursor should be displayed, display it now. */
4564 if (f && f->output_data.w32->hourglass_p)
4565 SetCursor (f->output_data.w32->hourglass_cursor);
4566
4567 goto dflt;
4568
4569 case WM_MENUSELECT:
4570 /* Direct handling of help_echo in menus. Should be safe now
4571 that we generate the help_echo by placing a help event in the
4572 keyboard buffer. */
4573 {
4574 HMENU menu = (HMENU) lParam;
4575 UINT menu_item = (UINT) LOWORD (wParam);
4576 UINT flags = (UINT) HIWORD (wParam);
4577
4578 w32_menu_display_help (hwnd, menu, menu_item, flags);
4579 }
4580 return 0;
4581
4582 case WM_MEASUREITEM:
4583 f = x_window_to_frame (dpyinfo, hwnd);
4584 if (f)
4585 {
4586 MEASUREITEMSTRUCT * pMis = (MEASUREITEMSTRUCT *) lParam;
4587
4588 if (pMis->CtlType == ODT_MENU)
4589 {
4590 /* Work out dimensions for popup menu titles. */
4591 char * title = (char *) pMis->itemData;
4592 HDC hdc = GetDC (hwnd);
4593 HFONT menu_font = GetCurrentObject (hdc, OBJ_FONT);
4594 LOGFONT menu_logfont;
4595 HFONT old_font;
4596 SIZE size;
4597
4598 GetObject (menu_font, sizeof (menu_logfont), &menu_logfont);
4599 menu_logfont.lfWeight = FW_BOLD;
4600 menu_font = CreateFontIndirect (&menu_logfont);
4601 old_font = SelectObject (hdc, menu_font);
4602
4603 pMis->itemHeight = GetSystemMetrics (SM_CYMENUSIZE);
4604 if (title)
4605 {
4606 if (unicode_append_menu)
4607 GetTextExtentPoint32W (hdc, (WCHAR *) title,
4608 wcslen ((WCHAR *) title),
4609 &size);
4610 else
4611 GetTextExtentPoint32 (hdc, title, strlen (title), &size);
4612
4613 pMis->itemWidth = size.cx;
4614 if (pMis->itemHeight < size.cy)
4615 pMis->itemHeight = size.cy;
4616 }
4617 else
4618 pMis->itemWidth = 0;
4619
4620 SelectObject (hdc, old_font);
4621 DeleteObject (menu_font);
4622 ReleaseDC (hwnd, hdc);
4623 return TRUE;
4624 }
4625 }
4626 return 0;
4627
4628 case WM_DRAWITEM:
4629 f = x_window_to_frame (dpyinfo, hwnd);
4630 if (f)
4631 {
4632 DRAWITEMSTRUCT * pDis = (DRAWITEMSTRUCT *) lParam;
4633
4634 if (pDis->CtlType == ODT_MENU)
4635 {
4636 /* Draw popup menu title. */
4637 char * title = (char *) pDis->itemData;
4638 if (title)
4639 {
4640 HDC hdc = pDis->hDC;
4641 HFONT menu_font = GetCurrentObject (hdc, OBJ_FONT);
4642 LOGFONT menu_logfont;
4643 HFONT old_font;
4644
4645 GetObject (menu_font, sizeof (menu_logfont), &menu_logfont);
4646 menu_logfont.lfWeight = FW_BOLD;
4647 menu_font = CreateFontIndirect (&menu_logfont);
4648 old_font = SelectObject (hdc, menu_font);
4649
4650 /* Always draw title as if not selected. */
4651 if (unicode_append_menu)
4652 ExtTextOutW (hdc,
4653 pDis->rcItem.left
4654 + GetSystemMetrics (SM_CXMENUCHECK),
4655 pDis->rcItem.top,
4656 ETO_OPAQUE, &pDis->rcItem,
4657 (WCHAR *) title,
4658 wcslen ((WCHAR *) title), NULL);
4659 else
4660 ExtTextOut (hdc,
4661 pDis->rcItem.left
4662 + GetSystemMetrics (SM_CXMENUCHECK),
4663 pDis->rcItem.top,
4664 ETO_OPAQUE, &pDis->rcItem,
4665 title, strlen (title), NULL);
4666
4667 SelectObject (hdc, old_font);
4668 DeleteObject (menu_font);
4669 }
4670 return TRUE;
4671 }
4672 }
4673 return 0;
4674
4675 #if 0
4676 /* Still not right - can't distinguish between clicks in the
4677 client area of the frame from clicks forwarded from the scroll
4678 bars - may have to hook WM_NCHITTEST to remember the mouse
4679 position and then check if it is in the client area ourselves. */
4680 case WM_MOUSEACTIVATE:
4681 /* Discard the mouse click that activates a frame, allowing the
4682 user to click anywhere without changing point (or worse!).
4683 Don't eat mouse clicks on scrollbars though!! */
4684 if (LOWORD (lParam) == HTCLIENT )
4685 return MA_ACTIVATEANDEAT;
4686 goto dflt;
4687 #endif
4688
4689 case WM_MOUSELEAVE:
4690 /* No longer tracking mouse. */
4691 track_mouse_window = NULL;
4692
4693 case WM_ACTIVATEAPP:
4694 case WM_ACTIVATE:
4695 case WM_WINDOWPOSCHANGED:
4696 case WM_SHOWWINDOW:
4697 /* Inform lisp thread that a frame might have just been obscured
4698 or exposed, so should recheck visibility of all frames. */
4699 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4700 goto dflt;
4701
4702 case WM_SETFOCUS:
4703 dpyinfo->faked_key = 0;
4704 reset_modifiers ();
4705 if (!w32_kbdhook_active)
4706 register_hot_keys (hwnd);
4707 goto command;
4708 case WM_KILLFOCUS:
4709 if (!w32_kbdhook_active)
4710 unregister_hot_keys (hwnd);
4711 button_state = 0;
4712 ReleaseCapture ();
4713 /* Relinquish the system caret. */
4714 if (w32_system_caret_hwnd)
4715 {
4716 w32_visible_system_caret_hwnd = NULL;
4717 w32_system_caret_hwnd = NULL;
4718 DestroyCaret ();
4719 }
4720 goto command;
4721 case WM_COMMAND:
4722 menubar_in_use = 0;
4723 f = x_window_to_frame (dpyinfo, hwnd);
4724 if (f && HIWORD (wParam) == 0)
4725 {
4726 if (menu_free_timer)
4727 {
4728 KillTimer (hwnd, menu_free_timer);
4729 menu_free_timer = 0;
4730 }
4731 }
4732 case WM_MOVE:
4733 case WM_SIZE:
4734 command:
4735 wmsg.dwModifiers = w32_get_modifiers ();
4736 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4737 goto dflt;
4738
4739 #ifdef WINDOWSNT
4740 case WM_CREATE:
4741 setup_w32_kbdhook ();
4742 goto dflt;
4743 #endif
4744
4745 case WM_DESTROY:
4746 #ifdef WINDOWSNT
4747 remove_w32_kbdhook ();
4748 #endif
4749 CoUninitialize ();
4750 return 0;
4751
4752 case WM_WTSSESSION_CHANGE:
4753 if (wParam == WTS_SESSION_LOCK)
4754 reset_w32_kbdhook_state ();
4755 goto dflt;
4756
4757 case WM_CLOSE:
4758 wmsg.dwModifiers = w32_get_modifiers ();
4759 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4760 return 0;
4761
4762 case WM_WINDOWPOSCHANGING:
4763 /* Don't restrict the sizing of any kind of frames. If the window
4764 manager doesn't, there's no reason to do it ourselves. */
4765 return 0;
4766
4767 case WM_GETMINMAXINFO:
4768 /* Hack to allow resizing the Emacs frame above the screen size.
4769 Note that Windows 9x limits coordinates to 16-bits. */
4770 ((LPMINMAXINFO) lParam)->ptMaxTrackSize.x = 32767;
4771 ((LPMINMAXINFO) lParam)->ptMaxTrackSize.y = 32767;
4772 return 0;
4773
4774 case WM_SETCURSOR:
4775 if (LOWORD (lParam) == HTCLIENT)
4776 {
4777 f = x_window_to_frame (dpyinfo, hwnd);
4778 if (f)
4779 {
4780 if (f->output_data.w32->hourglass_p
4781 && !menubar_in_use && !current_popup_menu)
4782 SetCursor (f->output_data.w32->hourglass_cursor);
4783 else if (f->pointer_invisible)
4784 SetCursor (NULL);
4785 else
4786 SetCursor (f->output_data.w32->current_cursor);
4787 }
4788
4789 return 0;
4790 }
4791 goto dflt;
4792
4793 case WM_EMACS_SETCURSOR:
4794 {
4795 Cursor cursor = (Cursor) wParam;
4796 f = x_window_to_frame (dpyinfo, hwnd);
4797 if (f && cursor)
4798 {
4799 f->output_data.w32->current_cursor = cursor;
4800 /* Don't change the cursor while menu-bar menu is in use. */
4801 if (!f->output_data.w32->menubar_active
4802 && !f->output_data.w32->hourglass_p)
4803 {
4804 if (f->pointer_invisible)
4805 SetCursor (NULL);
4806 else
4807 SetCursor (cursor);
4808 }
4809 }
4810 return 0;
4811 }
4812
4813 case WM_EMACS_SHOWCURSOR:
4814 {
4815 ShowCursor ((BOOL) wParam);
4816
4817 return 0;
4818 }
4819
4820 case WM_EMACS_CREATEVSCROLLBAR:
4821 return (LRESULT) w32_createvscrollbar ((struct frame *) wParam,
4822 (struct scroll_bar *) lParam);
4823
4824 case WM_EMACS_CREATEHSCROLLBAR:
4825 return (LRESULT) w32_createhscrollbar ((struct frame *) wParam,
4826 (struct scroll_bar *) lParam);
4827
4828 case WM_EMACS_SHOWWINDOW:
4829 return ShowWindow ((HWND) wParam, (WPARAM) lParam);
4830
4831 case WM_EMACS_BRINGTOTOP:
4832 case WM_EMACS_SETFOREGROUND:
4833 {
4834 HWND foreground_window;
4835 DWORD foreground_thread, retval;
4836
4837 /* On NT 5.0, and apparently Windows 98, it is necessary to
4838 attach to the thread that currently has focus in order to
4839 pull the focus away from it. */
4840 foreground_window = GetForegroundWindow ();
4841 foreground_thread = GetWindowThreadProcessId (foreground_window, NULL);
4842 if (!foreground_window
4843 || foreground_thread == GetCurrentThreadId ()
4844 || !AttachThreadInput (GetCurrentThreadId (),
4845 foreground_thread, TRUE))
4846 foreground_thread = 0;
4847
4848 retval = SetForegroundWindow ((HWND) wParam);
4849 if (msg == WM_EMACS_BRINGTOTOP)
4850 retval = BringWindowToTop ((HWND) wParam);
4851
4852 /* Detach from the previous foreground thread. */
4853 if (foreground_thread)
4854 AttachThreadInput (GetCurrentThreadId (),
4855 foreground_thread, FALSE);
4856
4857 return retval;
4858 }
4859
4860 case WM_EMACS_SETWINDOWPOS:
4861 {
4862 WINDOWPOS * pos = (WINDOWPOS *) wParam;
4863 return SetWindowPos (hwnd, pos->hwndInsertAfter,
4864 pos->x, pos->y, pos->cx, pos->cy, pos->flags);
4865 }
4866
4867 case WM_EMACS_DESTROYWINDOW:
4868 DragAcceptFiles ((HWND) wParam, FALSE);
4869 return DestroyWindow ((HWND) wParam);
4870
4871 case WM_EMACS_HIDE_CARET:
4872 return HideCaret (hwnd);
4873
4874 case WM_EMACS_SHOW_CARET:
4875 return ShowCaret (hwnd);
4876
4877 case WM_EMACS_DESTROY_CARET:
4878 w32_system_caret_hwnd = NULL;
4879 w32_visible_system_caret_hwnd = NULL;
4880 return DestroyCaret ();
4881
4882 case WM_EMACS_TRACK_CARET:
4883 /* If there is currently no system caret, create one. */
4884 if (w32_system_caret_hwnd == NULL)
4885 {
4886 /* Use the default caret width, and avoid changing it
4887 unnecessarily, as it confuses screen reader software. */
4888 w32_system_caret_hwnd = hwnd;
4889 CreateCaret (hwnd, NULL, 0,
4890 w32_system_caret_height);
4891 }
4892
4893 if (!SetCaretPos (w32_system_caret_x, w32_system_caret_y))
4894 return 0;
4895 /* Ensure visible caret gets turned on when requested. */
4896 else if (w32_use_visible_system_caret
4897 && w32_visible_system_caret_hwnd != hwnd)
4898 {
4899 w32_visible_system_caret_hwnd = hwnd;
4900 return ShowCaret (hwnd);
4901 }
4902 /* Ensure visible caret gets turned off when requested. */
4903 else if (!w32_use_visible_system_caret
4904 && w32_visible_system_caret_hwnd)
4905 {
4906 w32_visible_system_caret_hwnd = NULL;
4907 return HideCaret (hwnd);
4908 }
4909 else
4910 return 1;
4911
4912 case WM_EMACS_TRACKPOPUPMENU:
4913 {
4914 UINT flags;
4915 POINT *pos;
4916 int retval;
4917 pos = (POINT *)lParam;
4918 flags = TPM_CENTERALIGN;
4919 if (button_state & LMOUSE)
4920 flags |= TPM_LEFTBUTTON;
4921 else if (button_state & RMOUSE)
4922 flags |= TPM_RIGHTBUTTON;
4923
4924 /* Remember we did a SetCapture on the initial mouse down event,
4925 so for safety, we make sure the capture is canceled now. */
4926 ReleaseCapture ();
4927 button_state = 0;
4928
4929 /* Use menubar_active to indicate that WM_INITMENU is from
4930 TrackPopupMenu below, and should be ignored. */
4931 f = x_window_to_frame (dpyinfo, hwnd);
4932 if (f)
4933 f->output_data.w32->menubar_active = 1;
4934
4935 if (TrackPopupMenu ((HMENU)wParam, flags, pos->x, pos->y,
4936 0, hwnd, NULL))
4937 {
4938 MSG amsg;
4939 /* Eat any mouse messages during popupmenu */
4940 while (PeekMessage (&amsg, hwnd, WM_MOUSEFIRST, WM_MOUSELAST,
4941 PM_REMOVE));
4942 /* Get the menu selection, if any */
4943 if (PeekMessage (&amsg, hwnd, WM_COMMAND, WM_COMMAND, PM_REMOVE))
4944 {
4945 retval = LOWORD (amsg.wParam);
4946 }
4947 else
4948 {
4949 retval = 0;
4950 }
4951 }
4952 else
4953 {
4954 retval = -1;
4955 }
4956
4957 return retval;
4958 }
4959 case WM_EMACS_FILENOTIFY:
4960 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4961 return 1;
4962
4963 default:
4964 /* Check for messages registered at runtime. */
4965 if (msg == msh_mousewheel)
4966 {
4967 wmsg.dwModifiers = w32_get_modifiers ();
4968 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4969 signal_user_input ();
4970 return 0;
4971 }
4972
4973 dflt:
4974 return (w32_unicode_gui ? DefWindowProcW : DefWindowProcA) (hwnd, msg, wParam, lParam);
4975 }
4976
4977 /* The most common default return code for handled messages is 0. */
4978 return 0;
4979 }
4980
4981 static void
4982 my_create_window (struct frame * f)
4983 {
4984 MSG msg;
4985 static int coords[2];
4986 Lisp_Object left, top;
4987 struct w32_display_info *dpyinfo = &one_w32_display_info;
4988
4989 /* When called with RES_TYPE_NUMBER, x_get_arg will return zero for
4990 anything that is not a number and is not Qunbound. */
4991 left = x_get_arg (dpyinfo, Qnil, Qleft, "left", "Left", RES_TYPE_NUMBER);
4992 top = x_get_arg (dpyinfo, Qnil, Qtop, "top", "Top", RES_TYPE_NUMBER);
4993 if (EQ (left, Qunbound))
4994 coords[0] = CW_USEDEFAULT;
4995 else
4996 coords[0] = XINT (left);
4997 if (EQ (top, Qunbound))
4998 coords[1] = CW_USEDEFAULT;
4999 else
5000 coords[1] = XINT (top);
5001
5002 if (!PostThreadMessage (dwWindowsThreadId, WM_EMACS_CREATEWINDOW,
5003 (WPARAM)f, (LPARAM)coords))
5004 emacs_abort ();
5005 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
5006 }
5007
5008
5009 /* Create a tooltip window. Unlike my_create_window, we do not do this
5010 indirectly via the Window thread, as we do not need to process Window
5011 messages for the tooltip. Creating tooltips indirectly also creates
5012 deadlocks when tooltips are created for menu items. */
5013 static void
5014 my_create_tip_window (struct frame *f)
5015 {
5016 RECT rect;
5017
5018 rect.left = rect.top = 0;
5019 rect.right = FRAME_PIXEL_WIDTH (f);
5020 rect.bottom = FRAME_PIXEL_HEIGHT (f);
5021
5022 AdjustWindowRect (&rect, f->output_data.w32->dwStyle, false);
5023
5024 tip_window = FRAME_W32_WINDOW (f)
5025 = CreateWindow (EMACS_CLASS,
5026 f->namebuf,
5027 f->output_data.w32->dwStyle,
5028 f->left_pos,
5029 f->top_pos,
5030 rect.right - rect.left,
5031 rect.bottom - rect.top,
5032 FRAME_W32_WINDOW (SELECTED_FRAME ()), /* owner */
5033 NULL,
5034 hinst,
5035 NULL);
5036
5037 if (tip_window)
5038 {
5039 SetWindowLong (tip_window, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
5040 SetWindowLong (tip_window, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
5041 SetWindowLong (tip_window, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
5042 SetWindowLong (tip_window, WND_BACKGROUND_INDEX, FRAME_BACKGROUND_PIXEL (f));
5043
5044 /* Tip frames have no scrollbars. */
5045 SetWindowLong (tip_window, WND_VSCROLLBAR_INDEX, 0);
5046 SetWindowLong (tip_window, WND_HSCROLLBAR_INDEX, 0);
5047
5048 /* Do this to discard the default setting specified by our parent. */
5049 ShowWindow (tip_window, SW_HIDE);
5050 }
5051 }
5052
5053
5054 /* Create and set up the w32 window for frame F. */
5055
5056 static void
5057 w32_window (struct frame *f, long window_prompting, bool minibuffer_only)
5058 {
5059 block_input ();
5060
5061 /* Use the resource name as the top-level window name
5062 for looking up resources. Make a non-Lisp copy
5063 for the window manager, so GC relocation won't bother it.
5064
5065 Elsewhere we specify the window name for the window manager. */
5066 f->namebuf = xlispstrdup (Vx_resource_name);
5067
5068 my_create_window (f);
5069
5070 validate_x_resource_name ();
5071
5072 /* x_set_name normally ignores requests to set the name if the
5073 requested name is the same as the current name. This is the one
5074 place where that assumption isn't correct; f->name is set, but
5075 the server hasn't been told. */
5076 {
5077 Lisp_Object name;
5078 int explicit = f->explicit_name;
5079
5080 f->explicit_name = 0;
5081 name = f->name;
5082 fset_name (f, Qnil);
5083 x_set_name (f, name, explicit);
5084 }
5085
5086 unblock_input ();
5087
5088 if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
5089 initialize_frame_menubar (f);
5090
5091 if (FRAME_W32_WINDOW (f) == 0)
5092 error ("Unable to create window");
5093 }
5094
5095 /* Handle the icon stuff for this window. Perhaps later we might
5096 want an x_set_icon_position which can be called interactively as
5097 well. */
5098
5099 static void
5100 x_icon (struct frame *f, Lisp_Object parms)
5101 {
5102 Lisp_Object icon_x, icon_y;
5103 struct w32_display_info *dpyinfo = &one_w32_display_info;
5104
5105 /* Set the position of the icon. Note that Windows 95 groups all
5106 icons in the tray. */
5107 icon_x = x_get_arg (dpyinfo, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
5108 icon_y = x_get_arg (dpyinfo, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
5109 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
5110 {
5111 CHECK_NUMBER (icon_x);
5112 CHECK_NUMBER (icon_y);
5113 }
5114 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
5115 error ("Both left and top icon corners of icon must be specified");
5116
5117 block_input ();
5118
5119 #if 0 /* TODO */
5120 /* Start up iconic or window? */
5121 x_wm_set_window_state
5122 (f, (EQ (x_get_arg (dpyinfo, parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL), Qicon)
5123 ? IconicState
5124 : NormalState));
5125
5126 x_text_icon (f, SSDATA ((!NILP (f->icon_name)
5127 ? f->icon_name
5128 : f->name)));
5129 #endif
5130
5131 unblock_input ();
5132 }
5133
5134
5135 static void
5136 x_make_gc (struct frame *f)
5137 {
5138 XGCValues gc_values;
5139
5140 block_input ();
5141
5142 /* Create the GC's of this frame.
5143 Note that many default values are used. */
5144
5145 /* Normal video */
5146 gc_values.font = FRAME_FONT (f);
5147
5148 /* Cursor has cursor-color background, background-color foreground. */
5149 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
5150 gc_values.background = f->output_data.w32->cursor_pixel;
5151 f->output_data.w32->cursor_gc
5152 = XCreateGC (NULL, FRAME_W32_WINDOW (f),
5153 (GCFont | GCForeground | GCBackground),
5154 &gc_values);
5155
5156 /* Reliefs. */
5157 f->output_data.w32->white_relief.gc = 0;
5158 f->output_data.w32->black_relief.gc = 0;
5159
5160 unblock_input ();
5161 }
5162
5163
5164 /* Handler for signals raised during x_create_frame and
5165 x_create_tip_frame. FRAME is the frame which is partially
5166 constructed. */
5167
5168 static Lisp_Object
5169 unwind_create_frame (Lisp_Object frame)
5170 {
5171 struct frame *f = XFRAME (frame);
5172
5173 /* If frame is ``official'', nothing to do. */
5174 if (NILP (Fmemq (frame, Vframe_list)))
5175 {
5176 #ifdef GLYPH_DEBUG
5177 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
5178
5179 /* If the frame's image cache refcount is still the same as our
5180 private shadow variable, it means we are unwinding a frame
5181 for which we didn't yet call init_frame_faces, where the
5182 refcount is incremented. Therefore, we increment it here, so
5183 that free_frame_faces, called in x_free_frame_resources
5184 below, will not mistakenly decrement the counter that was not
5185 incremented yet to account for this new frame. */
5186 if (FRAME_IMAGE_CACHE (f) != NULL
5187 && FRAME_IMAGE_CACHE (f)->refcount == image_cache_refcount)
5188 FRAME_IMAGE_CACHE (f)->refcount++;
5189 #endif
5190
5191 x_free_frame_resources (f);
5192 free_glyphs (f);
5193
5194 #ifdef GLYPH_DEBUG
5195 /* Check that reference counts are indeed correct. */
5196 eassert (dpyinfo->reference_count == dpyinfo_refcount);
5197 eassert ((dpyinfo->terminal->image_cache == NULL
5198 && image_cache_refcount == 0)
5199 || (dpyinfo->terminal->image_cache != NULL
5200 && dpyinfo->terminal->image_cache->refcount == image_cache_refcount));
5201 #endif
5202 return Qt;
5203 }
5204
5205 return Qnil;
5206 }
5207
5208 static void
5209 do_unwind_create_frame (Lisp_Object frame)
5210 {
5211 unwind_create_frame (frame);
5212 }
5213
5214 static void
5215 x_default_font_parameter (struct frame *f, Lisp_Object parms)
5216 {
5217 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
5218 Lisp_Object font_param = x_get_arg (dpyinfo, parms, Qfont, NULL, NULL,
5219 RES_TYPE_STRING);
5220 Lisp_Object font;
5221 if (EQ (font_param, Qunbound))
5222 font_param = Qnil;
5223 font = !NILP (font_param) ? font_param
5224 : x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
5225
5226 if (!STRINGP (font))
5227 {
5228 int i;
5229 static char *names[]
5230 = { "Courier New-10",
5231 "-*-Courier-normal-r-*-*-13-*-*-*-c-*-iso8859-1",
5232 "-*-Fixedsys-normal-r-*-*-12-*-*-*-c-*-iso8859-1",
5233 "Fixedsys",
5234 NULL };
5235
5236 for (i = 0; names[i]; i++)
5237 {
5238 font = font_open_by_name (f, build_unibyte_string (names[i]));
5239 if (! NILP (font))
5240 break;
5241 }
5242 if (NILP (font))
5243 error ("No suitable font was found");
5244 }
5245 else if (!NILP (font_param))
5246 {
5247 /* Remember the explicit font parameter, so we can re-apply it after
5248 we've applied the `default' face settings. */
5249 x_set_frame_parameters (f, Fcons (Fcons (Qfont_parameter, font_param),
5250 Qnil));
5251 }
5252 x_default_parameter (f, parms, Qfont, font, "font", "Font", RES_TYPE_STRING);
5253 }
5254
5255 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
5256 1, 1, 0,
5257 doc: /* Make a new window, which is called a \"frame\" in Emacs terms.
5258 Return an Emacs frame object.
5259 PARAMETERS is an alist of frame parameters.
5260 If the parameters specify that the frame should not have a minibuffer,
5261 and do not specify a specific minibuffer window to use,
5262 then `default-minibuffer-frame' must be a frame whose minibuffer can
5263 be shared by the new frame.
5264
5265 This function is an internal primitive--use `make-frame' instead. */)
5266 (Lisp_Object parameters)
5267 {
5268 struct frame *f;
5269 Lisp_Object frame, tem;
5270 Lisp_Object name;
5271 bool minibuffer_only = false;
5272 long window_prompting = 0;
5273 ptrdiff_t count = SPECPDL_INDEX ();
5274 Lisp_Object display;
5275 struct w32_display_info *dpyinfo = NULL;
5276 Lisp_Object parent;
5277 struct kboard *kb;
5278 int x_width = 0, x_height = 0;
5279
5280 if (!FRAME_W32_P (SELECTED_FRAME ())
5281 && !FRAME_INITIAL_P (SELECTED_FRAME ()))
5282 error ("Cannot create a GUI frame in a -nw session");
5283
5284 /* Make copy of frame parameters because the original is in pure
5285 storage now. */
5286 parameters = Fcopy_alist (parameters);
5287
5288 /* Use this general default value to start with
5289 until we know if this frame has a specified name. */
5290 Vx_resource_name = Vinvocation_name;
5291
5292 display = x_get_arg (dpyinfo, parameters, Qterminal, 0, 0, RES_TYPE_NUMBER);
5293 if (EQ (display, Qunbound))
5294 display = x_get_arg (dpyinfo, parameters, Qdisplay, 0, 0, RES_TYPE_STRING);
5295 if (EQ (display, Qunbound))
5296 display = Qnil;
5297 dpyinfo = check_x_display_info (display);
5298 kb = dpyinfo->terminal->kboard;
5299
5300 if (!dpyinfo->terminal->name)
5301 error ("Terminal is not live, can't create new frames on it");
5302
5303 name = x_get_arg (dpyinfo, parameters, Qname, "name", "Name", RES_TYPE_STRING);
5304 if (!STRINGP (name)
5305 && ! EQ (name, Qunbound)
5306 && ! NILP (name))
5307 error ("Invalid frame name--not a string or nil");
5308
5309 if (STRINGP (name))
5310 Vx_resource_name = name;
5311
5312 /* See if parent window is specified. */
5313 parent = x_get_arg (dpyinfo, parameters, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
5314 if (EQ (parent, Qunbound))
5315 parent = Qnil;
5316 if (! NILP (parent))
5317 CHECK_NUMBER (parent);
5318
5319 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
5320 /* No need to protect DISPLAY because that's not used after passing
5321 it to make_frame_without_minibuffer. */
5322 frame = Qnil;
5323 tem = x_get_arg (dpyinfo, parameters, Qminibuffer, "minibuffer", "Minibuffer",
5324 RES_TYPE_SYMBOL);
5325 if (EQ (tem, Qnone) || NILP (tem))
5326 f = make_frame_without_minibuffer (Qnil, kb, display);
5327 else if (EQ (tem, Qonly))
5328 {
5329 f = make_minibuffer_frame ();
5330 minibuffer_only = true;
5331 }
5332 else if (WINDOWP (tem))
5333 f = make_frame_without_minibuffer (tem, kb, display);
5334 else
5335 f = make_frame (true);
5336
5337 XSETFRAME (frame, f);
5338
5339 /* By default, make scrollbars the system standard width and height. */
5340 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = GetSystemMetrics (SM_CXVSCROLL);
5341 FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = GetSystemMetrics (SM_CXHSCROLL);
5342
5343 f->terminal = dpyinfo->terminal;
5344
5345 f->output_method = output_w32;
5346 f->output_data.w32 = xzalloc (sizeof (struct w32_output));
5347 FRAME_FONTSET (f) = -1;
5348
5349 fset_icon_name
5350 (f, x_get_arg (dpyinfo, parameters, Qicon_name, "iconName", "Title",
5351 RES_TYPE_STRING));
5352 if (! STRINGP (f->icon_name))
5353 fset_icon_name (f, Qnil);
5354
5355 /* FRAME_DISPLAY_INFO (f) = dpyinfo; */
5356
5357 /* With FRAME_DISPLAY_INFO set up, this unwind-protect is safe. */
5358 record_unwind_protect (do_unwind_create_frame, frame);
5359
5360 #ifdef GLYPH_DEBUG
5361 image_cache_refcount =
5362 FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
5363 dpyinfo_refcount = dpyinfo->reference_count;
5364 #endif /* GLYPH_DEBUG */
5365
5366 /* Specify the parent under which to make this window. */
5367 if (!NILP (parent))
5368 {
5369 /* Cast to UINT_PTR shuts up compiler warnings about cast to
5370 pointer from integer of different size. */
5371 f->output_data.w32->parent_desc = (Window) (UINT_PTR) XFASTINT (parent);
5372 f->output_data.w32->explicit_parent = true;
5373 }
5374 else
5375 {
5376 f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
5377 f->output_data.w32->explicit_parent = false;
5378 }
5379
5380 /* Set the name; the functions to which we pass f expect the name to
5381 be set. */
5382 if (EQ (name, Qunbound) || NILP (name))
5383 {
5384 fset_name (f, build_string (dpyinfo->w32_id_name));
5385 f->explicit_name = false;
5386 }
5387 else
5388 {
5389 fset_name (f, name);
5390 f->explicit_name = true;
5391 /* Use the frame's title when getting resources for this frame. */
5392 specbind (Qx_resource_name, name);
5393 }
5394
5395 if (uniscribe_available)
5396 register_font_driver (&uniscribe_font_driver, f);
5397 register_font_driver (&w32font_driver, f);
5398
5399 x_default_parameter (f, parameters, Qfont_backend, Qnil,
5400 "fontBackend", "FontBackend", RES_TYPE_STRING);
5401
5402 /* Extract the window parameters from the supplied values
5403 that are needed to determine window geometry. */
5404 x_default_font_parameter (f, parameters);
5405
5406 x_default_parameter (f, parameters, Qborder_width, make_number (2),
5407 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
5408
5409 /* We recognize either internalBorderWidth or internalBorder
5410 (which is what xterm calls it). */
5411 if (NILP (Fassq (Qinternal_border_width, parameters)))
5412 {
5413 Lisp_Object value;
5414
5415 value = x_get_arg (dpyinfo, parameters, Qinternal_border_width,
5416 "internalBorder", "InternalBorder", RES_TYPE_NUMBER);
5417 if (! EQ (value, Qunbound))
5418 parameters = Fcons (Fcons (Qinternal_border_width, value),
5419 parameters);
5420 }
5421 /* Default internalBorderWidth to 0 on Windows to match other programs. */
5422 x_default_parameter (f, parameters, Qinternal_border_width, make_number (0),
5423 "internalBorderWidth", "InternalBorder", RES_TYPE_NUMBER);
5424 x_default_parameter (f, parameters, Qright_divider_width, make_number (0),
5425 NULL, NULL, RES_TYPE_NUMBER);
5426 x_default_parameter (f, parameters, Qbottom_divider_width, make_number (0),
5427 NULL, NULL, RES_TYPE_NUMBER);
5428 x_default_parameter (f, parameters, Qvertical_scroll_bars, Qright,
5429 "verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL);
5430 x_default_parameter (f, parameters, Qhorizontal_scroll_bars, Qnil,
5431 "horizontalScrollBars", "ScrollBars", RES_TYPE_SYMBOL);
5432
5433 /* Also do the stuff which must be set before the window exists. */
5434 x_default_parameter (f, parameters, Qforeground_color, build_string ("black"),
5435 "foreground", "Foreground", RES_TYPE_STRING);
5436 x_default_parameter (f, parameters, Qbackground_color, build_string ("white"),
5437 "background", "Background", RES_TYPE_STRING);
5438 x_default_parameter (f, parameters, Qmouse_color, build_string ("black"),
5439 "pointerColor", "Foreground", RES_TYPE_STRING);
5440 x_default_parameter (f, parameters, Qborder_color, build_string ("black"),
5441 "borderColor", "BorderColor", RES_TYPE_STRING);
5442 x_default_parameter (f, parameters, Qscreen_gamma, Qnil,
5443 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
5444 x_default_parameter (f, parameters, Qline_spacing, Qnil,
5445 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
5446 x_default_parameter (f, parameters, Qleft_fringe, Qnil,
5447 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
5448 x_default_parameter (f, parameters, Qright_fringe, Qnil,
5449 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
5450 /* Process alpha here (Bug#16619). */
5451 x_default_parameter (f, parameters, Qalpha, Qnil,
5452 "alpha", "Alpha", RES_TYPE_NUMBER);
5453
5454 /* Init faces first since we need the frame's column width/line
5455 height in various occasions. */
5456 init_frame_faces (f);
5457
5458 /* The following call of change_frame_size is needed since otherwise
5459 x_set_tool_bar_lines will already work with the character sizes
5460 installed by init_frame_faces while the frame's pixel size is
5461 still calculated from a character size of 1 and we subsequently
5462 hit the (height >= 0) assertion in window_box_height.
5463
5464 The non-pixelwise code apparently worked around this because it
5465 had one frame line vs one toolbar line which left us with a zero
5466 root window height which was obviously wrong as well ... */
5467 adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
5468 FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 5, true,
5469 Qx_create_frame_1);
5470
5471 /* The X resources controlling the menu-bar and tool-bar are
5472 processed specially at startup, and reflected in the mode
5473 variables; ignore them here. */
5474 x_default_parameter (f, parameters, Qmenu_bar_lines,
5475 NILP (Vmenu_bar_mode)
5476 ? make_number (0) : make_number (1),
5477 NULL, NULL, RES_TYPE_NUMBER);
5478 x_default_parameter (f, parameters, Qtool_bar_lines,
5479 NILP (Vtool_bar_mode)
5480 ? make_number (0) : make_number (1),
5481 NULL, NULL, RES_TYPE_NUMBER);
5482
5483 x_default_parameter (f, parameters, Qbuffer_predicate, Qnil,
5484 "bufferPredicate", "BufferPredicate", RES_TYPE_SYMBOL);
5485 x_default_parameter (f, parameters, Qtitle, Qnil,
5486 "title", "Title", RES_TYPE_STRING);
5487
5488 f->output_data.w32->dwStyle = WS_OVERLAPPEDWINDOW;
5489 f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
5490
5491 f->output_data.w32->text_cursor = w32_load_cursor (IDC_IBEAM);
5492 f->output_data.w32->nontext_cursor = w32_load_cursor (IDC_ARROW);
5493 f->output_data.w32->modeline_cursor = w32_load_cursor (IDC_ARROW);
5494 f->output_data.w32->hand_cursor = w32_load_cursor (IDC_HAND);
5495 f->output_data.w32->hourglass_cursor = w32_load_cursor (IDC_WAIT);
5496 f->output_data.w32->horizontal_drag_cursor = w32_load_cursor (IDC_SIZEWE);
5497 f->output_data.w32->vertical_drag_cursor = w32_load_cursor (IDC_SIZENS);
5498
5499 f->output_data.w32->current_cursor = f->output_data.w32->nontext_cursor;
5500
5501 window_prompting = x_figure_window_size (f, parameters, true, &x_width, &x_height);
5502
5503 tem = x_get_arg (dpyinfo, parameters, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
5504 f->no_split = minibuffer_only || EQ (tem, Qt);
5505
5506 w32_window (f, window_prompting, minibuffer_only);
5507 x_icon (f, parameters);
5508
5509 x_make_gc (f);
5510
5511 /* Now consider the frame official. */
5512 f->terminal->reference_count++;
5513 FRAME_DISPLAY_INFO (f)->reference_count++;
5514 Vframe_list = Fcons (frame, Vframe_list);
5515
5516 /* We need to do this after creating the window, so that the
5517 icon-creation functions can say whose icon they're describing. */
5518 x_default_parameter (f, parameters, Qicon_type, Qnil,
5519 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL);
5520
5521 x_default_parameter (f, parameters, Qauto_raise, Qnil,
5522 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
5523 x_default_parameter (f, parameters, Qauto_lower, Qnil,
5524 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
5525 x_default_parameter (f, parameters, Qcursor_type, Qbox,
5526 "cursorType", "CursorType", RES_TYPE_SYMBOL);
5527 x_default_parameter (f, parameters, Qscroll_bar_width, Qnil,
5528 "scrollBarWidth", "ScrollBarWidth", RES_TYPE_NUMBER);
5529 x_default_parameter (f, parameters, Qscroll_bar_height, Qnil,
5530 "scrollBarHeight", "ScrollBarHeight", RES_TYPE_NUMBER);
5531
5532 /* Allow x_set_window_size, now. */
5533 f->can_x_set_window_size = true;
5534
5535 if (x_width > 0)
5536 SET_FRAME_WIDTH (f, x_width);
5537 if (x_height > 0)
5538 SET_FRAME_HEIGHT (f, x_height);
5539
5540 /* Tell the server what size and position, etc, we want, and how
5541 badly we want them. This should be done after we have the menu
5542 bar so that its size can be taken into account. */
5543 block_input ();
5544 x_wm_set_size_hint (f, window_prompting, false);
5545 unblock_input ();
5546
5547 adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 0, true,
5548 Qx_create_frame_2);
5549
5550 /* Process fullscreen parameter here in the hope that normalizing a
5551 fullheight/fullwidth frame will produce the size set by the last
5552 adjust_frame_size call. */
5553 x_default_parameter (f, parameters, Qfullscreen, Qnil,
5554 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
5555
5556 /* Make the window appear on the frame and enable display, unless
5557 the caller says not to. However, with explicit parent, Emacs
5558 cannot control visibility, so don't try. */
5559 if (! f->output_data.w32->explicit_parent)
5560 {
5561 Lisp_Object visibility;
5562
5563 visibility = x_get_arg (dpyinfo, parameters, Qvisibility, 0, 0, RES_TYPE_SYMBOL);
5564 if (EQ (visibility, Qunbound))
5565 visibility = Qt;
5566
5567 if (EQ (visibility, Qicon))
5568 x_iconify_frame (f);
5569 else if (! NILP (visibility))
5570 x_make_frame_visible (f);
5571 else
5572 /* Must have been Qnil. */
5573 ;
5574 }
5575
5576 /* Initialize `default-minibuffer-frame' in case this is the first
5577 frame on this terminal. */
5578 if (FRAME_HAS_MINIBUF_P (f)
5579 && (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
5580 || !FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)))))
5581 kset_default_minibuffer_frame (kb, frame);
5582
5583 /* All remaining specified parameters, which have not been "used"
5584 by x_get_arg and friends, now go in the misc. alist of the frame. */
5585 for (tem = parameters; CONSP (tem); tem = XCDR (tem))
5586 if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
5587 fset_param_alist (f, Fcons (XCAR (tem), f->param_alist));
5588
5589 /* Make sure windows on this frame appear in calls to next-window
5590 and similar functions. */
5591 Vwindow_list = Qnil;
5592
5593 return unbind_to (count, frame);
5594 }
5595
5596 /* FRAME is used only to get a handle on the X display. We don't pass the
5597 display info directly because we're called from frame.c, which doesn't
5598 know about that structure. */
5599 Lisp_Object
5600 x_get_focus_frame (struct frame *frame)
5601 {
5602 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (frame);
5603 Lisp_Object xfocus;
5604 if (! dpyinfo->w32_focus_frame)
5605 return Qnil;
5606
5607 XSETFRAME (xfocus, dpyinfo->w32_focus_frame);
5608 return xfocus;
5609 }
5610
5611 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
5612 doc: /* Internal function called by `color-defined-p', which see.
5613 \(Note that the Nextstep version of this function ignores FRAME.) */)
5614 (Lisp_Object color, Lisp_Object frame)
5615 {
5616 XColor foo;
5617 struct frame *f = decode_window_system_frame (frame);
5618
5619 CHECK_STRING (color);
5620
5621 if (w32_defined_color (f, SSDATA (color), &foo, false))
5622 return Qt;
5623 else
5624 return Qnil;
5625 }
5626
5627 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
5628 doc: /* Internal function called by `color-values', which see. */)
5629 (Lisp_Object color, Lisp_Object frame)
5630 {
5631 XColor foo;
5632 struct frame *f = decode_window_system_frame (frame);
5633
5634 CHECK_STRING (color);
5635
5636 if (w32_defined_color (f, SSDATA (color), &foo, false))
5637 return list3i ((GetRValue (foo.pixel) << 8) | GetRValue (foo.pixel),
5638 (GetGValue (foo.pixel) << 8) | GetGValue (foo.pixel),
5639 (GetBValue (foo.pixel) << 8) | GetBValue (foo.pixel));
5640 else
5641 return Qnil;
5642 }
5643
5644 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
5645 doc: /* Internal function called by `display-color-p', which see. */)
5646 (Lisp_Object display)
5647 {
5648 struct w32_display_info *dpyinfo = check_x_display_info (display);
5649
5650 if ((dpyinfo->n_planes * dpyinfo->n_cbits) <= 2)
5651 return Qnil;
5652
5653 return Qt;
5654 }
5655
5656 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p,
5657 Sx_display_grayscale_p, 0, 1, 0,
5658 doc: /* Return t if DISPLAY supports shades of gray.
5659 Note that color displays do support shades of gray.
5660 The optional argument DISPLAY specifies which display to ask about.
5661 DISPLAY should be either a frame or a display name (a string).
5662 If omitted or nil, that stands for the selected frame's display. */)
5663 (Lisp_Object display)
5664 {
5665 struct w32_display_info *dpyinfo = check_x_display_info (display);
5666
5667 if ((dpyinfo->n_planes * dpyinfo->n_cbits) <= 1)
5668 return Qnil;
5669
5670 return Qt;
5671 }
5672
5673 DEFUN ("x-display-pixel-width", Fx_display_pixel_width,
5674 Sx_display_pixel_width, 0, 1, 0,
5675 doc: /* Return the width in pixels of DISPLAY.
5676 The optional argument DISPLAY specifies which display to ask about.
5677 DISPLAY should be either a frame or a display name (a string).
5678 If omitted or nil, that stands for the selected frame's display.
5679
5680 On \"multi-monitor\" setups this refers to the pixel width for all
5681 physical monitors associated with DISPLAY. To get information for
5682 each physical monitor, use `display-monitor-attributes-list'. */)
5683 (Lisp_Object display)
5684 {
5685 struct w32_display_info *dpyinfo = check_x_display_info (display);
5686
5687 return make_number (x_display_pixel_width (dpyinfo));
5688 }
5689
5690 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
5691 Sx_display_pixel_height, 0, 1, 0,
5692 doc: /* Return the height in pixels of DISPLAY.
5693 The optional argument DISPLAY specifies which display to ask about.
5694 DISPLAY should be either a frame or a display name (a string).
5695 If omitted or nil, that stands for the selected frame's display.
5696
5697 On \"multi-monitor\" setups this refers to the pixel height for all
5698 physical monitors associated with DISPLAY. To get information for
5699 each physical monitor, use `display-monitor-attributes-list'. */)
5700 (Lisp_Object display)
5701 {
5702 struct w32_display_info *dpyinfo = check_x_display_info (display);
5703
5704 return make_number (x_display_pixel_height (dpyinfo));
5705 }
5706
5707 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
5708 0, 1, 0,
5709 doc: /* Return the number of bitplanes of DISPLAY.
5710 The optional argument DISPLAY specifies which display to ask about.
5711 DISPLAY should be either a frame or a display name (a string).
5712 If omitted or nil, that stands for the selected frame's display. */)
5713 (Lisp_Object display)
5714 {
5715 struct w32_display_info *dpyinfo = check_x_display_info (display);
5716
5717 return make_number (dpyinfo->n_planes * dpyinfo->n_cbits);
5718 }
5719
5720 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
5721 0, 1, 0,
5722 doc: /* Return the number of color cells of DISPLAY.
5723 The optional argument DISPLAY specifies which display to ask about.
5724 DISPLAY should be either a frame or a display name (a string).
5725 If omitted or nil, that stands for the selected frame's display. */)
5726 (Lisp_Object display)
5727 {
5728 struct w32_display_info *dpyinfo = check_x_display_info (display);
5729 int cap;
5730
5731 /* Don't use NCOLORS: it returns incorrect results under remote
5732 * desktop. We force 24+ bit depths to 24-bit, both to prevent an
5733 * overflow and because probably is more meaningful on Windows
5734 * anyway. */
5735
5736 cap = 1 << min (dpyinfo->n_planes * dpyinfo->n_cbits, 24);
5737 return make_number (cap);
5738 }
5739
5740 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
5741 Sx_server_max_request_size,
5742 0, 1, 0,
5743 doc: /* Return the maximum request size of the server of DISPLAY.
5744 The optional argument DISPLAY specifies which display to ask about.
5745 DISPLAY should be either a frame or a display name (a string).
5746 If omitted or nil, that stands for the selected frame's display. */)
5747 (Lisp_Object display)
5748 {
5749 return make_number (1);
5750 }
5751
5752 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
5753 doc: /* Return the "vendor ID" string of the GUI software on TERMINAL.
5754
5755 \(Labeling every distributor as a "vendor" embodies the false assumption
5756 that operating systems cannot be developed and distributed noncommercially.)
5757
5758 For GNU and Unix systems, this queries the X server software; for
5759 MS-Windows, this queries the OS.
5760
5761 The optional argument TERMINAL specifies which display to ask about.
5762 TERMINAL should be a terminal object, a frame or a display name (a string).
5763 If omitted or nil, that stands for the selected frame's display. */)
5764 (Lisp_Object terminal)
5765 {
5766 return build_string ("Microsoft Corp.");
5767 }
5768
5769 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
5770 doc: /* Return the version numbers of the GUI software on TERMINAL.
5771 The value is a list of three integers specifying the version of the GUI
5772 software in use.
5773
5774 For GNU and Unix system, the first 2 numbers are the version of the X
5775 Protocol used on TERMINAL and the 3rd number is the distributor-specific
5776 release number. For MS-Windows, the 3 numbers report the version and
5777 the build number of the OS.
5778
5779 See also the function `x-server-vendor'.
5780
5781 The optional argument TERMINAL specifies which display to ask about.
5782 TERMINAL should be a terminal object, a frame or a display name (a string).
5783 If omitted or nil, that stands for the selected frame's display. */)
5784 (Lisp_Object terminal)
5785 {
5786 return list3i (w32_major_version, w32_minor_version, w32_build_number);
5787 }
5788
5789 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
5790 doc: /* Return the number of screens on the server of DISPLAY.
5791 The optional argument DISPLAY specifies which display to ask about.
5792 DISPLAY should be either a frame or a display name (a string).
5793 If omitted or nil, that stands for the selected frame's display. */)
5794 (Lisp_Object display)
5795 {
5796 return make_number (1);
5797 }
5798
5799 DEFUN ("x-display-mm-height", Fx_display_mm_height,
5800 Sx_display_mm_height, 0, 1, 0,
5801 doc: /* Return the height in millimeters of DISPLAY.
5802 The optional argument DISPLAY specifies which display to ask about.
5803 DISPLAY should be either a frame or a display name (a string).
5804 If omitted or nil, that stands for the selected frame's display.
5805
5806 On \"multi-monitor\" setups this refers to the height in millimeters for
5807 all physical monitors associated with DISPLAY. To get information
5808 for each physical monitor, use `display-monitor-attributes-list'. */)
5809 (Lisp_Object display)
5810 {
5811 struct w32_display_info *dpyinfo = check_x_display_info (display);
5812 HDC hdc;
5813 double mm_per_pixel;
5814
5815 hdc = GetDC (NULL);
5816 mm_per_pixel = ((double) GetDeviceCaps (hdc, VERTSIZE)
5817 / GetDeviceCaps (hdc, VERTRES));
5818 ReleaseDC (NULL, hdc);
5819
5820 return make_number (x_display_pixel_height (dpyinfo) * mm_per_pixel + 0.5);
5821 }
5822
5823 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
5824 doc: /* Return the width in millimeters of DISPLAY.
5825 The optional argument DISPLAY specifies which display to ask about.
5826 DISPLAY should be either a frame or a display name (a string).
5827 If omitted or nil, that stands for the selected frame's display.
5828
5829 On \"multi-monitor\" setups this refers to the width in millimeters for
5830 all physical monitors associated with TERMINAL. To get information
5831 for each physical monitor, use `display-monitor-attributes-list'. */)
5832 (Lisp_Object display)
5833 {
5834 struct w32_display_info *dpyinfo = check_x_display_info (display);
5835 HDC hdc;
5836 double mm_per_pixel;
5837
5838 hdc = GetDC (NULL);
5839 mm_per_pixel = ((double) GetDeviceCaps (hdc, HORZSIZE)
5840 / GetDeviceCaps (hdc, HORZRES));
5841 ReleaseDC (NULL, hdc);
5842
5843 return make_number (x_display_pixel_width (dpyinfo) * mm_per_pixel + 0.5);
5844 }
5845
5846 DEFUN ("x-display-backing-store", Fx_display_backing_store,
5847 Sx_display_backing_store, 0, 1, 0,
5848 doc: /* Return an indication of whether DISPLAY does backing store.
5849 The value may be `always', `when-mapped', or `not-useful'.
5850 The optional argument DISPLAY specifies which display to ask about.
5851 DISPLAY should be either a frame or a display name (a string).
5852 If omitted or nil, that stands for the selected frame's display. */)
5853 (Lisp_Object display)
5854 {
5855 return intern ("not-useful");
5856 }
5857
5858 DEFUN ("x-display-visual-class", Fx_display_visual_class,
5859 Sx_display_visual_class, 0, 1, 0,
5860 doc: /* Return the visual class of DISPLAY.
5861 The value is one of the symbols `static-gray', `gray-scale',
5862 `static-color', `pseudo-color', `true-color', or `direct-color'.
5863
5864 The optional argument DISPLAY specifies which display to ask about.
5865 DISPLAY should be either a frame or a display name (a string).
5866 If omitted or nil, that stands for the selected frame's display. */)
5867 (Lisp_Object display)
5868 {
5869 struct w32_display_info *dpyinfo = check_x_display_info (display);
5870 Lisp_Object result = Qnil;
5871
5872 if (dpyinfo->has_palette)
5873 result = intern ("pseudo-color");
5874 else if (dpyinfo->n_planes * dpyinfo->n_cbits == 1)
5875 result = intern ("static-grey");
5876 else if (dpyinfo->n_planes * dpyinfo->n_cbits == 4)
5877 result = intern ("static-color");
5878 else if (dpyinfo->n_planes * dpyinfo->n_cbits > 8)
5879 result = intern ("true-color");
5880
5881 return result;
5882 }
5883
5884 DEFUN ("x-display-save-under", Fx_display_save_under,
5885 Sx_display_save_under, 0, 1, 0,
5886 doc: /* Return t if DISPLAY supports the save-under feature.
5887 The optional argument DISPLAY specifies which display to ask about.
5888 DISPLAY should be either a frame or a display name (a string).
5889 If omitted or nil, that stands for the selected frame's display. */)
5890 (Lisp_Object display)
5891 {
5892 return Qnil;
5893 }
5894
5895 static BOOL CALLBACK ALIGN_STACK
5896 w32_monitor_enum (HMONITOR monitor, HDC hdc, RECT *rcMonitor, LPARAM dwData)
5897 {
5898 Lisp_Object *monitor_list = (Lisp_Object *) dwData;
5899
5900 *monitor_list = Fcons (make_save_ptr (monitor), *monitor_list);
5901
5902 return TRUE;
5903 }
5904
5905 static Lisp_Object
5906 w32_display_monitor_attributes_list (void)
5907 {
5908 Lisp_Object attributes_list = Qnil, primary_monitor_attributes = Qnil;
5909 Lisp_Object monitor_list = Qnil, monitor_frames, rest, frame;
5910 int i, n_monitors;
5911 HMONITOR *monitors;
5912
5913 if (!(enum_display_monitors_fn && get_monitor_info_fn
5914 && monitor_from_window_fn))
5915 return Qnil;
5916
5917 if (!enum_display_monitors_fn (NULL, NULL, w32_monitor_enum,
5918 (LPARAM) &monitor_list)
5919 || NILP (monitor_list))
5920 return Qnil;
5921
5922 n_monitors = 0;
5923 for (rest = monitor_list; CONSP (rest); rest = XCDR (rest))
5924 n_monitors++;
5925
5926 monitors = xmalloc (n_monitors * sizeof (*monitors));
5927 for (i = 0; i < n_monitors; i++)
5928 {
5929 monitors[i] = XSAVE_POINTER (XCAR (monitor_list), 0);
5930 monitor_list = XCDR (monitor_list);
5931 }
5932
5933 monitor_frames = Fmake_vector (make_number (n_monitors), Qnil);
5934 FOR_EACH_FRAME (rest, frame)
5935 {
5936 struct frame *f = XFRAME (frame);
5937
5938 if (FRAME_W32_P (f) && !EQ (frame, tip_frame))
5939 {
5940 HMONITOR monitor =
5941 monitor_from_window_fn (FRAME_W32_WINDOW (f),
5942 MONITOR_DEFAULT_TO_NEAREST);
5943
5944 for (i = 0; i < n_monitors; i++)
5945 if (monitors[i] == monitor)
5946 break;
5947
5948 if (i < n_monitors)
5949 ASET (monitor_frames, i, Fcons (frame, AREF (monitor_frames, i)));
5950 }
5951 }
5952
5953 for (i = 0; i < n_monitors; i++)
5954 {
5955 Lisp_Object geometry, workarea, name, attributes = Qnil;
5956 HDC hdc;
5957 int width_mm, height_mm;
5958 struct MONITOR_INFO_EX mi;
5959
5960 mi.cbSize = sizeof (mi);
5961 if (!get_monitor_info_fn (monitors[i], (struct MONITOR_INFO *) &mi))
5962 continue;
5963
5964 hdc = CreateDCA ("DISPLAY", mi.szDevice, NULL, NULL);
5965 if (hdc == NULL)
5966 continue;
5967 width_mm = GetDeviceCaps (hdc, HORZSIZE);
5968 height_mm = GetDeviceCaps (hdc, VERTSIZE);
5969 DeleteDC (hdc);
5970
5971 attributes = Fcons (Fcons (Qframes, AREF (monitor_frames, i)),
5972 attributes);
5973
5974 name = DECODE_SYSTEM (build_unibyte_string (mi.szDevice));
5975
5976 attributes = Fcons (Fcons (Qname, name), attributes);
5977
5978 attributes = Fcons (Fcons (Qmm_size, list2i (width_mm, height_mm)),
5979 attributes);
5980
5981 workarea = list4i (mi.rcWork.left, mi.rcWork.top,
5982 mi.rcWork.right - mi.rcWork.left,
5983 mi.rcWork.bottom - mi.rcWork.top);
5984 attributes = Fcons (Fcons (Qworkarea, workarea), attributes);
5985
5986 geometry = list4i (mi.rcMonitor.left, mi.rcMonitor.top,
5987 mi.rcMonitor.right - mi.rcMonitor.left,
5988 mi.rcMonitor.bottom - mi.rcMonitor.top);
5989 attributes = Fcons (Fcons (Qgeometry, geometry), attributes);
5990
5991 if (mi.dwFlags & MONITORINFOF_PRIMARY)
5992 primary_monitor_attributes = attributes;
5993 else
5994 attributes_list = Fcons (attributes, attributes_list);
5995 }
5996
5997 if (!NILP (primary_monitor_attributes))
5998 attributes_list = Fcons (primary_monitor_attributes, attributes_list);
5999
6000 xfree (monitors);
6001
6002 return attributes_list;
6003 }
6004
6005 static Lisp_Object
6006 w32_display_monitor_attributes_list_fallback (struct w32_display_info *dpyinfo)
6007 {
6008 Lisp_Object geometry, workarea, frames, rest, frame, attributes = Qnil;
6009 HDC hdc;
6010 double mm_per_pixel;
6011 int pixel_width, pixel_height, width_mm, height_mm;
6012 RECT workarea_rect;
6013
6014 /* Fallback: treat (possibly) multiple physical monitors as if they
6015 formed a single monitor as a whole. This should provide a
6016 consistent result at least on single monitor environments. */
6017 attributes = Fcons (Fcons (Qname, build_string ("combined screen")),
6018 attributes);
6019
6020 frames = Qnil;
6021 FOR_EACH_FRAME (rest, frame)
6022 {
6023 struct frame *f = XFRAME (frame);
6024
6025 if (FRAME_W32_P (f) && !EQ (frame, tip_frame))
6026 frames = Fcons (frame, frames);
6027 }
6028 attributes = Fcons (Fcons (Qframes, frames), attributes);
6029
6030 pixel_width = x_display_pixel_width (dpyinfo);
6031 pixel_height = x_display_pixel_height (dpyinfo);
6032
6033 hdc = GetDC (NULL);
6034 mm_per_pixel = ((double) GetDeviceCaps (hdc, HORZSIZE)
6035 / GetDeviceCaps (hdc, HORZRES));
6036 width_mm = pixel_width * mm_per_pixel + 0.5;
6037 mm_per_pixel = ((double) GetDeviceCaps (hdc, VERTSIZE)
6038 / GetDeviceCaps (hdc, VERTRES));
6039 height_mm = pixel_height * mm_per_pixel + 0.5;
6040 ReleaseDC (NULL, hdc);
6041 attributes = Fcons (Fcons (Qmm_size, list2i (width_mm, height_mm)),
6042 attributes);
6043
6044 /* GetSystemMetrics below may return 0 for Windows 95 or NT 4.0, but
6045 we don't care. */
6046 geometry = list4i (GetSystemMetrics (SM_XVIRTUALSCREEN),
6047 GetSystemMetrics (SM_YVIRTUALSCREEN),
6048 pixel_width, pixel_height);
6049 if (SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0))
6050 workarea = list4i (workarea_rect.left, workarea_rect.top,
6051 workarea_rect.right - workarea_rect.left,
6052 workarea_rect.bottom - workarea_rect.top);
6053 else
6054 workarea = geometry;
6055 attributes = Fcons (Fcons (Qworkarea, workarea), attributes);
6056
6057 attributes = Fcons (Fcons (Qgeometry, geometry), attributes);
6058
6059 return list1 (attributes);
6060 }
6061
6062 DEFUN ("w32-display-monitor-attributes-list", Fw32_display_monitor_attributes_list,
6063 Sw32_display_monitor_attributes_list,
6064 0, 1, 0,
6065 doc: /* Return a list of physical monitor attributes on the W32 display DISPLAY.
6066
6067 The optional argument DISPLAY specifies which display to ask about.
6068 DISPLAY should be either a frame or a display name (a string).
6069 If omitted or nil, that stands for the selected frame's display.
6070
6071 Internal use only, use `display-monitor-attributes-list' instead. */)
6072 (Lisp_Object display)
6073 {
6074 struct w32_display_info *dpyinfo = check_x_display_info (display);
6075 Lisp_Object attributes_list;
6076
6077 block_input ();
6078 attributes_list = w32_display_monitor_attributes_list ();
6079 if (NILP (attributes_list))
6080 attributes_list = w32_display_monitor_attributes_list_fallback (dpyinfo);
6081 unblock_input ();
6082
6083 return attributes_list;
6084 }
6085
6086 DEFUN ("set-message-beep", Fset_message_beep, Sset_message_beep, 1, 1, 0,
6087 doc: /* Set the sound generated when the bell is rung.
6088 SOUND is `asterisk', `exclamation', `hand', `question', `ok', or `silent'
6089 to use the corresponding system sound for the bell. The `silent' sound
6090 prevents Emacs from making any sound at all.
6091 SOUND is nil to use the normal beep. */)
6092 (Lisp_Object sound)
6093 {
6094 CHECK_SYMBOL (sound);
6095
6096 if (NILP (sound))
6097 sound_type = 0xFFFFFFFF;
6098 else if (EQ (sound, intern ("asterisk")))
6099 sound_type = MB_ICONASTERISK;
6100 else if (EQ (sound, intern ("exclamation")))
6101 sound_type = MB_ICONEXCLAMATION;
6102 else if (EQ (sound, intern ("hand")))
6103 sound_type = MB_ICONHAND;
6104 else if (EQ (sound, intern ("question")))
6105 sound_type = MB_ICONQUESTION;
6106 else if (EQ (sound, intern ("ok")))
6107 sound_type = MB_OK;
6108 else if (EQ (sound, intern ("silent")))
6109 sound_type = MB_EMACS_SILENT;
6110 else
6111 sound_type = 0xFFFFFFFF;
6112
6113 return sound;
6114 }
6115
6116 int
6117 x_screen_planes (register struct frame *f)
6118 {
6119 return FRAME_DISPLAY_INFO (f)->n_planes;
6120 }
6121 \f
6122 /* Return the display structure for the display named NAME.
6123 Open a new connection if necessary. */
6124
6125 struct w32_display_info *
6126 x_display_info_for_name (Lisp_Object name)
6127 {
6128 struct w32_display_info *dpyinfo;
6129
6130 CHECK_STRING (name);
6131
6132 for (dpyinfo = &one_w32_display_info; dpyinfo; dpyinfo = dpyinfo->next)
6133 if (!NILP (Fstring_equal (XCAR (dpyinfo->name_list_element), name)))
6134 return dpyinfo;
6135
6136 /* Use this general default value to start with. */
6137 Vx_resource_name = Vinvocation_name;
6138
6139 validate_x_resource_name ();
6140
6141 dpyinfo = w32_term_init (name, NULL, SSDATA (Vx_resource_name));
6142
6143 if (dpyinfo == 0)
6144 error ("Cannot connect to server %s", SDATA (name));
6145
6146 XSETFASTINT (Vwindow_system_version, w32_major_version);
6147
6148 return dpyinfo;
6149 }
6150
6151 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
6152 1, 3, 0, doc: /* Open a connection to a display server.
6153 DISPLAY is the name of the display to connect to.
6154 Optional second arg XRM-STRING is a string of resources in xrdb format.
6155 If the optional third arg MUST-SUCCEED is non-nil,
6156 terminate Emacs if we can't open the connection.
6157 \(In the Nextstep version, the last two arguments are currently ignored.) */)
6158 (Lisp_Object display, Lisp_Object xrm_string, Lisp_Object must_succeed)
6159 {
6160 char *xrm_option;
6161 struct w32_display_info *dpyinfo;
6162
6163 CHECK_STRING (display);
6164
6165 /* Signal an error in order to encourage correct use from callers.
6166 * If we ever support multiple window systems in the same Emacs,
6167 * we'll need callers to be precise about what window system they
6168 * want. */
6169
6170 if (strcmp (SSDATA (display), "w32") != 0)
6171 error ("The name of the display in this Emacs must be \"w32\"");
6172
6173 /* If initialization has already been done, return now to avoid
6174 overwriting critical parts of one_w32_display_info. */
6175 if (window_system_available (NULL))
6176 return Qnil;
6177
6178 if (! NILP (xrm_string))
6179 CHECK_STRING (xrm_string);
6180
6181 /* Allow color mapping to be defined externally; first look in user's
6182 HOME directory, then in Emacs etc dir for a file called rgb.txt. */
6183 {
6184 Lisp_Object color_file;
6185
6186 color_file = build_string ("~/rgb.txt");
6187
6188 if (NILP (Ffile_readable_p (color_file)))
6189 color_file =
6190 Fexpand_file_name (build_string ("rgb.txt"),
6191 Fsymbol_value (intern ("data-directory")));
6192
6193 Vw32_color_map = Fx_load_color_file (color_file);
6194 }
6195 if (NILP (Vw32_color_map))
6196 Vw32_color_map = w32_default_color_map ();
6197
6198 /* Merge in system logical colors. */
6199 add_system_logical_colors_to_map (&Vw32_color_map);
6200
6201 if (! NILP (xrm_string))
6202 xrm_option = SSDATA (xrm_string);
6203 else
6204 xrm_option = NULL;
6205
6206 /* Use this general default value to start with. */
6207 /* First remove .exe suffix from invocation-name - it looks ugly. */
6208 {
6209 char basename[ MAX_PATH ], *str;
6210
6211 lispstpcpy (basename, Vinvocation_name);
6212 str = strrchr (basename, '.');
6213 if (str) *str = 0;
6214 Vinvocation_name = build_string (basename);
6215 }
6216 Vx_resource_name = Vinvocation_name;
6217
6218 validate_x_resource_name ();
6219
6220 /* This is what opens the connection and sets x_current_display.
6221 This also initializes many symbols, such as those used for input. */
6222 dpyinfo = w32_term_init (display, xrm_option, SSDATA (Vx_resource_name));
6223
6224 if (dpyinfo == 0)
6225 {
6226 if (!NILP (must_succeed))
6227 fatal ("Cannot connect to server %s.\n",
6228 SDATA (display));
6229 else
6230 error ("Cannot connect to server %s", SDATA (display));
6231 }
6232
6233 XSETFASTINT (Vwindow_system_version, w32_major_version);
6234 return Qnil;
6235 }
6236
6237 DEFUN ("x-close-connection", Fx_close_connection,
6238 Sx_close_connection, 1, 1, 0,
6239 doc: /* Close the connection to DISPLAY's server.
6240 For DISPLAY, specify either a frame or a display name (a string).
6241 If DISPLAY is nil, that stands for the selected frame's display. */)
6242 (Lisp_Object display)
6243 {
6244 struct w32_display_info *dpyinfo = check_x_display_info (display);
6245
6246 if (dpyinfo->reference_count > 0)
6247 error ("Display still has frames on it");
6248
6249 block_input ();
6250 x_destroy_all_bitmaps (dpyinfo);
6251
6252 x_delete_display (dpyinfo);
6253 unblock_input ();
6254
6255 return Qnil;
6256 }
6257
6258 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
6259 doc: /* Return the list of display names that Emacs has connections to. */)
6260 (void)
6261 {
6262 Lisp_Object result = Qnil;
6263 struct w32_display_info *wdi;
6264
6265 for (wdi = x_display_list; wdi; wdi = wdi->next)
6266 result = Fcons (XCAR (wdi->name_list_element), result);
6267
6268 return result;
6269 }
6270
6271 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
6272 doc: /* If ON is non-nil, report X errors as soon as the erring request is made.
6273 This function only has an effect on X Windows. With MS Windows, it is
6274 defined but does nothing.
6275
6276 If ON is nil, allow buffering of requests.
6277 Turning on synchronization prohibits the Xlib routines from buffering
6278 requests and seriously degrades performance, but makes debugging much
6279 easier.
6280 The optional second argument TERMINAL specifies which display to act on.
6281 TERMINAL should be a terminal object, a frame or a display name (a string).
6282 If TERMINAL is omitted or nil, that stands for the selected frame's display. */)
6283 (Lisp_Object on, Lisp_Object display)
6284 {
6285 return Qnil;
6286 }
6287
6288
6289 \f
6290 /***********************************************************************
6291 Window properties
6292 ***********************************************************************/
6293
6294 #if 0 /* TODO : port window properties to W32 */
6295
6296 DEFUN ("x-change-window-property", Fx_change_window_property,
6297 Sx_change_window_property, 2, 6, 0,
6298 doc: /* Change window property PROP to VALUE on the X window of FRAME.
6299 PROP must be a string. VALUE may be a string or a list of conses,
6300 numbers and/or strings. If an element in the list is a string, it is
6301 converted to an atom and the value of the Atom is used. If an element
6302 is a cons, it is converted to a 32 bit number where the car is the 16
6303 top bits and the cdr is the lower 16 bits.
6304
6305 FRAME nil or omitted means use the selected frame.
6306 If TYPE is given and non-nil, it is the name of the type of VALUE.
6307 If TYPE is not given or nil, the type is STRING.
6308 FORMAT gives the size in bits of each element if VALUE is a list.
6309 It must be one of 8, 16 or 32.
6310 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
6311 If OUTER-P is non-nil, the property is changed for the outer X window of
6312 FRAME. Default is to change on the edit X window. */)
6313 (Lisp_Object prop, Lisp_Object value, Lisp_Object frame,
6314 Lisp_Object type, Lisp_Object format, Lisp_Object outer_p)
6315 {
6316 struct frame *f = decode_window_system_frame (frame);
6317 Atom prop_atom;
6318
6319 CHECK_STRING (prop);
6320 CHECK_STRING (value);
6321
6322 block_input ();
6323 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
6324 XChangeProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
6325 prop_atom, XA_STRING, 8, PropModeReplace,
6326 SDATA (value), SCHARS (value));
6327
6328 /* Make sure the property is set when we return. */
6329 XFlush (FRAME_W32_DISPLAY (f));
6330 unblock_input ();
6331
6332 return value;
6333 }
6334
6335
6336 DEFUN ("x-delete-window-property", Fx_delete_window_property,
6337 Sx_delete_window_property, 1, 2, 0,
6338 doc: /* Remove window property PROP from X window of FRAME.
6339 FRAME nil or omitted means use the selected frame. Value is PROP. */)
6340 (Lisp_Object prop, Lisp_Object frame)
6341 {
6342 struct frame *f = decode_window_system_frame (frame);
6343 Atom prop_atom;
6344
6345 CHECK_STRING (prop);
6346 block_input ();
6347 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
6348 XDeleteProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f), prop_atom);
6349
6350 /* Make sure the property is removed when we return. */
6351 XFlush (FRAME_W32_DISPLAY (f));
6352 unblock_input ();
6353
6354 return prop;
6355 }
6356
6357
6358 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
6359 1, 6, 0,
6360 doc: /* Value is the value of window property PROP on FRAME.
6361 If FRAME is nil or omitted, use the selected frame.
6362
6363 On X Windows, the following optional arguments are also accepted:
6364 If TYPE is nil or omitted, get the property as a string.
6365 Otherwise TYPE is the name of the atom that denotes the type expected.
6366 If SOURCE is non-nil, get the property on that window instead of from
6367 FRAME. The number 0 denotes the root window.
6368 If DELETE-P is non-nil, delete the property after retrieving it.
6369 If VECTOR-RET-P is non-nil, don't return a string but a vector of values.
6370
6371 On MS Windows, this function accepts but ignores those optional arguments.
6372
6373 Value is nil if FRAME hasn't a property with name PROP or if PROP has
6374 no value of TYPE (always string in the MS Windows case). */)
6375 (Lisp_Object prop, Lisp_Object frame, Lisp_Object type,
6376 Lisp_Object source, Lisp_Object delete_p, Lisp_Object vector_ret_p)
6377 {
6378 struct frame *f = decode_window_system_frame (frame);
6379 Atom prop_atom;
6380 int rc;
6381 Lisp_Object prop_value = Qnil;
6382 char *tmp_data = NULL;
6383 Atom actual_type;
6384 int actual_format;
6385 unsigned long actual_size, bytes_remaining;
6386
6387 CHECK_STRING (prop);
6388 block_input ();
6389 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
6390 rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
6391 prop_atom, 0, 0, False, XA_STRING,
6392 &actual_type, &actual_format, &actual_size,
6393 &bytes_remaining, (unsigned char **) &tmp_data);
6394 if (rc == Success)
6395 {
6396 int size = bytes_remaining;
6397
6398 XFree (tmp_data);
6399 tmp_data = NULL;
6400
6401 rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
6402 prop_atom, 0, bytes_remaining,
6403 False, XA_STRING,
6404 &actual_type, &actual_format,
6405 &actual_size, &bytes_remaining,
6406 (unsigned char **) &tmp_data);
6407 if (rc == Success)
6408 prop_value = make_string (tmp_data, size);
6409
6410 XFree (tmp_data);
6411 }
6412
6413 unblock_input ();
6414
6415 return prop_value;
6416
6417 return Qnil;
6418 }
6419
6420 #endif /* TODO */
6421
6422 /***********************************************************************
6423 Tool tips
6424 ***********************************************************************/
6425
6426 static void compute_tip_xy (struct frame *, Lisp_Object, Lisp_Object,
6427 Lisp_Object, int, int, int *, int *);
6428
6429 /* The frame of a currently visible tooltip. */
6430
6431 Lisp_Object tip_frame;
6432
6433 /* If non-nil, a timer started that hides the last tooltip when it
6434 fires. */
6435
6436 Lisp_Object tip_timer;
6437 Window tip_window;
6438
6439 /* If non-nil, a vector of 3 elements containing the last args
6440 with which x-show-tip was called. See there. */
6441
6442 Lisp_Object last_show_tip_args;
6443
6444
6445 static void
6446 unwind_create_tip_frame (Lisp_Object frame)
6447 {
6448 Lisp_Object deleted;
6449
6450 deleted = unwind_create_frame (frame);
6451 if (EQ (deleted, Qt))
6452 {
6453 tip_window = NULL;
6454 tip_frame = Qnil;
6455 }
6456 }
6457
6458
6459 /* Create a frame for a tooltip on the display described by DPYINFO.
6460 PARMS is a list of frame parameters. Value is the frame.
6461
6462 Note that functions called here, esp. x_default_parameter can
6463 signal errors, for instance when a specified color name is
6464 undefined. We have to make sure that we're in a consistent state
6465 when this happens. */
6466
6467 static Lisp_Object
6468 x_create_tip_frame (struct w32_display_info *dpyinfo, Lisp_Object parms)
6469 {
6470 struct frame *f;
6471 Lisp_Object frame;
6472 Lisp_Object name;
6473 int width, height;
6474 ptrdiff_t count = SPECPDL_INDEX ();
6475 struct kboard *kb;
6476 bool face_change_before = face_change;
6477 int x_width = 0, x_height = 0;
6478
6479 /* Use this general default value to start with until we know if
6480 this frame has a specified name. */
6481 Vx_resource_name = Vinvocation_name;
6482
6483 kb = dpyinfo->terminal->kboard;
6484
6485 /* The calls to x_get_arg remove elements from PARMS, so copy it to
6486 avoid destructive changes behind our caller's back. */
6487 parms = Fcopy_alist (parms);
6488
6489 /* Get the name of the frame to use for resource lookup. */
6490 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
6491 if (!STRINGP (name)
6492 && !EQ (name, Qunbound)
6493 && !NILP (name))
6494 error ("Invalid frame name--not a string or nil");
6495 Vx_resource_name = name;
6496
6497 frame = Qnil;
6498 /* Make a frame without minibuffer nor mode-line. */
6499 f = make_frame (false);
6500 f->wants_modeline = false;
6501 XSETFRAME (frame, f);
6502
6503 record_unwind_protect (unwind_create_tip_frame, frame);
6504
6505 /* By setting the output method, we're essentially saying that
6506 the frame is live, as per FRAME_LIVE_P. If we get a signal
6507 from this point on, x_destroy_window might screw up reference
6508 counts etc. */
6509 f->terminal = dpyinfo->terminal;
6510 f->output_method = output_w32;
6511 f->output_data.w32 = xzalloc (sizeof (struct w32_output));
6512
6513 FRAME_FONTSET (f) = -1;
6514 fset_icon_name (f, Qnil);
6515
6516 #ifdef GLYPH_DEBUG
6517 image_cache_refcount =
6518 FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
6519 dpyinfo_refcount = dpyinfo->reference_count;
6520 #endif /* GLYPH_DEBUG */
6521 FRAME_KBOARD (f) = kb;
6522 f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
6523 f->output_data.w32->explicit_parent = false;
6524
6525 /* Set the name; the functions to which we pass f expect the name to
6526 be set. */
6527 if (EQ (name, Qunbound) || NILP (name))
6528 {
6529 fset_name (f, build_string (dpyinfo->w32_id_name));
6530 f->explicit_name = false;
6531 }
6532 else
6533 {
6534 fset_name (f, name);
6535 f->explicit_name = true;
6536 /* Use the frame's title when getting resources for this frame. */
6537 specbind (Qx_resource_name, name);
6538 }
6539
6540 if (uniscribe_available)
6541 register_font_driver (&uniscribe_font_driver, f);
6542 register_font_driver (&w32font_driver, f);
6543
6544 x_default_parameter (f, parms, Qfont_backend, Qnil,
6545 "fontBackend", "FontBackend", RES_TYPE_STRING);
6546
6547 /* Extract the window parameters from the supplied values
6548 that are needed to determine window geometry. */
6549 x_default_font_parameter (f, parms);
6550
6551 x_default_parameter (f, parms, Qborder_width, make_number (2),
6552 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
6553 /* This defaults to 2 in order to match xterm. We recognize either
6554 internalBorderWidth or internalBorder (which is what xterm calls
6555 it). */
6556 if (NILP (Fassq (Qinternal_border_width, parms)))
6557 {
6558 Lisp_Object value;
6559
6560 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
6561 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
6562 if (! EQ (value, Qunbound))
6563 parms = Fcons (Fcons (Qinternal_border_width, value),
6564 parms);
6565 }
6566
6567 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
6568 "internalBorderWidth", "internalBorderWidth",
6569 RES_TYPE_NUMBER);
6570 /* Also do the stuff which must be set before the window exists. */
6571 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
6572 "foreground", "Foreground", RES_TYPE_STRING);
6573 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
6574 "background", "Background", RES_TYPE_STRING);
6575 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
6576 "pointerColor", "Foreground", RES_TYPE_STRING);
6577 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
6578 "cursorColor", "Foreground", RES_TYPE_STRING);
6579 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
6580 "borderColor", "BorderColor", RES_TYPE_STRING);
6581
6582 /* Init faces before x_default_parameter is called for the
6583 scroll-bar-width parameter because otherwise we end up in
6584 init_iterator with a null face cache, which should not happen. */
6585 init_frame_faces (f);
6586
6587 f->output_data.w32->dwStyle = WS_BORDER | WS_POPUP | WS_DISABLED;
6588 f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
6589
6590 x_figure_window_size (f, parms, true, &x_width, &x_height);
6591
6592 /* No fringes on tip frame. */
6593 f->fringe_cols = 0;
6594 f->left_fringe_width = 0;
6595 f->right_fringe_width = 0;
6596 /* No dividers on tip frame. */
6597 f->right_divider_width = 0;
6598 f->bottom_divider_width = 0;
6599
6600 block_input ();
6601 my_create_tip_window (f);
6602 unblock_input ();
6603
6604 x_make_gc (f);
6605
6606 x_default_parameter (f, parms, Qauto_raise, Qnil,
6607 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
6608 x_default_parameter (f, parms, Qauto_lower, Qnil,
6609 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
6610 x_default_parameter (f, parms, Qcursor_type, Qbox,
6611 "cursorType", "CursorType", RES_TYPE_SYMBOL);
6612 /* Process alpha here (Bug#17344). */
6613 x_default_parameter (f, parms, Qalpha, Qnil,
6614 "alpha", "Alpha", RES_TYPE_NUMBER);
6615
6616 /* Dimensions, especially FRAME_LINES (f), must be done via
6617 change_frame_size. Change will not be effected unless different
6618 from the current FRAME_LINES (f). */
6619 width = FRAME_COLS (f);
6620 height = FRAME_LINES (f);
6621 SET_FRAME_COLS (f, 0);
6622 SET_FRAME_LINES (f, 0);
6623 adjust_frame_size (f, width * FRAME_COLUMN_WIDTH (f),
6624 height * FRAME_LINE_HEIGHT (f), 0, true, Qtip_frame);
6625 /* Add `tooltip' frame parameter's default value. */
6626 if (NILP (Fframe_parameter (frame, Qtooltip)))
6627 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtooltip, Qt), Qnil));
6628
6629 /* Set up faces after all frame parameters are known. This call
6630 also merges in face attributes specified for new frames.
6631
6632 Frame parameters may be changed if .Xdefaults contains
6633 specifications for the default font. For example, if there is an
6634 `Emacs.default.attributeBackground: pink', the `background-color'
6635 attribute of the frame get's set, which let's the internal border
6636 of the tooltip frame appear in pink. Prevent this. */
6637 {
6638 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
6639 Lisp_Object fg = Fframe_parameter (frame, Qforeground_color);
6640 Lisp_Object colors = Qnil;
6641
6642 call2 (Qface_set_after_frame_default, frame, Qnil);
6643
6644 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
6645 colors = Fcons (Fcons (Qbackground_color, bg), colors);
6646 if (!EQ (fg, Fframe_parameter (frame, Qforeground_color)))
6647 colors = Fcons (Fcons (Qforeground_color, fg), colors);
6648
6649 if (!NILP (colors))
6650 Fmodify_frame_parameters (frame, colors);
6651 }
6652
6653 f->no_split = true;
6654
6655 /* Now that the frame is official, it counts as a reference to
6656 its display. */
6657 FRAME_DISPLAY_INFO (f)->reference_count++;
6658 f->terminal->reference_count++;
6659
6660 /* It is now ok to make the frame official even if we get an error
6661 below. And the frame needs to be on Vframe_list or making it
6662 visible won't work. */
6663 Vframe_list = Fcons (frame, Vframe_list);
6664 f->can_x_set_window_size = true;
6665
6666 /* Setting attributes of faces of the tooltip frame from resources
6667 and similar will set face_change, which leads to the
6668 clearing of all current matrices. Since this isn't necessary
6669 here, avoid it by resetting face_change to the value it
6670 had before we created the tip frame. */
6671 face_change = face_change_before;
6672
6673 /* Discard the unwind_protect. */
6674 return unbind_to (count, frame);
6675 }
6676
6677
6678 /* Compute where to display tip frame F. PARMS is the list of frame
6679 parameters for F. DX and DY are specified offsets from the current
6680 location of the mouse. WIDTH and HEIGHT are the width and height
6681 of the tooltip. Return coordinates relative to the root window of
6682 the display in *ROOT_X and *ROOT_Y. */
6683
6684 static void
6685 compute_tip_xy (struct frame *f,
6686 Lisp_Object parms, Lisp_Object dx, Lisp_Object dy,
6687 int width, int height, int *root_x, int *root_y)
6688 {
6689 Lisp_Object left, top, right, bottom;
6690 int min_x, min_y, max_x, max_y;
6691
6692 /* User-specified position? */
6693 left = Fcdr (Fassq (Qleft, parms));
6694 top = Fcdr (Fassq (Qtop, parms));
6695 right = Fcdr (Fassq (Qright, parms));
6696 bottom = Fcdr (Fassq (Qbottom, parms));
6697
6698 /* Move the tooltip window where the mouse pointer is. Resize and
6699 show it. */
6700 if ((!INTEGERP (left) && !INTEGERP (right))
6701 || (!INTEGERP (top) && !INTEGERP (bottom)))
6702 {
6703 POINT pt;
6704
6705 /* Default min and max values. */
6706 min_x = 0;
6707 min_y = 0;
6708 max_x = x_display_pixel_width (FRAME_DISPLAY_INFO (f));
6709 max_y = x_display_pixel_height (FRAME_DISPLAY_INFO (f));
6710
6711 block_input ();
6712 GetCursorPos (&pt);
6713 *root_x = pt.x;
6714 *root_y = pt.y;
6715 unblock_input ();
6716
6717 /* If multiple monitor support is available, constrain the tip onto
6718 the current monitor. This improves the above by allowing negative
6719 co-ordinates if monitor positions are such that they are valid, and
6720 snaps a tooltip onto a single monitor if we are close to the edge
6721 where it would otherwise flow onto the other monitor (or into
6722 nothingness if there is a gap in the overlap). */
6723 if (monitor_from_point_fn && get_monitor_info_fn)
6724 {
6725 struct MONITOR_INFO info;
6726 HMONITOR monitor
6727 = monitor_from_point_fn (pt, MONITOR_DEFAULT_TO_NEAREST);
6728 info.cbSize = sizeof (info);
6729
6730 if (get_monitor_info_fn (monitor, &info))
6731 {
6732 min_x = info.rcWork.left;
6733 min_y = info.rcWork.top;
6734 max_x = info.rcWork.right;
6735 max_y = info.rcWork.bottom;
6736 }
6737 }
6738 }
6739
6740 if (INTEGERP (top))
6741 *root_y = XINT (top);
6742 else if (INTEGERP (bottom))
6743 *root_y = XINT (bottom) - height;
6744 else if (*root_y + XINT (dy) <= min_y)
6745 *root_y = min_y; /* Can happen for negative dy */
6746 else if (*root_y + XINT (dy) + height <= max_y)
6747 /* It fits below the pointer */
6748 *root_y += XINT (dy);
6749 else if (height + XINT (dy) + min_y <= *root_y)
6750 /* It fits above the pointer. */
6751 *root_y -= height + XINT (dy);
6752 else
6753 /* Put it on the top. */
6754 *root_y = min_y;
6755
6756 if (INTEGERP (left))
6757 *root_x = XINT (left);
6758 else if (INTEGERP (right))
6759 *root_x = XINT (right) - width;
6760 else if (*root_x + XINT (dx) <= min_x)
6761 *root_x = 0; /* Can happen for negative dx */
6762 else if (*root_x + XINT (dx) + width <= max_x)
6763 /* It fits to the right of the pointer. */
6764 *root_x += XINT (dx);
6765 else if (width + XINT (dx) + min_x <= *root_x)
6766 /* It fits to the left of the pointer. */
6767 *root_x -= width + XINT (dx);
6768 else
6769 /* Put it left justified on the screen -- it ought to fit that way. */
6770 *root_x = min_x;
6771 }
6772
6773 /* Hide tooltip. Delete its frame if DELETE is true. */
6774 static Lisp_Object
6775 x_hide_tip (bool delete)
6776 {
6777 if (!NILP (tip_timer))
6778 {
6779 call1 (Qcancel_timer, tip_timer);
6780 tip_timer = Qnil;
6781 }
6782
6783 if (NILP (tip_frame)
6784 || (!delete && FRAMEP (tip_frame)
6785 && !FRAME_VISIBLE_P (XFRAME (tip_frame))))
6786 return Qnil;
6787 else
6788 {
6789 ptrdiff_t count;
6790 Lisp_Object was_open = Qnil;
6791
6792 count = SPECPDL_INDEX ();
6793 specbind (Qinhibit_redisplay, Qt);
6794 specbind (Qinhibit_quit, Qt);
6795
6796 if (FRAMEP (tip_frame))
6797 {
6798 if (delete)
6799 {
6800 delete_frame (tip_frame, Qnil);
6801 tip_frame = Qnil;
6802 }
6803 else
6804 x_make_frame_invisible (XFRAME (tip_frame));
6805
6806 was_open = Qt;
6807 }
6808 else
6809 tip_frame = Qnil;
6810
6811 return unbind_to (count, was_open);
6812 }
6813 }
6814
6815
6816 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
6817 doc: /* Show STRING in a \"tooltip\" window on frame FRAME.
6818 A tooltip window is a small window displaying a string.
6819
6820 This is an internal function; Lisp code should call `tooltip-show'.
6821
6822 FRAME nil or omitted means use the selected frame.
6823
6824 PARMS is an optional list of frame parameters which can be
6825 used to change the tooltip's appearance.
6826
6827 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
6828 means use the default timeout of 5 seconds.
6829
6830 If the list of frame parameters PARMS contains a `left' parameter,
6831 display the tooltip at that x-position. If the list of frame parameters
6832 PARMS contains no `left' but a `right' parameter, display the tooltip
6833 right-adjusted at that x-position. Otherwise display it at the
6834 x-position of the mouse, with offset DX added (default is 5 if DX isn't
6835 specified).
6836
6837 Likewise for the y-position: If a `top' frame parameter is specified, it
6838 determines the position of the upper edge of the tooltip window. If a
6839 `bottom' parameter but no `top' frame parameter is specified, it
6840 determines the position of the lower edge of the tooltip window.
6841 Otherwise display the tooltip window at the y-position of the mouse,
6842 with offset DY added (default is -10).
6843
6844 A tooltip's maximum size is specified by `x-max-tooltip-size'.
6845 Text larger than the specified size is clipped. */)
6846 (Lisp_Object string, Lisp_Object frame, Lisp_Object parms, Lisp_Object timeout, Lisp_Object dx, Lisp_Object dy)
6847 {
6848 struct frame *f, *tip_f;
6849 struct window *w;
6850 int root_x, root_y;
6851 struct buffer *old_buffer;
6852 struct text_pos pos;
6853 int i, width, height;
6854 int old_windows_or_buffers_changed = windows_or_buffers_changed;
6855 ptrdiff_t count = SPECPDL_INDEX ();
6856 ptrdiff_t count_1;
6857 Lisp_Object window, size;
6858
6859 specbind (Qinhibit_redisplay, Qt);
6860
6861 CHECK_STRING (string);
6862 f = decode_window_system_frame (frame);
6863 if (NILP (timeout))
6864 timeout = make_number (5);
6865 else
6866 CHECK_NATNUM (timeout);
6867
6868 if (NILP (dx))
6869 dx = make_number (5);
6870 else
6871 CHECK_NUMBER (dx);
6872
6873 if (NILP (dy))
6874 dy = make_number (-10);
6875 else
6876 CHECK_NUMBER (dy);
6877
6878 if (NILP (last_show_tip_args))
6879 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
6880
6881 if (FRAMEP (tip_frame) && FRAME_LIVE_P (XFRAME (tip_frame)))
6882 {
6883 Lisp_Object last_string = AREF (last_show_tip_args, 0);
6884 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
6885 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
6886
6887 if (FRAME_VISIBLE_P (XFRAME (tip_frame))
6888 && EQ (frame, last_frame)
6889 && !NILP (Fequal_including_properties (last_string, string))
6890 && !NILP (Fequal (last_parms, parms)))
6891 {
6892 /* Only DX and DY have changed. */
6893 tip_f = XFRAME (tip_frame);
6894 if (!NILP (tip_timer))
6895 {
6896 Lisp_Object timer = tip_timer;
6897
6898 tip_timer = Qnil;
6899 call1 (Qcancel_timer, timer);
6900 }
6901
6902 block_input ();
6903 compute_tip_xy (tip_f, parms, dx, dy, FRAME_PIXEL_WIDTH (tip_f),
6904 FRAME_PIXEL_HEIGHT (tip_f), &root_x, &root_y);
6905
6906 /* Put tooltip in topmost group and in position. */
6907 SetWindowPos (FRAME_W32_WINDOW (tip_f), HWND_TOPMOST,
6908 root_x, root_y, 0, 0,
6909 SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
6910
6911 /* Ensure tooltip is on top of other topmost windows (eg menus). */
6912 SetWindowPos (FRAME_W32_WINDOW (tip_f), HWND_TOP,
6913 0, 0, 0, 0,
6914 SWP_NOMOVE | SWP_NOSIZE
6915 | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
6916
6917 /* Let redisplay know that we have made the frame visible already. */
6918 SET_FRAME_VISIBLE (tip_f, 1);
6919 ShowWindow (FRAME_W32_WINDOW (tip_f), SW_SHOWNOACTIVATE);
6920 unblock_input ();
6921
6922 goto start_timer;
6923 }
6924 else if (tooltip_reuse_hidden_frame && EQ (frame, last_frame))
6925 {
6926 bool delete = false;
6927 Lisp_Object tail, elt, parm, last;
6928
6929 /* Check if every parameter in PARMS has the same value in
6930 last_parms. This may destruct last_parms which, however,
6931 will be recreated below. */
6932 for (tail = parms; CONSP (tail); tail = XCDR (tail))
6933 {
6934 elt = XCAR (tail);
6935 parm = Fcar (elt);
6936 /* The left, top, right and bottom parameters are handled
6937 by compute_tip_xy so they can be ignored here. */
6938 if (!EQ (parm, Qleft) && !EQ (parm, Qtop)
6939 && !EQ (parm, Qright) && !EQ (parm, Qbottom))
6940 {
6941 last = Fassq (parm, last_parms);
6942 if (NILP (Fequal (Fcdr (elt), Fcdr (last))))
6943 {
6944 /* We lost, delete the old tooltip. */
6945 delete = true;
6946 break;
6947 }
6948 else
6949 last_parms = call2 (Qassq_delete_all, parm, last_parms);
6950 }
6951 else
6952 last_parms = call2 (Qassq_delete_all, parm, last_parms);
6953 }
6954
6955 /* Now check if there's a parameter left in last_parms with a
6956 non-nil value. */
6957 for (tail = last_parms; CONSP (tail); tail = XCDR (tail))
6958 {
6959 elt = XCAR (tail);
6960 parm = Fcar (elt);
6961 if (!EQ (parm, Qleft) && !EQ (parm, Qtop) && !EQ (parm, Qright)
6962 && !EQ (parm, Qbottom) && !NILP (Fcdr (elt)))
6963 {
6964 /* We lost, delete the old tooltip. */
6965 delete = true;
6966 break;
6967 }
6968 }
6969
6970 x_hide_tip (delete);
6971 }
6972 else
6973 x_hide_tip (true);
6974 }
6975 else
6976 x_hide_tip (true);
6977
6978 ASET (last_show_tip_args, 0, string);
6979 ASET (last_show_tip_args, 1, frame);
6980 ASET (last_show_tip_args, 2, parms);
6981
6982 /* Block input until the tip has been fully drawn, to avoid crashes
6983 when drawing tips in menus. */
6984 block_input ();
6985
6986 if (!FRAMEP (tip_frame) || !FRAME_LIVE_P (XFRAME (tip_frame)))
6987 {
6988 /* Add default values to frame parameters. */
6989 if (NILP (Fassq (Qname, parms)))
6990 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
6991 if (NILP (Fassq (Qinternal_border_width, parms)))
6992 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
6993 if (NILP (Fassq (Qborder_width, parms)))
6994 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
6995 if (NILP (Fassq (Qborder_color, parms)))
6996 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
6997 if (NILP (Fassq (Qbackground_color, parms)))
6998 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
6999 parms);
7000
7001 /* Create a frame for the tooltip, and record it in the global
7002 variable tip_frame. */
7003 if (NILP (tip_frame = x_create_tip_frame (FRAME_DISPLAY_INFO (f), parms)))
7004 {
7005 /* Creating the tip frame failed. */
7006 unblock_input ();
7007 return unbind_to (count, Qnil);
7008 }
7009 }
7010
7011 tip_f = XFRAME (tip_frame);
7012 window = FRAME_ROOT_WINDOW (tip_f);
7013 AUTO_STRING (tip, " *tip*");
7014 set_window_buffer (window, Fget_buffer_create (tip), false, false);
7015 w = XWINDOW (window);
7016 w->pseudo_window_p = true;
7017
7018 /* Set up the frame's root window. Note: The following code does not
7019 try to size the window or its frame correctly. Its only purpose is
7020 to make the subsequent text size calculations work. The right
7021 sizes should get installed when the toolkit gets back to us. */
7022 w->left_col = 0;
7023 w->top_line = 0;
7024 w->pixel_left = 0;
7025 w->pixel_top = 0;
7026
7027 if (CONSP (Vx_max_tooltip_size)
7028 && RANGED_INTEGERP (1, XCAR (Vx_max_tooltip_size), INT_MAX)
7029 && RANGED_INTEGERP (1, XCDR (Vx_max_tooltip_size), INT_MAX))
7030 {
7031 w->total_cols = XFASTINT (XCAR (Vx_max_tooltip_size));
7032 w->total_lines = XFASTINT (XCDR (Vx_max_tooltip_size));
7033 }
7034 else
7035 {
7036 w->total_cols = 80;
7037 w->total_lines = 40;
7038 }
7039
7040 w->pixel_width = w->total_cols * FRAME_COLUMN_WIDTH (tip_f);
7041 w->pixel_height = w->total_lines * FRAME_LINE_HEIGHT (tip_f);
7042 FRAME_TOTAL_COLS (tip_f) = WINDOW_TOTAL_COLS (w);
7043 adjust_frame_glyphs (tip_f);
7044
7045 /* Insert STRING into the root window's buffer and fit the frame to
7046 the buffer. */
7047 count_1 = SPECPDL_INDEX ();
7048 old_buffer = current_buffer;
7049 set_buffer_internal_1 (XBUFFER (w->contents));
7050 bset_truncate_lines (current_buffer, Qnil);
7051 specbind (Qinhibit_read_only, Qt);
7052 specbind (Qinhibit_modification_hooks, Qt);
7053 specbind (Qinhibit_point_motion_hooks, Qt);
7054 Ferase_buffer ();
7055 Finsert (1, &string);
7056 clear_glyph_matrix (w->desired_matrix);
7057 clear_glyph_matrix (w->current_matrix);
7058 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
7059 try_window (window, pos, TRY_WINDOW_IGNORE_FONTS_CHANGE);
7060 /* Calculate size of tooltip window. */
7061 size = Fwindow_text_pixel_size (window, Qnil, Qnil, Qnil,
7062 make_number (w->pixel_height), Qnil);
7063 /* Add the frame's internal border to calculated size. */
7064 width = XINT (Fcar (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
7065 height = XINT (Fcdr (size)) + 2 * FRAME_INTERNAL_BORDER_WIDTH (tip_f);
7066 /* Calculate position of tooltip frame. */
7067 compute_tip_xy (tip_f, parms, dx, dy, width, height, &root_x, &root_y);
7068
7069 /* Show tooltip frame. */
7070 {
7071 RECT rect;
7072 int pad = (NUMBERP (Vw32_tooltip_extra_pixels)
7073 ? max (0, XINT (Vw32_tooltip_extra_pixels))
7074 : FRAME_COLUMN_WIDTH (tip_f));
7075
7076 rect.left = rect.top = 0;
7077 rect.right = width;
7078 rect.bottom = height;
7079 AdjustWindowRect (&rect, tip_f->output_data.w32->dwStyle,
7080 FRAME_EXTERNAL_MENU_BAR (tip_f));
7081
7082 /* Position and size tooltip and put it in the topmost group. */
7083 SetWindowPos (FRAME_W32_WINDOW (tip_f), HWND_TOPMOST,
7084 root_x, root_y,
7085 rect.right - rect.left + pad,
7086 rect.bottom - rect.top, SWP_NOACTIVATE | SWP_NOOWNERZORDER);
7087
7088 /* Ensure tooltip is on top of other topmost windows (eg menus). */
7089 SetWindowPos (FRAME_W32_WINDOW (tip_f), HWND_TOP,
7090 0, 0, 0, 0,
7091 SWP_NOMOVE | SWP_NOSIZE
7092 | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
7093
7094 /* Let redisplay know that we have made the frame visible already. */
7095 SET_FRAME_VISIBLE (tip_f, 1);
7096
7097 ShowWindow (FRAME_W32_WINDOW (tip_f), SW_SHOWNOACTIVATE);
7098 }
7099
7100 w->must_be_updated_p = true;
7101 update_single_window (w);
7102 set_buffer_internal_1 (old_buffer);
7103 unbind_to (count_1, Qnil);
7104 unblock_input ();
7105 windows_or_buffers_changed = old_windows_or_buffers_changed;
7106
7107 start_timer:
7108 /* Let the tip disappear after timeout seconds. */
7109 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
7110 intern ("x-hide-tip"));
7111
7112 return unbind_to (count, Qnil);
7113 }
7114
7115
7116 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
7117 doc: /* Hide the current tooltip window, if there is any.
7118 Value is t if tooltip was open, nil otherwise. */)
7119 (void)
7120 {
7121 return x_hide_tip (!tooltip_reuse_hidden_frame);
7122 }
7123 \f
7124 /***********************************************************************
7125 File selection dialog
7126 ***********************************************************************/
7127
7128 #define FILE_NAME_TEXT_FIELD edt1
7129 #define FILE_NAME_COMBO_BOX cmb13
7130 #define FILE_NAME_LIST lst1
7131
7132 /* Callback for altering the behavior of the Open File dialog.
7133 Makes the Filename text field contain "Current Directory" and be
7134 read-only when "Directories" is selected in the filter. This
7135 allows us to work around the fact that the standard Open File
7136 dialog does not support directories. */
7137 static UINT_PTR CALLBACK
7138 file_dialog_callback (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
7139 {
7140 if (msg == WM_NOTIFY)
7141 {
7142 OFNOTIFYW * notify_w = (OFNOTIFYW *)lParam;
7143 OFNOTIFYA * notify_a = (OFNOTIFYA *)lParam;
7144 int dropdown_changed;
7145 int dir_index;
7146 #ifdef NTGUI_UNICODE
7147 const int use_unicode = 1;
7148 #else /* !NTGUI_UNICODE */
7149 int use_unicode = w32_unicode_filenames;
7150 #endif /* NTGUI_UNICODE */
7151
7152 /* Detect when the Filter dropdown is changed. */
7153 if (use_unicode)
7154 dropdown_changed =
7155 notify_w->hdr.code == CDN_TYPECHANGE
7156 || notify_w->hdr.code == CDN_INITDONE;
7157 else
7158 dropdown_changed =
7159 notify_a->hdr.code == CDN_TYPECHANGE
7160 || notify_a->hdr.code == CDN_INITDONE;
7161 if (dropdown_changed)
7162 {
7163 HWND dialog = GetParent (hwnd);
7164 HWND edit_control = GetDlgItem (dialog, FILE_NAME_TEXT_FIELD);
7165 HWND list = GetDlgItem (dialog, FILE_NAME_LIST);
7166 int hdr_code;
7167
7168 /* At least on Windows 7, the above attempt to get the window handle
7169 to the File Name Text Field fails. The following code does the
7170 job though. Note that this code is based on my examination of the
7171 window hierarchy using Microsoft Spy++. bk */
7172 if (edit_control == NULL)
7173 {
7174 HWND tmp = GetDlgItem (dialog, FILE_NAME_COMBO_BOX);
7175 if (tmp)
7176 {
7177 tmp = GetWindow (tmp, GW_CHILD);
7178 if (tmp)
7179 edit_control = GetWindow (tmp, GW_CHILD);
7180 }
7181 }
7182
7183 /* Directories is in index 2. */
7184 if (use_unicode)
7185 {
7186 dir_index = notify_w->lpOFN->nFilterIndex;
7187 hdr_code = notify_w->hdr.code;
7188 }
7189 else
7190 {
7191 dir_index = notify_a->lpOFN->nFilterIndex;
7192 hdr_code = notify_a->hdr.code;
7193 }
7194 if (dir_index == 2)
7195 {
7196 if (use_unicode)
7197 SendMessageW (dialog, CDM_SETCONTROLTEXT, FILE_NAME_TEXT_FIELD,
7198 (LPARAM)L"Current Directory");
7199 else
7200 SendMessageA (dialog, CDM_SETCONTROLTEXT, FILE_NAME_TEXT_FIELD,
7201 (LPARAM)"Current Directory");
7202 EnableWindow (edit_control, FALSE);
7203 /* Note that at least on Windows 7, the above call to EnableWindow
7204 disables the window that would ordinarily have focus. If we
7205 do not set focus to some other window here, focus will land in
7206 no man's land and the user will be unable to tab through the
7207 dialog box (pressing tab will only result in a beep).
7208 Avoid that problem by setting focus to the list here. */
7209 if (hdr_code == CDN_INITDONE)
7210 SetFocus (list);
7211 }
7212 else
7213 {
7214 /* Don't override default filename on init done. */
7215 if (hdr_code == CDN_TYPECHANGE)
7216 {
7217 if (use_unicode)
7218 SendMessageW (dialog, CDM_SETCONTROLTEXT,
7219 FILE_NAME_TEXT_FIELD, (LPARAM)L"");
7220 else
7221 SendMessageA (dialog, CDM_SETCONTROLTEXT,
7222 FILE_NAME_TEXT_FIELD, (LPARAM)"");
7223 }
7224 EnableWindow (edit_control, TRUE);
7225 }
7226 }
7227 }
7228 return 0;
7229 }
7230
7231 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
7232 doc: /* Read file name, prompting with PROMPT in directory DIR.
7233 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
7234 selection box, if specified. If MUSTMATCH is non-nil, the returned file
7235 or directory must exist.
7236
7237 This function is only defined on NS, MS Windows, and X Windows with the
7238 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
7239 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories.
7240 On Windows 7 and later, the file selection dialog "remembers" the last
7241 directory where the user selected a file, and will open that directory
7242 instead of DIR on subsequent invocations of this function with the same
7243 value of DIR as in previous invocations; this is standard Windows behavior. */)
7244 (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object only_dir_p)
7245 {
7246 /* Filter index: 1: All Files, 2: Directories only */
7247 static const wchar_t filter_w[] = L"All Files (*.*)\0*.*\0Directories\0*|*\0";
7248 static const char filter_a[] = "All Files (*.*)\0*.*\0Directories\0*|*\0";
7249
7250 Lisp_Object filename = default_filename;
7251 struct frame *f = SELECTED_FRAME ();
7252 BOOL file_opened = FALSE;
7253 Lisp_Object orig_dir = dir;
7254 Lisp_Object orig_prompt = prompt;
7255
7256 /* If we compile with _WIN32_WINNT set to 0x0400 (for NT4
7257 compatibility) we end up with the old file dialogs. Define a big
7258 enough struct for the new dialog to trick GetOpenFileName into
7259 giving us the new dialogs on newer versions of Windows. */
7260 struct {
7261 OPENFILENAMEW details;
7262 #if _WIN32_WINNT < 0x500 /* < win2k */
7263 PVOID pvReserved;
7264 DWORD dwReserved;
7265 DWORD FlagsEx;
7266 #endif /* < win2k */
7267 } new_file_details_w;
7268
7269 #ifdef NTGUI_UNICODE
7270 wchar_t filename_buf_w[32*1024 + 1]; // NT kernel maximum
7271 OPENFILENAMEW * file_details_w = &new_file_details_w.details;
7272 const int use_unicode = 1;
7273 #else /* not NTGUI_UNICODE */
7274 struct {
7275 OPENFILENAMEA details;
7276 #if _WIN32_WINNT < 0x500 /* < win2k */
7277 PVOID pvReserved;
7278 DWORD dwReserved;
7279 DWORD FlagsEx;
7280 #endif /* < win2k */
7281 } new_file_details_a;
7282 wchar_t filename_buf_w[MAX_PATH + 1], dir_w[MAX_PATH];
7283 char filename_buf_a[MAX_PATH + 1], dir_a[MAX_PATH];
7284 OPENFILENAMEW * file_details_w = &new_file_details_w.details;
7285 OPENFILENAMEA * file_details_a = &new_file_details_a.details;
7286 int use_unicode = w32_unicode_filenames;
7287 wchar_t *prompt_w;
7288 char *prompt_a;
7289 int len;
7290 char fname_ret[MAX_UTF8_PATH];
7291 #endif /* NTGUI_UNICODE */
7292
7293 {
7294 /* Note: under NTGUI_UNICODE, we do _NOT_ use ENCODE_FILE: the
7295 system file encoding expected by the platform APIs (e.g. Cygwin's
7296 POSIX implementation) may not be the same as the encoding expected
7297 by the Windows "ANSI" APIs! */
7298
7299 CHECK_STRING (prompt);
7300 CHECK_STRING (dir);
7301
7302 dir = Fexpand_file_name (dir, Qnil);
7303
7304 if (STRINGP (filename))
7305 filename = Ffile_name_nondirectory (filename);
7306 else
7307 filename = empty_unibyte_string;
7308
7309 #ifdef CYGWIN
7310 dir = Fcygwin_convert_file_name_to_windows (dir, Qt);
7311 if (SCHARS (filename) > 0)
7312 filename = Fcygwin_convert_file_name_to_windows (filename, Qnil);
7313 #endif
7314
7315 CHECK_STRING (dir);
7316 CHECK_STRING (filename);
7317
7318 /* The code in file_dialog_callback that attempts to set the text
7319 of the file name edit window when handling the CDN_INITDONE
7320 WM_NOTIFY message does not work. Setting filename to "Current
7321 Directory" in the only_dir_p case here does work however. */
7322 if (SCHARS (filename) == 0 && ! NILP (only_dir_p))
7323 filename = build_string ("Current Directory");
7324
7325 /* Convert the values we've computed so far to system form. */
7326 #ifdef NTGUI_UNICODE
7327 to_unicode (prompt, &prompt);
7328 to_unicode (dir, &dir);
7329 to_unicode (filename, &filename);
7330 if (SBYTES (filename) + 1 > sizeof (filename_buf_w))
7331 report_file_error ("filename too long", default_filename);
7332
7333 memcpy (filename_buf_w, SDATA (filename), SBYTES (filename) + 1);
7334 #else /* !NTGUI_UNICODE */
7335 prompt = ENCODE_FILE (prompt);
7336 dir = ENCODE_FILE (dir);
7337 filename = ENCODE_FILE (filename);
7338
7339 /* We modify these in-place, so make copies for safety. */
7340 dir = Fcopy_sequence (dir);
7341 unixtodos_filename (SSDATA (dir));
7342 filename = Fcopy_sequence (filename);
7343 unixtodos_filename (SSDATA (filename));
7344 if (SBYTES (filename) >= MAX_UTF8_PATH)
7345 report_file_error ("filename too long", default_filename);
7346 if (w32_unicode_filenames)
7347 {
7348 filename_to_utf16 (SSDATA (dir), dir_w);
7349 if (filename_to_utf16 (SSDATA (filename), filename_buf_w) != 0)
7350 {
7351 /* filename_to_utf16 sets errno to ENOENT when the file
7352 name is too long or cannot be converted to UTF-16. */
7353 if (errno == ENOENT && filename_buf_w[MAX_PATH - 1] != 0)
7354 report_file_error ("filename too long", default_filename);
7355 }
7356 len = pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
7357 SSDATA (prompt), -1, NULL, 0);
7358 if (len > 32768)
7359 len = 32768;
7360 prompt_w = alloca (len * sizeof (wchar_t));
7361 pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
7362 SSDATA (prompt), -1, prompt_w, len);
7363 }
7364 else
7365 {
7366 filename_to_ansi (SSDATA (dir), dir_a);
7367 if (filename_to_ansi (SSDATA (filename), filename_buf_a) != '\0')
7368 {
7369 /* filename_to_ansi sets errno to ENOENT when the file
7370 name is too long or cannot be converted to UTF-16. */
7371 if (errno == ENOENT && filename_buf_a[MAX_PATH - 1] != 0)
7372 report_file_error ("filename too long", default_filename);
7373 }
7374 len = pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
7375 SSDATA (prompt), -1, NULL, 0);
7376 if (len > 32768)
7377 len = 32768;
7378 prompt_w = alloca (len * sizeof (wchar_t));
7379 pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
7380 SSDATA (prompt), -1, prompt_w, len);
7381 len = pWideCharToMultiByte (CP_ACP, 0, prompt_w, -1, NULL, 0, NULL, NULL);
7382 if (len > 32768)
7383 len = 32768;
7384 prompt_a = alloca (len);
7385 pWideCharToMultiByte (CP_ACP, 0, prompt_w, -1, prompt_a, len, NULL, NULL);
7386 }
7387 #endif /* NTGUI_UNICODE */
7388
7389 /* Fill in the structure for the call to GetOpenFileName below.
7390 For NTGUI_UNICODE builds (which run only on NT), we just use
7391 the actual size of the structure. For non-NTGUI_UNICODE
7392 builds, we tell the OS we're using an old version of the
7393 structure if the OS isn't new enough to support the newer
7394 version. */
7395 if (use_unicode)
7396 {
7397 memset (&new_file_details_w, 0, sizeof (new_file_details_w));
7398 if (w32_major_version > 4 && w32_major_version < 95)
7399 file_details_w->lStructSize = sizeof (new_file_details_w);
7400 else
7401 file_details_w->lStructSize = sizeof (*file_details_w);
7402 /* Set up the inout parameter for the selected file name. */
7403 file_details_w->lpstrFile = filename_buf_w;
7404 file_details_w->nMaxFile =
7405 sizeof (filename_buf_w) / sizeof (*filename_buf_w);
7406 file_details_w->hwndOwner = FRAME_W32_WINDOW (f);
7407 /* Undocumented Bug in Common File Dialog:
7408 If a filter is not specified, shell links are not resolved. */
7409 file_details_w->lpstrFilter = filter_w;
7410 #ifdef NTGUI_UNICODE
7411 file_details_w->lpstrInitialDir = (wchar_t*) SDATA (dir);
7412 file_details_w->lpstrTitle = (guichar_t*) SDATA (prompt);
7413 #else
7414 file_details_w->lpstrInitialDir = dir_w;
7415 file_details_w->lpstrTitle = prompt_w;
7416 #endif
7417 file_details_w->nFilterIndex = NILP (only_dir_p) ? 1 : 2;
7418 file_details_w->Flags = (OFN_HIDEREADONLY | OFN_NOCHANGEDIR
7419 | OFN_EXPLORER | OFN_ENABLEHOOK);
7420 if (!NILP (mustmatch))
7421 {
7422 /* Require that the path to the parent directory exists. */
7423 file_details_w->Flags |= OFN_PATHMUSTEXIST;
7424 /* If we are looking for a file, require that it exists. */
7425 if (NILP (only_dir_p))
7426 file_details_w->Flags |= OFN_FILEMUSTEXIST;
7427 }
7428 }
7429 #ifndef NTGUI_UNICODE
7430 else
7431 {
7432 memset (&new_file_details_a, 0, sizeof (new_file_details_a));
7433 if (w32_major_version > 4 && w32_major_version < 95)
7434 file_details_a->lStructSize = sizeof (new_file_details_a);
7435 else
7436 file_details_a->lStructSize = sizeof (*file_details_a);
7437 file_details_a->lpstrFile = filename_buf_a;
7438 file_details_a->nMaxFile =
7439 sizeof (filename_buf_a) / sizeof (*filename_buf_a);
7440 file_details_a->hwndOwner = FRAME_W32_WINDOW (f);
7441 file_details_a->lpstrFilter = filter_a;
7442 file_details_a->lpstrInitialDir = dir_a;
7443 file_details_a->lpstrTitle = prompt_a;
7444 file_details_a->nFilterIndex = NILP (only_dir_p) ? 1 : 2;
7445 file_details_a->Flags = (OFN_HIDEREADONLY | OFN_NOCHANGEDIR
7446 | OFN_EXPLORER | OFN_ENABLEHOOK);
7447 if (!NILP (mustmatch))
7448 {
7449 /* Require that the path to the parent directory exists. */
7450 file_details_a->Flags |= OFN_PATHMUSTEXIST;
7451 /* If we are looking for a file, require that it exists. */
7452 if (NILP (only_dir_p))
7453 file_details_a->Flags |= OFN_FILEMUSTEXIST;
7454 }
7455 }
7456 #endif /* !NTGUI_UNICODE */
7457
7458 {
7459 int count = SPECPDL_INDEX ();
7460 /* Prevent redisplay. */
7461 specbind (Qinhibit_redisplay, Qt);
7462 block_input ();
7463 if (use_unicode)
7464 {
7465 file_details_w->lpfnHook = file_dialog_callback;
7466
7467 file_opened = GetOpenFileNameW (file_details_w);
7468 }
7469 #ifndef NTGUI_UNICODE
7470 else
7471 {
7472 file_details_a->lpfnHook = file_dialog_callback;
7473
7474 file_opened = GetOpenFileNameA (file_details_a);
7475 }
7476 #endif /* !NTGUI_UNICODE */
7477 unblock_input ();
7478 unbind_to (count, Qnil);
7479 }
7480
7481 if (file_opened)
7482 {
7483 /* Get an Emacs string from the value Windows gave us. */
7484 #ifdef NTGUI_UNICODE
7485 filename = from_unicode_buffer (filename_buf_w);
7486 #else /* !NTGUI_UNICODE */
7487 if (use_unicode)
7488 filename_from_utf16 (filename_buf_w, fname_ret);
7489 else
7490 filename_from_ansi (filename_buf_a, fname_ret);
7491 dostounix_filename (fname_ret);
7492 filename = DECODE_FILE (build_unibyte_string (fname_ret));
7493 #endif /* NTGUI_UNICODE */
7494
7495 #ifdef CYGWIN
7496 filename = Fcygwin_convert_file_name_from_windows (filename, Qt);
7497 #endif /* CYGWIN */
7498
7499 /* Strip the dummy filename off the end of the string if we
7500 added it to select a directory. */
7501 if ((use_unicode && file_details_w->nFilterIndex == 2)
7502 #ifndef NTGUI_UNICODE
7503 || (!use_unicode && file_details_a->nFilterIndex == 2)
7504 #endif
7505 )
7506 filename = Ffile_name_directory (filename);
7507 }
7508 /* User canceled the dialog without making a selection. */
7509 else if (!CommDlgExtendedError ())
7510 filename = Qnil;
7511 /* An error occurred, fallback on reading from the mini-buffer. */
7512 else
7513 filename = Fcompleting_read (
7514 orig_prompt,
7515 intern ("read-file-name-internal"),
7516 orig_dir,
7517 mustmatch,
7518 orig_dir,
7519 Qfile_name_history,
7520 default_filename,
7521 Qnil);
7522 }
7523
7524 /* Make "Cancel" equivalent to C-g. */
7525 if (NILP (filename))
7526 Fsignal (Qquit, Qnil);
7527
7528 return filename;
7529 }
7530
7531 \f
7532 #ifdef WINDOWSNT
7533 /* Moving files to the system recycle bin.
7534 Used by `move-file-to-trash' instead of the default moving to ~/.Trash */
7535 DEFUN ("system-move-file-to-trash", Fsystem_move_file_to_trash,
7536 Ssystem_move_file_to_trash, 1, 1, 0,
7537 doc: /* Move file or directory named FILENAME to the recycle bin. */)
7538 (Lisp_Object filename)
7539 {
7540 Lisp_Object handler;
7541 Lisp_Object encoded_file;
7542 Lisp_Object operation;
7543
7544 operation = Qdelete_file;
7545 if (!NILP (Ffile_directory_p (filename))
7546 && NILP (Ffile_symlink_p (filename)))
7547 {
7548 operation = intern ("delete-directory");
7549 filename = Fdirectory_file_name (filename);
7550 }
7551
7552 /* Must have fully qualified file names for moving files to Recycle
7553 Bin. */
7554 filename = Fexpand_file_name (filename, Qnil);
7555
7556 handler = Ffind_file_name_handler (filename, operation);
7557 if (!NILP (handler))
7558 return call2 (handler, operation, filename);
7559 else
7560 {
7561 const char * path;
7562 int result;
7563
7564 encoded_file = ENCODE_FILE (filename);
7565
7566 path = map_w32_filename (SSDATA (encoded_file), NULL);
7567
7568 /* The Unicode version of SHFileOperation is not supported on
7569 Windows 9X. */
7570 if (w32_unicode_filenames && os_subtype != OS_9X)
7571 {
7572 SHFILEOPSTRUCTW file_op_w;
7573 /* We need one more element beyond MAX_PATH because this is
7574 a list of file names, with the last element double-null
7575 terminated. */
7576 wchar_t tmp_path_w[MAX_PATH + 1];
7577
7578 memset (tmp_path_w, 0, sizeof (tmp_path_w));
7579 filename_to_utf16 (path, tmp_path_w);
7580
7581 /* On Windows, write permission is required to delete/move files. */
7582 _wchmod (tmp_path_w, 0666);
7583
7584 memset (&file_op_w, 0, sizeof (file_op_w));
7585 file_op_w.hwnd = HWND_DESKTOP;
7586 file_op_w.wFunc = FO_DELETE;
7587 file_op_w.pFrom = tmp_path_w;
7588 file_op_w.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_ALLOWUNDO
7589 | FOF_NOERRORUI | FOF_NO_CONNECTED_ELEMENTS;
7590 file_op_w.fAnyOperationsAborted = FALSE;
7591
7592 result = SHFileOperationW (&file_op_w);
7593 }
7594 else
7595 {
7596 SHFILEOPSTRUCTA file_op_a;
7597 char tmp_path_a[MAX_PATH + 1];
7598
7599 memset (tmp_path_a, 0, sizeof (tmp_path_a));
7600 filename_to_ansi (path, tmp_path_a);
7601
7602 /* If a file cannot be represented in ANSI codepage, don't
7603 let them inadvertently delete other files because some
7604 characters are interpreted as a wildcards. */
7605 if (_mbspbrk ((unsigned char *)tmp_path_a,
7606 (const unsigned char *)"?*"))
7607 result = ERROR_FILE_NOT_FOUND;
7608 else
7609 {
7610 _chmod (tmp_path_a, 0666);
7611
7612 memset (&file_op_a, 0, sizeof (file_op_a));
7613 file_op_a.hwnd = HWND_DESKTOP;
7614 file_op_a.wFunc = FO_DELETE;
7615 file_op_a.pFrom = tmp_path_a;
7616 file_op_a.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_ALLOWUNDO
7617 | FOF_NOERRORUI | FOF_NO_CONNECTED_ELEMENTS;
7618 file_op_a.fAnyOperationsAborted = FALSE;
7619
7620 result = SHFileOperationA (&file_op_a);
7621 }
7622 }
7623 if (result != 0)
7624 report_file_error ("Removing old name", list1 (filename));
7625 }
7626 return Qnil;
7627 }
7628
7629 #endif /* WINDOWSNT */
7630
7631 \f
7632 /***********************************************************************
7633 w32 specialized functions
7634 ***********************************************************************/
7635
7636 DEFUN ("w32-send-sys-command", Fw32_send_sys_command,
7637 Sw32_send_sys_command, 1, 2, 0,
7638 doc: /* Send frame a Windows WM_SYSCOMMAND message of type COMMAND.
7639 Some useful values for COMMAND are #xf030 to maximize frame (#xf020
7640 to minimize), #xf120 to restore frame to original size, and #xf100
7641 to activate the menubar for keyboard access. #xf140 activates the
7642 screen saver if defined.
7643
7644 If optional parameter FRAME is not specified, use selected frame. */)
7645 (Lisp_Object command, Lisp_Object frame)
7646 {
7647 struct frame *f = decode_window_system_frame (frame);
7648
7649 CHECK_NUMBER (command);
7650
7651 if (FRAME_W32_P (f))
7652 PostMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, XINT (command), 0);
7653
7654 return Qnil;
7655 }
7656
7657 DEFUN ("w32-shell-execute", Fw32_shell_execute, Sw32_shell_execute, 2, 4, 0,
7658 doc: /* Get Windows to perform OPERATION on DOCUMENT.
7659 This is a wrapper around the ShellExecute system function, which
7660 invokes the application registered to handle OPERATION for DOCUMENT.
7661
7662 OPERATION is either nil or a string that names a supported operation.
7663 What operations can be used depends on the particular DOCUMENT and its
7664 handler application, but typically it is one of the following common
7665 operations:
7666
7667 \"open\" - open DOCUMENT, which could be a file, a directory, or an
7668 executable program (application). If it is an application,
7669 that application is launched in the current buffer's default
7670 directory. Otherwise, the application associated with
7671 DOCUMENT is launched in the buffer's default directory.
7672 \"opennew\" - like \"open\", but instruct the application to open
7673 DOCUMENT in a new window.
7674 \"openas\" - open the \"Open With\" dialog for DOCUMENT.
7675 \"print\" - print DOCUMENT, which must be a file.
7676 \"printto\" - print DOCUMENT, which must be a file, to a specified printer.
7677 The printer should be provided in PARAMETERS, see below.
7678 \"explore\" - start the Windows Explorer on DOCUMENT.
7679 \"edit\" - launch an editor and open DOCUMENT for editing; which
7680 editor is launched depends on the association for the
7681 specified DOCUMENT.
7682 \"find\" - initiate search starting from DOCUMENT, which must specify
7683 a directory.
7684 \"delete\" - move DOCUMENT, a file or a directory, to Recycle Bin.
7685 \"copy\" - copy DOCUMENT, which must be a file or a directory, into
7686 the clipboard.
7687 \"cut\" - move DOCUMENT, a file or a directory, into the clipboard.
7688 \"paste\" - paste the file whose name is in the clipboard into DOCUMENT,
7689 which must be a directory.
7690 \"pastelink\"
7691 - create a shortcut in DOCUMENT (which must be a directory)
7692 the file or directory whose name is in the clipboard.
7693 \"runas\" - run DOCUMENT, which must be an excutable file, with
7694 elevated privileges (a.k.a. \"as Administrator\").
7695 \"properties\"
7696 - open the property sheet dialog for DOCUMENT.
7697 nil - invoke the default OPERATION, or \"open\" if default is
7698 not defined or unavailable.
7699
7700 DOCUMENT is typically the name of a document file or a URL, but can
7701 also be an executable program to run, or a directory to open in the
7702 Windows Explorer. If it is a file or a directory, it must be a local
7703 one; this function does not support remote file names.
7704
7705 If DOCUMENT is an executable program, the optional third arg PARAMETERS
7706 can be a string containing command line parameters, separated by blanks,
7707 that will be passed to the program. Some values of OPERATION also require
7708 parameters (e.g., \"printto\" requires the printer address). Otherwise,
7709 PARAMETERS should be nil or unspecified. Note that double quote characters
7710 in PARAMETERS must each be enclosed in 2 additional quotes, as in \"\"\".
7711
7712 Optional fourth argument SHOW-FLAG can be used to control how the
7713 application will be displayed when it is invoked. If SHOW-FLAG is nil
7714 or unspecified, the application is displayed as if SHOW-FLAG of 10 was
7715 specified, otherwise it is an integer between 0 and 11 representing
7716 a ShowWindow flag:
7717
7718 0 - start hidden
7719 1 - start as normal-size window
7720 3 - start in a maximized window
7721 6 - start in a minimized window
7722 10 - start as the application itself specifies; this is the default. */)
7723 (Lisp_Object operation, Lisp_Object document, Lisp_Object parameters, Lisp_Object show_flag)
7724 {
7725 char *errstr;
7726 Lisp_Object current_dir = BVAR (current_buffer, directory);;
7727 wchar_t *doc_w = NULL, *params_w = NULL, *ops_w = NULL;
7728 #ifdef CYGWIN
7729 intptr_t result;
7730 #else
7731 int use_unicode = w32_unicode_filenames;
7732 char *doc_a = NULL, *params_a = NULL, *ops_a = NULL;
7733 Lisp_Object absdoc, handler;
7734 BOOL success;
7735 #endif
7736
7737 CHECK_STRING (document);
7738
7739 #ifdef CYGWIN
7740 current_dir = Fcygwin_convert_file_name_to_windows (current_dir, Qt);
7741 document = Fcygwin_convert_file_name_to_windows (document, Qt);
7742
7743 /* Encode filename, current directory and parameters. */
7744 current_dir = GUI_ENCODE_FILE (current_dir);
7745 document = GUI_ENCODE_FILE (document);
7746 doc_w = GUI_SDATA (document);
7747 if (STRINGP (parameters))
7748 {
7749 parameters = GUI_ENCODE_SYSTEM (parameters);
7750 params_w = GUI_SDATA (parameters);
7751 }
7752 if (STRINGP (operation))
7753 {
7754 operation = GUI_ENCODE_SYSTEM (operation);
7755 ops_w = GUI_SDATA (operation);
7756 }
7757 result = (intptr_t) ShellExecuteW (NULL, ops_w, doc_w, params_w,
7758 GUI_SDATA (current_dir),
7759 (INTEGERP (show_flag)
7760 ? XINT (show_flag) : SW_SHOWDEFAULT));
7761
7762 if (result > 32)
7763 return Qt;
7764
7765 switch (result)
7766 {
7767 case SE_ERR_ACCESSDENIED:
7768 errstr = w32_strerror (ERROR_ACCESS_DENIED);
7769 break;
7770 case SE_ERR_ASSOCINCOMPLETE:
7771 case SE_ERR_NOASSOC:
7772 errstr = w32_strerror (ERROR_NO_ASSOCIATION);
7773 break;
7774 case SE_ERR_DDEBUSY:
7775 case SE_ERR_DDEFAIL:
7776 errstr = w32_strerror (ERROR_DDE_FAIL);
7777 break;
7778 case SE_ERR_DDETIMEOUT:
7779 errstr = w32_strerror (ERROR_TIMEOUT);
7780 break;
7781 case SE_ERR_DLLNOTFOUND:
7782 errstr = w32_strerror (ERROR_DLL_NOT_FOUND);
7783 break;
7784 case SE_ERR_FNF:
7785 errstr = w32_strerror (ERROR_FILE_NOT_FOUND);
7786 break;
7787 case SE_ERR_OOM:
7788 errstr = w32_strerror (ERROR_NOT_ENOUGH_MEMORY);
7789 break;
7790 case SE_ERR_PNF:
7791 errstr = w32_strerror (ERROR_PATH_NOT_FOUND);
7792 break;
7793 case SE_ERR_SHARE:
7794 errstr = w32_strerror (ERROR_SHARING_VIOLATION);
7795 break;
7796 default:
7797 errstr = w32_strerror (0);
7798 break;
7799 }
7800
7801 #else /* !CYGWIN */
7802
7803 const char file_url_str[] = "file:///";
7804 const int file_url_len = sizeof (file_url_str) - 1;
7805 int doclen;
7806
7807 if (strncmp (SSDATA (document), file_url_str, file_url_len) == 0)
7808 {
7809 /* Passing "file:///" URLs to ShellExecute causes shlwapi.dll to
7810 start a thread in some rare system configurations, for
7811 unknown reasons. That thread is started in the context of
7812 the Emacs process, but out of control of our code, and seems
7813 to never exit afterwards. Each such thread reserves 8MB of
7814 stack space (because that's the value recorded in the Emacs
7815 executable at link time: Emacs needs a large stack). So a
7816 large enough number of invocations of w32-shell-execute can
7817 potentially cause the Emacs process to run out of available
7818 address space, which is nasty. To work around this, we
7819 convert such URLs to local file names, which seems to prevent
7820 those threads from starting. See bug #20220. */
7821 char *p = SSDATA (document) + file_url_len;
7822
7823 if (c_isalpha (*p) && p[1] == ':' && IS_DIRECTORY_SEP (p[2]))
7824 document = Fsubstring_no_properties (document,
7825 make_number (file_url_len), Qnil);
7826 }
7827 /* We have a situation here. If DOCUMENT is a relative file name,
7828 but its name includes leading directories, i.e. it lives not in
7829 CURRENT_DIR, but in its subdirectory, then ShellExecute below
7830 will fail to find it. So we need to make the file name is
7831 absolute. But DOCUMENT does not have to be a file, it can be a
7832 URL, for example. So we make it absolute only if it is an
7833 existing file; if it is a file that does not exist, tough. */
7834 absdoc = Fexpand_file_name (document, Qnil);
7835 /* Don't call file handlers for file-exists-p, since they might
7836 attempt to access the file, which could fail or produce undesired
7837 consequences, see bug#16558 for an example. */
7838 handler = Ffind_file_name_handler (absdoc, Qfile_exists_p);
7839 if (NILP (handler))
7840 {
7841 Lisp_Object absdoc_encoded = ENCODE_FILE (absdoc);
7842
7843 if (faccessat (AT_FDCWD, SSDATA (absdoc_encoded), F_OK, AT_EACCESS) == 0)
7844 {
7845 /* ShellExecute fails if DOCUMENT is a UNC with forward
7846 slashes (expand-file-name above converts all backslashes
7847 to forward slashes). Now that we know DOCUMENT is a
7848 file, we can mirror all forward slashes into backslashes. */
7849 unixtodos_filename (SSDATA (absdoc_encoded));
7850 document = absdoc_encoded;
7851 }
7852 else
7853 document = ENCODE_FILE (document);
7854 }
7855 else
7856 document = ENCODE_FILE (document);
7857
7858 current_dir = ENCODE_FILE (current_dir);
7859 /* Cannot use filename_to_utf16/ansi with DOCUMENT, since it could
7860 be a URL that is not limited to MAX_PATH chararcters. */
7861 doclen = pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
7862 SSDATA (document), -1, NULL, 0);
7863 doc_w = xmalloc (doclen * sizeof (wchar_t));
7864 pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
7865 SSDATA (document), -1, doc_w, doclen);
7866 if (use_unicode)
7867 {
7868 wchar_t current_dir_w[MAX_PATH];
7869 SHELLEXECUTEINFOW shexinfo_w;
7870
7871 /* Encode the current directory and parameters, and convert
7872 operation to UTF-16. */
7873 filename_to_utf16 (SSDATA (current_dir), current_dir_w);
7874 if (STRINGP (parameters))
7875 {
7876 int len;
7877
7878 parameters = ENCODE_SYSTEM (parameters);
7879 len = pMultiByteToWideChar (CP_ACP, multiByteToWideCharFlags,
7880 SSDATA (parameters), -1, NULL, 0);
7881 if (len > 32768)
7882 len = 32768;
7883 params_w = alloca (len * sizeof (wchar_t));
7884 pMultiByteToWideChar (CP_ACP, multiByteToWideCharFlags,
7885 SSDATA (parameters), -1, params_w, len);
7886 params_w[len - 1] = 0;
7887 }
7888 if (STRINGP (operation))
7889 {
7890 /* Assume OPERATION is pure ASCII. */
7891 const char *s = SSDATA (operation);
7892 wchar_t *d;
7893 int len = SBYTES (operation) + 1;
7894
7895 if (len > 32768)
7896 len = 32768;
7897 d = ops_w = alloca (len * sizeof (wchar_t));
7898 while (d < ops_w + len - 1)
7899 *d++ = *s++;
7900 *d = 0;
7901 }
7902
7903 /* Using ShellExecuteEx and setting the SEE_MASK_INVOKEIDLIST
7904 flag succeeds with more OPERATIONs (a.k.a. "verbs"), as it is
7905 able to invoke verbs from shortcut menu extensions, not just
7906 static verbs listed in the Registry. */
7907 memset (&shexinfo_w, 0, sizeof (shexinfo_w));
7908 shexinfo_w.cbSize = sizeof (shexinfo_w);
7909 shexinfo_w.fMask =
7910 SEE_MASK_INVOKEIDLIST | SEE_MASK_FLAG_DDEWAIT | SEE_MASK_FLAG_NO_UI;
7911 shexinfo_w.hwnd = NULL;
7912 shexinfo_w.lpVerb = ops_w;
7913 shexinfo_w.lpFile = doc_w;
7914 shexinfo_w.lpParameters = params_w;
7915 shexinfo_w.lpDirectory = current_dir_w;
7916 shexinfo_w.nShow =
7917 (INTEGERP (show_flag) ? XINT (show_flag) : SW_SHOWDEFAULT);
7918 success = ShellExecuteExW (&shexinfo_w);
7919 xfree (doc_w);
7920 }
7921 else
7922 {
7923 char current_dir_a[MAX_PATH];
7924 SHELLEXECUTEINFOA shexinfo_a;
7925 int codepage = codepage_for_filenames (NULL);
7926 int ldoc_a = pWideCharToMultiByte (codepage, 0, doc_w, -1, NULL, 0,
7927 NULL, NULL);
7928
7929 doc_a = xmalloc (ldoc_a);
7930 pWideCharToMultiByte (codepage, 0, doc_w, -1, doc_a, ldoc_a, NULL, NULL);
7931 filename_to_ansi (SSDATA (current_dir), current_dir_a);
7932 if (STRINGP (parameters))
7933 {
7934 parameters = ENCODE_SYSTEM (parameters);
7935 params_a = SSDATA (parameters);
7936 }
7937 if (STRINGP (operation))
7938 {
7939 /* Assume OPERATION is pure ASCII. */
7940 ops_a = SSDATA (operation);
7941 }
7942 memset (&shexinfo_a, 0, sizeof (shexinfo_a));
7943 shexinfo_a.cbSize = sizeof (shexinfo_a);
7944 shexinfo_a.fMask =
7945 SEE_MASK_INVOKEIDLIST | SEE_MASK_FLAG_DDEWAIT | SEE_MASK_FLAG_NO_UI;
7946 shexinfo_a.hwnd = NULL;
7947 shexinfo_a.lpVerb = ops_a;
7948 shexinfo_a.lpFile = doc_a;
7949 shexinfo_a.lpParameters = params_a;
7950 shexinfo_a.lpDirectory = current_dir_a;
7951 shexinfo_a.nShow =
7952 (INTEGERP (show_flag) ? XINT (show_flag) : SW_SHOWDEFAULT);
7953 success = ShellExecuteExA (&shexinfo_a);
7954 xfree (doc_w);
7955 xfree (doc_a);
7956 }
7957
7958 if (success)
7959 return Qt;
7960
7961 errstr = w32_strerror (0);
7962
7963 #endif /* !CYGWIN */
7964
7965 /* The error string might be encoded in the locale's encoding. */
7966 if (!NILP (Vlocale_coding_system))
7967 {
7968 Lisp_Object decoded =
7969 code_convert_string_norecord (build_unibyte_string (errstr),
7970 Vlocale_coding_system, 0);
7971 errstr = SSDATA (decoded);
7972 }
7973 error ("ShellExecute failed: %s", errstr);
7974 }
7975
7976 /* Lookup virtual keycode from string representing the name of a
7977 non-ascii keystroke into the corresponding virtual key, using
7978 lispy_function_keys. */
7979 static int
7980 lookup_vk_code (char *key)
7981 {
7982 int i;
7983
7984 for (i = 0; i < 256; i++)
7985 if (lispy_function_keys[i]
7986 && strcmp (lispy_function_keys[i], key) == 0)
7987 return i;
7988
7989 if (w32_kbdhook_active)
7990 {
7991 /* Alphanumerics map to themselves. */
7992 if (key[1] == 0)
7993 {
7994 if (key[0] >= 'A' && key[0] <= 'Z' ||
7995 key[0] >= '0' && key[0] <= '9')
7996 return key[0];
7997 if (key[0] >= 'a' && key[0] <= 'z')
7998 return toupper(key[0]);
7999 }
8000 }
8001
8002 return -1;
8003 }
8004
8005 /* Convert a one-element vector style key sequence to a hot key
8006 definition. */
8007 static Lisp_Object
8008 w32_parse_and_hook_hot_key (Lisp_Object key, int hook)
8009 {
8010 /* Copied from Fdefine_key and store_in_keymap. */
8011 register Lisp_Object c;
8012 int vk_code;
8013 int lisp_modifiers;
8014 int w32_modifiers;
8015 Lisp_Object res = Qnil;
8016 char* vkname;
8017
8018 CHECK_VECTOR (key);
8019
8020 if (ASIZE (key) != 1)
8021 return Qnil;
8022
8023 c = AREF (key, 0);
8024
8025 if (CONSP (c) && lucid_event_type_list_p (c))
8026 c = Fevent_convert_list (c);
8027
8028 if (! INTEGERP (c) && ! SYMBOLP (c))
8029 error ("Key definition is invalid");
8030
8031 /* Work out the base key and the modifiers. */
8032 if (SYMBOLP (c))
8033 {
8034 c = parse_modifiers (c);
8035 lisp_modifiers = XINT (Fcar (Fcdr (c)));
8036 c = Fcar (c);
8037 if (!SYMBOLP (c))
8038 emacs_abort ();
8039 vkname = SSDATA (SYMBOL_NAME (c));
8040 /* [s-], [M-], [h-]: Register all keys for this modifier */
8041 if (w32_kbdhook_active && vkname[0] == 0)
8042 vk_code = VK_ANY;
8043 else
8044 vk_code = lookup_vk_code (vkname);
8045 }
8046 else if (INTEGERP (c))
8047 {
8048 lisp_modifiers = XINT (c) & ~CHARACTERBITS;
8049 /* Many ascii characters are their own virtual key code. */
8050 vk_code = XINT (c) & CHARACTERBITS;
8051 }
8052
8053 if (vk_code < 0 || vk_code > 255)
8054 return Qnil;
8055
8056 if ((lisp_modifiers & meta_modifier) != 0
8057 && !NILP (Vw32_alt_is_meta))
8058 lisp_modifiers |= alt_modifier;
8059
8060 /* Supply defs missing from mingw32. */
8061 #ifndef MOD_ALT
8062 #define MOD_ALT 0x0001
8063 #define MOD_CONTROL 0x0002
8064 #define MOD_SHIFT 0x0004
8065 #define MOD_WIN 0x0008
8066 #endif
8067
8068 if (w32_kbdhook_active)
8069 {
8070 /* Register Alt-x combinations. */
8071 if (lisp_modifiers & alt_modifier)
8072 {
8073 hook_w32_key (hook, VK_MENU, vk_code);
8074 res = Qt;
8075 }
8076 /* Register Win-x combinations based on modifier mappings. */
8077 if (((lisp_modifiers & hyper_modifier)
8078 && EQ (Vw32_lwindow_modifier, Qhyper))
8079 || ((lisp_modifiers & super_modifier)
8080 && EQ (Vw32_lwindow_modifier, Qsuper)))
8081 {
8082 hook_w32_key (hook, VK_LWIN, vk_code);
8083 res = Qt;
8084 }
8085 if (((lisp_modifiers & hyper_modifier)
8086 && EQ (Vw32_rwindow_modifier, Qhyper))
8087 || ((lisp_modifiers & super_modifier)
8088 && EQ (Vw32_rwindow_modifier, Qsuper)))
8089 {
8090 hook_w32_key (hook, VK_RWIN, vk_code);
8091 res = Qt;
8092 }
8093 return res;
8094 }
8095 else
8096 {
8097 /* Convert lisp modifiers to Windows hot-key form. */
8098 w32_modifiers = (lisp_modifiers & hyper_modifier) ? MOD_WIN : 0;
8099 w32_modifiers |= (lisp_modifiers & alt_modifier) ? MOD_ALT : 0;
8100 w32_modifiers |= (lisp_modifiers & ctrl_modifier) ? MOD_CONTROL : 0;
8101 w32_modifiers |= (lisp_modifiers & shift_modifier) ? MOD_SHIFT : 0;
8102
8103 return HOTKEY (vk_code, w32_modifiers);
8104 }
8105 }
8106
8107 DEFUN ("w32-register-hot-key", Fw32_register_hot_key,
8108 Sw32_register_hot_key, 1, 1, 0,
8109 doc: /* Register KEY as a hot-key combination.
8110 Certain key combinations like Alt-Tab and Win-R are reserved for
8111 system use on Windows, and therefore are normally intercepted by the
8112 system. These key combinations can be received by registering them
8113 as hot-keys, except for Win-L which always locks the computer.
8114
8115 On Windows 98 and ME, KEY must be a one element key definition in
8116 vector form that would be acceptable to `define-key' (e.g. [A-tab] for
8117 Alt-Tab). The meta modifier is interpreted as Alt if
8118 `w32-alt-is-meta' is t, and hyper is always interpreted as the Windows
8119 modifier keys. The return value is the hotkey-id if registered, otherwise nil.
8120
8121 On Windows versions since NT, KEY can also be specified as [M-], [s-] or
8122 [h-] to indicate that all combinations of that key should be processed
8123 by Emacs instead of the operating system. The super and hyper
8124 modifiers are interpreted according to the current values of
8125 `w32-lwindow-modifier' and `w32-rwindow-modifier'. For instance,
8126 setting `w32-lwindow-modifier' to `super' and then calling
8127 `(register-hot-key [s-])' grabs all combinations of the left Windows
8128 key to Emacs, but leaves the right Windows key free for the operating
8129 system keyboard shortcuts. The return value is t if the call affected
8130 any key combinations, otherwise nil. */)
8131 (Lisp_Object key)
8132 {
8133 key = w32_parse_and_hook_hot_key (key, 1);
8134
8135 if (!w32_kbdhook_active
8136 && !NILP (key) && NILP (Fmemq (key, w32_grabbed_keys)))
8137 {
8138 /* Reuse an empty slot if possible. */
8139 Lisp_Object item = Fmemq (Qnil, w32_grabbed_keys);
8140
8141 /* Safe to add new key to list, even if we have focus. */
8142 if (NILP (item))
8143 w32_grabbed_keys = Fcons (key, w32_grabbed_keys);
8144 else
8145 XSETCAR (item, key);
8146
8147 /* Notify input thread about new hot-key definition, so that it
8148 takes effect without needing to switch focus. */
8149 PostThreadMessage (dwWindowsThreadId, WM_EMACS_REGISTER_HOT_KEY,
8150 (WPARAM) XINT (key), 0);
8151 }
8152
8153 return key;
8154 }
8155
8156 DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key,
8157 Sw32_unregister_hot_key, 1, 1, 0,
8158 doc: /* Unregister KEY as a hot-key combination. */)
8159 (Lisp_Object key)
8160 {
8161 Lisp_Object item;
8162
8163 if (!INTEGERP (key))
8164 key = w32_parse_and_hook_hot_key (key, 0);
8165
8166 if (w32_kbdhook_active)
8167 return key;
8168
8169 item = Fmemq (key, w32_grabbed_keys);
8170
8171 if (!NILP (item))
8172 {
8173 LPARAM lparam;
8174
8175 eassert (CONSP (item));
8176 /* Pass the tail of the list as a pointer to a Lisp_Cons cell,
8177 so that it works in a --with-wide-int build as well. */
8178 lparam = (LPARAM) XUNTAG (item, Lisp_Cons);
8179
8180 /* Notify input thread about hot-key definition being removed, so
8181 that it takes effect without needing focus switch. */
8182 if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_UNREGISTER_HOT_KEY,
8183 (WPARAM) XINT (XCAR (item)), lparam))
8184 {
8185 MSG msg;
8186 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
8187 }
8188 return Qt;
8189 }
8190 return Qnil;
8191 }
8192
8193 DEFUN ("w32-registered-hot-keys", Fw32_registered_hot_keys,
8194 Sw32_registered_hot_keys, 0, 0, 0,
8195 doc: /* Return list of registered hot-key IDs. */)
8196 (void)
8197 {
8198 return Fdelq (Qnil, Fcopy_sequence (w32_grabbed_keys));
8199 }
8200
8201 DEFUN ("w32-reconstruct-hot-key", Fw32_reconstruct_hot_key,
8202 Sw32_reconstruct_hot_key, 1, 1, 0,
8203 doc: /* Convert hot-key ID to a lisp key combination.
8204 usage: (w32-reconstruct-hot-key ID) */)
8205 (Lisp_Object hotkeyid)
8206 {
8207 int vk_code, w32_modifiers;
8208 Lisp_Object key;
8209
8210 CHECK_NUMBER (hotkeyid);
8211
8212 vk_code = HOTKEY_VK_CODE (hotkeyid);
8213 w32_modifiers = HOTKEY_MODIFIERS (hotkeyid);
8214
8215 if (vk_code < 256 && lispy_function_keys[vk_code])
8216 key = intern (lispy_function_keys[vk_code]);
8217 else
8218 key = make_number (vk_code);
8219
8220 key = Fcons (key, Qnil);
8221 if (w32_modifiers & MOD_SHIFT)
8222 key = Fcons (Qshift, key);
8223 if (w32_modifiers & MOD_CONTROL)
8224 key = Fcons (Qctrl, key);
8225 if (w32_modifiers & MOD_ALT)
8226 key = Fcons (NILP (Vw32_alt_is_meta) ? Qalt : Qmeta, key);
8227 if (w32_modifiers & MOD_WIN)
8228 key = Fcons (Qhyper, key);
8229
8230 return key;
8231 }
8232
8233 DEFUN ("w32-toggle-lock-key", Fw32_toggle_lock_key,
8234 Sw32_toggle_lock_key, 1, 2, 0,
8235 doc: /* Toggle the state of the lock key KEY.
8236 KEY can be `capslock', `kp-numlock', or `scroll'.
8237 If the optional parameter NEW-STATE is a number, then the state of KEY
8238 is set to off if the low bit of NEW-STATE is zero, otherwise on.
8239 If NEW-STATE is omitted or nil, the function toggles the state,
8240
8241 Value is the new state of the key, or nil if the function failed
8242 to change the state. */)
8243 (Lisp_Object key, Lisp_Object new_state)
8244 {
8245 int vk_code;
8246 LPARAM lparam;
8247
8248 if (EQ (key, intern ("capslock")))
8249 vk_code = VK_CAPITAL;
8250 else if (EQ (key, intern ("kp-numlock")))
8251 vk_code = VK_NUMLOCK;
8252 else if (EQ (key, intern ("scroll")))
8253 vk_code = VK_SCROLL;
8254 else
8255 return Qnil;
8256
8257 if (!dwWindowsThreadId)
8258 return make_number (w32_console_toggle_lock_key (vk_code, new_state));
8259
8260 if (NILP (new_state))
8261 lparam = -1;
8262 else
8263 lparam = (XUINT (new_state)) & 1;
8264 if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_TOGGLE_LOCK_KEY,
8265 (WPARAM) vk_code, lparam))
8266 {
8267 MSG msg;
8268 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
8269 return make_number (msg.wParam);
8270 }
8271 return Qnil;
8272 }
8273
8274 DEFUN ("w32-window-exists-p", Fw32_window_exists_p, Sw32_window_exists_p,
8275 2, 2, 0,
8276 doc: /* Return non-nil if a window exists with the specified CLASS and NAME.
8277
8278 This is a direct interface to the Windows API FindWindow function. */)
8279 (Lisp_Object class, Lisp_Object name)
8280 {
8281 HWND hnd;
8282
8283 if (!NILP (class))
8284 CHECK_STRING (class);
8285 if (!NILP (name))
8286 CHECK_STRING (name);
8287
8288 hnd = FindWindow (STRINGP (class) ? ((LPCTSTR) SDATA (class)) : NULL,
8289 STRINGP (name) ? ((LPCTSTR) SDATA (name)) : NULL);
8290 if (!hnd)
8291 return Qnil;
8292 return Qt;
8293 }
8294
8295 DEFUN ("w32-frame-geometry", Fw32_frame_geometry, Sw32_frame_geometry, 0, 1, 0,
8296 doc: /* Return geometric attributes of FRAME.
8297 FRAME must be a live frame and defaults to the selected one. The return
8298 value is an association list of the attributes listed below. All height
8299 and width values are in pixels.
8300
8301 `outer-position' is a cons of the outer left and top edges of FRAME
8302 relative to the origin - the position (0, 0) - of FRAME's display.
8303
8304 `outer-size' is a cons of the outer width and height of FRAME. The
8305 outer size includes the title bar and the external borders as well as
8306 any menu and/or tool bar of frame.
8307
8308 `external-border-size' is a cons of the horizontal and vertical width of
8309 FRAME's external borders as supplied by the window manager.
8310
8311 `title-bar-size' is a cons of the width and height of the title bar of
8312 FRAME as supplied by the window manager. If both of them are zero,
8313 FRAME has no title bar. If only the width is zero, Emacs was not
8314 able to retrieve the width information.
8315
8316 `menu-bar-external', if non-nil, means the menu bar is external (never
8317 included in the inner edges of FRAME).
8318
8319 `menu-bar-size' is a cons of the width and height of the menu bar of
8320 FRAME.
8321
8322 `tool-bar-external', if non-nil, means the tool bar is external (never
8323 included in the inner edges of FRAME).
8324
8325 `tool-bar-position' tells on which side the tool bar on FRAME is and can
8326 be one of `left', `top', `right' or `bottom'. If this is nil, FRAME
8327 has no tool bar.
8328
8329 `tool-bar-size' is a cons of the width and height of the tool bar of
8330 FRAME.
8331
8332 `internal-border-width' is the width of the internal border of
8333 FRAME. */)
8334 (Lisp_Object frame)
8335 {
8336 struct frame *f = decode_live_frame (frame);
8337
8338 MENUBARINFO menu_bar;
8339 WINDOWINFO window;
8340 int left, top, right, bottom;
8341 unsigned int external_border_width, external_border_height;
8342 int title_bar_width = 0, title_bar_height = 0;
8343 int single_menu_bar_height, wrapped_menu_bar_height, menu_bar_height;
8344 int tool_bar_height = FRAME_TOOL_BAR_HEIGHT (f);
8345 int internal_border_width = FRAME_INTERNAL_BORDER_WIDTH (f);
8346
8347 if (FRAME_INITIAL_P (f) || !FRAME_W32_P (f))
8348 return Qnil;
8349
8350 block_input ();
8351 /* Outer rectangle and borders. */
8352 window.cbSize = sizeof (window);
8353 GetWindowInfo (FRAME_W32_WINDOW (f), &window);
8354 external_border_width = window.cxWindowBorders;
8355 external_border_height = window.cyWindowBorders;
8356 /* Title bar. */
8357 if (get_title_bar_info_fn)
8358 {
8359 TITLEBAR_INFO title_bar;
8360
8361 title_bar.cbSize = sizeof (title_bar);
8362 title_bar.rcTitleBar.left = title_bar.rcTitleBar.right = 0;
8363 title_bar.rcTitleBar.top = title_bar.rcTitleBar.bottom = 0;
8364 for (int i = 0; i < 6; i++)
8365 title_bar.rgstate[i] = 0;
8366 if (get_title_bar_info_fn (FRAME_W32_WINDOW (f), &title_bar)
8367 && !(title_bar.rgstate[0] & 0x00008001))
8368 {
8369 title_bar_width
8370 = title_bar.rcTitleBar.right - title_bar.rcTitleBar.left;
8371 title_bar_height
8372 = title_bar.rcTitleBar.bottom - title_bar.rcTitleBar.top;
8373 }
8374 }
8375 else if ((window.dwStyle & WS_CAPTION) == WS_CAPTION)
8376 title_bar_height = GetSystemMetrics (SM_CYCAPTION);
8377 /* Menu bar. */
8378 menu_bar.cbSize = sizeof (menu_bar);
8379 menu_bar.rcBar.right = menu_bar.rcBar.left = 0;
8380 menu_bar.rcBar.top = menu_bar.rcBar.bottom = 0;
8381 GetMenuBarInfo (FRAME_W32_WINDOW (f), 0xFFFFFFFD, 0, &menu_bar);
8382 single_menu_bar_height = GetSystemMetrics (SM_CYMENU);
8383 wrapped_menu_bar_height = GetSystemMetrics (SM_CYMENUSIZE);
8384 unblock_input ();
8385
8386 left = window.rcWindow.left;
8387 top = window.rcWindow.top;
8388 right = window.rcWindow.right;
8389 bottom = window.rcWindow.bottom;
8390
8391 /* Menu bar. */
8392 menu_bar_height = menu_bar.rcBar.bottom - menu_bar.rcBar.top;
8393 /* Fix menu bar height reported by GetMenuBarInfo. */
8394 if (menu_bar_height > single_menu_bar_height)
8395 /* A wrapped menu bar. */
8396 menu_bar_height += single_menu_bar_height - wrapped_menu_bar_height;
8397 else if (menu_bar_height > 0)
8398 /* A single line menu bar. */
8399 menu_bar_height = single_menu_bar_height;
8400
8401 return listn (CONSTYPE_HEAP, 10,
8402 Fcons (Qouter_position,
8403 Fcons (make_number (left), make_number (top))),
8404 Fcons (Qouter_size,
8405 Fcons (make_number (right - left),
8406 make_number (bottom - top))),
8407 Fcons (Qexternal_border_size,
8408 Fcons (make_number (external_border_width),
8409 make_number (external_border_height))),
8410 Fcons (Qtitle_bar_size,
8411 Fcons (make_number (title_bar_width),
8412 make_number (title_bar_height))),
8413 Fcons (Qmenu_bar_external, Qt),
8414 Fcons (Qmenu_bar_size,
8415 Fcons (make_number
8416 (menu_bar.rcBar.right - menu_bar.rcBar.left),
8417 make_number (menu_bar_height))),
8418 Fcons (Qtool_bar_external, Qnil),
8419 Fcons (Qtool_bar_position, tool_bar_height ? Qtop : Qnil),
8420 Fcons (Qtool_bar_size,
8421 Fcons (make_number
8422 (tool_bar_height
8423 ? right - left - 2 * internal_border_width
8424 : 0),
8425 make_number (tool_bar_height))),
8426 Fcons (Qinternal_border_width,
8427 make_number (internal_border_width)));
8428 }
8429
8430 DEFUN ("w32-frame-edges", Fw32_frame_edges, Sw32_frame_edges, 0, 2, 0,
8431 doc: /* Return edge coordinates of FRAME.
8432 FRAME must be a live frame and defaults to the selected one. The return
8433 value is a list of the form (LEFT, TOP, RIGHT, BOTTOM). All values are
8434 in pixels relative to the origin - the position (0, 0) - of FRAME's
8435 display.
8436
8437 If optional argument TYPE is the symbol `outer-edges', return the outer
8438 edges of FRAME. The outer edges comprise the decorations of the window
8439 manager (like the title bar or external borders) as well as any external
8440 menu or tool bar of FRAME. If optional argument TYPE is the symbol
8441 `native-edges' or nil, return the native edges of FRAME. The native
8442 edges exclude the decorations of the window manager and any external
8443 menu or tool bar of FRAME. If TYPE is the symbol `inner-edges', return
8444 the inner edges of FRAME. These edges exclude title bar, any borders,
8445 menu bar or tool bar of FRAME. */)
8446 (Lisp_Object frame, Lisp_Object type)
8447 {
8448 struct frame *f = decode_live_frame (frame);
8449
8450 if (FRAME_INITIAL_P (f) || !FRAME_W32_P (f))
8451 return Qnil;
8452
8453 if (EQ (type, Qouter_edges))
8454 {
8455 RECT rectangle;
8456
8457 block_input ();
8458 /* Outer frame rectangle, including outer borders and title bar. */
8459 GetWindowRect (FRAME_W32_WINDOW (f), &rectangle);
8460 unblock_input ();
8461
8462 return list4 (make_number (rectangle.left),
8463 make_number (rectangle.top),
8464 make_number (rectangle.right),
8465 make_number (rectangle.bottom));
8466 }
8467 else
8468 {
8469 RECT rectangle;
8470 POINT pt;
8471 int left, top, right, bottom;
8472
8473 block_input ();
8474 /* Inner frame rectangle, excluding borders and title bar. */
8475 GetClientRect (FRAME_W32_WINDOW (f), &rectangle);
8476 /* Get top-left corner of native rectangle in screen
8477 coordinates. */
8478 pt.x = 0;
8479 pt.y = 0;
8480 ClientToScreen (FRAME_W32_WINDOW (f), &pt);
8481 unblock_input ();
8482
8483 left = pt.x;
8484 top = pt.y;
8485 right = left + rectangle.right;
8486 bottom = top + rectangle.bottom;
8487
8488 if (EQ (type, Qinner_edges))
8489 {
8490 int internal_border_width = FRAME_INTERNAL_BORDER_WIDTH (f);
8491
8492 return list4 (make_number (left + internal_border_width),
8493 make_number (top
8494 + FRAME_TOOL_BAR_HEIGHT (f)
8495 + internal_border_width),
8496 make_number (right - internal_border_width),
8497 make_number (bottom - internal_border_width));
8498 }
8499 else
8500 return list4 (make_number (left), make_number (top),
8501 make_number (right), make_number (bottom));
8502 }
8503 }
8504
8505 DEFUN ("w32-mouse-absolute-pixel-position", Fw32_mouse_absolute_pixel_position,
8506 Sw32_mouse_absolute_pixel_position, 0, 0, 0,
8507 doc: /* Return absolute position of mouse cursor in pixels.
8508 The position is returned as a cons cell (X . Y) of the coordinates of
8509 the mouse cursor position in pixels relative to a position (0, 0) of the
8510 selected frame's display. */)
8511 (void)
8512 {
8513 POINT pt;
8514
8515 block_input ();
8516 GetCursorPos (&pt);
8517 unblock_input ();
8518
8519 return Fcons (make_number (pt.x), make_number (pt.y));
8520 }
8521
8522 DEFUN ("w32-set-mouse-absolute-pixel-position", Fw32_set_mouse_absolute_pixel_position,
8523 Sw32_set_mouse_absolute_pixel_position, 2, 2, 0,
8524 doc: /* Move mouse pointer to absolute pixel position (X, Y).
8525 The coordinates X and Y are interpreted in pixels relative to a position
8526 \(0, 0) of the selected frame's display. */)
8527 (Lisp_Object x, Lisp_Object y)
8528 {
8529 UINT trail_num = 0;
8530 BOOL ret = false;
8531
8532 CHECK_TYPE_RANGED_INTEGER (int, x);
8533 CHECK_TYPE_RANGED_INTEGER (int, y);
8534
8535 block_input ();
8536 /* When "mouse trails" are in effect, moving the mouse cursor
8537 sometimes leaves behind an annoying "ghost" of the pointer.
8538 Avoid that by momentarily switching off mouse trails. */
8539 if (os_subtype == OS_NT
8540 && w32_major_version + w32_minor_version >= 6)
8541 ret = SystemParametersInfo (SPI_GETMOUSETRAILS, 0, &trail_num, 0);
8542 SetCursorPos (XINT (x), XINT (y));
8543 if (ret)
8544 SystemParametersInfo (SPI_SETMOUSETRAILS, trail_num, NULL, 0);
8545 unblock_input ();
8546
8547 return Qnil;
8548 }
8549
8550 DEFUN ("w32-battery-status", Fw32_battery_status, Sw32_battery_status, 0, 0, 0,
8551 doc: /* Get power status information from Windows system.
8552
8553 The following %-sequences are provided:
8554 %L AC line status (verbose)
8555 %B Battery status (verbose)
8556 %b Battery status, empty means high, `-' means low,
8557 `!' means critical, and `+' means charging
8558 %p Battery load percentage
8559 %s Remaining time (to charge or discharge) in seconds
8560 %m Remaining time (to charge or discharge) in minutes
8561 %h Remaining time (to charge or discharge) in hours
8562 %t Remaining time (to charge or discharge) in the form `h:min' */)
8563 (void)
8564 {
8565 Lisp_Object status = Qnil;
8566
8567 SYSTEM_POWER_STATUS system_status;
8568 if (GetSystemPowerStatus (&system_status))
8569 {
8570 Lisp_Object line_status, battery_status, battery_status_symbol;
8571 Lisp_Object load_percentage, seconds, minutes, hours, remain;
8572
8573 long seconds_left = (long) system_status.BatteryLifeTime;
8574
8575 if (system_status.ACLineStatus == 0)
8576 line_status = build_string ("off-line");
8577 else if (system_status.ACLineStatus == 1)
8578 line_status = build_string ("on-line");
8579 else
8580 line_status = build_string ("N/A");
8581
8582 if (system_status.BatteryFlag & 128)
8583 {
8584 battery_status = build_string ("N/A");
8585 battery_status_symbol = empty_unibyte_string;
8586 }
8587 else if (system_status.BatteryFlag & 8)
8588 {
8589 battery_status = build_string ("charging");
8590 battery_status_symbol = build_string ("+");
8591 if (system_status.BatteryFullLifeTime != -1L)
8592 seconds_left = system_status.BatteryFullLifeTime - seconds_left;
8593 }
8594 else if (system_status.BatteryFlag & 4)
8595 {
8596 battery_status = build_string ("critical");
8597 battery_status_symbol = build_string ("!");
8598 }
8599 else if (system_status.BatteryFlag & 2)
8600 {
8601 battery_status = build_string ("low");
8602 battery_status_symbol = build_string ("-");
8603 }
8604 else if (system_status.BatteryFlag & 1)
8605 {
8606 battery_status = build_string ("high");
8607 battery_status_symbol = empty_unibyte_string;
8608 }
8609 else
8610 {
8611 battery_status = build_string ("medium");
8612 battery_status_symbol = empty_unibyte_string;
8613 }
8614
8615 if (system_status.BatteryLifePercent > 100)
8616 load_percentage = build_string ("N/A");
8617 else
8618 {
8619 char buffer[16];
8620 snprintf (buffer, 16, "%d", system_status.BatteryLifePercent);
8621 load_percentage = build_string (buffer);
8622 }
8623
8624 if (seconds_left < 0)
8625 seconds = minutes = hours = remain = build_string ("N/A");
8626 else
8627 {
8628 long m;
8629 float h;
8630 char buffer[16];
8631 snprintf (buffer, 16, "%ld", seconds_left);
8632 seconds = build_string (buffer);
8633
8634 m = seconds_left / 60;
8635 snprintf (buffer, 16, "%ld", m);
8636 minutes = build_string (buffer);
8637
8638 h = seconds_left / 3600.0;
8639 snprintf (buffer, 16, "%3.1f", h);
8640 hours = build_string (buffer);
8641
8642 snprintf (buffer, 16, "%ld:%02ld", m / 60, m % 60);
8643 remain = build_string (buffer);
8644 }
8645
8646 status = listn (CONSTYPE_HEAP, 8,
8647 Fcons (make_number ('L'), line_status),
8648 Fcons (make_number ('B'), battery_status),
8649 Fcons (make_number ('b'), battery_status_symbol),
8650 Fcons (make_number ('p'), load_percentage),
8651 Fcons (make_number ('s'), seconds),
8652 Fcons (make_number ('m'), minutes),
8653 Fcons (make_number ('h'), hours),
8654 Fcons (make_number ('t'), remain));
8655 }
8656 return status;
8657 }
8658
8659 \f
8660 #ifdef WINDOWSNT
8661 typedef BOOL (WINAPI *GetDiskFreeSpaceExW_Proc)
8662 (LPCWSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
8663 typedef BOOL (WINAPI *GetDiskFreeSpaceExA_Proc)
8664 (LPCSTR, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER);
8665
8666 DEFUN ("file-system-info", Ffile_system_info, Sfile_system_info, 1, 1, 0,
8667 doc: /* Return storage information about the file system FILENAME is on.
8668 Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total
8669 storage of the file system, FREE is the free storage, and AVAIL is the
8670 storage available to a non-superuser. All 3 numbers are in bytes.
8671 If the underlying system call fails, value is nil. */)
8672 (Lisp_Object filename)
8673 {
8674 Lisp_Object encoded, value;
8675
8676 CHECK_STRING (filename);
8677 filename = Fexpand_file_name (filename, Qnil);
8678 encoded = ENCODE_FILE (filename);
8679
8680 value = Qnil;
8681
8682 /* Determining the required information on Windows turns out, sadly,
8683 to be more involved than one would hope. The original Windows API
8684 call for this will return bogus information on some systems, but we
8685 must dynamically probe for the replacement api, since that was
8686 added rather late on. */
8687 {
8688 HMODULE hKernel = GetModuleHandle ("kernel32");
8689 GetDiskFreeSpaceExW_Proc pfn_GetDiskFreeSpaceExW =
8690 (GetDiskFreeSpaceExW_Proc) GetProcAddress (hKernel, "GetDiskFreeSpaceExW");
8691 GetDiskFreeSpaceExA_Proc pfn_GetDiskFreeSpaceExA =
8692 (GetDiskFreeSpaceExA_Proc) GetProcAddress (hKernel, "GetDiskFreeSpaceExA");
8693 bool have_pfn_GetDiskFreeSpaceEx =
8694 ((w32_unicode_filenames && pfn_GetDiskFreeSpaceExW)
8695 || (!w32_unicode_filenames && pfn_GetDiskFreeSpaceExA));
8696
8697 /* On Windows, we may need to specify the root directory of the
8698 volume holding FILENAME. */
8699 char rootname[MAX_UTF8_PATH];
8700 wchar_t rootname_w[MAX_PATH];
8701 char rootname_a[MAX_PATH];
8702 char *name = SSDATA (encoded);
8703 BOOL result;
8704
8705 /* find the root name of the volume if given */
8706 if (isalpha (name[0]) && name[1] == ':')
8707 {
8708 rootname[0] = name[0];
8709 rootname[1] = name[1];
8710 rootname[2] = '\\';
8711 rootname[3] = 0;
8712 }
8713 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
8714 {
8715 char *str = rootname;
8716 int slashes = 4;
8717 do
8718 {
8719 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
8720 break;
8721 *str++ = *name++;
8722 }
8723 while ( *name );
8724
8725 *str++ = '\\';
8726 *str = 0;
8727 }
8728
8729 if (w32_unicode_filenames)
8730 filename_to_utf16 (rootname, rootname_w);
8731 else
8732 filename_to_ansi (rootname, rootname_a);
8733
8734 if (have_pfn_GetDiskFreeSpaceEx)
8735 {
8736 /* Unsigned large integers cannot be cast to double, so
8737 use signed ones instead. */
8738 LARGE_INTEGER availbytes;
8739 LARGE_INTEGER freebytes;
8740 LARGE_INTEGER totalbytes;
8741
8742 if (w32_unicode_filenames)
8743 result = pfn_GetDiskFreeSpaceExW (rootname_w,
8744 (ULARGE_INTEGER *)&availbytes,
8745 (ULARGE_INTEGER *)&totalbytes,
8746 (ULARGE_INTEGER *)&freebytes);
8747 else
8748 result = pfn_GetDiskFreeSpaceExA (rootname_a,
8749 (ULARGE_INTEGER *)&availbytes,
8750 (ULARGE_INTEGER *)&totalbytes,
8751 (ULARGE_INTEGER *)&freebytes);
8752 if (result)
8753 value = list3 (make_float ((double) totalbytes.QuadPart),
8754 make_float ((double) freebytes.QuadPart),
8755 make_float ((double) availbytes.QuadPart));
8756 }
8757 else
8758 {
8759 DWORD sectors_per_cluster;
8760 DWORD bytes_per_sector;
8761 DWORD free_clusters;
8762 DWORD total_clusters;
8763
8764 if (w32_unicode_filenames)
8765 result = GetDiskFreeSpaceW (rootname_w,
8766 &sectors_per_cluster,
8767 &bytes_per_sector,
8768 &free_clusters,
8769 &total_clusters);
8770 else
8771 result = GetDiskFreeSpaceA (rootname_a,
8772 &sectors_per_cluster,
8773 &bytes_per_sector,
8774 &free_clusters,
8775 &total_clusters);
8776 if (result)
8777 value = list3 (make_float ((double) total_clusters
8778 * sectors_per_cluster * bytes_per_sector),
8779 make_float ((double) free_clusters
8780 * sectors_per_cluster * bytes_per_sector),
8781 make_float ((double) free_clusters
8782 * sectors_per_cluster * bytes_per_sector));
8783 }
8784 }
8785
8786 return value;
8787 }
8788 #endif /* WINDOWSNT */
8789
8790 \f
8791 #ifdef WINDOWSNT
8792 DEFUN ("default-printer-name", Fdefault_printer_name, Sdefault_printer_name,
8793 0, 0, 0, doc: /* Return the name of Windows default printer device. */)
8794 (void)
8795 {
8796 static char pname_buf[256];
8797 int err;
8798 HANDLE hPrn;
8799 PRINTER_INFO_2W *ppi2w = NULL;
8800 PRINTER_INFO_2A *ppi2a = NULL;
8801 DWORD dwNeeded = 0, dwReturned = 0;
8802 char server_name[MAX_UTF8_PATH], share_name[MAX_UTF8_PATH];
8803 char port_name[MAX_UTF8_PATH];
8804
8805 /* Retrieve the default string from Win.ini (the registry).
8806 * String will be in form "printername,drivername,portname".
8807 * This is the most portable way to get the default printer. */
8808 if (GetProfileString ("windows", "device", ",,", pname_buf, sizeof (pname_buf)) <= 0)
8809 return Qnil;
8810 /* printername precedes first "," character */
8811 strtok (pname_buf, ",");
8812 /* We want to know more than the printer name */
8813 if (!OpenPrinter (pname_buf, &hPrn, NULL))
8814 return Qnil;
8815 /* GetPrinterW is not supported by unicows.dll. */
8816 if (w32_unicode_filenames && os_subtype != OS_9X)
8817 GetPrinterW (hPrn, 2, NULL, 0, &dwNeeded);
8818 else
8819 GetPrinterA (hPrn, 2, NULL, 0, &dwNeeded);
8820 if (dwNeeded == 0)
8821 {
8822 ClosePrinter (hPrn);
8823 return Qnil;
8824 }
8825 /* Call GetPrinter again with big enough memory block. */
8826 if (w32_unicode_filenames && os_subtype != OS_9X)
8827 {
8828 /* Allocate memory for the PRINTER_INFO_2 struct. */
8829 ppi2w = xmalloc (dwNeeded);
8830 err = GetPrinterW (hPrn, 2, (LPBYTE)ppi2w, dwNeeded, &dwReturned);
8831 ClosePrinter (hPrn);
8832 if (!err)
8833 {
8834 xfree (ppi2w);
8835 return Qnil;
8836 }
8837
8838 if ((ppi2w->Attributes & PRINTER_ATTRIBUTE_SHARED)
8839 && ppi2w->pServerName)
8840 {
8841 filename_from_utf16 (ppi2w->pServerName, server_name);
8842 filename_from_utf16 (ppi2w->pShareName, share_name);
8843 }
8844 else
8845 {
8846 server_name[0] = '\0';
8847 filename_from_utf16 (ppi2w->pPortName, port_name);
8848 }
8849 }
8850 else
8851 {
8852 ppi2a = xmalloc (dwNeeded);
8853 err = GetPrinterA (hPrn, 2, (LPBYTE)ppi2a, dwNeeded, &dwReturned);
8854 ClosePrinter (hPrn);
8855 if (!err)
8856 {
8857 xfree (ppi2a);
8858 return Qnil;
8859 }
8860
8861 if ((ppi2a->Attributes & PRINTER_ATTRIBUTE_SHARED)
8862 && ppi2a->pServerName)
8863 {
8864 filename_from_ansi (ppi2a->pServerName, server_name);
8865 filename_from_ansi (ppi2a->pShareName, share_name);
8866 }
8867 else
8868 {
8869 server_name[0] = '\0';
8870 filename_from_ansi (ppi2a->pPortName, port_name);
8871 }
8872 }
8873
8874 if (server_name[0])
8875 {
8876 /* a remote printer */
8877 if (server_name[0] == '\\')
8878 snprintf (pname_buf, sizeof (pname_buf), "%s\\%s", server_name,
8879 share_name);
8880 else
8881 snprintf (pname_buf, sizeof (pname_buf), "\\\\%s\\%s", server_name,
8882 share_name);
8883 pname_buf[sizeof (pname_buf) - 1] = '\0';
8884 }
8885 else
8886 {
8887 /* a local printer */
8888 strncpy (pname_buf, port_name, sizeof (pname_buf));
8889 pname_buf[sizeof (pname_buf) - 1] = '\0';
8890 /* `pPortName' can include several ports, delimited by ','.
8891 * we only use the first one. */
8892 strtok (pname_buf, ",");
8893 }
8894
8895 return DECODE_FILE (build_unibyte_string (pname_buf));
8896 }
8897 #endif /* WINDOWSNT */
8898 \f
8899
8900 /* Equivalent of strerror for W32 error codes. */
8901 char *
8902 w32_strerror (int error_no)
8903 {
8904 static char buf[500];
8905 DWORD ret;
8906
8907 if (error_no == 0)
8908 error_no = GetLastError ();
8909
8910 ret = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM |
8911 FORMAT_MESSAGE_IGNORE_INSERTS,
8912 NULL,
8913 error_no,
8914 0, /* choose most suitable language */
8915 buf, sizeof (buf), NULL);
8916
8917 while (ret > 0 && (buf[ret - 1] == '\n' ||
8918 buf[ret - 1] == '\r' ))
8919 --ret;
8920 buf[ret] = '\0';
8921 if (!ret)
8922 sprintf (buf, "w32 error %u", error_no);
8923
8924 return buf;
8925 }
8926
8927 /* For convenience when debugging. (You cannot call GetLastError
8928 directly from GDB: it will crash, because it uses the __stdcall
8929 calling convention, not the _cdecl convention assumed by GDB.) */
8930 DWORD
8931 w32_last_error (void)
8932 {
8933 return GetLastError ();
8934 }
8935
8936 /* Cache information describing the NT system for later use. */
8937 void
8938 cache_system_info (void)
8939 {
8940 union
8941 {
8942 struct info
8943 {
8944 char major;
8945 char minor;
8946 short platform;
8947 } info;
8948 DWORD data;
8949 } version;
8950
8951 /* Cache the module handle of Emacs itself. */
8952 hinst = GetModuleHandle (NULL);
8953
8954 /* Cache the version of the operating system. */
8955 version.data = GetVersion ();
8956 w32_major_version = version.info.major;
8957 w32_minor_version = version.info.minor;
8958
8959 if (version.info.platform & 0x8000)
8960 os_subtype = OS_9X;
8961 else
8962 os_subtype = OS_NT;
8963
8964 /* Cache page size, allocation unit, processor type, etc. */
8965 GetSystemInfo (&sysinfo_cache);
8966 syspage_mask = (DWORD_PTR)sysinfo_cache.dwPageSize - 1;
8967
8968 /* Cache os info. */
8969 osinfo_cache.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
8970 GetVersionEx (&osinfo_cache);
8971
8972 w32_build_number = osinfo_cache.dwBuildNumber;
8973 if (os_subtype == OS_9X)
8974 w32_build_number &= 0xffff;
8975
8976 w32_num_mouse_buttons = GetSystemMetrics (SM_CMOUSEBUTTONS);
8977 }
8978
8979 #ifdef EMACSDEBUG
8980 void
8981 _DebPrint (const char *fmt, ...)
8982 {
8983 char buf[1024];
8984 va_list args;
8985
8986 va_start (args, fmt);
8987 vsprintf (buf, fmt, args);
8988 va_end (args);
8989 #if CYGWIN
8990 fprintf (stderr, "%s", buf);
8991 #endif
8992 OutputDebugString (buf);
8993 }
8994 #endif
8995
8996 int
8997 w32_console_toggle_lock_key (int vk_code, Lisp_Object new_state)
8998 {
8999 int cur_state = (GetKeyState (vk_code) & 1);
9000
9001 if (NILP (new_state)
9002 || (NUMBERP (new_state)
9003 && ((XUINT (new_state)) & 1) != cur_state))
9004 {
9005 #ifdef WINDOWSNT
9006 faked_key = vk_code;
9007 #endif /* WINDOWSNT */
9008
9009 keybd_event ((BYTE) vk_code,
9010 (BYTE) MapVirtualKey (vk_code, 0),
9011 KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
9012 keybd_event ((BYTE) vk_code,
9013 (BYTE) MapVirtualKey (vk_code, 0),
9014 KEYEVENTF_EXTENDEDKEY | 0, 0);
9015 keybd_event ((BYTE) vk_code,
9016 (BYTE) MapVirtualKey (vk_code, 0),
9017 KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
9018 cur_state = !cur_state;
9019 }
9020
9021 return cur_state;
9022 }
9023
9024 /* Translate console modifiers to emacs modifiers.
9025 German keyboard support (Kai Morgan Zeise 2/18/95). */
9026 int
9027 w32_kbd_mods_to_emacs (DWORD mods, WORD key)
9028 {
9029 int retval = 0;
9030
9031 /* If we recognize right-alt and left-ctrl as AltGr, and it has been
9032 pressed, first remove those modifiers. */
9033 if (!NILP (Vw32_recognize_altgr)
9034 && (mods & (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
9035 == (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
9036 mods &= ~ (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED);
9037
9038 if (mods & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED))
9039 retval = ((NILP (Vw32_alt_is_meta)) ? alt_modifier : meta_modifier);
9040
9041 if (mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
9042 {
9043 retval |= ctrl_modifier;
9044 if ((mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
9045 == (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
9046 retval |= meta_modifier;
9047 }
9048
9049 if (mods & LEFT_WIN_PRESSED)
9050 retval |= w32_key_to_modifier (VK_LWIN);
9051 if (mods & RIGHT_WIN_PRESSED)
9052 retval |= w32_key_to_modifier (VK_RWIN);
9053 if (mods & APPS_PRESSED)
9054 retval |= w32_key_to_modifier (VK_APPS);
9055 if (mods & SCROLLLOCK_ON)
9056 retval |= w32_key_to_modifier (VK_SCROLL);
9057
9058 /* Just in case someone wanted the original behavior, make it
9059 optional by setting w32-capslock-is-shiftlock to t. */
9060 if (NILP (Vw32_capslock_is_shiftlock)
9061 /* Keys that should _not_ be affected by CapsLock. */
9062 && ( (key == VK_BACK)
9063 || (key == VK_TAB)
9064 || (key == VK_CLEAR)
9065 || (key == VK_RETURN)
9066 || (key == VK_ESCAPE)
9067 || ((key >= VK_SPACE) && (key <= VK_HELP))
9068 || ((key >= VK_NUMPAD0) && (key <= VK_F24))
9069 || ((key >= VK_NUMPAD_CLEAR) && (key <= VK_NUMPAD_DELETE))
9070 ))
9071 {
9072 /* Only consider shift state. */
9073 if ((mods & SHIFT_PRESSED) != 0)
9074 retval |= shift_modifier;
9075 }
9076 else
9077 {
9078 /* Ignore CapsLock state if not enabled. */
9079 if (NILP (Vw32_enable_caps_lock))
9080 mods &= ~CAPSLOCK_ON;
9081 if ((mods & (SHIFT_PRESSED | CAPSLOCK_ON)) != 0)
9082 retval |= shift_modifier;
9083 }
9084
9085 return retval;
9086 }
9087
9088 /* The return code indicates key code size. cpID is the codepage to
9089 use for translation to Unicode; -1 means use the current console
9090 input codepage. */
9091 int
9092 w32_kbd_patch_key (KEY_EVENT_RECORD *event, int cpId)
9093 {
9094 unsigned int key_code = event->wVirtualKeyCode;
9095 unsigned int mods = event->dwControlKeyState;
9096 BYTE keystate[256];
9097 static BYTE ansi_code[4];
9098 static int isdead = 0;
9099
9100 if (isdead == 2)
9101 {
9102 event->uChar.AsciiChar = ansi_code[2];
9103 isdead = 0;
9104 return 1;
9105 }
9106 if (event->uChar.AsciiChar != 0)
9107 return 1;
9108
9109 memset (keystate, 0, sizeof (keystate));
9110 keystate[key_code] = 0x80;
9111 if (mods & SHIFT_PRESSED)
9112 keystate[VK_SHIFT] = 0x80;
9113 if (mods & CAPSLOCK_ON)
9114 keystate[VK_CAPITAL] = 1;
9115 /* If we recognize right-alt and left-ctrl as AltGr, set the key
9116 states accordingly before invoking ToAscii. */
9117 if (!NILP (Vw32_recognize_altgr)
9118 && (mods & LEFT_CTRL_PRESSED) && (mods & RIGHT_ALT_PRESSED))
9119 {
9120 keystate[VK_CONTROL] = 0x80;
9121 keystate[VK_LCONTROL] = 0x80;
9122 keystate[VK_MENU] = 0x80;
9123 keystate[VK_RMENU] = 0x80;
9124 }
9125
9126 #if 0
9127 /* Because of an OS bug, ToAscii corrupts the stack when called to
9128 convert a dead key in console mode on NT4. Unfortunately, trying
9129 to check for dead keys using MapVirtualKey doesn't work either -
9130 these functions apparently use internal information about keyboard
9131 layout which doesn't get properly updated in console programs when
9132 changing layout (though apparently it gets partly updated,
9133 otherwise ToAscii wouldn't crash). */
9134 if (is_dead_key (event->wVirtualKeyCode))
9135 return 0;
9136 #endif
9137
9138 /* On NT, call ToUnicode instead and then convert to the current
9139 console input codepage. */
9140 if (os_subtype == OS_NT)
9141 {
9142 WCHAR buf[128];
9143
9144 isdead = ToUnicode (event->wVirtualKeyCode, event->wVirtualScanCode,
9145 keystate, buf, 128, 0);
9146 if (isdead > 0)
9147 {
9148 /* When we are called from the GUI message processing code,
9149 we are passed the current keyboard codepage, a positive
9150 number, to use below. */
9151 if (cpId == -1)
9152 cpId = GetConsoleCP ();
9153
9154 event->uChar.UnicodeChar = buf[isdead - 1];
9155 isdead = WideCharToMultiByte (cpId, 0, buf, isdead,
9156 (LPSTR)ansi_code, 4, NULL, NULL);
9157 }
9158 else
9159 isdead = 0;
9160 }
9161 else
9162 {
9163 isdead = ToAscii (event->wVirtualKeyCode, event->wVirtualScanCode,
9164 keystate, (LPWORD) ansi_code, 0);
9165 }
9166
9167 if (isdead == 0)
9168 return 0;
9169 event->uChar.AsciiChar = ansi_code[0];
9170 return isdead;
9171 }
9172
9173
9174 void
9175 w32_sys_ring_bell (struct frame *f)
9176 {
9177 if (sound_type == 0xFFFFFFFF)
9178 {
9179 Beep (666, 100);
9180 }
9181 else if (sound_type == MB_EMACS_SILENT)
9182 {
9183 /* Do nothing. */
9184 }
9185 else
9186 MessageBeep (sound_type);
9187 }
9188
9189 DEFUN ("w32--menu-bar-in-use", Fw32__menu_bar_in_use, Sw32__menu_bar_in_use,
9190 0, 0, 0,
9191 doc: /* Return non-nil when a menu-bar menu is being used.
9192 Internal use only. */)
9193 (void)
9194 {
9195 return menubar_in_use ? Qt : Qnil;
9196 }
9197
9198 #if defined WINDOWSNT && !defined HAVE_DBUS
9199
9200 /***********************************************************************
9201 Tray notifications
9202 ***********************************************************************/
9203 /* A private struct declaration to avoid compile-time limits. */
9204 typedef struct MY_NOTIFYICONDATAW {
9205 DWORD cbSize;
9206 HWND hWnd;
9207 UINT uID;
9208 UINT uFlags;
9209 UINT uCallbackMessage;
9210 HICON hIcon;
9211 WCHAR szTip[128];
9212 DWORD dwState;
9213 DWORD dwStateMask;
9214 WCHAR szInfo[256];
9215 _ANONYMOUS_UNION union {
9216 UINT uTimeout;
9217 UINT uVersion;
9218 } DUMMYUNIONNAME;
9219 WCHAR szInfoTitle[64];
9220 DWORD dwInfoFlags;
9221 GUID guidItem;
9222 HICON hBalloonIcon;
9223 } MY_NOTIFYICONDATAW;
9224
9225 #define MYNOTIFYICONDATAW_V1_SIZE offsetof (MY_NOTIFYICONDATAW, szTip[64])
9226 #define MYNOTIFYICONDATAW_V2_SIZE offsetof (MY_NOTIFYICONDATAW, guidItem)
9227 #define MYNOTIFYICONDATAW_V3_SIZE offsetof (MY_NOTIFYICONDATAW, hBalloonIcon)
9228 #ifndef NIF_INFO
9229 # define NIF_INFO 0x00000010
9230 #endif
9231 #ifndef NIIF_NONE
9232 # define NIIF_NONE 0x00000000
9233 #endif
9234 #ifndef NIIF_INFO
9235 # define NIIF_INFO 0x00000001
9236 #endif
9237 #ifndef NIIF_WARNING
9238 # define NIIF_WARNING 0x00000002
9239 #endif
9240 #ifndef NIIF_ERROR
9241 # define NIIF_ERROR 0x00000003
9242 #endif
9243
9244
9245 #define EMACS_TRAY_NOTIFICATION_ID 42 /* arbitrary */
9246 #define EMACS_NOTIFICATION_MSG (WM_APP + 1)
9247
9248 enum NI_Severity {
9249 Ni_None,
9250 Ni_Info,
9251 Ni_Warn,
9252 Ni_Err
9253 };
9254
9255 /* Report the version of a DLL given by its name. The return value is
9256 constructed using MAKEDLLVERULL. */
9257 static ULONGLONG
9258 get_dll_version (const char *dll_name)
9259 {
9260 ULONGLONG version = 0;
9261 HINSTANCE hdll = LoadLibrary (dll_name);
9262
9263 if (hdll)
9264 {
9265 DLLGETVERSIONPROC pDllGetVersion
9266 = (DLLGETVERSIONPROC) GetProcAddress (hdll, "DllGetVersion");
9267
9268 if (pDllGetVersion)
9269 {
9270 DLLVERSIONINFO dvi;
9271 HRESULT result;
9272
9273 memset (&dvi, 0, sizeof(dvi));
9274 dvi.cbSize = sizeof(dvi);
9275 result = pDllGetVersion (&dvi);
9276 if (SUCCEEDED (result))
9277 version = MAKEDLLVERULL (dvi.dwMajorVersion, dvi.dwMinorVersion,
9278 0, 0);
9279 }
9280 FreeLibrary (hdll);
9281 }
9282
9283 return version;
9284 }
9285
9286 /* Return the number of bytes in UTF-8 encoded string STR that
9287 corresponds to at most LIM characters. If STR ends before LIM
9288 characters, return the number of bytes in STR including the
9289 terminating null byte. */
9290 static int
9291 utf8_mbslen_lim (const char *str, int lim)
9292 {
9293 const char *p = str;
9294 int mblen = 0, nchars = 0;
9295
9296 while (*p && nchars < lim)
9297 {
9298 int nbytes = CHAR_BYTES (*p);
9299
9300 mblen += nbytes;
9301 nchars++;
9302 p += nbytes;
9303 }
9304
9305 if (!*p && nchars < lim)
9306 mblen++;
9307
9308 return mblen;
9309 }
9310
9311 /* Low-level subroutine to show tray notifications. All strings are
9312 supposed to be unibyte UTF-8 encoded by the caller. */
9313 static EMACS_INT
9314 add_tray_notification (struct frame *f, const char *icon, const char *tip,
9315 enum NI_Severity severity, unsigned timeout,
9316 const char *title, const char *msg)
9317 {
9318 EMACS_INT retval = EMACS_TRAY_NOTIFICATION_ID;
9319
9320 if (FRAME_W32_P (f))
9321 {
9322 MY_NOTIFYICONDATAW nidw;
9323 ULONGLONG shell_dll_version = get_dll_version ("Shell32.dll");
9324 wchar_t tipw[128], msgw[256], titlew[64];
9325 int tiplen;
9326
9327 memset (&nidw, 0, sizeof(nidw));
9328
9329 /* MSDN says the full struct is supported since Vista, whose
9330 Shell32.dll version is said to be 6.0.6. But DllGetVersion
9331 cannot report the 3rd field value, it reports "build number"
9332 instead, which is something else. So we use the Windows 7's
9333 version 6.1 as cutoff, and Vista loses. (Actually, the loss
9334 is not a real one, since we don't expose the hBalloonIcon
9335 member of the struct to Lisp.) */
9336 if (shell_dll_version >= MAKEDLLVERULL (6, 1, 0, 0)) /* >= Windows 7 */
9337 nidw.cbSize = sizeof (nidw);
9338 else if (shell_dll_version >= MAKEDLLVERULL (6, 0, 0, 0)) /* XP */
9339 nidw.cbSize = MYNOTIFYICONDATAW_V3_SIZE;
9340 else if (shell_dll_version >= MAKEDLLVERULL (5, 0, 0, 0)) /* W2K */
9341 nidw.cbSize = MYNOTIFYICONDATAW_V2_SIZE;
9342 else
9343 nidw.cbSize = MYNOTIFYICONDATAW_V1_SIZE; /* < W2K */
9344 nidw.hWnd = FRAME_W32_WINDOW (f);
9345 nidw.uID = EMACS_TRAY_NOTIFICATION_ID;
9346 nidw.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP | NIF_INFO;
9347 nidw.uCallbackMessage = EMACS_NOTIFICATION_MSG;
9348 if (!*icon)
9349 nidw.hIcon = LoadIcon (hinst, EMACS_CLASS);
9350 else
9351 {
9352 if (w32_unicode_filenames)
9353 {
9354 wchar_t icon_w[MAX_PATH];
9355
9356 if (filename_to_utf16 (icon, icon_w) != 0)
9357 {
9358 errno = ENOENT;
9359 return -1;
9360 }
9361 nidw.hIcon = LoadImageW (NULL, icon_w, IMAGE_ICON, 0, 0,
9362 LR_DEFAULTSIZE | LR_LOADFROMFILE);
9363 }
9364 else
9365 {
9366 char icon_a[MAX_PATH];
9367
9368 if (filename_to_ansi (icon, icon_a) != 0)
9369 {
9370 errno = ENOENT;
9371 return -1;
9372 }
9373 nidw.hIcon = LoadImageA (NULL, icon_a, IMAGE_ICON, 0, 0,
9374 LR_DEFAULTSIZE | LR_LOADFROMFILE);
9375 }
9376 }
9377 if (!nidw.hIcon)
9378 {
9379 switch (GetLastError ())
9380 {
9381 case ERROR_FILE_NOT_FOUND:
9382 errno = ENOENT;
9383 break;
9384 default:
9385 errno = ENOMEM;
9386 break;
9387 }
9388 return -1;
9389 }
9390
9391 /* Windows 9X and NT4 support only 64 characters in the Tip,
9392 later versions support up to 128. */
9393 if (nidw.cbSize == MYNOTIFYICONDATAW_V1_SIZE)
9394 {
9395 tiplen = pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
9396 tip, utf8_mbslen_lim (tip, 63),
9397 tipw, 64);
9398 if (tiplen >= 63)
9399 tipw[63] = 0;
9400 }
9401 else
9402 {
9403 tiplen = pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
9404 tip, utf8_mbslen_lim (tip, 127),
9405 tipw, 128);
9406 if (tiplen >= 127)
9407 tipw[127] = 0;
9408 }
9409 if (tiplen == 0)
9410 {
9411 errno = EINVAL;
9412 retval = -1;
9413 goto done;
9414 }
9415 wcscpy (nidw.szTip, tipw);
9416
9417 /* The rest of the structure is only supported since Windows 2000. */
9418 if (nidw.cbSize > MYNOTIFYICONDATAW_V1_SIZE)
9419 {
9420 int slen;
9421
9422 slen = pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
9423 msg, utf8_mbslen_lim (msg, 255),
9424 msgw, 256);
9425 if (slen >= 255)
9426 msgw[255] = 0;
9427 else if (slen == 0)
9428 {
9429 errno = EINVAL;
9430 retval = -1;
9431 goto done;
9432 }
9433 wcscpy (nidw.szInfo, msgw);
9434 nidw.uTimeout = timeout;
9435 slen = pMultiByteToWideChar (CP_UTF8, multiByteToWideCharFlags,
9436 title, utf8_mbslen_lim (title, 63),
9437 titlew, 64);
9438 if (slen >= 63)
9439 titlew[63] = 0;
9440 else if (slen == 0)
9441 {
9442 errno = EINVAL;
9443 retval = -1;
9444 goto done;
9445 }
9446 wcscpy (nidw.szInfoTitle, titlew);
9447
9448 switch (severity)
9449 {
9450 case Ni_None:
9451 nidw.dwInfoFlags = NIIF_NONE;
9452 break;
9453 case Ni_Info:
9454 default:
9455 nidw.dwInfoFlags = NIIF_INFO;
9456 break;
9457 case Ni_Warn:
9458 nidw.dwInfoFlags = NIIF_WARNING;
9459 break;
9460 case Ni_Err:
9461 nidw.dwInfoFlags = NIIF_ERROR;
9462 break;
9463 }
9464 }
9465
9466 if (!Shell_NotifyIconW (NIM_ADD, (PNOTIFYICONDATAW)&nidw))
9467 {
9468 /* GetLastError returns meaningless results when
9469 Shell_NotifyIcon fails. */
9470 DebPrint (("Shell_NotifyIcon ADD failed (err=%d)\n",
9471 GetLastError ()));
9472 errno = EINVAL;
9473 retval = -1;
9474 }
9475 done:
9476 if (*icon && !DestroyIcon (nidw.hIcon))
9477 DebPrint (("DestroyIcon failed (err=%d)\n", GetLastError ()));
9478 }
9479 return retval;
9480 }
9481
9482 /* Low-level subroutine to remove a tray notification. Note: we only
9483 pass the minimum data about the notification: its ID and the handle
9484 of the window to which it sends messages. MSDN doesn't say this is
9485 enough, but it works in practice. This allows us to avoid keeping
9486 the notification data around after we show the notification. */
9487 static void
9488 delete_tray_notification (struct frame *f, int id)
9489 {
9490 if (FRAME_W32_P (f))
9491 {
9492 MY_NOTIFYICONDATAW nidw;
9493
9494 memset (&nidw, 0, sizeof(nidw));
9495 nidw.hWnd = FRAME_W32_WINDOW (f);
9496 nidw.uID = id;
9497
9498 if (!Shell_NotifyIconW (NIM_DELETE, (PNOTIFYICONDATAW)&nidw))
9499 {
9500 /* GetLastError returns meaningless results when
9501 Shell_NotifyIcon fails. */
9502 DebPrint (("Shell_NotifyIcon DELETE failed\n"));
9503 errno = EINVAL;
9504 return;
9505 }
9506 }
9507 return;
9508 }
9509
9510 DEFUN ("w32-notification-notify",
9511 Fw32_notification_notify, Sw32_notification_notify,
9512 0, MANY, 0,
9513 doc: /* Display an MS-Windows tray notification as specified by PARAMS.
9514
9515 Value is the integer unique ID of the notification that can be used
9516 to remove the notification using `w32-notification-close', which see.
9517 If the function fails, the return value is nil.
9518
9519 Tray notifications, a.k.a. \"taskbar messages\", are messages that
9520 inform the user about events unrelated to the current user activity,
9521 such as a significant system event, by briefly displaying informative
9522 text in a balloon from an icon in the notification area of the taskbar.
9523
9524 Parameters in PARAMS are specified as keyword/value pairs. All the
9525 parameters are optional, but if no parameters are specified, the
9526 function will do nothing and return nil.
9527
9528 The following parameters are supported:
9529
9530 :icon ICON -- Display ICON in the system tray. If ICON is a string,
9531 it should specify a file name from which to load the
9532 icon; the specified file should be a .ico Windows icon
9533 file. If ICON is not a string, or if this parameter
9534 is not specified, the standard Emacs icon will be used.
9535
9536 :tip TIP -- Use TIP as the tooltip for the notification. If TIP
9537 is a string, this is the text of a tooltip that will
9538 be shown when the mouse pointer hovers over the tray
9539 icon added by the notification. If TIP is not a
9540 string, or if this parameter is not specified, the
9541 default tooltip text is \"Emacs notification\". The
9542 tooltip text can be up to 127 characters long (63
9543 on Windows versions before W2K). Longer strings
9544 will be truncated.
9545
9546 :level LEVEL -- Notification severity level, one of `info',
9547 `warning', or `error'. If given, the value
9548 determines the icon displayed to the left of the
9549 notification title, but only if the `:title'
9550 parameter (see below) is also specified and is a
9551 string.
9552
9553 :title TITLE -- The title of the notification. If TITLE is a string,
9554 it is displayed in a larger font immediately above
9555 the body text. The title text can be up to 63
9556 characters long; longer text will be truncated.
9557
9558 :body BODY -- The body of the notification. If BODY is a string,
9559 it specifies the text of the notification message.
9560 Use embedded newlines to control how the text is
9561 broken into lines. The body text can be up to 255
9562 characters long, and will be truncated if it's longer.
9563
9564 Note that versions of Windows before W2K support only `:icon' and `:tip'.
9565 You can pass the other parameters, but they will be ignored on those
9566 old systems.
9567
9568 There can be at most one active notification at any given time. An
9569 active notification must be removed by calling `w32-notification-close'
9570 before a new one can be shown.
9571
9572 usage: (w32-notification-notify &rest PARAMS) */)
9573 (ptrdiff_t nargs, Lisp_Object *args)
9574 {
9575 struct frame *f = SELECTED_FRAME ();
9576 Lisp_Object arg_plist, lres;
9577 EMACS_INT retval;
9578 char *icon, *tip, *title, *msg;
9579 enum NI_Severity severity;
9580 unsigned timeout;
9581
9582 if (nargs == 0)
9583 return Qnil;
9584
9585 arg_plist = Flist (nargs, args);
9586
9587 /* Icon. */
9588 lres = Fplist_get (arg_plist, QCicon);
9589 if (STRINGP (lres))
9590 icon = SSDATA (ENCODE_FILE (Fexpand_file_name (lres, Qnil)));
9591 else
9592 icon = "";
9593
9594 /* Tip. */
9595 lres = Fplist_get (arg_plist, QCtip);
9596 if (STRINGP (lres))
9597 tip = SSDATA (code_convert_string_norecord (lres, Qutf_8, 1));
9598 else
9599 tip = "Emacs notification";
9600
9601 /* Severity. */
9602 lres = Fplist_get (arg_plist, QClevel);
9603 if (NILP (lres))
9604 severity = Ni_None;
9605 else if (EQ (lres, Qinfo))
9606 severity = Ni_Info;
9607 else if (EQ (lres, Qwarning))
9608 severity = Ni_Warn;
9609 else if (EQ (lres, Qerror))
9610 severity = Ni_Err;
9611 else
9612 severity = Ni_Info;
9613
9614 /* Title. */
9615 lres = Fplist_get (arg_plist, QCtitle);
9616 if (STRINGP (lres))
9617 title = SSDATA (code_convert_string_norecord (lres, Qutf_8, 1));
9618 else
9619 title = "";
9620
9621 /* Notification body text. */
9622 lres = Fplist_get (arg_plist, QCbody);
9623 if (STRINGP (lres))
9624 msg = SSDATA (code_convert_string_norecord (lres, Qutf_8, 1));
9625 else
9626 msg = "";
9627
9628 /* Do it! */
9629 retval = add_tray_notification (f, icon, tip, severity, timeout, title, msg);
9630 return (retval < 0 ? Qnil : make_number (retval));
9631 }
9632
9633 DEFUN ("w32-notification-close",
9634 Fw32_notification_close, Sw32_notification_close,
9635 1, 1, 0,
9636 doc: /* Remove the MS-Windows tray notification specified by its ID. */)
9637 (Lisp_Object id)
9638 {
9639 struct frame *f = SELECTED_FRAME ();
9640
9641 if (INTEGERP (id))
9642 delete_tray_notification (f, XINT (id));
9643
9644 return Qnil;
9645 }
9646
9647 #endif /* WINDOWSNT && !HAVE_DBUS */
9648
9649 \f
9650 /***********************************************************************
9651 Initialization
9652 ***********************************************************************/
9653
9654 /* Keep this list in the same order as frame_parms in frame.c.
9655 Use 0 for unsupported frame parameters. */
9656
9657 frame_parm_handler w32_frame_parm_handlers[] =
9658 {
9659 x_set_autoraise,
9660 x_set_autolower,
9661 x_set_background_color,
9662 x_set_border_color,
9663 x_set_border_width,
9664 x_set_cursor_color,
9665 x_set_cursor_type,
9666 x_set_font,
9667 x_set_foreground_color,
9668 x_set_icon_name,
9669 x_set_icon_type,
9670 x_set_internal_border_width,
9671 x_set_right_divider_width,
9672 x_set_bottom_divider_width,
9673 x_set_menu_bar_lines,
9674 x_set_mouse_color,
9675 x_explicitly_set_name,
9676 x_set_scroll_bar_width,
9677 x_set_scroll_bar_height,
9678 x_set_title,
9679 x_set_unsplittable,
9680 x_set_vertical_scroll_bars,
9681 x_set_horizontal_scroll_bars,
9682 x_set_visibility,
9683 x_set_tool_bar_lines,
9684 0, /* x_set_scroll_bar_foreground, */
9685 0, /* x_set_scroll_bar_background, */
9686 x_set_screen_gamma,
9687 x_set_line_spacing,
9688 x_set_left_fringe,
9689 x_set_right_fringe,
9690 0, /* x_set_wait_for_wm, */
9691 x_set_fullscreen,
9692 x_set_font_backend,
9693 x_set_alpha,
9694 0, /* x_set_sticky */
9695 0, /* x_set_tool_bar_position */
9696 };
9697
9698 void
9699 syms_of_w32fns (void)
9700 {
9701 globals_of_w32fns ();
9702 track_mouse_window = NULL;
9703
9704 w32_visible_system_caret_hwnd = NULL;
9705
9706 DEFSYM (Qundefined_color, "undefined-color");
9707 DEFSYM (Qcancel_timer, "cancel-timer");
9708 DEFSYM (Qhyper, "hyper");
9709 DEFSYM (Qsuper, "super");
9710 DEFSYM (Qmeta, "meta");
9711 DEFSYM (Qalt, "alt");
9712 DEFSYM (Qctrl, "ctrl");
9713 DEFSYM (Qcontrol, "control");
9714 DEFSYM (Qshift, "shift");
9715 DEFSYM (Qfont_parameter, "font-parameter");
9716 DEFSYM (Qgeometry, "geometry");
9717 DEFSYM (Qworkarea, "workarea");
9718 DEFSYM (Qmm_size, "mm-size");
9719 DEFSYM (Qframes, "frames");
9720 DEFSYM (Qtip_frame, "tip-frame");
9721 DEFSYM (Qassq_delete_all, "assq-delete-all");
9722 DEFSYM (Qunicode_sip, "unicode-sip");
9723 #if defined WINDOWSNT && !defined HAVE_DBUS
9724 DEFSYM (QCicon, ":icon");
9725 DEFSYM (QCtip, ":tip");
9726 DEFSYM (QClevel, ":level");
9727 DEFSYM (Qinfo, "info");
9728 DEFSYM (Qwarning, "warning");
9729 DEFSYM (QCtitle, ":title");
9730 DEFSYM (QCbody, ":body");
9731 #endif
9732
9733 /* Symbols used elsewhere, but only in MS-Windows-specific code. */
9734 DEFSYM (Qgnutls, "gnutls");
9735 DEFSYM (Qlibxml2, "libxml2");
9736 DEFSYM (Qserif, "serif");
9737 DEFSYM (Qzlib, "zlib");
9738
9739 Fput (Qundefined_color, Qerror_conditions,
9740 listn (CONSTYPE_PURE, 2, Qundefined_color, Qerror));
9741 Fput (Qundefined_color, Qerror_message,
9742 build_pure_c_string ("Undefined color"));
9743
9744 staticpro (&w32_grabbed_keys);
9745 w32_grabbed_keys = Qnil;
9746
9747 DEFVAR_LISP ("w32-color-map", Vw32_color_map,
9748 doc: /* An array of color name mappings for Windows. */);
9749 Vw32_color_map = Qnil;
9750
9751 DEFVAR_LISP ("w32-pass-alt-to-system", Vw32_pass_alt_to_system,
9752 doc: /* Non-nil if Alt key presses are passed on to Windows.
9753 When non-nil, for example, Alt pressed and released and then space will
9754 open the System menu. When nil, Emacs processes the Alt key events, and
9755 then silently swallows them. */);
9756 Vw32_pass_alt_to_system = Qnil;
9757
9758 DEFVAR_LISP ("w32-alt-is-meta", Vw32_alt_is_meta,
9759 doc: /* Non-nil if the Alt key is to be considered the same as the META key.
9760 When nil, Emacs will translate the Alt key to the ALT modifier, not to META. */);
9761 Vw32_alt_is_meta = Qt;
9762
9763 DEFVAR_INT ("w32-quit-key", w32_quit_key,
9764 doc: /* If non-zero, the virtual key code for an alternative quit key. */);
9765 w32_quit_key = 0;
9766
9767 DEFVAR_LISP ("w32-pass-lwindow-to-system",
9768 Vw32_pass_lwindow_to_system,
9769 doc: /* If non-nil, the left \"Windows\" key is passed on to Windows.
9770
9771 When non-nil, the Start menu is opened by tapping the key.
9772 If you set this to nil, the left \"Windows\" key is processed by Emacs
9773 according to the value of `w32-lwindow-modifier', which see.
9774
9775 Note that some combinations of the left \"Windows\" key with other
9776 keys are caught by Windows at low level. For example, <lwindow>-r
9777 pops up the Windows Run dialog, <lwindow>-<Pause> pops up the "System
9778 Properties" dialog, etc. On Windows 10, no \"Windows\" key
9779 combinations are normally handed to applications. To enable Emacs to
9780 process \"Windows\" key combinations, use the function
9781 `w32-register-hot-key`.
9782
9783 For Windows 98/ME, see the doc string of `w32-phantom-key-code'. */);
9784 Vw32_pass_lwindow_to_system = Qt;
9785
9786 DEFVAR_LISP ("w32-pass-rwindow-to-system",
9787 Vw32_pass_rwindow_to_system,
9788 doc: /* If non-nil, the right \"Windows\" key is passed on to Windows.
9789
9790 When non-nil, the Start menu is opened by tapping the key.
9791 If you set this to nil, the right \"Windows\" key is processed by Emacs
9792 according to the value of `w32-rwindow-modifier', which see.
9793
9794 Note that some combinations of the right \"Windows\" key with other
9795 keys are caught by Windows at low level. For example, <rwindow>-r
9796 pops up the Windows Run dialog, <rwindow>-<Pause> pops up the "System
9797 Properties" dialog, etc. On Windows 10, no \"Windows\" key
9798 combinations are normally handed to applications. To enable Emacs to
9799 process \"Windows\" key combinations, use the function
9800 `w32-register-hot-key`.
9801
9802 For Windows 98/ME, see the doc string of `w32-phantom-key-code'. */);
9803 Vw32_pass_rwindow_to_system = Qt;
9804
9805 DEFVAR_LISP ("w32-phantom-key-code",
9806 Vw32_phantom_key_code,
9807 doc: /* Virtual key code used to generate \"phantom\" key presses.
9808 Value is a number between 0 and 255.
9809
9810 Phantom key presses are generated in order to stop the system from
9811 acting on \"Windows\" key events when `w32-pass-lwindow-to-system' or
9812 `w32-pass-rwindow-to-system' is nil.
9813
9814 This variable is only used on Windows 98 and ME. For other Windows
9815 versions, see the documentation of the `w32-register-hot-key`
9816 function. */);
9817 /* Although 255 is technically not a valid key code, it works and
9818 means that this hack won't interfere with any real key code. */
9819 XSETINT (Vw32_phantom_key_code, 255);
9820
9821 DEFVAR_LISP ("w32-enable-num-lock",
9822 Vw32_enable_num_lock,
9823 doc: /* If non-nil, the Num Lock key acts normally.
9824 Set to nil to handle Num Lock as the `kp-numlock' key. */);
9825 Vw32_enable_num_lock = Qt;
9826
9827 DEFVAR_LISP ("w32-enable-caps-lock",
9828 Vw32_enable_caps_lock,
9829 doc: /* If non-nil, the Caps Lock key acts normally.
9830 Set to nil to handle Caps Lock as the `capslock' key. */);
9831 Vw32_enable_caps_lock = Qt;
9832
9833 DEFVAR_LISP ("w32-scroll-lock-modifier",
9834 Vw32_scroll_lock_modifier,
9835 doc: /* Modifier to use for the Scroll Lock ON state.
9836 The value can be hyper, super, meta, alt, control or shift for the
9837 respective modifier, or nil to handle Scroll Lock as the `scroll' key.
9838 Any other value will cause the Scroll Lock key to be ignored. */);
9839 Vw32_scroll_lock_modifier = Qnil;
9840
9841 DEFVAR_LISP ("w32-lwindow-modifier",
9842 Vw32_lwindow_modifier,
9843 doc: /* Modifier to use for the left \"Windows\" key.
9844 The value can be hyper, super, meta, alt, control or shift for the
9845 respective modifier, or nil to appear as the `lwindow' key.
9846 Any other value will cause the key to be ignored.
9847
9848 Also see the documentation of the `w32-register-hot-key` function. */);
9849 Vw32_lwindow_modifier = Qnil;
9850
9851 DEFVAR_LISP ("w32-rwindow-modifier",
9852 Vw32_rwindow_modifier,
9853 doc: /* Modifier to use for the right \"Windows\" key.
9854 The value can be hyper, super, meta, alt, control or shift for the
9855 respective modifier, or nil to appear as the `rwindow' key.
9856 Any other value will cause the key to be ignored.
9857
9858 Also see the documentation of the `w32-register-hot-key` function. */);
9859 Vw32_rwindow_modifier = Qnil;
9860
9861 DEFVAR_LISP ("w32-apps-modifier",
9862 Vw32_apps_modifier,
9863 doc: /* Modifier to use for the \"Apps\" key.
9864 The value can be hyper, super, meta, alt, control or shift for the
9865 respective modifier, or nil to appear as the `apps' key.
9866 Any other value will cause the key to be ignored. */);
9867 Vw32_apps_modifier = Qnil;
9868
9869 DEFVAR_BOOL ("w32-enable-synthesized-fonts", w32_enable_synthesized_fonts,
9870 doc: /* Non-nil enables selection of artificially italicized and bold fonts. */);
9871 w32_enable_synthesized_fonts = 0;
9872
9873 DEFVAR_LISP ("w32-enable-palette", Vw32_enable_palette,
9874 doc: /* Non-nil enables Windows palette management to map colors exactly. */);
9875 Vw32_enable_palette = Qt;
9876
9877 DEFVAR_INT ("w32-mouse-button-tolerance",
9878 w32_mouse_button_tolerance,
9879 doc: /* Analogue of double click interval for faking middle mouse events.
9880 The value is the minimum time in milliseconds that must elapse between
9881 left and right button down events before they are considered distinct events.
9882 If both mouse buttons are depressed within this interval, a middle mouse
9883 button down event is generated instead. */);
9884 w32_mouse_button_tolerance = GetDoubleClickTime () / 2;
9885
9886 DEFVAR_INT ("w32-mouse-move-interval",
9887 w32_mouse_move_interval,
9888 doc: /* Minimum interval between mouse move events.
9889 The value is the minimum time in milliseconds that must elapse between
9890 successive mouse move (or scroll bar drag) events before they are
9891 reported as lisp events. */);
9892 w32_mouse_move_interval = 0;
9893
9894 DEFVAR_BOOL ("w32-pass-extra-mouse-buttons-to-system",
9895 w32_pass_extra_mouse_buttons_to_system,
9896 doc: /* If non-nil, the fourth and fifth mouse buttons are passed to Windows.
9897 Recent versions of Windows support mice with up to five buttons.
9898 Since most applications don't support these extra buttons, most mouse
9899 drivers will allow you to map them to functions at the system level.
9900 If this variable is non-nil, Emacs will pass them on, allowing the
9901 system to handle them. */);
9902 w32_pass_extra_mouse_buttons_to_system = 0;
9903
9904 DEFVAR_BOOL ("w32-pass-multimedia-buttons-to-system",
9905 w32_pass_multimedia_buttons_to_system,
9906 doc: /* If non-nil, media buttons are passed to Windows.
9907 Some modern keyboards contain buttons for controlling media players, web
9908 browsers and other applications. Generally these buttons are handled on a
9909 system wide basis, but by setting this to nil they are made available
9910 to Emacs for binding. Depending on your keyboard, additional keys that
9911 may be available are:
9912
9913 browser-back, browser-forward, browser-refresh, browser-stop,
9914 browser-search, browser-favorites, browser-home,
9915 mail, mail-reply, mail-forward, mail-send,
9916 app-1, app-2,
9917 help, find, new, open, close, save, print, undo, redo, copy, cut, paste,
9918 spell-check, correction-list, toggle-dictate-command,
9919 media-next, media-previous, media-stop, media-play-pause, media-select,
9920 media-play, media-pause, media-record, media-fast-forward, media-rewind,
9921 media-channel-up, media-channel-down,
9922 volume-mute, volume-up, volume-down,
9923 mic-volume-mute, mic-volume-down, mic-volume-up, mic-toggle,
9924 bass-down, bass-boost, bass-up, treble-down, treble-up */);
9925 w32_pass_multimedia_buttons_to_system = 1;
9926
9927 #if 0 /* TODO: Mouse cursor customization. */
9928 DEFVAR_LISP ("x-pointer-shape", Vx_pointer_shape,
9929 doc: /* The shape of the pointer when over text.
9930 Changing the value does not affect existing frames
9931 unless you set the mouse color. */);
9932 Vx_pointer_shape = Qnil;
9933
9934 Vx_nontext_pointer_shape = Qnil;
9935
9936 Vx_mode_pointer_shape = Qnil;
9937
9938 DEFVAR_LISP ("x-hourglass-pointer-shape", Vx_hourglass_pointer_shape,
9939 doc: /* The shape of the pointer when Emacs is busy.
9940 This variable takes effect when you create a new frame
9941 or when you set the mouse color. */);
9942 Vx_hourglass_pointer_shape = Qnil;
9943
9944 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
9945 Vx_sensitive_text_pointer_shape,
9946 doc: /* The shape of the pointer when over mouse-sensitive text.
9947 This variable takes effect when you create a new frame
9948 or when you set the mouse color. */);
9949 Vx_sensitive_text_pointer_shape = Qnil;
9950
9951 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
9952 Vx_window_horizontal_drag_shape,
9953 doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
9954 This variable takes effect when you create a new frame
9955 or when you set the mouse color. */);
9956 Vx_window_horizontal_drag_shape = Qnil;
9957
9958 DEFVAR_LISP ("x-window-vertical-drag-cursor",
9959 Vx_window_vertical_drag_shape,
9960 doc: /* Pointer shape to use for indicating a window can be dragged vertically.
9961 This variable takes effect when you create a new frame
9962 or when you set the mouse color. */);
9963 Vx_window_vertical_drag_shape = Qnil;
9964 #endif
9965
9966 DEFVAR_LISP ("x-cursor-fore-pixel", Vx_cursor_fore_pixel,
9967 doc: /* A string indicating the foreground color of the cursor box. */);
9968 Vx_cursor_fore_pixel = Qnil;
9969
9970 DEFVAR_LISP ("x-max-tooltip-size", Vx_max_tooltip_size,
9971 doc: /* Maximum size for tooltips.
9972 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
9973 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
9974
9975 DEFVAR_LISP ("x-no-window-manager", Vx_no_window_manager,
9976 doc: /* Non-nil if no window manager is in use.
9977 Emacs doesn't try to figure this out; this is always nil
9978 unless you set it to something else. */);
9979 /* We don't have any way to find this out, so set it to nil
9980 and maybe the user would like to set it to t. */
9981 Vx_no_window_manager = Qnil;
9982
9983 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
9984 Vx_pixel_size_width_font_regexp,
9985 doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
9986
9987 Since Emacs gets width of a font matching with this regexp from
9988 PIXEL_SIZE field of the name, font finding mechanism gets faster for
9989 such a font. This is especially effective for such large fonts as
9990 Chinese, Japanese, and Korean. */);
9991 Vx_pixel_size_width_font_regexp = Qnil;
9992
9993 DEFVAR_LISP ("w32-bdf-filename-alist",
9994 Vw32_bdf_filename_alist,
9995 doc: /* List of bdf fonts and their corresponding filenames. */);
9996 Vw32_bdf_filename_alist = Qnil;
9997
9998 DEFVAR_BOOL ("w32-strict-fontnames",
9999 w32_strict_fontnames,
10000 doc: /* Non-nil means only use fonts that are exact matches for those requested.
10001 Default is nil, which allows old fontnames that are not XLFD compliant,
10002 and allows third-party CJK display to work by specifying false charset
10003 fields to trick Emacs into translating to Big5, SJIS etc.
10004 Setting this to t will prevent wrong fonts being selected when
10005 fontsets are automatically created. */);
10006 w32_strict_fontnames = 0;
10007
10008 DEFVAR_BOOL ("w32-strict-painting",
10009 w32_strict_painting,
10010 doc: /* Non-nil means use strict rules for repainting frames.
10011 Set this to nil to get the old behavior for repainting; this should
10012 only be necessary if the default setting causes problems. */);
10013 w32_strict_painting = 1;
10014
10015 DEFVAR_BOOL ("w32-use-fallback-wm-chars-method",
10016 w32_use_fallback_wm_chars_method,
10017 doc: /* Non-nil means use old method of processing character keys.
10018 This is intended only for debugging of the new processing method.
10019 Default is nil.
10020
10021 This variable has effect only on NT family of systems, not on Windows 9X. */);
10022 w32_use_fallback_wm_chars_method = 0;
10023
10024 DEFVAR_BOOL ("w32-disable-new-uniscribe-apis",
10025 w32_disable_new_uniscribe_apis,
10026 doc: /* Non-nil means don't use new Uniscribe APIs.
10027 The new APIs are used to access OTF features supported by fonts.
10028 This is intended only for debugging of the new Uniscribe-related code.
10029 Default is nil.
10030
10031 This variable has effect only on Windows Vista and later. */);
10032 w32_disable_new_uniscribe_apis = 0;
10033
10034 DEFVAR_LISP ("w32-tooltip-extra-pixels",
10035 Vw32_tooltip_extra_pixels,
10036 doc: /* Number of pixels added after tooltip text.
10037 On Windows some fonts may cause the last character of a tooltip be
10038 truncated or wrapped around to the next line. Adding some extra space
10039 at the end of the toooltip works around this problem.
10040
10041 This variable specifies the number of pixels that shall be added. The
10042 default value t means to add the width of one canonical character of the
10043 tip frame. */);
10044 Vw32_tooltip_extra_pixels = Qt;
10045
10046 #if 0 /* TODO: Port to W32 */
10047 defsubr (&Sx_change_window_property);
10048 defsubr (&Sx_delete_window_property);
10049 defsubr (&Sx_window_property);
10050 #endif
10051 defsubr (&Sxw_display_color_p);
10052 defsubr (&Sx_display_grayscale_p);
10053 defsubr (&Sxw_color_defined_p);
10054 defsubr (&Sxw_color_values);
10055 defsubr (&Sx_server_max_request_size);
10056 defsubr (&Sx_server_vendor);
10057 defsubr (&Sx_server_version);
10058 defsubr (&Sx_display_pixel_width);
10059 defsubr (&Sx_display_pixel_height);
10060 defsubr (&Sx_display_mm_width);
10061 defsubr (&Sx_display_mm_height);
10062 defsubr (&Sx_display_screens);
10063 defsubr (&Sx_display_planes);
10064 defsubr (&Sx_display_color_cells);
10065 defsubr (&Sx_display_visual_class);
10066 defsubr (&Sx_display_backing_store);
10067 defsubr (&Sx_display_save_under);
10068 defsubr (&Sx_create_frame);
10069 defsubr (&Sx_open_connection);
10070 defsubr (&Sx_close_connection);
10071 defsubr (&Sx_display_list);
10072 defsubr (&Sw32_frame_geometry);
10073 defsubr (&Sw32_frame_edges);
10074 defsubr (&Sw32_mouse_absolute_pixel_position);
10075 defsubr (&Sw32_set_mouse_absolute_pixel_position);
10076 defsubr (&Sx_synchronize);
10077
10078 /* W32 specific functions */
10079
10080 defsubr (&Sw32_define_rgb_color);
10081 defsubr (&Sw32_default_color_map);
10082 defsubr (&Sw32_display_monitor_attributes_list);
10083 defsubr (&Sw32_send_sys_command);
10084 defsubr (&Sw32_shell_execute);
10085 defsubr (&Sw32_register_hot_key);
10086 defsubr (&Sw32_unregister_hot_key);
10087 defsubr (&Sw32_registered_hot_keys);
10088 defsubr (&Sw32_reconstruct_hot_key);
10089 defsubr (&Sw32_toggle_lock_key);
10090 defsubr (&Sw32_window_exists_p);
10091 defsubr (&Sw32_battery_status);
10092 defsubr (&Sw32__menu_bar_in_use);
10093 #if defined WINDOWSNT && !defined HAVE_DBUS
10094 defsubr (&Sw32_notification_notify);
10095 defsubr (&Sw32_notification_close);
10096 #endif
10097
10098 #ifdef WINDOWSNT
10099 defsubr (&Sfile_system_info);
10100 defsubr (&Sdefault_printer_name);
10101 #endif
10102
10103 defsubr (&Sset_message_beep);
10104 defsubr (&Sx_show_tip);
10105 defsubr (&Sx_hide_tip);
10106 tip_timer = Qnil;
10107 staticpro (&tip_timer);
10108 tip_frame = Qnil;
10109 staticpro (&tip_frame);
10110
10111 last_show_tip_args = Qnil;
10112 staticpro (&last_show_tip_args);
10113
10114 defsubr (&Sx_file_dialog);
10115 #ifdef WINDOWSNT
10116 defsubr (&Ssystem_move_file_to_trash);
10117 #endif
10118 }
10119
10120 \f
10121
10122 /* Crashing and reporting backtrace. */
10123
10124 #ifndef CYGWIN
10125 static LONG CALLBACK my_exception_handler (EXCEPTION_POINTERS *);
10126 static LPTOP_LEVEL_EXCEPTION_FILTER prev_exception_handler;
10127 #endif
10128 static DWORD except_code;
10129 static PVOID except_addr;
10130
10131 #ifndef CYGWIN
10132
10133 /* Stack overflow recovery. */
10134
10135 /* MinGW headers don't declare this (should be in malloc.h). Also,
10136 the function is not present pre-W2K, so make the call through
10137 a function pointer. */
10138 typedef int (__cdecl *_resetstkoflw_proc) (void);
10139 static _resetstkoflw_proc resetstkoflw;
10140
10141 /* Re-establish the guard page at stack limit. This is needed because
10142 when a stack overflow is detected, Windows removes the guard bit
10143 from the guard page, so if we don't re-establish that protection,
10144 the next stack overflow will cause a crash. */
10145 void
10146 w32_reset_stack_overflow_guard (void)
10147 {
10148 if (resetstkoflw == NULL)
10149 resetstkoflw =
10150 (_resetstkoflw_proc)GetProcAddress (GetModuleHandle ("msvcrt.dll"),
10151 "_resetstkoflw");
10152 /* We ignore the return value. If _resetstkoflw fails, the next
10153 stack overflow will crash the program. */
10154 if (resetstkoflw != NULL)
10155 (void)resetstkoflw ();
10156 }
10157
10158 static void
10159 stack_overflow_handler (void)
10160 {
10161 /* Hard GC error may lead to stack overflow caused by
10162 too nested calls to mark_object. No way to survive. */
10163 if (gc_in_progress)
10164 terminate_due_to_signal (SIGSEGV, 40);
10165 #ifdef _WIN64
10166 /* See ms-w32.h: MinGW64's longjmp crashes if invoked in this context. */
10167 __builtin_longjmp (return_to_command_loop, 1);
10168 #else
10169 sys_longjmp (return_to_command_loop, 1);
10170 #endif
10171 }
10172
10173 /* This handler records the exception code and the address where it
10174 was triggered so that this info could be included in the backtrace.
10175 Without that, the backtrace in some cases has no information
10176 whatsoever about the offending code, and looks as if the top-level
10177 exception handler in the MinGW startup code was the one that
10178 crashed. We also recover from stack overflow, by calling our stack
10179 overflow handler that jumps back to top level. */
10180 static LONG CALLBACK
10181 my_exception_handler (EXCEPTION_POINTERS * exception_data)
10182 {
10183 except_code = exception_data->ExceptionRecord->ExceptionCode;
10184 except_addr = exception_data->ExceptionRecord->ExceptionAddress;
10185
10186 /* If this is a stack overflow exception, attempt to recover. */
10187 if (exception_data->ExceptionRecord->ExceptionCode == EXCEPTION_STACK_OVERFLOW
10188 && exception_data->ExceptionRecord->NumberParameters == 2
10189 /* We can only longjmp to top level from the main thread. */
10190 && GetCurrentThreadId () == dwMainThreadId)
10191 {
10192 /* Call stack_overflow_handler (). */
10193 #ifdef _WIN64
10194 exception_data->ContextRecord->Rip = (DWORD_PTR) &stack_overflow_handler;
10195 #else
10196 exception_data->ContextRecord->Eip = (DWORD_PTR) &stack_overflow_handler;
10197 #endif
10198 /* Zero this out, so the stale address of the stack overflow
10199 exception we handled is not displayed in some future
10200 unrelated crash. */
10201 except_addr = 0;
10202 return EXCEPTION_CONTINUE_EXECUTION;
10203 }
10204
10205 if (prev_exception_handler)
10206 return prev_exception_handler (exception_data);
10207 return EXCEPTION_EXECUTE_HANDLER;
10208 }
10209 #endif
10210
10211 typedef USHORT (WINAPI * CaptureStackBackTrace_proc) (ULONG, ULONG, PVOID *,
10212 PULONG);
10213
10214 #define BACKTRACE_LIMIT_MAX 62
10215
10216 int
10217 w32_backtrace (void **buffer, int limit)
10218 {
10219 static CaptureStackBackTrace_proc s_pfn_CaptureStackBackTrace = NULL;
10220 HMODULE hm_kernel32 = NULL;
10221
10222 if (!s_pfn_CaptureStackBackTrace)
10223 {
10224 hm_kernel32 = LoadLibrary ("Kernel32.dll");
10225 s_pfn_CaptureStackBackTrace =
10226 (CaptureStackBackTrace_proc) GetProcAddress (hm_kernel32,
10227 "RtlCaptureStackBackTrace");
10228 }
10229 if (s_pfn_CaptureStackBackTrace)
10230 return s_pfn_CaptureStackBackTrace (0, min (BACKTRACE_LIMIT_MAX, limit),
10231 buffer, NULL);
10232 return 0;
10233 }
10234
10235 void
10236 emacs_abort (void)
10237 {
10238 int button;
10239 button = MessageBox (NULL,
10240 "A fatal error has occurred!\n\n"
10241 "Would you like to attach a debugger?\n\n"
10242 "Select:\n"
10243 "YES -- to debug Emacs, or\n"
10244 "NO -- to abort Emacs and produce a backtrace\n"
10245 " (emacs_backtrace.txt in current directory)."
10246 #if __GNUC__
10247 "\n\n(type \"gdb -p <emacs-PID>\" and\n"
10248 "\"continue\" inside GDB before clicking YES.)"
10249 #endif
10250 , "Emacs Abort Dialog",
10251 MB_ICONEXCLAMATION | MB_TASKMODAL
10252 | MB_SETFOREGROUND | MB_YESNO);
10253 switch (button)
10254 {
10255 case IDYES:
10256 DebugBreak ();
10257 exit (2); /* tell the compiler we will never return */
10258 case IDNO:
10259 default:
10260 {
10261 void *stack[BACKTRACE_LIMIT_MAX + 1];
10262 int i = w32_backtrace (stack, BACKTRACE_LIMIT_MAX + 1);
10263
10264 if (i)
10265 {
10266 int errfile_fd = -1;
10267 int j;
10268 char buf[sizeof ("\r\nException at this address:\r\n\r\n")
10269 /* The type below should really be 'void *', but
10270 INT_BUFSIZE_BOUND cannot handle that without
10271 triggering compiler warnings (under certain
10272 pedantic warning switches), it wants an
10273 integer type. */
10274 + 2 * INT_BUFSIZE_BOUND (intptr_t)];
10275 #ifdef CYGWIN
10276 int stderr_fd = 2;
10277 #else
10278 HANDLE errout = GetStdHandle (STD_ERROR_HANDLE);
10279 int stderr_fd = -1;
10280
10281 if (errout && errout != INVALID_HANDLE_VALUE)
10282 stderr_fd = _open_osfhandle ((intptr_t)errout, O_APPEND | O_BINARY);
10283 #endif
10284
10285 /* We use %p, not 0x%p, as %p produces a leading "0x" on XP,
10286 but not on Windows 7. addr2line doesn't mind a missing
10287 "0x", but will be confused by an extra one. */
10288 if (except_addr)
10289 sprintf (buf, "\r\nException 0x%lx at this address:\r\n%p\r\n",
10290 except_code, except_addr);
10291 if (stderr_fd >= 0)
10292 {
10293 if (except_addr)
10294 write (stderr_fd, buf, strlen (buf));
10295 write (stderr_fd, "\r\nBacktrace:\r\n", 14);
10296 }
10297 #ifdef CYGWIN
10298 #define _open open
10299 #endif
10300 errfile_fd = _open ("emacs_backtrace.txt", O_RDWR | O_CREAT | O_BINARY, S_IREAD | S_IWRITE);
10301 if (errfile_fd >= 0)
10302 {
10303 lseek (errfile_fd, 0L, SEEK_END);
10304 if (except_addr)
10305 write (errfile_fd, buf, strlen (buf));
10306 write (errfile_fd, "\r\nBacktrace:\r\n", 14);
10307 }
10308
10309 for (j = 0; j < i; j++)
10310 {
10311 /* stack[] gives the return addresses, whereas we want
10312 the address of the call, so decrease each address
10313 by approximate size of 1 CALL instruction. */
10314 sprintf (buf, "%p\r\n", (char *)stack[j] - sizeof(void *));
10315 if (stderr_fd >= 0)
10316 write (stderr_fd, buf, strlen (buf));
10317 if (errfile_fd >= 0)
10318 write (errfile_fd, buf, strlen (buf));
10319 }
10320 if (i == BACKTRACE_LIMIT_MAX)
10321 {
10322 if (stderr_fd >= 0)
10323 write (stderr_fd, "...\r\n", 5);
10324 if (errfile_fd >= 0)
10325 write (errfile_fd, "...\r\n", 5);
10326 }
10327 if (errfile_fd >= 0)
10328 close (errfile_fd);
10329 }
10330 abort ();
10331 break;
10332 }
10333 }
10334 }
10335
10336 \f
10337
10338 /* Initialization. */
10339
10340 /*
10341 globals_of_w32fns is used to initialize those global variables that
10342 must always be initialized on startup even when the global variable
10343 initialized is non zero (see the function main in emacs.c).
10344 globals_of_w32fns is called from syms_of_w32fns when the global
10345 variable initialized is 0 and directly from main when initialized
10346 is non zero.
10347 */
10348 void
10349 globals_of_w32fns (void)
10350 {
10351 HMODULE user32_lib = GetModuleHandle ("user32.dll");
10352 /*
10353 TrackMouseEvent not available in all versions of Windows, so must load
10354 it dynamically. Do it once, here, instead of every time it is used.
10355 */
10356 track_mouse_event_fn = (TrackMouseEvent_Proc)
10357 GetProcAddress (user32_lib, "TrackMouseEvent");
10358
10359 monitor_from_point_fn = (MonitorFromPoint_Proc)
10360 GetProcAddress (user32_lib, "MonitorFromPoint");
10361 get_monitor_info_fn = (GetMonitorInfo_Proc)
10362 GetProcAddress (user32_lib, "GetMonitorInfoA");
10363 monitor_from_window_fn = (MonitorFromWindow_Proc)
10364 GetProcAddress (user32_lib, "MonitorFromWindow");
10365 enum_display_monitors_fn = (EnumDisplayMonitors_Proc)
10366 GetProcAddress (user32_lib, "EnumDisplayMonitors");
10367 get_title_bar_info_fn = (GetTitleBarInfo_Proc)
10368 GetProcAddress (user32_lib, "GetTitleBarInfo");
10369
10370 {
10371 HMODULE imm32_lib = GetModuleHandle ("imm32.dll");
10372 get_composition_string_fn = (ImmGetCompositionString_Proc)
10373 GetProcAddress (imm32_lib, "ImmGetCompositionStringW");
10374 get_ime_context_fn = (ImmGetContext_Proc)
10375 GetProcAddress (imm32_lib, "ImmGetContext");
10376 release_ime_context_fn = (ImmReleaseContext_Proc)
10377 GetProcAddress (imm32_lib, "ImmReleaseContext");
10378 set_ime_composition_window_fn = (ImmSetCompositionWindow_Proc)
10379 GetProcAddress (imm32_lib, "ImmSetCompositionWindow");
10380 }
10381
10382 except_code = 0;
10383 except_addr = 0;
10384 #ifndef CYGWIN
10385 prev_exception_handler = SetUnhandledExceptionFilter (my_exception_handler);
10386 resetstkoflw = NULL;
10387 #endif
10388
10389 DEFVAR_INT ("w32-ansi-code-page",
10390 w32_ansi_code_page,
10391 doc: /* The ANSI code page used by the system. */);
10392 w32_ansi_code_page = GetACP ();
10393
10394 if (os_subtype == OS_NT)
10395 w32_unicode_gui = 1;
10396 else
10397 w32_unicode_gui = 0;
10398
10399 after_deadkey = -1;
10400
10401 /* MessageBox does not work without this when linked to comctl32.dll 6.0. */
10402 InitCommonControls ();
10403
10404 syms_of_w32uniscribe ();
10405 }
10406
10407 #ifdef NTGUI_UNICODE
10408
10409 Lisp_Object
10410 ntgui_encode_system (Lisp_Object str)
10411 {
10412 Lisp_Object encoded;
10413 to_unicode (str, &encoded);
10414 return encoded;
10415 }
10416
10417 #endif /* NTGUI_UNICODE */