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