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