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