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