]> code.delx.au - gnu-emacs/blob - src/w32fns.c
delx.au / code / gnu-emacs / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Handle NULL pointers in w32heap.c allocation routines
[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 <c-ctype.h>
33
34 #include "lisp.h"
35 #include "w32term.h"
36 #include "frame.h"
37 #include "window.h"
38 #include "character.h"
39 #include "buffer.h"
40 #include "intervals.h"
41 #include "dispextern.h"
42 #include "keyboard.h"
43 #include "blockinput.h"
44 #include "epaths.h"
45 #include "charset.h"
46 #include "coding.h"
47 #include "ccl.h"
48 #include "fontset.h"
49 #include "systime.h"
50 #include "termhooks.h"
51
52 #include "w32common.h"
53
54 #ifdef WINDOWSNT
55 #include "w32heap.h"
56 #include <mbstring.h>
57 #endif /* WINDOWSNT */
58
59 #if CYGWIN
60 #include "cygw32.h"
61 #else
62 #include "w32.h"
63 #endif
64
65 #include "bitmaps/gray.xbm"
66
67 #include <commctrl.h>
68 #include <commdlg.h>
69 #include <shellapi.h>
70 #include <ctype.h>
71 #include <winspool.h>
72 #include <objbase.h>
73
74 #include <dlgs.h>
75 #include <imm.h>
76 #include <windowsx.h>
77
78 #include "font.h"
79 #include "w32font.h"
80
81 #ifndef FOF_NO_CONNECTED_ELEMENTS
82 #define FOF_NO_CONNECTED_ELEMENTS 0x2000
83 #endif
84
85 void syms_of_w32fns (void);
86 void globals_of_w32fns (void);
87
88 extern void free_frame_menubar (struct frame *);
89 extern int w32_console_toggle_lock_key (int, Lisp_Object);
90 extern void w32_menu_display_help (HWND, HMENU, UINT, UINT);
91 extern void w32_free_menu_strings (HWND);
92 extern const char *map_w32_filename (const char *, const char **);
93 extern char * w32_strerror (int error_no);
94
95 #ifndef IDC_HAND
96 #define IDC_HAND MAKEINTRESOURCE(32649)
97 #endif
98
99 /* Prefix for system colors. */
100 #define SYSTEM_COLOR_PREFIX "System"
101 #define SYSTEM_COLOR_PREFIX_LEN (sizeof (SYSTEM_COLOR_PREFIX) - 1)
102
103 /* State variables for emulating a three button mouse. */
104 #define LMOUSE 1
105 #define MMOUSE 2
106 #define RMOUSE 4
107
108 static int button_state = 0;
109 static W32Msg saved_mouse_button_msg;
110 static unsigned mouse_button_timer = 0; /* non-zero when timer is active */
111 static W32Msg saved_mouse_move_msg;
112 static unsigned mouse_move_timer = 0;
113
114 /* Window that is tracking the mouse. */
115 static HWND track_mouse_window;
116
117 /* Multi-monitor API definitions that are not pulled from the headers
118 since we are compiling for NT 4. */
119 #ifndef MONITOR_DEFAULT_TO_NEAREST
120 #define MONITOR_DEFAULT_TO_NEAREST 2
121 #endif
122 #ifndef MONITORINFOF_PRIMARY
123 #define MONITORINFOF_PRIMARY 1
124 #endif
125 #ifndef SM_XVIRTUALSCREEN
126 #define SM_XVIRTUALSCREEN 76
127 #endif
128 #ifndef SM_YVIRTUALSCREEN
129 #define SM_YVIRTUALSCREEN 77
130 #endif
131 /* MinGW headers define MONITORINFO unconditionally, but MSVC ones don't.
132 To avoid a compile error on one or the other, redefine with a new name. */
133 struct MONITOR_INFO
134 {
135 DWORD cbSize;
136 RECT rcMonitor;
137 RECT rcWork;
138 DWORD dwFlags;
139 };
140
141 #ifndef CCHDEVICENAME
142 #define CCHDEVICENAME 32
143 #endif
144 struct MONITOR_INFO_EX
145 {
146 DWORD cbSize;
147 RECT rcMonitor;
148 RECT rcWork;
149 DWORD dwFlags;
150 char szDevice[CCHDEVICENAME];
151 };
152
153 /* Reportedly, MSVC does not have this in its headers. */
154 #if defined (_MSC_VER) && _WIN32_WINNT < 0x0500
155 DECLARE_HANDLE(HMONITOR);
156 #endif
157
158 typedef BOOL (WINAPI * TrackMouseEvent_Proc)
159 (IN OUT LPTRACKMOUSEEVENT lpEventTrack);
160 typedef LONG (WINAPI * ImmGetCompositionString_Proc)
161 (IN HIMC context, IN DWORD index, OUT LPVOID buffer, IN DWORD bufLen);
162 typedef HIMC (WINAPI * ImmGetContext_Proc) (IN HWND window);
163 typedef BOOL (WINAPI * ImmReleaseContext_Proc) (IN HWND wnd, IN HIMC context);
164 typedef BOOL (WINAPI * ImmSetCompositionWindow_Proc) (IN HIMC context,
165 IN COMPOSITIONFORM *form);
166 typedef HMONITOR (WINAPI * MonitorFromPoint_Proc) (IN POINT pt, IN DWORD flags);
167 typedef BOOL (WINAPI * GetMonitorInfo_Proc)
168 (IN HMONITOR monitor, OUT struct MONITOR_INFO* info);
169 typedef HMONITOR (WINAPI * MonitorFromWindow_Proc)
170 (IN HWND hwnd, IN DWORD dwFlags);
171 typedef BOOL CALLBACK (* MonitorEnum_Proc)
172 (IN HMONITOR monitor, IN HDC hdc, IN RECT *rcMonitor, IN LPARAM dwData);
173 typedef BOOL (WINAPI * EnumDisplayMonitors_Proc)
174 (IN HDC hdc, IN RECT *rcClip, IN MonitorEnum_Proc fnEnum, IN LPARAM dwData);
175
176 TrackMouseEvent_Proc track_mouse_event_fn = NULL;
177 ImmGetCompositionString_Proc get_composition_string_fn = NULL;
178 ImmGetContext_Proc get_ime_context_fn = NULL;
179 ImmReleaseContext_Proc release_ime_context_fn = NULL;
180 ImmSetCompositionWindow_Proc set_ime_composition_window_fn = NULL;
181 MonitorFromPoint_Proc monitor_from_point_fn = NULL;
182 GetMonitorInfo_Proc get_monitor_info_fn = NULL;
183 MonitorFromWindow_Proc monitor_from_window_fn = NULL;
184 EnumDisplayMonitors_Proc enum_display_monitors_fn = NULL;
185
186 #ifdef NTGUI_UNICODE
187 #define unicode_append_menu AppendMenuW
188 #else /* !NTGUI_UNICODE */
189 extern AppendMenuW_Proc unicode_append_menu;
190 #endif /* NTGUI_UNICODE */
191
192 /* Flag to selectively ignore WM_IME_CHAR messages. */
193 static int ignore_ime_char = 0;
194
195 /* W95 mousewheel handler */
196 unsigned int msh_mousewheel = 0;
197
198 /* Timers */
199 #define MOUSE_BUTTON_ID 1
200 #define MOUSE_MOVE_ID 2
201 #define MENU_FREE_ID 3
202 /* The delay (milliseconds) before a menu is freed after WM_EXITMENULOOP
203 is received. */
204 #define MENU_FREE_DELAY 1000
205 static unsigned menu_free_timer = 0;
206
207 #ifdef GLYPH_DEBUG
208 static ptrdiff_t image_cache_refcount;
209 static int dpyinfo_refcount;
210 #endif
211
212 static HWND w32_visible_system_caret_hwnd;
213
214 static int w32_unicode_gui;
215
216 /* From w32menu.c */
217 extern HMENU current_popup_menu;
218 int menubar_in_use = 0;
219
220 /* From w32uniscribe.c */
221 extern void syms_of_w32uniscribe (void);
222 extern int uniscribe_available;
223
224 #ifdef WINDOWSNT
225 /* From w32inevt.c */
226 extern int faked_key;
227 #endif /* WINDOWSNT */
228
229 /* This gives us the page size and the size of the allocation unit on NT. */
230 SYSTEM_INFO sysinfo_cache;
231
232 /* This gives us version, build, and platform identification. */
233 OSVERSIONINFO osinfo_cache;
234
235 DWORD_PTR syspage_mask = 0;
236
237 /* The major and minor versions of NT. */
238 int w32_major_version;
239 int w32_minor_version;
240 int w32_build_number;
241
242 /* Distinguish between Windows NT and Windows 95. */
243 int os_subtype;
244
245 #ifdef HAVE_NTGUI
246 HINSTANCE hinst = NULL;
247 #endif
248
249 static unsigned int sound_type = 0xFFFFFFFF;
250 #define MB_EMACS_SILENT (0xFFFFFFFF - 1)
251
252 /* Let the user specify a display with a frame.
253 nil stands for the selected frame--or, if that is not a w32 frame,
254 the first display on the list. */
255
256 struct w32_display_info *
257 check_x_display_info (Lisp_Object object)
258 {
259 if (NILP (object))
260 {
261 struct frame *sf = XFRAME (selected_frame);
262
263 if (FRAME_W32_P (sf) && FRAME_LIVE_P (sf))
264 return FRAME_DISPLAY_INFO (sf);
265 else
266 return &one_w32_display_info;
267 }
268 else if (TERMINALP (object))
269 {
270 struct terminal *t = decode_live_terminal (object);
271
272 if (t->type != output_w32)
273 error ("Terminal %d is not a W32 display", t->id);
274
275 return t->display_info.w32;
276 }
277 else if (STRINGP (object))
278 return x_display_info_for_name (object);
279 else
280 {
281 struct frame *f;
282
283 CHECK_LIVE_FRAME (object);
284 f = XFRAME (object);
285 if (! FRAME_W32_P (f))
286 error ("Non-W32 frame used");
287 return FRAME_DISPLAY_INFO (f);
288 }
289 }
290 \f
291 /* Return the Emacs frame-object corresponding to an w32 window.
292 It could be the frame's main window or an icon window. */
293
294 struct frame *
295 x_window_to_frame (struct w32_display_info *dpyinfo, HWND wdesc)
296 {
297 Lisp_Object tail, frame;
298 struct frame *f;
299
300 FOR_EACH_FRAME (tail, frame)
301 {
302 f = XFRAME (frame);
303 if (!FRAME_W32_P (f) || FRAME_DISPLAY_INFO (f) != dpyinfo)
304 continue;
305
306 if (FRAME_W32_WINDOW (f) == wdesc)
307 return f;
308 }
309 return 0;
310 }
311
312 \f
313 static Lisp_Object unwind_create_frame (Lisp_Object);
314 static void unwind_create_tip_frame (Lisp_Object);
315 static void my_create_window (struct frame *);
316 static void my_create_tip_window (struct frame *);
317
318 /* TODO: Native Input Method support; see x_create_im. */
319 void x_set_foreground_color (struct frame *, Lisp_Object, Lisp_Object);
320 void x_set_background_color (struct frame *, Lisp_Object, Lisp_Object);
321 void x_set_mouse_color (struct frame *, Lisp_Object, Lisp_Object);
322 void x_set_cursor_color (struct frame *, Lisp_Object, Lisp_Object);
323 void x_set_border_color (struct frame *, Lisp_Object, Lisp_Object);
324 void x_set_cursor_type (struct frame *, Lisp_Object, Lisp_Object);
325 void x_set_icon_type (struct frame *, Lisp_Object, Lisp_Object);
326 void x_set_icon_name (struct frame *, Lisp_Object, Lisp_Object);
327 void x_explicitly_set_name (struct frame *, Lisp_Object, Lisp_Object);
328 void x_set_menu_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
329 void x_set_title (struct frame *, Lisp_Object, Lisp_Object);
330 void x_set_tool_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
331 void x_set_internal_border_width (struct frame *f, Lisp_Object, Lisp_Object);
332 \f
333
334 /* Store the screen positions of frame F into XPTR and YPTR.
335 These are the positions of the containing window manager window,
336 not Emacs's own window. */
337
338 void
339 x_real_positions (struct frame *f, int *xptr, int *yptr)
340 {
341 POINT pt;
342 RECT rect;
343
344 /* Get the bounds of the WM window. */
345 GetWindowRect (FRAME_W32_WINDOW (f), &rect);
346
347 pt.x = 0;
348 pt.y = 0;
349
350 /* Convert (0, 0) in the client area to screen co-ordinates. */
351 ClientToScreen (FRAME_W32_WINDOW (f), &pt);
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 /* We should "goto dflt" here to pass WM_IME_STARTCOMPOSITION to
3332 DefWindowProc, so that the composition window will actually
3333 be displayed. But doing so causes trouble with displaying
3334 dialog boxes, such as the file selection dialog or font
3335 selection dialog. So something else is needed to fix the
3336 former without breaking the latter. See bug#11732. */
3337 break;
3338
3339 case WM_IME_ENDCOMPOSITION:
3340 ignore_ime_char = 0;
3341 goto dflt;
3342
3343 /* Simulate middle mouse button events when left and right buttons
3344 are used together, but only if user has two button mouse. */
3345 case WM_LBUTTONDOWN:
3346 case WM_RBUTTONDOWN:
3347 if (w32_num_mouse_buttons > 2)
3348 goto handle_plain_button;
3349
3350 {
3351 int this = (msg == WM_LBUTTONDOWN) ? LMOUSE : RMOUSE;
3352 int other = (msg == WM_LBUTTONDOWN) ? RMOUSE : LMOUSE;
3353
3354 if (button_state & this)
3355 return 0;
3356
3357 if (button_state == 0)
3358 SetCapture (hwnd);
3359
3360 button_state |= this;
3361
3362 if (button_state & other)
3363 {
3364 if (mouse_button_timer)
3365 {
3366 KillTimer (hwnd, mouse_button_timer);
3367 mouse_button_timer = 0;
3368
3369 /* Generate middle mouse event instead. */
3370 msg = WM_MBUTTONDOWN;
3371 button_state |= MMOUSE;
3372 }
3373 else if (button_state & MMOUSE)
3374 {
3375 /* Ignore button event if we've already generated a
3376 middle mouse down event. This happens if the
3377 user releases and press one of the two buttons
3378 after we've faked a middle mouse event. */
3379 return 0;
3380 }
3381 else
3382 {
3383 /* Flush out saved message. */
3384 post_msg (&saved_mouse_button_msg);
3385 }
3386 wmsg.dwModifiers = w32_get_modifiers ();
3387 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3388 signal_user_input ();
3389
3390 /* Clear message buffer. */
3391 saved_mouse_button_msg.msg.hwnd = 0;
3392 }
3393 else
3394 {
3395 /* Hold onto message for now. */
3396 mouse_button_timer =
3397 SetTimer (hwnd, MOUSE_BUTTON_ID,
3398 w32_mouse_button_tolerance, NULL);
3399 saved_mouse_button_msg.msg.hwnd = hwnd;
3400 saved_mouse_button_msg.msg.message = msg;
3401 saved_mouse_button_msg.msg.wParam = wParam;
3402 saved_mouse_button_msg.msg.lParam = lParam;
3403 saved_mouse_button_msg.msg.time = GetMessageTime ();
3404 saved_mouse_button_msg.dwModifiers = w32_get_modifiers ();
3405 }
3406 }
3407 return 0;
3408
3409 case WM_LBUTTONUP:
3410 case WM_RBUTTONUP:
3411 if (w32_num_mouse_buttons > 2)
3412 goto handle_plain_button;
3413
3414 {
3415 int this = (msg == WM_LBUTTONUP) ? LMOUSE : RMOUSE;
3416 int other = (msg == WM_LBUTTONUP) ? RMOUSE : LMOUSE;
3417
3418 if ((button_state & this) == 0)
3419 return 0;
3420
3421 button_state &= ~this;
3422
3423 if (button_state & MMOUSE)
3424 {
3425 /* Only generate event when second button is released. */
3426 if ((button_state & other) == 0)
3427 {
3428 msg = WM_MBUTTONUP;
3429 button_state &= ~MMOUSE;
3430
3431 if (button_state) emacs_abort ();
3432 }
3433 else
3434 return 0;
3435 }
3436 else
3437 {
3438 /* Flush out saved message if necessary. */
3439 if (saved_mouse_button_msg.msg.hwnd)
3440 {
3441 post_msg (&saved_mouse_button_msg);
3442 }
3443 }
3444 wmsg.dwModifiers = w32_get_modifiers ();
3445 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3446 signal_user_input ();
3447
3448 /* Always clear message buffer and cancel timer. */
3449 saved_mouse_button_msg.msg.hwnd = 0;
3450 KillTimer (hwnd, mouse_button_timer);
3451 mouse_button_timer = 0;
3452
3453 if (button_state == 0)
3454 ReleaseCapture ();
3455 }
3456 return 0;
3457
3458 case WM_XBUTTONDOWN:
3459 case WM_XBUTTONUP:
3460 if (w32_pass_extra_mouse_buttons_to_system)
3461 goto dflt;
3462 /* else fall through and process them. */
3463 case WM_MBUTTONDOWN:
3464 case WM_MBUTTONUP:
3465 handle_plain_button:
3466 {
3467 BOOL up;
3468 int button;
3469
3470 /* Ignore middle and extra buttons as long as the menu is active. */
3471 f = x_window_to_frame (dpyinfo, hwnd);
3472 if (f && f->output_data.w32->menubar_active)
3473 return 0;
3474
3475 if (parse_button (msg, HIWORD (wParam), &button, &up))
3476 {
3477 if (up) ReleaseCapture ();
3478 else SetCapture (hwnd);
3479 button = (button == 0) ? LMOUSE :
3480 ((button == 1) ? MMOUSE : RMOUSE);
3481 if (up)
3482 button_state &= ~button;
3483 else
3484 button_state |= button;
3485 }
3486 }
3487
3488 wmsg.dwModifiers = w32_get_modifiers ();
3489 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3490 signal_user_input ();
3491
3492 /* Need to return true for XBUTTON messages, false for others,
3493 to indicate that we processed the message. */
3494 return (msg == WM_XBUTTONDOWN || msg == WM_XBUTTONUP);
3495
3496 case WM_MOUSEMOVE:
3497 f = x_window_to_frame (dpyinfo, hwnd);
3498 if (f)
3499 {
3500 /* Ignore mouse movements as long as the menu is active.
3501 These movements are processed by the window manager
3502 anyway, and it's wrong to handle them as if they happened
3503 on the underlying frame. */
3504 if (f->output_data.w32->menubar_active)
3505 return 0;
3506
3507 /* If the mouse moved, and the mouse pointer is invisible,
3508 make it visible again. We do this here so as to be able
3509 to show the mouse pointer even when the main
3510 (a.k.a. "Lisp") thread is busy doing something. */
3511 static int last_x, last_y;
3512 int x = GET_X_LPARAM (lParam);
3513 int y = GET_Y_LPARAM (lParam);
3514
3515 if (f->pointer_invisible
3516 && (x != last_x || y != last_y))
3517 f->pointer_invisible = false;
3518
3519 last_x = x;
3520 last_y = y;
3521 }
3522
3523 /* If the mouse has just moved into the frame, start tracking
3524 it, so we will be notified when it leaves the frame. Mouse
3525 tracking only works under W98 and NT4 and later. On earlier
3526 versions, there is no way of telling when the mouse leaves the
3527 frame, so we just have to put up with help-echo and mouse
3528 highlighting remaining while the frame is not active. */
3529 if (track_mouse_event_fn && !track_mouse_window
3530 /* If the menu bar is active, turning on tracking of mouse
3531 movement events might send these events to the tooltip
3532 frame, if the user happens to move the mouse pointer over
3533 the tooltip. But since we don't process events for
3534 tooltip frames, this causes Windows to present a
3535 hourglass cursor, which is ugly and unexpected. So don't
3536 enable tracking mouse events in this case; they will be
3537 restarted when the menu pops down. (Confusingly, the
3538 menubar_active member of f->output_data.w32, tested
3539 above, is only set when a menu was popped up _not_ from
3540 the frame's menu bar, but via x-popup-menu.) */
3541 && !menubar_in_use)
3542 {
3543 TRACKMOUSEEVENT tme;
3544 tme.cbSize = sizeof (tme);
3545 tme.dwFlags = TME_LEAVE;
3546 tme.hwndTrack = hwnd;
3547 tme.dwHoverTime = HOVER_DEFAULT;
3548
3549 track_mouse_event_fn (&tme);
3550 track_mouse_window = hwnd;
3551 }
3552 case WM_HSCROLL:
3553 case WM_VSCROLL:
3554 if (w32_mouse_move_interval <= 0
3555 || (msg == WM_MOUSEMOVE && button_state == 0))
3556 {
3557 wmsg.dwModifiers = w32_get_modifiers ();
3558 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3559 return 0;
3560 }
3561
3562 /* Hang onto mouse move and scroll messages for a bit, to avoid
3563 sending such events to Emacs faster than it can process them.
3564 If we get more events before the timer from the first message
3565 expires, we just replace the first message. */
3566
3567 if (saved_mouse_move_msg.msg.hwnd == 0)
3568 mouse_move_timer =
3569 SetTimer (hwnd, MOUSE_MOVE_ID,
3570 w32_mouse_move_interval, NULL);
3571
3572 /* Hold onto message for now. */
3573 saved_mouse_move_msg.msg.hwnd = hwnd;
3574 saved_mouse_move_msg.msg.message = msg;
3575 saved_mouse_move_msg.msg.wParam = wParam;
3576 saved_mouse_move_msg.msg.lParam = lParam;
3577 saved_mouse_move_msg.msg.time = GetMessageTime ();
3578 saved_mouse_move_msg.dwModifiers = w32_get_modifiers ();
3579
3580 return 0;
3581
3582 case WM_MOUSEWHEEL:
3583 case WM_DROPFILES:
3584 wmsg.dwModifiers = w32_get_modifiers ();
3585 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3586 signal_user_input ();
3587 return 0;
3588
3589 case WM_APPCOMMAND:
3590 if (w32_pass_multimedia_buttons_to_system)
3591 goto dflt;
3592 /* Otherwise, pass to lisp, the same way we do with mousehwheel. */
3593 case WM_MOUSEHWHEEL:
3594 wmsg.dwModifiers = w32_get_modifiers ();
3595 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3596 signal_user_input ();
3597 /* Non-zero must be returned when WM_MOUSEHWHEEL messages are
3598 handled, to prevent the system trying to handle it by faking
3599 scroll bar events. */
3600 return 1;
3601
3602 case WM_TIMER:
3603 /* Flush out saved messages if necessary. */
3604 if (wParam == mouse_button_timer)
3605 {
3606 if (saved_mouse_button_msg.msg.hwnd)
3607 {
3608 post_msg (&saved_mouse_button_msg);
3609 signal_user_input ();
3610 saved_mouse_button_msg.msg.hwnd = 0;
3611 }
3612 KillTimer (hwnd, mouse_button_timer);
3613 mouse_button_timer = 0;
3614 }
3615 else if (wParam == mouse_move_timer)
3616 {
3617 if (saved_mouse_move_msg.msg.hwnd)
3618 {
3619 post_msg (&saved_mouse_move_msg);
3620 saved_mouse_move_msg.msg.hwnd = 0;
3621 }
3622 KillTimer (hwnd, mouse_move_timer);
3623 mouse_move_timer = 0;
3624 }
3625 else if (wParam == menu_free_timer)
3626 {
3627 KillTimer (hwnd, menu_free_timer);
3628 menu_free_timer = 0;
3629 f = x_window_to_frame (dpyinfo, hwnd);
3630 /* If a popup menu is active, don't wipe its strings. */
3631 if (menubar_in_use
3632 && current_popup_menu == NULL)
3633 {
3634 /* Free memory used by owner-drawn and help-echo strings. */
3635 w32_free_menu_strings (hwnd);
3636 if (f)
3637 f->output_data.w32->menubar_active = 0;
3638 menubar_in_use = 0;
3639 }
3640 }
3641 return 0;
3642
3643 case WM_NCACTIVATE:
3644 /* Windows doesn't send us focus messages when putting up and
3645 taking down a system popup dialog as for Ctrl-Alt-Del on Windows 95.
3646 The only indication we get that something happened is receiving
3647 this message afterwards. So this is a good time to reset our
3648 keyboard modifiers' state. */
3649 reset_modifiers ();
3650 goto dflt;
3651
3652 case WM_INITMENU:
3653 button_state = 0;
3654 ReleaseCapture ();
3655 /* We must ensure menu bar is fully constructed and up to date
3656 before allowing user interaction with it. To achieve this
3657 we send this message to the lisp thread and wait for a
3658 reply (whose value is not actually needed) to indicate that
3659 the menu bar is now ready for use, so we can now return.
3660
3661 To remain responsive in the meantime, we enter a nested message
3662 loop that can process all other messages.
3663
3664 However, we skip all this if the message results from calling
3665 TrackPopupMenu - in fact, we must NOT attempt to send the lisp
3666 thread a message because it is blocked on us at this point. We
3667 set menubar_active before calling TrackPopupMenu to indicate
3668 this (there is no possibility of confusion with real menubar
3669 being active). */
3670
3671 f = x_window_to_frame (dpyinfo, hwnd);
3672 if (f
3673 && (f->output_data.w32->menubar_active
3674 /* We can receive this message even in the absence of a
3675 menubar (ie. when the system menu is activated) - in this
3676 case we do NOT want to forward the message, otherwise it
3677 will cause the menubar to suddenly appear when the user
3678 had requested it to be turned off! */
3679 || f->output_data.w32->menubar_widget == NULL))
3680 return 0;
3681
3682 {
3683 deferred_msg msg_buf;
3684
3685 /* Detect if message has already been deferred; in this case
3686 we cannot return any sensible value to ignore this. */
3687 if (find_deferred_msg (hwnd, msg) != NULL)
3688 emacs_abort ();
3689
3690 menubar_in_use = 1;
3691
3692 return send_deferred_msg (&msg_buf, hwnd, msg, wParam, lParam);
3693 }
3694
3695 case WM_EXITMENULOOP:
3696 f = x_window_to_frame (dpyinfo, hwnd);
3697
3698 /* If a menu is still active, check again after a short delay,
3699 since Windows often (always?) sends the WM_EXITMENULOOP
3700 before the corresponding WM_COMMAND message.
3701 Don't do this if a popup menu is active, since it is only
3702 menubar menus that require cleaning up in this way.
3703 */
3704 if (f && menubar_in_use && current_popup_menu == NULL)
3705 menu_free_timer = SetTimer (hwnd, MENU_FREE_ID, MENU_FREE_DELAY, NULL);
3706
3707 /* If hourglass cursor should be displayed, display it now. */
3708 if (f && f->output_data.w32->hourglass_p)
3709 SetCursor (f->output_data.w32->hourglass_cursor);
3710
3711 goto dflt;
3712
3713 case WM_MENUSELECT:
3714 /* Direct handling of help_echo in menus. Should be safe now
3715 that we generate the help_echo by placing a help event in the
3716 keyboard buffer. */
3717 {
3718 HMENU menu = (HMENU) lParam;
3719 UINT menu_item = (UINT) LOWORD (wParam);
3720 UINT flags = (UINT) HIWORD (wParam);
3721
3722 w32_menu_display_help (hwnd, menu, menu_item, flags);
3723 }
3724 return 0;
3725
3726 case WM_MEASUREITEM:
3727 f = x_window_to_frame (dpyinfo, hwnd);
3728 if (f)
3729 {
3730 MEASUREITEMSTRUCT * pMis = (MEASUREITEMSTRUCT *) lParam;
3731
3732 if (pMis->CtlType == ODT_MENU)
3733 {
3734 /* Work out dimensions for popup menu titles. */
3735 char * title = (char *) pMis->itemData;
3736 HDC hdc = GetDC (hwnd);
3737 HFONT menu_font = GetCurrentObject (hdc, OBJ_FONT);
3738 LOGFONT menu_logfont;
3739 HFONT old_font;
3740 SIZE size;
3741
3742 GetObject (menu_font, sizeof (menu_logfont), &menu_logfont);
3743 menu_logfont.lfWeight = FW_BOLD;
3744 menu_font = CreateFontIndirect (&menu_logfont);
3745 old_font = SelectObject (hdc, menu_font);
3746
3747 pMis->itemHeight = GetSystemMetrics (SM_CYMENUSIZE);
3748 if (title)
3749 {
3750 if (unicode_append_menu)
3751 GetTextExtentPoint32W (hdc, (WCHAR *) title,
3752 wcslen ((WCHAR *) title),
3753 &size);
3754 else
3755 GetTextExtentPoint32 (hdc, title, strlen (title), &size);
3756
3757 pMis->itemWidth = size.cx;
3758 if (pMis->itemHeight < size.cy)
3759 pMis->itemHeight = size.cy;
3760 }
3761 else
3762 pMis->itemWidth = 0;
3763
3764 SelectObject (hdc, old_font);
3765 DeleteObject (menu_font);
3766 ReleaseDC (hwnd, hdc);
3767 return TRUE;
3768 }
3769 }
3770 return 0;
3771
3772 case WM_DRAWITEM:
3773 f = x_window_to_frame (dpyinfo, hwnd);
3774 if (f)
3775 {
3776 DRAWITEMSTRUCT * pDis = (DRAWITEMSTRUCT *) lParam;
3777
3778 if (pDis->CtlType == ODT_MENU)
3779 {
3780 /* Draw popup menu title. */
3781 char * title = (char *) pDis->itemData;
3782 if (title)
3783 {
3784 HDC hdc = pDis->hDC;
3785 HFONT menu_font = GetCurrentObject (hdc, OBJ_FONT);
3786 LOGFONT menu_logfont;
3787 HFONT old_font;
3788
3789 GetObject (menu_font, sizeof (menu_logfont), &menu_logfont);
3790 menu_logfont.lfWeight = FW_BOLD;
3791 menu_font = CreateFontIndirect (&menu_logfont);
3792 old_font = SelectObject (hdc, menu_font);
3793
3794 /* Always draw title as if not selected. */
3795 if (unicode_append_menu)
3796 ExtTextOutW (hdc,
3797 pDis->rcItem.left
3798 + GetSystemMetrics (SM_CXMENUCHECK),
3799 pDis->rcItem.top,
3800 ETO_OPAQUE, &pDis->rcItem,
3801 (WCHAR *) title,
3802 wcslen ((WCHAR *) title), NULL);
3803 else
3804 ExtTextOut (hdc,
3805 pDis->rcItem.left
3806 + GetSystemMetrics (SM_CXMENUCHECK),
3807 pDis->rcItem.top,
3808 ETO_OPAQUE, &pDis->rcItem,
3809 title, strlen (title), NULL);
3810
3811 SelectObject (hdc, old_font);
3812 DeleteObject (menu_font);
3813 }
3814 return TRUE;
3815 }
3816 }
3817 return 0;
3818
3819 #if 0
3820 /* Still not right - can't distinguish between clicks in the
3821 client area of the frame from clicks forwarded from the scroll
3822 bars - may have to hook WM_NCHITTEST to remember the mouse
3823 position and then check if it is in the client area ourselves. */
3824 case WM_MOUSEACTIVATE:
3825 /* Discard the mouse click that activates a frame, allowing the
3826 user to click anywhere without changing point (or worse!).
3827 Don't eat mouse clicks on scrollbars though!! */
3828 if (LOWORD (lParam) == HTCLIENT )
3829 return MA_ACTIVATEANDEAT;
3830 goto dflt;
3831 #endif
3832
3833 case WM_MOUSELEAVE:
3834 /* No longer tracking mouse. */
3835 track_mouse_window = NULL;
3836
3837 case WM_ACTIVATEAPP:
3838 case WM_ACTIVATE:
3839 case WM_WINDOWPOSCHANGED:
3840 case WM_SHOWWINDOW:
3841 /* Inform lisp thread that a frame might have just been obscured
3842 or exposed, so should recheck visibility of all frames. */
3843 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3844 goto dflt;
3845
3846 case WM_SETFOCUS:
3847 dpyinfo->faked_key = 0;
3848 reset_modifiers ();
3849 register_hot_keys (hwnd);
3850 goto command;
3851 case WM_KILLFOCUS:
3852 unregister_hot_keys (hwnd);
3853 button_state = 0;
3854 ReleaseCapture ();
3855 /* Relinquish the system caret. */
3856 if (w32_system_caret_hwnd)
3857 {
3858 w32_visible_system_caret_hwnd = NULL;
3859 w32_system_caret_hwnd = NULL;
3860 DestroyCaret ();
3861 }
3862 goto command;
3863 case WM_COMMAND:
3864 menubar_in_use = 0;
3865 f = x_window_to_frame (dpyinfo, hwnd);
3866 if (f && HIWORD (wParam) == 0)
3867 {
3868 if (menu_free_timer)
3869 {
3870 KillTimer (hwnd, menu_free_timer);
3871 menu_free_timer = 0;
3872 }
3873 }
3874 case WM_MOVE:
3875 case WM_SIZE:
3876 command:
3877 wmsg.dwModifiers = w32_get_modifiers ();
3878 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3879 goto dflt;
3880
3881 case WM_DESTROY:
3882 CoUninitialize ();
3883 return 0;
3884
3885 case WM_CLOSE:
3886 wmsg.dwModifiers = w32_get_modifiers ();
3887 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
3888 return 0;
3889
3890 case WM_WINDOWPOSCHANGING:
3891 /* Don't restrict the sizing of any kind of frames. If the window
3892 manager doesn't, there's no reason to do it ourselves. */
3893 #if 0
3894 if (frame_resize_pixelwise || hwnd == tip_window)
3895 #endif
3896 return 0;
3897
3898 #if 0
3899 /* Don't restrict the sizing of fullscreened frames, allowing them to be
3900 flush with the sides of the screen. */
3901 f = x_window_to_frame (dpyinfo, hwnd);
3902 if (f && FRAME_PREV_FSMODE (f) != FULLSCREEN_NONE)
3903 return 0;
3904
3905 {
3906 WINDOWPLACEMENT wp;
3907 LPWINDOWPOS lppos = (WINDOWPOS *) lParam;
3908
3909 wp.length = sizeof (WINDOWPLACEMENT);
3910 GetWindowPlacement (hwnd, &wp);
3911
3912 if (wp.showCmd != SW_SHOWMAXIMIZED && wp.showCmd != SW_SHOWMINIMIZED
3913 && (lppos->flags & SWP_NOSIZE) == 0)
3914 {
3915 RECT rect;
3916 int wdiff;
3917 int hdiff;
3918 DWORD font_width;
3919 DWORD line_height;
3920 DWORD internal_border;
3921 DWORD vscrollbar_extra;
3922 DWORD hscrollbar_extra;
3923 RECT wr;
3924
3925 wp.length = sizeof (wp);
3926 GetWindowRect (hwnd, &wr);
3927
3928 enter_crit ();
3929
3930 font_width = GetWindowLong (hwnd, WND_FONTWIDTH_INDEX);
3931 line_height = GetWindowLong (hwnd, WND_LINEHEIGHT_INDEX);
3932 internal_border = GetWindowLong (hwnd, WND_BORDER_INDEX);
3933 vscrollbar_extra = GetWindowLong (hwnd, WND_VSCROLLBAR_INDEX);
3934 hscrollbar_extra = GetWindowLong (hwnd, WND_HSCROLLBAR_INDEX);
3935
3936 leave_crit ();
3937
3938 memset (&rect, 0, sizeof (rect));
3939 AdjustWindowRect (&rect, GetWindowLong (hwnd, GWL_STYLE),
3940 GetMenu (hwnd) != NULL);
3941
3942 /* Force width and height of client area to be exact
3943 multiples of the character cell dimensions. */
3944 wdiff = (lppos->cx - (rect.right - rect.left)
3945 - 2 * internal_border - vscrollbar_extra)
3946 % font_width;
3947 hdiff = (lppos->cy - (rect.bottom - rect.top)
3948 - 2 * internal_border - hscrollbar_extra)
3949 % line_height;
3950
3951 if (wdiff || hdiff)
3952 {
3953 /* For right/bottom sizing we can just fix the sizes.
3954 However for top/left sizing we will need to fix the X
3955 and Y positions as well. */
3956
3957 int cx_mintrack = GetSystemMetrics (SM_CXMINTRACK);
3958 int cy_mintrack = GetSystemMetrics (SM_CYMINTRACK);
3959
3960 lppos->cx = max (lppos->cx - wdiff, cx_mintrack);
3961 lppos->cy = max (lppos->cy - hdiff, cy_mintrack);
3962
3963 if (wp.showCmd != SW_SHOWMAXIMIZED
3964 && (lppos->flags & SWP_NOMOVE) == 0)
3965 {
3966 if (lppos->x != wr.left || lppos->y != wr.top)
3967 {
3968 lppos->x += wdiff;
3969 lppos->y += hdiff;
3970 }
3971 else
3972 {
3973 lppos->flags |= SWP_NOMOVE;
3974 }
3975 }
3976
3977 return 0;
3978 }
3979 }
3980 }
3981
3982 goto dflt;
3983 #endif
3984
3985 case WM_GETMINMAXINFO:
3986 /* Hack to allow resizing the Emacs frame above the screen size.
3987 Note that Windows 9x limits coordinates to 16-bits. */
3988 ((LPMINMAXINFO) lParam)->ptMaxTrackSize.x = 32767;
3989 ((LPMINMAXINFO) lParam)->ptMaxTrackSize.y = 32767;
3990 return 0;
3991
3992 case WM_SETCURSOR:
3993 if (LOWORD (lParam) == HTCLIENT)
3994 {
3995 f = x_window_to_frame (dpyinfo, hwnd);
3996 if (f)
3997 {
3998 if (f->output_data.w32->hourglass_p
3999 && !menubar_in_use && !current_popup_menu)
4000 SetCursor (f->output_data.w32->hourglass_cursor);
4001 else if (f->pointer_invisible)
4002 SetCursor (NULL);
4003 else
4004 SetCursor (f->output_data.w32->current_cursor);
4005 }
4006
4007 return 0;
4008 }
4009 goto dflt;
4010
4011 case WM_EMACS_SETCURSOR:
4012 {
4013 Cursor cursor = (Cursor) wParam;
4014 f = x_window_to_frame (dpyinfo, hwnd);
4015 if (f && cursor)
4016 {
4017 f->output_data.w32->current_cursor = cursor;
4018 /* Don't change the cursor while menu-bar menu is in use. */
4019 if (!f->output_data.w32->menubar_active
4020 && !f->output_data.w32->hourglass_p)
4021 {
4022 if (f->pointer_invisible)
4023 SetCursor (NULL);
4024 else
4025 SetCursor (cursor);
4026 }
4027 }
4028 return 0;
4029 }
4030
4031 case WM_EMACS_SHOWCURSOR:
4032 {
4033 ShowCursor ((BOOL) wParam);
4034
4035 return 0;
4036 }
4037
4038 case WM_EMACS_CREATEVSCROLLBAR:
4039 return (LRESULT) w32_createvscrollbar ((struct frame *) wParam,
4040 (struct scroll_bar *) lParam);
4041
4042 case WM_EMACS_CREATEHSCROLLBAR:
4043 return (LRESULT) w32_createhscrollbar ((struct frame *) wParam,
4044 (struct scroll_bar *) lParam);
4045
4046 case WM_EMACS_SHOWWINDOW:
4047 return ShowWindow ((HWND) wParam, (WPARAM) lParam);
4048
4049 case WM_EMACS_BRINGTOTOP:
4050 case WM_EMACS_SETFOREGROUND:
4051 {
4052 HWND foreground_window;
4053 DWORD foreground_thread, retval;
4054
4055 /* On NT 5.0, and apparently Windows 98, it is necessary to
4056 attach to the thread that currently has focus in order to
4057 pull the focus away from it. */
4058 foreground_window = GetForegroundWindow ();
4059 foreground_thread = GetWindowThreadProcessId (foreground_window, NULL);
4060 if (!foreground_window
4061 || foreground_thread == GetCurrentThreadId ()
4062 || !AttachThreadInput (GetCurrentThreadId (),
4063 foreground_thread, TRUE))
4064 foreground_thread = 0;
4065
4066 retval = SetForegroundWindow ((HWND) wParam);
4067 if (msg == WM_EMACS_BRINGTOTOP)
4068 retval = BringWindowToTop ((HWND) wParam);
4069
4070 /* Detach from the previous foreground thread. */
4071 if (foreground_thread)
4072 AttachThreadInput (GetCurrentThreadId (),
4073 foreground_thread, FALSE);
4074
4075 return retval;
4076 }
4077
4078 case WM_EMACS_SETWINDOWPOS:
4079 {
4080 WINDOWPOS * pos = (WINDOWPOS *) wParam;
4081 return SetWindowPos (hwnd, pos->hwndInsertAfter,
4082 pos->x, pos->y, pos->cx, pos->cy, pos->flags);
4083 }
4084
4085 case WM_EMACS_DESTROYWINDOW:
4086 DragAcceptFiles ((HWND) wParam, FALSE);
4087 return DestroyWindow ((HWND) wParam);
4088
4089 case WM_EMACS_HIDE_CARET:
4090 return HideCaret (hwnd);
4091
4092 case WM_EMACS_SHOW_CARET:
4093 return ShowCaret (hwnd);
4094
4095 case WM_EMACS_DESTROY_CARET:
4096 w32_system_caret_hwnd = NULL;
4097 w32_visible_system_caret_hwnd = NULL;
4098 return DestroyCaret ();
4099
4100 case WM_EMACS_TRACK_CARET:
4101 /* If there is currently no system caret, create one. */
4102 if (w32_system_caret_hwnd == NULL)
4103 {
4104 /* Use the default caret width, and avoid changing it
4105 unnecessarily, as it confuses screen reader software. */
4106 w32_system_caret_hwnd = hwnd;
4107 CreateCaret (hwnd, NULL, 0,
4108 w32_system_caret_height);
4109 }
4110
4111 if (!SetCaretPos (w32_system_caret_x, w32_system_caret_y))
4112 return 0;
4113 /* Ensure visible caret gets turned on when requested. */
4114 else if (w32_use_visible_system_caret
4115 && w32_visible_system_caret_hwnd != hwnd)
4116 {
4117 w32_visible_system_caret_hwnd = hwnd;
4118 return ShowCaret (hwnd);
4119 }
4120 /* Ensure visible caret gets turned off when requested. */
4121 else if (!w32_use_visible_system_caret
4122 && w32_visible_system_caret_hwnd)
4123 {
4124 w32_visible_system_caret_hwnd = NULL;
4125 return HideCaret (hwnd);
4126 }
4127 else
4128 return 1;
4129
4130 case WM_EMACS_TRACKPOPUPMENU:
4131 {
4132 UINT flags;
4133 POINT *pos;
4134 int retval;
4135 pos = (POINT *)lParam;
4136 flags = TPM_CENTERALIGN;
4137 if (button_state & LMOUSE)
4138 flags |= TPM_LEFTBUTTON;
4139 else if (button_state & RMOUSE)
4140 flags |= TPM_RIGHTBUTTON;
4141
4142 /* Remember we did a SetCapture on the initial mouse down event,
4143 so for safety, we make sure the capture is canceled now. */
4144 ReleaseCapture ();
4145 button_state = 0;
4146
4147 /* Use menubar_active to indicate that WM_INITMENU is from
4148 TrackPopupMenu below, and should be ignored. */
4149 f = x_window_to_frame (dpyinfo, hwnd);
4150 if (f)
4151 f->output_data.w32->menubar_active = 1;
4152
4153 if (TrackPopupMenu ((HMENU)wParam, flags, pos->x, pos->y,
4154 0, hwnd, NULL))
4155 {
4156 MSG amsg;
4157 /* Eat any mouse messages during popupmenu */
4158 while (PeekMessage (&amsg, hwnd, WM_MOUSEFIRST, WM_MOUSELAST,
4159 PM_REMOVE));
4160 /* Get the menu selection, if any */
4161 if (PeekMessage (&amsg, hwnd, WM_COMMAND, WM_COMMAND, PM_REMOVE))
4162 {
4163 retval = LOWORD (amsg.wParam);
4164 }
4165 else
4166 {
4167 retval = 0;
4168 }
4169 }
4170 else
4171 {
4172 retval = -1;
4173 }
4174
4175 return retval;
4176 }
4177 case WM_EMACS_FILENOTIFY:
4178 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4179 return 1;
4180
4181 default:
4182 /* Check for messages registered at runtime. */
4183 if (msg == msh_mousewheel)
4184 {
4185 wmsg.dwModifiers = w32_get_modifiers ();
4186 my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
4187 signal_user_input ();
4188 return 0;
4189 }
4190
4191 dflt:
4192 return (w32_unicode_gui ? DefWindowProcW : DefWindowProcA) (hwnd, msg, wParam, lParam);
4193 }
4194
4195 /* The most common default return code for handled messages is 0. */
4196 return 0;
4197 }
4198
4199 static void
4200 my_create_window (struct frame * f)
4201 {
4202 MSG msg;
4203 static int coords[2];
4204 Lisp_Object left, top;
4205 struct w32_display_info *dpyinfo = &one_w32_display_info;
4206
4207 /* When called with RES_TYPE_NUMBER, x_get_arg will return zero for
4208 anything that is not a number and is not Qunbound. */
4209 left = x_get_arg (dpyinfo, Qnil, Qleft, "left", "Left", RES_TYPE_NUMBER);
4210 top = x_get_arg (dpyinfo, Qnil, Qtop, "top", "Top", RES_TYPE_NUMBER);
4211 if (EQ (left, Qunbound))
4212 coords[0] = CW_USEDEFAULT;
4213 else
4214 coords[0] = XINT (left);
4215 if (EQ (top, Qunbound))
4216 coords[1] = CW_USEDEFAULT;
4217 else
4218 coords[1] = XINT (top);
4219
4220 if (!PostThreadMessage (dwWindowsThreadId, WM_EMACS_CREATEWINDOW,
4221 (WPARAM)f, (LPARAM)coords))
4222 emacs_abort ();
4223 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
4224 }
4225
4226
4227 /* Create a tooltip window. Unlike my_create_window, we do not do this
4228 indirectly via the Window thread, as we do not need to process Window
4229 messages for the tooltip. Creating tooltips indirectly also creates
4230 deadlocks when tooltips are created for menu items. */
4231 static void
4232 my_create_tip_window (struct frame *f)
4233 {
4234 RECT rect;
4235
4236 rect.left = rect.top = 0;
4237 rect.right = FRAME_PIXEL_WIDTH (f);
4238 rect.bottom = FRAME_PIXEL_HEIGHT (f);
4239
4240 AdjustWindowRect (&rect, f->output_data.w32->dwStyle,
4241 FRAME_EXTERNAL_MENU_BAR (f));
4242
4243 tip_window = FRAME_W32_WINDOW (f)
4244 = CreateWindow (EMACS_CLASS,
4245 f->namebuf,
4246 f->output_data.w32->dwStyle,
4247 f->left_pos,
4248 f->top_pos,
4249 rect.right - rect.left,
4250 rect.bottom - rect.top,
4251 FRAME_W32_WINDOW (SELECTED_FRAME ()), /* owner */
4252 NULL,
4253 hinst,
4254 NULL);
4255
4256 if (tip_window)
4257 {
4258 SetWindowLong (tip_window, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
4259 SetWindowLong (tip_window, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
4260 SetWindowLong (tip_window, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
4261 SetWindowLong (tip_window, WND_BACKGROUND_INDEX, FRAME_BACKGROUND_PIXEL (f));
4262
4263 /* Tip frames have no scrollbars. */
4264 SetWindowLong (tip_window, WND_VSCROLLBAR_INDEX, 0);
4265 SetWindowLong (tip_window, WND_HSCROLLBAR_INDEX, 0);
4266
4267 /* Do this to discard the default setting specified by our parent. */
4268 ShowWindow (tip_window, SW_HIDE);
4269 }
4270 }
4271
4272
4273 /* Create and set up the w32 window for frame F. */
4274
4275 static void
4276 w32_window (struct frame *f, long window_prompting, bool minibuffer_only)
4277 {
4278 block_input ();
4279
4280 /* Use the resource name as the top-level window name
4281 for looking up resources. Make a non-Lisp copy
4282 for the window manager, so GC relocation won't bother it.
4283
4284 Elsewhere we specify the window name for the window manager. */
4285 f->namebuf = xlispstrdup (Vx_resource_name);
4286
4287 my_create_window (f);
4288
4289 validate_x_resource_name ();
4290
4291 /* x_set_name normally ignores requests to set the name if the
4292 requested name is the same as the current name. This is the one
4293 place where that assumption isn't correct; f->name is set, but
4294 the server hasn't been told. */
4295 {
4296 Lisp_Object name;
4297 int explicit = f->explicit_name;
4298
4299 f->explicit_name = 0;
4300 name = f->name;
4301 fset_name (f, Qnil);
4302 x_set_name (f, name, explicit);
4303 }
4304
4305 unblock_input ();
4306
4307 if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
4308 initialize_frame_menubar (f);
4309
4310 if (FRAME_W32_WINDOW (f) == 0)
4311 error ("Unable to create window");
4312 }
4313
4314 /* Handle the icon stuff for this window. Perhaps later we might
4315 want an x_set_icon_position which can be called interactively as
4316 well. */
4317
4318 static void
4319 x_icon (struct frame *f, Lisp_Object parms)
4320 {
4321 Lisp_Object icon_x, icon_y;
4322 struct w32_display_info *dpyinfo = &one_w32_display_info;
4323
4324 /* Set the position of the icon. Note that Windows 95 groups all
4325 icons in the tray. */
4326 icon_x = x_get_arg (dpyinfo, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
4327 icon_y = x_get_arg (dpyinfo, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
4328 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
4329 {
4330 CHECK_NUMBER (icon_x);
4331 CHECK_NUMBER (icon_y);
4332 }
4333 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
4334 error ("Both left and top icon corners of icon must be specified");
4335
4336 block_input ();
4337
4338 #if 0 /* TODO */
4339 /* Start up iconic or window? */
4340 x_wm_set_window_state
4341 (f, (EQ (x_get_arg (dpyinfo, parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL), Qicon)
4342 ? IconicState
4343 : NormalState));
4344
4345 x_text_icon (f, SSDATA ((!NILP (f->icon_name)
4346 ? f->icon_name
4347 : f->name)));
4348 #endif
4349
4350 unblock_input ();
4351 }
4352
4353
4354 static void
4355 x_make_gc (struct frame *f)
4356 {
4357 XGCValues gc_values;
4358
4359 block_input ();
4360
4361 /* Create the GC's of this frame.
4362 Note that many default values are used. */
4363
4364 /* Normal video */
4365 gc_values.font = FRAME_FONT (f);
4366
4367 /* Cursor has cursor-color background, background-color foreground. */
4368 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
4369 gc_values.background = f->output_data.w32->cursor_pixel;
4370 f->output_data.w32->cursor_gc
4371 = XCreateGC (NULL, FRAME_W32_WINDOW (f),
4372 (GCFont | GCForeground | GCBackground),
4373 &gc_values);
4374
4375 /* Reliefs. */
4376 f->output_data.w32->white_relief.gc = 0;
4377 f->output_data.w32->black_relief.gc = 0;
4378
4379 unblock_input ();
4380 }
4381
4382
4383 /* Handler for signals raised during x_create_frame and
4384 x_create_tip_frame. FRAME is the frame which is partially
4385 constructed. */
4386
4387 static Lisp_Object
4388 unwind_create_frame (Lisp_Object frame)
4389 {
4390 struct frame *f = XFRAME (frame);
4391
4392 /* If frame is ``official'', nothing to do. */
4393 if (NILP (Fmemq (frame, Vframe_list)))
4394 {
4395 #ifdef GLYPH_DEBUG
4396 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
4397
4398 /* If the frame's image cache refcount is still the same as our
4399 private shadow variable, it means we are unwinding a frame
4400 for which we didn't yet call init_frame_faces, where the
4401 refcount is incremented. Therefore, we increment it here, so
4402 that free_frame_faces, called in x_free_frame_resources
4403 below, will not mistakenly decrement the counter that was not
4404 incremented yet to account for this new frame. */
4405 if (FRAME_IMAGE_CACHE (f) != NULL
4406 && FRAME_IMAGE_CACHE (f)->refcount == image_cache_refcount)
4407 FRAME_IMAGE_CACHE (f)->refcount++;
4408 #endif
4409
4410 x_free_frame_resources (f);
4411 free_glyphs (f);
4412
4413 #ifdef GLYPH_DEBUG
4414 /* Check that reference counts are indeed correct. */
4415 eassert (dpyinfo->reference_count == dpyinfo_refcount);
4416 eassert ((dpyinfo->terminal->image_cache == NULL
4417 && image_cache_refcount == 0)
4418 || (dpyinfo->terminal->image_cache != NULL
4419 && dpyinfo->terminal->image_cache->refcount == image_cache_refcount));
4420 #endif
4421 return Qt;
4422 }
4423
4424 return Qnil;
4425 }
4426
4427 static void
4428 do_unwind_create_frame (Lisp_Object frame)
4429 {
4430 unwind_create_frame (frame);
4431 }
4432
4433 static void
4434 unwind_create_frame_1 (Lisp_Object val)
4435 {
4436 inhibit_lisp_code = val;
4437 }
4438
4439 static void
4440 x_default_font_parameter (struct frame *f, Lisp_Object parms)
4441 {
4442 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
4443 Lisp_Object font_param = x_get_arg (dpyinfo, parms, Qfont, NULL, NULL,
4444 RES_TYPE_STRING);
4445 Lisp_Object font;
4446 if (EQ (font_param, Qunbound))
4447 font_param = Qnil;
4448 font = !NILP (font_param) ? font_param
4449 : x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
4450
4451 if (!STRINGP (font))
4452 {
4453 int i;
4454 static char *names[]
4455 = { "Courier New-10",
4456 "-*-Courier-normal-r-*-*-13-*-*-*-c-*-iso8859-1",
4457 "-*-Fixedsys-normal-r-*-*-12-*-*-*-c-*-iso8859-1",
4458 "Fixedsys",
4459 NULL };
4460
4461 for (i = 0; names[i]; i++)
4462 {
4463 font = font_open_by_name (f, build_unibyte_string (names[i]));
4464 if (! NILP (font))
4465 break;
4466 }
4467 if (NILP (font))
4468 error ("No suitable font was found");
4469 }
4470 else if (!NILP (font_param))
4471 {
4472 /* Remember the explicit font parameter, so we can re-apply it after
4473 we've applied the `default' face settings. */
4474 x_set_frame_parameters (f, Fcons (Fcons (Qfont_param, font_param), Qnil));
4475 }
4476 x_default_parameter (f, parms, Qfont, font, "font", "Font", RES_TYPE_STRING);
4477 }
4478
4479 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
4480 1, 1, 0,
4481 doc: /* Make a new window, which is called a \"frame\" in Emacs terms.
4482 Return an Emacs frame object.
4483 PARAMETERS is an alist of frame parameters.
4484 If the parameters specify that the frame should not have a minibuffer,
4485 and do not specify a specific minibuffer window to use,
4486 then `default-minibuffer-frame' must be a frame whose minibuffer can
4487 be shared by the new frame.
4488
4489 This function is an internal primitive--use `make-frame' instead. */)
4490 (Lisp_Object parameters)
4491 {
4492 struct frame *f;
4493 Lisp_Object frame, tem;
4494 Lisp_Object name;
4495 bool minibuffer_only = false;
4496 long window_prompting = 0;
4497 ptrdiff_t count = SPECPDL_INDEX ();
4498 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4499 Lisp_Object display;
4500 struct w32_display_info *dpyinfo = NULL;
4501 Lisp_Object parent;
4502 struct kboard *kb;
4503
4504 if (!FRAME_W32_P (SELECTED_FRAME ())
4505 && !FRAME_INITIAL_P (SELECTED_FRAME ()))
4506 error ("Cannot create a GUI frame in a -nw session");
4507
4508 /* Make copy of frame parameters because the original is in pure
4509 storage now. */
4510 parameters = Fcopy_alist (parameters);
4511
4512 /* Use this general default value to start with
4513 until we know if this frame has a specified name. */
4514 Vx_resource_name = Vinvocation_name;
4515
4516 display = x_get_arg (dpyinfo, parameters, Qterminal, 0, 0, RES_TYPE_NUMBER);
4517 if (EQ (display, Qunbound))
4518 display = x_get_arg (dpyinfo, parameters, Qdisplay, 0, 0, RES_TYPE_STRING);
4519 if (EQ (display, Qunbound))
4520 display = Qnil;
4521 dpyinfo = check_x_display_info (display);
4522 kb = dpyinfo->terminal->kboard;
4523
4524 if (!dpyinfo->terminal->name)
4525 error ("Terminal is not live, can't create new frames on it");
4526
4527 name = x_get_arg (dpyinfo, parameters, Qname, "name", "Name", RES_TYPE_STRING);
4528 if (!STRINGP (name)
4529 && ! EQ (name, Qunbound)
4530 && ! NILP (name))
4531 error ("Invalid frame name--not a string or nil");
4532
4533 if (STRINGP (name))
4534 Vx_resource_name = name;
4535
4536 /* See if parent window is specified. */
4537 parent = x_get_arg (dpyinfo, parameters, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
4538 if (EQ (parent, Qunbound))
4539 parent = Qnil;
4540 if (! NILP (parent))
4541 CHECK_NUMBER (parent);
4542
4543 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
4544 /* No need to protect DISPLAY because that's not used after passing
4545 it to make_frame_without_minibuffer. */
4546 frame = Qnil;
4547 GCPRO4 (parameters, parent, name, frame);
4548 tem = x_get_arg (dpyinfo, parameters, Qminibuffer, "minibuffer", "Minibuffer",
4549 RES_TYPE_SYMBOL);
4550 if (EQ (tem, Qnone) || NILP (tem))
4551 f = make_frame_without_minibuffer (Qnil, kb, display);
4552 else if (EQ (tem, Qonly))
4553 {
4554 f = make_minibuffer_frame ();
4555 minibuffer_only = true;
4556 }
4557 else if (WINDOWP (tem))
4558 f = make_frame_without_minibuffer (tem, kb, display);
4559 else
4560 f = make_frame (true);
4561
4562 XSETFRAME (frame, f);
4563
4564 /* By default, make scrollbars the system standard width and height. */
4565 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = GetSystemMetrics (SM_CXVSCROLL);
4566 FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = GetSystemMetrics (SM_CXHSCROLL);
4567
4568 f->terminal = dpyinfo->terminal;
4569
4570 f->output_method = output_w32;
4571 f->output_data.w32 = xzalloc (sizeof (struct w32_output));
4572 FRAME_FONTSET (f) = -1;
4573
4574 fset_icon_name
4575 (f, x_get_arg (dpyinfo, parameters, Qicon_name, "iconName", "Title",
4576 RES_TYPE_STRING));
4577 if (! STRINGP (f->icon_name))
4578 fset_icon_name (f, Qnil);
4579
4580 /* FRAME_DISPLAY_INFO (f) = dpyinfo; */
4581
4582 /* With FRAME_DISPLAY_INFO set up, this unwind-protect is safe. */
4583 record_unwind_protect (do_unwind_create_frame, frame);
4584
4585 #ifdef GLYPH_DEBUG
4586 image_cache_refcount =
4587 FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
4588 dpyinfo_refcount = dpyinfo->reference_count;
4589 #endif /* GLYPH_DEBUG */
4590
4591 /* Specify the parent under which to make this window. */
4592 if (!NILP (parent))
4593 {
4594 /* Cast to UINT_PTR shuts up compiler warnings about cast to
4595 pointer from integer of different size. */
4596 f->output_data.w32->parent_desc = (Window) (UINT_PTR) XFASTINT (parent);
4597 f->output_data.w32->explicit_parent = true;
4598 }
4599 else
4600 {
4601 f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
4602 f->output_data.w32->explicit_parent = false;
4603 }
4604
4605 /* Set the name; the functions to which we pass f expect the name to
4606 be set. */
4607 if (EQ (name, Qunbound) || NILP (name))
4608 {
4609 fset_name (f, build_string (dpyinfo->w32_id_name));
4610 f->explicit_name = false;
4611 }
4612 else
4613 {
4614 fset_name (f, name);
4615 f->explicit_name = true;
4616 /* Use the frame's title when getting resources for this frame. */
4617 specbind (Qx_resource_name, name);
4618 }
4619
4620 if (uniscribe_available)
4621 register_font_driver (&uniscribe_font_driver, f);
4622 register_font_driver (&w32font_driver, f);
4623
4624 x_default_parameter (f, parameters, Qfont_backend, Qnil,
4625 "fontBackend", "FontBackend", RES_TYPE_STRING);
4626
4627 /* Extract the window parameters from the supplied values
4628 that are needed to determine window geometry. */
4629 x_default_font_parameter (f, parameters);
4630
4631 x_default_parameter (f, parameters, Qborder_width, make_number (2),
4632 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
4633
4634 /* We recognize either internalBorderWidth or internalBorder
4635 (which is what xterm calls it). */
4636 if (NILP (Fassq (Qinternal_border_width, parameters)))
4637 {
4638 Lisp_Object value;
4639
4640 value = x_get_arg (dpyinfo, parameters, Qinternal_border_width,
4641 "internalBorder", "InternalBorder", RES_TYPE_NUMBER);
4642 if (! EQ (value, Qunbound))
4643 parameters = Fcons (Fcons (Qinternal_border_width, value),
4644 parameters);
4645 }
4646 /* Default internalBorderWidth to 0 on Windows to match other programs. */
4647 x_default_parameter (f, parameters, Qinternal_border_width, make_number (0),
4648 "internalBorderWidth", "InternalBorder", RES_TYPE_NUMBER);
4649 x_default_parameter (f, parameters, Qright_divider_width, make_number (0),
4650 NULL, NULL, RES_TYPE_NUMBER);
4651 x_default_parameter (f, parameters, Qbottom_divider_width, make_number (0),
4652 NULL, NULL, RES_TYPE_NUMBER);
4653 x_default_parameter (f, parameters, Qvertical_scroll_bars, Qright,
4654 "verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL);
4655 x_default_parameter (f, parameters, Qhorizontal_scroll_bars, Qnil,
4656 "horizontalScrollBars", "ScrollBars", RES_TYPE_SYMBOL);
4657
4658 /* Also do the stuff which must be set before the window exists. */
4659 x_default_parameter (f, parameters, Qforeground_color, build_string ("black"),
4660 "foreground", "Foreground", RES_TYPE_STRING);
4661 x_default_parameter (f, parameters, Qbackground_color, build_string ("white"),
4662 "background", "Background", RES_TYPE_STRING);
4663 x_default_parameter (f, parameters, Qmouse_color, build_string ("black"),
4664 "pointerColor", "Foreground", RES_TYPE_STRING);
4665 x_default_parameter (f, parameters, Qborder_color, build_string ("black"),
4666 "borderColor", "BorderColor", RES_TYPE_STRING);
4667 x_default_parameter (f, parameters, Qscreen_gamma, Qnil,
4668 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
4669 x_default_parameter (f, parameters, Qline_spacing, Qnil,
4670 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
4671 x_default_parameter (f, parameters, Qleft_fringe, Qnil,
4672 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
4673 x_default_parameter (f, parameters, Qright_fringe, Qnil,
4674 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
4675 /* Process alpha here (Bug#16619). */
4676 x_default_parameter (f, parameters, Qalpha, Qnil,
4677 "alpha", "Alpha", RES_TYPE_NUMBER);
4678
4679 /* Init faces first since we need the frame's column width/line
4680 height in various occasions. */
4681 init_frame_faces (f);
4682
4683 /* The following call of change_frame_size is needed since otherwise
4684 x_set_tool_bar_lines will already work with the character sizes
4685 installed by init_frame_faces while the frame's pixel size is
4686 still calculated from a character size of 1 and we subsequently
4687 hit the (height >= 0) assertion in window_box_height.
4688
4689 The non-pixelwise code apparently worked around this because it
4690 had one frame line vs one toolbar line which left us with a zero
4691 root window height which was obviously wrong as well ... */
4692 adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
4693 FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 5, true,
4694 Qx_create_frame_1);
4695
4696 /* The X resources controlling the menu-bar and tool-bar are
4697 processed specially at startup, and reflected in the mode
4698 variables; ignore them here. */
4699 x_default_parameter (f, parameters, Qmenu_bar_lines,
4700 NILP (Vmenu_bar_mode)
4701 ? make_number (0) : make_number (1),
4702 NULL, NULL, RES_TYPE_NUMBER);
4703 x_default_parameter (f, parameters, Qtool_bar_lines,
4704 NILP (Vtool_bar_mode)
4705 ? make_number (0) : make_number (1),
4706 NULL, NULL, RES_TYPE_NUMBER);
4707
4708 x_default_parameter (f, parameters, Qbuffer_predicate, Qnil,
4709 "bufferPredicate", "BufferPredicate", RES_TYPE_SYMBOL);
4710 x_default_parameter (f, parameters, Qtitle, Qnil,
4711 "title", "Title", RES_TYPE_STRING);
4712
4713 f->output_data.w32->dwStyle = WS_OVERLAPPEDWINDOW;
4714 f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
4715
4716 f->output_data.w32->text_cursor = w32_load_cursor (IDC_IBEAM);
4717 f->output_data.w32->nontext_cursor = w32_load_cursor (IDC_ARROW);
4718 f->output_data.w32->modeline_cursor = w32_load_cursor (IDC_ARROW);
4719 f->output_data.w32->hand_cursor = w32_load_cursor (IDC_HAND);
4720 f->output_data.w32->hourglass_cursor = w32_load_cursor (IDC_WAIT);
4721 f->output_data.w32->horizontal_drag_cursor = w32_load_cursor (IDC_SIZEWE);
4722 f->output_data.w32->vertical_drag_cursor = w32_load_cursor (IDC_SIZENS);
4723
4724 f->output_data.w32->current_cursor = f->output_data.w32->nontext_cursor;
4725
4726 window_prompting = x_figure_window_size (f, parameters, true);
4727
4728 tem = x_get_arg (dpyinfo, parameters, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
4729 f->no_split = minibuffer_only || EQ (tem, Qt);
4730
4731 w32_window (f, window_prompting, minibuffer_only);
4732 x_icon (f, parameters);
4733
4734 x_make_gc (f);
4735
4736 /* Now consider the frame official. */
4737 f->terminal->reference_count++;
4738 FRAME_DISPLAY_INFO (f)->reference_count++;
4739 Vframe_list = Fcons (frame, Vframe_list);
4740
4741 /* We need to do this after creating the window, so that the
4742 icon-creation functions can say whose icon they're describing. */
4743 x_default_parameter (f, parameters, Qicon_type, Qnil,
4744 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL);
4745
4746 x_default_parameter (f, parameters, Qauto_raise, Qnil,
4747 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4748 x_default_parameter (f, parameters, Qauto_lower, Qnil,
4749 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4750 x_default_parameter (f, parameters, Qcursor_type, Qbox,
4751 "cursorType", "CursorType", RES_TYPE_SYMBOL);
4752 x_default_parameter (f, parameters, Qscroll_bar_width, Qnil,
4753 "scrollBarWidth", "ScrollBarWidth", RES_TYPE_NUMBER);
4754 x_default_parameter (f, parameters, Qscroll_bar_height, Qnil,
4755 "scrollBarHeight", "ScrollBarHeight", RES_TYPE_NUMBER);
4756
4757 /* Allow x_set_window_size, now. */
4758 f->can_x_set_window_size = true;
4759
4760 adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 0, true,
4761 Qx_create_frame_2);
4762
4763 /* Tell the server what size and position, etc, we want, and how
4764 badly we want them. This should be done after we have the menu
4765 bar so that its size can be taken into account. */
4766 block_input ();
4767 x_wm_set_size_hint (f, window_prompting, false);
4768 unblock_input ();
4769
4770 /* Process fullscreen parameter here in the hope that normalizing a
4771 fullheight/fullwidth frame will produce the size set by the last
4772 adjust_frame_size call. */
4773 x_default_parameter (f, parameters, Qfullscreen, Qnil,
4774 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
4775
4776 /* Make the window appear on the frame and enable display, unless
4777 the caller says not to. However, with explicit parent, Emacs
4778 cannot control visibility, so don't try. */
4779 if (! f->output_data.w32->explicit_parent)
4780 {
4781 Lisp_Object visibility;
4782
4783 visibility = x_get_arg (dpyinfo, parameters, Qvisibility, 0, 0, RES_TYPE_SYMBOL);
4784 if (EQ (visibility, Qunbound))
4785 visibility = Qt;
4786
4787 if (EQ (visibility, Qicon))
4788 x_iconify_frame (f);
4789 else if (! NILP (visibility))
4790 x_make_frame_visible (f);
4791 else
4792 /* Must have been Qnil. */
4793 ;
4794 }
4795
4796 /* Initialize `default-minibuffer-frame' in case this is the first
4797 frame on this terminal. */
4798 if (FRAME_HAS_MINIBUF_P (f)
4799 && (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
4800 || !FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)))))
4801 kset_default_minibuffer_frame (kb, frame);
4802
4803 /* All remaining specified parameters, which have not been "used"
4804 by x_get_arg and friends, now go in the misc. alist of the frame. */
4805 for (tem = parameters; CONSP (tem); tem = XCDR (tem))
4806 if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
4807 fset_param_alist (f, Fcons (XCAR (tem), f->param_alist));
4808
4809 UNGCPRO;
4810
4811 /* Make sure windows on this frame appear in calls to next-window
4812 and similar functions. */
4813 Vwindow_list = Qnil;
4814
4815 return unbind_to (count, frame);
4816 }
4817
4818 /* FRAME is used only to get a handle on the X display. We don't pass the
4819 display info directly because we're called from frame.c, which doesn't
4820 know about that structure. */
4821 Lisp_Object
4822 x_get_focus_frame (struct frame *frame)
4823 {
4824 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (frame);
4825 Lisp_Object xfocus;
4826 if (! dpyinfo->w32_focus_frame)
4827 return Qnil;
4828
4829 XSETFRAME (xfocus, dpyinfo->w32_focus_frame);
4830 return xfocus;
4831 }
4832
4833 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
4834 doc: /* Internal function called by `color-defined-p', which see.
4835 \(Note that the Nextstep version of this function ignores FRAME.) */)
4836 (Lisp_Object color, Lisp_Object frame)
4837 {
4838 XColor foo;
4839 struct frame *f = decode_window_system_frame (frame);
4840
4841 CHECK_STRING (color);
4842
4843 if (w32_defined_color (f, SDATA (color), &foo, false))
4844 return Qt;
4845 else
4846 return Qnil;
4847 }
4848
4849 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
4850 doc: /* Internal function called by `color-values', which see. */)
4851 (Lisp_Object color, Lisp_Object frame)
4852 {
4853 XColor foo;
4854 struct frame *f = decode_window_system_frame (frame);
4855
4856 CHECK_STRING (color);
4857
4858 if (w32_defined_color (f, SDATA (color), &foo, false))
4859 return list3i ((GetRValue (foo.pixel) << 8) | GetRValue (foo.pixel),
4860 (GetGValue (foo.pixel) << 8) | GetGValue (foo.pixel),
4861 (GetBValue (foo.pixel) << 8) | GetBValue (foo.pixel));
4862 else
4863 return Qnil;
4864 }
4865
4866 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
4867 doc: /* Internal function called by `display-color-p', which see. */)
4868 (Lisp_Object display)
4869 {
4870 struct w32_display_info *dpyinfo = check_x_display_info (display);
4871
4872 if ((dpyinfo->n_planes * dpyinfo->n_cbits) <= 2)
4873 return Qnil;
4874
4875 return Qt;
4876 }
4877
4878 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p,
4879 Sx_display_grayscale_p, 0, 1, 0,
4880 doc: /* Return t if DISPLAY supports shades of gray.
4881 Note that color displays do support shades of gray.
4882 The optional argument DISPLAY specifies which display to ask about.
4883 DISPLAY should be either a frame or a display name (a string).
4884 If omitted or nil, that stands for the selected frame's display. */)
4885 (Lisp_Object display)
4886 {
4887 struct w32_display_info *dpyinfo = check_x_display_info (display);
4888
4889 if ((dpyinfo->n_planes * dpyinfo->n_cbits) <= 1)
4890 return Qnil;
4891
4892 return Qt;
4893 }
4894
4895 DEFUN ("x-display-pixel-width", Fx_display_pixel_width,
4896 Sx_display_pixel_width, 0, 1, 0,
4897 doc: /* Return the width in pixels of DISPLAY.
4898 The optional argument DISPLAY specifies which display to ask about.
4899 DISPLAY should be either a frame or a display name (a string).
4900 If omitted or nil, that stands for the selected frame's display.
4901
4902 On \"multi-monitor\" setups this refers to the pixel width for all
4903 physical monitors associated with DISPLAY. To get information for
4904 each physical monitor, use `display-monitor-attributes-list'. */)
4905 (Lisp_Object display)
4906 {
4907 struct w32_display_info *dpyinfo = check_x_display_info (display);
4908
4909 return make_number (x_display_pixel_width (dpyinfo));
4910 }
4911
4912 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
4913 Sx_display_pixel_height, 0, 1, 0,
4914 doc: /* Return the height in pixels of DISPLAY.
4915 The optional argument DISPLAY specifies which display to ask about.
4916 DISPLAY should be either a frame or a display name (a string).
4917 If omitted or nil, that stands for the selected frame's display.
4918
4919 On \"multi-monitor\" setups this refers to the pixel height for all
4920 physical monitors associated with DISPLAY. To get information for
4921 each physical monitor, use `display-monitor-attributes-list'. */)
4922 (Lisp_Object display)
4923 {
4924 struct w32_display_info *dpyinfo = check_x_display_info (display);
4925
4926 return make_number (x_display_pixel_height (dpyinfo));
4927 }
4928
4929 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
4930 0, 1, 0,
4931 doc: /* Return the number of bitplanes of DISPLAY.
4932 The optional argument DISPLAY specifies which display to ask about.
4933 DISPLAY should be either a frame or a display name (a string).
4934 If omitted or nil, that stands for the selected frame's display. */)
4935 (Lisp_Object display)
4936 {
4937 struct w32_display_info *dpyinfo = check_x_display_info (display);
4938
4939 return make_number (dpyinfo->n_planes * dpyinfo->n_cbits);
4940 }
4941
4942 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
4943 0, 1, 0,
4944 doc: /* Return the number of color cells of DISPLAY.
4945 The optional argument DISPLAY specifies which display to ask about.
4946 DISPLAY should be either a frame or a display name (a string).
4947 If omitted or nil, that stands for the selected frame's display. */)
4948 (Lisp_Object display)
4949 {
4950 struct w32_display_info *dpyinfo = check_x_display_info (display);
4951 int cap;
4952
4953 /* Don't use NCOLORS: it returns incorrect results under remote
4954 * desktop. We force 24+ bit depths to 24-bit, both to prevent an
4955 * overflow and because probably is more meaningful on Windows
4956 * anyway. */
4957
4958 cap = 1 << min (dpyinfo->n_planes * dpyinfo->n_cbits, 24);
4959 return make_number (cap);
4960 }
4961
4962 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
4963 Sx_server_max_request_size,
4964 0, 1, 0,
4965 doc: /* Return the maximum request size of the server of DISPLAY.
4966 The optional argument DISPLAY specifies which display to ask about.
4967 DISPLAY should be either a frame or a display name (a string).
4968 If omitted or nil, that stands for the selected frame's display. */)
4969 (Lisp_Object display)
4970 {
4971 return make_number (1);
4972 }
4973
4974 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
4975 doc: /* Return the "vendor ID" string of the GUI software on TERMINAL.
4976
4977 \(Labeling every distributor as a "vendor" embodies the false assumption
4978 that operating systems cannot be developed and distributed noncommercially.)
4979
4980 For GNU and Unix systems, this queries the X server software; for
4981 MS-Windows, this queries the OS.
4982
4983 The optional argument TERMINAL specifies which display to ask about.
4984 TERMINAL should be a terminal object, a frame or a display name (a string).
4985 If omitted or nil, that stands for the selected frame's display. */)
4986 (Lisp_Object terminal)
4987 {
4988 return build_string ("Microsoft Corp.");
4989 }
4990
4991 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
4992 doc: /* Return the version numbers of the GUI software on TERMINAL.
4993 The value is a list of three integers specifying the version of the GUI
4994 software in use.
4995
4996 For GNU and Unix system, the first 2 numbers are the version of the X
4997 Protocol used on TERMINAL and the 3rd number is the distributor-specific
4998 release number. For MS-Windows, the 3 numbers report the version and
4999 the build number of the OS.
5000
5001 See also the function `x-server-vendor'.
5002
5003 The optional argument TERMINAL specifies which display to ask about.
5004 TERMINAL should be a terminal object, a frame or a display name (a string).
5005 If omitted or nil, that stands for the selected frame's display. */)
5006 (Lisp_Object terminal)
5007 {
5008 return list3i (w32_major_version, w32_minor_version, w32_build_number);
5009 }
5010
5011 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
5012 doc: /* Return the number of screens on the server of DISPLAY.
5013 The optional argument DISPLAY specifies which display to ask about.
5014 DISPLAY should be either a frame or a display name (a string).
5015 If omitted or nil, that stands for the selected frame's display. */)
5016 (Lisp_Object display)
5017 {
5018 return make_number (1);
5019 }
5020
5021 DEFUN ("x-display-mm-height", Fx_display_mm_height,
5022 Sx_display_mm_height, 0, 1, 0,
5023 doc: /* Return the height in millimeters of DISPLAY.
5024 The optional argument DISPLAY specifies which display to ask about.
5025 DISPLAY should be either a frame or a display name (a string).
5026 If omitted or nil, that stands for the selected frame's display.
5027
5028 On \"multi-monitor\" setups this refers to the height in millimeters for
5029 all physical monitors associated with DISPLAY. To get information
5030 for each physical monitor, use `display-monitor-attributes-list'. */)
5031 (Lisp_Object display)
5032 {
5033 struct w32_display_info *dpyinfo = check_x_display_info (display);
5034 HDC hdc;
5035 double mm_per_pixel;
5036
5037 hdc = GetDC (NULL);
5038 mm_per_pixel = ((double) GetDeviceCaps (hdc, VERTSIZE)
5039 / GetDeviceCaps (hdc, VERTRES));
5040 ReleaseDC (NULL, hdc);
5041
5042 return make_number (x_display_pixel_height (dpyinfo) * mm_per_pixel + 0.5);
5043 }
5044
5045 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
5046 doc: /* Return the width in millimeters of DISPLAY.
5047 The optional argument DISPLAY specifies which display to ask about.
5048 DISPLAY should be either a frame or a display name (a string).
5049 If omitted or nil, that stands for the selected frame's display.
5050
5051 On \"multi-monitor\" setups this refers to the width in millimeters for
5052 all physical monitors associated with TERMINAL. To get information
5053 for each physical monitor, use `display-monitor-attributes-list'. */)
5054 (Lisp_Object display)
5055 {
5056 struct w32_display_info *dpyinfo = check_x_display_info (display);
5057 HDC hdc;
5058 double mm_per_pixel;
5059
5060 hdc = GetDC (NULL);
5061 mm_per_pixel = ((double) GetDeviceCaps (hdc, HORZSIZE)
5062 / GetDeviceCaps (hdc, HORZRES));
5063 ReleaseDC (NULL, hdc);
5064
5065 return make_number (x_display_pixel_width (dpyinfo) * mm_per_pixel + 0.5);
5066 }
5067
5068 DEFUN ("x-display-backing-store", Fx_display_backing_store,
5069 Sx_display_backing_store, 0, 1, 0,
5070 doc: /* Return an indication of whether DISPLAY does backing store.
5071 The value may be `always', `when-mapped', or `not-useful'.
5072 The optional argument DISPLAY specifies which display to ask about.
5073 DISPLAY should be either a frame or a display name (a string).
5074 If omitted or nil, that stands for the selected frame's display. */)
5075 (Lisp_Object display)
5076 {
5077 return intern ("not-useful");
5078 }
5079
5080 DEFUN ("x-display-visual-class", Fx_display_visual_class,
5081 Sx_display_visual_class, 0, 1, 0,
5082 doc: /* Return the visual class of DISPLAY.
5083 The value is one of the symbols `static-gray', `gray-scale',
5084 `static-color', `pseudo-color', `true-color', or `direct-color'.
5085
5086 The optional argument DISPLAY specifies which display to ask about.
5087 DISPLAY should be either a frame or a display name (a string).
5088 If omitted or nil, that stands for the selected frame's display. */)
5089 (Lisp_Object display)
5090 {
5091 struct w32_display_info *dpyinfo = check_x_display_info (display);
5092 Lisp_Object result = Qnil;
5093
5094 if (dpyinfo->has_palette)
5095 result = intern ("pseudo-color");
5096 else if (dpyinfo->n_planes * dpyinfo->n_cbits == 1)
5097 result = intern ("static-grey");
5098 else if (dpyinfo->n_planes * dpyinfo->n_cbits == 4)
5099 result = intern ("static-color");
5100 else if (dpyinfo->n_planes * dpyinfo->n_cbits > 8)
5101 result = intern ("true-color");
5102
5103 return result;
5104 }
5105
5106 DEFUN ("x-display-save-under", Fx_display_save_under,
5107 Sx_display_save_under, 0, 1, 0,
5108 doc: /* Return t if DISPLAY supports the save-under feature.
5109 The optional argument DISPLAY specifies which display to ask about.
5110 DISPLAY should be either a frame or a display name (a string).
5111 If omitted or nil, that stands for the selected frame's display. */)
5112 (Lisp_Object display)
5113 {
5114 return Qnil;
5115 }
5116
5117 static BOOL CALLBACK ALIGN_STACK
5118 w32_monitor_enum (HMONITOR monitor, HDC hdc, RECT *rcMonitor, LPARAM dwData)
5119 {
5120 Lisp_Object *monitor_list = (Lisp_Object *) dwData;
5121
5122 *monitor_list = Fcons (make_save_ptr (monitor), *monitor_list);
5123
5124 return TRUE;
5125 }
5126
5127 static Lisp_Object
5128 w32_display_monitor_attributes_list (void)
5129 {
5130 Lisp_Object attributes_list = Qnil, primary_monitor_attributes = Qnil;
5131 Lisp_Object monitor_list = Qnil, monitor_frames, rest, frame;
5132 int i, n_monitors;
5133 HMONITOR *monitors;
5134 struct gcpro gcpro1, gcpro2, gcpro3;
5135
5136 if (!(enum_display_monitors_fn && get_monitor_info_fn
5137 && monitor_from_window_fn))
5138 return Qnil;
5139
5140 if (!enum_display_monitors_fn (NULL, NULL, w32_monitor_enum,
5141 (LPARAM) &monitor_list)
5142 || NILP (monitor_list))
5143 return Qnil;
5144
5145 n_monitors = 0;
5146 for (rest = monitor_list; CONSP (rest); rest = XCDR (rest))
5147 n_monitors++;
5148
5149 monitors = xmalloc (n_monitors * sizeof (*monitors));
5150 for (i = 0; i < n_monitors; i++)
5151 {
5152 monitors[i] = XSAVE_POINTER (XCAR (monitor_list), 0);
5153 monitor_list = XCDR (monitor_list);
5154 }
5155
5156 monitor_frames = Fmake_vector (make_number (n_monitors), Qnil);
5157 FOR_EACH_FRAME (rest, frame)
5158 {
5159 struct frame *f = XFRAME (frame);
5160
5161 if (FRAME_W32_P (f) && !EQ (frame, tip_frame))
5162 {
5163 HMONITOR monitor =
5164 monitor_from_window_fn (FRAME_W32_WINDOW (f),
5165 MONITOR_DEFAULT_TO_NEAREST);
5166
5167 for (i = 0; i < n_monitors; i++)
5168 if (monitors[i] == monitor)
5169 break;
5170
5171 if (i < n_monitors)
5172 ASET (monitor_frames, i, Fcons (frame, AREF (monitor_frames, i)));
5173 }
5174 }
5175
5176 GCPRO3 (attributes_list, primary_monitor_attributes, monitor_frames);
5177
5178 for (i = 0; i < n_monitors; i++)
5179 {
5180 Lisp_Object geometry, workarea, name, attributes = Qnil;
5181 HDC hdc;
5182 int width_mm, height_mm;
5183 struct MONITOR_INFO_EX mi;
5184
5185 mi.cbSize = sizeof (mi);
5186 if (!get_monitor_info_fn (monitors[i], (struct MONITOR_INFO *) &mi))
5187 continue;
5188
5189 hdc = CreateDCA ("DISPLAY", mi.szDevice, NULL, NULL);
5190 if (hdc == NULL)
5191 continue;
5192 width_mm = GetDeviceCaps (hdc, HORZSIZE);
5193 height_mm = GetDeviceCaps (hdc, VERTSIZE);
5194 DeleteDC (hdc);
5195
5196 attributes = Fcons (Fcons (Qframes, AREF (monitor_frames, i)),
5197 attributes);
5198
5199 name = DECODE_SYSTEM (build_unibyte_string (mi.szDevice));
5200
5201 attributes = Fcons (Fcons (Qname, name), attributes);
5202
5203 attributes = Fcons (Fcons (Qmm_size, list2i (width_mm, height_mm)),
5204 attributes);
5205
5206 workarea = list4i (mi.rcWork.left, mi.rcWork.top,
5207 mi.rcWork.right - mi.rcWork.left,
5208 mi.rcWork.bottom - mi.rcWork.top);
5209 attributes = Fcons (Fcons (Qworkarea, workarea), attributes);
5210
5211 geometry = list4i (mi.rcMonitor.left, mi.rcMonitor.top,
5212 mi.rcMonitor.right - mi.rcMonitor.left,
5213 mi.rcMonitor.bottom - mi.rcMonitor.top);
5214 attributes = Fcons (Fcons (Qgeometry, geometry), attributes);
5215
5216 if (mi.dwFlags & MONITORINFOF_PRIMARY)
5217 primary_monitor_attributes = attributes;
5218 else
5219 attributes_list = Fcons (attributes, attributes_list);
5220 }
5221
5222 if (!NILP (primary_monitor_attributes))
5223 attributes_list = Fcons (primary_monitor_attributes, attributes_list);
5224
5225 UNGCPRO;
5226
5227 xfree (monitors);
5228
5229 return attributes_list;
5230 }
5231
5232 static Lisp_Object
5233 w32_display_monitor_attributes_list_fallback (struct w32_display_info *dpyinfo)
5234 {
5235 Lisp_Object geometry, workarea, frames, rest, frame, attributes = Qnil;
5236 HDC hdc;
5237 double mm_per_pixel;
5238 int pixel_width, pixel_height, width_mm, height_mm;
5239 RECT workarea_rect;
5240
5241 /* Fallback: treat (possibly) multiple physical monitors as if they
5242 formed a single monitor as a whole. This should provide a
5243 consistent result at least on single monitor environments. */
5244 attributes = Fcons (Fcons (Qname, build_string ("combined screen")),
5245 attributes);
5246
5247 frames = Qnil;
5248 FOR_EACH_FRAME (rest, frame)
5249 {
5250 struct frame *f = XFRAME (frame);
5251
5252 if (FRAME_W32_P (f) && !EQ (frame, tip_frame))
5253 frames = Fcons (frame, frames);
5254 }
5255 attributes = Fcons (Fcons (Qframes, frames), attributes);
5256
5257 pixel_width = x_display_pixel_width (dpyinfo);
5258 pixel_height = x_display_pixel_height (dpyinfo);
5259
5260 hdc = GetDC (NULL);
5261 mm_per_pixel = ((double) GetDeviceCaps (hdc, HORZSIZE)
5262 / GetDeviceCaps (hdc, HORZRES));
5263 width_mm = pixel_width * mm_per_pixel + 0.5;
5264 mm_per_pixel = ((double) GetDeviceCaps (hdc, VERTSIZE)
5265 / GetDeviceCaps (hdc, VERTRES));
5266 height_mm = pixel_height * mm_per_pixel + 0.5;
5267 ReleaseDC (NULL, hdc);
5268 attributes = Fcons (Fcons (Qmm_size, list2i (width_mm, height_mm)),
5269 attributes);
5270
5271 /* GetSystemMetrics below may return 0 for Windows 95 or NT 4.0, but
5272 we don't care. */
5273 geometry = list4i (GetSystemMetrics (SM_XVIRTUALSCREEN),
5274 GetSystemMetrics (SM_YVIRTUALSCREEN),
5275 pixel_width, pixel_height);
5276 if (SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0))
5277 workarea = list4i (workarea_rect.left, workarea_rect.top,
5278 workarea_rect.right - workarea_rect.left,
5279 workarea_rect.bottom - workarea_rect.top);
5280 else
5281 workarea = geometry;
5282 attributes = Fcons (Fcons (Qworkarea, workarea), attributes);
5283
5284 attributes = Fcons (Fcons (Qgeometry, geometry), attributes);
5285
5286 return list1 (attributes);
5287 }
5288
5289 DEFUN ("w32-display-monitor-attributes-list", Fw32_display_monitor_attributes_list,
5290 Sw32_display_monitor_attributes_list,
5291 0, 1, 0,
5292 doc: /* Return a list of physical monitor attributes on the W32 display DISPLAY.
5293
5294 The optional argument DISPLAY specifies which display to ask about.
5295 DISPLAY should be either a frame or a display name (a string).
5296 If omitted or nil, that stands for the selected frame's display.
5297
5298 Internal use only, use `display-monitor-attributes-list' instead. */)
5299 (Lisp_Object display)
5300 {
5301 struct w32_display_info *dpyinfo = check_x_display_info (display);
5302 Lisp_Object attributes_list;
5303
5304 block_input ();
5305 attributes_list = w32_display_monitor_attributes_list ();
5306 if (NILP (attributes_list))
5307 attributes_list = w32_display_monitor_attributes_list_fallback (dpyinfo);
5308 unblock_input ();
5309
5310 return attributes_list;
5311 }
5312
5313 DEFUN ("set-message-beep", Fset_message_beep, Sset_message_beep, 1, 1, 0,
5314 doc: /* Set the sound generated when the bell is rung.
5315 SOUND is 'asterisk, 'exclamation, 'hand, 'question, 'ok, or 'silent
5316 to use the corresponding system sound for the bell. The 'silent sound
5317 prevents Emacs from making any sound at all.
5318 SOUND is nil to use the normal beep. */)
5319 (Lisp_Object sound)
5320 {
5321 CHECK_SYMBOL (sound);
5322
5323 if (NILP (sound))
5324 sound_type = 0xFFFFFFFF;
5325 else if (EQ (sound, intern ("asterisk")))
5326 sound_type = MB_ICONASTERISK;
5327 else if (EQ (sound, intern ("exclamation")))
5328 sound_type = MB_ICONEXCLAMATION;
5329 else if (EQ (sound, intern ("hand")))
5330 sound_type = MB_ICONHAND;
5331 else if (EQ (sound, intern ("question")))
5332 sound_type = MB_ICONQUESTION;
5333 else if (EQ (sound, intern ("ok")))
5334 sound_type = MB_OK;
5335 else if (EQ (sound, intern ("silent")))
5336 sound_type = MB_EMACS_SILENT;
5337 else
5338 sound_type = 0xFFFFFFFF;
5339
5340 return sound;
5341 }
5342
5343 int
5344 x_screen_planes (register struct frame *f)
5345 {
5346 return FRAME_DISPLAY_INFO (f)->n_planes;
5347 }
5348 \f
5349 /* Return the display structure for the display named NAME.
5350 Open a new connection if necessary. */
5351
5352 struct w32_display_info *
5353 x_display_info_for_name (Lisp_Object name)
5354 {
5355 struct w32_display_info *dpyinfo;
5356
5357 CHECK_STRING (name);
5358
5359 for (dpyinfo = &one_w32_display_info; dpyinfo; dpyinfo = dpyinfo->next)
5360 if (!NILP (Fstring_equal (XCAR (dpyinfo->name_list_element), name)))
5361 return dpyinfo;
5362
5363 /* Use this general default value to start with. */
5364 Vx_resource_name = Vinvocation_name;
5365
5366 validate_x_resource_name ();
5367
5368 dpyinfo = w32_term_init (name, (unsigned char *)0,
5369 SSDATA (Vx_resource_name));
5370
5371 if (dpyinfo == 0)
5372 error ("Cannot connect to server %s", SDATA (name));
5373
5374 XSETFASTINT (Vwindow_system_version, w32_major_version);
5375
5376 return dpyinfo;
5377 }
5378
5379 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
5380 1, 3, 0, doc: /* Open a connection to a display server.
5381 DISPLAY is the name of the display to connect to.
5382 Optional second arg XRM-STRING is a string of resources in xrdb format.
5383 If the optional third arg MUST-SUCCEED is non-nil,
5384 terminate Emacs if we can't open the connection.
5385 \(In the Nextstep version, the last two arguments are currently ignored.) */)
5386 (Lisp_Object display, Lisp_Object xrm_string, Lisp_Object must_succeed)
5387 {
5388 unsigned char *xrm_option;
5389 struct w32_display_info *dpyinfo;
5390
5391 CHECK_STRING (display);
5392
5393 /* Signal an error in order to encourage correct use from callers.
5394 * If we ever support multiple window systems in the same Emacs,
5395 * we'll need callers to be precise about what window system they
5396 * want. */
5397
5398 if (strcmp (SSDATA (display), "w32") != 0)
5399 error ("The name of the display in this Emacs must be \"w32\"");
5400
5401 /* If initialization has already been done, return now to avoid
5402 overwriting critical parts of one_w32_display_info. */
5403 if (window_system_available (NULL))
5404 return Qnil;
5405
5406 if (! NILP (xrm_string))
5407 CHECK_STRING (xrm_string);
5408
5409 /* Allow color mapping to be defined externally; first look in user's
5410 HOME directory, then in Emacs etc dir for a file called rgb.txt. */
5411 {
5412 Lisp_Object color_file;
5413 struct gcpro gcpro1;
5414
5415 color_file = build_string ("~/rgb.txt");
5416
5417 GCPRO1 (color_file);
5418
5419 if (NILP (Ffile_readable_p (color_file)))
5420 color_file =
5421 Fexpand_file_name (build_string ("rgb.txt"),
5422 Fsymbol_value (intern ("data-directory")));
5423
5424 Vw32_color_map = Fx_load_color_file (color_file);
5425
5426 UNGCPRO;
5427 }
5428 if (NILP (Vw32_color_map))
5429 Vw32_color_map = w32_default_color_map ();
5430
5431 /* Merge in system logical colors. */
5432 add_system_logical_colors_to_map (&Vw32_color_map);
5433
5434 if (! NILP (xrm_string))
5435 xrm_option = SDATA (xrm_string);
5436 else
5437 xrm_option = (unsigned char *) 0;
5438
5439 /* Use this general default value to start with. */
5440 /* First remove .exe suffix from invocation-name - it looks ugly. */
5441 {
5442 char basename[ MAX_PATH ], *str;
5443
5444 lispstpcpy (basename, Vinvocation_name);
5445 str = strrchr (basename, '.');
5446 if (str) *str = 0;
5447 Vinvocation_name = build_string (basename);
5448 }
5449 Vx_resource_name = Vinvocation_name;
5450
5451 validate_x_resource_name ();
5452
5453 /* This is what opens the connection and sets x_current_display.
5454 This also initializes many symbols, such as those used for input. */
5455 dpyinfo = w32_term_init (display, xrm_option,
5456 SSDATA (Vx_resource_name));
5457
5458 if (dpyinfo == 0)
5459 {
5460 if (!NILP (must_succeed))
5461 fatal ("Cannot connect to server %s.\n",
5462 SDATA (display));
5463 else
5464 error ("Cannot connect to server %s", SDATA (display));
5465 }
5466
5467 XSETFASTINT (Vwindow_system_version, w32_major_version);
5468 return Qnil;
5469 }
5470
5471 DEFUN ("x-close-connection", Fx_close_connection,
5472 Sx_close_connection, 1, 1, 0,
5473 doc: /* Close the connection to DISPLAY's server.
5474 For DISPLAY, specify either a frame or a display name (a string).
5475 If DISPLAY is nil, that stands for the selected frame's display. */)
5476 (Lisp_Object display)
5477 {
5478 struct w32_display_info *dpyinfo = check_x_display_info (display);
5479
5480 if (dpyinfo->reference_count > 0)
5481 error ("Display still has frames on it");
5482
5483 block_input ();
5484 x_destroy_all_bitmaps (dpyinfo);
5485
5486 x_delete_display (dpyinfo);
5487 unblock_input ();
5488
5489 return Qnil;
5490 }
5491
5492 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
5493 doc: /* Return the list of display names that Emacs has connections to. */)
5494 (void)
5495 {
5496 Lisp_Object result = Qnil;
5497 struct w32_display_info *wdi;
5498
5499 for (wdi = x_display_list; wdi; wdi = wdi->next)
5500 result = Fcons (XCAR (wdi->name_list_element), result);
5501
5502 return result;
5503 }
5504
5505 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
5506 doc: /* If ON is non-nil, report X errors as soon as the erring request is made.
5507 This function only has an effect on X Windows. With MS Windows, it is
5508 defined but does nothing.
5509
5510 If ON is nil, allow buffering of requests.
5511 Turning on synchronization prohibits the Xlib routines from buffering
5512 requests and seriously degrades performance, but makes debugging much
5513 easier.
5514 The optional second argument TERMINAL specifies which display to act on.
5515 TERMINAL should be a terminal object, a frame or a display name (a string).
5516 If TERMINAL is omitted or nil, that stands for the selected frame's display. */)
5517 (Lisp_Object on, Lisp_Object display)
5518 {
5519 return Qnil;
5520 }
5521
5522
5523 \f
5524 /***********************************************************************
5525 Window properties
5526 ***********************************************************************/
5527
5528 #if 0 /* TODO : port window properties to W32 */
5529
5530 DEFUN ("x-change-window-property", Fx_change_window_property,
5531 Sx_change_window_property, 2, 6, 0,
5532 doc: /* Change window property PROP to VALUE on the X window of FRAME.
5533 PROP must be a string. VALUE may be a string or a list of conses,
5534 numbers and/or strings. If an element in the list is a string, it is
5535 converted to an atom and the value of the Atom is used. If an element
5536 is a cons, it is converted to a 32 bit number where the car is the 16
5537 top bits and the cdr is the lower 16 bits.
5538
5539 FRAME nil or omitted means use the selected frame.
5540 If TYPE is given and non-nil, it is the name of the type of VALUE.
5541 If TYPE is not given or nil, the type is STRING.
5542 FORMAT gives the size in bits of each element if VALUE is a list.
5543 It must be one of 8, 16 or 32.
5544 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
5545 If OUTER-P is non-nil, the property is changed for the outer X window of
5546 FRAME. Default is to change on the edit X window. */)
5547 (Lisp_Object prop, Lisp_Object value, Lisp_Object frame,
5548 Lisp_Object type, Lisp_Object format, Lisp_Object outer_p)
5549 {
5550 struct frame *f = decode_window_system_frame (frame);
5551 Atom prop_atom;
5552
5553 CHECK_STRING (prop);
5554 CHECK_STRING (value);
5555
5556 block_input ();
5557 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
5558 XChangeProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
5559 prop_atom, XA_STRING, 8, PropModeReplace,
5560 SDATA (value), SCHARS (value));
5561
5562 /* Make sure the property is set when we return. */
5563 XFlush (FRAME_W32_DISPLAY (f));
5564 unblock_input ();
5565
5566 return value;
5567 }
5568
5569
5570 DEFUN ("x-delete-window-property", Fx_delete_window_property,
5571 Sx_delete_window_property, 1, 2, 0,
5572 doc: /* Remove window property PROP from X window of FRAME.
5573 FRAME nil or omitted means use the selected frame. Value is PROP. */)
5574 (Lisp_Object prop, Lisp_Object frame)
5575 {
5576 struct frame *f = decode_window_system_frame (frame);
5577 Atom prop_atom;
5578
5579 CHECK_STRING (prop);
5580 block_input ();
5581 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
5582 XDeleteProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f), prop_atom);
5583
5584 /* Make sure the property is removed when we return. */
5585 XFlush (FRAME_W32_DISPLAY (f));
5586 unblock_input ();
5587
5588 return prop;
5589 }
5590
5591
5592 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
5593 1, 6, 0,
5594 doc: /* Value is the value of window property PROP on FRAME.
5595 If FRAME is nil or omitted, use the selected frame.
5596
5597 On X Windows, the following optional arguments are also accepted:
5598 If TYPE is nil or omitted, get the property as a string.
5599 Otherwise TYPE is the name of the atom that denotes the type expected.
5600 If SOURCE is non-nil, get the property on that window instead of from
5601 FRAME. The number 0 denotes the root window.
5602 If DELETE-P is non-nil, delete the property after retrieving it.
5603 If VECTOR-RET-P is non-nil, don't return a string but a vector of values.
5604
5605 On MS Windows, this function accepts but ignores those optional arguments.
5606
5607 Value is nil if FRAME hasn't a property with name PROP or if PROP has
5608 no value of TYPE (always string in the MS Windows case). */)
5609 (Lisp_Object prop, Lisp_Object frame, Lisp_Object type,
5610 Lisp_Object source, Lisp_Object delete_p, Lisp_Object vector_ret_p)
5611 {
5612 struct frame *f = decode_window_system_frame (frame);
5613 Atom prop_atom;
5614 int rc;
5615 Lisp_Object prop_value = Qnil;
5616 char *tmp_data = NULL;
5617 Atom actual_type;
5618 int actual_format;
5619 unsigned long actual_size, bytes_remaining;
5620
5621 CHECK_STRING (prop);
5622 block_input ();
5623 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
5624 rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
5625 prop_atom, 0, 0, False, XA_STRING,
5626 &actual_type, &actual_format, &actual_size,
5627 &bytes_remaining, (unsigned char **) &tmp_data);
5628 if (rc == Success)
5629 {
5630 int size = bytes_remaining;
5631
5632 XFree (tmp_data);
5633 tmp_data = NULL;
5634
5635 rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
5636 prop_atom, 0, bytes_remaining,
5637 False, XA_STRING,
5638 &actual_type, &actual_format,
5639 &actual_size, &bytes_remaining,
5640 (unsigned char **) &tmp_data);
5641 if (rc == Success)
5642 prop_value = make_string (tmp_data, size);
5643
5644 XFree (tmp_data);
5645 }
5646
5647 unblock_input ();
5648
5649 return prop_value;
5650
5651 return Qnil;
5652 }
5653
5654 #endif /* TODO */
5655
5656 /***********************************************************************
5657 Tool tips
5658 ***********************************************************************/
5659
5660 static Lisp_Object x_create_tip_frame (struct w32_display_info *,
5661 Lisp_Object, Lisp_Object);
5662 static void compute_tip_xy (struct frame *, Lisp_Object, Lisp_Object,
5663 Lisp_Object, int, int, int *, int *);
5664
5665 /* The frame of a currently visible tooltip. */
5666
5667 Lisp_Object tip_frame;
5668
5669 /* If non-nil, a timer started that hides the last tooltip when it
5670 fires. */
5671
5672 Lisp_Object tip_timer;
5673 Window tip_window;
5674
5675 /* If non-nil, a vector of 3 elements containing the last args
5676 with which x-show-tip was called. See there. */
5677
5678 Lisp_Object last_show_tip_args;
5679
5680
5681 static void
5682 unwind_create_tip_frame (Lisp_Object frame)
5683 {
5684 Lisp_Object deleted;
5685
5686 deleted = unwind_create_frame (frame);
5687 if (EQ (deleted, Qt))
5688 {
5689 tip_window = NULL;
5690 tip_frame = Qnil;
5691 }
5692 }
5693
5694
5695 /* Create a frame for a tooltip on the display described by DPYINFO.
5696 PARMS is a list of frame parameters. TEXT is the string to
5697 display in the tip frame. Value is the frame.
5698
5699 Note that functions called here, esp. x_default_parameter can
5700 signal errors, for instance when a specified color name is
5701 undefined. We have to make sure that we're in a consistent state
5702 when this happens. */
5703
5704 static Lisp_Object
5705 x_create_tip_frame (struct w32_display_info *dpyinfo,
5706 Lisp_Object parms, Lisp_Object text)
5707 {
5708 struct frame *f;
5709 Lisp_Object frame;
5710 Lisp_Object name;
5711 long window_prompting = 0;
5712 int width, height;
5713 ptrdiff_t count = SPECPDL_INDEX ();
5714 struct gcpro gcpro1, gcpro2, gcpro3;
5715 struct kboard *kb;
5716 bool face_change_before = face_change;
5717 Lisp_Object buffer;
5718 struct buffer *old_buffer;
5719
5720 /* Use this general default value to start with until we know if
5721 this frame has a specified name. */
5722 Vx_resource_name = Vinvocation_name;
5723
5724 kb = dpyinfo->terminal->kboard;
5725
5726 /* The calls to x_get_arg remove elements from PARMS, so copy it to
5727 avoid destructive changes behind our caller's back. */
5728 parms = Fcopy_alist (parms);
5729
5730 /* Get the name of the frame to use for resource lookup. */
5731 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
5732 if (!STRINGP (name)
5733 && !EQ (name, Qunbound)
5734 && !NILP (name))
5735 error ("Invalid frame name--not a string or nil");
5736 Vx_resource_name = name;
5737
5738 frame = Qnil;
5739 GCPRO3 (parms, name, frame);
5740 /* Make a frame without minibuffer nor mode-line. */
5741 f = make_frame (false);
5742 f->wants_modeline = 0;
5743 XSETFRAME (frame, f);
5744
5745 AUTO_STRING (tip, " *tip*");
5746 buffer = Fget_buffer_create (tip);
5747 /* Use set_window_buffer instead of Fset_window_buffer (see
5748 discussion of bug#11984, bug#12025, bug#12026). */
5749 set_window_buffer (FRAME_ROOT_WINDOW (f), buffer, false, false);
5750 old_buffer = current_buffer;
5751 set_buffer_internal_1 (XBUFFER (buffer));
5752 bset_truncate_lines (current_buffer, Qnil);
5753 specbind (Qinhibit_read_only, Qt);
5754 specbind (Qinhibit_modification_hooks, Qt);
5755 Ferase_buffer ();
5756 Finsert (1, &text);
5757 set_buffer_internal_1 (old_buffer);
5758
5759 record_unwind_protect (unwind_create_tip_frame, frame);
5760
5761 /* By setting the output method, we're essentially saying that
5762 the frame is live, as per FRAME_LIVE_P. If we get a signal
5763 from this point on, x_destroy_window might screw up reference
5764 counts etc. */
5765 f->terminal = dpyinfo->terminal;
5766 f->output_method = output_w32;
5767 f->output_data.w32 = xzalloc (sizeof (struct w32_output));
5768
5769 FRAME_FONTSET (f) = -1;
5770 fset_icon_name (f, Qnil);
5771
5772 #ifdef GLYPH_DEBUG
5773 image_cache_refcount =
5774 FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
5775 dpyinfo_refcount = dpyinfo->reference_count;
5776 #endif /* GLYPH_DEBUG */
5777 FRAME_KBOARD (f) = kb;
5778 f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
5779 f->output_data.w32->explicit_parent = false;
5780
5781 /* Set the name; the functions to which we pass f expect the name to
5782 be set. */
5783 if (EQ (name, Qunbound) || NILP (name))
5784 {
5785 fset_name (f, build_string (dpyinfo->w32_id_name));
5786 f->explicit_name = false;
5787 }
5788 else
5789 {
5790 fset_name (f, name);
5791 f->explicit_name = true;
5792 /* use the frame's title when getting resources for this frame. */
5793 specbind (Qx_resource_name, name);
5794 }
5795
5796 if (uniscribe_available)
5797 register_font_driver (&uniscribe_font_driver, f);
5798 register_font_driver (&w32font_driver, f);
5799
5800 x_default_parameter (f, parms, Qfont_backend, Qnil,
5801 "fontBackend", "FontBackend", RES_TYPE_STRING);
5802
5803 /* Extract the window parameters from the supplied values
5804 that are needed to determine window geometry. */
5805 x_default_font_parameter (f, parms);
5806
5807 x_default_parameter (f, parms, Qborder_width, make_number (2),
5808 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
5809 /* This defaults to 2 in order to match xterm. We recognize either
5810 internalBorderWidth or internalBorder (which is what xterm calls
5811 it). */
5812 if (NILP (Fassq (Qinternal_border_width, parms)))
5813 {
5814 Lisp_Object value;
5815
5816 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
5817 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
5818 if (! EQ (value, Qunbound))
5819 parms = Fcons (Fcons (Qinternal_border_width, value),
5820 parms);
5821 }
5822 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
5823 "internalBorderWidth", "internalBorderWidth",
5824 RES_TYPE_NUMBER);
5825 x_default_parameter (f, parms, Qright_divider_width, make_number (0),
5826 NULL, NULL, RES_TYPE_NUMBER);
5827 x_default_parameter (f, parms, Qbottom_divider_width, make_number (0),
5828 NULL, NULL, RES_TYPE_NUMBER);
5829
5830 /* Also do the stuff which must be set before the window exists. */
5831 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
5832 "foreground", "Foreground", RES_TYPE_STRING);
5833 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
5834 "background", "Background", RES_TYPE_STRING);
5835 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
5836 "pointerColor", "Foreground", RES_TYPE_STRING);
5837 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
5838 "cursorColor", "Foreground", RES_TYPE_STRING);
5839 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
5840 "borderColor", "BorderColor", RES_TYPE_STRING);
5841
5842 /* Init faces before x_default_parameter is called for the
5843 scroll-bar-width parameter because otherwise we end up in
5844 init_iterator with a null face cache, which should not happen. */
5845 init_frame_faces (f);
5846
5847 f->output_data.w32->dwStyle = WS_BORDER | WS_POPUP | WS_DISABLED;
5848 f->output_data.w32->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
5849
5850 window_prompting = x_figure_window_size (f, parms, false);
5851
5852 /* No fringes on tip frame. */
5853 f->fringe_cols = 0;
5854 f->left_fringe_width = 0;
5855 f->right_fringe_width = 0;
5856
5857 block_input ();
5858 my_create_tip_window (f);
5859 unblock_input ();
5860
5861 x_make_gc (f);
5862
5863 x_default_parameter (f, parms, Qauto_raise, Qnil,
5864 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
5865 x_default_parameter (f, parms, Qauto_lower, Qnil,
5866 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
5867 x_default_parameter (f, parms, Qcursor_type, Qbox,
5868 "cursorType", "CursorType", RES_TYPE_SYMBOL);
5869 /* Process alpha here (Bug#17344). */
5870 x_default_parameter (f, parms, Qalpha, Qnil,
5871 "alpha", "Alpha", RES_TYPE_NUMBER);
5872
5873 /* Dimensions, especially FRAME_LINES (f), must be done via
5874 change_frame_size. Change will not be effected unless different
5875 from the current FRAME_LINES (f). */
5876 width = FRAME_COLS (f);
5877 height = FRAME_LINES (f);
5878 SET_FRAME_COLS (f, 0);
5879 SET_FRAME_LINES (f, 0);
5880 adjust_frame_size (f, width * FRAME_COLUMN_WIDTH (f),
5881 height * FRAME_LINE_HEIGHT (f), 0, true, Qtip_frame);
5882
5883 /* Add `tooltip' frame parameter's default value. */
5884 if (NILP (Fframe_parameter (frame, Qtooltip)))
5885 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtooltip, Qt), Qnil));
5886
5887 /* Set up faces after all frame parameters are known. This call
5888 also merges in face attributes specified for new frames.
5889
5890 Frame parameters may be changed if .Xdefaults contains
5891 specifications for the default font. For example, if there is an
5892 `Emacs.default.attributeBackground: pink', the `background-color'
5893 attribute of the frame get's set, which let's the internal border
5894 of the tooltip frame appear in pink. Prevent this. */
5895 {
5896 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
5897 Lisp_Object fg = Fframe_parameter (frame, Qforeground_color);
5898 Lisp_Object colors = Qnil;
5899
5900 /* Set tip_frame here, so that */
5901 tip_frame = frame;
5902 call2 (Qface_set_after_frame_default, frame, Qnil);
5903
5904 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
5905 colors = Fcons (Fcons (Qbackground_color, bg), colors);
5906 if (!EQ (fg, Fframe_parameter (frame, Qforeground_color)))
5907 colors = Fcons (Fcons (Qforeground_color, fg), colors);
5908
5909 if (!NILP (colors))
5910 Fmodify_frame_parameters (frame, colors);
5911 }
5912
5913 f->no_split = true;
5914
5915 UNGCPRO;
5916
5917 /* Now that the frame is official, it counts as a reference to
5918 its display. */
5919 FRAME_DISPLAY_INFO (f)->reference_count++;
5920 f->terminal->reference_count++;
5921
5922 /* It is now ok to make the frame official even if we get an error
5923 below. And the frame needs to be on Vframe_list or making it
5924 visible won't work. */
5925 Vframe_list = Fcons (frame, Vframe_list);
5926 f->can_x_set_window_size = true;
5927
5928 /* Setting attributes of faces of the tooltip frame from resources
5929 and similar will set face_change, which leads to the
5930 clearing of all current matrices. Since this isn't necessary
5931 here, avoid it by resetting face_change to the value it
5932 had before we created the tip frame. */
5933 face_change = face_change_before;
5934
5935 /* Discard the unwind_protect. */
5936 return unbind_to (count, frame);
5937 }
5938
5939
5940 /* Compute where to display tip frame F. PARMS is the list of frame
5941 parameters for F. DX and DY are specified offsets from the current
5942 location of the mouse. WIDTH and HEIGHT are the width and height
5943 of the tooltip. Return coordinates relative to the root window of
5944 the display in *ROOT_X and *ROOT_Y. */
5945
5946 static void
5947 compute_tip_xy (struct frame *f,
5948 Lisp_Object parms, Lisp_Object dx, Lisp_Object dy,
5949 int width, int height, int *root_x, int *root_y)
5950 {
5951 Lisp_Object left, top, right, bottom;
5952 int min_x, min_y, max_x, max_y;
5953
5954 /* User-specified position? */
5955 left = Fcdr (Fassq (Qleft, parms));
5956 top = Fcdr (Fassq (Qtop, parms));
5957 right = Fcdr (Fassq (Qright, parms));
5958 bottom = Fcdr (Fassq (Qbottom, parms));
5959
5960 /* Move the tooltip window where the mouse pointer is. Resize and
5961 show it. */
5962 if ((!INTEGERP (left) && !INTEGERP (right))
5963 || (!INTEGERP (top) && !INTEGERP (bottom)))
5964 {
5965 POINT pt;
5966
5967 /* Default min and max values. */
5968 min_x = 0;
5969 min_y = 0;
5970 max_x = x_display_pixel_width (FRAME_DISPLAY_INFO (f));
5971 max_y = x_display_pixel_height (FRAME_DISPLAY_INFO (f));
5972
5973 block_input ();
5974 GetCursorPos (&pt);
5975 *root_x = pt.x;
5976 *root_y = pt.y;
5977 unblock_input ();
5978
5979 /* If multiple monitor support is available, constrain the tip onto
5980 the current monitor. This improves the above by allowing negative
5981 co-ordinates if monitor positions are such that they are valid, and
5982 snaps a tooltip onto a single monitor if we are close to the edge
5983 where it would otherwise flow onto the other monitor (or into
5984 nothingness if there is a gap in the overlap). */
5985 if (monitor_from_point_fn && get_monitor_info_fn)
5986 {
5987 struct MONITOR_INFO info;
5988 HMONITOR monitor
5989 = monitor_from_point_fn (pt, MONITOR_DEFAULT_TO_NEAREST);
5990 info.cbSize = sizeof (info);
5991
5992 if (get_monitor_info_fn (monitor, &info))
5993 {
5994 min_x = info.rcWork.left;
5995 min_y = info.rcWork.top;
5996 max_x = info.rcWork.right;
5997 max_y = info.rcWork.bottom;
5998 }
5999 }
6000 }
6001
6002 if (INTEGERP (top))
6003 *root_y = XINT (top);
6004 else if (INTEGERP (bottom))
6005 *root_y = XINT (bottom) - height;
6006 else if (*root_y + XINT (dy) <= min_y)
6007 *root_y = min_y; /* Can happen for negative dy */
6008 else if (*root_y + XINT (dy) + height <= max_y)
6009 /* It fits below the pointer */
6010 *root_y += XINT (dy);
6011 else if (height + XINT (dy) + min_y <= *root_y)
6012 /* It fits above the pointer. */
6013 *root_y -= height + XINT (dy);
6014 else
6015 /* Put it on the top. */
6016 *root_y = min_y;
6017
6018 if (INTEGERP (left))
6019 *root_x = XINT (left);
6020 else if (INTEGERP (right))
6021 *root_y = XINT (right) - width;
6022 else if (*root_x + XINT (dx) <= min_x)
6023 *root_x = 0; /* Can happen for negative dx */
6024 else if (*root_x + XINT (dx) + width <= max_x)
6025 /* It fits to the right of the pointer. */
6026 *root_x += XINT (dx);
6027 else if (width + XINT (dx) + min_x <= *root_x)
6028 /* It fits to the left of the pointer. */
6029 *root_x -= width + XINT (dx);
6030 else
6031 /* Put it left justified on the screen -- it ought to fit that way. */
6032 *root_x = min_x;
6033 }
6034
6035
6036 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
6037 doc: /* Show STRING in a \"tooltip\" window on frame FRAME.
6038 A tooltip window is a small window displaying a string.
6039
6040 This is an internal function; Lisp code should call `tooltip-show'.
6041
6042 FRAME nil or omitted means use the selected frame.
6043
6044 PARMS is an optional list of frame parameters which can be
6045 used to change the tooltip's appearance.
6046
6047 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
6048 means use the default timeout of 5 seconds.
6049
6050 If the list of frame parameters PARMS contains a `left' parameter,
6051 display the tooltip at that x-position. If the list of frame parameters
6052 PARMS contains no `left' but a `right' parameter, display the tooltip
6053 right-adjusted at that x-position. Otherwise display it at the
6054 x-position of the mouse, with offset DX added (default is 5 if DX isn't
6055 specified).
6056
6057 Likewise for the y-position: If a `top' frame parameter is specified, it
6058 determines the position of the upper edge of the tooltip window. If a
6059 `bottom' parameter but no `top' frame parameter is specified, it
6060 determines the position of the lower edge of the tooltip window.
6061 Otherwise display the tooltip window at the y-position of the mouse,
6062 with offset DY added (default is -10).
6063
6064 A tooltip's maximum size is specified by `x-max-tooltip-size'.
6065 Text larger than the specified size is clipped. */)
6066 (Lisp_Object string, Lisp_Object frame, Lisp_Object parms, Lisp_Object timeout, Lisp_Object dx, Lisp_Object dy)
6067 {
6068 struct frame *f;
6069 struct window *w;
6070 int root_x, root_y;
6071 struct buffer *old_buffer;
6072 struct text_pos pos;
6073 int i, width, height;
6074 bool seen_reversed_p;
6075 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
6076 int old_windows_or_buffers_changed = windows_or_buffers_changed;
6077 ptrdiff_t count = SPECPDL_INDEX ();
6078
6079 specbind (Qinhibit_redisplay, Qt);
6080
6081 GCPRO4 (string, parms, frame, timeout);
6082
6083 CHECK_STRING (string);
6084 f = decode_window_system_frame (frame);
6085 if (NILP (timeout))
6086 timeout = make_number (5);
6087 else
6088 CHECK_NATNUM (timeout);
6089
6090 if (NILP (dx))
6091 dx = make_number (5);
6092 else
6093 CHECK_NUMBER (dx);
6094
6095 if (NILP (dy))
6096 dy = make_number (-10);
6097 else
6098 CHECK_NUMBER (dy);
6099
6100 if (NILP (last_show_tip_args))
6101 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
6102
6103 if (!NILP (tip_frame))
6104 {
6105 Lisp_Object last_string = AREF (last_show_tip_args, 0);
6106 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
6107 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
6108
6109 if (EQ (frame, last_frame)
6110 && !NILP (Fequal (last_string, string))
6111 && !NILP (Fequal (last_parms, parms)))
6112 {
6113 struct frame *f = XFRAME (tip_frame);
6114
6115 /* Only DX and DY have changed. */
6116 if (!NILP (tip_timer))
6117 {
6118 Lisp_Object timer = tip_timer;
6119 tip_timer = Qnil;
6120 call1 (Qcancel_timer, timer);
6121 }
6122
6123 block_input ();
6124 compute_tip_xy (f, parms, dx, dy, FRAME_PIXEL_WIDTH (f),
6125 FRAME_PIXEL_HEIGHT (f), &root_x, &root_y);
6126
6127 /* Put tooltip in topmost group and in position. */
6128 SetWindowPos (FRAME_W32_WINDOW (f), HWND_TOPMOST,
6129 root_x, root_y, 0, 0,
6130 SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
6131
6132 /* Ensure tooltip is on top of other topmost windows (eg menus). */
6133 SetWindowPos (FRAME_W32_WINDOW (f), HWND_TOP,
6134 0, 0, 0, 0,
6135 SWP_NOMOVE | SWP_NOSIZE
6136 | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
6137
6138 unblock_input ();
6139 goto start_timer;
6140 }
6141 }
6142
6143 /* Hide a previous tip, if any. */
6144 Fx_hide_tip ();
6145
6146 ASET (last_show_tip_args, 0, string);
6147 ASET (last_show_tip_args, 1, frame);
6148 ASET (last_show_tip_args, 2, parms);
6149
6150 /* Add default values to frame parameters. */
6151 if (NILP (Fassq (Qname, parms)))
6152 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
6153 if (NILP (Fassq (Qinternal_border_width, parms)))
6154 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
6155 if (NILP (Fassq (Qright_divider_width, parms)))
6156 parms = Fcons (Fcons (Qright_divider_width, make_number (0)), parms);
6157 if (NILP (Fassq (Qbottom_divider_width, parms)))
6158 parms = Fcons (Fcons (Qbottom_divider_width, make_number (0)), parms);
6159 if (NILP (Fassq (Qborder_width, parms)))
6160 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
6161 if (NILP (Fassq (Qborder_color, parms)))
6162 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
6163 if (NILP (Fassq (Qbackground_color, parms)))
6164 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
6165 parms);
6166
6167 /* Block input until the tip has been fully drawn, to avoid crashes
6168 when drawing tips in menus. */
6169 block_input ();
6170
6171 /* Create a frame for the tooltip, and record it in the global
6172 variable tip_frame. */
6173 frame = x_create_tip_frame (FRAME_DISPLAY_INFO (f), parms, string);
6174 f = XFRAME (frame);
6175
6176 /* Set up the frame's root window. */
6177 w = XWINDOW (FRAME_ROOT_WINDOW (f));
6178 w->left_col = 0;
6179 w->top_line = 0;
6180 w->pixel_left = 0;
6181 w->pixel_top = 0;
6182
6183 if (CONSP (Vx_max_tooltip_size)
6184 && INTEGERP (XCAR (Vx_max_tooltip_size))
6185 && XINT (XCAR (Vx_max_tooltip_size)) > 0
6186 && INTEGERP (XCDR (Vx_max_tooltip_size))
6187 && XINT (XCDR (Vx_max_tooltip_size)) > 0)
6188 {
6189 w->total_cols = XFASTINT (XCAR (Vx_max_tooltip_size));
6190 w->total_lines = XFASTINT (XCDR (Vx_max_tooltip_size));
6191 }
6192 else
6193 {
6194 w->total_cols = 80;
6195 w->total_lines = 40;
6196 }
6197
6198 w->pixel_width = w->total_cols * FRAME_COLUMN_WIDTH (f);
6199 w->pixel_height = w->total_lines * FRAME_LINE_HEIGHT (f);
6200
6201 FRAME_TOTAL_COLS (f) = WINDOW_TOTAL_COLS (w);
6202 adjust_frame_glyphs (f);
6203 w->pseudo_window_p = true;
6204
6205 /* Display the tooltip text in a temporary buffer. */
6206 old_buffer = current_buffer;
6207 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->contents));
6208 bset_truncate_lines (current_buffer, Qnil);
6209 clear_glyph_matrix (w->desired_matrix);
6210 clear_glyph_matrix (w->current_matrix);
6211 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
6212 try_window (FRAME_ROOT_WINDOW (f), pos, TRY_WINDOW_IGNORE_FONTS_CHANGE);
6213
6214 /* Compute width and height of the tooltip. */
6215 width = height = 0;
6216 seen_reversed_p = false;
6217 for (i = 0; i < w->desired_matrix->nrows; ++i)
6218 {
6219 struct glyph_row *row = &w->desired_matrix->rows[i];
6220 struct glyph *last;
6221 int row_width;
6222
6223 /* Stop at the first empty row at the end. */
6224 if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
6225 break;
6226
6227 /* Let the row go over the full width of the frame. */
6228 row->full_width_p = true;
6229
6230 row_width = row->pixel_width;
6231 if (row->used[TEXT_AREA])
6232 {
6233 if (!row->reversed_p)
6234 {
6235 /* There's a glyph at the end of rows that is used to
6236 place the cursor there. Don't include the width of
6237 this glyph. */
6238 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
6239 if (NILP (last->object))
6240 row_width -= last->pixel_width;
6241 }
6242 else
6243 {
6244 /* There could be a stretch glyph at the beginning of R2L
6245 rows that is produced by extend_face_to_end_of_line.
6246 Don't count that glyph. */
6247 struct glyph *g = row->glyphs[TEXT_AREA];
6248
6249 if (g->type == STRETCH_GLYPH && NILP (g->object))
6250 {
6251 row_width -= g->pixel_width;
6252 seen_reversed_p = true;
6253 }
6254 }
6255 }
6256
6257 height += row->height;
6258 width = max (width, row_width);
6259 }
6260
6261 /* If we've seen partial-length R2L rows, we need to re-adjust the
6262 tool-tip frame width and redisplay it again, to avoid over-wide
6263 tips due to the stretch glyph that extends R2L lines to full
6264 width of the frame. */
6265 if (seen_reversed_p)
6266 {
6267 /* PXW: Why do we do the pixel-to-cols conversion only if
6268 seen_reversed_p holds? Don't we have to set other fields of
6269 the window/frame structure?
6270
6271 w->total_cols and FRAME_TOTAL_COLS want the width in columns,
6272 not in pixels. */
6273 w->pixel_width = width;
6274 width /= WINDOW_FRAME_COLUMN_WIDTH (w);
6275 w->total_cols = width;
6276 FRAME_TOTAL_COLS (f) = width;
6277 SET_FRAME_WIDTH (f, width);
6278 adjust_frame_glyphs (f);
6279 w->pseudo_window_p = 1;
6280 clear_glyph_matrix (w->desired_matrix);
6281 clear_glyph_matrix (w->current_matrix);
6282 try_window (FRAME_ROOT_WINDOW (f), pos, TRY_WINDOW_IGNORE_FONTS_CHANGE);
6283 width = height = 0;
6284 /* Recompute width and height of the tooltip. */
6285 for (i = 0; i < w->desired_matrix->nrows; ++i)
6286 {
6287 struct glyph_row *row = &w->desired_matrix->rows[i];
6288 struct glyph *last;
6289 int row_width;
6290
6291 if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
6292 break;
6293 row->full_width_p = true;
6294 row_width = row->pixel_width;
6295 if (row->used[TEXT_AREA] && !row->reversed_p)
6296 {
6297 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
6298 if (NILP (last->object))
6299 row_width -= last->pixel_width;
6300 }
6301
6302 height += row->height;
6303 width = max (width, row_width);
6304 }
6305 }
6306
6307 /* Add the frame's internal border to the width and height the w32
6308 window should have. */
6309 height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
6310 width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
6311
6312 /* Move the tooltip window where the mouse pointer is. Resize and
6313 show it.
6314
6315 PXW: This should use the frame's pixel coordinates. */
6316 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
6317
6318 {
6319 /* Adjust Window size to take border into account. */
6320 RECT rect;
6321 rect.left = rect.top = 0;
6322 rect.right = width;
6323 rect.bottom = height;
6324 AdjustWindowRect (&rect, f->output_data.w32->dwStyle,
6325 FRAME_EXTERNAL_MENU_BAR (f));
6326
6327 /* Position and size tooltip, and put it in the topmost group.
6328 The add-on of FRAME_COLUMN_WIDTH to the 5th argument is a
6329 peculiarity of w32 display: without it, some fonts cause the
6330 last character of the tip to be truncated or wrapped around to
6331 the next line. */
6332 SetWindowPos (FRAME_W32_WINDOW (f), HWND_TOPMOST,
6333 root_x, root_y,
6334 rect.right - rect.left + FRAME_COLUMN_WIDTH (f),
6335 rect.bottom - rect.top, SWP_NOACTIVATE | SWP_NOOWNERZORDER);
6336
6337 /* Ensure tooltip is on top of other topmost windows (eg menus). */
6338 SetWindowPos (FRAME_W32_WINDOW (f), HWND_TOP,
6339 0, 0, 0, 0,
6340 SWP_NOMOVE | SWP_NOSIZE
6341 | SWP_NOACTIVATE | SWP_NOOWNERZORDER);
6342
6343 /* Let redisplay know that we have made the frame visible already. */
6344 SET_FRAME_VISIBLE (f, 1);
6345
6346 ShowWindow (FRAME_W32_WINDOW (f), SW_SHOWNOACTIVATE);
6347 }
6348
6349 /* Draw into the window. */
6350 w->must_be_updated_p = true;
6351 update_single_window (w);
6352
6353 unblock_input ();
6354
6355 /* Restore original current buffer. */
6356 set_buffer_internal_1 (old_buffer);
6357 windows_or_buffers_changed = old_windows_or_buffers_changed;
6358
6359 start_timer:
6360 /* Let the tip disappear after timeout seconds. */
6361 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
6362 intern ("x-hide-tip"));
6363
6364 UNGCPRO;
6365 return unbind_to (count, Qnil);
6366 }
6367
6368
6369 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
6370 doc: /* Hide the current tooltip window, if there is any.
6371 Value is t if tooltip was open, nil otherwise. */)
6372 (void)
6373 {
6374 ptrdiff_t count;
6375 Lisp_Object deleted, frame, timer;
6376 struct gcpro gcpro1, gcpro2;
6377
6378 /* Return quickly if nothing to do. */
6379 if (NILP (tip_timer) && NILP (tip_frame))
6380 return Qnil;
6381
6382 frame = tip_frame;
6383 timer = tip_timer;
6384 GCPRO2 (frame, timer);
6385 tip_frame = tip_timer = deleted = Qnil;
6386
6387 count = SPECPDL_INDEX ();
6388 specbind (Qinhibit_redisplay, Qt);
6389 specbind (Qinhibit_quit, Qt);
6390
6391 if (!NILP (timer))
6392 call1 (Qcancel_timer, timer);
6393
6394 if (FRAMEP (frame))
6395 {
6396 delete_frame (frame, Qnil);
6397 deleted = Qt;
6398 }
6399
6400 UNGCPRO;
6401 return unbind_to (count, deleted);
6402 }
6403 \f
6404 /***********************************************************************
6405 File selection dialog
6406 ***********************************************************************/
6407
6408 #define FILE_NAME_TEXT_FIELD edt1
6409 #define FILE_NAME_COMBO_BOX cmb13
6410 #define FILE_NAME_LIST lst1
6411
6412 /* Callback for altering the behavior of the Open File dialog.
6413 Makes the Filename text field contain "Current Directory" and be
6414 read-only when "Directories" is selected in the filter. This
6415 allows us to work around the fact that the standard Open File
6416 dialog does not support directories. */
6417 static UINT_PTR CALLBACK
6418 file_dialog_callback (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
6419 {
6420 if (msg == WM_NOTIFY)
6421 {
6422 OFNOTIFYW * notify_w = (OFNOTIFYW *)lParam;
6423 OFNOTIFYA * notify_a = (OFNOTIFYA *)lParam;
6424 int dropdown_changed;
6425 int dir_index;
6426 #ifdef NTGUI_UNICODE
6427 const int use_unicode = 1;
6428 #else /* !NTGUI_UNICODE */
6429 int use_unicode = w32_unicode_filenames;
6430 #endif /* NTGUI_UNICODE */
6431
6432 /* Detect when the Filter dropdown is changed. */
6433 if (use_unicode)
6434 dropdown_changed =
6435 notify_w->hdr.code == CDN_TYPECHANGE
6436 || notify_w->hdr.code == CDN_INITDONE;
6437 else
6438 dropdown_changed =
6439 notify_a->hdr.code == CDN_TYPECHANGE
6440 || notify_a->hdr.code == CDN_INITDONE;
6441 if (dropdown_changed)
6442 {
6443 HWND dialog = GetParent (hwnd);
6444 HWND edit_control = GetDlgItem (dialog, FILE_NAME_TEXT_FIELD);
6445 HWND list = GetDlgItem (dialog, FILE_NAME_LIST);
6446 int hdr_code;
6447
6448 /* At least on Windows 7, the above attempt to get the window handle
6449 to the File Name Text Field fails. The following code does the
6450 job though. Note that this code is based on my examination of the
6451 window hierarchy using Microsoft Spy++. bk */
6452 if (edit_control == NULL)
6453 {
6454 HWND tmp = GetDlgItem (dialog, FILE_NAME_COMBO_BOX);
6455 if (tmp)
6456 {
6457 tmp = GetWindow (tmp, GW_CHILD);
6458 if (tmp)
6459 edit_control = GetWindow (tmp, GW_CHILD);
6460 }
6461 }
6462
6463 /* Directories is in index 2. */
6464 if (use_unicode)
6465 {
6466 dir_index = notify_w->lpOFN->nFilterIndex;
6467 hdr_code = notify_w->hdr.code;
6468 }
6469 else
6470 {
6471 dir_index = notify_a->lpOFN->nFilterIndex;
6472 hdr_code = notify_a->hdr.code;
6473 }
6474 if (dir_index == 2)
6475 {
6476 if (use_unicode)
6477 SendMessageW (dialog, CDM_SETCONTROLTEXT, FILE_NAME_TEXT_FIELD,
6478 (LPARAM)L"Current Directory");
6479 else
6480 SendMessageA (dialog, CDM_SETCONTROLTEXT, FILE_NAME_TEXT_FIELD,
6481 (LPARAM)"Current Directory");
6482 EnableWindow (edit_control, FALSE);
6483 /* Note that at least on Windows 7, the above call to EnableWindow
6484 disables the window that would ordinarily have focus. If we
6485 do not set focus to some other window here, focus will land in
6486 no man's land and the user will be unable to tab through the
6487 dialog box (pressing tab will only result in a beep).
6488 Avoid that problem by setting focus to the list here. */
6489 if (hdr_code == CDN_INITDONE)
6490 SetFocus (list);
6491 }
6492 else
6493 {
6494 /* Don't override default filename on init done. */
6495 if (hdr_code == CDN_TYPECHANGE)
6496 {
6497 if (use_unicode)
6498 SendMessageW (dialog, CDM_SETCONTROLTEXT,
6499 FILE_NAME_TEXT_FIELD, (LPARAM)L"");
6500 else
6501 SendMessageA (dialog, CDM_SETCONTROLTEXT,
6502 FILE_NAME_TEXT_FIELD, (LPARAM)"");
6503 }
6504 EnableWindow (edit_control, TRUE);
6505 }
6506 }
6507 }
6508 return 0;
6509 }
6510
6511 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
6512 doc: /* Read file name, prompting with PROMPT in directory DIR.
6513 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
6514 selection box, if specified. If MUSTMATCH is non-nil, the returned file
6515 or directory must exist.
6516
6517 This function is only defined on NS, MS Windows, and X Windows with the
6518 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
6519 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories.
6520 On Windows 7 and later, the file selection dialog "remembers" the last
6521 directory where the user selected a file, and will open that directory
6522 instead of DIR on subsequent invocations of this function with the same
6523 value of DIR as in previous invocations; this is standard Windows behavior. */)
6524 (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object only_dir_p)
6525 {
6526 /* Filter index: 1: All Files, 2: Directories only */
6527 static const wchar_t filter_w[] = L"All Files (*.*)\0*.*\0Directories\0*|*\0";
6528 static const char filter_a[] = "All Files (*.*)\0*.*\0Directories\0*|*\0";
6529
6530 Lisp_Object filename = default_filename;
6531 struct frame *f = SELECTED_FRAME ();
6532 BOOL file_opened = FALSE;
6533 Lisp_Object orig_dir = dir;
6534 Lisp_Object orig_prompt = prompt;
6535
6536 /* If we compile with _WIN32_WINNT set to 0x0400 (for NT4
6537 compatibility) we end up with the old file dialogs. Define a big
6538 enough struct for the new dialog to trick GetOpenFileName into
6539 giving us the new dialogs on newer versions of Windows. */
6540 struct {
6541 OPENFILENAMEW details;
6542 #if _WIN32_WINNT < 0x500 /* < win2k */
6543 PVOID pvReserved;
6544 DWORD dwReserved;
6545 DWORD FlagsEx;
6546 #endif /* < win2k */
6547 } new_file_details_w;
6548
6549 #ifdef NTGUI_UNICODE
6550 wchar_t filename_buf_w[32*1024 + 1]; // NT kernel maximum
6551 OPENFILENAMEW * file_details_w = &new_file_details_w.details;
6552 const int use_unicode = 1;
6553 #else /* not NTGUI_UNICODE */
6554 struct {
6555 OPENFILENAMEA details;
6556 #if _WIN32_WINNT < 0x500 /* < win2k */
6557 PVOID pvReserved;
6558 DWORD dwReserved;
6559 DWORD FlagsEx;
6560 #endif /* < win2k */
6561 } new_file_details_a;
6562 wchar_t filename_buf_w[MAX_PATH + 1], dir_w[MAX_PATH];
6563 char filename_buf_a[MAX_PATH + 1], dir_a[MAX_PATH];
6564 OPENFILENAMEW * file_details_w = &new_file_details_w.details;
6565 OPENFILENAMEA * file_details_a = &new_file_details_a.details;
6566 int use_unicode = w32_unicode_filenames;
6567 wchar_t *prompt_w;
6568 char *prompt_a;
6569 int len;
6570 char fname_ret[MAX_UTF8_PATH];
6571 #endif /* NTGUI_UNICODE */
6572
6573 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
6574 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, filename);
6575
6576 {
6577 struct gcpro gcpro1, gcpro2;
6578 GCPRO2 (orig_dir, orig_prompt); /* There is no GCPRON, N>6. */
6579
6580 /* Note: under NTGUI_UNICODE, we do _NOT_ use ENCODE_FILE: the
6581 system file encoding expected by the platform APIs (e.g. Cygwin's
6582 POSIX implementation) may not be the same as the encoding expected
6583 by the Windows "ANSI" APIs! */
6584
6585 CHECK_STRING (prompt);
6586 CHECK_STRING (dir);
6587
6588 dir = Fexpand_file_name (dir, Qnil);
6589
6590 if (STRINGP (filename))
6591 filename = Ffile_name_nondirectory (filename);
6592 else
6593 filename = empty_unibyte_string;
6594
6595 #ifdef CYGWIN
6596 dir = Fcygwin_convert_file_name_to_windows (dir, Qt);
6597 if (SCHARS (filename) > 0)
6598 filename = Fcygwin_convert_file_name_to_windows (filename, Qnil);
6599 #endif
6600
6601 CHECK_STRING (dir);
6602 CHECK_STRING (filename);
6603
6604 /* The code in file_dialog_callback that attempts to set the text
6605 of the file name edit window when handling the CDN_INITDONE
6606 WM_NOTIFY message does not work. Setting filename to "Current
6607 Directory" in the only_dir_p case here does work however. */
6608 if (SCHARS (filename) == 0 && ! NILP (only_dir_p))
6609 filename = build_string ("Current Directory");
6610
6611 /* Convert the values we've computed so far to system form. */
6612 #ifdef NTGUI_UNICODE
6613 to_unicode (prompt, &prompt);
6614 to_unicode (dir, &dir);
6615 to_unicode (filename, &filename);
6616 if (SBYTES (filename) + 1 > sizeof (filename_buf_w))
6617 report_file_error ("filename too long", default_filename);
6618
6619 memcpy (filename_buf_w, SDATA (filename), SBYTES (filename) + 1);
6620 #else /* !NTGUI_UNICODE */
6621 prompt = ENCODE_FILE (prompt);
6622 dir = ENCODE_FILE (dir);
6623 filename = ENCODE_FILE (filename);
6624
6625 /* We modify these in-place, so make copies for safety. */
6626 dir = Fcopy_sequence (dir);
6627 unixtodos_filename (SDATA (dir));
6628 filename = Fcopy_sequence (filename);
6629 unixtodos_filename (SDATA (filename));
6630 if (SBYTES (filename) >= MAX_UTF8_PATH)
6631 report_file_error ("filename too long", default_filename);
6632 if (w32_unicode_filenames)
6633 {
6634 filename_to_utf16 (SSDATA (dir), dir_w);
6635 if (filename_to_utf16 (SSDATA (filename), filename_buf_w) != 0)
6636 {
6637 /* filename_to_utf16 sets errno to ENOENT when the file
6638 name is too long or cannot be converted to UTF-16. */
6639 if (errno == ENOENT && filename_buf_w[MAX_PATH - 1] != 0)
6640 report_file_error ("filename too long", default_filename);
6641 }
6642 len = pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS,
6643 SSDATA (prompt), -1, NULL, 0);
6644 if (len > 32768)
6645 len = 32768;
6646 prompt_w = alloca (len * sizeof (wchar_t));
6647 pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS,
6648 SSDATA (prompt), -1, prompt_w, len);
6649 }
6650 else
6651 {
6652 filename_to_ansi (SSDATA (dir), dir_a);
6653 if (filename_to_ansi (SSDATA (filename), filename_buf_a) != '\0')
6654 {
6655 /* filename_to_ansi sets errno to ENOENT when the file
6656 name is too long or cannot be converted to UTF-16. */
6657 if (errno == ENOENT && filename_buf_a[MAX_PATH - 1] != 0)
6658 report_file_error ("filename too long", default_filename);
6659 }
6660 len = pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS,
6661 SSDATA (prompt), -1, NULL, 0);
6662 if (len > 32768)
6663 len = 32768;
6664 prompt_w = alloca (len * sizeof (wchar_t));
6665 pMultiByteToWideChar (CP_UTF8, MB_ERR_INVALID_CHARS,
6666 SSDATA (prompt), -1, prompt_w, len);
6667 len = pWideCharToMultiByte (CP_ACP, 0, prompt_w, -1, NULL, 0, NULL, NULL);
6668 if (len > 32768)
6669 len = 32768;
6670 prompt_a = alloca (len);
6671 pWideCharToMultiByte (CP_ACP, 0, prompt_w, -1, prompt_a, len, NULL, NULL);
6672 }
6673 #endif /* NTGUI_UNICODE */
6674
6675 /* Fill in the structure for the call to GetOpenFileName below.
6676 For NTGUI_UNICODE builds (which run only on NT), we just use
6677 the actual size of the structure. For non-NTGUI_UNICODE
6678 builds, we tell the OS we're using an old version of the
6679 structure if the OS isn't new enough to support the newer
6680 version. */
6681 if (use_unicode)
6682 {
6683 memset (&new_file_details_w, 0, sizeof (new_file_details_w));
6684 if (w32_major_version > 4 && w32_major_version < 95)
6685 file_details_w->lStructSize = sizeof (new_file_details_w);
6686 else
6687 file_details_w->lStructSize = sizeof (*file_details_w);
6688 /* Set up the inout parameter for the selected file name. */
6689 file_details_w->lpstrFile = filename_buf_w;
6690 file_details_w->nMaxFile =
6691 sizeof (filename_buf_w) / sizeof (*filename_buf_w);
6692 file_details_w->hwndOwner = FRAME_W32_WINDOW (f);
6693 /* Undocumented Bug in Common File Dialog:
6694 If a filter is not specified, shell links are not resolved. */
6695 file_details_w->lpstrFilter = filter_w;
6696 #ifdef NTGUI_UNICODE
6697 file_details_w->lpstrInitialDir = (wchar_t*) SDATA (dir);
6698 file_details_w->lpstrTitle = (guichar_t*) SDATA (prompt);
6699 #else
6700 file_details_w->lpstrInitialDir = dir_w;
6701 file_details_w->lpstrTitle = prompt_w;
6702 #endif
6703 file_details_w->nFilterIndex = NILP (only_dir_p) ? 1 : 2;
6704 file_details_w->Flags = (OFN_HIDEREADONLY | OFN_NOCHANGEDIR
6705 | OFN_EXPLORER | OFN_ENABLEHOOK);
6706 if (!NILP (mustmatch))
6707 {
6708 /* Require that the path to the parent directory exists. */
6709 file_details_w->Flags |= OFN_PATHMUSTEXIST;
6710 /* If we are looking for a file, require that it exists. */
6711 if (NILP (only_dir_p))
6712 file_details_w->Flags |= OFN_FILEMUSTEXIST;
6713 }
6714 }
6715 #ifndef NTGUI_UNICODE
6716 else
6717 {
6718 memset (&new_file_details_a, 0, sizeof (new_file_details_a));
6719 if (w32_major_version > 4 && w32_major_version < 95)
6720 file_details_a->lStructSize = sizeof (new_file_details_a);
6721 else
6722 file_details_a->lStructSize = sizeof (*file_details_a);
6723 file_details_a->lpstrFile = filename_buf_a;
6724 file_details_a->nMaxFile =
6725 sizeof (filename_buf_a) / sizeof (*filename_buf_a);
6726 file_details_a->hwndOwner = FRAME_W32_WINDOW (f);
6727 file_details_a->lpstrFilter = filter_a;
6728 file_details_a->lpstrInitialDir = dir_a;
6729 file_details_a->lpstrTitle = prompt_a;
6730 file_details_a->nFilterIndex = NILP (only_dir_p) ? 1 : 2;
6731 file_details_a->Flags = (OFN_HIDEREADONLY | OFN_NOCHANGEDIR
6732 | OFN_EXPLORER | OFN_ENABLEHOOK);
6733 if (!NILP (mustmatch))
6734 {
6735 /* Require that the path to the parent directory exists. */
6736 file_details_a->Flags |= OFN_PATHMUSTEXIST;
6737 /* If we are looking for a file, require that it exists. */
6738 if (NILP (only_dir_p))
6739 file_details_a->Flags |= OFN_FILEMUSTEXIST;
6740 }
6741 }
6742 #endif /* !NTGUI_UNICODE */
6743
6744 {
6745 int count = SPECPDL_INDEX ();
6746 /* Prevent redisplay. */
6747 specbind (Qinhibit_redisplay, Qt);
6748 block_input ();
6749 if (use_unicode)
6750 {
6751 file_details_w->lpfnHook = file_dialog_callback;
6752
6753 file_opened = GetOpenFileNameW (file_details_w);
6754 }
6755 #ifndef NTGUI_UNICODE
6756 else
6757 {
6758 file_details_a->lpfnHook = file_dialog_callback;
6759
6760 file_opened = GetOpenFileNameA (file_details_a);
6761 }
6762 #endif /* !NTGUI_UNICODE */
6763 unblock_input ();
6764 unbind_to (count, Qnil);
6765 }
6766
6767 if (file_opened)
6768 {
6769 /* Get an Emacs string from the value Windows gave us. */
6770 #ifdef NTGUI_UNICODE
6771 filename = from_unicode_buffer (filename_buf_w);
6772 #else /* !NTGUI_UNICODE */
6773 if (use_unicode)
6774 filename_from_utf16 (filename_buf_w, fname_ret);
6775 else
6776 filename_from_ansi (filename_buf_a, fname_ret);
6777 dostounix_filename (fname_ret);
6778 filename = DECODE_FILE (build_unibyte_string (fname_ret));
6779 #endif /* NTGUI_UNICODE */
6780
6781 #ifdef CYGWIN
6782 filename = Fcygwin_convert_file_name_from_windows (filename, Qt);
6783 #endif /* CYGWIN */
6784
6785 /* Strip the dummy filename off the end of the string if we
6786 added it to select a directory. */
6787 if ((use_unicode && file_details_w->nFilterIndex == 2)
6788 #ifndef NTGUI_UNICODE
6789 || (!use_unicode && file_details_a->nFilterIndex == 2)
6790 #endif
6791 )
6792 filename = Ffile_name_directory (filename);
6793 }
6794 /* User canceled the dialog without making a selection. */
6795 else if (!CommDlgExtendedError ())
6796 filename = Qnil;
6797 /* An error occurred, fallback on reading from the mini-buffer. */
6798 else
6799 filename = Fcompleting_read (
6800 orig_prompt,
6801 intern ("read-file-name-internal"),
6802 orig_dir,
6803 mustmatch,
6804 orig_dir,
6805 Qfile_name_history,
6806 default_filename,
6807 Qnil);
6808
6809 UNGCPRO;
6810 }
6811
6812 /* Make "Cancel" equivalent to C-g. */
6813 if (NILP (filename))
6814 Fsignal (Qquit, Qnil);
6815
6816 RETURN_UNGCPRO (filename);
6817 }
6818
6819 \f
6820 #ifdef WINDOWSNT
6821 /* Moving files to the system recycle bin.
6822 Used by `move-file-to-trash' instead of the default moving to ~/.Trash */
6823 DEFUN ("system-move-file-to-trash", Fsystem_move_file_to_trash,
6824 Ssystem_move_file_to_trash, 1, 1, 0,
6825 doc: /* Move file or directory named FILENAME to the recycle bin. */)
6826 (Lisp_Object filename)
6827 {
6828 Lisp_Object handler;
6829 Lisp_Object encoded_file;
6830 Lisp_Object operation;
6831
6832 operation = Qdelete_file;
6833 if (!NILP (Ffile_directory_p (filename))
6834 && NILP (Ffile_symlink_p (filename)))
6835 {
6836 operation = intern ("delete-directory");
6837 filename = Fdirectory_file_name (filename);
6838 }
6839
6840 /* Must have fully qualified file names for moving files to Recycle
6841 Bin. */
6842 filename = Fexpand_file_name (filename, Qnil);
6843
6844 handler = Ffind_file_name_handler (filename, operation);
6845 if (!NILP (handler))
6846 return call2 (handler, operation, filename);
6847 else
6848 {
6849 const char * path;
6850 int result;
6851
6852 encoded_file = ENCODE_FILE (filename);
6853
6854 path = map_w32_filename (SDATA (encoded_file), NULL);
6855
6856 /* The Unicode version of SHFileOperation is not supported on
6857 Windows 9X. */
6858 if (w32_unicode_filenames && os_subtype != OS_9X)
6859 {
6860 SHFILEOPSTRUCTW file_op_w;
6861 /* We need one more element beyond MAX_PATH because this is
6862 a list of file names, with the last element double-null
6863 terminated. */
6864 wchar_t tmp_path_w[MAX_PATH + 1];
6865
6866 memset (tmp_path_w, 0, sizeof (tmp_path_w));
6867 filename_to_utf16 (path, tmp_path_w);
6868
6869 /* On Windows, write permission is required to delete/move files. */
6870 _wchmod (tmp_path_w, 0666);
6871
6872 memset (&file_op_w, 0, sizeof (file_op_w));
6873 file_op_w.hwnd = HWND_DESKTOP;
6874 file_op_w.wFunc = FO_DELETE;
6875 file_op_w.pFrom = tmp_path_w;
6876 file_op_w.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_ALLOWUNDO
6877 | FOF_NOERRORUI | FOF_NO_CONNECTED_ELEMENTS;
6878 file_op_w.fAnyOperationsAborted = FALSE;
6879
6880 result = SHFileOperationW (&file_op_w);
6881 }
6882 else
6883 {
6884 SHFILEOPSTRUCTA file_op_a;
6885 char tmp_path_a[MAX_PATH + 1];
6886
6887 memset (tmp_path_a, 0, sizeof (tmp_path_a));
6888 filename_to_ansi (path, tmp_path_a);
6889
6890 /* If a file cannot be represented in ANSI codepage, don't
6891 let them inadvertently delete other files because some
6892 characters are interpreted as a wildcards. */
6893 if (_mbspbrk (tmp_path_a, "?*"))
6894 result = ERROR_FILE_NOT_FOUND;
6895 else
6896 {
6897 _chmod (tmp_path_a, 0666);
6898
6899 memset (&file_op_a, 0, sizeof (file_op_a));
6900 file_op_a.hwnd = HWND_DESKTOP;
6901 file_op_a.wFunc = FO_DELETE;
6902 file_op_a.pFrom = tmp_path_a;
6903 file_op_a.fFlags = FOF_SILENT | FOF_NOCONFIRMATION | FOF_ALLOWUNDO
6904 | FOF_NOERRORUI | FOF_NO_CONNECTED_ELEMENTS;
6905 file_op_a.fAnyOperationsAborted = FALSE;
6906
6907 result = SHFileOperationA (&file_op_a);
6908 }
6909 }
6910 if (result != 0)
6911 report_file_error ("Removing old name", list1 (filename));
6912 }
6913 return Qnil;
6914 }
6915
6916 #endif /* WINDOWSNT */
6917
6918 \f
6919 /***********************************************************************
6920 w32 specialized functions
6921 ***********************************************************************/
6922
6923 DEFUN ("w32-send-sys-command", Fw32_send_sys_command,
6924 Sw32_send_sys_command, 1, 2, 0,
6925 doc: /* Send frame a Windows WM_SYSCOMMAND message of type COMMAND.
6926 Some useful values for COMMAND are #xf030 to maximize frame (#xf020
6927 to minimize), #xf120 to restore frame to original size, and #xf100
6928 to activate the menubar for keyboard access. #xf140 activates the
6929 screen saver if defined.
6930
6931 If optional parameter FRAME is not specified, use selected frame. */)
6932 (Lisp_Object command, Lisp_Object frame)
6933 {
6934 struct frame *f = decode_window_system_frame (frame);
6935
6936 CHECK_NUMBER (command);
6937
6938 if (FRAME_W32_P (f))
6939 PostMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, XINT (command), 0);
6940
6941 return Qnil;
6942 }
6943
6944 DEFUN ("w32-shell-execute", Fw32_shell_execute, Sw32_shell_execute, 2, 4, 0,
6945 doc: /* Get Windows to perform OPERATION on DOCUMENT.
6946 This is a wrapper around the ShellExecute system function, which
6947 invokes the application registered to handle OPERATION for DOCUMENT.
6948
6949 OPERATION is either nil or a string that names a supported operation.
6950 What operations can be used depends on the particular DOCUMENT and its
6951 handler application, but typically it is one of the following common
6952 operations:
6953
6954 \"open\" - open DOCUMENT, which could be a file, a directory, or an
6955 executable program (application). If it is an application,
6956 that application is launched in the current buffer's default
6957 directory. Otherwise, the application associated with
6958 DOCUMENT is launched in the buffer's default directory.
6959 \"opennew\" - like \"open\", but instruct the application to open
6960 DOCUMENT in a new window.
6961 \"openas\" - open the \"Open With\" dialog for DOCUMENT.
6962 \"print\" - print DOCUMENT, which must be a file.
6963 \"printto\" - print DOCUMENT, which must be a file, to a specified printer.
6964 The printer should be provided in PARAMETERS, see below.
6965 \"explore\" - start the Windows Explorer on DOCUMENT.
6966 \"edit\" - launch an editor and open DOCUMENT for editing; which
6967 editor is launched depends on the association for the
6968 specified DOCUMENT.
6969 \"find\" - initiate search starting from DOCUMENT, which must specify
6970 a directory.
6971 \"delete\" - move DOCUMENT, a file or a directory, to Recycle Bin.
6972 \"copy\" - copy DOCUMENT, which must be a file or a directory, into
6973 the clipboard.
6974 \"cut\" - move DOCUMENT, a file or a directory, into the clipboard.
6975 \"paste\" - paste the file whose name is in the clipboard into DOCUMENT,
6976 which must be a directory.
6977 \"pastelink\"
6978 - create a shortcut in DOCUMENT (which must be a directory)
6979 the file or directory whose name is in the clipboard.
6980 \"runas\" - run DOCUMENT, which must be an excutable file, with
6981 elevated privileges (a.k.a. \"as Administrator\").
6982 \"properties\"
6983 - open the property sheet dialog for DOCUMENT.
6984 nil - invoke the default OPERATION, or \"open\" if default is
6985 not defined or unavailable.
6986
6987 DOCUMENT is typically the name of a document file or a URL, but can
6988 also be an executable program to run, or a directory to open in the
6989 Windows Explorer. If it is a file or a directory, it must be a local
6990 one; this function does not support remote file names.
6991
6992 If DOCUMENT is an executable program, the optional third arg PARAMETERS
6993 can be a string containing command line parameters, separated by blanks,
6994 that will be passed to the program. Some values of OPERATION also require
6995 parameters (e.g., \"printto\" requires the printer address). Otherwise,
6996 PARAMETERS should be nil or unspecified. Note that double quote characters
6997 in PARAMETERS must each be enclosed in 2 additional quotes, as in \"\"\".
6998
6999 Optional fourth argument SHOW-FLAG can be used to control how the
7000 application will be displayed when it is invoked. If SHOW-FLAG is nil
7001 or unspecified, the application is displayed as if SHOW-FLAG of 10 was
7002 specified, otherwise it is an integer between 0 and 11 representing
7003 a ShowWindow flag:
7004
7005 0 - start hidden
7006 1 - start as normal-size window
7007 3 - start in a maximized window
7008 6 - start in a minimized window
7009 10 - start as the application itself specifies; this is the default. */)
7010 (Lisp_Object operation, Lisp_Object document, Lisp_Object parameters, Lisp_Object show_flag)
7011 {
7012 char *errstr;
7013 Lisp_Object current_dir = BVAR (current_buffer, directory);;
7014 wchar_t *doc_w = NULL, *params_w = NULL, *ops_w = NULL;
7015 #ifdef CYGWIN
7016 intptr_t result;
7017 #else
7018 int use_unicode = w32_unicode_filenames;
7019 char *doc_a = NULL, *params_a = NULL, *ops_a = NULL;
7020 Lisp_Object absdoc, handler;
7021 BOOL success;
7022 struct gcpro gcpro1;
7023 #endif
7024
7025 CHECK_STRING (document);
7026
7027 #ifdef CYGWIN
7028 current_dir = Fcygwin_convert_file_name_to_windows (current_dir, Qt);
7029 document = Fcygwin_convert_file_name_to_windows (document, Qt);
7030
7031 /* Encode filename, current directory and parameters. */
7032 current_dir = GUI_ENCODE_FILE (current_dir);
7033 document = GUI_ENCODE_FILE (document);
7034 doc_w = GUI_SDATA (document);
7035 if (STRINGP (parameters))
7036 {
7037 parameters = GUI_ENCODE_SYSTEM (parameters);
7038 params_w = GUI_SDATA (parameters);
7039 }
7040 if (STRINGP (operation))
7041 {
7042 operation = GUI_ENCODE_SYSTEM (operation);
7043 ops_w = GUI_SDATA (operation);
7044 }
7045 result = (intptr_t) ShellExecuteW (NULL, ops_w, doc_w, params_w,
7046 GUI_SDATA (current_dir),
7047 (INTEGERP (show_flag)
7048 ? XINT (show_flag) : SW_SHOWDEFAULT));
7049
7050 if (result > 32)
7051 return Qt;
7052
7053 switch (result)
7054 {
7055 case SE_ERR_ACCESSDENIED:
7056 errstr = w32_strerror (ERROR_ACCESS_DENIED);
7057 break;
7058 case SE_ERR_ASSOCINCOMPLETE:
7059 case SE_ERR_NOASSOC:
7060 errstr = w32_strerror (ERROR_NO_ASSOCIATION);
7061 break;
7062 case SE_ERR_DDEBUSY:
7063 case SE_ERR_DDEFAIL:
7064 errstr = w32_strerror (ERROR_DDE_FAIL);
7065 break;
7066 case SE_ERR_DDETIMEOUT:
7067 errstr = w32_strerror (ERROR_TIMEOUT);
7068 break;
7069 case SE_ERR_DLLNOTFOUND:
7070 errstr = w32_strerror (ERROR_DLL_NOT_FOUND);
7071 break;
7072 case SE_ERR_FNF:
7073 errstr = w32_strerror (ERROR_FILE_NOT_FOUND);
7074 break;
7075 case SE_ERR_OOM:
7076 errstr = w32_strerror (ERROR_NOT_ENOUGH_MEMORY);
7077 break;
7078 case SE_ERR_PNF:
7079 errstr = w32_strerror (ERROR_PATH_NOT_FOUND);
7080 break;
7081 case SE_ERR_SHARE:
7082 errstr = w32_strerror (ERROR_SHARING_VIOLATION);
7083 break;
7084 default:
7085 errstr = w32_strerror (0);
7086 break;
7087 }
7088
7089 #else /* !CYGWIN */
7090
7091 const char file_url_str[] = "file:///";
7092 const int file_url_len = sizeof (file_url_str) - 1;
7093 if (strncmp (SSDATA (document), file_url_str, file_url_len) == 0)
7094 {
7095 /* Passing "file:///" URLs to ShellExecute causes shlwapi.dll to
7096 start a thread in some rare system configurations, for
7097 unknown reasons. That thread is started in the context of
7098 the Emacs process, but out of control of our code, and seems
7099 to never exit afterwards. Each such thread reserves 8MB of
7100 stack space (because that's the value recorded in the Emacs
7101 executable at link time: Emacs needs a large stack). So a
7102 large enough number of invocations of w32-shell-execute can
7103 potentially cause the Emacs process to run out of available
7104 address space, which is nasty. To work around this, we
7105 convert such URLs to local file names, which seems to prevent
7106 those threads from starting. See bug #20220. */
7107 char *p = SSDATA (document) + file_url_len;
7108
7109 if (c_isalpha (*p) && p[1] == ':' && IS_DIRECTORY_SEP (p[2]))
7110 document = Fsubstring_no_properties (document,
7111 make_number (file_url_len), Qnil);
7112 }
7113 /* We have a situation here. If DOCUMENT is a relative file name,
7114 but its name includes leading directories, i.e. it lives not in
7115 CURRENT_DIR, but in its subdirectory, then ShellExecute below
7116 will fail to find it. So we need to make the file name is
7117 absolute. But DOCUMENT does not have to be a file, it can be a
7118 URL, for example. So we make it absolute only if it is an
7119 existing file; if it is a file that does not exist, tough. */
7120 GCPRO1 (absdoc);
7121 absdoc = Fexpand_file_name (document, Qnil);
7122 /* Don't call file handlers for file-exists-p, since they might
7123 attempt to access the file, which could fail or produce undesired
7124 consequences, see bug#16558 for an example. */
7125 handler = Ffind_file_name_handler (absdoc, Qfile_exists_p);
7126 if (NILP (handler))
7127 {
7128 Lisp_Object absdoc_encoded = ENCODE_FILE (absdoc);
7129
7130 if (faccessat (AT_FDCWD, SSDATA (absdoc_encoded), F_OK, AT_EACCESS) == 0)
7131 {
7132 /* ShellExecute fails if DOCUMENT is a UNC with forward
7133 slashes (expand-file-name above converts all backslashes
7134 to forward slashes). Now that we know DOCUMENT is a
7135 file, we can mirror all forward slashes into backslashes. */
7136 unixtodos_filename (SSDATA (absdoc_encoded));
7137 document = absdoc_encoded;
7138 }
7139 else
7140 document = ENCODE_FILE (document);
7141 }
7142 else
7143 document = ENCODE_FILE (document);
7144 UNGCPRO;
7145
7146 current_dir = ENCODE_FILE (current_dir);
7147 if (use_unicode)
7148 {
7149 wchar_t document_w[MAX_PATH], current_dir_w[MAX_PATH];
7150 SHELLEXECUTEINFOW shexinfo_w;
7151
7152 /* Encode filename, current directory and parameters, and
7153 convert operation to UTF-16. */
7154 filename_to_utf16 (SSDATA (current_dir), current_dir_w);
7155 filename_to_utf16 (SSDATA (document), document_w);
7156 doc_w = document_w;
7157 if (STRINGP (parameters))
7158 {
7159 int len;
7160
7161 parameters = ENCODE_SYSTEM (parameters);
7162 len = pMultiByteToWideChar (CP_ACP, MB_ERR_INVALID_CHARS,
7163 SSDATA (parameters), -1, NULL, 0);
7164 if (len > 32768)
7165 len = 32768;
7166 params_w = alloca (len * sizeof (wchar_t));
7167 pMultiByteToWideChar (CP_ACP, MB_ERR_INVALID_CHARS,
7168 SSDATA (parameters), -1, params_w, len);
7169 }
7170 if (STRINGP (operation))
7171 {
7172 /* Assume OPERATION is pure ASCII. */
7173 const char *s = SSDATA (operation);
7174 wchar_t *d;
7175 int len = SBYTES (operation) + 1;
7176
7177 if (len > 32768)
7178 len = 32768;
7179 d = ops_w = alloca (len * sizeof (wchar_t));
7180 while (d < ops_w + len - 1)
7181 *d++ = *s++;
7182 *d = 0;
7183 }
7184
7185 /* Using ShellExecuteEx and setting the SEE_MASK_INVOKEIDLIST
7186 flag succeeds with more OPERATIONs (a.k.a. "verbs"), as it is
7187 able to invoke verbs from shortcut menu extensions, not just
7188 static verbs listed in the Registry. */
7189 memset (&shexinfo_w, 0, sizeof (shexinfo_w));
7190 shexinfo_w.cbSize = sizeof (shexinfo_w);
7191 shexinfo_w.fMask =
7192 SEE_MASK_INVOKEIDLIST | SEE_MASK_FLAG_DDEWAIT | SEE_MASK_FLAG_NO_UI;
7193 shexinfo_w.hwnd = NULL;
7194 shexinfo_w.lpVerb = ops_w;
7195 shexinfo_w.lpFile = doc_w;
7196 shexinfo_w.lpParameters = params_w;
7197 shexinfo_w.lpDirectory = current_dir_w;
7198 shexinfo_w.nShow =
7199 (INTEGERP (show_flag) ? XINT (show_flag) : SW_SHOWDEFAULT);
7200 success = ShellExecuteExW (&shexinfo_w);
7201 }
7202 else
7203 {
7204 char document_a[MAX_PATH], current_dir_a[MAX_PATH];
7205 SHELLEXECUTEINFOA shexinfo_a;
7206
7207 filename_to_ansi (SSDATA (current_dir), current_dir_a);
7208 filename_to_ansi (SSDATA (document), document_a);
7209 doc_a = document_a;
7210 if (STRINGP (parameters))
7211 {
7212 parameters = ENCODE_SYSTEM (parameters);
7213 params_a = SSDATA (parameters);
7214 }
7215 if (STRINGP (operation))
7216 {
7217 /* Assume OPERATION is pure ASCII. */
7218 ops_a = SSDATA (operation);
7219 }
7220 memset (&shexinfo_a, 0, sizeof (shexinfo_a));
7221 shexinfo_a.cbSize = sizeof (shexinfo_a);
7222 shexinfo_a.fMask =
7223 SEE_MASK_INVOKEIDLIST | SEE_MASK_FLAG_DDEWAIT | SEE_MASK_FLAG_NO_UI;
7224 shexinfo_a.hwnd = NULL;
7225 shexinfo_a.lpVerb = ops_a;
7226 shexinfo_a.lpFile = doc_a;
7227 shexinfo_a.lpParameters = params_a;
7228 shexinfo_a.lpDirectory = current_dir_a;
7229 shexinfo_a.nShow =
7230 (INTEGERP (show_flag) ? XINT (show_flag) : SW_SHOWDEFAULT);
7231 success = ShellExecuteExA (&shexinfo_a);
7232 }
7233
7234 if (success)
7235 return Qt;
7236
7237 errstr = w32_strerror (0);
7238
7239 #endif /* !CYGWIN */
7240
7241 /* The error string might be encoded in the locale's encoding. */
7242 if (!NILP (Vlocale_coding_system))
7243 {
7244 Lisp_Object decoded =
7245 code_convert_string_norecord (build_unibyte_string (errstr),
7246 Vlocale_coding_system, 0);
7247 errstr = SSDATA (decoded);
7248 }
7249 error ("ShellExecute failed: %s", errstr);
7250 }
7251
7252 /* Lookup virtual keycode from string representing the name of a
7253 non-ascii keystroke into the corresponding virtual key, using
7254 lispy_function_keys. */
7255 static int
7256 lookup_vk_code (char *key)
7257 {
7258 int i;
7259
7260 for (i = 0; i < 256; i++)
7261 if (lispy_function_keys[i]
7262 && strcmp (lispy_function_keys[i], key) == 0)
7263 return i;
7264
7265 return -1;
7266 }
7267
7268 /* Convert a one-element vector style key sequence to a hot key
7269 definition. */
7270 static Lisp_Object
7271 w32_parse_hot_key (Lisp_Object key)
7272 {
7273 /* Copied from Fdefine_key and store_in_keymap. */
7274 register Lisp_Object c;
7275 int vk_code;
7276 int lisp_modifiers;
7277 int w32_modifiers;
7278 struct gcpro gcpro1;
7279
7280 CHECK_VECTOR (key);
7281
7282 if (ASIZE (key) != 1)
7283 return Qnil;
7284
7285 GCPRO1 (key);
7286
7287 c = AREF (key, 0);
7288
7289 if (CONSP (c) && lucid_event_type_list_p (c))
7290 c = Fevent_convert_list (c);
7291
7292 UNGCPRO;
7293
7294 if (! INTEGERP (c) && ! SYMBOLP (c))
7295 error ("Key definition is invalid");
7296
7297 /* Work out the base key and the modifiers. */
7298 if (SYMBOLP (c))
7299 {
7300 c = parse_modifiers (c);
7301 lisp_modifiers = XINT (Fcar (Fcdr (c)));
7302 c = Fcar (c);
7303 if (!SYMBOLP (c))
7304 emacs_abort ();
7305 vk_code = lookup_vk_code (SDATA (SYMBOL_NAME (c)));
7306 }
7307 else if (INTEGERP (c))
7308 {
7309 lisp_modifiers = XINT (c) & ~CHARACTERBITS;
7310 /* Many ascii characters are their own virtual key code. */
7311 vk_code = XINT (c) & CHARACTERBITS;
7312 }
7313
7314 if (vk_code < 0 || vk_code > 255)
7315 return Qnil;
7316
7317 if ((lisp_modifiers & meta_modifier) != 0
7318 && !NILP (Vw32_alt_is_meta))
7319 lisp_modifiers |= alt_modifier;
7320
7321 /* Supply defs missing from mingw32. */
7322 #ifndef MOD_ALT
7323 #define MOD_ALT 0x0001
7324 #define MOD_CONTROL 0x0002
7325 #define MOD_SHIFT 0x0004
7326 #define MOD_WIN 0x0008
7327 #endif
7328
7329 /* Convert lisp modifiers to Windows hot-key form. */
7330 w32_modifiers = (lisp_modifiers & hyper_modifier) ? MOD_WIN : 0;
7331 w32_modifiers |= (lisp_modifiers & alt_modifier) ? MOD_ALT : 0;
7332 w32_modifiers |= (lisp_modifiers & ctrl_modifier) ? MOD_CONTROL : 0;
7333 w32_modifiers |= (lisp_modifiers & shift_modifier) ? MOD_SHIFT : 0;
7334
7335 return HOTKEY (vk_code, w32_modifiers);
7336 }
7337
7338 DEFUN ("w32-register-hot-key", Fw32_register_hot_key,
7339 Sw32_register_hot_key, 1, 1, 0,
7340 doc: /* Register KEY as a hot-key combination.
7341 Certain key combinations like Alt-Tab are reserved for system use on
7342 Windows, and therefore are normally intercepted by the system. However,
7343 most of these key combinations can be received by registering them as
7344 hot-keys, overriding their special meaning.
7345
7346 KEY must be a one element key definition in vector form that would be
7347 acceptable to `define-key' (e.g. [A-tab] for Alt-Tab). The meta
7348 modifier is interpreted as Alt if `w32-alt-is-meta' is t, and hyper
7349 is always interpreted as the Windows modifier keys.
7350
7351 The return value is the hotkey-id if registered, otherwise nil. */)
7352 (Lisp_Object key)
7353 {
7354 key = w32_parse_hot_key (key);
7355
7356 if (!NILP (key) && NILP (Fmemq (key, w32_grabbed_keys)))
7357 {
7358 /* Reuse an empty slot if possible. */
7359 Lisp_Object item = Fmemq (Qnil, w32_grabbed_keys);
7360
7361 /* Safe to add new key to list, even if we have focus. */
7362 if (NILP (item))
7363 w32_grabbed_keys = Fcons (key, w32_grabbed_keys);
7364 else
7365 XSETCAR (item, key);
7366
7367 /* Notify input thread about new hot-key definition, so that it
7368 takes effect without needing to switch focus. */
7369 PostThreadMessage (dwWindowsThreadId, WM_EMACS_REGISTER_HOT_KEY,
7370 (WPARAM) XINT (key), 0);
7371 }
7372
7373 return key;
7374 }
7375
7376 DEFUN ("w32-unregister-hot-key", Fw32_unregister_hot_key,
7377 Sw32_unregister_hot_key, 1, 1, 0,
7378 doc: /* Unregister KEY as a hot-key combination. */)
7379 (Lisp_Object key)
7380 {
7381 Lisp_Object item;
7382
7383 if (!INTEGERP (key))
7384 key = w32_parse_hot_key (key);
7385
7386 item = Fmemq (key, w32_grabbed_keys);
7387
7388 if (!NILP (item))
7389 {
7390 LPARAM lparam;
7391
7392 eassert (CONSP (item));
7393 /* Pass the tail of the list as a pointer to a Lisp_Cons cell,
7394 so that it works in a --with-wide-int build as well. */
7395 lparam = (LPARAM) XUNTAG (item, Lisp_Cons);
7396
7397 /* Notify input thread about hot-key definition being removed, so
7398 that it takes effect without needing focus switch. */
7399 if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_UNREGISTER_HOT_KEY,
7400 (WPARAM) XINT (XCAR (item)), lparam))
7401 {
7402 MSG msg;
7403 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
7404 }
7405 return Qt;
7406 }
7407 return Qnil;
7408 }
7409
7410 DEFUN ("w32-registered-hot-keys", Fw32_registered_hot_keys,
7411 Sw32_registered_hot_keys, 0, 0, 0,
7412 doc: /* Return list of registered hot-key IDs. */)
7413 (void)
7414 {
7415 return Fdelq (Qnil, Fcopy_sequence (w32_grabbed_keys));
7416 }
7417
7418 DEFUN ("w32-reconstruct-hot-key", Fw32_reconstruct_hot_key,
7419 Sw32_reconstruct_hot_key, 1, 1, 0,
7420 doc: /* Convert hot-key ID to a lisp key combination.
7421 usage: (w32-reconstruct-hot-key ID) */)
7422 (Lisp_Object hotkeyid)
7423 {
7424 int vk_code, w32_modifiers;
7425 Lisp_Object key;
7426
7427 CHECK_NUMBER (hotkeyid);
7428
7429 vk_code = HOTKEY_VK_CODE (hotkeyid);
7430 w32_modifiers = HOTKEY_MODIFIERS (hotkeyid);
7431
7432 if (vk_code < 256 && lispy_function_keys[vk_code])
7433 key = intern (lispy_function_keys[vk_code]);
7434 else
7435 key = make_number (vk_code);
7436
7437 key = Fcons (key, Qnil);
7438 if (w32_modifiers & MOD_SHIFT)
7439 key = Fcons (Qshift, key);
7440 if (w32_modifiers & MOD_CONTROL)
7441 key = Fcons (Qctrl, key);
7442 if (w32_modifiers & MOD_ALT)
7443 key = Fcons (NILP (Vw32_alt_is_meta) ? Qalt : Qmeta, key);
7444 if (w32_modifiers & MOD_WIN)
7445 key = Fcons (Qhyper, key);
7446
7447 return key;
7448 }
7449
7450 DEFUN ("w32-toggle-lock-key", Fw32_toggle_lock_key,
7451 Sw32_toggle_lock_key, 1, 2, 0,
7452 doc: /* Toggle the state of the lock key KEY.
7453 KEY can be `capslock', `kp-numlock', or `scroll'.
7454 If the optional parameter NEW-STATE is a number, then the state of KEY
7455 is set to off if the low bit of NEW-STATE is zero, otherwise on.
7456 If NEW-STATE is omitted or nil, the function toggles the state,
7457
7458 Value is the new state of the key, or nil if the function failed
7459 to change the state. */)
7460 (Lisp_Object key, Lisp_Object new_state)
7461 {
7462 int vk_code;
7463 LPARAM lparam;
7464
7465 if (EQ (key, intern ("capslock")))
7466 vk_code = VK_CAPITAL;
7467 else if (EQ (key, intern ("kp-numlock")))
7468 vk_code = VK_NUMLOCK;
7469 else if (EQ (key, intern ("scroll")))
7470 vk_code = VK_SCROLL;
7471 else
7472 return Qnil;
7473
7474 if (!dwWindowsThreadId)
7475 return make_number (w32_console_toggle_lock_key (vk_code, new_state));
7476
7477 if (NILP (new_state))
7478 lparam = -1;
7479 else
7480 lparam = (XUINT (new_state)) & 1;
7481 if (PostThreadMessage (dwWindowsThreadId, WM_EMACS_TOGGLE_LOCK_KEY,
7482 (WPARAM) vk_code, lparam))
7483 {
7484 MSG msg;
7485 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
7486 return make_number (msg.wParam);
7487 }
7488 return Qnil;
7489 }
7490
7491 DEFUN ("w32-window-exists-p", Fw32_window_exists_p, Sw32_window_exists_p,
7492 2, 2, 0,
7493 doc: /* Return non-nil if a window exists with the specified CLASS and NAME.
7494
7495 This is a direct interface to the Windows API FindWindow function. */)
7496 (Lisp_Object class, Lisp_Object name)
7497 {
7498 HWND hnd;
7499
7500 if (!NILP (class))
7501 CHECK_STRING (class);
7502 if (!NILP (name))
7503 CHECK_STRING (name);
7504
7505 hnd = FindWindow (STRINGP (class) ? ((LPCTSTR) SDATA (class)) : NULL,
7506 STRINGP (name) ? ((LPCTSTR) SDATA (name)) : NULL);
7507 if (!hnd)
7508 return Qnil;
7509 return Qt;
7510 }
7511
7512 DEFUN ("w32-frame-menu-bar-size", Fw32_frame_menu_bar_size, Sw32_frame_menu_bar_size, 0, 1, 0,
7513 doc: /* Return sizes of menu bar on frame FRAME.
7514 The return value is a list of four elements: The current width and
7515 height of FRAME's menu bar in pixels, the height of one menu bar line in
7516 a wrapped menu bar in pixels, and the height of a single line menu bar
7517 in pixels.
7518
7519 If FRAME is omitted or nil, the selected frame is used. */)
7520 (Lisp_Object frame)
7521 {
7522 struct frame *f = decode_any_frame (frame);
7523 MENUBARINFO menu_bar;
7524 int width, height, single_height, wrapped_height;
7525
7526 if (FRAME_INITIAL_P (f) || !FRAME_W32_P (f))
7527 return Qnil;
7528
7529 block_input ();
7530
7531 single_height = GetSystemMetrics (SM_CYMENU);
7532 wrapped_height = GetSystemMetrics (SM_CYMENUSIZE);
7533 menu_bar.cbSize = sizeof (menu_bar);
7534 menu_bar.rcBar.right = menu_bar.rcBar.left = 0;
7535 menu_bar.rcBar.top = menu_bar.rcBar.bottom = 0;
7536 GetMenuBarInfo (FRAME_W32_WINDOW (f), 0xFFFFFFFD, 0, &menu_bar);
7537 width = menu_bar.rcBar.right - menu_bar.rcBar.left;
7538 height = menu_bar.rcBar.bottom - menu_bar.rcBar.top;
7539
7540 unblock_input ();
7541
7542 return list4 (make_number (width), make_number (height),
7543 make_number (wrapped_height), make_number (single_height));
7544 }
7545
7546 DEFUN ("w32-frame-rect", Fw32_frame_rect, Sw32_frame_rect, 0, 2, 0,
7547 doc: /* Return boundary rectangle of FRAME in screen coordinates.
7548 FRAME must be a live frame and defaults to the selected one.
7549
7550 The boundary rectangle is a list of four elements, specifying the left,
7551 top, right and bottom screen coordinates of FRAME including menu and
7552 title bar and decorations. Optional argument CLIENT non-nil means to
7553 return the boundaries of the client rectangle which excludes menu and
7554 title bar and decorations. */)
7555 (Lisp_Object frame, Lisp_Object client)
7556 {
7557 struct frame *f = decode_live_frame (frame);
7558 RECT rect;
7559
7560 if (FRAME_INITIAL_P (f) || !FRAME_W32_P (f))
7561 return Qnil;
7562
7563 block_input ();
7564
7565 if (!NILP (client))
7566 GetClientRect (FRAME_W32_WINDOW (f), &rect);
7567 else
7568 GetWindowRect (FRAME_W32_WINDOW (f), &rect);
7569
7570 unblock_input ();
7571
7572 return list4 (make_number (rect.left), make_number (rect.top),
7573 make_number (rect.right), make_number (rect.bottom));
7574 }
7575
7576 DEFUN ("x-frame-geometry", Fx_frame_geometry, Sx_frame_geometry, 0, 1, 0,
7577 doc: /* Return geometric attributes of frame FRAME.
7578 FRAME must be a live frame and defaults to the selected one.
7579
7580 The return value is an association list containing the following
7581 elements (all size values are in pixels).
7582
7583 - `frame-outer-size' is a cons of the outer width and height of FRAME.
7584 The outer size includes the title bar and the external borders as well
7585 as any menu and/or tool bar of frame.
7586
7587 - `border' is a cons of the horizontal and vertical width of FRAME's
7588 external borders.
7589
7590 - `title-bar-height' is the height of the title bar of FRAME.
7591
7592 - `menu-bar-external' if t means the menu bar is by default external
7593 (not included in the inner size of FRAME).
7594
7595 - `menu-bar-size' is a cons of the width and height of the menu bar of
7596 FRAME.
7597
7598 - `tool-bar-external' if t means the tool bar is by default external
7599 (not included in the inner size of FRAME).
7600
7601 - `tool-bar-side' tells tells on which side the tool bar on FRAME is by
7602 default and can be one of `left', `top', `right' or `bottom'.
7603
7604 - `tool-bar-size' is a cons of the width and height of the tool bar of
7605 FRAME.
7606
7607 - `frame-inner-size' is a cons of the inner width and height of FRAME.
7608 This excludes FRAME's title bar and external border as well as any
7609 external menu and/or tool bar. */)
7610 (Lisp_Object frame)
7611 {
7612 struct frame *f = decode_live_frame (frame);
7613 Lisp_Object geometry = Qnil;
7614 RECT frame_outer_edges, frame_inner_edges;
7615 MENUBARINFO menu_bar;
7616 int border_width, border_height, title_height;
7617 int single_bar_height, wrapped_bar_height, menu_bar_height;
7618 Lisp_Object fullscreen = Fframe_parameter (frame, Qfullscreen);
7619
7620 if (FRAME_INITIAL_P (f) || !FRAME_W32_P (f))
7621 return Qnil;
7622
7623 block_input ();
7624
7625 /* Outer frame rectangle, including outer borders and title bar. */
7626 GetWindowRect (FRAME_W32_WINDOW (f), &frame_outer_edges);
7627 /* Inner frame rectangle, excluding borders and title bar. */
7628 GetClientRect (FRAME_W32_WINDOW (f), &frame_inner_edges);
7629 /* Outer border. */
7630 border_width = GetSystemMetrics (SM_CXFRAME);
7631 border_height = GetSystemMetrics (SM_CYFRAME);
7632 /* Title bar. */
7633 title_height = GetSystemMetrics (SM_CYCAPTION);
7634 /* Menu bar. */
7635 menu_bar.cbSize = sizeof (menu_bar);
7636 menu_bar.rcBar.right = menu_bar.rcBar.left = 0;
7637 menu_bar.rcBar.top = menu_bar.rcBar.bottom = 0;
7638 GetMenuBarInfo (FRAME_W32_WINDOW (f), 0xFFFFFFFD, 0, &menu_bar);
7639 single_bar_height = GetSystemMetrics (SM_CYMENU);
7640 wrapped_bar_height = GetSystemMetrics (SM_CYMENUSIZE);
7641 unblock_input ();
7642
7643 menu_bar_height = menu_bar.rcBar.bottom - menu_bar.rcBar.top;
7644 /* Fix menu bar height reported by GetMenuBarInfo. */
7645 if (menu_bar_height > single_bar_height)
7646 /* A wrapped menu bar. */
7647 menu_bar_height += single_bar_height - wrapped_bar_height;
7648 else if (menu_bar_height > 0)
7649 /* A single line menu bar. */
7650 menu_bar_height = single_bar_height;
7651
7652 return
7653 listn (CONSTYPE_HEAP, 10,
7654 Fcons (Qframe_position,
7655 Fcons (make_number (frame_outer_edges.left),
7656 make_number (frame_outer_edges.top))),
7657 Fcons (Qframe_outer_size,
7658 Fcons (make_number
7659 (frame_outer_edges.right - frame_outer_edges.left),
7660 make_number
7661 (frame_outer_edges.bottom - frame_outer_edges.top))),
7662 Fcons (Qexternal_border_size,
7663 ((EQ (fullscreen, Qfullboth) || EQ (fullscreen, Qfullscreen))
7664 ? Fcons (make_number (0), make_number (0))
7665 : Fcons (make_number (border_width),
7666 make_number (border_height)))),
7667 Fcons (Qtitle_height,
7668 ((EQ (fullscreen, Qfullboth) || EQ (fullscreen, Qfullscreen))
7669 ? make_number (0)
7670 : make_number (title_height))),
7671 Fcons (Qmenu_bar_external, Qt),
7672 Fcons (Qmenu_bar_size,
7673 Fcons (make_number
7674 (menu_bar.rcBar.right - menu_bar.rcBar.left),
7675 make_number (menu_bar_height))),
7676 Fcons (Qtool_bar_external, Qnil),
7677 Fcons (Qtool_bar_position, Qtop),
7678 Fcons (Qtool_bar_size,
7679 Fcons (make_number (FRAME_TOOL_BAR_LINES (f)
7680 ? (FRAME_PIXEL_WIDTH (f)
7681 - 2 * FRAME_INTERNAL_BORDER_WIDTH (f))
7682 : 0),
7683 make_number (FRAME_TOOL_BAR_HEIGHT (f)))),
7684 Fcons (Qframe_inner_size,
7685 Fcons (make_number
7686 (frame_inner_edges.right - frame_inner_edges.left),
7687 make_number
7688 (frame_inner_edges.bottom - frame_inner_edges.top))));
7689 }
7690
7691 DEFUN ("w32-battery-status", Fw32_battery_status, Sw32_battery_status, 0, 0, 0,
7692 doc: /* Get power status information from Windows system.
7693
7694 The following %-sequences are provided:
7695 %L AC line status (verbose)
7696 %B Battery status (verbose)
7697 %b Battery status, empty means high, `-' means low,
7698 `!' means critical, and `+' means charging
7699 %p Battery load percentage
7700 %s Remaining time (to charge or discharge) in seconds
7701 %m Remaining time (to charge or discharge) in minutes
7702 %h Remaining time (to charge or discharge) in hours
7703 %t Remaining time (to charge or discharge) in the form `h:min' */)
7704 (void)
7705 {
7706 Lisp_Object status = Qnil;
7707
7708 SYSTEM_POWER_STATUS system_status;
7709 if (GetSystemPowerStatus (&system_status))
7710 {
7711 Lisp_Object line_status, battery_status, battery_status_symbol;
7712 Lisp_Object load_percentage, seconds, minutes, hours, remain;
7713
7714 long seconds_left = (long) system_status.BatteryLifeTime;
7715
7716 if (system_status.ACLineStatus == 0)
7717 line_status = build_string ("off-line");
7718 else if (system_status.ACLineStatus == 1)
7719 line_status = build_string ("on-line");
7720 else
7721 line_status = build_string ("N/A");
7722
7723 if (system_status.BatteryFlag & 128)
7724 {
7725 battery_status = build_string ("N/A");
7726 battery_status_symbol = empty_unibyte_string;
7727 }
7728 else if (system_status.BatteryFlag & 8)
7729 {
7730 battery_status = build_string ("charging");
7731 battery_status_symbol = build_string ("+");
7732 if (system_status.BatteryFullLifeTime != -1L)
7733 seconds_left = system_status.BatteryFullLifeTime - seconds_left;
7734 }
7735 else if (system_status.BatteryFlag & 4)
7736 {
7737 battery_status = build_string ("critical");
7738 battery_status_symbol = build_string ("!");
7739 }
7740 else if (system_status.BatteryFlag & 2)
7741 {
7742 battery_status = build_string ("low");
7743 battery_status_symbol = build_string ("-");
7744 }
7745 else if (system_status.BatteryFlag & 1)
7746 {
7747 battery_status = build_string ("high");
7748 battery_status_symbol = empty_unibyte_string;
7749 }
7750 else
7751 {
7752 battery_status = build_string ("medium");
7753 battery_status_symbol = empty_unibyte_string;
7754 }
7755
7756 if (system_status.BatteryLifePercent > 100)
7757 load_percentage = build_string ("N/A");
7758 else
7759 {
7760 char buffer[16];
7761 snprintf (buffer, 16, "%d", system_status.BatteryLifePercent);
7762 load_percentage = build_string (buffer);
7763 }
7764
7765 if (seconds_left < 0)
7766 seconds = minutes = hours = remain = build_string ("N/A");
7767 else
7768 {
7769 long m;
7770 float h;
7771 char buffer[16];
7772 snprintf (buffer, 16, "%ld", seconds_left);
7773 seconds = build_string (buffer);
7774
7775 m = seconds_left / 60;
7776 snprintf (buffer, 16, "%ld", m);
7777 minutes = build_string (buffer);
7778
7779 h = seconds_left / 3600.0;
7780 snprintf (buffer, 16, "%3.1f", h);
7781 hours = build_string (buffer);
7782
7783 snprintf (buffer, 16, "%ld:%02ld", m / 60, m % 60);
7784 remain = build_string (buffer);
7785 }
7786
7787 status = listn (CONSTYPE_HEAP, 8,
7788 Fcons (make_number ('L'), line_status),
7789 Fcons (make_number ('B'), battery_status),
7790 Fcons (make_number ('b'), battery_status_symbol),
7791 Fcons (make_number ('p'), load_percentage),
7792 Fcons (make_number ('s'), seconds),
7793 Fcons (make_number ('m'), minutes),
7794 Fcons (make_number ('h'), hours),
7795 Fcons (make_number ('t'), remain));
7796 }
7797 return status;
7798 }
7799
7800 \f
7801 #ifdef WINDOWSNT
7802 DEFUN ("file-system-info", Ffile_system_info, Sfile_system_info, 1, 1, 0,
7803 doc: /* Return storage information about the file system FILENAME is on.
7804 Value is a list of floats (TOTAL FREE AVAIL), where TOTAL is the total
7805 storage of the file system, FREE is the free storage, and AVAIL is the
7806 storage available to a non-superuser. All 3 numbers are in bytes.
7807 If the underlying system call fails, value is nil. */)
7808 (Lisp_Object filename)
7809 {
7810 Lisp_Object encoded, value;
7811
7812 CHECK_STRING (filename);
7813 filename = Fexpand_file_name (filename, Qnil);
7814 encoded = ENCODE_FILE (filename);
7815
7816 value = Qnil;
7817
7818 /* Determining the required information on Windows turns out, sadly,
7819 to be more involved than one would hope. The original Windows API
7820 call for this will return bogus information on some systems, but we
7821 must dynamically probe for the replacement api, since that was
7822 added rather late on. */
7823 {
7824 HMODULE hKernel = GetModuleHandle ("kernel32");
7825 BOOL (WINAPI *pfn_GetDiskFreeSpaceExW)
7826 (wchar_t *, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER)
7827 = GetProcAddress (hKernel, "GetDiskFreeSpaceExW");
7828 BOOL (WINAPI *pfn_GetDiskFreeSpaceExA)
7829 (char *, PULARGE_INTEGER, PULARGE_INTEGER, PULARGE_INTEGER)
7830 = GetProcAddress (hKernel, "GetDiskFreeSpaceExA");
7831 bool have_pfn_GetDiskFreeSpaceEx =
7832 ((w32_unicode_filenames && pfn_GetDiskFreeSpaceExW)
7833 || (!w32_unicode_filenames && pfn_GetDiskFreeSpaceExA));
7834
7835 /* On Windows, we may need to specify the root directory of the
7836 volume holding FILENAME. */
7837 char rootname[MAX_UTF8_PATH];
7838 wchar_t rootname_w[MAX_PATH];
7839 char rootname_a[MAX_PATH];
7840 char *name = SDATA (encoded);
7841 BOOL result;
7842
7843 /* find the root name of the volume if given */
7844 if (isalpha (name[0]) && name[1] == ':')
7845 {
7846 rootname[0] = name[0];
7847 rootname[1] = name[1];
7848 rootname[2] = '\\';
7849 rootname[3] = 0;
7850 }
7851 else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
7852 {
7853 char *str = rootname;
7854 int slashes = 4;
7855 do
7856 {
7857 if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
7858 break;
7859 *str++ = *name++;
7860 }
7861 while ( *name );
7862
7863 *str++ = '\\';
7864 *str = 0;
7865 }
7866
7867 if (w32_unicode_filenames)
7868 filename_to_utf16 (rootname, rootname_w);
7869 else
7870 filename_to_ansi (rootname, rootname_a);
7871
7872 if (have_pfn_GetDiskFreeSpaceEx)
7873 {
7874 /* Unsigned large integers cannot be cast to double, so
7875 use signed ones instead. */
7876 LARGE_INTEGER availbytes;
7877 LARGE_INTEGER freebytes;
7878 LARGE_INTEGER totalbytes;
7879
7880 if (w32_unicode_filenames)
7881 result = pfn_GetDiskFreeSpaceExW (rootname_w,
7882 (ULARGE_INTEGER *)&availbytes,
7883 (ULARGE_INTEGER *)&totalbytes,
7884 (ULARGE_INTEGER *)&freebytes);
7885 else
7886 result = pfn_GetDiskFreeSpaceExA (rootname_a,
7887 (ULARGE_INTEGER *)&availbytes,
7888 (ULARGE_INTEGER *)&totalbytes,
7889 (ULARGE_INTEGER *)&freebytes);
7890 if (result)
7891 value = list3 (make_float ((double) totalbytes.QuadPart),
7892 make_float ((double) freebytes.QuadPart),
7893 make_float ((double) availbytes.QuadPart));
7894 }
7895 else
7896 {
7897 DWORD sectors_per_cluster;
7898 DWORD bytes_per_sector;
7899 DWORD free_clusters;
7900 DWORD total_clusters;
7901
7902 if (w32_unicode_filenames)
7903 result = GetDiskFreeSpaceW (rootname_w,
7904 &sectors_per_cluster,
7905 &bytes_per_sector,
7906 &free_clusters,
7907 &total_clusters);
7908 else
7909 result = GetDiskFreeSpaceA (rootname_a,
7910 &sectors_per_cluster,
7911 &bytes_per_sector,
7912 &free_clusters,
7913 &total_clusters);
7914 if (result)
7915 value = list3 (make_float ((double) total_clusters
7916 * sectors_per_cluster * bytes_per_sector),
7917 make_float ((double) free_clusters
7918 * sectors_per_cluster * bytes_per_sector),
7919 make_float ((double) free_clusters
7920 * sectors_per_cluster * bytes_per_sector));
7921 }
7922 }
7923
7924 return value;
7925 }
7926 #endif /* WINDOWSNT */
7927
7928 \f
7929 #ifdef WINDOWSNT
7930 DEFUN ("default-printer-name", Fdefault_printer_name, Sdefault_printer_name,
7931 0, 0, 0, doc: /* Return the name of Windows default printer device. */)
7932 (void)
7933 {
7934 static char pname_buf[256];
7935 int err;
7936 HANDLE hPrn;
7937 PRINTER_INFO_2W *ppi2w = NULL;
7938 PRINTER_INFO_2A *ppi2a = NULL;
7939 DWORD dwNeeded = 0, dwReturned = 0;
7940 char server_name[MAX_UTF8_PATH], share_name[MAX_UTF8_PATH];
7941 char port_name[MAX_UTF8_PATH];
7942
7943 /* Retrieve the default string from Win.ini (the registry).
7944 * String will be in form "printername,drivername,portname".
7945 * This is the most portable way to get the default printer. */
7946 if (GetProfileString ("windows", "device", ",,", pname_buf, sizeof (pname_buf)) <= 0)
7947 return Qnil;
7948 /* printername precedes first "," character */
7949 strtok (pname_buf, ",");
7950 /* We want to know more than the printer name */
7951 if (!OpenPrinter (pname_buf, &hPrn, NULL))
7952 return Qnil;
7953 /* GetPrinterW is not supported by unicows.dll. */
7954 if (w32_unicode_filenames && os_subtype != OS_9X)
7955 GetPrinterW (hPrn, 2, NULL, 0, &dwNeeded);
7956 else
7957 GetPrinterA (hPrn, 2, NULL, 0, &dwNeeded);
7958 if (dwNeeded == 0)
7959 {
7960 ClosePrinter (hPrn);
7961 return Qnil;
7962 }
7963 /* Call GetPrinter again with big enough memory block. */
7964 if (w32_unicode_filenames && os_subtype != OS_9X)
7965 {
7966 /* Allocate memory for the PRINTER_INFO_2 struct. */
7967 ppi2w = xmalloc (dwNeeded);
7968 err = GetPrinterW (hPrn, 2, (LPBYTE)ppi2w, dwNeeded, &dwReturned);
7969 ClosePrinter (hPrn);
7970 if (!err)
7971 {
7972 xfree (ppi2w);
7973 return Qnil;
7974 }
7975
7976 if ((ppi2w->Attributes & PRINTER_ATTRIBUTE_SHARED)
7977 && ppi2w->pServerName)
7978 {
7979 filename_from_utf16 (ppi2w->pServerName, server_name);
7980 filename_from_utf16 (ppi2w->pShareName, share_name);
7981 }
7982 else
7983 {
7984 server_name[0] = '\0';
7985 filename_from_utf16 (ppi2w->pPortName, port_name);
7986 }
7987 }
7988 else
7989 {
7990 ppi2a = xmalloc (dwNeeded);
7991 err = GetPrinterA (hPrn, 2, (LPBYTE)ppi2a, dwNeeded, &dwReturned);
7992 ClosePrinter (hPrn);
7993 if (!err)
7994 {
7995 xfree (ppi2a);
7996 return Qnil;
7997 }
7998
7999 if ((ppi2a->Attributes & PRINTER_ATTRIBUTE_SHARED)
8000 && ppi2a->pServerName)
8001 {
8002 filename_from_ansi (ppi2a->pServerName, server_name);
8003 filename_from_ansi (ppi2a->pShareName, share_name);
8004 }
8005 else
8006 {
8007 server_name[0] = '\0';
8008 filename_from_ansi (ppi2a->pPortName, port_name);
8009 }
8010 }
8011
8012 if (server_name[0])
8013 {
8014 /* a remote printer */
8015 if (server_name[0] == '\\')
8016 snprintf (pname_buf, sizeof (pname_buf), "%s\\%s", server_name,
8017 share_name);
8018 else
8019 snprintf (pname_buf, sizeof (pname_buf), "\\\\%s\\%s", server_name,
8020 share_name);
8021 pname_buf[sizeof (pname_buf) - 1] = '\0';
8022 }
8023 else
8024 {
8025 /* a local printer */
8026 strncpy (pname_buf, port_name, sizeof (pname_buf));
8027 pname_buf[sizeof (pname_buf) - 1] = '\0';
8028 /* `pPortName' can include several ports, delimited by ','.
8029 * we only use the first one. */
8030 strtok (pname_buf, ",");
8031 }
8032
8033 return DECODE_FILE (build_unibyte_string (pname_buf));
8034 }
8035 #endif /* WINDOWSNT */
8036 \f
8037
8038 /* Equivalent of strerror for W32 error codes. */
8039 char *
8040 w32_strerror (int error_no)
8041 {
8042 static char buf[500];
8043 DWORD ret;
8044
8045 if (error_no == 0)
8046 error_no = GetLastError ();
8047
8048 ret = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM |
8049 FORMAT_MESSAGE_IGNORE_INSERTS,
8050 NULL,
8051 error_no,
8052 0, /* choose most suitable language */
8053 buf, sizeof (buf), NULL);
8054
8055 while (ret > 0 && (buf[ret - 1] == '\n' ||
8056 buf[ret - 1] == '\r' ))
8057 --ret;
8058 buf[ret] = '\0';
8059 if (!ret)
8060 sprintf (buf, "w32 error %u", error_no);
8061
8062 return buf;
8063 }
8064
8065 /* For convenience when debugging. (You cannot call GetLastError
8066 directly from GDB: it will crash, because it uses the __stdcall
8067 calling convention, not the _cdecl convention assumed by GDB.) */
8068 DWORD
8069 w32_last_error (void)
8070 {
8071 return GetLastError ();
8072 }
8073
8074 /* Cache information describing the NT system for later use. */
8075 void
8076 cache_system_info (void)
8077 {
8078 union
8079 {
8080 struct info
8081 {
8082 char major;
8083 char minor;
8084 short platform;
8085 } info;
8086 DWORD data;
8087 } version;
8088
8089 /* Cache the module handle of Emacs itself. */
8090 hinst = GetModuleHandle (NULL);
8091
8092 /* Cache the version of the operating system. */
8093 version.data = GetVersion ();
8094 w32_major_version = version.info.major;
8095 w32_minor_version = version.info.minor;
8096
8097 if (version.info.platform & 0x8000)
8098 os_subtype = OS_9X;
8099 else
8100 os_subtype = OS_NT;
8101
8102 /* Cache page size, allocation unit, processor type, etc. */
8103 GetSystemInfo (&sysinfo_cache);
8104 syspage_mask = (DWORD_PTR)sysinfo_cache.dwPageSize - 1;
8105
8106 /* Cache os info. */
8107 osinfo_cache.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
8108 GetVersionEx (&osinfo_cache);
8109
8110 w32_build_number = osinfo_cache.dwBuildNumber;
8111 if (os_subtype == OS_9X)
8112 w32_build_number &= 0xffff;
8113
8114 w32_num_mouse_buttons = GetSystemMetrics (SM_CMOUSEBUTTONS);
8115 }
8116
8117 #ifdef EMACSDEBUG
8118 void
8119 _DebPrint (const char *fmt, ...)
8120 {
8121 char buf[1024];
8122 va_list args;
8123
8124 va_start (args, fmt);
8125 vsprintf (buf, fmt, args);
8126 va_end (args);
8127 #if CYGWIN
8128 fprintf (stderr, "%s", buf);
8129 #endif
8130 OutputDebugString (buf);
8131 }
8132 #endif
8133
8134 int
8135 w32_console_toggle_lock_key (int vk_code, Lisp_Object new_state)
8136 {
8137 int cur_state = (GetKeyState (vk_code) & 1);
8138
8139 if (NILP (new_state)
8140 || (NUMBERP (new_state)
8141 && ((XUINT (new_state)) & 1) != cur_state))
8142 {
8143 #ifdef WINDOWSNT
8144 faked_key = vk_code;
8145 #endif /* WINDOWSNT */
8146
8147 keybd_event ((BYTE) vk_code,
8148 (BYTE) MapVirtualKey (vk_code, 0),
8149 KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
8150 keybd_event ((BYTE) vk_code,
8151 (BYTE) MapVirtualKey (vk_code, 0),
8152 KEYEVENTF_EXTENDEDKEY | 0, 0);
8153 keybd_event ((BYTE) vk_code,
8154 (BYTE) MapVirtualKey (vk_code, 0),
8155 KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
8156 cur_state = !cur_state;
8157 }
8158
8159 return cur_state;
8160 }
8161
8162 /* Translate console modifiers to emacs modifiers.
8163 German keyboard support (Kai Morgan Zeise 2/18/95). */
8164 int
8165 w32_kbd_mods_to_emacs (DWORD mods, WORD key)
8166 {
8167 int retval = 0;
8168
8169 /* If we recognize right-alt and left-ctrl as AltGr, and it has been
8170 pressed, first remove those modifiers. */
8171 if (!NILP (Vw32_recognize_altgr)
8172 && (mods & (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
8173 == (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED))
8174 mods &= ~ (RIGHT_ALT_PRESSED | LEFT_CTRL_PRESSED);
8175
8176 if (mods & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED))
8177 retval = ((NILP (Vw32_alt_is_meta)) ? alt_modifier : meta_modifier);
8178
8179 if (mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
8180 {
8181 retval |= ctrl_modifier;
8182 if ((mods & (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
8183 == (RIGHT_CTRL_PRESSED | LEFT_CTRL_PRESSED))
8184 retval |= meta_modifier;
8185 }
8186
8187 if (mods & LEFT_WIN_PRESSED)
8188 retval |= w32_key_to_modifier (VK_LWIN);
8189 if (mods & RIGHT_WIN_PRESSED)
8190 retval |= w32_key_to_modifier (VK_RWIN);
8191 if (mods & APPS_PRESSED)
8192 retval |= w32_key_to_modifier (VK_APPS);
8193 if (mods & SCROLLLOCK_ON)
8194 retval |= w32_key_to_modifier (VK_SCROLL);
8195
8196 /* Just in case someone wanted the original behavior, make it
8197 optional by setting w32-capslock-is-shiftlock to t. */
8198 if (NILP (Vw32_capslock_is_shiftlock)
8199 /* Keys that should _not_ be affected by CapsLock. */
8200 && ( (key == VK_BACK)
8201 || (key == VK_TAB)
8202 || (key == VK_CLEAR)
8203 || (key == VK_RETURN)
8204 || (key == VK_ESCAPE)
8205 || ((key >= VK_SPACE) && (key <= VK_HELP))
8206 || ((key >= VK_NUMPAD0) && (key <= VK_F24))
8207 || ((key >= VK_NUMPAD_CLEAR) && (key <= VK_NUMPAD_DELETE))
8208 ))
8209 {
8210 /* Only consider shift state. */
8211 if ((mods & SHIFT_PRESSED) != 0)
8212 retval |= shift_modifier;
8213 }
8214 else
8215 {
8216 /* Ignore CapsLock state if not enabled. */
8217 if (NILP (Vw32_enable_caps_lock))
8218 mods &= ~CAPSLOCK_ON;
8219 if ((mods & (SHIFT_PRESSED | CAPSLOCK_ON)) != 0)
8220 retval |= shift_modifier;
8221 }
8222
8223 return retval;
8224 }
8225
8226 /* The return code indicates key code size. cpID is the codepage to
8227 use for translation to Unicode; -1 means use the current console
8228 input codepage. */
8229 int
8230 w32_kbd_patch_key (KEY_EVENT_RECORD *event, int cpId)
8231 {
8232 unsigned int key_code = event->wVirtualKeyCode;
8233 unsigned int mods = event->dwControlKeyState;
8234 BYTE keystate[256];
8235 static BYTE ansi_code[4];
8236 static int isdead = 0;
8237
8238 if (isdead == 2)
8239 {
8240 event->uChar.AsciiChar = ansi_code[2];
8241 isdead = 0;
8242 return 1;
8243 }
8244 if (event->uChar.AsciiChar != 0)
8245 return 1;
8246
8247 memset (keystate, 0, sizeof (keystate));
8248 keystate[key_code] = 0x80;
8249 if (mods & SHIFT_PRESSED)
8250 keystate[VK_SHIFT] = 0x80;
8251 if (mods & CAPSLOCK_ON)
8252 keystate[VK_CAPITAL] = 1;
8253 /* If we recognize right-alt and left-ctrl as AltGr, set the key
8254 states accordingly before invoking ToAscii. */
8255 if (!NILP (Vw32_recognize_altgr)
8256 && (mods & LEFT_CTRL_PRESSED) && (mods & RIGHT_ALT_PRESSED))
8257 {
8258 keystate[VK_CONTROL] = 0x80;
8259 keystate[VK_LCONTROL] = 0x80;
8260 keystate[VK_MENU] = 0x80;
8261 keystate[VK_RMENU] = 0x80;
8262 }
8263
8264 #if 0
8265 /* Because of an OS bug, ToAscii corrupts the stack when called to
8266 convert a dead key in console mode on NT4. Unfortunately, trying
8267 to check for dead keys using MapVirtualKey doesn't work either -
8268 these functions apparently use internal information about keyboard
8269 layout which doesn't get properly updated in console programs when
8270 changing layout (though apparently it gets partly updated,
8271 otherwise ToAscii wouldn't crash). */
8272 if (is_dead_key (event->wVirtualKeyCode))
8273 return 0;
8274 #endif
8275
8276 /* On NT, call ToUnicode instead and then convert to the current
8277 console input codepage. */
8278 if (os_subtype == OS_NT)
8279 {
8280 WCHAR buf[128];
8281
8282 isdead = ToUnicode (event->wVirtualKeyCode, event->wVirtualScanCode,
8283 keystate, buf, 128, 0);
8284 if (isdead > 0)
8285 {
8286 /* When we are called from the GUI message processing code,
8287 we are passed the current keyboard codepage, a positive
8288 number, to use below. */
8289 if (cpId == -1)
8290 cpId = GetConsoleCP ();
8291
8292 event->uChar.UnicodeChar = buf[isdead - 1];
8293 isdead = WideCharToMultiByte (cpId, 0, buf, isdead,
8294 ansi_code, 4, NULL, NULL);
8295 }
8296 else
8297 isdead = 0;
8298 }
8299 else
8300 {
8301 isdead = ToAscii (event->wVirtualKeyCode, event->wVirtualScanCode,
8302 keystate, (LPWORD) ansi_code, 0);
8303 }
8304
8305 if (isdead == 0)
8306 return 0;
8307 event->uChar.AsciiChar = ansi_code[0];
8308 return isdead;
8309 }
8310
8311
8312 void
8313 w32_sys_ring_bell (struct frame *f)
8314 {
8315 if (sound_type == 0xFFFFFFFF)
8316 {
8317 Beep (666, 100);
8318 }
8319 else if (sound_type == MB_EMACS_SILENT)
8320 {
8321 /* Do nothing. */
8322 }
8323 else
8324 MessageBeep (sound_type);
8325 }
8326
8327 DEFUN ("w32--menu-bar-in-use", Fw32__menu_bar_in_use, Sw32__menu_bar_in_use,
8328 0, 0, 0,
8329 doc: /* Return non-nil when a menu-bar menu is being used.
8330 Internal use only. */)
8331 (void)
8332 {
8333 return menubar_in_use ? Qt : Qnil;
8334 }
8335
8336 \f
8337 /***********************************************************************
8338 Initialization
8339 ***********************************************************************/
8340
8341 /* Keep this list in the same order as frame_parms in frame.c.
8342 Use 0 for unsupported frame parameters. */
8343
8344 frame_parm_handler w32_frame_parm_handlers[] =
8345 {
8346 x_set_autoraise,
8347 x_set_autolower,
8348 x_set_background_color,
8349 x_set_border_color,
8350 x_set_border_width,
8351 x_set_cursor_color,
8352 x_set_cursor_type,
8353 x_set_font,
8354 x_set_foreground_color,
8355 x_set_icon_name,
8356 x_set_icon_type,
8357 x_set_internal_border_width,
8358 x_set_right_divider_width,
8359 x_set_bottom_divider_width,
8360 x_set_menu_bar_lines,
8361 x_set_mouse_color,
8362 x_explicitly_set_name,
8363 x_set_scroll_bar_width,
8364 x_set_scroll_bar_height,
8365 x_set_title,
8366 x_set_unsplittable,
8367 x_set_vertical_scroll_bars,
8368 x_set_horizontal_scroll_bars,
8369 x_set_visibility,
8370 x_set_tool_bar_lines,
8371 0, /* x_set_scroll_bar_foreground, */
8372 0, /* x_set_scroll_bar_background, */
8373 x_set_screen_gamma,
8374 x_set_line_spacing,
8375 x_set_left_fringe,
8376 x_set_right_fringe,
8377 0, /* x_set_wait_for_wm, */
8378 x_set_fullscreen,
8379 x_set_font_backend,
8380 x_set_alpha,
8381 0, /* x_set_sticky */
8382 0, /* x_set_tool_bar_position */
8383 };
8384
8385 void
8386 syms_of_w32fns (void)
8387 {
8388 globals_of_w32fns ();
8389 track_mouse_window = NULL;
8390
8391 w32_visible_system_caret_hwnd = NULL;
8392
8393 DEFSYM (Qundefined_color, "undefined-color");
8394 DEFSYM (Qcancel_timer, "cancel-timer");
8395 DEFSYM (Qhyper, "hyper");
8396 DEFSYM (Qsuper, "super");
8397 DEFSYM (Qmeta, "meta");
8398 DEFSYM (Qalt, "alt");
8399 DEFSYM (Qctrl, "ctrl");
8400 DEFSYM (Qcontrol, "control");
8401 DEFSYM (Qshift, "shift");
8402 DEFSYM (Qfont_param, "font-parameter");
8403 DEFSYM (Qgeometry, "geometry");
8404 DEFSYM (Qworkarea, "workarea");
8405 DEFSYM (Qmm_size, "mm-size");
8406 DEFSYM (Qframes, "frames");
8407 DEFSYM (Qtip_frame, "tip-frame");
8408 DEFSYM (Qunicode_sip, "unicode-sip");
8409
8410 /* Symbols used elsewhere, but only in MS-Windows-specific code. */
8411 DEFSYM (Qgnutls_dll, "gnutls");
8412 DEFSYM (Qlibxml2_dll, "libxml2");
8413 DEFSYM (Qserif, "serif");
8414 DEFSYM (Qzlib_dll, "zlib");
8415
8416 Fput (Qundefined_color, Qerror_conditions,
8417 listn (CONSTYPE_PURE, 2, Qundefined_color, Qerror));
8418 Fput (Qundefined_color, Qerror_message,
8419 build_pure_c_string ("Undefined color"));
8420
8421 staticpro (&w32_grabbed_keys);
8422 w32_grabbed_keys = Qnil;
8423
8424 DEFVAR_LISP ("w32-color-map", Vw32_color_map,
8425 doc: /* An array of color name mappings for Windows. */);
8426 Vw32_color_map = Qnil;
8427
8428 DEFVAR_LISP ("w32-pass-alt-to-system", Vw32_pass_alt_to_system,
8429 doc: /* Non-nil if Alt key presses are passed on to Windows.
8430 When non-nil, for example, Alt pressed and released and then space will
8431 open the System menu. When nil, Emacs processes the Alt key events, and
8432 then silently swallows them. */);
8433 Vw32_pass_alt_to_system = Qnil;
8434
8435 DEFVAR_LISP ("w32-alt-is-meta", Vw32_alt_is_meta,
8436 doc: /* Non-nil if the Alt key is to be considered the same as the META key.
8437 When nil, Emacs will translate the Alt key to the ALT modifier, not to META. */);
8438 Vw32_alt_is_meta = Qt;
8439
8440 DEFVAR_INT ("w32-quit-key", w32_quit_key,
8441 doc: /* If non-zero, the virtual key code for an alternative quit key. */);
8442 w32_quit_key = 0;
8443
8444 DEFVAR_LISP ("w32-pass-lwindow-to-system",
8445 Vw32_pass_lwindow_to_system,
8446 doc: /* If non-nil, the left \"Windows\" key is passed on to Windows.
8447
8448 When non-nil, the Start menu is opened by tapping the key.
8449 If you set this to nil, the left \"Windows\" key is processed by Emacs
8450 according to the value of `w32-lwindow-modifier', which see.
8451
8452 Note that some combinations of the left \"Windows\" key with other keys are
8453 caught by Windows at low level, and so binding them in Emacs will have no
8454 effect. For example, <lwindow>-r always pops up the Windows Run dialog,
8455 <lwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
8456 the doc string of `w32-phantom-key-code'. */);
8457 Vw32_pass_lwindow_to_system = Qt;
8458
8459 DEFVAR_LISP ("w32-pass-rwindow-to-system",
8460 Vw32_pass_rwindow_to_system,
8461 doc: /* If non-nil, the right \"Windows\" key is passed on to Windows.
8462
8463 When non-nil, the Start menu is opened by tapping the key.
8464 If you set this to nil, the right \"Windows\" key is processed by Emacs
8465 according to the value of `w32-rwindow-modifier', which see.
8466
8467 Note that some combinations of the right \"Windows\" key with other keys are
8468 caught by Windows at low level, and so binding them in Emacs will have no
8469 effect. For example, <rwindow>-r always pops up the Windows Run dialog,
8470 <rwindow>-<Pause> pops up the "System Properties" dialog, etc. However, see
8471 the doc string of `w32-phantom-key-code'. */);
8472 Vw32_pass_rwindow_to_system = Qt;
8473
8474 DEFVAR_LISP ("w32-phantom-key-code",
8475 Vw32_phantom_key_code,
8476 doc: /* Virtual key code used to generate \"phantom\" key presses.
8477 Value is a number between 0 and 255.
8478
8479 Phantom key presses are generated in order to stop the system from
8480 acting on \"Windows\" key events when `w32-pass-lwindow-to-system' or
8481 `w32-pass-rwindow-to-system' is nil. */);
8482 /* Although 255 is technically not a valid key code, it works and
8483 means that this hack won't interfere with any real key code. */
8484 XSETINT (Vw32_phantom_key_code, 255);
8485
8486 DEFVAR_LISP ("w32-enable-num-lock",
8487 Vw32_enable_num_lock,
8488 doc: /* If non-nil, the Num Lock key acts normally.
8489 Set to nil to handle Num Lock as the `kp-numlock' key. */);
8490 Vw32_enable_num_lock = Qt;
8491
8492 DEFVAR_LISP ("w32-enable-caps-lock",
8493 Vw32_enable_caps_lock,
8494 doc: /* If non-nil, the Caps Lock key acts normally.
8495 Set to nil to handle Caps Lock as the `capslock' key. */);
8496 Vw32_enable_caps_lock = Qt;
8497
8498 DEFVAR_LISP ("w32-scroll-lock-modifier",
8499 Vw32_scroll_lock_modifier,
8500 doc: /* Modifier to use for the Scroll Lock ON state.
8501 The value can be hyper, super, meta, alt, control or shift for the
8502 respective modifier, or nil to handle Scroll Lock as the `scroll' key.
8503 Any other value will cause the Scroll Lock key to be ignored. */);
8504 Vw32_scroll_lock_modifier = Qnil;
8505
8506 DEFVAR_LISP ("w32-lwindow-modifier",
8507 Vw32_lwindow_modifier,
8508 doc: /* Modifier to use for the left \"Windows\" key.
8509 The value can be hyper, super, meta, alt, control or shift for the
8510 respective modifier, or nil to appear as the `lwindow' key.
8511 Any other value will cause the key to be ignored. */);
8512 Vw32_lwindow_modifier = Qnil;
8513
8514 DEFVAR_LISP ("w32-rwindow-modifier",
8515 Vw32_rwindow_modifier,
8516 doc: /* Modifier to use for the right \"Windows\" key.
8517 The value can be hyper, super, meta, alt, control or shift for the
8518 respective modifier, or nil to appear as the `rwindow' key.
8519 Any other value will cause the key to be ignored. */);
8520 Vw32_rwindow_modifier = Qnil;
8521
8522 DEFVAR_LISP ("w32-apps-modifier",
8523 Vw32_apps_modifier,
8524 doc: /* Modifier to use for the \"Apps\" key.
8525 The value can be hyper, super, meta, alt, control or shift for the
8526 respective modifier, or nil to appear as the `apps' key.
8527 Any other value will cause the key to be ignored. */);
8528 Vw32_apps_modifier = Qnil;
8529
8530 DEFVAR_BOOL ("w32-enable-synthesized-fonts", w32_enable_synthesized_fonts,
8531 doc: /* Non-nil enables selection of artificially italicized and bold fonts. */);
8532 w32_enable_synthesized_fonts = 0;
8533
8534 DEFVAR_LISP ("w32-enable-palette", Vw32_enable_palette,
8535 doc: /* Non-nil enables Windows palette management to map colors exactly. */);
8536 Vw32_enable_palette = Qt;
8537
8538 DEFVAR_INT ("w32-mouse-button-tolerance",
8539 w32_mouse_button_tolerance,
8540 doc: /* Analogue of double click interval for faking middle mouse events.
8541 The value is the minimum time in milliseconds that must elapse between
8542 left and right button down events before they are considered distinct events.
8543 If both mouse buttons are depressed within this interval, a middle mouse
8544 button down event is generated instead. */);
8545 w32_mouse_button_tolerance = GetDoubleClickTime () / 2;
8546
8547 DEFVAR_INT ("w32-mouse-move-interval",
8548 w32_mouse_move_interval,
8549 doc: /* Minimum interval between mouse move events.
8550 The value is the minimum time in milliseconds that must elapse between
8551 successive mouse move (or scroll bar drag) events before they are
8552 reported as lisp events. */);
8553 w32_mouse_move_interval = 0;
8554
8555 DEFVAR_BOOL ("w32-pass-extra-mouse-buttons-to-system",
8556 w32_pass_extra_mouse_buttons_to_system,
8557 doc: /* If non-nil, the fourth and fifth mouse buttons are passed to Windows.
8558 Recent versions of Windows support mice with up to five buttons.
8559 Since most applications don't support these extra buttons, most mouse
8560 drivers will allow you to map them to functions at the system level.
8561 If this variable is non-nil, Emacs will pass them on, allowing the
8562 system to handle them. */);
8563 w32_pass_extra_mouse_buttons_to_system = 0;
8564
8565 DEFVAR_BOOL ("w32-pass-multimedia-buttons-to-system",
8566 w32_pass_multimedia_buttons_to_system,
8567 doc: /* If non-nil, media buttons are passed to Windows.
8568 Some modern keyboards contain buttons for controlling media players, web
8569 browsers and other applications. Generally these buttons are handled on a
8570 system wide basis, but by setting this to nil they are made available
8571 to Emacs for binding. Depending on your keyboard, additional keys that
8572 may be available are:
8573
8574 browser-back, browser-forward, browser-refresh, browser-stop,
8575 browser-search, browser-favorites, browser-home,
8576 mail, mail-reply, mail-forward, mail-send,
8577 app-1, app-2,
8578 help, find, new, open, close, save, print, undo, redo, copy, cut, paste,
8579 spell-check, correction-list, toggle-dictate-command,
8580 media-next, media-previous, media-stop, media-play-pause, media-select,
8581 media-play, media-pause, media-record, media-fast-forward, media-rewind,
8582 media-channel-up, media-channel-down,
8583 volume-mute, volume-up, volume-down,
8584 mic-volume-mute, mic-volume-down, mic-volume-up, mic-toggle,
8585 bass-down, bass-boost, bass-up, treble-down, treble-up */);
8586 w32_pass_multimedia_buttons_to_system = 1;
8587
8588 #if 0 /* TODO: Mouse cursor customization. */
8589 DEFVAR_LISP ("x-pointer-shape", Vx_pointer_shape,
8590 doc: /* The shape of the pointer when over text.
8591 Changing the value does not affect existing frames
8592 unless you set the mouse color. */);
8593 Vx_pointer_shape = Qnil;
8594
8595 Vx_nontext_pointer_shape = Qnil;
8596
8597 Vx_mode_pointer_shape = Qnil;
8598
8599 DEFVAR_LISP ("x-hourglass-pointer-shape", Vx_hourglass_pointer_shape,
8600 doc: /* The shape of the pointer when Emacs is busy.
8601 This variable takes effect when you create a new frame
8602 or when you set the mouse color. */);
8603 Vx_hourglass_pointer_shape = Qnil;
8604
8605 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
8606 Vx_sensitive_text_pointer_shape,
8607 doc: /* The shape of the pointer when over mouse-sensitive text.
8608 This variable takes effect when you create a new frame
8609 or when you set the mouse color. */);
8610 Vx_sensitive_text_pointer_shape = Qnil;
8611
8612 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
8613 Vx_window_horizontal_drag_shape,
8614 doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
8615 This variable takes effect when you create a new frame
8616 or when you set the mouse color. */);
8617 Vx_window_horizontal_drag_shape = Qnil;
8618
8619 DEFVAR_LISP ("x-window-vertical-drag-cursor",
8620 Vx_window_vertical_drag_shape,
8621 doc: /* Pointer shape to use for indicating a window can be dragged vertically.
8622 This variable takes effect when you create a new frame
8623 or when you set the mouse color. */);
8624 Vx_window_vertical_drag_shape = Qnil;
8625 #endif
8626
8627 DEFVAR_LISP ("x-cursor-fore-pixel", Vx_cursor_fore_pixel,
8628 doc: /* A string indicating the foreground color of the cursor box. */);
8629 Vx_cursor_fore_pixel = Qnil;
8630
8631 DEFVAR_LISP ("x-max-tooltip-size", Vx_max_tooltip_size,
8632 doc: /* Maximum size for tooltips.
8633 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
8634 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
8635
8636 DEFVAR_LISP ("x-no-window-manager", Vx_no_window_manager,
8637 doc: /* Non-nil if no window manager is in use.
8638 Emacs doesn't try to figure this out; this is always nil
8639 unless you set it to something else. */);
8640 /* We don't have any way to find this out, so set it to nil
8641 and maybe the user would like to set it to t. */
8642 Vx_no_window_manager = Qnil;
8643
8644 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
8645 Vx_pixel_size_width_font_regexp,
8646 doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
8647
8648 Since Emacs gets width of a font matching with this regexp from
8649 PIXEL_SIZE field of the name, font finding mechanism gets faster for
8650 such a font. This is especially effective for such large fonts as
8651 Chinese, Japanese, and Korean. */);
8652 Vx_pixel_size_width_font_regexp = Qnil;
8653
8654 DEFVAR_LISP ("w32-bdf-filename-alist",
8655 Vw32_bdf_filename_alist,
8656 doc: /* List of bdf fonts and their corresponding filenames. */);
8657 Vw32_bdf_filename_alist = Qnil;
8658
8659 DEFVAR_BOOL ("w32-strict-fontnames",
8660 w32_strict_fontnames,
8661 doc: /* Non-nil means only use fonts that are exact matches for those requested.
8662 Default is nil, which allows old fontnames that are not XLFD compliant,
8663 and allows third-party CJK display to work by specifying false charset
8664 fields to trick Emacs into translating to Big5, SJIS etc.
8665 Setting this to t will prevent wrong fonts being selected when
8666 fontsets are automatically created. */);
8667 w32_strict_fontnames = 0;
8668
8669 DEFVAR_BOOL ("w32-strict-painting",
8670 w32_strict_painting,
8671 doc: /* Non-nil means use strict rules for repainting frames.
8672 Set this to nil to get the old behavior for repainting; this should
8673 only be necessary if the default setting causes problems. */);
8674 w32_strict_painting = 1;
8675
8676 #if 0 /* TODO: Port to W32 */
8677 defsubr (&Sx_change_window_property);
8678 defsubr (&Sx_delete_window_property);
8679 defsubr (&Sx_window_property);
8680 #endif
8681 defsubr (&Sxw_display_color_p);
8682 defsubr (&Sx_display_grayscale_p);
8683 defsubr (&Sxw_color_defined_p);
8684 defsubr (&Sxw_color_values);
8685 defsubr (&Sx_server_max_request_size);
8686 defsubr (&Sx_server_vendor);
8687 defsubr (&Sx_server_version);
8688 defsubr (&Sx_display_pixel_width);
8689 defsubr (&Sx_display_pixel_height);
8690 defsubr (&Sx_display_mm_width);
8691 defsubr (&Sx_display_mm_height);
8692 defsubr (&Sx_display_screens);
8693 defsubr (&Sx_display_planes);
8694 defsubr (&Sx_display_color_cells);
8695 defsubr (&Sx_display_visual_class);
8696 defsubr (&Sx_display_backing_store);
8697 defsubr (&Sx_display_save_under);
8698 defsubr (&Sx_create_frame);
8699 defsubr (&Sx_open_connection);
8700 defsubr (&Sx_close_connection);
8701 defsubr (&Sx_display_list);
8702 defsubr (&Sx_frame_geometry);
8703 defsubr (&Sx_synchronize);
8704
8705 /* W32 specific functions */
8706
8707 defsubr (&Sw32_define_rgb_color);
8708 defsubr (&Sw32_default_color_map);
8709 defsubr (&Sw32_display_monitor_attributes_list);
8710 defsubr (&Sw32_send_sys_command);
8711 defsubr (&Sw32_shell_execute);
8712 defsubr (&Sw32_register_hot_key);
8713 defsubr (&Sw32_unregister_hot_key);
8714 defsubr (&Sw32_registered_hot_keys);
8715 defsubr (&Sw32_reconstruct_hot_key);
8716 defsubr (&Sw32_toggle_lock_key);
8717 defsubr (&Sw32_window_exists_p);
8718 defsubr (&Sw32_frame_rect);
8719 defsubr (&Sw32_frame_menu_bar_size);
8720 defsubr (&Sw32_battery_status);
8721 defsubr (&Sw32__menu_bar_in_use);
8722
8723 #ifdef WINDOWSNT
8724 defsubr (&Sfile_system_info);
8725 defsubr (&Sdefault_printer_name);
8726 #endif
8727
8728 defsubr (&Sset_message_beep);
8729 defsubr (&Sx_show_tip);
8730 defsubr (&Sx_hide_tip);
8731 tip_timer = Qnil;
8732 staticpro (&tip_timer);
8733 tip_frame = Qnil;
8734 staticpro (&tip_frame);
8735
8736 last_show_tip_args = Qnil;
8737 staticpro (&last_show_tip_args);
8738
8739 defsubr (&Sx_file_dialog);
8740 #ifdef WINDOWSNT
8741 defsubr (&Ssystem_move_file_to_trash);
8742 #endif
8743 }
8744
8745 \f
8746
8747 /* Crashing and reporting backtrace. */
8748
8749 #ifndef CYGWIN
8750 static LONG CALLBACK my_exception_handler (EXCEPTION_POINTERS *);
8751 static LPTOP_LEVEL_EXCEPTION_FILTER prev_exception_handler;
8752 #endif
8753 static DWORD except_code;
8754 static PVOID except_addr;
8755
8756 #ifndef CYGWIN
8757 /* This handler records the exception code and the address where it
8758 was triggered so that this info could be included in the backtrace.
8759 Without that, the backtrace in some cases has no information
8760 whatsoever about the offending code, and looks as if the top-level
8761 exception handler in the MinGW startup code di the one that
8762 crashed. */
8763 static LONG CALLBACK
8764 my_exception_handler (EXCEPTION_POINTERS * exception_data)
8765 {
8766 except_code = exception_data->ExceptionRecord->ExceptionCode;
8767 except_addr = exception_data->ExceptionRecord->ExceptionAddress;
8768
8769 if (prev_exception_handler)
8770 return prev_exception_handler (exception_data);
8771 return EXCEPTION_EXECUTE_HANDLER;
8772 }
8773 #endif
8774
8775 typedef USHORT (WINAPI * CaptureStackBackTrace_proc) (ULONG, ULONG, PVOID *,
8776 PULONG);
8777
8778 #define BACKTRACE_LIMIT_MAX 62
8779
8780 int
8781 w32_backtrace (void **buffer, int limit)
8782 {
8783 static CaptureStackBackTrace_proc s_pfn_CaptureStackBackTrace = NULL;
8784 HMODULE hm_kernel32 = NULL;
8785
8786 if (!s_pfn_CaptureStackBackTrace)
8787 {
8788 hm_kernel32 = LoadLibrary ("Kernel32.dll");
8789 s_pfn_CaptureStackBackTrace =
8790 (CaptureStackBackTrace_proc) GetProcAddress (hm_kernel32,
8791 "RtlCaptureStackBackTrace");
8792 }
8793 if (s_pfn_CaptureStackBackTrace)
8794 return s_pfn_CaptureStackBackTrace (0, min (BACKTRACE_LIMIT_MAX, limit),
8795 buffer, NULL);
8796 return 0;
8797 }
8798
8799 void
8800 emacs_abort (void)
8801 {
8802 int button;
8803 button = MessageBox (NULL,
8804 "A fatal error has occurred!\n\n"
8805 "Would you like to attach a debugger?\n\n"
8806 "Select:\n"
8807 "YES -- to debug Emacs, or\n"
8808 "NO -- to abort Emacs and produce a backtrace\n"
8809 " (emacs_backtrace.txt in current directory)."
8810 #if __GNUC__
8811 "\n\n(type \"gdb -p <emacs-PID>\" and\n"
8812 "\"continue\" inside GDB before clicking YES.)"
8813 #endif
8814 , "Emacs Abort Dialog",
8815 MB_ICONEXCLAMATION | MB_TASKMODAL
8816 | MB_SETFOREGROUND | MB_YESNO);
8817 switch (button)
8818 {
8819 case IDYES:
8820 DebugBreak ();
8821 exit (2); /* tell the compiler we will never return */
8822 case IDNO:
8823 default:
8824 {
8825 void *stack[BACKTRACE_LIMIT_MAX + 1];
8826 int i = w32_backtrace (stack, BACKTRACE_LIMIT_MAX + 1);
8827
8828 if (i)
8829 {
8830 int errfile_fd = -1;
8831 int j;
8832 char buf[sizeof ("\r\nException at this address:\r\n\r\n")
8833 /* The type below should really be 'void *', but
8834 INT_BUFSIZE_BOUND cannot handle that without
8835 triggering compiler warnings (under certain
8836 pedantic warning switches), it wants an
8837 integer type. */
8838 + 2 * INT_BUFSIZE_BOUND (intptr_t)];
8839 #ifdef CYGWIN
8840 int stderr_fd = 2;
8841 #else
8842 HANDLE errout = GetStdHandle (STD_ERROR_HANDLE);
8843 int stderr_fd = -1;
8844
8845 if (errout && errout != INVALID_HANDLE_VALUE)
8846 stderr_fd = _open_osfhandle ((intptr_t)errout, O_APPEND | O_BINARY);
8847 #endif
8848
8849 /* We use %p, not 0x%p, as %p produces a leading "0x" on XP,
8850 but not on Windows 7. addr2line doesn't mind a missing
8851 "0x", but will be confused by an extra one. */
8852 if (except_addr)
8853 sprintf (buf, "\r\nException 0x%lx at this address:\r\n%p\r\n",
8854 except_code, except_addr);
8855 if (stderr_fd >= 0)
8856 {
8857 if (except_addr)
8858 write (stderr_fd, buf, strlen (buf));
8859 write (stderr_fd, "\r\nBacktrace:\r\n", 14);
8860 }
8861 #ifdef CYGWIN
8862 #define _open open
8863 #endif
8864 errfile_fd = _open ("emacs_backtrace.txt", O_RDWR | O_CREAT | O_BINARY, S_IREAD | S_IWRITE);
8865 if (errfile_fd >= 0)
8866 {
8867 lseek (errfile_fd, 0L, SEEK_END);
8868 if (except_addr)
8869 write (errfile_fd, buf, strlen (buf));
8870 write (errfile_fd, "\r\nBacktrace:\r\n", 14);
8871 }
8872
8873 for (j = 0; j < i; j++)
8874 {
8875 /* stack[] gives the return addresses, whereas we want
8876 the address of the call, so decrease each address
8877 by approximate size of 1 CALL instruction. */
8878 sprintf (buf, "%p\r\n", (char *)stack[j] - sizeof(void *));
8879 if (stderr_fd >= 0)
8880 write (stderr_fd, buf, strlen (buf));
8881 if (errfile_fd >= 0)
8882 write (errfile_fd, buf, strlen (buf));
8883 }
8884 if (i == BACKTRACE_LIMIT_MAX)
8885 {
8886 if (stderr_fd >= 0)
8887 write (stderr_fd, "...\r\n", 5);
8888 if (errfile_fd >= 0)
8889 write (errfile_fd, "...\r\n", 5);
8890 }
8891 if (errfile_fd >= 0)
8892 close (errfile_fd);
8893 }
8894 abort ();
8895 break;
8896 }
8897 }
8898 }
8899
8900 \f
8901
8902 /* Initialization. */
8903
8904 /*
8905 globals_of_w32fns is used to initialize those global variables that
8906 must always be initialized on startup even when the global variable
8907 initialized is non zero (see the function main in emacs.c).
8908 globals_of_w32fns is called from syms_of_w32fns when the global
8909 variable initialized is 0 and directly from main when initialized
8910 is non zero.
8911 */
8912 void
8913 globals_of_w32fns (void)
8914 {
8915 HMODULE user32_lib = GetModuleHandle ("user32.dll");
8916 /*
8917 TrackMouseEvent not available in all versions of Windows, so must load
8918 it dynamically. Do it once, here, instead of every time it is used.
8919 */
8920 track_mouse_event_fn = (TrackMouseEvent_Proc)
8921 GetProcAddress (user32_lib, "TrackMouseEvent");
8922
8923 monitor_from_point_fn = (MonitorFromPoint_Proc)
8924 GetProcAddress (user32_lib, "MonitorFromPoint");
8925 get_monitor_info_fn = (GetMonitorInfo_Proc)
8926 GetProcAddress (user32_lib, "GetMonitorInfoA");
8927 monitor_from_window_fn = (MonitorFromWindow_Proc)
8928 GetProcAddress (user32_lib, "MonitorFromWindow");
8929 enum_display_monitors_fn = (EnumDisplayMonitors_Proc)
8930 GetProcAddress (user32_lib, "EnumDisplayMonitors");
8931
8932 {
8933 HMODULE imm32_lib = GetModuleHandle ("imm32.dll");
8934 get_composition_string_fn = (ImmGetCompositionString_Proc)
8935 GetProcAddress (imm32_lib, "ImmGetCompositionStringW");
8936 get_ime_context_fn = (ImmGetContext_Proc)
8937 GetProcAddress (imm32_lib, "ImmGetContext");
8938 release_ime_context_fn = (ImmReleaseContext_Proc)
8939 GetProcAddress (imm32_lib, "ImmReleaseContext");
8940 set_ime_composition_window_fn = (ImmSetCompositionWindow_Proc)
8941 GetProcAddress (imm32_lib, "ImmSetCompositionWindow");
8942 }
8943
8944 except_code = 0;
8945 except_addr = 0;
8946 #ifndef CYGWIN
8947 prev_exception_handler = SetUnhandledExceptionFilter (my_exception_handler);
8948 #endif
8949
8950 DEFVAR_INT ("w32-ansi-code-page",
8951 w32_ansi_code_page,
8952 doc: /* The ANSI code page used by the system. */);
8953 w32_ansi_code_page = GetACP ();
8954
8955 if (os_subtype == OS_NT)
8956 w32_unicode_gui = 1;
8957 else
8958 w32_unicode_gui = 0;
8959
8960 /* MessageBox does not work without this when linked to comctl32.dll 6.0. */
8961 InitCommonControls ();
8962
8963 syms_of_w32uniscribe ();
8964 }
8965
8966 #ifdef NTGUI_UNICODE
8967
8968 Lisp_Object
8969 ntgui_encode_system (Lisp_Object str)
8970 {
8971 Lisp_Object encoded;
8972 to_unicode (str, &encoded);
8973 return encoded;
8974 }
8975
8976 #endif /* NTGUI_UNICODE */