Merge from trunk.
[bpt/emacs.git] / src / w32term.c
1 /* Implementation of GUI terminal on the Microsoft Windows API.
2
3 Copyright (C) 1989, 1993-2013 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 3 of the License, or
10 (at your option) 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. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include <config.h>
21 #include <signal.h>
22 #include <stdio.h>
23 #include "lisp.h"
24 #include "blockinput.h"
25 #include "w32term.h"
26
27 #include "systty.h"
28 #include "systime.h"
29
30 #include <ctype.h>
31 #include <errno.h>
32 #include <sys/stat.h>
33 #include <imm.h>
34
35 #include "charset.h"
36 #include "character.h"
37 #include "coding.h"
38 #include "ccl.h"
39 #include "frame.h"
40 #include "dispextern.h"
41 #include "fontset.h"
42 #include "termhooks.h"
43 #include "termopts.h"
44 #include "termchar.h"
45 #include "disptab.h"
46 #include "buffer.h"
47 #include "window.h"
48 #include "keyboard.h"
49 #include "intervals.h"
50 #include "process.h"
51 #include "atimer.h"
52 #include "keymap.h"
53
54 #ifdef WINDOWSNT
55 #include "w32heap.h"
56 #endif
57
58 #ifndef WINDOWSNT
59 #include <io.h> /* for get_osfhandle */
60 #endif
61
62 #include <shellapi.h>
63
64 #include "font.h"
65 #include "w32font.h"
66 \f
67 /* Fringe bitmaps. */
68
69 static int max_fringe_bmp = 0;
70 static HBITMAP *fringe_bmp = 0;
71
72 /* Temporary variables for w32_read_socket. */
73
74 static int last_mousemove_x = 0;
75 static int last_mousemove_y = 0;
76
77 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
78 #ifndef GET_WHEEL_DELTA_WPARAM
79 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
80 #endif
81
82 /* Non-zero means that a HELP_EVENT has been generated since Emacs
83 start. */
84
85 static int any_help_event_p;
86
87 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
88 static Lisp_Object last_window;
89
90 extern unsigned int msh_mousewheel;
91
92 extern void free_frame_menubar (struct frame *);
93
94 extern int w32_codepage_for_font (char *fontname);
95 extern Cursor w32_load_cursor (LPCTSTR name);
96
97 #define x_any_window_to_frame x_window_to_frame
98 #define x_top_window_to_frame x_window_to_frame
99
100 \f
101 /* This is display since w32 does not support multiple ones. */
102 struct w32_display_info one_w32_display_info;
103 struct w32_display_info *x_display_list;
104
105 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
106 one for each element of w32_display_list and in the same order.
107 NAME is the name of the frame.
108 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
109 Lisp_Object w32_display_name_list;
110
111
112 #if _WIN32_WINNT < 0x0500 && !defined(_W64)
113 /* Pre Windows 2000, this was not available, but define it here so
114 that Emacs compiled on such a platform will run on newer versions.
115 MinGW64 (_W64) defines these unconditionally, so avoid redefining. */
116
117 typedef struct tagWCRANGE
118 {
119 WCHAR wcLow;
120 USHORT cGlyphs;
121 } WCRANGE;
122
123 typedef struct tagGLYPHSET
124 {
125 DWORD cbThis;
126 DWORD flAccel;
127 DWORD cGlyphsSupported;
128 DWORD cRanges;
129 WCRANGE ranges[1];
130 } GLYPHSET;
131
132 #endif /* compiling for pre-Win2k */
133
134 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
135 BOOL (WINAPI *pfnSetLayeredWindowAttributes) (HWND, COLORREF, BYTE, DWORD);
136
137 #ifndef LWA_ALPHA
138 #define LWA_ALPHA 0x02
139 #endif
140 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
141 later targets by MSVC headers. */
142 #ifndef WS_EX_LAYERED
143 #define WS_EX_LAYERED 0x80000
144 #endif
145
146 /* This is a frame waiting to be autoraised, within w32_read_socket. */
147 struct frame *pending_autoraise_frame;
148
149 /* The handle of the frame that currently owns the system caret. */
150 HWND w32_system_caret_hwnd;
151 int w32_system_caret_height;
152 int w32_system_caret_x;
153 int w32_system_caret_y;
154 DWORD dwWindowsThreadId = 0;
155 HANDLE hWindowsThread = NULL;
156 DWORD dwMainThreadId = 0;
157 HANDLE hMainThread = NULL;
158
159 int vertical_scroll_bar_min_handle;
160 int vertical_scroll_bar_top_border;
161 int vertical_scroll_bar_bottom_border;
162
163 int last_scroll_bar_drag_pos;
164
165 /* Keyboard code page - may be changed by language-change events. */
166 int w32_keyboard_codepage;
167
168 /* Mouse movement. */
169
170 /* Where the mouse was last time we reported a mouse event. */
171 static RECT last_mouse_glyph;
172 static FRAME_PTR last_mouse_glyph_frame;
173
174 /* The scroll bar in which the last motion event occurred.
175
176 If the last motion event occurred in a scroll bar, we set this
177 so w32_mouse_position can know whether to report a scroll bar motion or
178 an ordinary motion.
179
180 If the last motion event didn't occur in a scroll bar, we set this
181 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
182 static Lisp_Object last_mouse_scroll_bar;
183 static int last_mouse_scroll_bar_pos;
184
185 /* This is a hack. We would really prefer that w32_mouse_position would
186 return the time associated with the position it returns, but there
187 doesn't seem to be any way to wrest the time-stamp from the server
188 along with the position query. So, we just keep track of the time
189 of the last movement we received, and return that in hopes that
190 it's somewhat accurate. */
191 static Time last_mouse_movement_time;
192
193 /* Incremented by w32_read_socket whenever it really tries to read
194 events. */
195 static int volatile input_signal_count;
196
197 #ifdef CYGWIN
198 int w32_message_fd = -1;
199 #endif /* CYGWIN */
200
201 static void x_update_window_end (struct window *, int, int);
202 static void w32_handle_tool_bar_click (struct frame *,
203 struct input_event *);
204 static void w32_define_cursor (Window, Cursor);
205
206 void x_lower_frame (struct frame *);
207 void x_scroll_bar_clear (struct frame *);
208 void x_wm_set_size_hint (struct frame *, long, bool);
209 void x_raise_frame (struct frame *);
210 void x_set_window_size (struct frame *, int, int, int);
211 void x_wm_set_window_state (struct frame *, int);
212 void x_wm_set_icon_pixmap (struct frame *, int);
213 static void w32_initialize (void);
214 static void x_update_end (struct frame *);
215 static void w32_frame_up_to_date (struct frame *);
216 static void w32_set_terminal_modes (struct terminal *);
217 static void w32_reset_terminal_modes (struct terminal *);
218 static void x_clear_frame (struct frame *);
219 static void frame_highlight (struct frame *);
220 static void frame_unhighlight (struct frame *);
221 static void x_new_focus_frame (struct w32_display_info *,
222 struct frame *);
223 static void x_focus_changed (int, int, struct w32_display_info *,
224 struct frame *, struct input_event *);
225 static void w32_detect_focus_change (struct w32_display_info *,
226 W32Msg *, struct input_event *);
227 static void w32_frame_rehighlight (struct frame *);
228 static void x_frame_rehighlight (struct w32_display_info *);
229 static void x_draw_hollow_cursor (struct window *, struct glyph_row *);
230 static void x_draw_bar_cursor (struct window *, struct glyph_row *, int,
231 enum text_cursor_kinds);
232 static void w32_clip_to_row (struct window *, struct glyph_row *, int, HDC);
233 static BOOL my_show_window (struct frame *, HWND, int);
234 static void my_set_window_pos (HWND, HWND, int, int, int, int, UINT);
235 #if 0
236 static void my_set_focus (struct frame *, HWND);
237 #endif
238 static void my_set_foreground_window (HWND);
239 static void my_destroy_window (struct frame *, HWND);
240 static void w32fullscreen_hook (FRAME_PTR);
241
242 #ifdef GLYPH_DEBUG
243 static void x_check_font (struct frame *, struct font *);
244 #endif
245
246 static Lisp_Object Qvendor_specific_keysyms;
247 static Lisp_Object Qadded, Qremoved, Qmodified;
248 static Lisp_Object Qrenamed_from, Qrenamed_to;
249
250 \f
251 /***********************************************************************
252 Debugging
253 ***********************************************************************/
254
255 #if 0
256
257 /* This is a function useful for recording debugging information about
258 the sequence of occurrences in this file. */
259
260 struct record
261 {
262 char *locus;
263 int type;
264 };
265
266 struct record event_record[100];
267
268 int event_record_index;
269
270 record_event (char *locus, int type)
271 {
272 if (event_record_index == sizeof (event_record) / sizeof (struct record))
273 event_record_index = 0;
274
275 event_record[event_record_index].locus = locus;
276 event_record[event_record_index].type = type;
277 event_record_index++;
278 }
279
280 #endif /* 0 */
281 \f
282
283 void
284 XChangeGC (void *ignore, XGCValues *gc, unsigned long mask,
285 XGCValues *xgcv)
286 {
287 if (mask & GCForeground)
288 gc->foreground = xgcv->foreground;
289 if (mask & GCBackground)
290 gc->background = xgcv->background;
291 if (mask & GCFont)
292 gc->font = xgcv->font;
293 }
294
295 XGCValues *
296 XCreateGC (void *ignore, Window window, unsigned long mask, XGCValues *xgcv)
297 {
298 XGCValues *gc = xzalloc (sizeof (XGCValues));
299
300 XChangeGC (ignore, gc, mask, xgcv);
301
302 return gc;
303 }
304
305 void
306 XGetGCValues (void *ignore, XGCValues *gc,
307 unsigned long mask, XGCValues *xgcv)
308 {
309 XChangeGC (ignore, xgcv, mask, gc);
310 }
311
312 static void
313 w32_set_clip_rectangle (HDC hdc, RECT *rect)
314 {
315 if (rect)
316 {
317 HRGN clip_region = CreateRectRgnIndirect (rect);
318 SelectClipRgn (hdc, clip_region);
319 DeleteObject (clip_region);
320 }
321 else
322 SelectClipRgn (hdc, NULL);
323 }
324
325 /* Restore clipping rectangle in S */
326 static void
327 w32_restore_glyph_string_clip (struct glyph_string *s)
328 {
329 RECT *r = s->clip;
330 int n = s->num_clips;
331
332 if (n == 1)
333 w32_set_clip_rectangle (s->hdc, r);
334 else if (n > 1)
335 {
336 HRGN clip1 = CreateRectRgnIndirect (r);
337 HRGN clip2 = CreateRectRgnIndirect (r + 1);
338 if (CombineRgn (clip1, clip1, clip2, RGN_OR) != ERROR)
339 SelectClipRgn (s->hdc, clip1);
340 DeleteObject (clip1);
341 DeleteObject (clip2);
342 }
343 }
344
345 /*
346 Draw a wavy line under S. The wave fills wave_height pixels from y0.
347
348 x0 wave_length = 2
349 --
350 y0 * * * * *
351 |* * * * * * * * *
352 wave_height = 3 | * * * *
353
354 */
355
356 void
357 w32_draw_underwave (struct glyph_string *s, COLORREF color)
358 {
359 int wave_height = 3, wave_length = 2;
360 int dx, dy, x0, y0, width, x1, y1, x2, y2, odd, xmax;
361 XRectangle wave_clip, string_clip, final_clip;
362 RECT w32_final_clip, w32_string_clip;
363 HPEN hp, oldhp;
364
365 dx = wave_length;
366 dy = wave_height - 1;
367 x0 = s->x;
368 y0 = s->ybase - wave_height + 3;
369 width = s->width;
370 xmax = x0 + width;
371
372 /* Find and set clipping rectangle */
373
374 wave_clip.x = x0;
375 wave_clip.y = y0;
376 wave_clip.width = width;
377 wave_clip.height = wave_height;
378
379 get_glyph_string_clip_rect (s, &w32_string_clip);
380 CONVERT_TO_XRECT (string_clip, w32_string_clip);
381
382 if (!x_intersect_rectangles (&wave_clip, &string_clip, &final_clip))
383 return;
384
385 hp = CreatePen (PS_SOLID, 0, color);
386 oldhp = SelectObject (s->hdc, hp);
387 CONVERT_FROM_XRECT (final_clip, w32_final_clip);
388 w32_set_clip_rectangle (s->hdc, &w32_final_clip);
389
390 /* Draw the waves */
391
392 x1 = x0 - (x0 % dx);
393 x2 = x1 + dx;
394 odd = (x1/dx) % 2;
395 y1 = y2 = y0;
396
397 if (odd)
398 y1 += dy;
399 else
400 y2 += dy;
401
402 MoveToEx (s->hdc, x1, y1, NULL);
403
404 while (x1 <= xmax)
405 {
406 LineTo (s->hdc, x2, y2);
407 x1 = x2, y1 = y2;
408 x2 += dx, y2 = y0 + odd*dy;
409 odd = !odd;
410 }
411
412 /* Restore previous pen and clipping rectangle(s) */
413 w32_restore_glyph_string_clip (s);
414 SelectObject (s->hdc, oldhp);
415 DeleteObject (hp);
416 }
417
418 /* Draw a hollow rectangle at the specified position. */
419 void
420 w32_draw_rectangle (HDC hdc, XGCValues *gc, int x, int y,
421 int width, int height)
422 {
423 HBRUSH hb, oldhb;
424 HPEN hp, oldhp;
425
426 hb = CreateSolidBrush (gc->background);
427 hp = CreatePen (PS_SOLID, 0, gc->foreground);
428 oldhb = SelectObject (hdc, hb);
429 oldhp = SelectObject (hdc, hp);
430
431 Rectangle (hdc, x, y, x + width, y + height);
432
433 SelectObject (hdc, oldhb);
434 SelectObject (hdc, oldhp);
435 DeleteObject (hb);
436 DeleteObject (hp);
437 }
438
439 /* Draw a filled rectangle at the specified position. */
440 void
441 w32_fill_rect (FRAME_PTR f, HDC hdc, COLORREF pix, RECT *lprect)
442 {
443 HBRUSH hb;
444
445 hb = CreateSolidBrush (pix);
446 FillRect (hdc, lprect, hb);
447 DeleteObject (hb);
448 }
449
450 void
451 w32_clear_window (FRAME_PTR f)
452 {
453 RECT rect;
454 HDC hdc = get_frame_dc (f);
455
456 /* Under certain conditions, this can be called at startup with
457 a console frame pointer before the GUI frame is created. An HDC
458 of 0 indicates this. */
459 if (hdc)
460 {
461 GetClientRect (FRAME_W32_WINDOW (f), &rect);
462 w32_clear_rect (f, hdc, &rect);
463 }
464
465 release_frame_dc (f, hdc);
466 }
467
468 #define OPAQUE_FRAME 255
469
470 void
471 x_set_frame_alpha (struct frame *f)
472 {
473 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
474 double alpha = 1.0;
475 double alpha_min = 1.0;
476 BYTE opac;
477 LONG ex_style;
478 HWND window = FRAME_W32_WINDOW (f);
479
480 /* Older versions of Windows do not support transparency. */
481 if (!pfnSetLayeredWindowAttributes)
482 return;
483
484 if (dpyinfo->x_highlight_frame == f)
485 alpha = f->alpha[0];
486 else
487 alpha = f->alpha[1];
488
489 if (FLOATP (Vframe_alpha_lower_limit))
490 alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
491 else if (INTEGERP (Vframe_alpha_lower_limit))
492 alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
493
494 if (alpha < 0.0)
495 return;
496 else if (alpha > 1.0)
497 alpha = 1.0;
498 else if (alpha < alpha_min && alpha_min <= 1.0)
499 alpha = alpha_min;
500
501 opac = alpha * OPAQUE_FRAME;
502
503 ex_style = GetWindowLong (window, GWL_EXSTYLE);
504
505 if (opac == OPAQUE_FRAME)
506 ex_style &= ~WS_EX_LAYERED;
507 else
508 ex_style |= WS_EX_LAYERED;
509
510 SetWindowLong (window, GWL_EXSTYLE, ex_style);
511
512 if (opac != OPAQUE_FRAME)
513 pfnSetLayeredWindowAttributes (window, 0, opac, LWA_ALPHA);
514 }
515
516 int
517 x_display_pixel_height (struct w32_display_info *dpyinfo)
518 {
519 HDC dc = GetDC (NULL);
520 int pixels = GetDeviceCaps (dc, VERTRES);
521 ReleaseDC (NULL, dc);
522 return pixels;
523 }
524
525 int
526 x_display_pixel_width (struct w32_display_info *dpyinfo)
527 {
528 HDC dc = GetDC (NULL);
529 int pixels = GetDeviceCaps (dc, HORZRES);
530 ReleaseDC (NULL, dc);
531 return pixels;
532 }
533
534 \f
535 /***********************************************************************
536 Starting and ending an update
537 ***********************************************************************/
538
539 /* Start an update of frame F. This function is installed as a hook
540 for update_begin, i.e. it is called when update_begin is called.
541 This function is called prior to calls to x_update_window_begin for
542 each window being updated. */
543
544 static void
545 x_update_begin (struct frame *f)
546 {
547 struct w32_display_info *display_info = FRAME_W32_DISPLAY_INFO (f);
548
549 if (! FRAME_W32_P (f))
550 return;
551
552 /* Regenerate display palette before drawing if list of requested
553 colors has changed. */
554 if (display_info->regen_palette)
555 {
556 w32_regenerate_palette (f);
557 display_info->regen_palette = FALSE;
558 }
559 }
560
561
562 /* Start update of window W. Set the global variable updated_window
563 to the window being updated and set output_cursor to the cursor
564 position of W. */
565
566 static void
567 x_update_window_begin (struct window *w)
568 {
569 struct frame *f = XFRAME (WINDOW_FRAME (w));
570 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
571
572 /* Hide the system caret during an update. */
573 if (w32_use_visible_system_caret && w32_system_caret_hwnd)
574 {
575 SendMessage (w32_system_caret_hwnd, WM_EMACS_HIDE_CARET, 0, 0);
576 }
577
578 updated_window = w;
579 set_output_cursor (&w->cursor);
580
581 block_input ();
582
583 if (f == hlinfo->mouse_face_mouse_frame)
584 {
585 /* Don't do highlighting for mouse motion during the update. */
586 hlinfo->mouse_face_defer = 1;
587
588 /* If F needs to be redrawn, simply forget about any prior mouse
589 highlighting. */
590 if (FRAME_GARBAGED_P (f))
591 hlinfo->mouse_face_window = Qnil;
592
593 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
594 their mouse_face_p flag set, which means that they are always
595 unequal to rows in a desired matrix which never have that
596 flag set. So, rows containing mouse-face glyphs are never
597 scrolled, and we don't have to switch the mouse highlight off
598 here to prevent it from being scrolled. */
599
600 /* Can we tell that this update does not affect the window
601 where the mouse highlight is? If so, no need to turn off.
602 Likewise, don't do anything if the frame is garbaged;
603 in that case, the frame's current matrix that we would use
604 is all wrong, and we will redisplay that line anyway. */
605 if (!NILP (hlinfo->mouse_face_window)
606 && w == XWINDOW (hlinfo->mouse_face_window))
607 {
608 int i;
609
610 for (i = 0; i < w->desired_matrix->nrows; ++i)
611 if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
612 break;
613
614 if (i < w->desired_matrix->nrows)
615 clear_mouse_face (hlinfo);
616 }
617 #endif /* 0 */
618 }
619
620 unblock_input ();
621 }
622
623 /* Draw a vertical window border from (x,y0) to (x,y1) */
624
625 static void
626 w32_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
627 {
628 struct frame *f = XFRAME (WINDOW_FRAME (w));
629 RECT r;
630 HDC hdc;
631 struct face *face;
632
633 r.left = x;
634 r.right = x + 1;
635 r.top = y0;
636 r.bottom = y1;
637
638 hdc = get_frame_dc (f);
639 face = FACE_FROM_ID (f, VERTICAL_BORDER_FACE_ID);
640 if (face)
641 w32_fill_rect (f, hdc, face->foreground, &r);
642 else
643 w32_fill_rect (f, hdc, FRAME_FOREGROUND_PIXEL (f), &r);
644
645 release_frame_dc (f, hdc);
646 }
647
648
649 /* End update of window W (which is equal to updated_window).
650
651 Draw vertical borders between horizontally adjacent windows, and
652 display W's cursor if CURSOR_ON_P is non-zero.
653
654 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
655 glyphs in mouse-face were overwritten. In that case we have to
656 make sure that the mouse-highlight is properly redrawn.
657
658 W may be a menu bar pseudo-window in case we don't have X toolkit
659 support. Such windows don't have a cursor, so don't display it
660 here. */
661
662 static void
663 x_update_window_end (struct window *w, int cursor_on_p,
664 int mouse_face_overwritten_p)
665 {
666 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
667
668 if (!w->pseudo_window_p)
669 {
670 block_input ();
671
672 if (cursor_on_p)
673 display_and_set_cursor (w, 1, output_cursor.hpos,
674 output_cursor.vpos,
675 output_cursor.x, output_cursor.y);
676
677 if (draw_window_fringes (w, 1))
678 x_draw_vertical_border (w);
679
680 unblock_input ();
681 }
682
683 /* If a row with mouse-face was overwritten, arrange for
684 XTframe_up_to_date to redisplay the mouse highlight. */
685 if (mouse_face_overwritten_p)
686 {
687 hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
688 hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
689 hlinfo->mouse_face_window = Qnil;
690 }
691
692 /* Unhide the caret. This won't actually show the cursor, unless it
693 was visible before the corresponding call to HideCaret in
694 x_update_window_begin. */
695 if (w32_use_visible_system_caret && w32_system_caret_hwnd)
696 {
697 SendMessage (w32_system_caret_hwnd, WM_EMACS_SHOW_CARET, 0, 0);
698 }
699
700 updated_window = NULL;
701 }
702
703
704 /* End update of frame F. This function is installed as a hook in
705 update_end. */
706
707 static void
708 x_update_end (struct frame *f)
709 {
710 if (! FRAME_W32_P (f))
711 return;
712
713 /* Mouse highlight may be displayed again. */
714 MOUSE_HL_INFO (f)->mouse_face_defer = 0;
715 }
716
717
718 /* This function is called from various places in xdisp.c whenever a
719 complete update has been performed. The global variable
720 updated_window is not available here. */
721
722 static void
723 w32_frame_up_to_date (struct frame *f)
724 {
725 if (FRAME_W32_P (f))
726 FRAME_MOUSE_UPDATE (f);
727 }
728
729
730 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
731 arrow bitmaps, or clear the fringes if no bitmaps are required
732 before DESIRED_ROW is made current. The window being updated is
733 found in updated_window. This function is called from
734 update_window_line only if it is known that there are differences
735 between bitmaps to be drawn between current row and DESIRED_ROW. */
736
737 static void
738 x_after_update_window_line (struct glyph_row *desired_row)
739 {
740 struct window *w = updated_window;
741 struct frame *f;
742 int width, height;
743
744 eassert (w);
745
746 if (!desired_row->mode_line_p && !w->pseudo_window_p)
747 desired_row->redraw_fringe_bitmaps_p = 1;
748
749 /* When a window has disappeared, make sure that no rest of
750 full-width rows stays visible in the internal border. Could
751 check here if updated_window is the leftmost/rightmost window,
752 but I guess it's not worth doing since vertically split windows
753 are almost never used, internal border is rarely set, and the
754 overhead is very small. */
755 if (windows_or_buffers_changed
756 && desired_row->full_width_p
757 && (f = XFRAME (w->frame),
758 width = FRAME_INTERNAL_BORDER_WIDTH (f),
759 width != 0)
760 && (height = desired_row->visible_height,
761 height > 0))
762 {
763 int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
764
765 block_input ();
766 {
767 HDC hdc = get_frame_dc (f);
768 w32_clear_area (f, hdc, 0, y, width, height);
769 w32_clear_area (f, hdc, FRAME_PIXEL_WIDTH (f) - width,
770 y, width, height);
771 release_frame_dc (f, hdc);
772 }
773 unblock_input ();
774 }
775 }
776
777
778 /* Draw the bitmap WHICH in one of the left or right fringes of
779 window W. ROW is the glyph row for which to display the bitmap; it
780 determines the vertical position at which the bitmap has to be
781 drawn. */
782
783 static void
784 w32_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
785 struct draw_fringe_bitmap_params *p)
786 {
787 struct frame *f = XFRAME (WINDOW_FRAME (w));
788 HDC hdc;
789 struct face *face = p->face;
790
791 hdc = get_frame_dc (f);
792
793 if (!p->overlay_p)
794 {
795 int bx = p->bx, by = p->by, nx = p->nx, ny = p->ny;
796
797 /* If the fringe is adjacent to the left (right) scroll bar of a
798 leftmost (rightmost, respectively) window, then extend its
799 background to the gap between the fringe and the bar. */
800 if ((WINDOW_LEFTMOST_P (w)
801 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
802 || (WINDOW_RIGHTMOST_P (w)
803 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)))
804 {
805 int sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
806
807 if (sb_width > 0)
808 {
809 int bar_area_x = WINDOW_SCROLL_BAR_AREA_X (w);
810 int bar_area_width = (WINDOW_CONFIG_SCROLL_BAR_COLS (w)
811 * FRAME_COLUMN_WIDTH (f));
812
813 if (bx < 0)
814 {
815 /* Bitmap fills the fringe. */
816 if (bar_area_x + bar_area_width == p->x)
817 bx = bar_area_x + sb_width;
818 else if (p->x + p->wd == bar_area_x)
819 bx = bar_area_x;
820 if (bx >= 0)
821 {
822 int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
823
824 nx = bar_area_width - sb_width;
825 by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
826 row->y));
827 ny = row->visible_height;
828 }
829 }
830 else
831 {
832 if (bar_area_x + bar_area_width == bx)
833 {
834 bx = bar_area_x + sb_width;
835 nx += bar_area_width - sb_width;
836 }
837 else if (bx + nx == bar_area_x)
838 nx += bar_area_width - sb_width;
839 }
840 }
841 }
842
843 if (bx >= 0 && nx > 0)
844 w32_fill_area (f, hdc, face->background, bx, by, nx, ny);
845 }
846
847 /* Must clip because of partially visible lines. */
848 w32_clip_to_row (w, row, -1, hdc);
849
850 if (p->which && p->which < max_fringe_bmp)
851 {
852 HBITMAP pixmap = fringe_bmp[p->which];
853 HDC compat_hdc;
854 HANDLE horig_obj;
855
856 compat_hdc = CreateCompatibleDC (hdc);
857
858 SaveDC (hdc);
859
860 horig_obj = SelectObject (compat_hdc, pixmap);
861
862 /* Paint overlays transparently. */
863 if (p->overlay_p)
864 {
865 HBRUSH h_brush, h_orig_brush;
866
867 SetTextColor (hdc, BLACK_PIX_DEFAULT (f));
868 SetBkColor (hdc, WHITE_PIX_DEFAULT (f));
869 h_brush = CreateSolidBrush (face->foreground);
870 h_orig_brush = SelectObject (hdc, h_brush);
871
872 BitBlt (hdc, p->x, p->y, p->wd, p->h,
873 compat_hdc, 0, p->dh,
874 DSTINVERT);
875 BitBlt (hdc, p->x, p->y, p->wd, p->h,
876 compat_hdc, 0, p->dh,
877 0x2E064A);
878 BitBlt (hdc, p->x, p->y, p->wd, p->h,
879 compat_hdc, 0, p->dh,
880 DSTINVERT);
881
882 SelectObject (hdc, h_orig_brush);
883 DeleteObject (h_brush);
884 }
885 else
886 {
887 SetTextColor (hdc, face->background);
888 SetBkColor (hdc, (p->cursor_p
889 ? f->output_data.w32->cursor_pixel
890 : face->foreground));
891
892 BitBlt (hdc, p->x, p->y, p->wd, p->h,
893 compat_hdc, 0, p->dh,
894 SRCCOPY);
895 }
896
897 SelectObject (compat_hdc, horig_obj);
898 DeleteDC (compat_hdc);
899 RestoreDC (hdc, -1);
900 }
901
902 w32_set_clip_rectangle (hdc, NULL);
903
904 release_frame_dc (f, hdc);
905 }
906
907 static void
908 w32_define_fringe_bitmap (int which, unsigned short *bits, int h, int wd)
909 {
910 if (which >= max_fringe_bmp)
911 {
912 int i = max_fringe_bmp;
913 max_fringe_bmp = which + 20;
914 fringe_bmp = (HBITMAP *) xrealloc (fringe_bmp, max_fringe_bmp * sizeof (HBITMAP));
915 while (i < max_fringe_bmp)
916 fringe_bmp[i++] = 0;
917 }
918
919 fringe_bmp[which] = CreateBitmap (wd, h, 1, 1, bits);
920 }
921
922 static void
923 w32_destroy_fringe_bitmap (int which)
924 {
925 if (which >= max_fringe_bmp)
926 return;
927
928 if (fringe_bmp[which])
929 DeleteObject (fringe_bmp[which]);
930 fringe_bmp[which] = 0;
931 }
932
933
934 \f
935 /* This is called when starting Emacs and when restarting after
936 suspend. When starting Emacs, no window is mapped. And nothing
937 must be done to Emacs's own window if it is suspended (though that
938 rarely happens). */
939
940 static void
941 w32_set_terminal_modes (struct terminal *term)
942 {
943 }
944
945 /* This is called when exiting or suspending Emacs. Exiting will make
946 the W32 windows go away, and suspending requires no action. */
947
948 static void
949 w32_reset_terminal_modes (struct terminal *term)
950 {
951 }
952
953
954 \f
955 /***********************************************************************
956 Display Iterator
957 ***********************************************************************/
958
959 /* Function prototypes of this page. */
960
961 static void x_set_glyph_string_clipping (struct glyph_string *);
962 static void x_set_glyph_string_gc (struct glyph_string *);
963 static void x_draw_glyph_string_background (struct glyph_string *,
964 int);
965 static void x_draw_glyph_string_foreground (struct glyph_string *);
966 static void x_draw_composite_glyph_string_foreground (struct glyph_string *);
967 static void x_draw_glyph_string_box (struct glyph_string *);
968 static void x_draw_glyph_string (struct glyph_string *);
969 static void x_set_cursor_gc (struct glyph_string *);
970 static void x_set_mode_line_face_gc (struct glyph_string *);
971 static void x_set_mouse_face_gc (struct glyph_string *);
972 static int w32_alloc_lighter_color (struct frame *, COLORREF *, double, int);
973 static void w32_setup_relief_color (struct frame *, struct relief *,
974 double, int, COLORREF);
975 static void x_setup_relief_colors (struct glyph_string *);
976 static void x_draw_image_glyph_string (struct glyph_string *);
977 static void x_draw_image_relief (struct glyph_string *);
978 static void x_draw_image_foreground (struct glyph_string *);
979 static void w32_draw_image_foreground_1 (struct glyph_string *, HBITMAP);
980 static void x_clear_glyph_string_rect (struct glyph_string *, int,
981 int, int, int);
982 static void w32_draw_relief_rect (struct frame *, int, int, int, int,
983 int, int, int, int, int, int,
984 RECT *);
985 static void w32_draw_box_rect (struct glyph_string *, int, int, int, int,
986 int, int, int, RECT *);
987
988
989 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
990 face. */
991
992 static void
993 x_set_cursor_gc (struct glyph_string *s)
994 {
995 if (s->font == FRAME_FONT (s->f)
996 && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
997 && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
998 && !s->cmp)
999 s->gc = s->f->output_data.w32->cursor_gc;
1000 else
1001 {
1002 /* Cursor on non-default face: must merge. */
1003 XGCValues xgcv;
1004 unsigned long mask;
1005
1006 xgcv.background = s->f->output_data.w32->cursor_pixel;
1007 xgcv.foreground = s->face->background;
1008
1009 /* If the glyph would be invisible, try a different foreground. */
1010 if (xgcv.foreground == xgcv.background)
1011 xgcv.foreground = s->face->foreground;
1012 if (xgcv.foreground == xgcv.background)
1013 xgcv.foreground = s->f->output_data.w32->cursor_foreground_pixel;
1014 if (xgcv.foreground == xgcv.background)
1015 xgcv.foreground = s->face->foreground;
1016
1017 /* Make sure the cursor is distinct from text in this face. */
1018 if (xgcv.background == s->face->background
1019 && xgcv.foreground == s->face->foreground)
1020 {
1021 xgcv.background = s->face->foreground;
1022 xgcv.foreground = s->face->background;
1023 }
1024
1025 IF_DEBUG (x_check_font (s->f, s->font));
1026 xgcv.font = s->font;
1027 mask = GCForeground | GCBackground | GCFont;
1028
1029 if (FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc)
1030 XChangeGC (NULL, FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc,
1031 mask, &xgcv);
1032 else
1033 FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc
1034 = XCreateGC (NULL, s->window, mask, &xgcv);
1035
1036 s->gc = FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc;
1037 }
1038 }
1039
1040
1041 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1042
1043 static void
1044 x_set_mouse_face_gc (struct glyph_string *s)
1045 {
1046 int face_id;
1047 struct face *face;
1048
1049 /* What face has to be used last for the mouse face? */
1050 face_id = MOUSE_HL_INFO (s->f)->mouse_face_face_id;
1051 face = FACE_FROM_ID (s->f, face_id);
1052 if (face == NULL)
1053 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
1054
1055 if (s->first_glyph->type == CHAR_GLYPH)
1056 face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch, -1, Qnil);
1057 else
1058 face_id = FACE_FOR_CHAR (s->f, face, 0, -1, Qnil);
1059 s->face = FACE_FROM_ID (s->f, face_id);
1060 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
1061
1062 /* If font in this face is same as S->font, use it. */
1063 if (s->font == s->face->font)
1064 s->gc = s->face->gc;
1065 else
1066 {
1067 /* Otherwise construct scratch_cursor_gc with values from FACE
1068 but font FONT. */
1069 XGCValues xgcv;
1070 unsigned long mask;
1071
1072 xgcv.background = s->face->background;
1073 xgcv.foreground = s->face->foreground;
1074 IF_DEBUG (x_check_font (s->f, s->font));
1075 xgcv.font = s->font;
1076 mask = GCForeground | GCBackground | GCFont;
1077
1078 if (FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc)
1079 XChangeGC (NULL, FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc,
1080 mask, &xgcv);
1081 else
1082 FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc
1083 = XCreateGC (NULL, s->window, mask, &xgcv);
1084
1085 s->gc = FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc;
1086 }
1087
1088 eassert (s->gc != 0);
1089 }
1090
1091
1092 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1093 Faces to use in the mode line have already been computed when the
1094 matrix was built, so there isn't much to do, here. */
1095
1096 static inline void
1097 x_set_mode_line_face_gc (struct glyph_string *s)
1098 {
1099 s->gc = s->face->gc;
1100 }
1101
1102
1103 /* Set S->gc of glyph string S for drawing that glyph string. Set
1104 S->stippled_p to a non-zero value if the face of S has a stipple
1105 pattern. */
1106
1107 static inline void
1108 x_set_glyph_string_gc (struct glyph_string *s)
1109 {
1110 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
1111
1112 if (s->hl == DRAW_NORMAL_TEXT)
1113 {
1114 s->gc = s->face->gc;
1115 s->stippled_p = s->face->stipple != 0;
1116 }
1117 else if (s->hl == DRAW_INVERSE_VIDEO)
1118 {
1119 x_set_mode_line_face_gc (s);
1120 s->stippled_p = s->face->stipple != 0;
1121 }
1122 else if (s->hl == DRAW_CURSOR)
1123 {
1124 x_set_cursor_gc (s);
1125 s->stippled_p = 0;
1126 }
1127 else if (s->hl == DRAW_MOUSE_FACE)
1128 {
1129 x_set_mouse_face_gc (s);
1130 s->stippled_p = s->face->stipple != 0;
1131 }
1132 else if (s->hl == DRAW_IMAGE_RAISED
1133 || s->hl == DRAW_IMAGE_SUNKEN)
1134 {
1135 s->gc = s->face->gc;
1136 s->stippled_p = s->face->stipple != 0;
1137 }
1138 else
1139 {
1140 s->gc = s->face->gc;
1141 s->stippled_p = s->face->stipple != 0;
1142 }
1143
1144 /* GC must have been set. */
1145 eassert (s->gc != 0);
1146 }
1147
1148
1149 /* Set clipping for output of glyph string S. S may be part of a mode
1150 line or menu if we don't have X toolkit support. */
1151
1152 static inline void
1153 x_set_glyph_string_clipping (struct glyph_string *s)
1154 {
1155 RECT *r = s->clip;
1156 int n = get_glyph_string_clip_rects (s, r, 2);
1157
1158 if (n == 1)
1159 w32_set_clip_rectangle (s->hdc, r);
1160 else if (n > 1)
1161 {
1162 HRGN clip1 = CreateRectRgnIndirect (r);
1163 HRGN clip2 = CreateRectRgnIndirect (r + 1);
1164 if (CombineRgn (clip1, clip1, clip2, RGN_OR) != ERROR)
1165 SelectClipRgn (s->hdc, clip1);
1166 DeleteObject (clip1);
1167 DeleteObject (clip2);
1168 }
1169 s->num_clips = n;
1170 }
1171
1172 /* Set SRC's clipping for output of glyph string DST. This is called
1173 when we are drawing DST's left_overhang or right_overhang only in
1174 the area of SRC. */
1175
1176 static void
1177 x_set_glyph_string_clipping_exactly (struct glyph_string *src,
1178 struct glyph_string *dst)
1179 {
1180 RECT r;
1181
1182 r.left = src->x;
1183 r.right = r.left + src->width;
1184 r.top = src->y;
1185 r.bottom = r.top + src->height;
1186 dst->clip[0] = r;
1187 dst->num_clips = 1;
1188 w32_set_clip_rectangle (dst->hdc, &r);
1189 }
1190
1191 /* RIF:
1192 Compute left and right overhang of glyph string S. */
1193
1194 static void
1195 w32_compute_glyph_string_overhangs (struct glyph_string *s)
1196 {
1197 if (s->cmp == NULL
1198 && s->first_glyph->type == CHAR_GLYPH
1199 && !s->font_not_found_p)
1200 {
1201 unsigned *code = alloca (sizeof (unsigned) * s->nchars);
1202 struct font *font = s->font;
1203 struct font_metrics metrics;
1204 int i;
1205
1206 for (i = 0; i < s->nchars; i++)
1207 code[i] = s->char2b[i];
1208 font->driver->text_extents (font, code, s->nchars, &metrics);
1209 s->right_overhang = (metrics.rbearing > metrics.width
1210 ? metrics.rbearing - metrics.width : 0);
1211 s->left_overhang = metrics.lbearing < 0 ? -metrics.lbearing : 0;
1212 }
1213 else if (s->cmp)
1214 {
1215 s->right_overhang = s->cmp->rbearing - s->cmp->pixel_width;
1216 s->left_overhang = -s->cmp->lbearing;
1217 }
1218 }
1219
1220 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1221
1222 static inline void
1223 x_clear_glyph_string_rect (struct glyph_string *s,
1224 int x, int y, int w, int h)
1225 {
1226 int real_x = x;
1227 int real_y = y;
1228 int real_w = w;
1229 int real_h = h;
1230 #if 0
1231 /* Take clipping into account. */
1232 if (s->gc->clip_mask == Rect)
1233 {
1234 real_x = max (real_x, s->gc->clip_rectangle.left);
1235 real_y = max (real_y, s->gc->clip_rectangle.top);
1236 real_w = min (real_w, s->gc->clip_rectangle.right
1237 - s->gc->clip_rectangle.left);
1238 real_h = min (real_h, s->gc->clip_rectangle.bottom
1239 - s->gc->clip_rectangle.top);
1240 }
1241 #endif
1242 w32_fill_area (s->f, s->hdc, s->gc->background, real_x, real_y,
1243 real_w, real_h);
1244 }
1245
1246
1247 /* Draw the background of glyph_string S. If S->background_filled_p
1248 is non-zero don't draw it. FORCE_P non-zero means draw the
1249 background even if it wouldn't be drawn normally. This is used
1250 when a string preceding S draws into the background of S, or S
1251 contains the first component of a composition. */
1252
1253 static void
1254 x_draw_glyph_string_background (struct glyph_string *s, int force_p)
1255 {
1256 /* Nothing to do if background has already been drawn or if it
1257 shouldn't be drawn in the first place. */
1258 if (!s->background_filled_p)
1259 {
1260 int box_line_width = max (s->face->box_line_width, 0);
1261
1262 #if 0 /* TODO: stipple */
1263 if (s->stippled_p)
1264 {
1265 /* Fill background with a stipple pattern. */
1266 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
1267 XFillRectangle (s->display, s->window, s->gc, s->x,
1268 s->y + box_line_width,
1269 s->background_width,
1270 s->height - 2 * box_line_width);
1271 XSetFillStyle (s->display, s->gc, FillSolid);
1272 s->background_filled_p = 1;
1273 }
1274 else
1275 #endif
1276 if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
1277 || s->font_not_found_p
1278 || s->extends_to_end_of_line_p
1279 || force_p)
1280 {
1281 x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
1282 s->background_width,
1283 s->height - 2 * box_line_width);
1284 s->background_filled_p = 1;
1285 }
1286 }
1287 }
1288
1289
1290 /* Draw the foreground of glyph string S. */
1291
1292 static void
1293 x_draw_glyph_string_foreground (struct glyph_string *s)
1294 {
1295 int i, x;
1296
1297 /* If first glyph of S has a left box line, start drawing the text
1298 of S to the right of that box line. */
1299 if (s->face->box != FACE_NO_BOX
1300 && s->first_glyph->left_box_line_p)
1301 x = s->x + eabs (s->face->box_line_width);
1302 else
1303 x = s->x;
1304
1305 SetTextColor (s->hdc, s->gc->foreground);
1306 SetBkColor (s->hdc, s->gc->background);
1307 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1308
1309 /* Draw characters of S as rectangles if S's font could not be
1310 loaded. */
1311 if (s->font_not_found_p)
1312 {
1313 for (i = 0; i < s->nchars; ++i)
1314 {
1315 struct glyph *g = s->first_glyph + i;
1316
1317 w32_draw_rectangle (s->hdc, s->gc, x, s->y, g->pixel_width - 1,
1318 s->height - 1);
1319 x += g->pixel_width;
1320 }
1321 }
1322 else
1323 {
1324 struct font *font = s->font;
1325 int boff = font->baseline_offset;
1326 int y;
1327 HFONT old_font;
1328
1329 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1330
1331 if (font->vertical_centering)
1332 boff = VCENTER_BASELINE_OFFSET (font, s->f) - boff;
1333
1334 y = s->ybase - boff;
1335 if (s->for_overlaps
1336 || (s->background_filled_p && s->hl != DRAW_CURSOR))
1337 font->driver->draw (s, 0, s->nchars, x, y, 0);
1338 else
1339 font->driver->draw (s, 0, s->nchars, x, y, 1);
1340 if (s->face->overstrike)
1341 font->driver->draw (s, 0, s->nchars, x + 1, y, 0);
1342
1343 SelectObject (s->hdc, old_font);
1344 }
1345 }
1346
1347 /* Draw the foreground of composite glyph string S. */
1348
1349 static void
1350 x_draw_composite_glyph_string_foreground (struct glyph_string *s)
1351 {
1352 int i, j, x;
1353 struct font *font = s->font;
1354
1355 /* If first glyph of S has a left box line, start drawing the text
1356 of S to the right of that box line. */
1357 if (s->face && s->face->box != FACE_NO_BOX
1358 && s->first_glyph->left_box_line_p)
1359 x = s->x + eabs (s->face->box_line_width);
1360 else
1361 x = s->x;
1362
1363 /* S is a glyph string for a composition. S->cmp_from is the index
1364 of the first character drawn for glyphs of this composition.
1365 S->cmp_from == 0 means we are drawing the very first character of
1366 this composition. */
1367
1368 SetTextColor (s->hdc, s->gc->foreground);
1369 SetBkColor (s->hdc, s->gc->background);
1370 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1371
1372 /* Draw a rectangle for the composition if the font for the very
1373 first character of the composition could not be loaded. */
1374 if (s->font_not_found_p)
1375 {
1376 if (s->cmp_from == 0)
1377 w32_draw_rectangle (s->hdc, s->gc, x, s->y, s->width - 1,
1378 s->height - 1);
1379 }
1380 else if (! s->first_glyph->u.cmp.automatic)
1381 {
1382 int y = s->ybase;
1383 HFONT old_font;
1384
1385 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1386
1387 for (i = 0, j = s->cmp_from; i < s->nchars; i++, j++)
1388 /* TAB in a composition means display glyphs with padding
1389 space on the left or right. */
1390 if (COMPOSITION_GLYPH (s->cmp, j) != '\t')
1391 {
1392 int xx = x + s->cmp->offsets[j * 2];
1393 int yy = y - s->cmp->offsets[j * 2 + 1];
1394
1395 font->driver->draw (s, j, j + 1, xx, yy, 0);
1396 if (s->face->overstrike)
1397 font->driver->draw (s, j, j + 1, xx + 1, yy, 0);
1398 }
1399 SelectObject (s->hdc, old_font);
1400 }
1401 else
1402 {
1403 Lisp_Object gstring = composition_gstring_from_id (s->cmp_id);
1404 Lisp_Object glyph;
1405 int y = s->ybase;
1406 int width = 0;
1407 HFONT old_font;
1408
1409 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1410
1411 for (i = j = s->cmp_from; i < s->cmp_to; i++)
1412 {
1413 glyph = LGSTRING_GLYPH (gstring, i);
1414 if (NILP (LGLYPH_ADJUSTMENT (glyph)))
1415 width += LGLYPH_WIDTH (glyph);
1416 else
1417 {
1418 int xoff, yoff, wadjust;
1419
1420 if (j < i)
1421 {
1422 font->driver->draw (s, j, i, x, y, 0);
1423 x += width;
1424 }
1425 xoff = LGLYPH_XOFF (glyph);
1426 yoff = LGLYPH_YOFF (glyph);
1427 wadjust = LGLYPH_WADJUST (glyph);
1428 font->driver->draw (s, i, i + 1, x + xoff, y + yoff, 0);
1429 x += wadjust;
1430 j = i + 1;
1431 width = 0;
1432 }
1433 }
1434 if (j < i)
1435 font->driver->draw (s, j, i, x, y, 0);
1436
1437 SelectObject (s->hdc, old_font);
1438 }
1439 }
1440
1441
1442 /* Draw the foreground of glyph string S for glyphless characters. */
1443
1444 static void
1445 x_draw_glyphless_glyph_string_foreground (struct glyph_string *s)
1446 {
1447 struct glyph *glyph = s->first_glyph;
1448 XChar2b char2b[8];
1449 int x, i, j;
1450 int with_background;
1451
1452 /* If first glyph of S has a left box line, start drawing the text
1453 of S to the right of that box line. */
1454 if (s->face->box != FACE_NO_BOX
1455 && s->first_glyph->left_box_line_p)
1456 x = s->x + eabs (s->face->box_line_width);
1457 else
1458 x = s->x;
1459
1460 SetTextColor (s->hdc, s->gc->foreground);
1461 SetBkColor (s->hdc, s->gc->background);
1462 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1463
1464 s->char2b = char2b;
1465 with_background = ! (s->for_overlaps
1466 || (s->background_filled_p && s->hl != DRAW_CURSOR));
1467 for (i = 0; i < s->nchars; i++, glyph++)
1468 {
1469 char buf[7], *str = NULL;
1470 int len = glyph->u.glyphless.len;
1471
1472 if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_ACRONYM)
1473 {
1474 if (len > 1
1475 && CHAR_TABLE_P (Vglyphless_char_display)
1476 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display))
1477 >= 1))
1478 {
1479 Lisp_Object acronym
1480 = (! glyph->u.glyphless.for_no_font
1481 ? CHAR_TABLE_REF (Vglyphless_char_display,
1482 glyph->u.glyphless.ch)
1483 : XCHAR_TABLE (Vglyphless_char_display)->extras[0]);
1484 if (STRINGP (acronym))
1485 str = SSDATA (acronym);
1486 }
1487 }
1488 else if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_HEX_CODE)
1489 {
1490 sprintf ((char *) buf, "%0*X",
1491 glyph->u.glyphless.ch < 0x10000 ? 4 : 6,
1492 glyph->u.glyphless.ch);
1493 str = buf;
1494 }
1495
1496 if (glyph->u.glyphless.method != GLYPHLESS_DISPLAY_THIN_SPACE)
1497 w32_draw_rectangle (s->hdc, s->gc,
1498 x, s->ybase - glyph->ascent,
1499 glyph->pixel_width - 1,
1500 glyph->ascent + glyph->descent - 1);
1501 if (str)
1502 {
1503 struct font *font = s->font;
1504 int upper_len = (len + 1) / 2;
1505 unsigned code;
1506 HFONT old_font;
1507
1508 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1509 /* It is certain that all LEN characters in STR are ASCII. */
1510 for (j = 0; j < len; j++)
1511 {
1512 code = font->driver->encode_char (font, str[j]);
1513 STORE_XCHAR2B (char2b + j, code >> 8, code & 0xFF);
1514 }
1515 font->driver->draw (s, 0, upper_len,
1516 x + glyph->slice.glyphless.upper_xoff,
1517 s->ybase + glyph->slice.glyphless.upper_yoff,
1518 with_background);
1519 font->driver->draw (s, upper_len, len,
1520 x + glyph->slice.glyphless.lower_xoff,
1521 s->ybase + glyph->slice.glyphless.lower_yoff,
1522 with_background);
1523 SelectObject (s->hdc, old_font);
1524 }
1525 x += glyph->pixel_width;
1526 }
1527 }
1528
1529
1530 /* Brightness beyond which a color won't have its highlight brightness
1531 boosted.
1532
1533 Nominally, highlight colors for `3d' faces are calculated by
1534 brightening an object's color by a constant scale factor, but this
1535 doesn't yield good results for dark colors, so for colors whose
1536 brightness is less than this value (on a scale of 0-255) have to
1537 use an additional additive factor.
1538
1539 The value here is set so that the default menu-bar/mode-line color
1540 (grey75) will not have its highlights changed at all. */
1541 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1542
1543
1544 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1545 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1546 If this produces the same color as COLOR, try a color where all RGB
1547 values have DELTA added. Return the allocated color in *COLOR.
1548 DISPLAY is the X display, CMAP is the colormap to operate on.
1549 Value is non-zero if successful. */
1550
1551 static int
1552 w32_alloc_lighter_color (struct frame *f, COLORREF *color,
1553 double factor, int delta)
1554 {
1555 COLORREF new;
1556 long bright;
1557
1558 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1559 delta /= 256;
1560
1561 /* Change RGB values by specified FACTOR. Avoid overflow! */
1562 eassert (factor >= 0);
1563 new = PALETTERGB (min (0xff, factor * GetRValue (*color)),
1564 min (0xff, factor * GetGValue (*color)),
1565 min (0xff, factor * GetBValue (*color)));
1566
1567 /* Calculate brightness of COLOR. */
1568 bright = (2 * GetRValue (*color) + 3 * GetGValue (*color)
1569 + GetBValue (*color)) / 6;
1570
1571 /* We only boost colors that are darker than
1572 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1573 if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
1574 /* Make an additive adjustment to NEW, because it's dark enough so
1575 that scaling by FACTOR alone isn't enough. */
1576 {
1577 /* How far below the limit this color is (0 - 1, 1 being darker). */
1578 double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
1579 /* The additive adjustment. */
1580 int min_delta = delta * dimness * factor / 2;
1581
1582 if (factor < 1)
1583 new = PALETTERGB (max (0, min (0xff, min_delta - GetRValue (*color))),
1584 max (0, min (0xff, min_delta - GetGValue (*color))),
1585 max (0, min (0xff, min_delta - GetBValue (*color))));
1586 else
1587 new = PALETTERGB (max (0, min (0xff, min_delta + GetRValue (*color))),
1588 max (0, min (0xff, min_delta + GetGValue (*color))),
1589 max (0, min (0xff, min_delta + GetBValue (*color))));
1590 }
1591
1592 if (new == *color)
1593 new = PALETTERGB (max (0, min (0xff, delta + GetRValue (*color))),
1594 max (0, min (0xff, delta + GetGValue (*color))),
1595 max (0, min (0xff, delta + GetBValue (*color))));
1596
1597 /* TODO: Map to palette and retry with delta if same? */
1598 /* TODO: Free colors (if using palette)? */
1599
1600 if (new == *color)
1601 return 0;
1602
1603 *color = new;
1604
1605 return 1;
1606 }
1607
1608 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1609 colors in COLORS. On W32, we no longer try to map colors to
1610 a palette. */
1611 void
1612 x_query_colors (struct frame *f, XColor *colors, int ncolors)
1613 {
1614 int i;
1615
1616 for (i = 0; i < ncolors; i++)
1617 {
1618 DWORD pixel = colors[i].pixel;
1619 /* Convert to a 16 bit value in range 0 - 0xffff. */
1620 colors[i].red = GetRValue (pixel) * 257;
1621 colors[i].green = GetGValue (pixel) * 257;
1622 colors[i].blue = GetBValue (pixel) * 257;
1623 }
1624 }
1625
1626 void
1627 x_query_color (struct frame *f, XColor *color)
1628 {
1629 x_query_colors (f, color, 1);
1630 }
1631
1632
1633 /* Set up the foreground color for drawing relief lines of glyph
1634 string S. RELIEF is a pointer to a struct relief containing the GC
1635 with which lines will be drawn. Use a color that is FACTOR or
1636 DELTA lighter or darker than the relief's background which is found
1637 in S->f->output_data.x->relief_background. If such a color cannot
1638 be allocated, use DEFAULT_PIXEL, instead. */
1639
1640 static void
1641 w32_setup_relief_color (struct frame *f, struct relief *relief, double factor,
1642 int delta, COLORREF default_pixel)
1643 {
1644 XGCValues xgcv;
1645 struct w32_output *di = f->output_data.w32;
1646 unsigned long mask = GCForeground;
1647 COLORREF pixel;
1648 COLORREF background = di->relief_background;
1649 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
1650
1651 /* TODO: Free colors (if using palette)? */
1652
1653 /* Allocate new color. */
1654 xgcv.foreground = default_pixel;
1655 pixel = background;
1656 if (w32_alloc_lighter_color (f, &pixel, factor, delta))
1657 {
1658 relief->allocated_p = 1;
1659 xgcv.foreground = relief->pixel = pixel;
1660 }
1661
1662 if (relief->gc == 0)
1663 {
1664 #if 0 /* TODO: stipple */
1665 xgcv.stipple = dpyinfo->gray;
1666 mask |= GCStipple;
1667 #endif
1668 relief->gc = XCreateGC (NULL, FRAME_W32_WINDOW (f), mask, &xgcv);
1669 }
1670 else
1671 XChangeGC (NULL, relief->gc, mask, &xgcv);
1672 }
1673
1674
1675 /* Set up colors for the relief lines around glyph string S. */
1676
1677 static void
1678 x_setup_relief_colors (struct glyph_string *s)
1679 {
1680 struct w32_output *di = s->f->output_data.w32;
1681 COLORREF color;
1682
1683 if (s->face->use_box_color_for_shadows_p)
1684 color = s->face->box_color;
1685 else if (s->first_glyph->type == IMAGE_GLYPH
1686 && s->img->pixmap
1687 && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
1688 color = IMAGE_BACKGROUND (s->img, s->f, 0);
1689 else
1690 color = s->gc->background;
1691
1692 if (di->white_relief.gc == 0
1693 || color != di->relief_background)
1694 {
1695 di->relief_background = color;
1696 w32_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
1697 WHITE_PIX_DEFAULT (s->f));
1698 w32_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
1699 BLACK_PIX_DEFAULT (s->f));
1700 }
1701 }
1702
1703
1704 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1705 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1706 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1707 relief. LEFT_P non-zero means draw a relief on the left side of
1708 the rectangle. RIGHT_P non-zero means draw a relief on the right
1709 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1710 when drawing. */
1711
1712 static void
1713 w32_draw_relief_rect (struct frame *f,
1714 int left_x, int top_y, int right_x, int bottom_y,
1715 int width, int raised_p,
1716 int top_p, int bot_p, int left_p, int right_p,
1717 RECT *clip_rect)
1718 {
1719 int i;
1720 XGCValues gc;
1721 HDC hdc = get_frame_dc (f);
1722
1723 if (raised_p)
1724 gc.foreground = f->output_data.w32->white_relief.gc->foreground;
1725 else
1726 gc.foreground = f->output_data.w32->black_relief.gc->foreground;
1727
1728 w32_set_clip_rectangle (hdc, clip_rect);
1729
1730 /* Top. */
1731 if (top_p)
1732 for (i = 0; i < width; ++i)
1733 w32_fill_area (f, hdc, gc.foreground,
1734 left_x + i * left_p, top_y + i,
1735 right_x - left_x - i * (left_p + right_p ) + 1, 1);
1736
1737 /* Left. */
1738 if (left_p)
1739 for (i = 0; i < width; ++i)
1740 w32_fill_area (f, hdc, gc.foreground,
1741 left_x + i, top_y + (i + 1) * top_p, 1,
1742 bottom_y - top_y - (i + 1) * (bot_p + top_p) + 1);
1743
1744 if (raised_p)
1745 gc.foreground = f->output_data.w32->black_relief.gc->foreground;
1746 else
1747 gc.foreground = f->output_data.w32->white_relief.gc->foreground;
1748
1749 /* Bottom. */
1750 if (bot_p)
1751 for (i = 0; i < width; ++i)
1752 w32_fill_area (f, hdc, gc.foreground,
1753 left_x + i * left_p, bottom_y - i,
1754 right_x - left_x - i * (left_p + right_p) + 1, 1);
1755
1756 /* Right. */
1757 if (right_p)
1758 for (i = 0; i < width; ++i)
1759 w32_fill_area (f, hdc, gc.foreground,
1760 right_x - i, top_y + (i + 1) * top_p, 1,
1761 bottom_y - top_y - (i + 1) * (bot_p + top_p) + 1);
1762
1763 w32_set_clip_rectangle (hdc, NULL);
1764
1765 release_frame_dc (f, hdc);
1766 }
1767
1768
1769 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1770 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1771 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1772 left side of the rectangle. RIGHT_P non-zero means draw a line
1773 on the right side of the rectangle. CLIP_RECT is the clipping
1774 rectangle to use when drawing. */
1775
1776 static void
1777 w32_draw_box_rect (struct glyph_string *s,
1778 int left_x, int top_y, int right_x, int bottom_y, int width,
1779 int left_p, int right_p, RECT *clip_rect)
1780 {
1781 w32_set_clip_rectangle (s->hdc, clip_rect);
1782
1783 /* Top. */
1784 w32_fill_area (s->f, s->hdc, s->face->box_color,
1785 left_x, top_y, right_x - left_x + 1, width);
1786
1787 /* Left. */
1788 if (left_p)
1789 {
1790 w32_fill_area (s->f, s->hdc, s->face->box_color,
1791 left_x, top_y, width, bottom_y - top_y + 1);
1792 }
1793
1794 /* Bottom. */
1795 w32_fill_area (s->f, s->hdc, s->face->box_color,
1796 left_x, bottom_y - width + 1, right_x - left_x + 1, width);
1797
1798 /* Right. */
1799 if (right_p)
1800 {
1801 w32_fill_area (s->f, s->hdc, s->face->box_color,
1802 right_x - width + 1, top_y, width, bottom_y - top_y + 1);
1803 }
1804
1805 w32_set_clip_rectangle (s->hdc, NULL);
1806 }
1807
1808
1809 /* Draw a box around glyph string S. */
1810
1811 static void
1812 x_draw_glyph_string_box (struct glyph_string *s)
1813 {
1814 int width, left_x, right_x, top_y, bottom_y, last_x, raised_p;
1815 int left_p, right_p;
1816 struct glyph *last_glyph;
1817 RECT clip_rect;
1818
1819 last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
1820 ? WINDOW_RIGHT_EDGE_X (s->w)
1821 : window_box_right (s->w, s->area));
1822
1823 /* The glyph that may have a right box line. */
1824 last_glyph = (s->cmp || s->img
1825 ? s->first_glyph
1826 : s->first_glyph + s->nchars - 1);
1827
1828 width = eabs (s->face->box_line_width);
1829 raised_p = s->face->box == FACE_RAISED_BOX;
1830 left_x = s->x;
1831 right_x = ((s->row->full_width_p && s->extends_to_end_of_line_p
1832 ? last_x - 1
1833 : min (last_x, s->x + s->background_width) - 1));
1834 top_y = s->y;
1835 bottom_y = top_y + s->height - 1;
1836
1837 left_p = (s->first_glyph->left_box_line_p
1838 || (s->hl == DRAW_MOUSE_FACE
1839 && (s->prev == NULL
1840 || s->prev->hl != s->hl)));
1841 right_p = (last_glyph->right_box_line_p
1842 || (s->hl == DRAW_MOUSE_FACE
1843 && (s->next == NULL
1844 || s->next->hl != s->hl)));
1845
1846 get_glyph_string_clip_rect (s, &clip_rect);
1847
1848 if (s->face->box == FACE_SIMPLE_BOX)
1849 w32_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
1850 left_p, right_p, &clip_rect);
1851 else
1852 {
1853 x_setup_relief_colors (s);
1854 w32_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
1855 width, raised_p, 1, 1, left_p, right_p, &clip_rect);
1856 }
1857 }
1858
1859
1860 /* Draw foreground of image glyph string S. */
1861
1862 static void
1863 x_draw_image_foreground (struct glyph_string *s)
1864 {
1865 int x = s->x;
1866 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
1867
1868 /* If first glyph of S has a left box line, start drawing it to the
1869 right of that line. */
1870 if (s->face->box != FACE_NO_BOX
1871 && s->first_glyph->left_box_line_p
1872 && s->slice.x == 0)
1873 x += eabs (s->face->box_line_width);
1874
1875 /* If there is a margin around the image, adjust x- and y-position
1876 by that margin. */
1877 if (s->slice.x == 0)
1878 x += s->img->hmargin;
1879 if (s->slice.y == 0)
1880 y += s->img->vmargin;
1881
1882 SaveDC (s->hdc);
1883
1884 if (s->img->pixmap)
1885 {
1886 HDC compat_hdc = CreateCompatibleDC (s->hdc);
1887 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
1888 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
1889 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
1890 SetBkColor (compat_hdc, RGB (255, 255, 255));
1891 SetTextColor (s->hdc, RGB (0, 0, 0));
1892 x_set_glyph_string_clipping (s);
1893
1894 if (s->img->mask)
1895 {
1896 HDC mask_dc = CreateCompatibleDC (s->hdc);
1897 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask);
1898
1899 SetTextColor (s->hdc, RGB (255, 255, 255));
1900 SetBkColor (s->hdc, RGB (0, 0, 0));
1901
1902 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1903 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
1904 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1905 mask_dc, s->slice.x, s->slice.y, SRCAND);
1906 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1907 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
1908
1909 SelectObject (mask_dc, mask_orig_obj);
1910 DeleteDC (mask_dc);
1911 }
1912 else
1913 {
1914 SetTextColor (s->hdc, s->gc->foreground);
1915 SetBkColor (s->hdc, s->gc->background);
1916
1917 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1918 compat_hdc, s->slice.x, s->slice.y, SRCCOPY);
1919
1920 /* When the image has a mask, we can expect that at
1921 least part of a mouse highlight or a block cursor will
1922 be visible. If the image doesn't have a mask, make
1923 a block cursor visible by drawing a rectangle around
1924 the image. I believe it's looking better if we do
1925 nothing here for mouse-face. */
1926 if (s->hl == DRAW_CURSOR)
1927 {
1928 int r = s->img->relief;
1929 if (r < 0) r = -r;
1930 w32_draw_rectangle (s->hdc, s->gc, x - r, y - r ,
1931 s->slice.width + r*2 - 1,
1932 s->slice.height + r*2 - 1);
1933 }
1934 }
1935
1936 w32_set_clip_rectangle (s->hdc, NULL);
1937 SelectObject (s->hdc, orig_brush);
1938 DeleteObject (fg_brush);
1939 SelectObject (compat_hdc, orig_obj);
1940 DeleteDC (compat_hdc);
1941 }
1942 else
1943 w32_draw_rectangle (s->hdc, s->gc, x, y,
1944 s->slice.width - 1, s->slice.height - 1);
1945
1946 RestoreDC (s->hdc ,-1);
1947 }
1948
1949
1950 /* Draw a relief around the image glyph string S. */
1951
1952 static void
1953 x_draw_image_relief (struct glyph_string *s)
1954 {
1955 int x1, y1, thick, raised_p, top_p, bot_p, left_p, right_p;
1956 RECT r;
1957 int x = s->x;
1958 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
1959
1960 /* If first glyph of S has a left box line, start drawing it to the
1961 right of that line. */
1962 if (s->face->box != FACE_NO_BOX
1963 && s->first_glyph->left_box_line_p
1964 && s->slice.x == 0)
1965 x += eabs (s->face->box_line_width);
1966
1967 /* If there is a margin around the image, adjust x- and y-position
1968 by that margin. */
1969 if (s->slice.x == 0)
1970 x += s->img->hmargin;
1971 if (s->slice.y == 0)
1972 y += s->img->vmargin;
1973
1974 if (s->hl == DRAW_IMAGE_SUNKEN
1975 || s->hl == DRAW_IMAGE_RAISED)
1976 {
1977 thick = tool_bar_button_relief >= 0 ? tool_bar_button_relief
1978 : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
1979 raised_p = s->hl == DRAW_IMAGE_RAISED;
1980 }
1981 else
1982 {
1983 thick = eabs (s->img->relief);
1984 raised_p = s->img->relief > 0;
1985 }
1986
1987 x1 = x + s->slice.width - 1;
1988 y1 = y + s->slice.height - 1;
1989 top_p = bot_p = left_p = right_p = 0;
1990
1991 if (s->slice.x == 0)
1992 x -= thick, left_p = 1;
1993 if (s->slice.y == 0)
1994 y -= thick, top_p = 1;
1995 if (s->slice.x + s->slice.width == s->img->width)
1996 x1 += thick, right_p = 1;
1997 if (s->slice.y + s->slice.height == s->img->height)
1998 y1 += thick, bot_p = 1;
1999
2000 x_setup_relief_colors (s);
2001 get_glyph_string_clip_rect (s, &r);
2002 w32_draw_relief_rect (s->f, x, y, x1, y1, thick, raised_p,
2003 top_p, bot_p, left_p, right_p, &r);
2004 }
2005
2006
2007 /* Draw the foreground of image glyph string S to PIXMAP. */
2008
2009 static void
2010 w32_draw_image_foreground_1 (struct glyph_string *s, HBITMAP pixmap)
2011 {
2012 HDC hdc = CreateCompatibleDC (s->hdc);
2013 HGDIOBJ orig_hdc_obj = SelectObject (hdc, pixmap);
2014 int x = 0;
2015 int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
2016
2017 /* If first glyph of S has a left box line, start drawing it to the
2018 right of that line. */
2019 if (s->face->box != FACE_NO_BOX
2020 && s->first_glyph->left_box_line_p
2021 && s->slice.x == 0)
2022 x += eabs (s->face->box_line_width);
2023
2024 /* If there is a margin around the image, adjust x- and y-position
2025 by that margin. */
2026 if (s->slice.x == 0)
2027 x += s->img->hmargin;
2028 if (s->slice.y == 0)
2029 y += s->img->vmargin;
2030
2031 if (s->img->pixmap)
2032 {
2033 HDC compat_hdc = CreateCompatibleDC (hdc);
2034 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
2035 HBRUSH orig_brush = SelectObject (hdc, fg_brush);
2036 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
2037
2038 if (s->img->mask)
2039 {
2040 HDC mask_dc = CreateCompatibleDC (hdc);
2041 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask);
2042
2043 SetTextColor (hdc, RGB (0, 0, 0));
2044 SetBkColor (hdc, RGB (255, 255, 255));
2045 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2046 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
2047 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2048 mask_dc, s->slice.x, s->slice.y, SRCAND);
2049 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2050 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
2051
2052 SelectObject (mask_dc, mask_orig_obj);
2053 DeleteDC (mask_dc);
2054 }
2055 else
2056 {
2057 SetTextColor (hdc, s->gc->foreground);
2058 SetBkColor (hdc, s->gc->background);
2059
2060 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2061 compat_hdc, s->slice.x, s->slice.y, SRCCOPY);
2062
2063 /* When the image has a mask, we can expect that at
2064 least part of a mouse highlight or a block cursor will
2065 be visible. If the image doesn't have a mask, make
2066 a block cursor visible by drawing a rectangle around
2067 the image. I believe it's looking better if we do
2068 nothing here for mouse-face. */
2069 if (s->hl == DRAW_CURSOR)
2070 {
2071 int r = s->img->relief;
2072 if (r < 0) r = -r;
2073 w32_draw_rectangle (hdc, s->gc, x - r, y - r,
2074 s->slice.width + r*2 - 1,
2075 s->slice.height + r*2 - 1);
2076 }
2077 }
2078
2079 SelectObject (hdc, orig_brush);
2080 DeleteObject (fg_brush);
2081 SelectObject (compat_hdc, orig_obj);
2082 DeleteDC (compat_hdc);
2083 }
2084 else
2085 w32_draw_rectangle (hdc, s->gc, x, y,
2086 s->slice.width - 1, s->slice.height - 1);
2087
2088 SelectObject (hdc, orig_hdc_obj);
2089 DeleteDC (hdc);
2090 }
2091
2092
2093 /* Draw part of the background of glyph string S. X, Y, W, and H
2094 give the rectangle to draw. */
2095
2096 static void
2097 x_draw_glyph_string_bg_rect (struct glyph_string *s, int x, int y, int w, int h)
2098 {
2099 #if 0 /* TODO: stipple */
2100 if (s->stippled_p)
2101 {
2102 /* Fill background with a stipple pattern. */
2103 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2104 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
2105 XSetFillStyle (s->display, s->gc, FillSolid);
2106 }
2107 else
2108 #endif
2109 x_clear_glyph_string_rect (s, x, y, w, h);
2110 }
2111
2112
2113 /* Draw image glyph string S.
2114
2115 s->y
2116 s->x +-------------------------
2117 | s->face->box
2118 |
2119 | +-------------------------
2120 | | s->img->vmargin
2121 | |
2122 | | +-------------------
2123 | | | the image
2124
2125 */
2126
2127 static void
2128 x_draw_image_glyph_string (struct glyph_string *s)
2129 {
2130 int x, y;
2131 int box_line_hwidth = eabs (s->face->box_line_width);
2132 int box_line_vwidth = max (s->face->box_line_width, 0);
2133 int height;
2134 HBITMAP pixmap = 0;
2135
2136 height = s->height - 2 * box_line_vwidth;
2137
2138 /* Fill background with face under the image. Do it only if row is
2139 taller than image or if image has a clip mask to reduce
2140 flickering. */
2141 s->stippled_p = s->face->stipple != 0;
2142 if (height > s->slice.height
2143 || s->img->hmargin
2144 || s->img->vmargin
2145 || s->img->mask
2146 || s->img->pixmap == 0
2147 || s->width != s->background_width)
2148 {
2149 x = s->x;
2150 if (s->first_glyph->left_box_line_p
2151 && s->slice.x == 0)
2152 x += box_line_hwidth;
2153
2154 y = s->y;
2155 if (s->slice.y == 0)
2156 y += box_line_vwidth;
2157
2158 #if 0 /* TODO: figure out if we need to do this on Windows. */
2159 if (s->img->mask)
2160 {
2161 /* Create a pixmap as large as the glyph string. Fill it
2162 with the background color. Copy the image to it, using
2163 its mask. Copy the temporary pixmap to the display. */
2164 Screen *screen = FRAME_X_SCREEN (s->f);
2165 int depth = DefaultDepthOfScreen (screen);
2166
2167 /* Create a pixmap as large as the glyph string. */
2168 pixmap = XCreatePixmap (s->display, s->window,
2169 s->background_width,
2170 s->height, depth);
2171
2172 /* Don't clip in the following because we're working on the
2173 pixmap. */
2174 XSetClipMask (s->display, s->gc, None);
2175
2176 /* Fill the pixmap with the background color/stipple. */
2177 if (s->stippled_p)
2178 {
2179 /* Fill background with a stipple pattern. */
2180 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2181 XFillRectangle (s->display, pixmap, s->gc,
2182 0, 0, s->background_width, s->height);
2183 XSetFillStyle (s->display, s->gc, FillSolid);
2184 }
2185 else
2186 {
2187 XGCValues xgcv;
2188 XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
2189 &xgcv);
2190 XSetForeground (s->display, s->gc, xgcv.background);
2191 XFillRectangle (s->display, pixmap, s->gc,
2192 0, 0, s->background_width, s->height);
2193 XSetForeground (s->display, s->gc, xgcv.foreground);
2194 }
2195 }
2196 else
2197 #endif
2198 x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
2199
2200 s->background_filled_p = 1;
2201 }
2202
2203 /* Draw the foreground. */
2204 if (pixmap != 0)
2205 {
2206 w32_draw_image_foreground_1 (s, pixmap);
2207 x_set_glyph_string_clipping (s);
2208 {
2209 HDC compat_hdc = CreateCompatibleDC (s->hdc);
2210 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
2211 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
2212 HGDIOBJ orig_obj = SelectObject (compat_hdc, pixmap);
2213
2214 SetTextColor (s->hdc, s->gc->foreground);
2215 SetBkColor (s->hdc, s->gc->background);
2216 BitBlt (s->hdc, s->x, s->y, s->background_width, s->height,
2217 compat_hdc, 0, 0, SRCCOPY);
2218
2219 SelectObject (s->hdc, orig_brush);
2220 DeleteObject (fg_brush);
2221 SelectObject (compat_hdc, orig_obj);
2222 DeleteDC (compat_hdc);
2223 }
2224 DeleteObject (pixmap);
2225 pixmap = 0;
2226 }
2227 else
2228 x_draw_image_foreground (s);
2229
2230 /* If we must draw a relief around the image, do it. */
2231 if (s->img->relief
2232 || s->hl == DRAW_IMAGE_RAISED
2233 || s->hl == DRAW_IMAGE_SUNKEN)
2234 x_draw_image_relief (s);
2235 }
2236
2237
2238 /* Draw stretch glyph string S. */
2239
2240 static void
2241 x_draw_stretch_glyph_string (struct glyph_string *s)
2242 {
2243 eassert (s->first_glyph->type == STRETCH_GLYPH);
2244
2245 if (s->hl == DRAW_CURSOR
2246 && !x_stretch_cursor_p)
2247 {
2248 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2249 wide as the stretch glyph. */
2250 int width, background_width = s->background_width;
2251 int x = s->x;
2252
2253 if (!s->row->reversed_p)
2254 {
2255 int left_x = window_box_left_offset (s->w, TEXT_AREA);
2256
2257 if (x < left_x)
2258 {
2259 background_width -= left_x - x;
2260 x = left_x;
2261 }
2262 }
2263 else
2264 {
2265 /* In R2L rows, draw the cursor on the right edge of the
2266 stretch glyph. */
2267 int right_x = window_box_right_offset (s->w, TEXT_AREA);
2268
2269 if (x + background_width > right_x)
2270 background_width -= x - right_x;
2271 x += background_width;
2272 }
2273 width = min (FRAME_COLUMN_WIDTH (s->f), background_width);
2274 if (s->row->reversed_p)
2275 x -= width;
2276
2277 /* Draw cursor. */
2278 x_draw_glyph_string_bg_rect (s, x, s->y, width, s->height);
2279
2280 /* Clear rest using the GC of the original non-cursor face. */
2281 if (width < background_width)
2282 {
2283 XGCValues *gc = s->face->gc;
2284 int y = s->y;
2285 int w = background_width - width, h = s->height;
2286 RECT r;
2287 HDC hdc = s->hdc;
2288
2289 if (!s->row->reversed_p)
2290 x += width;
2291 else
2292 x = s->x;
2293 if (s->row->mouse_face_p
2294 && cursor_in_mouse_face_p (s->w))
2295 {
2296 x_set_mouse_face_gc (s);
2297 gc = s->gc;
2298 }
2299 else
2300 gc = s->face->gc;
2301
2302 get_glyph_string_clip_rect (s, &r);
2303 w32_set_clip_rectangle (hdc, &r);
2304
2305 #if 0 /* TODO: stipple */
2306 if (s->face->stipple)
2307 {
2308 /* Fill background with a stipple pattern. */
2309 XSetFillStyle (s->display, gc, FillOpaqueStippled);
2310 XFillRectangle (s->display, s->window, gc, x, y, w, h);
2311 XSetFillStyle (s->display, gc, FillSolid);
2312 }
2313 else
2314 #endif
2315 {
2316 w32_fill_area (s->f, s->hdc, gc->background, x, y, w, h);
2317 }
2318 }
2319 }
2320 else if (!s->background_filled_p)
2321 {
2322 int background_width = s->background_width;
2323 int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
2324
2325 /* Don't draw into left margin, fringe or scrollbar area
2326 except for header line and mode line. */
2327 if (x < left_x && !s->row->mode_line_p)
2328 {
2329 background_width -= left_x - x;
2330 x = left_x;
2331 }
2332 if (background_width > 0)
2333 x_draw_glyph_string_bg_rect (s, x, s->y, background_width, s->height);
2334 }
2335
2336 s->background_filled_p = 1;
2337 }
2338
2339
2340 /* Draw glyph string S. */
2341
2342 static void
2343 x_draw_glyph_string (struct glyph_string *s)
2344 {
2345 int relief_drawn_p = 0;
2346
2347 /* If S draws into the background of its successor, draw the
2348 background of the successor first so that S can draw into it.
2349 This makes S->next use XDrawString instead of XDrawImageString. */
2350 if (s->next && s->right_overhang && !s->for_overlaps)
2351 {
2352 int width;
2353 struct glyph_string *next;
2354 for (width = 0, next = s->next;
2355 next && width < s->right_overhang;
2356 width += next->width, next = next->next)
2357 if (next->first_glyph->type != IMAGE_GLYPH)
2358 {
2359 x_set_glyph_string_gc (next);
2360 x_set_glyph_string_clipping (next);
2361 if (next->first_glyph->type == STRETCH_GLYPH)
2362 x_draw_stretch_glyph_string (next);
2363 else
2364 x_draw_glyph_string_background (next, 1);
2365 next->num_clips = 0;
2366 }
2367 }
2368
2369 /* Set up S->gc, set clipping and draw S. */
2370 x_set_glyph_string_gc (s);
2371
2372 /* Draw relief (if any) in advance for char/composition so that the
2373 glyph string can be drawn over it. */
2374 if (!s->for_overlaps
2375 && s->face->box != FACE_NO_BOX
2376 && (s->first_glyph->type == CHAR_GLYPH
2377 || s->first_glyph->type == COMPOSITE_GLYPH))
2378
2379 {
2380 x_set_glyph_string_clipping (s);
2381 x_draw_glyph_string_background (s, 1);
2382 x_draw_glyph_string_box (s);
2383 x_set_glyph_string_clipping (s);
2384 relief_drawn_p = 1;
2385 }
2386 else if (!s->clip_head /* draw_glyphs didn't specify a clip mask. */
2387 && !s->clip_tail
2388 && ((s->prev && s->prev->hl != s->hl && s->left_overhang)
2389 || (s->next && s->next->hl != s->hl && s->right_overhang)))
2390 /* We must clip just this glyph. left_overhang part has already
2391 drawn when s->prev was drawn, and right_overhang part will be
2392 drawn later when s->next is drawn. */
2393 x_set_glyph_string_clipping_exactly (s, s);
2394 else
2395 x_set_glyph_string_clipping (s);
2396
2397 switch (s->first_glyph->type)
2398 {
2399 case IMAGE_GLYPH:
2400 x_draw_image_glyph_string (s);
2401 break;
2402
2403 case STRETCH_GLYPH:
2404 x_draw_stretch_glyph_string (s);
2405 break;
2406
2407 case CHAR_GLYPH:
2408 if (s->for_overlaps)
2409 s->background_filled_p = 1;
2410 else
2411 x_draw_glyph_string_background (s, 0);
2412 x_draw_glyph_string_foreground (s);
2413 break;
2414
2415 case COMPOSITE_GLYPH:
2416 if (s->for_overlaps || (s->cmp_from > 0
2417 && ! s->first_glyph->u.cmp.automatic))
2418 s->background_filled_p = 1;
2419 else
2420 x_draw_glyph_string_background (s, 1);
2421 x_draw_composite_glyph_string_foreground (s);
2422 break;
2423
2424 case GLYPHLESS_GLYPH:
2425 if (s->for_overlaps)
2426 s->background_filled_p = 1;
2427 else
2428 x_draw_glyph_string_background (s, 0);
2429 x_draw_glyphless_glyph_string_foreground (s);
2430 break;
2431
2432 default:
2433 emacs_abort ();
2434 }
2435
2436 if (!s->for_overlaps)
2437 {
2438 /* Draw underline. */
2439 if (s->face->underline_p)
2440 {
2441 if (s->face->underline_type == FACE_UNDER_WAVE)
2442 {
2443 COLORREF color;
2444
2445 if (s->face->underline_defaulted_p)
2446 color = s->gc->foreground;
2447 else
2448 color = s->face->underline_color;
2449
2450 w32_draw_underwave (s, color);
2451 }
2452 else if (s->face->underline_type == FACE_UNDER_LINE)
2453 {
2454 unsigned long thickness, position;
2455 int y;
2456
2457 if (s->prev && s->prev->face->underline_p
2458 && s->prev->face->underline_type == FACE_UNDER_LINE)
2459 {
2460 /* We use the same underline style as the previous one. */
2461 thickness = s->prev->underline_thickness;
2462 position = s->prev->underline_position;
2463 }
2464 else
2465 {
2466 /* Get the underline thickness. Default is 1 pixel. */
2467 if (s->font && s->font->underline_thickness > 0)
2468 thickness = s->font->underline_thickness;
2469 else
2470 thickness = 1;
2471 if (x_underline_at_descent_line)
2472 position = (s->height - thickness) - (s->ybase - s->y);
2473 else
2474 {
2475 /* Get the underline position. This is the recommended
2476 vertical offset in pixels from the baseline to the top of
2477 the underline. This is a signed value according to the
2478 specs, and its default is
2479
2480 ROUND ((maximum_descent) / 2), with
2481 ROUND (x) = floor (x + 0.5) */
2482
2483 if (x_use_underline_position_properties
2484 && s->font && s->font->underline_position >= 0)
2485 position = s->font->underline_position;
2486 else if (s->font)
2487 position = (s->font->descent + 1) / 2;
2488 }
2489 position = max (position, underline_minimum_offset);
2490 }
2491 /* Check the sanity of thickness and position. We should
2492 avoid drawing underline out of the current line area. */
2493 if (s->y + s->height <= s->ybase + position)
2494 position = (s->height - 1) - (s->ybase - s->y);
2495 if (s->y + s->height < s->ybase + position + thickness)
2496 thickness = (s->y + s->height) - (s->ybase + position);
2497 s->underline_thickness = thickness;
2498 s->underline_position =position;
2499 y = s->ybase + position;
2500 if (s->face->underline_defaulted_p)
2501 {
2502 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
2503 y, s->width, 1);
2504 }
2505 else
2506 {
2507 w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x,
2508 y, s->width, 1);
2509 }
2510 }
2511 }
2512 /* Draw overline. */
2513 if (s->face->overline_p)
2514 {
2515 unsigned long dy = 0, h = 1;
2516
2517 if (s->face->overline_color_defaulted_p)
2518 {
2519 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
2520 s->y + dy, s->width, h);
2521 }
2522 else
2523 {
2524 w32_fill_area (s->f, s->hdc, s->face->overline_color, s->x,
2525 s->y + dy, s->width, h);
2526 }
2527 }
2528
2529 /* Draw strike-through. */
2530 if (s->face->strike_through_p
2531 && !FONT_TEXTMETRIC (s->font).tmStruckOut)
2532 {
2533 unsigned long h = 1;
2534 unsigned long dy = (s->height - h) / 2;
2535
2536 if (s->face->strike_through_color_defaulted_p)
2537 {
2538 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x, s->y + dy,
2539 s->width, h);
2540 }
2541 else
2542 {
2543 w32_fill_area (s->f, s->hdc, s->face->strike_through_color, s->x,
2544 s->y + dy, s->width, h);
2545 }
2546 }
2547
2548 /* Draw relief if not yet drawn. */
2549 if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
2550 x_draw_glyph_string_box (s);
2551
2552 if (s->prev)
2553 {
2554 struct glyph_string *prev;
2555
2556 for (prev = s->prev; prev; prev = prev->prev)
2557 if (prev->hl != s->hl
2558 && prev->x + prev->width + prev->right_overhang > s->x)
2559 {
2560 /* As prev was drawn while clipped to its own area, we
2561 must draw the right_overhang part using s->hl now. */
2562 enum draw_glyphs_face save = prev->hl;
2563
2564 prev->hl = s->hl;
2565 x_set_glyph_string_gc (prev);
2566 x_set_glyph_string_clipping_exactly (s, prev);
2567 if (prev->first_glyph->type == CHAR_GLYPH)
2568 x_draw_glyph_string_foreground (prev);
2569 else
2570 x_draw_composite_glyph_string_foreground (prev);
2571 w32_set_clip_rectangle (prev->hdc, NULL);
2572 prev->hl = save;
2573 prev->num_clips = 0;
2574 }
2575 }
2576
2577 if (s->next)
2578 {
2579 struct glyph_string *next;
2580
2581 for (next = s->next; next; next = next->next)
2582 if (next->hl != s->hl
2583 && next->x - next->left_overhang < s->x + s->width)
2584 {
2585 /* As next will be drawn while clipped to its own area,
2586 we must draw the left_overhang part using s->hl now. */
2587 enum draw_glyphs_face save = next->hl;
2588
2589 next->hl = s->hl;
2590 x_set_glyph_string_gc (next);
2591 x_set_glyph_string_clipping_exactly (s, next);
2592 if (next->first_glyph->type == CHAR_GLYPH)
2593 x_draw_glyph_string_foreground (next);
2594 else
2595 x_draw_composite_glyph_string_foreground (next);
2596 w32_set_clip_rectangle (next->hdc, NULL);
2597 next->hl = save;
2598 next->num_clips = 0;
2599 next->clip_head = s->next;
2600 }
2601 }
2602 }
2603
2604 /* Reset clipping. */
2605 w32_set_clip_rectangle (s->hdc, NULL);
2606 s->num_clips = 0;
2607 }
2608
2609
2610 /* Shift display to make room for inserted glyphs. */
2611
2612 void
2613 w32_shift_glyphs_for_insert (struct frame *f, int x, int y,
2614 int width, int height, int shift_by)
2615 {
2616 HDC hdc;
2617
2618 hdc = get_frame_dc (f);
2619 BitBlt (hdc, x + shift_by, y, width, height,
2620 hdc, x, y, SRCCOPY);
2621
2622 release_frame_dc (f, hdc);
2623 }
2624
2625
2626 /* Delete N glyphs at the nominal cursor position. Not implemented
2627 for X frames. */
2628
2629 static void
2630 x_delete_glyphs (struct frame *f, register int n)
2631 {
2632 if (! FRAME_W32_P (f))
2633 return;
2634
2635 emacs_abort ();
2636 }
2637
2638
2639 /* Clear entire frame. */
2640
2641 static void
2642 x_clear_frame (struct frame *f)
2643 {
2644 if (! FRAME_W32_P (f))
2645 return;
2646
2647 /* Clearing the frame will erase any cursor, so mark them all as no
2648 longer visible. */
2649 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
2650 output_cursor.hpos = output_cursor.vpos = 0;
2651 output_cursor.x = -1;
2652
2653 /* We don't set the output cursor here because there will always
2654 follow an explicit cursor_to. */
2655 block_input ();
2656
2657 w32_clear_window (f);
2658
2659 /* We have to clear the scroll bars, too. If we have changed
2660 colors or something like that, then they should be notified. */
2661 x_scroll_bar_clear (f);
2662
2663 unblock_input ();
2664 }
2665
2666 \f
2667 /* Make audible bell. */
2668
2669 static void
2670 w32_ring_bell (struct frame *f)
2671 {
2672 block_input ();
2673
2674 if (FRAME_W32_P (f) && visible_bell)
2675 {
2676 int i;
2677 HWND hwnd = FRAME_W32_WINDOW (f);
2678
2679 for (i = 0; i < 5; i++)
2680 {
2681 FlashWindow (hwnd, TRUE);
2682 Sleep (10);
2683 }
2684 FlashWindow (hwnd, FALSE);
2685 }
2686 else
2687 w32_sys_ring_bell (f);
2688
2689 unblock_input ();
2690 }
2691
2692 \f
2693 /* Specify how many text lines, from the top of the window,
2694 should be affected by insert-lines and delete-lines operations.
2695 This, and those operations, are used only within an update
2696 that is bounded by calls to x_update_begin and x_update_end. */
2697
2698 static void
2699 w32_set_terminal_window (struct frame *f, int n)
2700 {
2701 /* This function intentionally left blank. */
2702 }
2703
2704 \f
2705 /***********************************************************************
2706 Line Dance
2707 ***********************************************************************/
2708
2709 /* Perform an insert-lines or delete-lines operation, inserting N
2710 lines or deleting -N lines at vertical position VPOS. */
2711
2712 static void
2713 x_ins_del_lines (struct frame *f, int vpos, int n)
2714 {
2715 if (! FRAME_W32_P (f))
2716 return;
2717
2718 emacs_abort ();
2719 }
2720
2721
2722 /* Scroll part of the display as described by RUN. */
2723
2724 static void
2725 x_scroll_run (struct window *w, struct run *run)
2726 {
2727 struct frame *f = XFRAME (w->frame);
2728 int x, y, width, height, from_y, to_y, bottom_y;
2729 HWND hwnd = FRAME_W32_WINDOW (f);
2730 HRGN expect_dirty;
2731
2732 /* Get frame-relative bounding box of the text display area of W,
2733 without mode lines. Include in this box the left and right
2734 fringes of W. */
2735 window_box (w, -1, &x, &y, &width, &height);
2736
2737 /* If the fringe is adjacent to the left (right) scroll bar of a
2738 leftmost (rightmost, respectively) window, then extend its
2739 background to the gap between the fringe and the bar. */
2740 if ((WINDOW_LEFTMOST_P (w)
2741 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
2742 || (WINDOW_RIGHTMOST_P (w)
2743 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)))
2744 {
2745 int sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
2746
2747 if (sb_width > 0)
2748 {
2749 int bar_area_x = WINDOW_SCROLL_BAR_AREA_X (w);
2750 int bar_area_width = (WINDOW_CONFIG_SCROLL_BAR_COLS (w)
2751 * FRAME_COLUMN_WIDTH (f));
2752
2753 if (bar_area_x + bar_area_width == x)
2754 {
2755 x = bar_area_x + sb_width;
2756 width += bar_area_width - sb_width;
2757 }
2758 else if (x + width == bar_area_x)
2759 width += bar_area_width - sb_width;
2760 }
2761 }
2762
2763 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
2764 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
2765 bottom_y = y + height;
2766
2767 if (to_y < from_y)
2768 {
2769 /* Scrolling up. Make sure we don't copy part of the mode
2770 line at the bottom. */
2771 if (from_y + run->height > bottom_y)
2772 height = bottom_y - from_y;
2773 else
2774 height = run->height;
2775 expect_dirty = CreateRectRgn (x, y + height, x + width, bottom_y);
2776 }
2777 else
2778 {
2779 /* Scrolling down. Make sure we don't copy over the mode line.
2780 at the bottom. */
2781 if (to_y + run->height > bottom_y)
2782 height = bottom_y - to_y;
2783 else
2784 height = run->height;
2785 expect_dirty = CreateRectRgn (x, y, x + width, to_y);
2786 }
2787
2788 block_input ();
2789
2790 /* Cursor off. Will be switched on again in x_update_window_end. */
2791 updated_window = w;
2792 x_clear_cursor (w);
2793
2794 {
2795 RECT from;
2796 RECT to;
2797 HRGN dirty = CreateRectRgn (0, 0, 0, 0);
2798 HRGN combined = CreateRectRgn (0, 0, 0, 0);
2799
2800 from.left = to.left = x;
2801 from.right = to.right = x + width;
2802 from.top = from_y;
2803 from.bottom = from_y + height;
2804 to.top = y;
2805 to.bottom = bottom_y;
2806
2807 ScrollWindowEx (hwnd, 0, to_y - from_y, &from, &to, dirty,
2808 NULL, SW_INVALIDATE);
2809
2810 /* Combine this with what we expect to be dirty. This covers the
2811 case where not all of the region we expect is actually dirty. */
2812 CombineRgn (combined, dirty, expect_dirty, RGN_OR);
2813
2814 /* If the dirty region is not what we expected, redraw the entire frame. */
2815 if (!EqualRgn (combined, expect_dirty))
2816 SET_FRAME_GARBAGED (f);
2817
2818 DeleteObject (dirty);
2819 DeleteObject (combined);
2820 }
2821
2822 unblock_input ();
2823 DeleteObject (expect_dirty);
2824 }
2825
2826
2827 \f
2828 /***********************************************************************
2829 Exposure Events
2830 ***********************************************************************/
2831
2832 static void
2833 frame_highlight (struct frame *f)
2834 {
2835 x_update_cursor (f, 1);
2836 x_set_frame_alpha (f);
2837 }
2838
2839 static void
2840 frame_unhighlight (struct frame *f)
2841 {
2842 x_update_cursor (f, 1);
2843 x_set_frame_alpha (f);
2844 }
2845
2846 /* The focus has changed. Update the frames as necessary to reflect
2847 the new situation. Note that we can't change the selected frame
2848 here, because the Lisp code we are interrupting might become confused.
2849 Each event gets marked with the frame in which it occurred, so the
2850 Lisp code can tell when the switch took place by examining the events. */
2851
2852 static void
2853 x_new_focus_frame (struct w32_display_info *dpyinfo, struct frame *frame)
2854 {
2855 struct frame *old_focus = dpyinfo->w32_focus_frame;
2856
2857 if (frame != dpyinfo->w32_focus_frame)
2858 {
2859 /* Set this before calling other routines, so that they see
2860 the correct value of w32_focus_frame. */
2861 dpyinfo->w32_focus_frame = frame;
2862
2863 if (old_focus && old_focus->auto_lower)
2864 x_lower_frame (old_focus);
2865
2866 if (dpyinfo->w32_focus_frame && dpyinfo->w32_focus_frame->auto_raise)
2867 pending_autoraise_frame = dpyinfo->w32_focus_frame;
2868 else
2869 pending_autoraise_frame = 0;
2870 }
2871
2872 x_frame_rehighlight (dpyinfo);
2873 }
2874
2875
2876 /* Handle FocusIn and FocusOut state changes for FRAME.
2877 If FRAME has focus and there exists more than one frame, puts
2878 a FOCUS_IN_EVENT into *BUFP. */
2879
2880 static void
2881 x_focus_changed (int type, int state, struct w32_display_info *dpyinfo,
2882 struct frame *frame, struct input_event *bufp)
2883 {
2884 if (type == WM_SETFOCUS)
2885 {
2886 if (dpyinfo->w32_focus_event_frame != frame)
2887 {
2888 x_new_focus_frame (dpyinfo, frame);
2889 dpyinfo->w32_focus_event_frame = frame;
2890
2891 /* Don't stop displaying the initial startup message
2892 for a switch-frame event we don't need. */
2893 if (NILP (Vterminal_frame)
2894 && CONSP (Vframe_list)
2895 && !NILP (XCDR (Vframe_list)))
2896 {
2897 bufp->kind = FOCUS_IN_EVENT;
2898 XSETFRAME (bufp->frame_or_window, frame);
2899 }
2900 }
2901
2902 frame->output_data.x->focus_state |= state;
2903
2904 /* TODO: IME focus? */
2905 }
2906 else if (type == WM_KILLFOCUS)
2907 {
2908 frame->output_data.x->focus_state &= ~state;
2909
2910 if (dpyinfo->w32_focus_event_frame == frame)
2911 {
2912 dpyinfo->w32_focus_event_frame = 0;
2913 x_new_focus_frame (dpyinfo, 0);
2914 }
2915
2916 /* TODO: IME focus? */
2917 }
2918 }
2919
2920
2921 /* The focus may have changed. Figure out if it is a real focus change,
2922 by checking both FocusIn/Out and Enter/LeaveNotify events.
2923
2924 Returns FOCUS_IN_EVENT event in *BUFP. */
2925
2926 static void
2927 w32_detect_focus_change (struct w32_display_info *dpyinfo, W32Msg *event,
2928 struct input_event *bufp)
2929 {
2930 struct frame *frame;
2931
2932 frame = x_any_window_to_frame (dpyinfo, event->msg.hwnd);
2933 if (! frame)
2934 return;
2935
2936 /* On w32, this is only called from focus events, so no switch needed. */
2937 x_focus_changed (event->msg.message,
2938 (event->msg.message == WM_KILLFOCUS ?
2939 FOCUS_IMPLICIT : FOCUS_EXPLICIT),
2940 dpyinfo, frame, bufp);
2941 }
2942
2943
2944 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2945
2946 void
2947 x_mouse_leave (struct w32_display_info *dpyinfo)
2948 {
2949 x_new_focus_frame (dpyinfo, dpyinfo->w32_focus_event_frame);
2950 }
2951
2952 /* The focus has changed, or we have redirected a frame's focus to
2953 another frame (this happens when a frame uses a surrogate
2954 mini-buffer frame). Shift the highlight as appropriate.
2955
2956 The FRAME argument doesn't necessarily have anything to do with which
2957 frame is being highlighted or un-highlighted; we only use it to find
2958 the appropriate X display info. */
2959
2960 static void
2961 w32_frame_rehighlight (struct frame *frame)
2962 {
2963 if (! FRAME_W32_P (frame))
2964 return;
2965 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame));
2966 }
2967
2968 static void
2969 x_frame_rehighlight (struct w32_display_info *dpyinfo)
2970 {
2971 struct frame *old_highlight = dpyinfo->x_highlight_frame;
2972
2973 if (dpyinfo->w32_focus_frame)
2974 {
2975 dpyinfo->x_highlight_frame
2976 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame)))
2977 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame))
2978 : dpyinfo->w32_focus_frame);
2979 if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
2980 {
2981 fset_focus_frame (dpyinfo->w32_focus_frame, Qnil);
2982 dpyinfo->x_highlight_frame = dpyinfo->w32_focus_frame;
2983 }
2984 }
2985 else
2986 dpyinfo->x_highlight_frame = 0;
2987
2988 if (dpyinfo->x_highlight_frame != old_highlight)
2989 {
2990 if (old_highlight)
2991 frame_unhighlight (old_highlight);
2992 if (dpyinfo->x_highlight_frame)
2993 frame_highlight (dpyinfo->x_highlight_frame);
2994 }
2995 }
2996 \f
2997 /* Keyboard processing - modifier keys, etc. */
2998
2999 /* Convert a keysym to its name. */
3000
3001 char *
3002 x_get_keysym_name (int keysym)
3003 {
3004 /* Make static so we can always return it */
3005 static char value[100];
3006
3007 block_input ();
3008 GetKeyNameText (keysym, value, 100);
3009 unblock_input ();
3010
3011 return value;
3012 }
3013
3014 static int
3015 codepage_for_locale (LCID locale)
3016 {
3017 char cp[20];
3018
3019 if (GetLocaleInfo (locale, LOCALE_IDEFAULTANSICODEPAGE, cp, 20) > 0)
3020 return atoi (cp);
3021 else
3022 return CP_ACP;
3023 }
3024
3025 \f
3026 /* Mouse clicks and mouse movement. Rah. */
3027
3028 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
3029 the state in PUP. XBUTTON provides extra information for extended mouse
3030 button messages. Returns FALSE if unable to parse the message. */
3031 BOOL
3032 parse_button (int message, int xbutton, int * pbutton, int * pup)
3033 {
3034 int button = 0;
3035 int up = 0;
3036
3037 switch (message)
3038 {
3039 case WM_LBUTTONDOWN:
3040 button = 0;
3041 up = 0;
3042 break;
3043 case WM_LBUTTONUP:
3044 button = 0;
3045 up = 1;
3046 break;
3047 case WM_MBUTTONDOWN:
3048 if (NILP (Vw32_swap_mouse_buttons))
3049 button = 1;
3050 else
3051 button = 2;
3052 up = 0;
3053 break;
3054 case WM_MBUTTONUP:
3055 if (NILP (Vw32_swap_mouse_buttons))
3056 button = 1;
3057 else
3058 button = 2;
3059 up = 1;
3060 break;
3061 case WM_RBUTTONDOWN:
3062 if (NILP (Vw32_swap_mouse_buttons))
3063 button = 2;
3064 else
3065 button = 1;
3066 up = 0;
3067 break;
3068 case WM_RBUTTONUP:
3069 if (NILP (Vw32_swap_mouse_buttons))
3070 button = 2;
3071 else
3072 button = 1;
3073 up = 1;
3074 break;
3075 case WM_XBUTTONDOWN:
3076 button = xbutton + 2;
3077 up = 0;
3078 break;
3079 case WM_XBUTTONUP:
3080 button = xbutton + 2;
3081 up = 1;
3082 break;
3083 default:
3084 return (FALSE);
3085 }
3086
3087 if (pup) *pup = up;
3088 if (pbutton) *pbutton = button;
3089
3090 return (TRUE);
3091 }
3092
3093
3094 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3095
3096 If the event is a button press, then note that we have grabbed
3097 the mouse. */
3098
3099 static Lisp_Object
3100 construct_mouse_click (struct input_event *result, W32Msg *msg, struct frame *f)
3101 {
3102 int button;
3103 int up;
3104
3105 parse_button (msg->msg.message, HIWORD (msg->msg.wParam),
3106 &button, &up);
3107
3108 /* Make the event type NO_EVENT; we'll change that when we decide
3109 otherwise. */
3110 result->kind = MOUSE_CLICK_EVENT;
3111 result->code = button;
3112 result->timestamp = msg->msg.time;
3113 result->modifiers = (msg->dwModifiers
3114 | (up
3115 ? up_modifier
3116 : down_modifier));
3117
3118 XSETINT (result->x, LOWORD (msg->msg.lParam));
3119 XSETINT (result->y, HIWORD (msg->msg.lParam));
3120 XSETFRAME (result->frame_or_window, f);
3121 result->arg = Qnil;
3122 return Qnil;
3123 }
3124
3125 static Lisp_Object
3126 construct_mouse_wheel (struct input_event *result, W32Msg *msg, struct frame *f)
3127 {
3128 POINT p;
3129 int delta;
3130
3131 result->kind = msg->msg.message == WM_MOUSEHWHEEL ? HORIZ_WHEEL_EVENT
3132 : WHEEL_EVENT;
3133 result->code = 0;
3134 result->timestamp = msg->msg.time;
3135
3136 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3137 forward, away from the user (up); a negative value indicates that
3138 the wheel was rotated backward, toward the user (down). */
3139 delta = GET_WHEEL_DELTA_WPARAM (msg->msg.wParam);
3140
3141 /* The up and down modifiers indicate if the wheel was rotated up or
3142 down based on WHEEL_DELTA value. */
3143 result->modifiers = (msg->dwModifiers
3144 | ((delta < 0 ) ? down_modifier : up_modifier));
3145
3146 /* With multiple monitors, we can legitimately get negative
3147 coordinates, so cast to short to interpret them correctly. */
3148 p.x = (short) LOWORD (msg->msg.lParam);
3149 p.y = (short) HIWORD (msg->msg.lParam);
3150 ScreenToClient (msg->msg.hwnd, &p);
3151 XSETINT (result->x, p.x);
3152 XSETINT (result->y, p.y);
3153 XSETFRAME (result->frame_or_window, f);
3154 result->arg = Qnil;
3155 return Qnil;
3156 }
3157
3158 static Lisp_Object
3159 construct_drag_n_drop (struct input_event *result, W32Msg *msg, struct frame *f)
3160 {
3161 Lisp_Object files;
3162 Lisp_Object frame;
3163 HDROP hdrop;
3164 POINT p;
3165 WORD num_files;
3166 guichar_t *name;
3167 int i, len;
3168
3169 result->kind = DRAG_N_DROP_EVENT;
3170 result->code = 0;
3171 result->timestamp = msg->msg.time;
3172 result->modifiers = msg->dwModifiers;
3173
3174 hdrop = (HDROP) msg->msg.wParam;
3175 DragQueryPoint (hdrop, &p);
3176
3177 #if 0
3178 p.x = LOWORD (msg->msg.lParam);
3179 p.y = HIWORD (msg->msg.lParam);
3180 ScreenToClient (msg->msg.hwnd, &p);
3181 #endif
3182
3183 XSETINT (result->x, p.x);
3184 XSETINT (result->y, p.y);
3185
3186 num_files = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0);
3187 files = Qnil;
3188
3189 for (i = 0; i < num_files; i++)
3190 {
3191 len = GUI_FN (DragQueryFile) (hdrop, i, NULL, 0);
3192 if (len <= 0)
3193 continue;
3194
3195 name = alloca ((len + 1) * sizeof (*name));
3196 GUI_FN (DragQueryFile) (hdrop, i, name, len + 1);
3197 #ifdef NTGUI_UNICODE
3198 files = Fcons (from_unicode_buffer (name), files);
3199 #else
3200 files = Fcons (DECODE_FILE (build_string (name)), files);
3201 #endif /* NTGUI_UNICODE */
3202 }
3203
3204 DragFinish (hdrop);
3205
3206 XSETFRAME (frame, f);
3207 result->frame_or_window = frame;
3208 result->arg = files;
3209 return Qnil;
3210 }
3211
3212 \f
3213 #if HAVE_W32NOTIFY
3214
3215 /* File event notifications (see w32notify.c). */
3216
3217 Lisp_Object
3218 lispy_file_action (DWORD action)
3219 {
3220 static char unknown_fmt[] = "unknown-action(%d)";
3221 Lisp_Object retval;
3222
3223 switch (action)
3224 {
3225 case FILE_ACTION_ADDED:
3226 retval = Qadded;
3227 break;
3228 case FILE_ACTION_REMOVED:
3229 retval = Qremoved;
3230 break;
3231 case FILE_ACTION_MODIFIED:
3232 retval = Qmodified;
3233 break;
3234 case FILE_ACTION_RENAMED_OLD_NAME:
3235 retval = Qrenamed_from;
3236 break;
3237 case FILE_ACTION_RENAMED_NEW_NAME:
3238 retval = Qrenamed_to;
3239 break;
3240 default:
3241 {
3242 char buf[sizeof(unknown_fmt) - 1 + INT_STRLEN_BOUND (DWORD)];
3243
3244 sprintf (buf, unknown_fmt, action);
3245 retval = intern (buf);
3246 }
3247 break;
3248 }
3249
3250 return retval;
3251 }
3252
3253 #ifdef WINDOWSNT
3254 /* Put file notifications into the Emacs input event queue. This
3255 function runs when the WM_EMACS_FILENOTIFY message arrives from a
3256 watcher thread. */
3257 static void
3258 queue_notifications (struct input_event *event, W32Msg *msg, struct frame *f,
3259 int *evcount)
3260 {
3261 BYTE *p = file_notifications;
3262 FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
3263 const DWORD min_size
3264 = offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
3265 Lisp_Object frame;
3266
3267 /* We cannot process notification before Emacs is fully initialized,
3268 since we need the UTF-16LE coding-system to be set up. */
3269 if (!initialized)
3270 {
3271 notification_buffer_in_use = 0;
3272 return;
3273 }
3274
3275 XSETFRAME (frame, f);
3276
3277 enter_crit ();
3278 if (notification_buffer_in_use)
3279 {
3280 DWORD info_size = notifications_size;
3281 Lisp_Object cs = intern ("utf-16le");
3282 Lisp_Object obj = w32_get_watch_object (notifications_desc);
3283
3284 /* notifications_size could be zero when the buffer of
3285 notifications overflowed on the OS level, or when the
3286 directory being watched was itself deleted. Do nothing in
3287 that case. */
3288 if (info_size
3289 && !NILP (obj) && CONSP (obj))
3290 {
3291 Lisp_Object callback = XCDR (obj);
3292
3293 while (info_size >= min_size)
3294 {
3295 Lisp_Object utf_16_fn
3296 = make_unibyte_string ((char *)fni->FileName,
3297 fni->FileNameLength);
3298 /* Note: mule-conf is preloaded, so utf-16le must
3299 already be defined at this point. */
3300 Lisp_Object fname
3301 = code_convert_string_norecord (utf_16_fn, cs, 0);
3302 Lisp_Object action = lispy_file_action (fni->Action);
3303
3304 event->kind = FILE_NOTIFY_EVENT;
3305 event->code
3306 = (ptrdiff_t)XINT (XIL ((EMACS_INT)notifications_desc));
3307 event->timestamp = msg->msg.time;
3308 event->modifiers = 0;
3309 event->frame_or_window = callback;
3310 event->arg = Fcons (action, fname);
3311 kbd_buffer_store_event (event);
3312 (*evcount)++;
3313
3314 if (!fni->NextEntryOffset)
3315 break;
3316 p += fni->NextEntryOffset;
3317 fni = (PFILE_NOTIFY_INFORMATION)p;
3318 info_size -= fni->NextEntryOffset;
3319 }
3320 }
3321 notification_buffer_in_use = 0;
3322 }
3323 else
3324 DebPrint (("We were promised notifications, but in-use flag is zero!\n"));
3325 leave_crit ();
3326
3327 /* We've stuffed all the events ourselves, so w32_read_socket shouldn't. */
3328 event->kind = NO_EVENT;
3329 }
3330 #endif /* WINDOWSNT */
3331 #endif /* HAVE_W32NOTIFY */
3332
3333 \f
3334 /* Function to report a mouse movement to the mainstream Emacs code.
3335 The input handler calls this.
3336
3337 We have received a mouse movement event, which is given in *event.
3338 If the mouse is over a different glyph than it was last time, tell
3339 the mainstream emacs code by setting mouse_moved. If not, ask for
3340 another motion event, so we can check again the next time it moves. */
3341
3342 static MSG last_mouse_motion_event;
3343 static Lisp_Object last_mouse_motion_frame;
3344
3345 static int
3346 note_mouse_movement (FRAME_PTR frame, MSG *msg)
3347 {
3348 int mouse_x = LOWORD (msg->lParam);
3349 int mouse_y = HIWORD (msg->lParam);
3350
3351 last_mouse_movement_time = msg->time;
3352 memcpy (&last_mouse_motion_event, msg, sizeof (last_mouse_motion_event));
3353 XSETFRAME (last_mouse_motion_frame, frame);
3354
3355 if (!FRAME_X_OUTPUT (frame))
3356 return 0;
3357
3358 if (msg->hwnd != FRAME_W32_WINDOW (frame))
3359 {
3360 frame->mouse_moved = 1;
3361 last_mouse_scroll_bar = Qnil;
3362 note_mouse_highlight (frame, -1, -1);
3363 last_mouse_glyph_frame = 0;
3364 return 1;
3365 }
3366
3367 /* Has the mouse moved off the glyph it was on at the last sighting? */
3368 if (frame != last_mouse_glyph_frame
3369 || mouse_x < last_mouse_glyph.left
3370 || mouse_x >= last_mouse_glyph.right
3371 || mouse_y < last_mouse_glyph.top
3372 || mouse_y >= last_mouse_glyph.bottom)
3373 {
3374 frame->mouse_moved = 1;
3375 last_mouse_scroll_bar = Qnil;
3376 note_mouse_highlight (frame, mouse_x, mouse_y);
3377 /* Remember the mouse position here, as w32_mouse_position only
3378 gets called when mouse tracking is enabled but we also need
3379 to keep track of the mouse for help_echo and highlighting at
3380 other times. */
3381 remember_mouse_glyph (frame, mouse_x, mouse_y, &last_mouse_glyph);
3382 last_mouse_glyph_frame = frame;
3383 return 1;
3384 }
3385
3386 return 0;
3387 }
3388
3389 \f
3390 /************************************************************************
3391 Mouse Face
3392 ************************************************************************/
3393
3394 static struct scroll_bar *x_window_to_scroll_bar (Window);
3395 static void x_scroll_bar_report_motion (FRAME_PTR *, Lisp_Object *,
3396 enum scroll_bar_part *,
3397 Lisp_Object *, Lisp_Object *,
3398 unsigned long *);
3399 static void x_check_fullscreen (struct frame *);
3400
3401 static void
3402 redo_mouse_highlight (void)
3403 {
3404 if (!NILP (last_mouse_motion_frame)
3405 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame)))
3406 note_mouse_highlight (XFRAME (last_mouse_motion_frame),
3407 LOWORD (last_mouse_motion_event.lParam),
3408 HIWORD (last_mouse_motion_event.lParam));
3409 }
3410
3411 static void
3412 w32_define_cursor (Window window, Cursor cursor)
3413 {
3414 PostMessage (window, WM_EMACS_SETCURSOR, (WPARAM) cursor, 0);
3415 }
3416 /* Return the current position of the mouse.
3417 *fp should be a frame which indicates which display to ask about.
3418
3419 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3420 and *part to the frame, window, and scroll bar part that the mouse
3421 is over. Set *x and *y to the portion and whole of the mouse's
3422 position on the scroll bar.
3423
3424 If the mouse movement started elsewhere, set *fp to the frame the
3425 mouse is on, *bar_window to nil, and *x and *y to the character cell
3426 the mouse is over.
3427
3428 Set *time to the server time-stamp for the time at which the mouse
3429 was at this position.
3430
3431 Don't store anything if we don't have a valid set of values to report.
3432
3433 This clears the mouse_moved flag, so we can wait for the next mouse
3434 movement. */
3435
3436 static void
3437 w32_mouse_position (FRAME_PTR *fp, int insist, Lisp_Object *bar_window,
3438 enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
3439 unsigned long *time)
3440 {
3441 FRAME_PTR f1;
3442
3443 block_input ();
3444
3445 if (! NILP (last_mouse_scroll_bar) && insist == 0)
3446 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
3447 else
3448 {
3449 POINT pt;
3450
3451 Lisp_Object frame, tail;
3452
3453 /* Clear the mouse-moved flag for every frame on this display. */
3454 FOR_EACH_FRAME (tail, frame)
3455 XFRAME (frame)->mouse_moved = 0;
3456
3457 last_mouse_scroll_bar = Qnil;
3458
3459 GetCursorPos (&pt);
3460
3461 /* Now we have a position on the root; find the innermost window
3462 containing the pointer. */
3463 {
3464 if (FRAME_W32_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
3465 && FRAME_LIVE_P (last_mouse_frame))
3466 {
3467 /* If mouse was grabbed on a frame, give coords for that frame
3468 even if the mouse is now outside it. */
3469 f1 = last_mouse_frame;
3470 }
3471 else
3472 {
3473 /* Is window under mouse one of our frames? */
3474 f1 = x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp),
3475 WindowFromPoint (pt));
3476 }
3477
3478 /* If not, is it one of our scroll bars? */
3479 if (! f1)
3480 {
3481 struct scroll_bar *bar
3482 = x_window_to_scroll_bar (WindowFromPoint (pt));
3483
3484 if (bar)
3485 {
3486 f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3487 }
3488 }
3489
3490 if (f1 == 0 && insist > 0)
3491 f1 = SELECTED_FRAME ();
3492
3493 if (f1)
3494 {
3495 /* Ok, we found a frame. Store all the values.
3496 last_mouse_glyph is a rectangle used to reduce the
3497 generation of mouse events. To not miss any motion
3498 events, we must divide the frame into rectangles of the
3499 size of the smallest character that could be displayed
3500 on it, i.e. into the same rectangles that matrices on
3501 the frame are divided into. */
3502
3503 ScreenToClient (FRAME_W32_WINDOW (f1), &pt);
3504 remember_mouse_glyph (f1, pt.x, pt.y, &last_mouse_glyph);
3505 last_mouse_glyph_frame = f1;
3506
3507 *bar_window = Qnil;
3508 *part = 0;
3509 *fp = f1;
3510 XSETINT (*x, pt.x);
3511 XSETINT (*y, pt.y);
3512 *time = last_mouse_movement_time;
3513 }
3514 }
3515 }
3516
3517 unblock_input ();
3518 }
3519
3520 \f
3521 /***********************************************************************
3522 Tool-bars
3523 ***********************************************************************/
3524
3525 /* Handle mouse button event on the tool-bar of frame F, at
3526 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
3527 or ButtonRelease. */
3528
3529 static void
3530 w32_handle_tool_bar_click (struct frame *f, struct input_event *button_event)
3531 {
3532 int x = XFASTINT (button_event->x);
3533 int y = XFASTINT (button_event->y);
3534
3535 if (button_event->modifiers & down_modifier)
3536 handle_tool_bar_click (f, x, y, 1, 0);
3537 else
3538 handle_tool_bar_click (f, x, y, 0,
3539 button_event->modifiers & ~up_modifier);
3540 }
3541
3542
3543 \f
3544 /***********************************************************************
3545 Scroll bars
3546 ***********************************************************************/
3547
3548 /* Scroll bar support. */
3549
3550 /* Given a window ID, find the struct scroll_bar which manages it.
3551 This can be called in GC, so we have to make sure to strip off mark
3552 bits. */
3553
3554 static struct scroll_bar *
3555 x_window_to_scroll_bar (Window window_id)
3556 {
3557 Lisp_Object tail, frame;
3558
3559 FOR_EACH_FRAME (tail, frame)
3560 {
3561 Lisp_Object bar, condemned;
3562
3563 /* Scan this frame's scroll bar list for a scroll bar with the
3564 right window ID. */
3565 condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
3566 for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
3567 /* This trick allows us to search both the ordinary and
3568 condemned scroll bar lists with one loop. */
3569 ! NILP (bar) || (bar = condemned,
3570 condemned = Qnil,
3571 ! NILP (bar));
3572 bar = XSCROLL_BAR (bar)->next)
3573 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar)) == window_id)
3574 return XSCROLL_BAR (bar);
3575 }
3576
3577 return 0;
3578 }
3579
3580
3581 \f
3582 /* Set the thumb size and position of scroll bar BAR. We are currently
3583 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3584
3585 static void
3586 w32_set_scroll_bar_thumb (struct scroll_bar *bar,
3587 int portion, int position, int whole)
3588 {
3589 Window w = SCROLL_BAR_W32_WINDOW (bar);
3590 /* We use the whole scroll-bar height in the calculations below, to
3591 avoid strange effects like scrolling backwards when just clicking
3592 on the handle (without moving it). */
3593 double range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height))
3594 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3595 int sb_page, sb_pos;
3596 BOOL draggingp = !NILP (bar->dragging) ? TRUE : FALSE;
3597 SCROLLINFO si;
3598
3599 /* We used to change the nPage setting while dragging the handle,
3600 but that had very strange effects (such as scrolling backwards
3601 while dragging downwards).
3602
3603 Now, we don't change the nPage setting while dragging unless we
3604 get near to the end of the buffer, in which case we often have to
3605 resize the handle to "go all the way". */
3606
3607 if (draggingp)
3608 {
3609 int near_bottom_p;
3610 block_input ();
3611 si.cbSize = sizeof (si);
3612 si.fMask = SIF_POS | SIF_PAGE;
3613 GetScrollInfo (w, SB_CTL, &si);
3614 near_bottom_p = si.nPos + si.nPage >= range;
3615 unblock_input ();
3616 if (!near_bottom_p)
3617 return;
3618 }
3619
3620 if (whole)
3621 {
3622 /* Position scroll bar at rock bottom if the bottom of the
3623 buffer is visible. This avoids shrinking the thumb away
3624 to nothing if it is held at the bottom of the buffer. */
3625 if (position + portion >= whole && !draggingp)
3626 {
3627 sb_page = range * (whole - position) / whole;
3628 sb_pos = range;
3629 }
3630 else
3631 {
3632 sb_pos = position * range / whole;
3633 sb_page = (min (portion, (whole - position)) * range) / whole;
3634 }
3635 }
3636 else
3637 {
3638 sb_page = range;
3639 sb_pos = 0;
3640 }
3641
3642 sb_page = max (sb_page, VERTICAL_SCROLL_BAR_MIN_HANDLE);
3643
3644 block_input ();
3645
3646 si.cbSize = sizeof (si);
3647 si.fMask = SIF_PAGE | SIF_POS;
3648 si.nPage = sb_page;
3649 si.nPos = sb_pos;
3650
3651 SetScrollInfo (w, SB_CTL, &si, TRUE);
3652
3653 unblock_input ();
3654 }
3655
3656 \f
3657 /************************************************************************
3658 Scroll bars, general
3659 ************************************************************************/
3660
3661 static HWND
3662 my_create_scrollbar (struct frame * f, struct scroll_bar * bar)
3663 {
3664 return (HWND) SendMessage (FRAME_W32_WINDOW (f),
3665 WM_EMACS_CREATESCROLLBAR, (WPARAM) f,
3666 (LPARAM) bar);
3667 }
3668
3669 /*#define ATTACH_THREADS*/
3670
3671 static BOOL
3672 my_show_window (FRAME_PTR f, HWND hwnd, int how)
3673 {
3674 #ifndef ATTACH_THREADS
3675 return SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SHOWWINDOW,
3676 (WPARAM) hwnd, (LPARAM) how);
3677 #else
3678 return ShowWindow (hwnd, how);
3679 #endif
3680 }
3681
3682 static void
3683 my_set_window_pos (HWND hwnd, HWND hwndAfter,
3684 int x, int y, int cx, int cy, UINT flags)
3685 {
3686 #ifndef ATTACH_THREADS
3687 WINDOWPOS pos;
3688 pos.hwndInsertAfter = hwndAfter;
3689 pos.x = x;
3690 pos.y = y;
3691 pos.cx = cx;
3692 pos.cy = cy;
3693 pos.flags = flags;
3694 SendMessage (hwnd, WM_EMACS_SETWINDOWPOS, (WPARAM) &pos, 0);
3695 #else
3696 SetWindowPos (hwnd, hwndAfter, x, y, cx, cy, flags);
3697 #endif
3698 }
3699
3700 #if 0
3701 static void
3702 my_set_focus (struct frame * f, HWND hwnd)
3703 {
3704 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SETFOCUS,
3705 (WPARAM) hwnd, 0);
3706 }
3707 #endif
3708
3709 static void
3710 my_set_foreground_window (HWND hwnd)
3711 {
3712 SendMessage (hwnd, WM_EMACS_SETFOREGROUND, (WPARAM) hwnd, 0);
3713 }
3714
3715
3716 static void
3717 my_destroy_window (struct frame * f, HWND hwnd)
3718 {
3719 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_DESTROYWINDOW,
3720 (WPARAM) hwnd, 0);
3721 }
3722
3723 static void
3724 my_bring_window_to_top (HWND hwnd)
3725 {
3726 SendMessage (hwnd, WM_EMACS_BRINGTOTOP, (WPARAM) hwnd, 0);
3727 }
3728
3729 /* Create a scroll bar and return the scroll bar vector for it. W is
3730 the Emacs window on which to create the scroll bar. TOP, LEFT,
3731 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
3732 scroll bar. */
3733
3734 static struct scroll_bar *
3735 x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
3736 {
3737 struct frame *f = XFRAME (WINDOW_FRAME (w));
3738 HWND hwnd;
3739 SCROLLINFO si;
3740 struct scroll_bar *bar
3741 = XSCROLL_BAR (Fmake_vector (make_number (VECSIZE (struct scroll_bar)), Qnil));
3742 Lisp_Object barobj;
3743
3744 block_input ();
3745
3746 XSETWINDOW (bar->window, w);
3747 XSETINT (bar->top, top);
3748 XSETINT (bar->left, left);
3749 XSETINT (bar->width, width);
3750 XSETINT (bar->height, height);
3751 XSETINT (bar->start, 0);
3752 XSETINT (bar->end, 0);
3753 bar->dragging = Qnil;
3754 bar->fringe_extended_p = Qnil;
3755
3756 /* Requires geometry to be set before call to create the real window */
3757
3758 hwnd = my_create_scrollbar (f, bar);
3759
3760 si.cbSize = sizeof (si);
3761 si.fMask = SIF_ALL;
3762 si.nMin = 0;
3763 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
3764 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3765 si.nPage = si.nMax;
3766 si.nPos = 0;
3767
3768 SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3769
3770 SET_SCROLL_BAR_W32_WINDOW (bar, hwnd);
3771
3772 /* Add bar to its frame's list of scroll bars. */
3773 bar->next = FRAME_SCROLL_BARS (f);
3774 bar->prev = Qnil;
3775 XSETVECTOR (barobj, bar);
3776 fset_scroll_bars (f, barobj);
3777 if (! NILP (bar->next))
3778 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
3779
3780 unblock_input ();
3781
3782 return bar;
3783 }
3784
3785
3786 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3787 nil. */
3788
3789 static void
3790 x_scroll_bar_remove (struct scroll_bar *bar)
3791 {
3792 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3793
3794 block_input ();
3795
3796 /* Destroy the window. */
3797 my_destroy_window (f, SCROLL_BAR_W32_WINDOW (bar));
3798
3799 /* Dissociate this scroll bar from its window. */
3800 wset_vertical_scroll_bar (XWINDOW (bar->window), Qnil);
3801
3802 unblock_input ();
3803 }
3804
3805 /* Set the handle of the vertical scroll bar for WINDOW to indicate
3806 that we are displaying PORTION characters out of a total of WHOLE
3807 characters, starting at POSITION. If WINDOW has no scroll bar,
3808 create one. */
3809 static void
3810 w32_set_vertical_scroll_bar (struct window *w,
3811 int portion, int whole, int position)
3812 {
3813 struct frame *f = XFRAME (w->frame);
3814 Lisp_Object barobj;
3815 struct scroll_bar *bar;
3816 int top, height, left, sb_left, width, sb_width;
3817 int window_y, window_height;
3818 int fringe_extended_p;
3819
3820 /* Get window dimensions. */
3821 window_box (w, -1, 0, &window_y, 0, &window_height);
3822 top = window_y;
3823 width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
3824 height = window_height;
3825
3826 /* Compute the left edge of the scroll bar area. */
3827 left = WINDOW_SCROLL_BAR_AREA_X (w);
3828
3829 /* Compute the width of the scroll bar which might be less than
3830 the width of the area reserved for the scroll bar. */
3831 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w) > 0)
3832 sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
3833 else
3834 sb_width = width;
3835
3836 /* Compute the left edge of the scroll bar. */
3837 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
3838 sb_left = left + (WINDOW_RIGHTMOST_P (w) ? width - sb_width : 0);
3839 else
3840 sb_left = left + (WINDOW_LEFTMOST_P (w) ? 0 : width - sb_width);
3841
3842 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
3843 fringe_extended_p = (WINDOW_LEFTMOST_P (w)
3844 && WINDOW_LEFT_FRINGE_WIDTH (w)
3845 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
3846 || WINDOW_LEFT_MARGIN_COLS (w) == 0));
3847 else
3848 fringe_extended_p = (WINDOW_RIGHTMOST_P (w)
3849 && WINDOW_RIGHT_FRINGE_WIDTH (w)
3850 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
3851 || WINDOW_RIGHT_MARGIN_COLS (w) == 0));
3852
3853 /* Does the scroll bar exist yet? */
3854 if (NILP (w->vertical_scroll_bar))
3855 {
3856 HDC hdc;
3857 block_input ();
3858 if (width > 0 && height > 0)
3859 {
3860 hdc = get_frame_dc (f);
3861 if (fringe_extended_p)
3862 w32_clear_area (f, hdc, sb_left, top, sb_width, height);
3863 else
3864 w32_clear_area (f, hdc, left, top, width, height);
3865 release_frame_dc (f, hdc);
3866 }
3867 unblock_input ();
3868
3869 bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
3870 }
3871 else
3872 {
3873 /* It may just need to be moved and resized. */
3874 HWND hwnd;
3875
3876 bar = XSCROLL_BAR (w->vertical_scroll_bar);
3877 hwnd = SCROLL_BAR_W32_WINDOW (bar);
3878
3879 /* If already correctly positioned, do nothing. */
3880 if ( XINT (bar->left) == sb_left
3881 && XINT (bar->top) == top
3882 && XINT (bar->width) == sb_width
3883 && XINT (bar->height) == height
3884 && !NILP (bar->fringe_extended_p) == fringe_extended_p )
3885 {
3886 /* Redraw after clear_frame. */
3887 if (!my_show_window (f, hwnd, SW_NORMAL))
3888 InvalidateRect (hwnd, NULL, FALSE);
3889 }
3890 else
3891 {
3892 HDC hdc;
3893 SCROLLINFO si;
3894
3895 block_input ();
3896 if (width && height)
3897 {
3898 hdc = get_frame_dc (f);
3899 /* Since Windows scroll bars are smaller than the space reserved
3900 for them on the frame, we have to clear "under" them. */
3901 if (fringe_extended_p)
3902 w32_clear_area (f, hdc, sb_left, top, sb_width, height);
3903 else
3904 w32_clear_area (f, hdc, left, top, width, height);
3905 release_frame_dc (f, hdc);
3906 }
3907 /* Make sure scroll bar is "visible" before moving, to ensure the
3908 area of the parent window now exposed will be refreshed. */
3909 my_show_window (f, hwnd, SW_HIDE);
3910 MoveWindow (hwnd, sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
3911 top, sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
3912 max (height, 1), TRUE);
3913
3914 si.cbSize = sizeof (si);
3915 si.fMask = SIF_RANGE;
3916 si.nMin = 0;
3917 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
3918 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3919
3920 SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3921
3922 my_show_window (f, hwnd, SW_NORMAL);
3923 /* InvalidateRect (w, NULL, FALSE); */
3924
3925 /* Remember new settings. */
3926 XSETINT (bar->left, sb_left);
3927 XSETINT (bar->top, top);
3928 XSETINT (bar->width, sb_width);
3929 XSETINT (bar->height, height);
3930
3931 unblock_input ();
3932 }
3933 }
3934 bar->fringe_extended_p = fringe_extended_p ? Qt : Qnil;
3935
3936 w32_set_scroll_bar_thumb (bar, portion, position, whole);
3937 XSETVECTOR (barobj, bar);
3938 wset_vertical_scroll_bar (w, barobj);
3939 }
3940
3941
3942 /* The following three hooks are used when we're doing a thorough
3943 redisplay of the frame. We don't explicitly know which scroll bars
3944 are going to be deleted, because keeping track of when windows go
3945 away is a real pain - "Can you say set-window-configuration, boys
3946 and girls?" Instead, we just assert at the beginning of redisplay
3947 that *all* scroll bars are to be removed, and then save a scroll bar
3948 from the fiery pit when we actually redisplay its window. */
3949
3950 /* Arrange for all scroll bars on FRAME to be removed at the next call
3951 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
3952 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
3953
3954 static void
3955 w32_condemn_scroll_bars (FRAME_PTR frame)
3956 {
3957 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
3958 while (! NILP (FRAME_SCROLL_BARS (frame)))
3959 {
3960 Lisp_Object bar;
3961 bar = FRAME_SCROLL_BARS (frame);
3962 fset_scroll_bars (frame, XSCROLL_BAR (bar)->next);
3963 XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
3964 XSCROLL_BAR (bar)->prev = Qnil;
3965 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
3966 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
3967 fset_condemned_scroll_bars (frame, bar);
3968 }
3969 }
3970
3971
3972 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
3973 Note that WINDOW isn't necessarily condemned at all. */
3974
3975 static void
3976 w32_redeem_scroll_bar (struct window *window)
3977 {
3978 struct scroll_bar *bar;
3979 Lisp_Object barobj;
3980 struct frame *f;
3981
3982 /* We can't redeem this window's scroll bar if it doesn't have one. */
3983 if (NILP (window->vertical_scroll_bar))
3984 emacs_abort ();
3985
3986 bar = XSCROLL_BAR (window->vertical_scroll_bar);
3987
3988 /* Unlink it from the condemned list. */
3989 f = XFRAME (WINDOW_FRAME (window));
3990 if (NILP (bar->prev))
3991 {
3992 /* If the prev pointer is nil, it must be the first in one of
3993 the lists. */
3994 if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
3995 /* It's not condemned. Everything's fine. */
3996 return;
3997 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
3998 window->vertical_scroll_bar))
3999 fset_condemned_scroll_bars (f, bar->next);
4000 else
4001 /* If its prev pointer is nil, it must be at the front of
4002 one or the other! */
4003 emacs_abort ();
4004 }
4005 else
4006 XSCROLL_BAR (bar->prev)->next = bar->next;
4007
4008 if (! NILP (bar->next))
4009 XSCROLL_BAR (bar->next)->prev = bar->prev;
4010
4011 bar->next = FRAME_SCROLL_BARS (f);
4012 bar->prev = Qnil;
4013 XSETVECTOR (barobj, bar);
4014 fset_scroll_bars (f, barobj);
4015 if (! NILP (bar->next))
4016 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
4017 }
4018
4019 /* Remove all scroll bars on FRAME that haven't been saved since the
4020 last call to `*condemn_scroll_bars_hook'. */
4021
4022 static void
4023 w32_judge_scroll_bars (FRAME_PTR f)
4024 {
4025 Lisp_Object bar, next;
4026
4027 bar = FRAME_CONDEMNED_SCROLL_BARS (f);
4028
4029 /* Clear out the condemned list now so we won't try to process any
4030 more events on the hapless scroll bars. */
4031 fset_condemned_scroll_bars (f, Qnil);
4032
4033 for (; ! NILP (bar); bar = next)
4034 {
4035 struct scroll_bar *b = XSCROLL_BAR (bar);
4036
4037 x_scroll_bar_remove (b);
4038
4039 next = b->next;
4040 b->next = b->prev = Qnil;
4041 }
4042
4043 /* Now there should be no references to the condemned scroll bars,
4044 and they should get garbage-collected. */
4045 }
4046
4047 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
4048 is set to something other than NO_EVENT, it is enqueued.
4049
4050 This may be called from a signal handler, so we have to ignore GC
4051 mark bits. */
4052
4053 static int
4054 w32_scroll_bar_handle_click (struct scroll_bar *bar, W32Msg *msg,
4055 struct input_event *emacs_event)
4056 {
4057 if (! WINDOWP (bar->window))
4058 emacs_abort ();
4059
4060 emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
4061 emacs_event->code = 0;
4062 /* not really meaningful to distinguish up/down */
4063 emacs_event->modifiers = msg->dwModifiers;
4064 emacs_event->frame_or_window = bar->window;
4065 emacs_event->arg = Qnil;
4066 emacs_event->timestamp = msg->msg.time;
4067
4068 {
4069 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
4070 int y;
4071 int dragging = !NILP (bar->dragging);
4072 SCROLLINFO si;
4073
4074 si.cbSize = sizeof (si);
4075 si.fMask = SIF_POS;
4076
4077 GetScrollInfo ((HWND) msg->msg.lParam, SB_CTL, &si);
4078 y = si.nPos;
4079
4080 bar->dragging = Qnil;
4081
4082
4083 last_mouse_scroll_bar_pos = msg->msg.wParam;
4084
4085 switch (LOWORD (msg->msg.wParam))
4086 {
4087 case SB_LINEDOWN:
4088 emacs_event->part = scroll_bar_down_arrow;
4089 break;
4090 case SB_LINEUP:
4091 emacs_event->part = scroll_bar_up_arrow;
4092 break;
4093 case SB_PAGEUP:
4094 emacs_event->part = scroll_bar_above_handle;
4095 break;
4096 case SB_PAGEDOWN:
4097 emacs_event->part = scroll_bar_below_handle;
4098 break;
4099 case SB_TOP:
4100 emacs_event->part = scroll_bar_handle;
4101 y = 0;
4102 break;
4103 case SB_BOTTOM:
4104 emacs_event->part = scroll_bar_handle;
4105 y = top_range;
4106 break;
4107 case SB_THUMBTRACK:
4108 case SB_THUMBPOSITION:
4109 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) <= 0xffff)
4110 y = HIWORD (msg->msg.wParam);
4111 bar->dragging = Qt;
4112 emacs_event->part = scroll_bar_handle;
4113
4114 /* "Silently" update current position. */
4115 {
4116 SCROLLINFO si;
4117
4118 si.cbSize = sizeof (si);
4119 si.fMask = SIF_POS;
4120 si.nPos = y;
4121 /* Remember apparent position (we actually lag behind the real
4122 position, so don't set that directly). */
4123 last_scroll_bar_drag_pos = y;
4124
4125 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, FALSE);
4126 }
4127 break;
4128 case SB_ENDSCROLL:
4129 /* If this is the end of a drag sequence, then reset the scroll
4130 handle size to normal and do a final redraw. Otherwise do
4131 nothing. */
4132 if (dragging)
4133 {
4134 SCROLLINFO si;
4135 int start = XINT (bar->start);
4136 int end = XINT (bar->end);
4137
4138 si.cbSize = sizeof (si);
4139 si.fMask = SIF_PAGE | SIF_POS;
4140 si.nPage = end - start + VERTICAL_SCROLL_BAR_MIN_HANDLE;
4141 si.nPos = last_scroll_bar_drag_pos;
4142 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE);
4143 }
4144 /* fall through */
4145 default:
4146 emacs_event->kind = NO_EVENT;
4147 return FALSE;
4148 }
4149
4150 XSETINT (emacs_event->x, y);
4151 XSETINT (emacs_event->y, top_range);
4152
4153 return TRUE;
4154 }
4155 }
4156
4157 /* Return information to the user about the current position of the mouse
4158 on the scroll bar. */
4159
4160 static void
4161 x_scroll_bar_report_motion (FRAME_PTR *fp, Lisp_Object *bar_window,
4162 enum scroll_bar_part *part,
4163 Lisp_Object *x, Lisp_Object *y,
4164 unsigned long *time)
4165 {
4166 struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
4167 Window w = SCROLL_BAR_W32_WINDOW (bar);
4168 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
4169 int pos;
4170 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
4171 SCROLLINFO si;
4172
4173 block_input ();
4174
4175 *fp = f;
4176 *bar_window = bar->window;
4177
4178 si.cbSize = sizeof (si);
4179 si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
4180
4181 GetScrollInfo (w, SB_CTL, &si);
4182 pos = si.nPos;
4183 top_range = si.nMax - si.nPage + 1;
4184
4185 switch (LOWORD (last_mouse_scroll_bar_pos))
4186 {
4187 case SB_THUMBPOSITION:
4188 case SB_THUMBTRACK:
4189 *part = scroll_bar_handle;
4190 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) <= 0xffff)
4191 pos = HIWORD (last_mouse_scroll_bar_pos);
4192 break;
4193 case SB_LINEDOWN:
4194 *part = scroll_bar_handle;
4195 pos++;
4196 break;
4197 default:
4198 *part = scroll_bar_handle;
4199 break;
4200 }
4201
4202 XSETINT (*x, pos);
4203 XSETINT (*y, top_range);
4204
4205 f->mouse_moved = 0;
4206 last_mouse_scroll_bar = Qnil;
4207
4208 *time = last_mouse_movement_time;
4209
4210 unblock_input ();
4211 }
4212
4213
4214 /* The screen has been cleared so we may have changed foreground or
4215 background colors, and the scroll bars may need to be redrawn.
4216 Clear out the scroll bars, and ask for expose events, so we can
4217 redraw them. */
4218
4219 void
4220 x_scroll_bar_clear (FRAME_PTR f)
4221 {
4222 Lisp_Object bar;
4223
4224 /* We can have scroll bars even if this is 0,
4225 if we just turned off scroll bar mode.
4226 But in that case we should not clear them. */
4227 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
4228 for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
4229 bar = XSCROLL_BAR (bar)->next)
4230 {
4231 HWND window = SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar));
4232 HDC hdc = GetDC (window);
4233 RECT rect;
4234
4235 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4236 arranges to refresh the scroll bar if hidden. */
4237 my_show_window (f, window, SW_HIDE);
4238
4239 GetClientRect (window, &rect);
4240 select_palette (f, hdc);
4241 w32_clear_rect (f, hdc, &rect);
4242 deselect_palette (f, hdc);
4243
4244 ReleaseDC (window, hdc);
4245 }
4246 }
4247
4248 \f
4249 /* The main W32 event-reading loop - w32_read_socket. */
4250
4251 /* Record the last 100 characters stored
4252 to help debug the loss-of-chars-during-GC problem. */
4253
4254 static int temp_index;
4255 static short temp_buffer[100];
4256
4257 /* Temporarily store lead byte of DBCS input sequences. */
4258 static char dbcs_lead = 0;
4259
4260 /* Read events coming from the W32 shell.
4261 This routine is called by the SIGIO handler.
4262 We return as soon as there are no more events to be read.
4263
4264 For an overview of how Emacs input works on MS-Windows, see the
4265 commentary before w32_msg_pump in w32fns.c.
4266
4267 We return the number of characters stored into the buffer,
4268 thus pretending to be `read'.
4269
4270 Some of these messages are reposted back to the message queue since the
4271 system calls the windows proc directly in a context where we cannot return
4272 the data nor can we guarantee the state we are in. So if we dispatch them
4273 we will get into an infinite loop. To prevent this from ever happening we
4274 will set a variable to indicate we are in the read_socket call and indicate
4275 which message we are processing since the windows proc gets called
4276 recursively with different messages by the system.
4277 */
4278
4279 static int
4280 w32_read_socket (struct terminal *terminal,
4281 struct input_event *hold_quit)
4282 {
4283 int count = 0;
4284 int check_visibility = 0;
4285 W32Msg msg;
4286 struct frame *f;
4287 struct w32_display_info *dpyinfo = &one_w32_display_info;
4288 Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
4289 static char buf[1];
4290
4291 block_input ();
4292
4293 /* So people can tell when we have read the available input. */
4294 input_signal_count++;
4295
4296 /* Process any incoming thread messages. */
4297 drain_message_queue ();
4298
4299 /* TODO: ghostscript integration. */
4300 while (get_next_msg (&msg, FALSE))
4301 {
4302 struct input_event inev;
4303 int do_help = 0;
4304
4305 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4306 /* w32_name_of_message (msg.msg.message), */
4307 /* msg.msg.time)); */
4308
4309 EVENT_INIT (inev);
4310 inev.kind = NO_EVENT;
4311 inev.arg = Qnil;
4312
4313 switch (msg.msg.message)
4314 {
4315 case WM_EMACS_PAINT:
4316 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4317
4318 if (f)
4319 {
4320 if (msg.rect.right == msg.rect.left ||
4321 msg.rect.bottom == msg.rect.top)
4322 {
4323 /* We may get paint messages even though the client
4324 area is clipped - these are not expose events. */
4325 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f,
4326 SDATA (f->name)));
4327 }
4328 else if (FRAME_VISIBLE_P (f) != 1)
4329 {
4330 bool iconified = FRAME_ICONIFIED_P (f);
4331
4332 /* Definitely not obscured, so mark as visible. */
4333 SET_FRAME_VISIBLE (f, 1);
4334 SET_FRAME_ICONIFIED (f, 0);
4335 SET_FRAME_GARBAGED (f);
4336 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f,
4337 SDATA (f->name)));
4338
4339 /* WM_PAINT serves as MapNotify as well, so report
4340 visibility changes properly. */
4341 if (iconified)
4342 {
4343 inev.kind = DEICONIFY_EVENT;
4344 XSETFRAME (inev.frame_or_window, f);
4345 }
4346 else if (!NILP (Vframe_list) && !NILP (XCDR (Vframe_list)))
4347 /* Force a redisplay sooner or later to update the
4348 frame titles in case this is the second frame. */
4349 record_asynch_buffer_change ();
4350 }
4351 else
4352 {
4353 HDC hdc = get_frame_dc (f);
4354
4355 /* Erase background again for safety. */
4356 w32_clear_rect (f, hdc, &msg.rect);
4357 release_frame_dc (f, hdc);
4358 expose_frame (f,
4359 msg.rect.left,
4360 msg.rect.top,
4361 msg.rect.right - msg.rect.left,
4362 msg.rect.bottom - msg.rect.top);
4363 }
4364 }
4365 break;
4366
4367 case WM_INPUTLANGCHANGE:
4368 /* Generate a language change event. */
4369 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4370
4371 /* lParam contains the input language ID in its low 16 bits.
4372 Use it to update our record of the keyboard codepage. */
4373 w32_keyboard_codepage = codepage_for_locale ((LCID)(msg.msg.lParam
4374 & 0xffff));
4375
4376 if (f)
4377 {
4378 inev.kind = LANGUAGE_CHANGE_EVENT;
4379 XSETFRAME (inev.frame_or_window, f);
4380 inev.code = w32_keyboard_codepage;
4381 inev.modifiers = msg.msg.lParam & 0xffff;
4382 }
4383 break;
4384
4385 case WM_KEYDOWN:
4386 case WM_SYSKEYDOWN:
4387 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4388
4389 if (f && !FRAME_ICONIFIED_P (f))
4390 {
4391 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4392 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4393 {
4394 clear_mouse_face (hlinfo);
4395 hlinfo->mouse_face_hidden = 1;
4396 }
4397
4398 if (temp_index == sizeof temp_buffer / sizeof (short))
4399 temp_index = 0;
4400 temp_buffer[temp_index++] = msg.msg.wParam;
4401 inev.kind = NON_ASCII_KEYSTROKE_EVENT;
4402 inev.code = msg.msg.wParam;
4403 inev.modifiers = msg.dwModifiers;
4404 XSETFRAME (inev.frame_or_window, f);
4405 inev.timestamp = msg.msg.time;
4406 }
4407 break;
4408
4409 case WM_UNICHAR:
4410 case WM_SYSCHAR:
4411 case WM_CHAR:
4412 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4413
4414 if (f && !FRAME_ICONIFIED_P (f))
4415 {
4416 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4417 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4418 {
4419 clear_mouse_face (hlinfo);
4420 hlinfo->mouse_face_hidden = 1;
4421 }
4422
4423 if (temp_index == sizeof temp_buffer / sizeof (short))
4424 temp_index = 0;
4425 temp_buffer[temp_index++] = msg.msg.wParam;
4426
4427 inev.modifiers = msg.dwModifiers;
4428 XSETFRAME (inev.frame_or_window, f);
4429 inev.timestamp = msg.msg.time;
4430
4431 if (msg.msg.message == WM_UNICHAR)
4432 {
4433 inev.code = msg.msg.wParam;
4434 }
4435 else if (msg.msg.wParam < 256)
4436 {
4437 wchar_t code;
4438 char dbcs[2];
4439 dbcs[0] = 0;
4440 dbcs[1] = (char) msg.msg.wParam;
4441
4442 if (dbcs_lead)
4443 {
4444 dbcs[0] = dbcs_lead;
4445 dbcs_lead = 0;
4446 if (!MultiByteToWideChar (w32_keyboard_codepage, 0,
4447 dbcs, 2, &code, 1))
4448 {
4449 /* Garbage */
4450 DebPrint (("Invalid DBCS sequence: %d %d\n",
4451 dbcs[0], dbcs[1]));
4452 inev.kind = NO_EVENT;
4453 break;
4454 }
4455 }
4456 else if (IsDBCSLeadByteEx (w32_keyboard_codepage,
4457 (BYTE) msg.msg.wParam))
4458 {
4459 dbcs_lead = (char) msg.msg.wParam;
4460 inev.kind = NO_EVENT;
4461 break;
4462 }
4463 else
4464 {
4465 if (!MultiByteToWideChar (w32_keyboard_codepage, 0,
4466 &dbcs[1], 1, &code, 1))
4467 {
4468 /* What to do with garbage? */
4469 DebPrint (("Invalid character: %d\n", dbcs[1]));
4470 inev.kind = NO_EVENT;
4471 break;
4472 }
4473 }
4474 inev.code = code;
4475 }
4476 else
4477 {
4478 /* Windows shouldn't generate WM_CHAR events above 0xFF
4479 in non-Unicode message handlers. */
4480 DebPrint (("Non-byte WM_CHAR: %d\n", msg.msg.wParam));
4481 inev.kind = NO_EVENT;
4482 break;
4483 }
4484 inev.kind = inev.code < 128 ? ASCII_KEYSTROKE_EVENT
4485 : MULTIBYTE_CHAR_KEYSTROKE_EVENT;
4486 }
4487 break;
4488
4489 case WM_APPCOMMAND:
4490 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4491
4492 if (f && !FRAME_ICONIFIED_P (f))
4493 {
4494 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4495 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4496 {
4497 clear_mouse_face (hlinfo);
4498 hlinfo->mouse_face_hidden = 1;
4499 }
4500
4501 if (temp_index == sizeof temp_buffer / sizeof (short))
4502 temp_index = 0;
4503 temp_buffer[temp_index++] = msg.msg.wParam;
4504 inev.kind = MULTIMEDIA_KEY_EVENT;
4505 inev.code = GET_APPCOMMAND_LPARAM (msg.msg.lParam);
4506 inev.modifiers = msg.dwModifiers;
4507 XSETFRAME (inev.frame_or_window, f);
4508 inev.timestamp = msg.msg.time;
4509 }
4510 break;
4511
4512 case WM_MOUSEMOVE:
4513 /* Ignore non-movement. */
4514 {
4515 int x = LOWORD (msg.msg.lParam);
4516 int y = HIWORD (msg.msg.lParam);
4517 if (x == last_mousemove_x && y == last_mousemove_y)
4518 break;
4519 last_mousemove_x = x;
4520 last_mousemove_y = y;
4521 }
4522
4523 previous_help_echo_string = help_echo_string;
4524 help_echo_string = Qnil;
4525
4526 if (dpyinfo->grabbed && last_mouse_frame
4527 && FRAME_LIVE_P (last_mouse_frame))
4528 f = last_mouse_frame;
4529 else
4530 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4531
4532 if (hlinfo->mouse_face_hidden)
4533 {
4534 hlinfo->mouse_face_hidden = 0;
4535 clear_mouse_face (hlinfo);
4536 }
4537
4538 if (f)
4539 {
4540 /* Generate SELECT_WINDOW_EVENTs when needed. */
4541 if (!NILP (Vmouse_autoselect_window))
4542 {
4543 Lisp_Object window;
4544 int x = LOWORD (msg.msg.lParam);
4545 int y = HIWORD (msg.msg.lParam);
4546
4547 window = window_from_coordinates (f, x, y, 0, 0);
4548
4549 /* Window will be selected only when it is not
4550 selected now and last mouse movement event was
4551 not in it. Minibuffer window will be selected
4552 only when it is active. */
4553 if (WINDOWP (window)
4554 && !EQ (window, last_window)
4555 && !EQ (window, selected_window)
4556 /* For click-to-focus window managers
4557 create event iff we don't leave the
4558 selected frame. */
4559 && (focus_follows_mouse
4560 || (EQ (XWINDOW (window)->frame,
4561 XWINDOW (selected_window)->frame))))
4562 {
4563 inev.kind = SELECT_WINDOW_EVENT;
4564 inev.frame_or_window = window;
4565 }
4566
4567 last_window = window;
4568 }
4569 if (!note_mouse_movement (f, &msg.msg))
4570 help_echo_string = previous_help_echo_string;
4571 }
4572 else
4573 {
4574 /* If we move outside the frame, then we're
4575 certainly no longer on any text in the frame. */
4576 clear_mouse_face (hlinfo);
4577 }
4578
4579 /* If the contents of the global variable help_echo_string
4580 has changed, generate a HELP_EVENT. */
4581 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4582 But it was originally changed to this to fix a bug, so I have
4583 not removed it completely in case the bug is still there. */
4584 if (help_echo_string != previous_help_echo_string ||
4585 (!NILP (help_echo_string) && !STRINGP (help_echo_string) && f->mouse_moved))
4586 #else /* This is what xterm.c does. */
4587 if (!NILP (help_echo_string)
4588 || !NILP (previous_help_echo_string))
4589 do_help = 1;
4590 #endif
4591 break;
4592
4593 case WM_LBUTTONDOWN:
4594 case WM_LBUTTONUP:
4595 case WM_MBUTTONDOWN:
4596 case WM_MBUTTONUP:
4597 case WM_RBUTTONDOWN:
4598 case WM_RBUTTONUP:
4599 case WM_XBUTTONDOWN:
4600 case WM_XBUTTONUP:
4601 {
4602 /* If we decide we want to generate an event to be seen
4603 by the rest of Emacs, we put it here. */
4604 int tool_bar_p = 0;
4605 int button;
4606 int up;
4607
4608 if (dpyinfo->grabbed && last_mouse_frame
4609 && FRAME_LIVE_P (last_mouse_frame))
4610 f = last_mouse_frame;
4611 else
4612 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4613
4614 if (f)
4615 {
4616 construct_mouse_click (&inev, &msg, f);
4617
4618 /* Is this in the tool-bar? */
4619 if (WINDOWP (f->tool_bar_window)
4620 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)))
4621 {
4622 Lisp_Object window;
4623 int x = XFASTINT (inev.x);
4624 int y = XFASTINT (inev.y);
4625
4626 window = window_from_coordinates (f, x, y, 0, 1);
4627
4628 if (EQ (window, f->tool_bar_window))
4629 {
4630 w32_handle_tool_bar_click (f, &inev);
4631 tool_bar_p = 1;
4632 }
4633 }
4634
4635 if (tool_bar_p
4636 || (dpyinfo->w32_focus_frame
4637 && f != dpyinfo->w32_focus_frame))
4638 inev.kind = NO_EVENT;
4639 }
4640
4641 parse_button (msg.msg.message, HIWORD (msg.msg.wParam),
4642 &button, &up);
4643
4644 if (up)
4645 {
4646 dpyinfo->grabbed &= ~ (1 << button);
4647 }
4648 else
4649 {
4650 dpyinfo->grabbed |= (1 << button);
4651 last_mouse_frame = f;
4652 /* Ignore any mouse motion that happened
4653 before this event; any subsequent mouse-movement
4654 Emacs events should reflect only motion after
4655 the ButtonPress. */
4656 if (f != 0)
4657 f->mouse_moved = 0;
4658
4659 if (!tool_bar_p)
4660 last_tool_bar_item = -1;
4661 }
4662 break;
4663 }
4664
4665 case WM_MOUSEWHEEL:
4666 case WM_MOUSEHWHEEL:
4667 {
4668 if (dpyinfo->grabbed && last_mouse_frame
4669 && FRAME_LIVE_P (last_mouse_frame))
4670 f = last_mouse_frame;
4671 else
4672 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4673
4674 if (f)
4675 {
4676
4677 if (!dpyinfo->w32_focus_frame
4678 || f == dpyinfo->w32_focus_frame)
4679 {
4680 /* Emit an Emacs wheel-up/down event. */
4681 construct_mouse_wheel (&inev, &msg, f);
4682 }
4683 /* Ignore any mouse motion that happened before this
4684 event; any subsequent mouse-movement Emacs events
4685 should reflect only motion after the
4686 ButtonPress. */
4687 f->mouse_moved = 0;
4688 }
4689 last_mouse_frame = f;
4690 last_tool_bar_item = -1;
4691 }
4692 break;
4693
4694 case WM_DROPFILES:
4695 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4696
4697 if (f)
4698 construct_drag_n_drop (&inev, &msg, f);
4699 break;
4700
4701 case WM_VSCROLL:
4702 {
4703 struct scroll_bar *bar =
4704 x_window_to_scroll_bar ((HWND)msg.msg.lParam);
4705
4706 if (bar)
4707 w32_scroll_bar_handle_click (bar, &msg, &inev);
4708 break;
4709 }
4710
4711 case WM_WINDOWPOSCHANGED:
4712 case WM_ACTIVATE:
4713 case WM_ACTIVATEAPP:
4714 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4715 if (f)
4716 {
4717 /* Run the full-screen hook function also when we are
4718 being activated, to actually install the required
4719 size in effect, if the WAIT flag is set. This is
4720 because when the hook is run from x_set_fullscreen,
4721 the frame might not yet be visible, if that call is a
4722 result of make-frame, and in that case the hook just
4723 sets the WAIT flag. */
4724 if ((msg.msg.message == WM_WINDOWPOSCHANGED || msg.msg.wParam)
4725 && (f->want_fullscreen & FULLSCREEN_WAIT))
4726 w32fullscreen_hook (f);
4727 x_check_fullscreen (f);
4728 }
4729 check_visibility = 1;
4730 break;
4731
4732 case WM_MOVE:
4733 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4734
4735 if (f && !FRAME_ICONIFIED_P (f))
4736 {
4737 int x, y;
4738
4739 x_real_positions (f, &x, &y);
4740 f->left_pos = x;
4741 f->top_pos = y;
4742 }
4743
4744 check_visibility = 1;
4745 break;
4746
4747 case WM_SHOWWINDOW:
4748 /* wParam non-zero means Window is about to be shown, 0 means
4749 about to be hidden. */
4750 /* Redo the mouse-highlight after the tooltip has gone. */
4751 if (!msg.msg.wParam && msg.msg.hwnd == tip_window)
4752 {
4753 tip_window = NULL;
4754 redo_mouse_highlight ();
4755 }
4756
4757 /* If window has been obscured or exposed by another window
4758 being maximized or minimized/restored, then recheck
4759 visibility of all frames. Direct changes to our own
4760 windows get handled by WM_SIZE. */
4761 #if 0
4762 if (msg.msg.lParam != 0)
4763 check_visibility = 1;
4764 else
4765 {
4766 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4767 f->async_visible = msg.msg.wParam;
4768 }
4769 #endif
4770
4771 check_visibility = 1;
4772 break;
4773
4774 case WM_SIZE:
4775 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4776
4777 /* Inform lisp of whether frame has been iconified etc. */
4778 if (f)
4779 {
4780 switch (msg.msg.wParam)
4781 {
4782 case SIZE_MINIMIZED:
4783 SET_FRAME_VISIBLE (f, 0);
4784 SET_FRAME_ICONIFIED (f, 1);
4785
4786 inev.kind = ICONIFY_EVENT;
4787 XSETFRAME (inev.frame_or_window, f);
4788 break;
4789
4790 case SIZE_MAXIMIZED:
4791 case SIZE_RESTORED:
4792 {
4793 bool iconified = FRAME_ICONIFIED_P (f);
4794
4795 SET_FRAME_VISIBLE (f, 1);
4796 SET_FRAME_ICONIFIED (f, 0);
4797
4798 /* wait_reading_process_output will notice this
4799 and update the frame's display structures. */
4800 SET_FRAME_GARBAGED (f);
4801
4802 if (iconified)
4803 {
4804 int x, y;
4805
4806 /* Reset top and left positions of the Window
4807 here since Windows sends a WM_MOVE message
4808 BEFORE telling us the Window is minimized
4809 when the Window is iconified, with 3000,3000
4810 as the co-ords. */
4811 x_real_positions (f, &x, &y);
4812 f->left_pos = x;
4813 f->top_pos = y;
4814
4815 inev.kind = DEICONIFY_EVENT;
4816 XSETFRAME (inev.frame_or_window, f);
4817 }
4818 else if (! NILP (Vframe_list)
4819 && ! NILP (XCDR (Vframe_list)))
4820 /* Force a redisplay sooner or later
4821 to update the frame titles
4822 in case this is the second frame. */
4823 record_asynch_buffer_change ();
4824 }
4825 break;
4826 }
4827 }
4828
4829 if (f && !FRAME_ICONIFIED_P (f) && msg.msg.wParam != SIZE_MINIMIZED)
4830 {
4831 RECT rect;
4832 int rows;
4833 int columns;
4834 int width;
4835 int height;
4836
4837 GetClientRect (msg.msg.hwnd, &rect);
4838
4839 height = rect.bottom - rect.top;
4840 width = rect.right - rect.left;
4841
4842 rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height);
4843 columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width);
4844
4845 /* TODO: Clip size to the screen dimensions. */
4846
4847 /* Even if the number of character rows and columns has
4848 not changed, the font size may have changed, so we need
4849 to check the pixel dimensions as well. */
4850
4851 if (columns != FRAME_COLS (f)
4852 || rows != FRAME_LINES (f)
4853 || width != FRAME_PIXEL_WIDTH (f)
4854 || height != FRAME_PIXEL_HEIGHT (f))
4855 {
4856 change_frame_size (f, rows, columns, 0, 1, 0);
4857 SET_FRAME_GARBAGED (f);
4858 cancel_mouse_face (f);
4859 FRAME_PIXEL_WIDTH (f) = width;
4860 FRAME_PIXEL_HEIGHT (f) = height;
4861 f->win_gravity = NorthWestGravity;
4862 }
4863 }
4864
4865 check_visibility = 1;
4866 break;
4867
4868 case WM_MOUSELEAVE:
4869 f = x_any_window_to_frame (dpyinfo, msg.msg.hwnd);
4870 if (f)
4871 {
4872 if (f == hlinfo->mouse_face_mouse_frame)
4873 {
4874 /* If we move outside the frame, then we're
4875 certainly no longer on any text in the frame. */
4876 clear_mouse_face (hlinfo);
4877 hlinfo->mouse_face_mouse_frame = 0;
4878 }
4879
4880 /* Generate a nil HELP_EVENT to cancel a help-echo.
4881 Do it only if there's something to cancel.
4882 Otherwise, the startup message is cleared when
4883 the mouse leaves the frame. */
4884 if (any_help_event_p)
4885 do_help = -1;
4886 }
4887 break;
4888
4889 case WM_SETFOCUS:
4890 w32_detect_focus_change (dpyinfo, &msg, &inev);
4891
4892 dpyinfo->grabbed = 0;
4893 check_visibility = 1;
4894 break;
4895
4896 case WM_KILLFOCUS:
4897 f = x_top_window_to_frame (dpyinfo, msg.msg.hwnd);
4898
4899 if (f)
4900 {
4901 if (f == dpyinfo->w32_focus_event_frame)
4902 dpyinfo->w32_focus_event_frame = 0;
4903
4904 if (f == dpyinfo->w32_focus_frame)
4905 x_new_focus_frame (dpyinfo, 0);
4906
4907 if (f == hlinfo->mouse_face_mouse_frame)
4908 {
4909 /* If we move outside the frame, then we're
4910 certainly no longer on any text in the frame. */
4911 clear_mouse_face (hlinfo);
4912 hlinfo->mouse_face_mouse_frame = 0;
4913 }
4914
4915 /* Generate a nil HELP_EVENT to cancel a help-echo.
4916 Do it only if there's something to cancel.
4917 Otherwise, the startup message is cleared when
4918 the mouse leaves the frame. */
4919 if (any_help_event_p)
4920 do_help = -1;
4921 }
4922
4923 dpyinfo->grabbed = 0;
4924 check_visibility = 1;
4925 break;
4926
4927 case WM_CLOSE:
4928 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4929
4930 if (f)
4931 {
4932 inev.kind = DELETE_WINDOW_EVENT;
4933 XSETFRAME (inev.frame_or_window, f);
4934 }
4935 break;
4936
4937 case WM_INITMENU:
4938 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4939
4940 if (f)
4941 {
4942 inev.kind = MENU_BAR_ACTIVATE_EVENT;
4943 XSETFRAME (inev.frame_or_window, f);
4944 }
4945 break;
4946
4947 case WM_COMMAND:
4948 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4949
4950 if (f)
4951 {
4952 extern void menubar_selection_callback
4953 (FRAME_PTR f, void * client_data);
4954 menubar_selection_callback (f, (void *)msg.msg.wParam);
4955 }
4956
4957 check_visibility = 1;
4958 break;
4959
4960 case WM_DISPLAYCHANGE:
4961 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4962
4963 if (f)
4964 {
4965 dpyinfo->n_cbits = msg.msg.wParam;
4966 DebPrint (("display change: %d %d\n",
4967 (short) LOWORD (msg.msg.lParam),
4968 (short) HIWORD (msg.msg.lParam)));
4969 }
4970
4971 check_visibility = 1;
4972 break;
4973
4974 #if HAVE_W32NOTIFY
4975 case WM_EMACS_FILENOTIFY:
4976 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4977 if (f)
4978 queue_notifications (&inev, &msg, f, &count);
4979 break;
4980 #endif
4981
4982 default:
4983 /* Check for messages registered at runtime. */
4984 if (msg.msg.message == msh_mousewheel)
4985 {
4986 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
4987 msg.msg.message = WM_MOUSEWHEEL;
4988 prepend_msg (&msg);
4989 }
4990 break;
4991 }
4992
4993 if (inev.kind != NO_EVENT)
4994 {
4995 kbd_buffer_store_event_hold (&inev, hold_quit);
4996 count++;
4997 }
4998
4999 if (do_help
5000 && !(hold_quit && hold_quit->kind != NO_EVENT))
5001 {
5002 Lisp_Object frame;
5003
5004 if (f)
5005 XSETFRAME (frame, f);
5006 else
5007 frame = Qnil;
5008
5009 if (do_help > 0)
5010 {
5011 if (NILP (help_echo_string))
5012 {
5013 help_echo_object = help_echo_window = Qnil;
5014 help_echo_pos = -1;
5015 }
5016
5017 any_help_event_p = 1;
5018 gen_help_event (help_echo_string, frame, help_echo_window,
5019 help_echo_object, help_echo_pos);
5020 }
5021 else
5022 {
5023 help_echo_string = Qnil;
5024 gen_help_event (Qnil, frame, Qnil, Qnil, 0);
5025 }
5026 count++;
5027 }
5028 }
5029
5030 /* If the focus was just given to an autoraising frame,
5031 raise it now. */
5032 /* ??? This ought to be able to handle more than one such frame. */
5033 if (pending_autoraise_frame)
5034 {
5035 x_raise_frame (pending_autoraise_frame);
5036 pending_autoraise_frame = 0;
5037 }
5038
5039 /* Check which frames are still visible, if we have enqueued any user
5040 events or been notified of events that may affect visibility. We
5041 do this here because there doesn't seem to be any direct
5042 notification from Windows that the visibility of a window has
5043 changed (at least, not in all cases). */
5044 if (count > 0 || check_visibility)
5045 {
5046 Lisp_Object tail, frame;
5047
5048 FOR_EACH_FRAME (tail, frame)
5049 {
5050 FRAME_PTR f = XFRAME (frame);
5051 /* The tooltip has been drawn already. Avoid the
5052 SET_FRAME_GARBAGED below. */
5053 if (EQ (frame, tip_frame))
5054 continue;
5055
5056 /* Check "visible" frames and mark each as obscured or not.
5057 Note that visible is nonzero for unobscured and obscured
5058 frames, but zero for hidden and iconified frames. */
5059 if (FRAME_W32_P (f) && FRAME_VISIBLE_P (f))
5060 {
5061 RECT clipbox;
5062 HDC hdc;
5063 bool obscured;
5064
5065 enter_crit ();
5066 /* Query clipping rectangle for the entire window area
5067 (GetWindowDC), not just the client portion (GetDC).
5068 Otherwise, the scrollbars and menubar aren't counted as
5069 part of the visible area of the frame, and we may think
5070 the frame is obscured when really a scrollbar is still
5071 visible and gets WM_PAINT messages above. */
5072 hdc = GetWindowDC (FRAME_W32_WINDOW (f));
5073 GetClipBox (hdc, &clipbox);
5074 ReleaseDC (FRAME_W32_WINDOW (f), hdc);
5075 leave_crit ();
5076
5077 obscured = FRAME_OBSCURED_P (f);
5078
5079 if (clipbox.right == clipbox.left || clipbox.bottom == clipbox.top)
5080 {
5081 /* Frame has become completely obscured so mark as such (we
5082 do this by setting visible to 2 so that FRAME_VISIBLE_P
5083 is still true, but redisplay will skip it). */
5084 SET_FRAME_VISIBLE (f, 2);
5085
5086 if (!obscured)
5087 DebPrint (("frame %p (%s) obscured\n", f, SDATA (f->name)));
5088 }
5089 else
5090 {
5091 /* Frame is not obscured, so mark it as such. */
5092 SET_FRAME_VISIBLE (f, 1);
5093
5094 if (obscured)
5095 {
5096 SET_FRAME_GARBAGED (f);
5097 DebPrint (("obscured frame %p (%s) found to be visible\n",
5098 f, SDATA (f->name)));
5099
5100 /* Force a redisplay sooner or later. */
5101 record_asynch_buffer_change ();
5102 }
5103 }
5104 }
5105 }
5106 }
5107
5108 unblock_input ();
5109 return count;
5110 }
5111
5112
5113 \f
5114 /***********************************************************************
5115 Text Cursor
5116 ***********************************************************************/
5117
5118 /* Set clipping for output in glyph row ROW. W is the window in which
5119 we operate. GC is the graphics context to set clipping in.
5120
5121 ROW may be a text row or, e.g., a mode line. Text rows must be
5122 clipped to the interior of the window dedicated to text display,
5123 mode lines must be clipped to the whole window. */
5124
5125 static void
5126 w32_clip_to_row (struct window *w, struct glyph_row *row, int area, HDC hdc)
5127 {
5128 RECT clip_rect;
5129 int window_x, window_y, window_width;
5130
5131 window_box (w, area, &window_x, &window_y, &window_width, 0);
5132
5133 clip_rect.left = window_x;
5134 clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
5135 clip_rect.top = max (clip_rect.top, window_y);
5136 clip_rect.right = clip_rect.left + window_width;
5137 clip_rect.bottom = clip_rect.top + row->visible_height;
5138
5139 w32_set_clip_rectangle (hdc, &clip_rect);
5140 }
5141
5142
5143 /* Draw a hollow box cursor on window W in glyph row ROW. */
5144
5145 static void
5146 x_draw_hollow_cursor (struct window *w, struct glyph_row *row)
5147 {
5148 struct frame *f = XFRAME (WINDOW_FRAME (w));
5149 HDC hdc;
5150 RECT rect;
5151 int left, top, h;
5152 struct glyph *cursor_glyph;
5153 HBRUSH hb = CreateSolidBrush (f->output_data.w32->cursor_pixel);
5154
5155 /* Get the glyph the cursor is on. If we can't tell because
5156 the current matrix is invalid or such, give up. */
5157 cursor_glyph = get_phys_cursor_glyph (w);
5158 if (cursor_glyph == NULL)
5159 return;
5160
5161 /* Compute frame-relative coordinates for phys cursor. */
5162 get_phys_cursor_geometry (w, row, cursor_glyph, &left, &top, &h);
5163 rect.left = left;
5164 rect.top = top;
5165 rect.bottom = rect.top + h;
5166 rect.right = rect.left + w->phys_cursor_width;
5167
5168 hdc = get_frame_dc (f);
5169 /* Set clipping, draw the rectangle, and reset clipping again. */
5170 w32_clip_to_row (w, row, TEXT_AREA, hdc);
5171 FrameRect (hdc, &rect, hb);
5172 DeleteObject (hb);
5173 w32_set_clip_rectangle (hdc, NULL);
5174 release_frame_dc (f, hdc);
5175 }
5176
5177
5178 /* Draw a bar cursor on window W in glyph row ROW.
5179
5180 Implementation note: One would like to draw a bar cursor with an
5181 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5182 Unfortunately, I didn't find a font yet that has this property set.
5183 --gerd. */
5184
5185 static void
5186 x_draw_bar_cursor (struct window *w, struct glyph_row *row,
5187 int width, enum text_cursor_kinds kind)
5188 {
5189 struct frame *f = XFRAME (w->frame);
5190 struct glyph *cursor_glyph;
5191
5192 /* If cursor is out of bounds, don't draw garbage. This can happen
5193 in mini-buffer windows when switching between echo area glyphs
5194 and mini-buffer. */
5195 cursor_glyph = get_phys_cursor_glyph (w);
5196 if (cursor_glyph == NULL)
5197 return;
5198
5199 /* If on an image, draw like a normal cursor. That's usually better
5200 visible than drawing a bar, esp. if the image is large so that
5201 the bar might not be in the window. */
5202 if (cursor_glyph->type == IMAGE_GLYPH)
5203 {
5204 struct glyph_row *row;
5205 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
5206 draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
5207 }
5208 else
5209 {
5210 COLORREF cursor_color = f->output_data.w32->cursor_pixel;
5211 struct face *face = FACE_FROM_ID (f, cursor_glyph->face_id);
5212 int x;
5213 HDC hdc;
5214
5215 /* If the glyph's background equals the color we normally draw
5216 the bar cursor in, the bar cursor in its normal color is
5217 invisible. Use the glyph's foreground color instead in this
5218 case, on the assumption that the glyph's colors are chosen so
5219 that the glyph is legible. */
5220 if (face->background == cursor_color)
5221 cursor_color = face->foreground;
5222
5223 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
5224
5225 hdc = get_frame_dc (f);
5226 w32_clip_to_row (w, row, TEXT_AREA, hdc);
5227
5228 if (kind == BAR_CURSOR)
5229 {
5230 if (width < 0)
5231 width = FRAME_CURSOR_WIDTH (f);
5232 width = min (cursor_glyph->pixel_width, width);
5233
5234 w->phys_cursor_width = width;
5235
5236 /* If the character under cursor is R2L, draw the bar cursor
5237 on the right of its glyph, rather than on the left. */
5238 if ((cursor_glyph->resolved_level & 1) != 0)
5239 x += cursor_glyph->pixel_width - width;
5240
5241 w32_fill_area (f, hdc, cursor_color, x,
5242 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
5243 width, row->height);
5244 }
5245 else
5246 {
5247 int dummy_x, dummy_y, dummy_h;
5248
5249 if (width < 0)
5250 width = row->height;
5251
5252 width = min (row->height, width);
5253
5254 get_phys_cursor_geometry (w, row, cursor_glyph, &dummy_x,
5255 &dummy_y, &dummy_h);
5256 w32_fill_area (f, hdc, cursor_color, x,
5257 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
5258 row->height - width),
5259 w->phys_cursor_width, width);
5260 }
5261
5262 w32_set_clip_rectangle (hdc, NULL);
5263 release_frame_dc (f, hdc);
5264 }
5265 }
5266
5267
5268 /* RIF: Define cursor CURSOR on frame F. */
5269
5270 static void
5271 w32_define_frame_cursor (struct frame *f, Cursor cursor)
5272 {
5273 w32_define_cursor (FRAME_W32_WINDOW (f), cursor);
5274 }
5275
5276
5277 /* RIF: Clear area on frame F. */
5278
5279 static void
5280 w32_clear_frame_area (struct frame *f, int x, int y, int width, int height)
5281 {
5282 HDC hdc;
5283
5284 hdc = get_frame_dc (f);
5285 w32_clear_area (f, hdc, x, y, width, height);
5286 release_frame_dc (f, hdc);
5287 }
5288
5289 /* RIF: Draw or clear cursor on window W. */
5290
5291 static void
5292 w32_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
5293 int x, int y, int cursor_type, int cursor_width,
5294 int on_p, int active_p)
5295 {
5296 if (on_p)
5297 {
5298 /* If the user wants to use the system caret, make sure our own
5299 cursor remains invisible. */
5300 if (w32_use_visible_system_caret)
5301 {
5302 /* Call to erase_phys_cursor here seems to use the
5303 wrong values of w->phys_cursor, as they have been
5304 overwritten before this function was called. */
5305 if (w->phys_cursor_type != NO_CURSOR)
5306 erase_phys_cursor (w);
5307
5308 cursor_type = w->phys_cursor_type = NO_CURSOR;
5309 w->phys_cursor_width = -1;
5310 }
5311 else
5312 {
5313 w->phys_cursor_type = cursor_type;
5314 }
5315
5316 w->phys_cursor_on_p = 1;
5317
5318 /* If this is the active cursor, we need to track it with the
5319 system caret, so third party software like screen magnifiers
5320 and speech synthesizers can follow the cursor. */
5321 if (active_p)
5322 {
5323 struct frame *f = XFRAME (WINDOW_FRAME (w));
5324 HWND hwnd = FRAME_W32_WINDOW (f);
5325
5326 w32_system_caret_x
5327 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
5328 w32_system_caret_y
5329 = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y)
5330 + glyph_row->ascent - w->phys_cursor_ascent);
5331
5332 PostMessage (hwnd, WM_IME_STARTCOMPOSITION, 0, 0);
5333
5334 /* If the size of the active cursor changed, destroy the old
5335 system caret. */
5336 if (w32_system_caret_hwnd
5337 && (w32_system_caret_height != w->phys_cursor_height))
5338 PostMessage (hwnd, WM_EMACS_DESTROY_CARET, 0, 0);
5339
5340 w32_system_caret_height = w->phys_cursor_height;
5341
5342 /* Move the system caret. */
5343 PostMessage (hwnd, WM_EMACS_TRACK_CARET, 0, 0);
5344 }
5345
5346 if (glyph_row->exact_window_width_line_p
5347 && (glyph_row->reversed_p
5348 ? (w->phys_cursor.hpos < 0)
5349 : (w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])))
5350 {
5351 glyph_row->cursor_in_fringe_p = 1;
5352 draw_fringe_bitmap (w, glyph_row, glyph_row->reversed_p);
5353 return;
5354 }
5355
5356 switch (cursor_type)
5357 {
5358 case HOLLOW_BOX_CURSOR:
5359 x_draw_hollow_cursor (w, glyph_row);
5360 break;
5361
5362 case FILLED_BOX_CURSOR:
5363 draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
5364 break;
5365
5366 case BAR_CURSOR:
5367 x_draw_bar_cursor (w, glyph_row, cursor_width, BAR_CURSOR);
5368 break;
5369
5370 case HBAR_CURSOR:
5371 x_draw_bar_cursor (w, glyph_row, cursor_width, HBAR_CURSOR);
5372 break;
5373
5374 case NO_CURSOR:
5375 w->phys_cursor_width = 0;
5376 break;
5377
5378 default:
5379 emacs_abort ();
5380 }
5381 }
5382 }
5383
5384
5385 \f
5386 /* Icons. */
5387
5388 int
5389 x_bitmap_icon (struct frame *f, Lisp_Object icon)
5390 {
5391 HANDLE main_icon;
5392 HANDLE small_icon = NULL;
5393
5394 if (FRAME_W32_WINDOW (f) == 0)
5395 return 1;
5396
5397 if (NILP (icon))
5398 main_icon = LoadIcon (hinst, EMACS_CLASS);
5399 else if (STRINGP (icon))
5400 {
5401 /* Load the main icon from the named file. */
5402 main_icon = LoadImage (NULL, (LPCTSTR) SDATA (icon), IMAGE_ICON, 0, 0,
5403 LR_DEFAULTSIZE | LR_LOADFROMFILE);
5404 /* Try to load a small icon to go with it. */
5405 small_icon = LoadImage (NULL, (LPCSTR) SDATA (icon), IMAGE_ICON,
5406 GetSystemMetrics (SM_CXSMICON),
5407 GetSystemMetrics (SM_CYSMICON),
5408 LR_LOADFROMFILE);
5409 }
5410 else if (SYMBOLP (icon))
5411 {
5412 LPCTSTR name;
5413
5414 if (EQ (icon, intern ("application")))
5415 name = (LPCTSTR) IDI_APPLICATION;
5416 else if (EQ (icon, intern ("hand")))
5417 name = (LPCTSTR) IDI_HAND;
5418 else if (EQ (icon, intern ("question")))
5419 name = (LPCTSTR) IDI_QUESTION;
5420 else if (EQ (icon, intern ("exclamation")))
5421 name = (LPCTSTR) IDI_EXCLAMATION;
5422 else if (EQ (icon, intern ("asterisk")))
5423 name = (LPCTSTR) IDI_ASTERISK;
5424 else if (EQ (icon, intern ("winlogo")))
5425 name = (LPCTSTR) IDI_WINLOGO;
5426 else
5427 return 1;
5428
5429 main_icon = LoadIcon (NULL, name);
5430 }
5431 else
5432 return 1;
5433
5434 if (main_icon == NULL)
5435 return 1;
5436
5437 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_BIG,
5438 (LPARAM) main_icon);
5439
5440 /* If there is a small icon that goes with it, set that too. */
5441 if (small_icon)
5442 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_SMALL,
5443 (LPARAM) small_icon);
5444
5445 return 0;
5446 }
5447
5448 \f
5449 /************************************************************************
5450 Handling X errors
5451 ************************************************************************/
5452
5453 /* Display Error Handling functions not used on W32. Listing them here
5454 helps diff stay in step when comparing w32term.c with xterm.c.
5455
5456 x_error_catcher (display, error)
5457 x_catch_errors (dpy)
5458 x_catch_errors_unwind (old_val)
5459 x_check_errors (dpy, format)
5460 x_fully_uncatch_errors ()
5461 x_had_errors_p (dpy)
5462 x_clear_errors (dpy)
5463 x_uncatch_errors (dpy, count)
5464 x_trace_wire ()
5465 x_connection_signal (signalnum)
5466 x_connection_closed (dpy, error_message)
5467 x_error_quitter (display, error)
5468 x_error_handler (display, error)
5469 x_io_error_quitter (display)
5470
5471 */
5472
5473 \f
5474 /* Changing the font of the frame. */
5475
5476 Lisp_Object
5477 x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
5478 {
5479 struct font *font = XFONT_OBJECT (font_object);
5480
5481 if (fontset < 0)
5482 fontset = fontset_from_font (font_object);
5483 FRAME_FONTSET (f) = fontset;
5484 if (FRAME_FONT (f) == font)
5485 /* This font is already set in frame F. There's nothing more to
5486 do. */
5487 return font_object;
5488
5489 FRAME_FONT (f) = font;
5490 FRAME_BASELINE_OFFSET (f) = font->baseline_offset;
5491 FRAME_COLUMN_WIDTH (f) = font->average_width;
5492 FRAME_LINE_HEIGHT (f) = font->height;
5493
5494 compute_fringe_widths (f, 1);
5495
5496 /* Compute the scroll bar width in character columns. */
5497 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
5498 {
5499 int wid = FRAME_COLUMN_WIDTH (f);
5500 FRAME_CONFIG_SCROLL_BAR_COLS (f)
5501 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid - 1) / wid;
5502 }
5503 else
5504 {
5505 int wid = FRAME_COLUMN_WIDTH (f);
5506 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
5507 }
5508
5509 /* Now make the frame display the given font. */
5510 if (FRAME_X_WINDOW (f) != 0)
5511 {
5512 /* Don't change the size of a tip frame; there's no point in
5513 doing it because it's done in Fx_show_tip, and it leads to
5514 problems because the tip frame has no widget. */
5515 if (NILP (tip_frame) || XFRAME (tip_frame) != f)
5516 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
5517 }
5518
5519 /* X version sets font of input methods here also. */
5520
5521 return font_object;
5522 }
5523
5524 \f
5525 /***********************************************************************
5526 TODO: W32 Input Methods
5527 ***********************************************************************/
5528 /* Listing missing functions from xterm.c helps diff stay in step.
5529
5530 xim_destroy_callback (xim, client_data, call_data)
5531 xim_open_dpy (dpyinfo, resource_name)
5532 struct xim_inst_t
5533 xim_instantiate_callback (display, client_data, call_data)
5534 xim_initialize (dpyinfo, resource_name)
5535 xim_close_dpy (dpyinfo)
5536
5537 */
5538
5539 \f
5540 /* Calculate the absolute position in frame F
5541 from its current recorded position values and gravity. */
5542
5543 void
5544 x_calc_absolute_position (struct frame *f)
5545 {
5546 int flags = f->size_hint_flags;
5547
5548 /* The sum of the widths of the frame's left and right borders, and
5549 the sum of the heights of the frame's top and bottom borders (in
5550 pixels) drawn by Windows. */
5551 unsigned int left_right_borders_width, top_bottom_borders_height;
5552
5553 /* Try to get the actual values of these two variables. We compute
5554 the border width (height) by subtracting the width (height) of
5555 the frame's client area from the width (height) of the frame's
5556 entire window. */
5557 WINDOWPLACEMENT wp = { 0 };
5558 RECT client_rect = { 0 };
5559
5560 if (GetWindowPlacement (FRAME_W32_WINDOW (f), &wp)
5561 && GetClientRect (FRAME_W32_WINDOW (f), &client_rect))
5562 {
5563 left_right_borders_width =
5564 (wp.rcNormalPosition.right - wp.rcNormalPosition.left) -
5565 (client_rect.right - client_rect.left);
5566
5567 top_bottom_borders_height =
5568 (wp.rcNormalPosition.bottom - wp.rcNormalPosition.top) -
5569 (client_rect.bottom - client_rect.top);
5570 }
5571 else
5572 {
5573 /* Use sensible default values. */
5574 left_right_borders_width = 8;
5575 top_bottom_borders_height = 32;
5576 }
5577
5578 /* Treat negative positions as relative to the rightmost bottommost
5579 position that fits on the screen. */
5580 if (flags & XNegative)
5581 f->left_pos = (x_display_pixel_width (FRAME_W32_DISPLAY_INFO (f))
5582 - FRAME_PIXEL_WIDTH (f)
5583 + f->left_pos
5584 - (left_right_borders_width - 1));
5585
5586 if (flags & YNegative)
5587 f->top_pos = (x_display_pixel_height (FRAME_W32_DISPLAY_INFO (f))
5588 - FRAME_PIXEL_HEIGHT (f)
5589 + f->top_pos
5590 - (top_bottom_borders_height - 1));
5591
5592 /* The left_pos and top_pos are now relative to the top and left
5593 screen edges, so the flags should correspond. */
5594 f->size_hint_flags &= ~ (XNegative | YNegative);
5595 }
5596
5597 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5598 to really change the position, and 0 when calling from
5599 x_make_frame_visible (in that case, XOFF and YOFF are the current
5600 position values). It is -1 when calling from x_set_frame_parameters,
5601 which means, do adjust for borders but don't change the gravity. */
5602
5603 void
5604 x_set_offset (struct frame *f, register int xoff, register int yoff,
5605 int change_gravity)
5606 {
5607 int modified_top, modified_left;
5608
5609 if (change_gravity > 0)
5610 {
5611 f->top_pos = yoff;
5612 f->left_pos = xoff;
5613 f->size_hint_flags &= ~ (XNegative | YNegative);
5614 if (xoff < 0)
5615 f->size_hint_flags |= XNegative;
5616 if (yoff < 0)
5617 f->size_hint_flags |= YNegative;
5618 f->win_gravity = NorthWestGravity;
5619 }
5620 x_calc_absolute_position (f);
5621
5622 block_input ();
5623 x_wm_set_size_hint (f, (long) 0, 0);
5624
5625 modified_left = f->left_pos;
5626 modified_top = f->top_pos;
5627
5628 my_set_window_pos (FRAME_W32_WINDOW (f),
5629 NULL,
5630 modified_left, modified_top,
5631 0, 0,
5632 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
5633 unblock_input ();
5634 }
5635
5636
5637 /* Check if we need to resize the frame due to a fullscreen request.
5638 If so needed, resize the frame. */
5639 static void
5640 x_check_fullscreen (struct frame *f)
5641 {
5642 if (f->want_fullscreen & FULLSCREEN_BOTH)
5643 {
5644 int width, height, ign;
5645
5646 x_real_positions (f, &f->left_pos, &f->top_pos);
5647
5648 x_fullscreen_adjust (f, &width, &height, &ign, &ign);
5649
5650 /* We do not need to move the window, it shall be taken care of
5651 when setting WM manager hints. */
5652 if (FRAME_COLS (f) != width || FRAME_LINES (f) != height)
5653 {
5654 change_frame_size (f, height, width, 0, 1, 0);
5655 SET_FRAME_GARBAGED (f);
5656 cancel_mouse_face (f);
5657
5658 /* Wait for the change of frame size to occur. */
5659 f->want_fullscreen |= FULLSCREEN_WAIT;
5660 }
5661 }
5662 }
5663
5664 static void
5665 w32fullscreen_hook (FRAME_PTR f)
5666 {
5667 if (FRAME_VISIBLE_P (f))
5668 {
5669 HWND hwnd = FRAME_W32_WINDOW(f);
5670 DWORD dwStyle = GetWindowLong (hwnd, GWL_STYLE);
5671 RECT rect;
5672
5673 block_input();
5674 f->want_fullscreen &= ~FULLSCREEN_WAIT;
5675
5676 if (FRAME_PREV_FSMODE (f) == FULLSCREEN_NONE)
5677 GetWindowPlacement (hwnd, &FRAME_NORMAL_PLACEMENT (f));
5678
5679 if (FRAME_PREV_FSMODE (f) == FULLSCREEN_BOTH)
5680 {
5681 SetWindowLong (hwnd, GWL_STYLE, dwStyle | WS_OVERLAPPEDWINDOW);
5682 SetWindowPos (hwnd, NULL, 0, 0, 0, 0,
5683 SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
5684 SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
5685 }
5686
5687 w32_fullscreen_rect (hwnd, f->want_fullscreen,
5688 FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
5689 FRAME_PREV_FSMODE (f) = f->want_fullscreen;
5690 if (f->want_fullscreen == FULLSCREEN_BOTH)
5691 {
5692 SetWindowLong (hwnd, GWL_STYLE, dwStyle & ~WS_OVERLAPPEDWINDOW);
5693 SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
5694 rect.right - rect.left, rect.bottom - rect.top,
5695 SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
5696 }
5697 else
5698 {
5699 SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
5700 rect.right - rect.left, rect.bottom - rect.top, 0);
5701 }
5702
5703 f->want_fullscreen = FULLSCREEN_NONE;
5704 unblock_input ();
5705 }
5706 else
5707 f->want_fullscreen |= FULLSCREEN_WAIT;
5708 }
5709
5710 /* Call this to change the size of frame F's x-window.
5711 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5712 for this size change and subsequent size changes.
5713 Otherwise we leave the window gravity unchanged. */
5714
5715 void
5716 x_set_window_size (struct frame *f, int change_gravity, int cols, int rows)
5717 {
5718 int pixelwidth, pixelheight;
5719
5720 block_input ();
5721
5722 check_frame_size (f, &rows, &cols);
5723 f->scroll_bar_actual_width
5724 = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
5725
5726 compute_fringe_widths (f, 0);
5727
5728 pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols);
5729 pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
5730
5731 f->win_gravity = NorthWestGravity;
5732 x_wm_set_size_hint (f, (long) 0, 0);
5733
5734 {
5735 RECT rect;
5736
5737 rect.left = rect.top = 0;
5738 rect.right = pixelwidth;
5739 rect.bottom = pixelheight;
5740
5741 AdjustWindowRect (&rect, f->output_data.w32->dwStyle,
5742 FRAME_EXTERNAL_MENU_BAR (f));
5743
5744 my_set_window_pos (FRAME_W32_WINDOW (f),
5745 NULL,
5746 0, 0,
5747 rect.right - rect.left,
5748 rect.bottom - rect.top,
5749 SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
5750 }
5751
5752 #if 0
5753 /* The following mirrors what is done in xterm.c. It appears to be
5754 for informing lisp of the new size immediately, while the actual
5755 resize will happen asynchronously. But on Windows, the menu bar
5756 automatically wraps when the frame is too narrow to contain it,
5757 and that causes any calculations made here to come out wrong. The
5758 end is some nasty buggy behavior, including the potential loss
5759 of the minibuffer.
5760
5761 Disabling this code is either not sufficient to fix the problems
5762 completely, or it causes fresh problems, but at least it removes
5763 the most problematic symptom of the minibuffer becoming unusable.
5764
5765 -----------------------------------------------------------------
5766
5767 Now, strictly speaking, we can't be sure that this is accurate,
5768 but the window manager will get around to dealing with the size
5769 change request eventually, and we'll hear how it went when the
5770 ConfigureNotify event gets here.
5771
5772 We could just not bother storing any of this information here,
5773 and let the ConfigureNotify event set everything up, but that
5774 might be kind of confusing to the Lisp code, since size changes
5775 wouldn't be reported in the frame parameters until some random
5776 point in the future when the ConfigureNotify event arrives.
5777
5778 We pass 1 for DELAY since we can't run Lisp code inside of
5779 a BLOCK_INPUT. */
5780 change_frame_size (f, rows, cols, 0, 1, 0);
5781 FRAME_PIXEL_WIDTH (f) = pixelwidth;
5782 FRAME_PIXEL_HEIGHT (f) = pixelheight;
5783
5784 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5785 receive in the ConfigureNotify event; if we get what we asked
5786 for, then the event won't cause the screen to become garbaged, so
5787 we have to make sure to do it here. */
5788 SET_FRAME_GARBAGED (f);
5789
5790 /* If cursor was outside the new size, mark it as off. */
5791 mark_window_cursors_off (XWINDOW (f->root_window));
5792
5793 /* Clear out any recollection of where the mouse highlighting was,
5794 since it might be in a place that's outside the new frame size.
5795 Actually checking whether it is outside is a pain in the neck,
5796 so don't try--just let the highlighting be done afresh with new size. */
5797 cancel_mouse_face (f);
5798 #endif
5799
5800 unblock_input ();
5801 }
5802 \f
5803 /* Mouse warping. */
5804
5805 void x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y);
5806
5807 void
5808 x_set_mouse_position (struct frame *f, int x, int y)
5809 {
5810 int pix_x, pix_y;
5811
5812 pix_x = FRAME_COL_TO_PIXEL_X (f, x) + FRAME_COLUMN_WIDTH (f) / 2;
5813 pix_y = FRAME_LINE_TO_PIXEL_Y (f, y) + FRAME_LINE_HEIGHT (f) / 2;
5814
5815 if (pix_x < 0) pix_x = 0;
5816 if (pix_x > FRAME_PIXEL_WIDTH (f)) pix_x = FRAME_PIXEL_WIDTH (f);
5817
5818 if (pix_y < 0) pix_y = 0;
5819 if (pix_y > FRAME_PIXEL_HEIGHT (f)) pix_y = FRAME_PIXEL_HEIGHT (f);
5820
5821 x_set_mouse_pixel_position (f, pix_x, pix_y);
5822 }
5823
5824 void
5825 x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y)
5826 {
5827 RECT rect;
5828 POINT pt;
5829
5830 block_input ();
5831
5832 GetClientRect (FRAME_W32_WINDOW (f), &rect);
5833 pt.x = rect.left + pix_x;
5834 pt.y = rect.top + pix_y;
5835 ClientToScreen (FRAME_W32_WINDOW (f), &pt);
5836
5837 SetCursorPos (pt.x, pt.y);
5838
5839 unblock_input ();
5840 }
5841
5842 \f
5843 /* focus shifting, raising and lowering. */
5844
5845 void
5846 x_focus_on_frame (struct frame *f)
5847 {
5848 struct w32_display_info *dpyinfo = &one_w32_display_info;
5849
5850 /* Give input focus to frame. */
5851 block_input ();
5852 #if 0
5853 /* Try not to change its Z-order if possible. */
5854 if (x_window_to_frame (dpyinfo, GetForegroundWindow ()))
5855 my_set_focus (f, FRAME_W32_WINDOW (f));
5856 else
5857 #endif
5858 my_set_foreground_window (FRAME_W32_WINDOW (f));
5859 unblock_input ();
5860 }
5861
5862 void
5863 x_unfocus_frame (struct frame *f)
5864 {
5865 }
5866
5867 /* Raise frame F. */
5868 void
5869 x_raise_frame (struct frame *f)
5870 {
5871 block_input ();
5872
5873 /* Strictly speaking, raise-frame should only change the frame's Z
5874 order, leaving input focus unchanged. This is reasonable behavior
5875 on X where the usual policy is point-to-focus. However, this
5876 behavior would be very odd on Windows where the usual policy is
5877 click-to-focus.
5878
5879 On X, if the mouse happens to be over the raised frame, it gets
5880 input focus anyway (so the window with focus will never be
5881 completely obscured) - if not, then just moving the mouse over it
5882 is sufficient to give it focus. On Windows, the user must actually
5883 click on the frame (preferably the title bar so as not to move
5884 point), which is more awkward. Also, no other Windows program
5885 raises a window to the top but leaves another window (possibly now
5886 completely obscured) with input focus.
5887
5888 Because there is a system setting on Windows that allows the user
5889 to choose the point to focus policy, we make the strict semantics
5890 optional, but by default we grab focus when raising. */
5891
5892 if (NILP (Vw32_grab_focus_on_raise))
5893 {
5894 /* The obvious call to my_set_window_pos doesn't work if Emacs is
5895 not already the foreground application: the frame is raised
5896 above all other frames belonging to us, but not above the
5897 current top window. To achieve that, we have to resort to this
5898 more cumbersome method. */
5899
5900 HDWP handle = BeginDeferWindowPos (2);
5901 if (handle)
5902 {
5903 handle = DeferWindowPos (handle,
5904 FRAME_W32_WINDOW (f),
5905 HWND_TOP,
5906 0, 0, 0, 0,
5907 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
5908 if (handle)
5909 {
5910 handle = DeferWindowPos (handle,
5911 GetForegroundWindow (),
5912 FRAME_W32_WINDOW (f),
5913 0, 0, 0, 0,
5914 SWP_NOSIZE | SWP_NOMOVE |
5915 SWP_NOACTIVATE);
5916 if (handle)
5917 EndDeferWindowPos (handle);
5918 }
5919 }
5920 }
5921 else
5922 {
5923 my_bring_window_to_top (FRAME_W32_WINDOW (f));
5924 }
5925
5926 unblock_input ();
5927 }
5928
5929 /* Lower frame F. */
5930 void
5931 x_lower_frame (struct frame *f)
5932 {
5933 block_input ();
5934 my_set_window_pos (FRAME_W32_WINDOW (f),
5935 HWND_BOTTOM,
5936 0, 0, 0, 0,
5937 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
5938 unblock_input ();
5939 }
5940
5941 static void
5942 w32_frame_raise_lower (FRAME_PTR f, int raise_flag)
5943 {
5944 if (! FRAME_W32_P (f))
5945 return;
5946
5947 if (raise_flag)
5948 x_raise_frame (f);
5949 else
5950 x_lower_frame (f);
5951 }
5952 \f
5953 /* Change of visibility. */
5954
5955 /* This tries to wait until the frame is really visible.
5956 However, if the window manager asks the user where to position
5957 the frame, this will return before the user finishes doing that.
5958 The frame will not actually be visible at that time,
5959 but it will become visible later when the window manager
5960 finishes with it. */
5961
5962 void
5963 x_make_frame_visible (struct frame *f)
5964 {
5965 Lisp_Object type;
5966
5967 block_input ();
5968
5969 type = x_icon_type (f);
5970 if (!NILP (type))
5971 x_bitmap_icon (f, type);
5972
5973 if (! FRAME_VISIBLE_P (f))
5974 {
5975 /* We test FRAME_GARBAGED_P here to make sure we don't
5976 call x_set_offset a second time
5977 if we get to x_make_frame_visible a second time
5978 before the window gets really visible. */
5979 if (! FRAME_ICONIFIED_P (f)
5980 && ! f->output_data.w32->asked_for_visible)
5981 {
5982 RECT workarea_rect;
5983 RECT window_rect;
5984
5985 /* Adjust vertical window position in order to avoid being
5986 covered by a task bar placed at the bottom of the desktop. */
5987 SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0);
5988 GetWindowRect (FRAME_W32_WINDOW (f), &window_rect);
5989 if (window_rect.bottom > workarea_rect.bottom
5990 && window_rect.top > workarea_rect.top)
5991 f->top_pos = max (window_rect.top
5992 - window_rect.bottom + workarea_rect.bottom,
5993 workarea_rect.top);
5994
5995 x_set_offset (f, f->left_pos, f->top_pos, 0);
5996 }
5997
5998 f->output_data.w32->asked_for_visible = 1;
5999
6000 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
6001 causes unexpected behavior when unminimizing frames that were
6002 previously maximized. But only SW_SHOWNORMAL works properly for
6003 frames that were truely hidden (using make-frame-invisible), so
6004 we need it to avoid Bug#5482. It seems that iconified is only
6005 set for minimized windows that are still visible, so use that to
6006 determine the appropriate flag to pass ShowWindow. */
6007 my_show_window (f, FRAME_W32_WINDOW (f),
6008 FRAME_ICONIFIED_P (f) ? SW_RESTORE : SW_SHOWNORMAL);
6009 }
6010
6011 /* Synchronize to ensure Emacs knows the frame is visible
6012 before we do anything else. We do this loop with input not blocked
6013 so that incoming events are handled. */
6014 {
6015 Lisp_Object frame;
6016 int count;
6017
6018 /* This must come after we set COUNT. */
6019 unblock_input ();
6020
6021 XSETFRAME (frame, f);
6022
6023 /* Wait until the frame is visible. Process X events until a
6024 MapNotify event has been seen, or until we think we won't get a
6025 MapNotify at all.. */
6026 for (count = input_signal_count + 10;
6027 input_signal_count < count && !FRAME_VISIBLE_P (f);)
6028 {
6029 /* Force processing of queued events. */
6030 /* TODO: x_sync equivalent? */
6031
6032 /* Machines that do polling rather than SIGIO have been observed
6033 to go into a busy-wait here. So we'll fake an alarm signal
6034 to let the handler know that there's something to be read.
6035 We used to raise a real alarm, but it seems that the handler
6036 isn't always enabled here. This is probably a bug. */
6037 if (input_polling_used ())
6038 {
6039 /* It could be confusing if a real alarm arrives while processing
6040 the fake one. Turn it off and let the handler reset it. */
6041 int old_poll_suppress_count = poll_suppress_count;
6042 poll_suppress_count = 1;
6043 poll_for_input_1 ();
6044 poll_suppress_count = old_poll_suppress_count;
6045 }
6046 }
6047 }
6048 }
6049
6050 /* Change from mapped state to withdrawn state. */
6051
6052 /* Make the frame visible (mapped and not iconified). */
6053
6054 void
6055 x_make_frame_invisible (struct frame *f)
6056 {
6057 /* Don't keep the highlight on an invisible frame. */
6058 if (FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame == f)
6059 FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame = 0;
6060
6061 block_input ();
6062
6063 my_show_window (f, FRAME_W32_WINDOW (f), SW_HIDE);
6064
6065 /* We can't distinguish this from iconification
6066 just by the event that we get from the server.
6067 So we can't win using the usual strategy of letting
6068 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6069 and synchronize with the server to make sure we agree. */
6070 SET_FRAME_VISIBLE (f, 0);
6071 SET_FRAME_ICONIFIED (f, 0);
6072
6073 unblock_input ();
6074 }
6075
6076 /* Change window state from mapped to iconified. */
6077
6078 void
6079 x_iconify_frame (struct frame *f)
6080 {
6081 Lisp_Object type;
6082
6083 /* Don't keep the highlight on an invisible frame. */
6084 if (FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame == f)
6085 FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame = 0;
6086
6087 if (FRAME_ICONIFIED_P (f))
6088 return;
6089
6090 block_input ();
6091
6092 type = x_icon_type (f);
6093 if (!NILP (type))
6094 x_bitmap_icon (f, type);
6095
6096 /* Simulate the user minimizing the frame. */
6097 SendMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, SC_MINIMIZE, 0);
6098
6099 unblock_input ();
6100 }
6101
6102 \f
6103 /* Free X resources of frame F. */
6104
6105 void
6106 x_free_frame_resources (struct frame *f)
6107 {
6108 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
6109 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
6110
6111 block_input ();
6112
6113 /* We must free faces before destroying windows because some
6114 font-driver (e.g. xft) access a window while finishing a
6115 face. */
6116 if (FRAME_FACE_CACHE (f))
6117 free_frame_faces (f);
6118
6119 if (FRAME_W32_WINDOW (f))
6120 my_destroy_window (f, FRAME_W32_WINDOW (f));
6121
6122 free_frame_menubar (f);
6123
6124 unload_color (f, FRAME_FOREGROUND_PIXEL (f));
6125 unload_color (f, FRAME_BACKGROUND_PIXEL (f));
6126 unload_color (f, f->output_data.w32->cursor_pixel);
6127 unload_color (f, f->output_data.w32->cursor_foreground_pixel);
6128 unload_color (f, f->output_data.w32->border_pixel);
6129 unload_color (f, f->output_data.w32->mouse_pixel);
6130 if (f->output_data.w32->white_relief.allocated_p)
6131 unload_color (f, f->output_data.w32->white_relief.pixel);
6132 if (f->output_data.w32->black_relief.allocated_p)
6133 unload_color (f, f->output_data.w32->black_relief.pixel);
6134
6135 if (FRAME_FACE_CACHE (f))
6136 free_frame_faces (f);
6137
6138 xfree (f->output_data.w32);
6139 f->output_data.w32 = NULL;
6140
6141 if (f == dpyinfo->w32_focus_frame)
6142 dpyinfo->w32_focus_frame = 0;
6143 if (f == dpyinfo->w32_focus_event_frame)
6144 dpyinfo->w32_focus_event_frame = 0;
6145 if (f == dpyinfo->x_highlight_frame)
6146 dpyinfo->x_highlight_frame = 0;
6147
6148 if (f == hlinfo->mouse_face_mouse_frame)
6149 {
6150 hlinfo->mouse_face_beg_row
6151 = hlinfo->mouse_face_beg_col = -1;
6152 hlinfo->mouse_face_end_row
6153 = hlinfo->mouse_face_end_col = -1;
6154 hlinfo->mouse_face_window = Qnil;
6155 hlinfo->mouse_face_mouse_frame = 0;
6156 }
6157
6158 unblock_input ();
6159 }
6160
6161
6162 /* Destroy the window of frame F. */
6163 void
6164 x_destroy_window (struct frame *f)
6165 {
6166 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
6167
6168 x_free_frame_resources (f);
6169 dpyinfo->reference_count--;
6170 }
6171
6172 \f
6173 /* Setting window manager hints. */
6174
6175 /* Set the normal size hints for the window manager, for frame F.
6176 FLAGS is the flags word to use--or 0 meaning preserve the flags
6177 that the window now has.
6178 If USER_POSITION, set the USPosition
6179 flag (this is useful when FLAGS is 0). */
6180 void
6181 x_wm_set_size_hint (struct frame *f, long flags, bool user_position)
6182 {
6183 Window window = FRAME_W32_WINDOW (f);
6184
6185 enter_crit ();
6186
6187 SetWindowLong (window, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
6188 SetWindowLong (window, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
6189 SetWindowLong (window, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
6190 SetWindowLong (window, WND_SCROLLBAR_INDEX, f->scroll_bar_actual_width);
6191
6192 leave_crit ();
6193 }
6194
6195 /* Window manager things */
6196 void
6197 x_wm_set_icon_position (struct frame *f, int icon_x, int icon_y)
6198 {
6199 #if 0
6200 Window window = FRAME_W32_WINDOW (f);
6201
6202 f->display.x->wm_hints.flags |= IconPositionHint;
6203 f->display.x->wm_hints.icon_x = icon_x;
6204 f->display.x->wm_hints.icon_y = icon_y;
6205
6206 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->display.x->wm_hints);
6207 #endif
6208 }
6209
6210 \f
6211 /***********************************************************************
6212 Fonts
6213 ***********************************************************************/
6214
6215 #ifdef GLYPH_DEBUG
6216
6217 /* Check that FONT is valid on frame F. It is if it can be found in F's
6218 font table. */
6219
6220 static void
6221 x_check_font (struct frame *f, struct font *font)
6222 {
6223 eassert (font != NULL && ! NILP (font->props[FONT_TYPE_INDEX]));
6224 if (font->driver->check)
6225 eassert (font->driver->check (f, font) == 0);
6226 }
6227
6228 #endif /* GLYPH_DEBUG */
6229
6230
6231 \f
6232 /***********************************************************************
6233 Initialization
6234 ***********************************************************************/
6235
6236 static int w32_initialized = 0;
6237
6238 void
6239 w32_initialize_display_info (Lisp_Object display_name)
6240 {
6241 struct w32_display_info *dpyinfo = &one_w32_display_info;
6242 Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
6243
6244 memset (dpyinfo, 0, sizeof (*dpyinfo));
6245
6246 /* Put it on w32_display_name_list. */
6247 w32_display_name_list = Fcons (Fcons (display_name, Qnil),
6248 w32_display_name_list);
6249 dpyinfo->name_list_element = XCAR (w32_display_name_list);
6250
6251 dpyinfo->w32_id_name = xmalloc (SCHARS (Vinvocation_name)
6252 + SCHARS (Vsystem_name) + 2);
6253 sprintf (dpyinfo->w32_id_name, "%s@%s",
6254 SDATA (Vinvocation_name), SDATA (Vsystem_name));
6255
6256 /* Default Console mode values - overridden when running in GUI mode
6257 with values obtained from system metrics. */
6258 dpyinfo->resx = 1;
6259 dpyinfo->resy = 1;
6260 dpyinfo->n_planes = 1;
6261 dpyinfo->n_cbits = 4;
6262 dpyinfo->n_fonts = 0;
6263 dpyinfo->smallest_font_height = 1;
6264 dpyinfo->smallest_char_width = 1;
6265
6266 hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
6267 hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
6268 hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
6269 hlinfo->mouse_face_window = Qnil;
6270 hlinfo->mouse_face_overlay = Qnil;
6271 hlinfo->mouse_face_hidden = 0;
6272
6273 dpyinfo->vertical_scroll_bar_cursor = w32_load_cursor (IDC_ARROW);
6274 /* TODO: dpyinfo->gray */
6275
6276 }
6277
6278 /* Create an xrdb-style database of resources to supersede registry settings.
6279 The database is just a concatenation of C strings, finished by an additional
6280 \0. The strings are submitted to some basic normalization, so
6281
6282 [ *]option[ *]:[ *]value...
6283
6284 becomes
6285
6286 option:value...
6287
6288 but any whitespace following value is not removed. */
6289
6290 static char *
6291 w32_make_rdb (char *xrm_option)
6292 {
6293 char *buffer = xmalloc (strlen (xrm_option) + 2);
6294 char *current = buffer;
6295 char ch;
6296 int in_option = 1;
6297 int before_value = 0;
6298
6299 do {
6300 ch = *xrm_option++;
6301
6302 if (ch == '\n')
6303 {
6304 *current++ = '\0';
6305 in_option = 1;
6306 before_value = 0;
6307 }
6308 else if (ch != ' ')
6309 {
6310 *current++ = ch;
6311 if (in_option && (ch == ':'))
6312 {
6313 in_option = 0;
6314 before_value = 1;
6315 }
6316 else if (before_value)
6317 {
6318 before_value = 0;
6319 }
6320 }
6321 else if (!(in_option || before_value))
6322 {
6323 *current++ = ch;
6324 }
6325 } while (ch);
6326
6327 *current = '\0';
6328
6329 return buffer;
6330 }
6331
6332 void
6333 x_flush (struct frame * f)
6334 { /* Nothing to do */ }
6335
6336
6337 extern frame_parm_handler w32_frame_parm_handlers[];
6338
6339 static struct redisplay_interface w32_redisplay_interface =
6340 {
6341 w32_frame_parm_handlers,
6342 x_produce_glyphs,
6343 x_write_glyphs,
6344 x_insert_glyphs,
6345 x_clear_end_of_line,
6346 x_scroll_run,
6347 x_after_update_window_line,
6348 x_update_window_begin,
6349 x_update_window_end,
6350 x_cursor_to,
6351 x_flush,
6352 0, /* flush_display_optional */
6353 x_clear_window_mouse_face,
6354 x_get_glyph_overhangs,
6355 x_fix_overlapping_area,
6356 w32_draw_fringe_bitmap,
6357 w32_define_fringe_bitmap,
6358 w32_destroy_fringe_bitmap,
6359 w32_compute_glyph_string_overhangs,
6360 x_draw_glyph_string,
6361 w32_define_frame_cursor,
6362 w32_clear_frame_area,
6363 w32_draw_window_cursor,
6364 w32_draw_vertical_window_border,
6365 w32_shift_glyphs_for_insert
6366 };
6367
6368 static void x_delete_terminal (struct terminal *term);
6369
6370 static struct terminal *
6371 w32_create_terminal (struct w32_display_info *dpyinfo)
6372 {
6373 struct terminal *terminal;
6374
6375 terminal = create_terminal ();
6376
6377 terminal->type = output_w32;
6378 terminal->display_info.w32 = dpyinfo;
6379 dpyinfo->terminal = terminal;
6380
6381 /* MSVC does not type K&R functions with no arguments correctly, and
6382 so we must explicitly cast them. */
6383 terminal->clear_frame_hook = x_clear_frame;
6384 terminal->ins_del_lines_hook = x_ins_del_lines;
6385 terminal->delete_glyphs_hook = x_delete_glyphs;
6386 terminal->ring_bell_hook = w32_ring_bell;
6387 terminal->reset_terminal_modes_hook = w32_reset_terminal_modes;
6388 terminal->set_terminal_modes_hook = w32_set_terminal_modes;
6389 terminal->update_begin_hook = x_update_begin;
6390 terminal->update_end_hook = x_update_end;
6391 terminal->set_terminal_window_hook = w32_set_terminal_window;
6392 terminal->read_socket_hook = w32_read_socket;
6393 terminal->frame_up_to_date_hook = w32_frame_up_to_date;
6394 terminal->mouse_position_hook = w32_mouse_position;
6395 terminal->frame_rehighlight_hook = w32_frame_rehighlight;
6396 terminal->frame_raise_lower_hook = w32_frame_raise_lower;
6397 terminal->fullscreen_hook = w32fullscreen_hook;
6398 terminal->set_vertical_scroll_bar_hook = w32_set_vertical_scroll_bar;
6399 terminal->condemn_scroll_bars_hook = w32_condemn_scroll_bars;
6400 terminal->redeem_scroll_bar_hook = w32_redeem_scroll_bar;
6401 terminal->judge_scroll_bars_hook = w32_judge_scroll_bars;
6402
6403 terminal->delete_frame_hook = x_destroy_window;
6404 terminal->delete_terminal_hook = x_delete_terminal;
6405
6406 terminal->rif = &w32_redisplay_interface;
6407 terminal->scroll_region_ok = 1; /* We'll scroll partial frames. */
6408 terminal->char_ins_del_ok = 1;
6409 terminal->line_ins_del_ok = 1; /* We'll just blt 'em. */
6410 terminal->fast_clear_end_of_line = 1; /* X does this well. */
6411 terminal->memory_below_frame = 0; /* We don't remember what scrolls
6412 off the bottom. */
6413
6414 /* We don't yet support separate terminals on W32, so don't try to share
6415 keyboards between virtual terminals that are on the same physical
6416 terminal like X does. */
6417 terminal->kboard = xmalloc (sizeof (KBOARD));
6418 init_kboard (terminal->kboard);
6419 kset_window_system (terminal->kboard, intern ("w32"));
6420 terminal->kboard->next_kboard = all_kboards;
6421 all_kboards = terminal->kboard;
6422 /* Don't let the initial kboard remain current longer than necessary.
6423 That would cause problems if a file loaded on startup tries to
6424 prompt in the mini-buffer. */
6425 if (current_kboard == initial_kboard)
6426 current_kboard = terminal->kboard;
6427 terminal->kboard->reference_count++;
6428
6429 return terminal;
6430 }
6431
6432 static void
6433 x_delete_terminal (struct terminal *terminal)
6434 {
6435 struct w32_display_info *dpyinfo = terminal->display_info.w32;
6436
6437 /* Protect against recursive calls. delete_frame in
6438 delete_terminal calls us back when it deletes our last frame. */
6439 if (!terminal->name)
6440 return;
6441
6442 block_input ();
6443
6444 x_delete_display (dpyinfo);
6445 unblock_input ();
6446 }
6447
6448 struct w32_display_info *
6449 w32_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
6450 {
6451 struct w32_display_info *dpyinfo;
6452 struct terminal *terminal;
6453 HDC hdc;
6454
6455 block_input ();
6456
6457 if (!w32_initialized)
6458 {
6459 w32_initialize ();
6460 w32_initialized = 1;
6461 }
6462
6463 w32_initialize_display_info (display_name);
6464
6465 dpyinfo = &one_w32_display_info;
6466 terminal = w32_create_terminal (dpyinfo);
6467
6468 /* Set the name of the terminal. */
6469 terminal->name = xmalloc (SBYTES (display_name) + 1);
6470 strncpy (terminal->name, SDATA (display_name), SBYTES (display_name));
6471 terminal->name[SBYTES (display_name)] = 0;
6472
6473 dpyinfo->xrdb = xrm_option ? w32_make_rdb (xrm_option) : NULL;
6474
6475 /* Put this display on the chain. */
6476 dpyinfo->next = x_display_list;
6477 x_display_list = dpyinfo;
6478
6479 hdc = GetDC (NULL);
6480
6481 dpyinfo->root_window = GetDesktopWindow ();
6482 dpyinfo->n_planes = GetDeviceCaps (hdc, PLANES);
6483 dpyinfo->n_cbits = GetDeviceCaps (hdc, BITSPIXEL);
6484 dpyinfo->resx = GetDeviceCaps (hdc, LOGPIXELSX);
6485 dpyinfo->resy = GetDeviceCaps (hdc, LOGPIXELSY);
6486 dpyinfo->has_palette = GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE;
6487 ReleaseDC (NULL, hdc);
6488
6489 /* initialize palette with white and black */
6490 {
6491 XColor color;
6492 w32_defined_color (0, "white", &color, 1);
6493 w32_defined_color (0, "black", &color, 1);
6494 }
6495
6496 #ifdef WINDOWSNT
6497 /* Add the default keyboard. When !WINDOWSNT, we're using the
6498 standard Emacs console handling machinery and don't need an
6499 explicit FD here. */
6500 add_keyboard_wait_descriptor (0);
6501 #elif CYGWIN
6502 /* /dev/windows wakes us up when we have a thread message pending. */
6503 add_keyboard_wait_descriptor (w32_message_fd);
6504 #endif
6505
6506 /* Create Fringe Bitmaps and store them for later use.
6507
6508 On W32, bitmaps are all unsigned short, as Windows requires
6509 bitmap data to be Word aligned. For some reason they are
6510 horizontally reflected compared to how they appear on X, so we
6511 need to bitswap and convert to unsigned shorts before creating
6512 the bitmaps. */
6513 w32_init_fringe (terminal->rif);
6514
6515 unblock_input ();
6516
6517 return dpyinfo;
6518 }
6519 \f
6520 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6521 void
6522 x_delete_display (struct w32_display_info *dpyinfo)
6523 {
6524 /* Discard this display from w32_display_name_list and w32_display_list.
6525 We can't use Fdelq because that can quit. */
6526 if (! NILP (w32_display_name_list)
6527 && EQ (XCAR (w32_display_name_list), dpyinfo->name_list_element))
6528 w32_display_name_list = XCDR (w32_display_name_list);
6529 else
6530 {
6531 Lisp_Object tail;
6532
6533 tail = w32_display_name_list;
6534 while (CONSP (tail) && CONSP (XCDR (tail)))
6535 {
6536 if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
6537 {
6538 XSETCDR (tail, XCDR (XCDR (tail)));
6539 break;
6540 }
6541 tail = XCDR (tail);
6542 }
6543 }
6544
6545 /* free palette table */
6546 {
6547 struct w32_palette_entry * plist;
6548
6549 plist = dpyinfo->color_list;
6550 while (plist)
6551 {
6552 struct w32_palette_entry * pentry = plist;
6553 plist = plist->next;
6554 xfree (pentry);
6555 }
6556 dpyinfo->color_list = NULL;
6557 if (dpyinfo->palette)
6558 DeleteObject (dpyinfo->palette);
6559 }
6560 xfree (dpyinfo->w32_id_name);
6561
6562 w32_reset_fringes ();
6563 }
6564
6565 \f
6566 /* Set up use of W32. */
6567
6568 DWORD WINAPI w32_msg_worker (void * arg);
6569
6570 static void
6571 w32_initialize (void)
6572 {
6573 HANDLE shell;
6574 HRESULT (WINAPI * set_user_model) (wchar_t * id);
6575
6576 baud_rate = 19200;
6577
6578 w32_system_caret_hwnd = NULL;
6579 w32_system_caret_height = 0;
6580 w32_system_caret_x = 0;
6581 w32_system_caret_y = 0;
6582
6583 /* On Windows 7 and later, we need to set the user model ID
6584 to associate emacsclient launched files with Emacs frames
6585 in the UI. */
6586 shell = GetModuleHandle ("shell32.dll");
6587 if (shell)
6588 {
6589 set_user_model
6590 = (void *) GetProcAddress (shell,
6591 "SetCurrentProcessExplicitAppUserModelID");
6592
6593 /* If the function is defined, then we are running on Windows 7
6594 or newer, and the UI uses this to group related windows
6595 together. Since emacs, runemacs, emacsclient are related, we
6596 want them grouped even though the executables are different,
6597 so we need to set a consistent ID between them. */
6598 if (set_user_model)
6599 set_user_model (L"GNU.Emacs");
6600 }
6601
6602 #ifdef CYGWIN
6603 if ((w32_message_fd = open ("/dev/windows", O_RDWR | O_CLOEXEC)) == -1)
6604 fatal ("opening /dev/windows: %s", strerror (errno));
6605 #endif /* CYGWIN */
6606
6607 /* Initialize w32_use_visible_system_caret based on whether a screen
6608 reader is in use. */
6609 if (!SystemParametersInfo (SPI_GETSCREENREADER, 0,
6610 &w32_use_visible_system_caret, 0))
6611 w32_use_visible_system_caret = 0;
6612
6613 last_tool_bar_item = -1;
6614 any_help_event_p = 0;
6615
6616 /* Initialize input mode: interrupt_input off, no flow control, allow
6617 8 bit character input, standard quit char. */
6618 Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
6619
6620 {
6621 DWORD input_locale_id = ((DWORD_PTR) GetKeyboardLayout (0) & 0xffffffff);
6622 w32_keyboard_codepage =
6623 codepage_for_locale ((LCID) (input_locale_id & 0xffff));
6624 }
6625
6626 /* Create the window thread - it will terminate itself when the app
6627 terminates */
6628 init_crit ();
6629
6630 dwMainThreadId = GetCurrentThreadId ();
6631 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6632 GetCurrentProcess (), &hMainThread, 0, TRUE, DUPLICATE_SAME_ACCESS);
6633
6634 /* Wait for thread to start */
6635 {
6636 MSG msg;
6637
6638 PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
6639
6640 hWindowsThread = CreateThread (NULL, 0,
6641 w32_msg_worker,
6642 0, 0, &dwWindowsThreadId);
6643
6644 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
6645 }
6646
6647 /* It is desirable that mainThread should have the same notion of
6648 focus window and active window as windowsThread. Unfortunately, the
6649 following call to AttachThreadInput, which should do precisely what
6650 we need, causes major problems when Emacs is linked as a console
6651 program. Unfortunately, we have good reasons for doing that, so
6652 instead we need to send messages to windowsThread to make some API
6653 calls for us (ones that affect, or depend on, the active/focus
6654 window state.) */
6655 #ifdef ATTACH_THREADS
6656 AttachThreadInput (dwMainThreadId, dwWindowsThreadId, TRUE);
6657 #endif
6658
6659 /* Dynamically link to optional system components. */
6660 {
6661 HMODULE user_lib = GetModuleHandle ("user32.dll");
6662
6663 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
6664
6665 LOAD_PROC (user_lib, SetLayeredWindowAttributes);
6666
6667 #undef LOAD_PROC
6668
6669 /* Ensure scrollbar handle is at least 5 pixels. */
6670 vertical_scroll_bar_min_handle = 5;
6671
6672 /* For either kind of scroll bar, take account of the arrows; these
6673 effectively form the border of the main scroll bar range. */
6674 vertical_scroll_bar_top_border = vertical_scroll_bar_bottom_border
6675 = GetSystemMetrics (SM_CYVSCROLL);
6676 }
6677 }
6678
6679 void
6680 syms_of_w32term (void)
6681 {
6682 staticpro (&w32_display_name_list);
6683 w32_display_name_list = Qnil;
6684
6685 staticpro (&last_mouse_scroll_bar);
6686 last_mouse_scroll_bar = Qnil;
6687
6688 DEFSYM (Qvendor_specific_keysyms, "vendor-specific-keysyms");
6689
6690 DEFSYM (Qadded, "added");
6691 DEFSYM (Qremoved, "removed");
6692 DEFSYM (Qmodified, "modified");
6693 DEFSYM (Qrenamed_from, "renamed-from");
6694 DEFSYM (Qrenamed_to, "renamed-to");
6695
6696 DEFVAR_INT ("w32-num-mouse-buttons",
6697 w32_num_mouse_buttons,
6698 doc: /* Number of physical mouse buttons. */);
6699 w32_num_mouse_buttons = 2;
6700
6701 DEFVAR_LISP ("w32-swap-mouse-buttons",
6702 Vw32_swap_mouse_buttons,
6703 doc: /* Swap the mapping of middle and right mouse buttons.
6704 When nil, middle button is mouse-2 and right button is mouse-3. */);
6705 Vw32_swap_mouse_buttons = Qnil;
6706
6707 DEFVAR_LISP ("w32-grab-focus-on-raise",
6708 Vw32_grab_focus_on_raise,
6709 doc: /* Raised frame grabs input focus.
6710 When t, `raise-frame' grabs input focus as well. This fits well
6711 with the normal Windows click-to-focus policy, but might not be
6712 desirable when using a point-to-focus policy. */);
6713 Vw32_grab_focus_on_raise = Qt;
6714
6715 DEFVAR_LISP ("w32-capslock-is-shiftlock",
6716 Vw32_capslock_is_shiftlock,
6717 doc: /* Apply CapsLock state to non character input keys.
6718 When nil, CapsLock only affects normal character input keys. */);
6719 Vw32_capslock_is_shiftlock = Qnil;
6720
6721 DEFVAR_LISP ("w32-recognize-altgr",
6722 Vw32_recognize_altgr,
6723 doc: /* Recognize right-alt and left-ctrl as AltGr.
6724 When nil, the right-alt and left-ctrl key combination is
6725 interpreted normally. */);
6726 Vw32_recognize_altgr = Qt;
6727
6728 DEFVAR_BOOL ("w32-use-visible-system-caret",
6729 w32_use_visible_system_caret,
6730 doc: /* Flag to make the system caret visible.
6731 When this is non-nil, Emacs will indicate the position of point by
6732 using the system caret instead of drawing its own cursor. Some screen
6733 reader software does not track the system cursor properly when it is
6734 invisible, and gets confused by Emacs drawing its own cursor, so this
6735 variable is initialized to t when Emacs detects that screen reader
6736 software is running as it starts up.
6737
6738 When this variable is set, other variables affecting the appearance of
6739 the cursor have no effect. */);
6740
6741 w32_use_visible_system_caret = 0;
6742
6743 /* We don't yet support this, but defining this here avoids whining
6744 from cus-start.el and other places, like "M-x set-variable". */
6745 DEFVAR_BOOL ("x-use-underline-position-properties",
6746 x_use_underline_position_properties,
6747 doc: /* Non-nil means make use of UNDERLINE_POSITION font properties.
6748 A value of nil means ignore them. If you encounter fonts with bogus
6749 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
6750 to 4.1, set this to nil. You can also use `underline-minimum-offset'
6751 to override the font's UNDERLINE_POSITION for small font display
6752 sizes. */);
6753 x_use_underline_position_properties = 0;
6754
6755 DEFVAR_BOOL ("x-underline-at-descent-line",
6756 x_underline_at_descent_line,
6757 doc: /* Non-nil means to draw the underline at the same place as the descent line.
6758 A value of nil means to draw the underline according to the value of the
6759 variable `x-use-underline-position-properties', which is usually at the
6760 baseline level. The default value is nil. */);
6761 x_underline_at_descent_line = 0;
6762
6763 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars,
6764 doc: /* Which toolkit scroll bars Emacs uses, if any.
6765 A value of nil means Emacs doesn't use toolkit scroll bars.
6766 With the X Window system, the value is a symbol describing the
6767 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
6768 With MS Windows or Nextstep, the value is t. */);
6769 Vx_toolkit_scroll_bars = Qt;
6770
6771 staticpro (&last_mouse_motion_frame);
6772 last_mouse_motion_frame = Qnil;
6773
6774 Fprovide (intern_c_string ("w32"), Qnil);
6775 }