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