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