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