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