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