]> code.delx.au - gnu-emacs/blob - src/w32fns.c
delx.au / code / gnu-emacs / blob


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