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