Merge from origin/emacs-25
[emacs.git] / src / w32term.c
blob74ea6b543bd75220ef79f733908c62acdc37a795
1 /* Implementation of GUI terminal on the Microsoft Windows API.
3 Copyright (C) 1989, 1993-2016 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or (at
10 your option) any later version.
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.
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/>. */
20 #include <config.h>
21 #include <signal.h>
22 #include <stdio.h>
23 #include "lisp.h"
24 #include "blockinput.h"
25 #include "w32term.h"
26 #include "w32common.h" /* for OS version info */
28 #include <ctype.h>
29 #include <errno.h>
30 #include <sys/stat.h>
31 #ifdef CYGWIN
32 #include <fcntl.h> /* for O_RDWR */
33 #endif
34 #include <imm.h>
36 #include "coding.h"
37 #include "frame.h"
38 #include "fontset.h"
39 #include "termhooks.h"
40 #include "termopts.h"
41 #include "termchar.h"
42 #include "buffer.h"
43 #include "window.h"
44 #include "keyboard.h"
45 #include "menu.h" /* for w32_menu_show */
47 #ifdef WINDOWSNT
48 #include "w32.h" /* for filename_from_utf16, filename_from_ansi */
49 #endif
51 #ifndef WINDOWSNT
52 #include <io.h> /* for get_osfhandle */
53 #endif
55 #include <shellapi.h>
57 #include "font.h"
58 #include "w32font.h"
60 #if 0 /* TODO: stipple */
61 #include "bitmaps/gray.xbm"
62 #endif
64 /* Fringe bitmaps. */
66 static int max_fringe_bmp = 0;
67 static HBITMAP *fringe_bmp = 0;
69 /* Temporary variables for w32_read_socket. */
71 static int last_mousemove_x = 0;
72 static int last_mousemove_y = 0;
74 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
75 #ifndef GET_WHEEL_DELTA_WPARAM
76 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
77 #endif
79 /* Non-zero means that a HELP_EVENT has been generated since Emacs
80 start. */
82 static int any_help_event_p;
84 extern unsigned int msh_mousewheel;
86 extern void free_frame_menubar (struct frame *);
88 extern int w32_codepage_for_font (char *fontname);
89 extern Cursor w32_load_cursor (LPCTSTR name);
91 #define x_any_window_to_frame x_window_to_frame
92 #define x_top_window_to_frame x_window_to_frame
95 /* This is display since w32 does not support multiple ones. */
96 struct w32_display_info one_w32_display_info;
97 struct w32_display_info *x_display_list;
99 #if _WIN32_WINNT < 0x0500 && !defined(MINGW_W64)
100 /* Pre Windows 2000, this was not available, but define it here so
101 that Emacs compiled on such a platform will run on newer versions.
102 MinGW64 defines these unconditionally, so avoid redefining. */
104 typedef struct tagWCRANGE
106 WCHAR wcLow;
107 USHORT cGlyphs;
108 } WCRANGE;
110 typedef struct tagGLYPHSET
112 DWORD cbThis;
113 DWORD flAccel;
114 DWORD cGlyphsSupported;
115 DWORD cRanges;
116 WCRANGE ranges[1];
117 } GLYPHSET;
119 #endif /* compiling for pre-Win2k */
121 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
122 BOOL (WINAPI *pfnSetLayeredWindowAttributes) (HWND, COLORREF, BYTE, DWORD);
124 #ifndef LWA_ALPHA
125 #define LWA_ALPHA 0x02
126 #endif
127 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
128 later targets by MSVC headers. */
129 #ifndef WS_EX_LAYERED
130 #define WS_EX_LAYERED 0x80000
131 #endif
133 /* SM_CXVIRTUALSCREEN and SM_CYVIRTUALSCREEN are not defined on 95 and
134 NT4. */
135 #ifndef SM_CXVIRTUALSCREEN
136 #define SM_CXVIRTUALSCREEN 78
137 #endif
138 #ifndef SM_CYVIRTUALSCREEN
139 #define SM_CYVIRTUALSCREEN 79
140 #endif
142 /* The handle of the frame that currently owns the system caret. */
143 HWND w32_system_caret_hwnd;
144 int w32_system_caret_height;
145 int w32_system_caret_x;
146 int w32_system_caret_y;
147 struct window *w32_system_caret_window;
148 int w32_system_caret_hdr_height;
149 int w32_system_caret_mode_height;
150 DWORD dwWindowsThreadId = 0;
151 HANDLE hWindowsThread = NULL;
152 DWORD dwMainThreadId = 0;
153 HANDLE hMainThread = NULL;
155 int vertical_scroll_bar_min_handle;
156 int horizontal_scroll_bar_min_handle;
157 int vertical_scroll_bar_top_border;
158 int vertical_scroll_bar_bottom_border;
159 int horizontal_scroll_bar_left_border;
160 int horizontal_scroll_bar_right_border;
162 int last_scroll_bar_drag_pos;
164 /* Keyboard code page - may be changed by language-change events. */
165 int w32_keyboard_codepage;
167 /* Incremented by w32_read_socket whenever it really tries to read
168 events. */
169 static int volatile input_signal_count;
171 #ifdef CYGWIN
172 int w32_message_fd = -1;
173 #endif /* CYGWIN */
175 static void w32_handle_tool_bar_click (struct frame *,
176 struct input_event *);
177 static void w32_define_cursor (Window, Cursor);
179 void x_lower_frame (struct frame *);
180 void x_scroll_bar_clear (struct frame *);
181 void x_wm_set_size_hint (struct frame *, long, bool);
182 void x_raise_frame (struct frame *);
183 void x_set_window_size (struct frame *, bool, int, int, bool);
184 void x_wm_set_window_state (struct frame *, int);
185 void x_wm_set_icon_pixmap (struct frame *, int);
186 static void w32_initialize (void);
187 static void x_update_end (struct frame *);
188 static void w32_frame_up_to_date (struct frame *);
189 static void x_clear_frame (struct frame *);
190 static void frame_highlight (struct frame *);
191 static void frame_unhighlight (struct frame *);
192 static void x_new_focus_frame (struct w32_display_info *,
193 struct frame *);
194 static void x_focus_changed (int, int, struct w32_display_info *,
195 struct frame *, struct input_event *);
196 static void w32_detect_focus_change (struct w32_display_info *,
197 W32Msg *, struct input_event *);
198 static void w32_frame_rehighlight (struct frame *);
199 static void x_frame_rehighlight (struct w32_display_info *);
200 static void x_draw_hollow_cursor (struct window *, struct glyph_row *);
201 static void x_draw_bar_cursor (struct window *, struct glyph_row *, int,
202 enum text_cursor_kinds);
203 static void w32_clip_to_row (struct window *, struct glyph_row *,
204 enum glyph_row_area, HDC);
205 static BOOL my_show_window (struct frame *, HWND, int);
206 static void my_set_window_pos (HWND, HWND, int, int, int, int, UINT);
207 #if 0
208 static void my_set_focus (struct frame *, HWND);
209 #endif
210 static void my_set_foreground_window (HWND);
211 static void my_destroy_window (struct frame *, HWND);
212 static void w32fullscreen_hook (struct frame *);
214 #ifdef GLYPH_DEBUG
215 static void x_check_font (struct frame *, struct font *);
216 #endif
219 /***********************************************************************
220 Debugging
221 ***********************************************************************/
223 #if 0
225 /* This is a function useful for recording debugging information about
226 the sequence of occurrences in this file. */
228 struct record
230 char *locus;
231 int type;
234 struct record event_record[100];
236 int event_record_index;
238 record_event (char *locus, int type)
240 if (event_record_index == sizeof (event_record) / sizeof (struct record))
241 event_record_index = 0;
243 event_record[event_record_index].locus = locus;
244 event_record[event_record_index].type = type;
245 event_record_index++;
248 #endif /* 0 */
251 void
252 XChangeGC (void *ignore, XGCValues *gc, unsigned long mask,
253 XGCValues *xgcv)
255 if (mask & GCForeground)
256 gc->foreground = xgcv->foreground;
257 if (mask & GCBackground)
258 gc->background = xgcv->background;
259 if (mask & GCFont)
260 gc->font = xgcv->font;
263 XGCValues *
264 XCreateGC (void *ignore, Window window, unsigned long mask, XGCValues *xgcv)
266 XGCValues *gc = xzalloc (sizeof (XGCValues));
268 XChangeGC (ignore, gc, mask, xgcv);
270 return gc;
273 void
274 XGetGCValues (void *ignore, XGCValues *gc,
275 unsigned long mask, XGCValues *xgcv)
277 XChangeGC (ignore, xgcv, mask, gc);
280 static void
281 w32_set_clip_rectangle (HDC hdc, RECT *rect)
283 if (rect)
285 HRGN clip_region = CreateRectRgnIndirect (rect);
286 SelectClipRgn (hdc, clip_region);
287 DeleteObject (clip_region);
289 else
290 SelectClipRgn (hdc, NULL);
293 /* Restore clipping rectangle in S */
294 static void
295 w32_restore_glyph_string_clip (struct glyph_string *s)
297 RECT *r = s->clip;
298 int n = s->num_clips;
300 if (n == 1)
301 w32_set_clip_rectangle (s->hdc, r);
302 else if (n > 1)
304 HRGN clip1 = CreateRectRgnIndirect (r);
305 HRGN clip2 = CreateRectRgnIndirect (r + 1);
306 if (CombineRgn (clip1, clip1, clip2, RGN_OR) != ERROR)
307 SelectClipRgn (s->hdc, clip1);
308 DeleteObject (clip1);
309 DeleteObject (clip2);
314 Draw a wavy line under S. The wave fills wave_height pixels from y0.
316 x0 wave_length = 2
318 y0 * * * * *
319 |* * * * * * * * *
320 wave_height = 3 | * * * *
324 void
325 w32_draw_underwave (struct glyph_string *s, COLORREF color)
327 int wave_height = 3, wave_length = 2;
328 int dx, dy, x0, y0, width, x1, y1, x2, y2, odd, xmax;
329 XRectangle wave_clip, string_clip, final_clip;
330 RECT w32_final_clip, w32_string_clip;
331 HPEN hp, oldhp;
333 dx = wave_length;
334 dy = wave_height - 1;
335 x0 = s->x;
336 y0 = s->ybase - wave_height + 3;
337 width = s->width;
338 xmax = x0 + width;
340 /* Find and set clipping rectangle */
342 wave_clip.x = x0;
343 wave_clip.y = y0;
344 wave_clip.width = width;
345 wave_clip.height = wave_height;
347 get_glyph_string_clip_rect (s, &w32_string_clip);
348 CONVERT_TO_XRECT (string_clip, w32_string_clip);
350 if (!x_intersect_rectangles (&wave_clip, &string_clip, &final_clip))
351 return;
353 hp = CreatePen (PS_SOLID, 0, color);
354 oldhp = SelectObject (s->hdc, hp);
355 CONVERT_FROM_XRECT (final_clip, w32_final_clip);
356 w32_set_clip_rectangle (s->hdc, &w32_final_clip);
358 /* Draw the waves */
360 x1 = x0 - (x0 % dx);
361 x2 = x1 + dx;
362 odd = (x1/dx) % 2;
363 y1 = y2 = y0;
365 if (odd)
366 y1 += dy;
367 else
368 y2 += dy;
370 MoveToEx (s->hdc, x1, y1, NULL);
372 while (x1 <= xmax)
374 LineTo (s->hdc, x2, y2);
375 x1 = x2, y1 = y2;
376 x2 += dx, y2 = y0 + odd*dy;
377 odd = !odd;
380 /* Restore previous pen and clipping rectangle(s) */
381 w32_restore_glyph_string_clip (s);
382 SelectObject (s->hdc, oldhp);
383 DeleteObject (hp);
386 /* Draw a hollow rectangle at the specified position. */
387 void
388 w32_draw_rectangle (HDC hdc, XGCValues *gc, int x, int y,
389 int width, int height)
391 HBRUSH hb, oldhb;
392 HPEN hp, oldhp;
394 hb = CreateSolidBrush (gc->background);
395 hp = CreatePen (PS_SOLID, 0, gc->foreground);
396 oldhb = SelectObject (hdc, hb);
397 oldhp = SelectObject (hdc, hp);
399 /* We enlarge WIDTH and HEIGHT by 1 to be bug-compatible to the
400 brain-dead design of XDrawRectangle, which draws a rectangle that
401 is 1 pixel wider and higher than its arguments WIDTH and HEIGHT.
402 This allows us to keep the code that calls this function similar
403 to the corresponding code in xterm.c. For the details, see
404 http://lists.gnu.org/archives/html/emacs-devel/2014-10/msg00546.html. */
405 Rectangle (hdc, x, y, x + width + 1, y + height + 1);
407 SelectObject (hdc, oldhb);
408 SelectObject (hdc, oldhp);
409 DeleteObject (hb);
410 DeleteObject (hp);
413 /* Draw a filled rectangle at the specified position. */
414 void
415 w32_fill_rect (struct frame *f, HDC hdc, COLORREF pix, RECT *lprect)
417 HBRUSH hb;
419 hb = CreateSolidBrush (pix);
420 FillRect (hdc, lprect, hb);
421 DeleteObject (hb);
424 void
425 w32_clear_window (struct frame *f)
427 RECT rect;
428 HDC hdc = get_frame_dc (f);
430 /* Under certain conditions, this can be called at startup with
431 a console frame pointer before the GUI frame is created. An HDC
432 of 0 indicates this. */
433 if (hdc)
435 GetClientRect (FRAME_W32_WINDOW (f), &rect);
436 w32_clear_rect (f, hdc, &rect);
439 release_frame_dc (f, hdc);
442 #define OPAQUE_FRAME 255
444 void
445 x_set_frame_alpha (struct frame *f)
447 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
448 double alpha = 1.0;
449 double alpha_min = 1.0;
450 BYTE opac;
451 LONG ex_style;
452 HWND window = FRAME_W32_WINDOW (f);
454 /* Older versions of Windows do not support transparency. */
455 if (!pfnSetLayeredWindowAttributes)
456 return;
458 if (dpyinfo->w32_focus_frame == f)
459 alpha = f->alpha[0];
460 else
461 alpha = f->alpha[1];
463 if (FLOATP (Vframe_alpha_lower_limit))
464 alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
465 else if (INTEGERP (Vframe_alpha_lower_limit))
466 alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
468 if (alpha < 0.0)
469 return;
470 else if (alpha > 1.0)
471 alpha = 1.0;
472 else if (alpha < alpha_min && alpha_min <= 1.0)
473 alpha = alpha_min;
475 opac = alpha * OPAQUE_FRAME;
477 ex_style = GetWindowLong (window, GWL_EXSTYLE);
479 if (opac == OPAQUE_FRAME)
480 ex_style &= ~WS_EX_LAYERED;
481 else
482 ex_style |= WS_EX_LAYERED;
484 SetWindowLong (window, GWL_EXSTYLE, ex_style);
486 if (opac != OPAQUE_FRAME)
487 pfnSetLayeredWindowAttributes (window, 0, opac, LWA_ALPHA);
491 x_display_pixel_height (struct w32_display_info *dpyinfo)
493 int pixels = GetSystemMetrics (SM_CYVIRTUALSCREEN);
495 if (pixels == 0)
496 /* Fallback for Windows 95 or NT 4.0. */
497 pixels = GetSystemMetrics (SM_CYSCREEN);
499 return pixels;
503 x_display_pixel_width (struct w32_display_info *dpyinfo)
505 int pixels = GetSystemMetrics (SM_CXVIRTUALSCREEN);
507 if (pixels == 0)
508 /* Fallback for Windows 95 or NT 4.0. */
509 pixels = GetSystemMetrics (SM_CXSCREEN);
511 return pixels;
515 /***********************************************************************
516 Starting and ending an update
517 ***********************************************************************/
519 /* Start an update of frame F. This function is installed as a hook
520 for update_begin, i.e. it is called when update_begin is called.
521 This function is called prior to calls to x_update_window_begin for
522 each window being updated. */
524 static void
525 x_update_begin (struct frame *f)
527 struct w32_display_info *display_info = FRAME_DISPLAY_INFO (f);
529 if (! FRAME_W32_P (f))
530 return;
532 /* Regenerate display palette before drawing if list of requested
533 colors has changed. */
534 if (display_info->regen_palette)
536 w32_regenerate_palette (f);
537 display_info->regen_palette = FALSE;
542 /* Start update of window W. */
544 static void
545 x_update_window_begin (struct window *w)
547 struct frame *f = XFRAME (WINDOW_FRAME (w));
548 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
550 /* Hide the system caret during an update. */
551 if (w32_use_visible_system_caret && w32_system_caret_hwnd)
553 SendMessage (w32_system_caret_hwnd, WM_EMACS_HIDE_CARET, 0, 0);
556 w->output_cursor = w->cursor;
558 block_input ();
560 if (f == hlinfo->mouse_face_mouse_frame)
562 /* Don't do highlighting for mouse motion during the update. */
563 hlinfo->mouse_face_defer = true;
565 /* If F needs to be redrawn, simply forget about any prior mouse
566 highlighting. */
567 if (FRAME_GARBAGED_P (f))
568 hlinfo->mouse_face_window = Qnil;
570 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
571 their mouse_face_p flag set, which means that they are always
572 unequal to rows in a desired matrix which never have that
573 flag set. So, rows containing mouse-face glyphs are never
574 scrolled, and we don't have to switch the mouse highlight off
575 here to prevent it from being scrolled. */
577 /* Can we tell that this update does not affect the window
578 where the mouse highlight is? If so, no need to turn off.
579 Likewise, don't do anything if the frame is garbaged;
580 in that case, the frame's current matrix that we would use
581 is all wrong, and we will redisplay that line anyway. */
582 if (!NILP (hlinfo->mouse_face_window)
583 && w == XWINDOW (hlinfo->mouse_face_window))
585 int i;
587 for (i = 0; i < w->desired_matrix->nrows; ++i)
588 if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
589 break;
591 if (i < w->desired_matrix->nrows)
592 clear_mouse_face (hlinfo);
594 #endif /* 0 */
597 unblock_input ();
600 /* Draw a vertical window border from (x,y0) to (x,y1) */
602 static void
603 w32_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
605 struct frame *f = XFRAME (WINDOW_FRAME (w));
606 RECT r;
607 HDC hdc;
608 struct face *face;
610 r.left = x;
611 r.right = x + 1;
612 r.top = y0;
613 r.bottom = y1;
615 hdc = get_frame_dc (f);
616 face = FACE_FROM_ID (f, VERTICAL_BORDER_FACE_ID);
617 if (face)
618 w32_fill_rect (f, hdc, face->foreground, &r);
619 else
620 w32_fill_rect (f, hdc, FRAME_FOREGROUND_PIXEL (f), &r);
622 release_frame_dc (f, hdc);
626 /* Draw a window divider from (x0, y0) to (x1, y1) */
628 static void
629 w32_draw_window_divider (struct window *w, int x0, int x1, int y0, int y1)
631 struct frame *f = XFRAME (WINDOW_FRAME (w));
632 HDC hdc = get_frame_dc (f);
633 struct face *face = FACE_FROM_ID (f, WINDOW_DIVIDER_FACE_ID);
634 struct face *face_first = FACE_FROM_ID (f, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID);
635 struct face *face_last = FACE_FROM_ID (f, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID);
636 unsigned long color = face ? face->foreground : FRAME_FOREGROUND_PIXEL (f);
637 unsigned long color_first = (face_first
638 ? face_first->foreground
639 : FRAME_FOREGROUND_PIXEL (f));
640 unsigned long color_last = (face_last
641 ? face_last->foreground
642 : FRAME_FOREGROUND_PIXEL (f));
644 if (y1 - y0 > x1 - x0 && x1 - x0 > 2)
645 /* Vertical. */
647 w32_fill_area_abs (f, hdc, color_first, x0, y0, x0 + 1, y1);
648 w32_fill_area_abs (f, hdc, color, x0 + 1, y0, x1 - 1, y1);
649 w32_fill_area_abs (f, hdc, color_last, x1 - 1, y0, x1, y1);
651 else if (x1 - x0 > y1 - y0 && y1 - y0 > 3)
652 /* Horizontal. */
654 w32_fill_area_abs (f, hdc, color_first, x0, y0, x1, y0 + 1);
655 w32_fill_area_abs (f, hdc, color, x0, y0 + 1, x1, y1 - 1);
656 w32_fill_area_abs (f, hdc, color_last, x0, y1 - 1, x1, y1);
658 else
659 w32_fill_area_abs (f, hdc, color, x0, y0, x1, y1);
661 release_frame_dc (f, hdc);
664 /* End update of window W.
666 Draw vertical borders between horizontally adjacent windows, and
667 display W's cursor if CURSOR_ON_P is non-zero.
669 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
670 glyphs in mouse-face were overwritten. In that case we have to
671 make sure that the mouse-highlight is properly redrawn.
673 W may be a menu bar pseudo-window in case we don't have X toolkit
674 support. Such windows don't have a cursor, so don't display it
675 here. */
677 static void
678 x_update_window_end (struct window *w, bool cursor_on_p,
679 bool mouse_face_overwritten_p)
681 if (!w->pseudo_window_p)
683 block_input ();
685 if (cursor_on_p)
686 display_and_set_cursor (w, true,
687 w->output_cursor.hpos, w->output_cursor.vpos,
688 w->output_cursor.x, w->output_cursor.y);
690 if (draw_window_fringes (w, true))
692 if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
693 x_draw_right_divider (w);
694 else
695 x_draw_vertical_border (w);
698 unblock_input ();
701 /* If a row with mouse-face was overwritten, arrange for
702 XTframe_up_to_date to redisplay the mouse highlight. */
703 if (mouse_face_overwritten_p)
705 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
707 hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
708 hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
709 hlinfo->mouse_face_window = Qnil;
712 /* Unhide the caret. This won't actually show the cursor, unless it
713 was visible before the corresponding call to HideCaret in
714 x_update_window_begin. */
715 if (w32_use_visible_system_caret && w32_system_caret_hwnd)
717 SendMessage (w32_system_caret_hwnd, WM_EMACS_SHOW_CARET, 0, 0);
722 /* End update of frame F. This function is installed as a hook in
723 update_end. */
725 static void
726 x_update_end (struct frame *f)
728 if (! FRAME_W32_P (f))
729 return;
731 /* Mouse highlight may be displayed again. */
732 MOUSE_HL_INFO (f)->mouse_face_defer = false;
736 /* This function is called from various places in xdisp.c
737 whenever a complete update has been performed. */
739 static void
740 w32_frame_up_to_date (struct frame *f)
742 if (FRAME_W32_P (f))
743 FRAME_MOUSE_UPDATE (f);
747 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
748 arrow bitmaps, or clear the fringes if no bitmaps are required
749 before DESIRED_ROW is made current. This function is called from
750 update_window_line only if it is known that there are differences
751 between bitmaps to be drawn between current row and DESIRED_ROW. */
753 static void
754 x_after_update_window_line (struct window *w, struct glyph_row *desired_row)
756 struct frame *f;
757 int width, height;
759 eassert (w);
761 if (!desired_row->mode_line_p && !w->pseudo_window_p)
762 desired_row->redraw_fringe_bitmaps_p = true;
764 /* When a window has disappeared, make sure that no rest of
765 full-width rows stays visible in the internal border. Could
766 check here if updated window is the leftmost/rightmost window,
767 but I guess it's not worth doing since vertically split windows
768 are almost never used, internal border is rarely set, and the
769 overhead is very small. */
770 if (windows_or_buffers_changed
771 && desired_row->full_width_p
772 && (f = XFRAME (w->frame),
773 width = FRAME_INTERNAL_BORDER_WIDTH (f),
774 width != 0)
775 && (height = desired_row->visible_height,
776 height > 0))
778 int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
780 block_input ();
782 HDC hdc = get_frame_dc (f);
783 w32_clear_area (f, hdc, 0, y, width, height);
784 w32_clear_area (f, hdc, FRAME_PIXEL_WIDTH (f) - width,
785 y, width, height);
786 release_frame_dc (f, hdc);
788 unblock_input ();
793 /* Draw the bitmap WHICH in one of the left or right fringes of
794 window W. ROW is the glyph row for which to display the bitmap; it
795 determines the vertical position at which the bitmap has to be
796 drawn. */
798 static void
799 w32_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
800 struct draw_fringe_bitmap_params *p)
802 struct frame *f = XFRAME (WINDOW_FRAME (w));
803 HDC hdc;
804 struct face *face = p->face;
806 hdc = get_frame_dc (f);
808 /* Must clip because of partially visible lines. */
809 w32_clip_to_row (w, row, ANY_AREA, hdc);
811 if (p->bx >= 0 && !p->overlay_p)
812 w32_fill_area (f, hdc, face->background,
813 p->bx, p->by, p->nx, p->ny);
815 if (p->which && p->which < max_fringe_bmp)
817 HBITMAP pixmap = fringe_bmp[p->which];
818 HDC compat_hdc;
819 HANDLE horig_obj;
821 compat_hdc = CreateCompatibleDC (hdc);
823 SaveDC (hdc);
825 horig_obj = SelectObject (compat_hdc, pixmap);
827 /* Paint overlays transparently. */
828 if (p->overlay_p)
830 HBRUSH h_brush, h_orig_brush;
832 SetTextColor (hdc, BLACK_PIX_DEFAULT (f));
833 SetBkColor (hdc, WHITE_PIX_DEFAULT (f));
834 h_brush = CreateSolidBrush (face->foreground);
835 h_orig_brush = SelectObject (hdc, h_brush);
837 BitBlt (hdc, p->x, p->y, p->wd, p->h,
838 compat_hdc, 0, p->dh,
839 DSTINVERT);
840 BitBlt (hdc, p->x, p->y, p->wd, p->h,
841 compat_hdc, 0, p->dh,
842 0x2E064A);
843 BitBlt (hdc, p->x, p->y, p->wd, p->h,
844 compat_hdc, 0, p->dh,
845 DSTINVERT);
847 SelectObject (hdc, h_orig_brush);
848 DeleteObject (h_brush);
850 else
852 SetTextColor (hdc, face->background);
853 SetBkColor (hdc, (p->cursor_p
854 ? f->output_data.w32->cursor_pixel
855 : face->foreground));
857 BitBlt (hdc, p->x, p->y, p->wd, p->h,
858 compat_hdc, 0, p->dh,
859 SRCCOPY);
862 SelectObject (compat_hdc, horig_obj);
863 DeleteDC (compat_hdc);
864 RestoreDC (hdc, -1);
867 w32_set_clip_rectangle (hdc, NULL);
869 release_frame_dc (f, hdc);
872 static void
873 w32_define_fringe_bitmap (int which, unsigned short *bits, int h, int wd)
875 if (which >= max_fringe_bmp)
877 int i = max_fringe_bmp;
878 max_fringe_bmp = which + 20;
879 fringe_bmp = (HBITMAP *) xrealloc (fringe_bmp, max_fringe_bmp * sizeof (HBITMAP));
880 while (i < max_fringe_bmp)
881 fringe_bmp[i++] = 0;
884 fringe_bmp[which] = CreateBitmap (wd, h, 1, 1, bits);
887 static void
888 w32_destroy_fringe_bitmap (int which)
890 if (which >= max_fringe_bmp)
891 return;
893 if (fringe_bmp[which])
894 DeleteObject (fringe_bmp[which]);
895 fringe_bmp[which] = 0;
898 /***********************************************************************
899 Display Iterator
900 ***********************************************************************/
902 /* Function prototypes of this page. */
904 static void x_set_glyph_string_clipping (struct glyph_string *);
905 static void x_set_glyph_string_gc (struct glyph_string *);
906 static void x_draw_glyph_string_background (struct glyph_string *,
907 bool);
908 static void x_draw_glyph_string_foreground (struct glyph_string *);
909 static void x_draw_composite_glyph_string_foreground (struct glyph_string *);
910 static void x_draw_glyph_string_box (struct glyph_string *);
911 static void x_draw_glyph_string (struct glyph_string *);
912 static void x_set_cursor_gc (struct glyph_string *);
913 static void x_set_mode_line_face_gc (struct glyph_string *);
914 static void x_set_mouse_face_gc (struct glyph_string *);
915 static int w32_alloc_lighter_color (struct frame *, COLORREF *, double, int);
916 static void w32_setup_relief_color (struct frame *, struct relief *,
917 double, int, COLORREF);
918 static void x_setup_relief_colors (struct glyph_string *);
919 static void x_draw_image_glyph_string (struct glyph_string *);
920 static void x_draw_image_relief (struct glyph_string *);
921 static void x_draw_image_foreground (struct glyph_string *);
922 static void w32_draw_image_foreground_1 (struct glyph_string *, HBITMAP);
923 static void x_clear_glyph_string_rect (struct glyph_string *, int,
924 int, int, int);
925 static void w32_draw_relief_rect (struct frame *, int, int, int, int,
926 int, int, int, int, int, int,
927 RECT *);
928 static void w32_draw_box_rect (struct glyph_string *, int, int, int, int,
929 int, bool, bool, RECT *);
932 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
933 face. */
935 static void
936 x_set_cursor_gc (struct glyph_string *s)
938 if (s->font == FRAME_FONT (s->f)
939 && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
940 && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
941 && !s->cmp)
942 s->gc = s->f->output_data.w32->cursor_gc;
943 else
945 /* Cursor on non-default face: must merge. */
946 XGCValues xgcv;
947 unsigned long mask;
949 xgcv.background = s->f->output_data.w32->cursor_pixel;
950 xgcv.foreground = s->face->background;
952 /* If the glyph would be invisible, try a different foreground. */
953 if (xgcv.foreground == xgcv.background)
954 xgcv.foreground = s->face->foreground;
955 if (xgcv.foreground == xgcv.background)
956 xgcv.foreground = s->f->output_data.w32->cursor_foreground_pixel;
957 if (xgcv.foreground == xgcv.background)
958 xgcv.foreground = s->face->foreground;
960 /* Make sure the cursor is distinct from text in this face. */
961 if (xgcv.background == s->face->background
962 && xgcv.foreground == s->face->foreground)
964 xgcv.background = s->face->foreground;
965 xgcv.foreground = s->face->background;
968 IF_DEBUG (x_check_font (s->f, s->font));
969 xgcv.font = s->font;
970 mask = GCForeground | GCBackground | GCFont;
972 if (FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc)
973 XChangeGC (NULL, FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc,
974 mask, &xgcv);
975 else
976 FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc
977 = XCreateGC (NULL, s->window, mask, &xgcv);
979 s->gc = FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc;
984 /* Set up S->gc of glyph string S for drawing text in mouse face. */
986 static void
987 x_set_mouse_face_gc (struct glyph_string *s)
989 int face_id;
990 struct face *face;
992 /* What face has to be used last for the mouse face? */
993 face_id = MOUSE_HL_INFO (s->f)->mouse_face_face_id;
994 face = FACE_FROM_ID (s->f, face_id);
995 if (face == NULL)
996 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
998 if (s->first_glyph->type == CHAR_GLYPH)
999 face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch, -1, Qnil);
1000 else
1001 face_id = FACE_FOR_CHAR (s->f, face, 0, -1, Qnil);
1002 s->face = FACE_FROM_ID (s->f, face_id);
1003 prepare_face_for_display (s->f, s->face);
1005 /* If font in this face is same as S->font, use it. */
1006 if (s->font == s->face->font)
1007 s->gc = s->face->gc;
1008 else
1010 /* Otherwise construct scratch_cursor_gc with values from FACE
1011 but font FONT. */
1012 XGCValues xgcv;
1013 unsigned long mask;
1015 xgcv.background = s->face->background;
1016 xgcv.foreground = s->face->foreground;
1017 IF_DEBUG (x_check_font (s->f, s->font));
1018 xgcv.font = s->font;
1019 mask = GCForeground | GCBackground | GCFont;
1021 if (FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc)
1022 XChangeGC (NULL, FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc,
1023 mask, &xgcv);
1024 else
1025 FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc
1026 = XCreateGC (NULL, s->window, mask, &xgcv);
1028 s->gc = FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc;
1031 eassert (s->gc != 0);
1035 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1036 Faces to use in the mode line have already been computed when the
1037 matrix was built, so there isn't much to do, here. */
1039 static inline void
1040 x_set_mode_line_face_gc (struct glyph_string *s)
1042 s->gc = s->face->gc;
1046 /* Set S->gc of glyph string S for drawing that glyph string. Set
1047 S->stippled_p to a non-zero value if the face of S has a stipple
1048 pattern. */
1050 static inline void
1051 x_set_glyph_string_gc (struct glyph_string *s)
1053 prepare_face_for_display (s->f, s->face);
1055 if (s->hl == DRAW_NORMAL_TEXT)
1057 s->gc = s->face->gc;
1058 s->stippled_p = s->face->stipple != 0;
1060 else if (s->hl == DRAW_INVERSE_VIDEO)
1062 x_set_mode_line_face_gc (s);
1063 s->stippled_p = s->face->stipple != 0;
1065 else if (s->hl == DRAW_CURSOR)
1067 x_set_cursor_gc (s);
1068 s->stippled_p = false;
1070 else if (s->hl == DRAW_MOUSE_FACE)
1072 x_set_mouse_face_gc (s);
1073 s->stippled_p = s->face->stipple != 0;
1075 else if (s->hl == DRAW_IMAGE_RAISED
1076 || s->hl == DRAW_IMAGE_SUNKEN)
1078 s->gc = s->face->gc;
1079 s->stippled_p = s->face->stipple != 0;
1081 else
1082 emacs_abort ();
1084 /* GC must have been set. */
1085 eassert (s->gc != 0);
1089 /* Set clipping for output of glyph string S. S may be part of a mode
1090 line or menu if we don't have X toolkit support. */
1092 static inline void
1093 x_set_glyph_string_clipping (struct glyph_string *s)
1095 RECT *r = s->clip;
1096 int n = get_glyph_string_clip_rects (s, r, 2);
1098 if (n == 1)
1099 w32_set_clip_rectangle (s->hdc, r);
1100 else if (n > 1)
1102 HRGN clip1 = CreateRectRgnIndirect (r);
1103 HRGN clip2 = CreateRectRgnIndirect (r + 1);
1104 if (CombineRgn (clip1, clip1, clip2, RGN_OR) != ERROR)
1105 SelectClipRgn (s->hdc, clip1);
1106 DeleteObject (clip1);
1107 DeleteObject (clip2);
1109 s->num_clips = n;
1112 /* Set SRC's clipping for output of glyph string DST. This is called
1113 when we are drawing DST's left_overhang or right_overhang only in
1114 the area of SRC. */
1116 static void
1117 x_set_glyph_string_clipping_exactly (struct glyph_string *src,
1118 struct glyph_string *dst)
1120 RECT r;
1122 r.left = src->x;
1123 r.right = r.left + src->width;
1124 r.top = src->y;
1125 r.bottom = r.top + src->height;
1126 dst->clip[0] = r;
1127 dst->num_clips = 1;
1128 w32_set_clip_rectangle (dst->hdc, &r);
1131 /* RIF:
1132 Compute left and right overhang of glyph string S. */
1134 static void
1135 w32_compute_glyph_string_overhangs (struct glyph_string *s)
1137 if (s->cmp == NULL
1138 && s->first_glyph->type == CHAR_GLYPH
1139 && !s->font_not_found_p)
1141 unsigned *code = alloca (sizeof (unsigned) * s->nchars);
1142 struct font *font = s->font;
1143 struct font_metrics metrics;
1144 int i;
1146 for (i = 0; i < s->nchars; i++)
1147 code[i] = s->char2b[i];
1148 font->driver->text_extents (font, code, s->nchars, &metrics);
1149 s->right_overhang = (metrics.rbearing > metrics.width
1150 ? metrics.rbearing - metrics.width : 0);
1151 s->left_overhang = metrics.lbearing < 0 ? -metrics.lbearing : 0;
1153 else if (s->cmp)
1155 s->right_overhang = s->cmp->rbearing - s->cmp->pixel_width;
1156 s->left_overhang = -s->cmp->lbearing;
1160 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1162 static inline void
1163 x_clear_glyph_string_rect (struct glyph_string *s,
1164 int x, int y, int w, int h)
1166 int real_x = x;
1167 int real_y = y;
1168 int real_w = w;
1169 int real_h = h;
1170 #if 0
1171 /* Take clipping into account. */
1172 if (s->gc->clip_mask == Rect)
1174 real_x = max (real_x, s->gc->clip_rectangle.left);
1175 real_y = max (real_y, s->gc->clip_rectangle.top);
1176 real_w = min (real_w, s->gc->clip_rectangle.right
1177 - s->gc->clip_rectangle.left);
1178 real_h = min (real_h, s->gc->clip_rectangle.bottom
1179 - s->gc->clip_rectangle.top);
1181 #endif
1182 w32_fill_area (s->f, s->hdc, s->gc->background, real_x, real_y,
1183 real_w, real_h);
1187 /* Draw the background of glyph_string S. If S->background_filled_p
1188 is non-zero don't draw it. FORCE_P non-zero means draw the
1189 background even if it wouldn't be drawn normally. This is used
1190 when a string preceding S draws into the background of S, or S
1191 contains the first component of a composition. */
1193 static void
1194 x_draw_glyph_string_background (struct glyph_string *s, bool force_p)
1196 /* Nothing to do if background has already been drawn or if it
1197 shouldn't be drawn in the first place. */
1198 if (!s->background_filled_p)
1200 int box_line_width = max (s->face->box_line_width, 0);
1202 #if 0 /* TODO: stipple */
1203 if (s->stippled_p)
1205 /* Fill background with a stipple pattern. */
1206 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
1207 XFillRectangle (s->display, s->window, s->gc, s->x,
1208 s->y + box_line_width,
1209 s->background_width,
1210 s->height - 2 * box_line_width);
1211 XSetFillStyle (s->display, s->gc, FillSolid);
1212 s->background_filled_p = true;
1214 else
1215 #endif
1216 if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
1217 /* When xdisp.c ignores FONT_HEIGHT, we cannot trust
1218 font dimensions, since the actual glyphs might be
1219 much smaller. So in that case we always clear the
1220 rectangle with background color. */
1221 || FONT_TOO_HIGH (s->font)
1222 || s->font_not_found_p
1223 || s->extends_to_end_of_line_p
1224 || force_p)
1226 x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
1227 s->background_width,
1228 s->height - 2 * box_line_width);
1229 s->background_filled_p = true;
1235 /* Draw the foreground of glyph string S. */
1237 static void
1238 x_draw_glyph_string_foreground (struct glyph_string *s)
1240 int i, x;
1242 /* If first glyph of S has a left box line, start drawing the text
1243 of S to the right of that box line. */
1244 if (s->face->box != FACE_NO_BOX
1245 && s->first_glyph->left_box_line_p)
1246 x = s->x + eabs (s->face->box_line_width);
1247 else
1248 x = s->x;
1250 SetTextColor (s->hdc, s->gc->foreground);
1251 SetBkColor (s->hdc, s->gc->background);
1252 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1254 /* Draw characters of S as rectangles if S's font could not be
1255 loaded. */
1256 if (s->font_not_found_p)
1258 for (i = 0; i < s->nchars; ++i)
1260 struct glyph *g = s->first_glyph + i;
1262 w32_draw_rectangle (s->hdc, s->gc, x, s->y, g->pixel_width - 1,
1263 s->height - 1);
1264 x += g->pixel_width;
1267 else
1269 struct font *font = s->font;
1270 int boff = font->baseline_offset;
1271 int y;
1272 HFONT old_font;
1274 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1276 if (font->vertical_centering)
1277 boff = VCENTER_BASELINE_OFFSET (font, s->f) - boff;
1279 y = s->ybase - boff;
1280 if (s->for_overlaps
1281 || (s->background_filled_p && s->hl != DRAW_CURSOR))
1282 font->driver->draw (s, 0, s->nchars, x, y, false);
1283 else
1284 font->driver->draw (s, 0, s->nchars, x, y, true);
1285 if (s->face->overstrike)
1286 font->driver->draw (s, 0, s->nchars, x + 1, y, false);
1288 SelectObject (s->hdc, old_font);
1292 /* Draw the foreground of composite glyph string S. */
1294 static void
1295 x_draw_composite_glyph_string_foreground (struct glyph_string *s)
1297 int i, j, x;
1298 struct font *font = s->font;
1300 /* If first glyph of S has a left box line, start drawing the text
1301 of S to the right of that box line. */
1302 if (s->face && s->face->box != FACE_NO_BOX
1303 && s->first_glyph->left_box_line_p)
1304 x = s->x + eabs (s->face->box_line_width);
1305 else
1306 x = s->x;
1308 /* S is a glyph string for a composition. S->cmp_from is the index
1309 of the first character drawn for glyphs of this composition.
1310 S->cmp_from == 0 means we are drawing the very first character of
1311 this composition. */
1313 SetTextColor (s->hdc, s->gc->foreground);
1314 SetBkColor (s->hdc, s->gc->background);
1315 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1317 /* Draw a rectangle for the composition if the font for the very
1318 first character of the composition could not be loaded. */
1319 if (s->font_not_found_p)
1321 if (s->cmp_from == 0)
1322 w32_draw_rectangle (s->hdc, s->gc, x, s->y, s->width - 1,
1323 s->height - 1);
1325 else if (! s->first_glyph->u.cmp.automatic)
1327 int y = s->ybase;
1328 HFONT old_font;
1330 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1332 for (i = 0, j = s->cmp_from; i < s->nchars; i++, j++)
1333 /* TAB in a composition means display glyphs with padding
1334 space on the left or right. */
1335 if (COMPOSITION_GLYPH (s->cmp, j) != '\t')
1337 int xx = x + s->cmp->offsets[j * 2];
1338 int yy = y - s->cmp->offsets[j * 2 + 1];
1340 font->driver->draw (s, j, j + 1, xx, yy, false);
1341 if (s->face->overstrike)
1342 font->driver->draw (s, j, j + 1, xx + 1, yy, false);
1344 SelectObject (s->hdc, old_font);
1346 else
1348 Lisp_Object gstring = composition_gstring_from_id (s->cmp_id);
1349 Lisp_Object glyph;
1350 int y = s->ybase;
1351 int width = 0;
1352 HFONT old_font;
1354 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1356 for (i = j = s->cmp_from; i < s->cmp_to; i++)
1358 glyph = LGSTRING_GLYPH (gstring, i);
1359 if (NILP (LGLYPH_ADJUSTMENT (glyph)))
1360 width += LGLYPH_WIDTH (glyph);
1361 else
1363 int xoff, yoff, wadjust;
1365 if (j < i)
1367 font->driver->draw (s, j, i, x, y, false);
1368 x += width;
1370 xoff = LGLYPH_XOFF (glyph);
1371 yoff = LGLYPH_YOFF (glyph);
1372 wadjust = LGLYPH_WADJUST (glyph);
1373 font->driver->draw (s, i, i + 1, x + xoff, y + yoff, false);
1374 x += wadjust;
1375 j = i + 1;
1376 width = 0;
1379 if (j < i)
1380 font->driver->draw (s, j, i, x, y, false);
1382 SelectObject (s->hdc, old_font);
1387 /* Draw the foreground of glyph string S for glyphless characters. */
1389 static void
1390 x_draw_glyphless_glyph_string_foreground (struct glyph_string *s)
1392 struct glyph *glyph = s->first_glyph;
1393 XChar2b char2b[8];
1394 int x, i, j;
1395 bool with_background;
1397 /* If first glyph of S has a left box line, start drawing the text
1398 of S to the right of that box line. */
1399 if (s->face->box != FACE_NO_BOX
1400 && s->first_glyph->left_box_line_p)
1401 x = s->x + eabs (s->face->box_line_width);
1402 else
1403 x = s->x;
1405 SetTextColor (s->hdc, s->gc->foreground);
1406 SetBkColor (s->hdc, s->gc->background);
1407 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1409 s->char2b = char2b;
1410 with_background = ((s->for_overlaps
1411 || (s->background_filled_p && s->hl != DRAW_CURSOR))) == 0;
1412 for (i = 0; i < s->nchars; i++, glyph++)
1414 char buf[7], *str = NULL;
1415 int len = glyph->u.glyphless.len;
1417 if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_ACRONYM)
1419 if (len > 0
1420 && CHAR_TABLE_P (Vglyphless_char_display)
1421 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display))
1422 >= 1))
1424 Lisp_Object acronym
1425 = (! glyph->u.glyphless.for_no_font
1426 ? CHAR_TABLE_REF (Vglyphless_char_display,
1427 glyph->u.glyphless.ch)
1428 : XCHAR_TABLE (Vglyphless_char_display)->extras[0]);
1429 if (STRINGP (acronym))
1430 str = SSDATA (acronym);
1433 else if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_HEX_CODE)
1435 sprintf ((char *) buf, "%0*X",
1436 glyph->u.glyphless.ch < 0x10000 ? 4 : 6,
1437 glyph->u.glyphless.ch);
1438 str = buf;
1441 if (glyph->u.glyphless.method != GLYPHLESS_DISPLAY_THIN_SPACE)
1442 w32_draw_rectangle (s->hdc, s->gc,
1443 x, s->ybase - glyph->ascent,
1444 glyph->pixel_width - 1,
1445 glyph->ascent + glyph->descent - 1);
1446 if (str)
1448 struct font *font = s->font;
1449 int upper_len = (len + 1) / 2;
1450 unsigned code;
1451 HFONT old_font;
1453 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1454 /* It is certain that all LEN characters in STR are ASCII. */
1455 for (j = 0; j < len; j++)
1457 code = font->driver->encode_char (font, str[j]);
1458 STORE_XCHAR2B (char2b + j, code >> 8, code & 0xFF);
1460 font->driver->draw (s, 0, upper_len,
1461 x + glyph->slice.glyphless.upper_xoff,
1462 s->ybase + glyph->slice.glyphless.upper_yoff,
1463 with_background);
1464 font->driver->draw (s, upper_len, len,
1465 x + glyph->slice.glyphless.lower_xoff,
1466 s->ybase + glyph->slice.glyphless.lower_yoff,
1467 with_background);
1468 SelectObject (s->hdc, old_font);
1470 x += glyph->pixel_width;
1475 /* Brightness beyond which a color won't have its highlight brightness
1476 boosted.
1478 Nominally, highlight colors for `3d' faces are calculated by
1479 brightening an object's color by a constant scale factor, but this
1480 doesn't yield good results for dark colors, so for colors whose
1481 brightness is less than this value (on a scale of 0-255) have to
1482 use an additional additive factor.
1484 The value here is set so that the default menu-bar/mode-line color
1485 (grey75) will not have its highlights changed at all. */
1486 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1489 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1490 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1491 If this produces the same color as COLOR, try a color where all RGB
1492 values have DELTA added. Return the allocated color in *COLOR.
1493 DISPLAY is the X display, CMAP is the colormap to operate on.
1494 Value is non-zero if successful. */
1496 static int
1497 w32_alloc_lighter_color (struct frame *f, COLORREF *color,
1498 double factor, int delta)
1500 COLORREF new;
1501 long bright;
1503 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1504 delta /= 256;
1506 /* Change RGB values by specified FACTOR. Avoid overflow! */
1507 eassert (factor >= 0);
1508 new = PALETTERGB (min (0xff, factor * GetRValue (*color)),
1509 min (0xff, factor * GetGValue (*color)),
1510 min (0xff, factor * GetBValue (*color)));
1512 /* Calculate brightness of COLOR. */
1513 bright = (2 * GetRValue (*color) + 3 * GetGValue (*color)
1514 + GetBValue (*color)) / 6;
1516 /* We only boost colors that are darker than
1517 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1518 if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
1519 /* Make an additive adjustment to NEW, because it's dark enough so
1520 that scaling by FACTOR alone isn't enough. */
1522 /* How far below the limit this color is (0 - 1, 1 being darker). */
1523 double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
1524 /* The additive adjustment. */
1525 int min_delta = delta * dimness * factor / 2;
1527 if (factor < 1)
1528 new = PALETTERGB (max (0, min (0xff, min_delta - GetRValue (*color))),
1529 max (0, min (0xff, min_delta - GetGValue (*color))),
1530 max (0, min (0xff, min_delta - GetBValue (*color))));
1531 else
1532 new = PALETTERGB (max (0, min (0xff, min_delta + GetRValue (*color))),
1533 max (0, min (0xff, min_delta + GetGValue (*color))),
1534 max (0, min (0xff, min_delta + GetBValue (*color))));
1537 if (new == *color)
1538 new = PALETTERGB (max (0, min (0xff, delta + GetRValue (*color))),
1539 max (0, min (0xff, delta + GetGValue (*color))),
1540 max (0, min (0xff, delta + GetBValue (*color))));
1542 /* TODO: Map to palette and retry with delta if same? */
1543 /* TODO: Free colors (if using palette)? */
1545 if (new == *color)
1546 return 0;
1548 *color = new;
1550 return 1;
1553 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1554 colors in COLORS. On W32, we no longer try to map colors to
1555 a palette. */
1556 void
1557 x_query_colors (struct frame *f, XColor *colors, int ncolors)
1559 int i;
1561 for (i = 0; i < ncolors; i++)
1563 DWORD pixel = colors[i].pixel;
1564 /* Convert to a 16 bit value in range 0 - 0xffff. */
1565 colors[i].red = GetRValue (pixel) * 257;
1566 colors[i].green = GetGValue (pixel) * 257;
1567 colors[i].blue = GetBValue (pixel) * 257;
1571 void
1572 x_query_color (struct frame *f, XColor *color)
1574 x_query_colors (f, color, 1);
1578 /* Set up the foreground color for drawing relief lines of glyph
1579 string S. RELIEF is a pointer to a struct relief containing the GC
1580 with which lines will be drawn. Use a color that is FACTOR or
1581 DELTA lighter or darker than the relief's background which is found
1582 in S->f->output_data.x->relief_background. If such a color cannot
1583 be allocated, use DEFAULT_PIXEL, instead. */
1585 static void
1586 w32_setup_relief_color (struct frame *f, struct relief *relief, double factor,
1587 int delta, COLORREF default_pixel)
1589 XGCValues xgcv;
1590 struct w32_output *di = f->output_data.w32;
1591 unsigned long mask = GCForeground;
1592 COLORREF pixel;
1593 COLORREF background = di->relief_background;
1594 #if 0
1595 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
1596 #endif
1598 /* TODO: Free colors (if using palette)? */
1600 /* Allocate new color. */
1601 xgcv.foreground = default_pixel;
1602 pixel = background;
1603 if (w32_alloc_lighter_color (f, &pixel, factor, delta))
1604 xgcv.foreground = relief->pixel = pixel;
1606 if (relief->gc == 0)
1608 #if 0 /* TODO: stipple */
1609 xgcv.stipple = dpyinfo->gray;
1610 mask |= GCStipple;
1611 #endif
1612 relief->gc = XCreateGC (NULL, FRAME_W32_WINDOW (f), mask, &xgcv);
1614 else
1615 XChangeGC (NULL, relief->gc, mask, &xgcv);
1619 /* Set up colors for the relief lines around glyph string S. */
1621 static void
1622 x_setup_relief_colors (struct glyph_string *s)
1624 struct w32_output *di = s->f->output_data.w32;
1625 COLORREF color;
1627 if (s->face->use_box_color_for_shadows_p)
1628 color = s->face->box_color;
1629 else if (s->first_glyph->type == IMAGE_GLYPH
1630 && s->img->pixmap
1631 && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
1632 color = IMAGE_BACKGROUND (s->img, s->f, 0);
1633 else
1634 color = s->gc->background;
1636 if (di->white_relief.gc == 0
1637 || color != di->relief_background)
1639 di->relief_background = color;
1640 w32_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
1641 WHITE_PIX_DEFAULT (s->f));
1642 w32_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
1643 BLACK_PIX_DEFAULT (s->f));
1648 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1649 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1650 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1651 relief. LEFT_P non-zero means draw a relief on the left side of
1652 the rectangle. RIGHT_P non-zero means draw a relief on the right
1653 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1654 when drawing. */
1656 static void
1657 w32_draw_relief_rect (struct frame *f,
1658 int left_x, int top_y, int right_x, int bottom_y,
1659 int width, int raised_p,
1660 int top_p, int bot_p, int left_p, int right_p,
1661 RECT *clip_rect)
1663 int i;
1664 XGCValues gc;
1665 HDC hdc = get_frame_dc (f);
1667 if (raised_p)
1668 gc.foreground = f->output_data.w32->white_relief.gc->foreground;
1669 else
1670 gc.foreground = f->output_data.w32->black_relief.gc->foreground;
1672 w32_set_clip_rectangle (hdc, clip_rect);
1674 /* Top. */
1675 if (top_p)
1676 for (i = 0; i < width; ++i)
1677 w32_fill_area (f, hdc, gc.foreground,
1678 left_x + i * left_p, top_y + i,
1679 right_x - left_x - i * (left_p + right_p ) + 1, 1);
1681 /* Left. */
1682 if (left_p)
1683 for (i = 0; i < width; ++i)
1684 w32_fill_area (f, hdc, gc.foreground,
1685 left_x + i, top_y + (i + 1) * top_p, 1,
1686 bottom_y - top_y - (i + 1) * (bot_p + top_p) + 1);
1688 if (raised_p)
1689 gc.foreground = f->output_data.w32->black_relief.gc->foreground;
1690 else
1691 gc.foreground = f->output_data.w32->white_relief.gc->foreground;
1693 /* Bottom. */
1694 if (bot_p)
1695 for (i = 0; i < width; ++i)
1696 w32_fill_area (f, hdc, gc.foreground,
1697 left_x + i * left_p, bottom_y - i,
1698 right_x - left_x - i * (left_p + right_p) + 1, 1);
1700 /* Right. */
1701 if (right_p)
1702 for (i = 0; i < width; ++i)
1703 w32_fill_area (f, hdc, gc.foreground,
1704 right_x - i, top_y + (i + 1) * top_p, 1,
1705 bottom_y - top_y - (i + 1) * (bot_p + top_p) + 1);
1707 w32_set_clip_rectangle (hdc, NULL);
1709 release_frame_dc (f, hdc);
1713 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1714 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1715 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1716 left side of the rectangle. RIGHT_P non-zero means draw a line
1717 on the right side of the rectangle. CLIP_RECT is the clipping
1718 rectangle to use when drawing. */
1720 static void
1721 w32_draw_box_rect (struct glyph_string *s,
1722 int left_x, int top_y, int right_x, int bottom_y, int width,
1723 bool left_p, bool right_p, RECT *clip_rect)
1725 w32_set_clip_rectangle (s->hdc, clip_rect);
1727 /* Top. */
1728 w32_fill_area (s->f, s->hdc, s->face->box_color,
1729 left_x, top_y, right_x - left_x + 1, width);
1731 /* Left. */
1732 if (left_p)
1734 w32_fill_area (s->f, s->hdc, s->face->box_color,
1735 left_x, top_y, width, bottom_y - top_y + 1);
1738 /* Bottom. */
1739 w32_fill_area (s->f, s->hdc, s->face->box_color,
1740 left_x, bottom_y - width + 1, right_x - left_x + 1, width);
1742 /* Right. */
1743 if (right_p)
1745 w32_fill_area (s->f, s->hdc, s->face->box_color,
1746 right_x - width + 1, top_y, width, bottom_y - top_y + 1);
1749 w32_set_clip_rectangle (s->hdc, NULL);
1753 /* Draw a box around glyph string S. */
1755 static void
1756 x_draw_glyph_string_box (struct glyph_string *s)
1758 int width, left_x, right_x, top_y, bottom_y, last_x;
1759 bool left_p, right_p, raised_p;
1760 struct glyph *last_glyph;
1761 RECT clip_rect;
1763 last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
1764 ? WINDOW_RIGHT_EDGE_X (s->w)
1765 : window_box_right (s->w, s->area));
1767 /* The glyph that may have a right box line. */
1768 last_glyph = (s->cmp || s->img
1769 ? s->first_glyph
1770 : s->first_glyph + s->nchars - 1);
1772 width = eabs (s->face->box_line_width);
1773 raised_p = s->face->box == FACE_RAISED_BOX;
1774 left_x = s->x;
1775 right_x = ((s->row->full_width_p && s->extends_to_end_of_line_p
1776 ? last_x - 1
1777 : min (last_x, s->x + s->background_width) - 1));
1778 top_y = s->y;
1779 bottom_y = top_y + s->height - 1;
1781 left_p = (s->first_glyph->left_box_line_p
1782 || (s->hl == DRAW_MOUSE_FACE
1783 && (s->prev == NULL
1784 || s->prev->hl != s->hl)));
1785 right_p = (last_glyph->right_box_line_p
1786 || (s->hl == DRAW_MOUSE_FACE
1787 && (s->next == NULL
1788 || s->next->hl != s->hl)));
1790 get_glyph_string_clip_rect (s, &clip_rect);
1792 if (s->face->box == FACE_SIMPLE_BOX)
1793 w32_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
1794 left_p, right_p, &clip_rect);
1795 else
1797 x_setup_relief_colors (s);
1798 w32_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
1799 width, raised_p, 1, 1, left_p, right_p, &clip_rect);
1804 /* Draw foreground of image glyph string S. */
1806 static void
1807 x_draw_image_foreground (struct glyph_string *s)
1809 int x = s->x;
1810 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
1812 /* If first glyph of S has a left box line, start drawing it to the
1813 right of that line. */
1814 if (s->face->box != FACE_NO_BOX
1815 && s->first_glyph->left_box_line_p
1816 && s->slice.x == 0)
1817 x += eabs (s->face->box_line_width);
1819 /* If there is a margin around the image, adjust x- and y-position
1820 by that margin. */
1821 if (s->slice.x == 0)
1822 x += s->img->hmargin;
1823 if (s->slice.y == 0)
1824 y += s->img->vmargin;
1826 SaveDC (s->hdc);
1828 if (s->img->pixmap)
1830 HDC compat_hdc = CreateCompatibleDC (s->hdc);
1831 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
1832 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
1833 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
1834 SetBkColor (compat_hdc, RGB (255, 255, 255));
1835 SetTextColor (s->hdc, RGB (0, 0, 0));
1836 x_set_glyph_string_clipping (s);
1838 if (s->img->mask)
1840 HDC mask_dc = CreateCompatibleDC (s->hdc);
1841 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask);
1843 SetTextColor (s->hdc, RGB (255, 255, 255));
1844 SetBkColor (s->hdc, RGB (0, 0, 0));
1846 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1847 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
1848 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1849 mask_dc, s->slice.x, s->slice.y, SRCAND);
1850 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1851 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
1853 SelectObject (mask_dc, mask_orig_obj);
1854 DeleteDC (mask_dc);
1856 else
1858 SetTextColor (s->hdc, s->gc->foreground);
1859 SetBkColor (s->hdc, s->gc->background);
1861 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1862 compat_hdc, s->slice.x, s->slice.y, SRCCOPY);
1864 /* When the image has a mask, we can expect that at
1865 least part of a mouse highlight or a block cursor will
1866 be visible. If the image doesn't have a mask, make
1867 a block cursor visible by drawing a rectangle around
1868 the image. I believe it's looking better if we do
1869 nothing here for mouse-face. */
1870 if (s->hl == DRAW_CURSOR)
1872 int r = s->img->relief;
1873 if (r < 0) r = -r;
1874 w32_draw_rectangle (s->hdc, s->gc, x - r, y - r ,
1875 s->slice.width + r*2 - 1,
1876 s->slice.height + r*2 - 1);
1880 w32_set_clip_rectangle (s->hdc, NULL);
1881 SelectObject (s->hdc, orig_brush);
1882 DeleteObject (fg_brush);
1883 SelectObject (compat_hdc, orig_obj);
1884 DeleteDC (compat_hdc);
1886 else
1887 w32_draw_rectangle (s->hdc, s->gc, x, y,
1888 s->slice.width - 1, s->slice.height - 1);
1890 RestoreDC (s->hdc ,-1);
1894 /* Draw a relief around the image glyph string S. */
1896 static void
1897 x_draw_image_relief (struct glyph_string *s)
1899 int x1, y1, thick, raised_p, top_p, bot_p, left_p, right_p;
1900 int extra_x, extra_y;
1901 RECT r;
1902 int x = s->x;
1903 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
1905 /* If first glyph of S has a left box line, start drawing it to the
1906 right of that line. */
1907 if (s->face->box != FACE_NO_BOX
1908 && s->first_glyph->left_box_line_p
1909 && s->slice.x == 0)
1910 x += eabs (s->face->box_line_width);
1912 /* If there is a margin around the image, adjust x- and y-position
1913 by that margin. */
1914 if (s->slice.x == 0)
1915 x += s->img->hmargin;
1916 if (s->slice.y == 0)
1917 y += s->img->vmargin;
1919 if (s->hl == DRAW_IMAGE_SUNKEN
1920 || s->hl == DRAW_IMAGE_RAISED)
1922 thick = tool_bar_button_relief >= 0 ? tool_bar_button_relief
1923 : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
1924 raised_p = s->hl == DRAW_IMAGE_RAISED;
1926 else
1928 thick = eabs (s->img->relief);
1929 raised_p = s->img->relief > 0;
1932 x1 = x + s->slice.width - 1;
1933 y1 = y + s->slice.height - 1;
1935 extra_x = extra_y = 0;
1936 if (s->face->id == TOOL_BAR_FACE_ID)
1938 if (CONSP (Vtool_bar_button_margin)
1939 && INTEGERP (XCAR (Vtool_bar_button_margin))
1940 && INTEGERP (XCDR (Vtool_bar_button_margin)))
1942 extra_x = XINT (XCAR (Vtool_bar_button_margin));
1943 extra_y = XINT (XCDR (Vtool_bar_button_margin));
1945 else if (INTEGERP (Vtool_bar_button_margin))
1946 extra_x = extra_y = XINT (Vtool_bar_button_margin);
1949 top_p = bot_p = left_p = right_p = 0;
1951 if (s->slice.x == 0)
1952 x -= thick + extra_x, left_p = 1;
1953 if (s->slice.y == 0)
1954 y -= thick + extra_y, top_p = 1;
1955 if (s->slice.x + s->slice.width == s->img->width)
1956 x1 += thick + extra_x, right_p = 1;
1957 if (s->slice.y + s->slice.height == s->img->height)
1958 y1 += thick + extra_y, bot_p = 1;
1960 x_setup_relief_colors (s);
1961 get_glyph_string_clip_rect (s, &r);
1962 w32_draw_relief_rect (s->f, x, y, x1, y1, thick, raised_p,
1963 top_p, bot_p, left_p, right_p, &r);
1967 /* Draw the foreground of image glyph string S to PIXMAP. */
1969 static void
1970 w32_draw_image_foreground_1 (struct glyph_string *s, HBITMAP pixmap)
1972 HDC hdc = CreateCompatibleDC (s->hdc);
1973 HGDIOBJ orig_hdc_obj = SelectObject (hdc, pixmap);
1974 int x = 0;
1975 int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
1977 /* If first glyph of S has a left box line, start drawing it to the
1978 right of that line. */
1979 if (s->face->box != FACE_NO_BOX
1980 && s->first_glyph->left_box_line_p
1981 && s->slice.x == 0)
1982 x += eabs (s->face->box_line_width);
1984 /* If there is a margin around the image, adjust x- and y-position
1985 by that margin. */
1986 if (s->slice.x == 0)
1987 x += s->img->hmargin;
1988 if (s->slice.y == 0)
1989 y += s->img->vmargin;
1991 if (s->img->pixmap)
1993 HDC compat_hdc = CreateCompatibleDC (hdc);
1994 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
1995 HBRUSH orig_brush = SelectObject (hdc, fg_brush);
1996 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
1998 if (s->img->mask)
2000 HDC mask_dc = CreateCompatibleDC (hdc);
2001 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask);
2003 SetTextColor (hdc, RGB (0, 0, 0));
2004 SetBkColor (hdc, RGB (255, 255, 255));
2005 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2006 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
2007 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2008 mask_dc, s->slice.x, s->slice.y, SRCAND);
2009 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2010 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
2012 SelectObject (mask_dc, mask_orig_obj);
2013 DeleteDC (mask_dc);
2015 else
2017 SetTextColor (hdc, s->gc->foreground);
2018 SetBkColor (hdc, s->gc->background);
2020 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2021 compat_hdc, s->slice.x, s->slice.y, SRCCOPY);
2023 /* When the image has a mask, we can expect that at
2024 least part of a mouse highlight or a block cursor will
2025 be visible. If the image doesn't have a mask, make
2026 a block cursor visible by drawing a rectangle around
2027 the image. I believe it's looking better if we do
2028 nothing here for mouse-face. */
2029 if (s->hl == DRAW_CURSOR)
2031 int r = s->img->relief;
2032 if (r < 0) r = -r;
2033 w32_draw_rectangle (hdc, s->gc, x - r, y - r,
2034 s->slice.width + r*2 - 1,
2035 s->slice.height + r*2 - 1);
2039 SelectObject (hdc, orig_brush);
2040 DeleteObject (fg_brush);
2041 SelectObject (compat_hdc, orig_obj);
2042 DeleteDC (compat_hdc);
2044 else
2045 w32_draw_rectangle (hdc, s->gc, x, y,
2046 s->slice.width - 1, s->slice.height - 1);
2048 SelectObject (hdc, orig_hdc_obj);
2049 DeleteDC (hdc);
2053 /* Draw part of the background of glyph string S. X, Y, W, and H
2054 give the rectangle to draw. */
2056 static void
2057 x_draw_glyph_string_bg_rect (struct glyph_string *s, int x, int y, int w, int h)
2059 #if 0 /* TODO: stipple */
2060 if (s->stippled_p)
2062 /* Fill background with a stipple pattern. */
2063 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2064 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
2065 XSetFillStyle (s->display, s->gc, FillSolid);
2067 else
2068 #endif
2069 x_clear_glyph_string_rect (s, x, y, w, h);
2073 /* Draw image glyph string S.
2075 s->y
2076 s->x +-------------------------
2077 | s->face->box
2079 | +-------------------------
2080 | | s->img->vmargin
2082 | | +-------------------
2083 | | | the image
2087 static void
2088 x_draw_image_glyph_string (struct glyph_string *s)
2090 int x, y;
2091 int box_line_hwidth = eabs (s->face->box_line_width);
2092 int box_line_vwidth = max (s->face->box_line_width, 0);
2093 int height, width;
2094 HBITMAP pixmap = 0;
2096 height = s->height;
2097 if (s->slice.y == 0)
2098 height -= box_line_vwidth;
2099 if (s->slice.y + s->slice.height >= s->img->height)
2100 height -= box_line_vwidth;
2102 /* Fill background with face under the image. Do it only if row is
2103 taller than image or if image has a clip mask to reduce
2104 flickering. */
2105 s->stippled_p = s->face->stipple != 0;
2106 if (height > s->slice.height
2107 || s->img->hmargin
2108 || s->img->vmargin
2109 || s->img->mask
2110 || s->img->pixmap == 0
2111 || s->width != s->background_width)
2113 width = s->background_width;
2114 x = s->x;
2115 if (s->first_glyph->left_box_line_p
2116 && s->slice.x == 0)
2118 x += box_line_hwidth;
2119 width -= box_line_hwidth;
2122 y = s->y;
2123 if (s->slice.y == 0)
2124 y += box_line_vwidth;
2126 #if 0 /* TODO: figure out if we need to do this on Windows. */
2127 if (s->img->mask)
2129 /* Create a pixmap as large as the glyph string. Fill it
2130 with the background color. Copy the image to it, using
2131 its mask. Copy the temporary pixmap to the display. */
2132 Screen *screen = FRAME_X_SCREEN (s->f);
2133 int depth = DefaultDepthOfScreen (screen);
2135 /* Create a pixmap as large as the glyph string. */
2136 pixmap = XCreatePixmap (s->display, s->window,
2137 s->background_width,
2138 s->height, depth);
2140 /* Don't clip in the following because we're working on the
2141 pixmap. */
2142 XSetClipMask (s->display, s->gc, None);
2144 /* Fill the pixmap with the background color/stipple. */
2145 if (s->stippled_p)
2147 /* Fill background with a stipple pattern. */
2148 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2149 XFillRectangle (s->display, pixmap, s->gc,
2150 0, 0, s->background_width, s->height);
2151 XSetFillStyle (s->display, s->gc, FillSolid);
2153 else
2155 XGCValues xgcv;
2156 XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
2157 &xgcv);
2158 XSetForeground (s->display, s->gc, xgcv.background);
2159 XFillRectangle (s->display, pixmap, s->gc,
2160 0, 0, s->background_width, s->height);
2161 XSetForeground (s->display, s->gc, xgcv.foreground);
2164 else
2165 #endif
2166 x_draw_glyph_string_bg_rect (s, x, y, width, height);
2168 s->background_filled_p = true;
2171 /* Draw the foreground. */
2172 if (pixmap != 0)
2174 w32_draw_image_foreground_1 (s, pixmap);
2175 x_set_glyph_string_clipping (s);
2177 HDC compat_hdc = CreateCompatibleDC (s->hdc);
2178 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
2179 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
2180 HGDIOBJ orig_obj = SelectObject (compat_hdc, pixmap);
2182 SetTextColor (s->hdc, s->gc->foreground);
2183 SetBkColor (s->hdc, s->gc->background);
2184 BitBlt (s->hdc, s->x, s->y, s->background_width, s->height,
2185 compat_hdc, 0, 0, SRCCOPY);
2187 SelectObject (s->hdc, orig_brush);
2188 DeleteObject (fg_brush);
2189 SelectObject (compat_hdc, orig_obj);
2190 DeleteDC (compat_hdc);
2192 DeleteObject (pixmap);
2193 pixmap = 0;
2195 else
2196 x_draw_image_foreground (s);
2198 /* If we must draw a relief around the image, do it. */
2199 if (s->img->relief
2200 || s->hl == DRAW_IMAGE_RAISED
2201 || s->hl == DRAW_IMAGE_SUNKEN)
2202 x_draw_image_relief (s);
2206 /* Draw stretch glyph string S. */
2208 static void
2209 x_draw_stretch_glyph_string (struct glyph_string *s)
2211 eassert (s->first_glyph->type == STRETCH_GLYPH);
2213 if (s->hl == DRAW_CURSOR
2214 && !x_stretch_cursor_p)
2216 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2217 wide as the stretch glyph. */
2218 int width, background_width = s->background_width;
2219 int x = s->x;
2221 if (!s->row->reversed_p)
2223 int left_x = window_box_left_offset (s->w, TEXT_AREA);
2225 if (x < left_x)
2227 background_width -= left_x - x;
2228 x = left_x;
2231 else
2233 /* In R2L rows, draw the cursor on the right edge of the
2234 stretch glyph. */
2235 int right_x = window_box_right (s->w, TEXT_AREA);
2237 if (x + background_width > right_x)
2238 background_width -= x - right_x;
2239 x += background_width;
2241 width = min (FRAME_COLUMN_WIDTH (s->f), background_width);
2242 if (s->row->reversed_p)
2243 x -= width;
2245 /* Draw cursor. */
2246 x_draw_glyph_string_bg_rect (s, x, s->y, width, s->height);
2248 /* Clear rest using the GC of the original non-cursor face. */
2249 if (width < background_width)
2251 XGCValues *gc = s->face->gc;
2252 int y = s->y;
2253 int w = background_width - width, h = s->height;
2254 RECT r;
2255 HDC hdc = s->hdc;
2257 if (!s->row->reversed_p)
2258 x += width;
2259 else
2260 x = s->x;
2261 if (s->row->mouse_face_p
2262 && cursor_in_mouse_face_p (s->w))
2264 x_set_mouse_face_gc (s);
2265 gc = s->gc;
2267 else
2268 gc = s->face->gc;
2270 get_glyph_string_clip_rect (s, &r);
2271 w32_set_clip_rectangle (hdc, &r);
2273 #if 0 /* TODO: stipple */
2274 if (s->face->stipple)
2276 /* Fill background with a stipple pattern. */
2277 XSetFillStyle (s->display, gc, FillOpaqueStippled);
2278 XFillRectangle (s->display, s->window, gc, x, y, w, h);
2279 XSetFillStyle (s->display, gc, FillSolid);
2281 else
2282 #endif
2284 w32_fill_area (s->f, s->hdc, gc->background, x, y, w, h);
2288 else if (!s->background_filled_p)
2290 int background_width = s->background_width;
2291 int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
2293 /* Don't draw into left margin, fringe or scrollbar area
2294 except for header line and mode line. */
2295 if (x < left_x && !s->row->mode_line_p)
2297 background_width -= left_x - x;
2298 x = left_x;
2300 if (background_width > 0)
2301 x_draw_glyph_string_bg_rect (s, x, s->y, background_width, s->height);
2304 s->background_filled_p = true;
2308 /* Draw glyph string S. */
2310 static void
2311 x_draw_glyph_string (struct glyph_string *s)
2313 bool relief_drawn_p = 0;
2315 /* If S draws into the background of its successor, draw the
2316 background of the successor first so that S can draw into it.
2317 This makes S->next use XDrawString instead of XDrawImageString. */
2318 if (s->next && s->right_overhang && !s->for_overlaps)
2320 int width;
2321 struct glyph_string *next;
2322 for (width = 0, next = s->next;
2323 next && width < s->right_overhang;
2324 width += next->width, next = next->next)
2325 if (next->first_glyph->type != IMAGE_GLYPH)
2327 x_set_glyph_string_gc (next);
2328 x_set_glyph_string_clipping (next);
2329 if (next->first_glyph->type == STRETCH_GLYPH)
2330 x_draw_stretch_glyph_string (next);
2331 else
2332 x_draw_glyph_string_background (next, true);
2333 next->num_clips = 0;
2337 /* Set up S->gc, set clipping and draw S. */
2338 x_set_glyph_string_gc (s);
2340 /* Draw relief (if any) in advance for char/composition so that the
2341 glyph string can be drawn over it. */
2342 if (!s->for_overlaps
2343 && s->face->box != FACE_NO_BOX
2344 && (s->first_glyph->type == CHAR_GLYPH
2345 || s->first_glyph->type == COMPOSITE_GLYPH))
2348 x_set_glyph_string_clipping (s);
2349 x_draw_glyph_string_background (s, true);
2350 x_draw_glyph_string_box (s);
2351 x_set_glyph_string_clipping (s);
2352 relief_drawn_p = 1;
2354 else if (!s->clip_head /* draw_glyphs didn't specify a clip mask. */
2355 && !s->clip_tail
2356 && ((s->prev && s->prev->hl != s->hl && s->left_overhang)
2357 || (s->next && s->next->hl != s->hl && s->right_overhang)))
2358 /* We must clip just this glyph. left_overhang part has already
2359 drawn when s->prev was drawn, and right_overhang part will be
2360 drawn later when s->next is drawn. */
2361 x_set_glyph_string_clipping_exactly (s, s);
2362 else
2363 x_set_glyph_string_clipping (s);
2365 switch (s->first_glyph->type)
2367 case IMAGE_GLYPH:
2368 x_draw_image_glyph_string (s);
2369 break;
2371 case STRETCH_GLYPH:
2372 x_draw_stretch_glyph_string (s);
2373 break;
2375 case CHAR_GLYPH:
2376 if (s->for_overlaps)
2377 s->background_filled_p = true;
2378 else
2379 x_draw_glyph_string_background (s, false);
2380 x_draw_glyph_string_foreground (s);
2381 break;
2383 case COMPOSITE_GLYPH:
2384 if (s->for_overlaps || (s->cmp_from > 0
2385 && ! s->first_glyph->u.cmp.automatic))
2386 s->background_filled_p = true;
2387 else
2388 x_draw_glyph_string_background (s, true);
2389 x_draw_composite_glyph_string_foreground (s);
2390 break;
2392 case GLYPHLESS_GLYPH:
2393 if (s->for_overlaps)
2394 s->background_filled_p = true;
2395 else
2396 x_draw_glyph_string_background (s, false);
2397 x_draw_glyphless_glyph_string_foreground (s);
2398 break;
2400 default:
2401 emacs_abort ();
2404 if (!s->for_overlaps)
2406 /* Draw underline. */
2407 if (s->face->underline_p)
2409 if (s->face->underline_type == FACE_UNDER_WAVE)
2411 COLORREF color;
2413 if (s->face->underline_defaulted_p)
2414 color = s->gc->foreground;
2415 else
2416 color = s->face->underline_color;
2418 w32_draw_underwave (s, color);
2420 else if (s->face->underline_type == FACE_UNDER_LINE)
2422 unsigned long thickness, position;
2423 int y;
2425 if (s->prev && s->prev->face->underline_p
2426 && s->prev->face->underline_type == FACE_UNDER_LINE)
2428 /* We use the same underline style as the previous one. */
2429 thickness = s->prev->underline_thickness;
2430 position = s->prev->underline_position;
2432 else
2434 /* Get the underline thickness. Default is 1 pixel. */
2435 if (s->font && s->font->underline_thickness > 0)
2436 thickness = s->font->underline_thickness;
2437 else
2438 thickness = 1;
2439 if (x_underline_at_descent_line)
2440 position = (s->height - thickness) - (s->ybase - s->y);
2441 else
2443 /* Get the underline position. This is the recommended
2444 vertical offset in pixels from the baseline to the top of
2445 the underline. This is a signed value according to the
2446 specs, and its default is
2448 ROUND ((maximum_descent) / 2), with
2449 ROUND (x) = floor (x + 0.5) */
2451 if (x_use_underline_position_properties
2452 && s->font && s->font->underline_position >= 0)
2453 position = s->font->underline_position;
2454 else if (s->font)
2455 position = (s->font->descent + 1) / 2;
2457 position = max (position, underline_minimum_offset);
2459 /* Check the sanity of thickness and position. We should
2460 avoid drawing underline out of the current line area. */
2461 if (s->y + s->height <= s->ybase + position)
2462 position = (s->height - 1) - (s->ybase - s->y);
2463 if (s->y + s->height < s->ybase + position + thickness)
2464 thickness = (s->y + s->height) - (s->ybase + position);
2465 s->underline_thickness = thickness;
2466 s->underline_position =position;
2467 y = s->ybase + position;
2468 if (s->face->underline_defaulted_p)
2470 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
2471 y, s->width, 1);
2473 else
2475 w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x,
2476 y, s->width, 1);
2480 /* Draw overline. */
2481 if (s->face->overline_p)
2483 unsigned long dy = 0, h = 1;
2485 if (s->face->overline_color_defaulted_p)
2487 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
2488 s->y + dy, s->width, h);
2490 else
2492 w32_fill_area (s->f, s->hdc, s->face->overline_color, s->x,
2493 s->y + dy, s->width, h);
2497 /* Draw strike-through. */
2498 if (s->face->strike_through_p
2499 && !FONT_TEXTMETRIC (s->font).tmStruckOut)
2501 unsigned long h = 1;
2502 unsigned long dy = (s->height - h) / 2;
2504 if (s->face->strike_through_color_defaulted_p)
2506 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x, s->y + dy,
2507 s->width, h);
2509 else
2511 w32_fill_area (s->f, s->hdc, s->face->strike_through_color, s->x,
2512 s->y + dy, s->width, h);
2516 /* Draw relief if not yet drawn. */
2517 if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
2518 x_draw_glyph_string_box (s);
2520 if (s->prev)
2522 struct glyph_string *prev;
2524 for (prev = s->prev; prev; prev = prev->prev)
2525 if (prev->hl != s->hl
2526 && prev->x + prev->width + prev->right_overhang > s->x)
2528 /* As prev was drawn while clipped to its own area, we
2529 must draw the right_overhang part using s->hl now. */
2530 enum draw_glyphs_face save = prev->hl;
2532 prev->hl = s->hl;
2533 x_set_glyph_string_gc (prev);
2534 x_set_glyph_string_clipping_exactly (s, prev);
2535 if (prev->first_glyph->type == CHAR_GLYPH)
2536 x_draw_glyph_string_foreground (prev);
2537 else
2538 x_draw_composite_glyph_string_foreground (prev);
2539 w32_set_clip_rectangle (prev->hdc, NULL);
2540 prev->hl = save;
2541 prev->num_clips = 0;
2545 if (s->next)
2547 struct glyph_string *next;
2549 for (next = s->next; next; next = next->next)
2550 if (next->hl != s->hl
2551 && next->x - next->left_overhang < s->x + s->width)
2553 /* As next will be drawn while clipped to its own area,
2554 we must draw the left_overhang part using s->hl now. */
2555 enum draw_glyphs_face save = next->hl;
2557 next->hl = s->hl;
2558 x_set_glyph_string_gc (next);
2559 x_set_glyph_string_clipping_exactly (s, next);
2560 if (next->first_glyph->type == CHAR_GLYPH)
2561 x_draw_glyph_string_foreground (next);
2562 else
2563 x_draw_composite_glyph_string_foreground (next);
2564 w32_set_clip_rectangle (next->hdc, NULL);
2565 next->hl = save;
2566 next->num_clips = 0;
2567 next->clip_head = s->next;
2572 /* Reset clipping. */
2573 w32_set_clip_rectangle (s->hdc, NULL);
2574 s->num_clips = 0;
2578 /* Shift display to make room for inserted glyphs. */
2580 void
2581 w32_shift_glyphs_for_insert (struct frame *f, int x, int y,
2582 int width, int height, int shift_by)
2584 HDC hdc;
2586 hdc = get_frame_dc (f);
2587 BitBlt (hdc, x + shift_by, y, width, height,
2588 hdc, x, y, SRCCOPY);
2590 release_frame_dc (f, hdc);
2594 /* Delete N glyphs at the nominal cursor position. Not implemented
2595 for X frames. */
2597 static void
2598 x_delete_glyphs (struct frame *f, register int n)
2600 if (! FRAME_W32_P (f))
2601 return;
2603 emacs_abort ();
2607 /* Clear entire frame. */
2609 static void
2610 x_clear_frame (struct frame *f)
2612 if (! FRAME_W32_P (f))
2613 return;
2615 /* Clearing the frame will erase any cursor, so mark them all as no
2616 longer visible. */
2617 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
2619 block_input ();
2621 w32_clear_window (f);
2623 /* We have to clear the scroll bars, too. If we have changed
2624 colors or something like that, then they should be notified. */
2625 x_scroll_bar_clear (f);
2627 unblock_input ();
2631 /* Make audible bell. */
2633 static void
2634 w32_ring_bell (struct frame *f)
2636 block_input ();
2638 if (FRAME_W32_P (f) && visible_bell)
2640 int i;
2641 HWND hwnd = FRAME_W32_WINDOW (f);
2643 for (i = 0; i < 5; i++)
2645 FlashWindow (hwnd, TRUE);
2646 Sleep (10);
2648 FlashWindow (hwnd, FALSE);
2650 else
2651 w32_sys_ring_bell (f);
2653 unblock_input ();
2656 /***********************************************************************
2657 Line Dance
2658 ***********************************************************************/
2660 /* Perform an insert-lines or delete-lines operation, inserting N
2661 lines or deleting -N lines at vertical position VPOS. */
2663 static void
2664 x_ins_del_lines (struct frame *f, int vpos, int n)
2666 if (! FRAME_W32_P (f))
2667 return;
2669 emacs_abort ();
2673 /* Scroll part of the display as described by RUN. */
2675 static void
2676 x_scroll_run (struct window *w, struct run *run)
2678 struct frame *f = XFRAME (w->frame);
2679 int x, y, width, height, from_y, to_y, bottom_y;
2680 HWND hwnd = FRAME_W32_WINDOW (f);
2681 HRGN expect_dirty;
2683 /* Get frame-relative bounding box of the text display area of W,
2684 without mode lines. Include in this box the left and right
2685 fringes of W. */
2686 window_box (w, ANY_AREA, &x, &y, &width, &height);
2688 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
2689 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
2690 bottom_y = y + height;
2692 if (to_y < from_y)
2694 /* Scrolling up. Make sure we don't copy part of the mode
2695 line at the bottom. */
2696 if (from_y + run->height > bottom_y)
2697 height = bottom_y - from_y;
2698 else
2699 height = run->height;
2700 expect_dirty = CreateRectRgn (x, y + height, x + width, bottom_y);
2702 else
2704 /* Scrolling down. Make sure we don't copy over the mode line.
2705 at the bottom. */
2706 if (to_y + run->height > bottom_y)
2707 height = bottom_y - to_y;
2708 else
2709 height = run->height;
2710 expect_dirty = CreateRectRgn (x, y, x + width, to_y);
2713 block_input ();
2715 /* Cursor off. Will be switched on again in x_update_window_end. */
2716 x_clear_cursor (w);
2719 RECT from;
2720 RECT to;
2721 HRGN dirty = CreateRectRgn (0, 0, 0, 0);
2722 HRGN combined = CreateRectRgn (0, 0, 0, 0);
2724 from.left = to.left = x;
2725 from.right = to.right = x + width;
2726 from.top = from_y;
2727 from.bottom = from_y + height;
2728 to.top = y;
2729 to.bottom = bottom_y;
2731 ScrollWindowEx (hwnd, 0, to_y - from_y, &from, &to, dirty,
2732 NULL, SW_INVALIDATE);
2734 /* Combine this with what we expect to be dirty. This covers the
2735 case where not all of the region we expect is actually dirty. */
2736 CombineRgn (combined, dirty, expect_dirty, RGN_OR);
2738 /* If the dirty region is not what we expected, redraw the entire frame. */
2739 if (!EqualRgn (combined, expect_dirty))
2740 SET_FRAME_GARBAGED (f);
2742 DeleteObject (dirty);
2743 DeleteObject (combined);
2746 unblock_input ();
2747 DeleteObject (expect_dirty);
2752 /***********************************************************************
2753 Exposure Events
2754 ***********************************************************************/
2756 static void
2757 frame_highlight (struct frame *f)
2759 x_update_cursor (f, 1);
2760 x_set_frame_alpha (f);
2763 static void
2764 frame_unhighlight (struct frame *f)
2766 x_update_cursor (f, 1);
2767 x_set_frame_alpha (f);
2770 /* The focus has changed. Update the frames as necessary to reflect
2771 the new situation. Note that we can't change the selected frame
2772 here, because the Lisp code we are interrupting might become confused.
2773 Each event gets marked with the frame in which it occurred, so the
2774 Lisp code can tell when the switch took place by examining the events. */
2776 static void
2777 x_new_focus_frame (struct w32_display_info *dpyinfo, struct frame *frame)
2779 struct frame *old_focus = dpyinfo->w32_focus_frame;
2781 if (frame != dpyinfo->w32_focus_frame)
2783 /* Set this before calling other routines, so that they see
2784 the correct value of w32_focus_frame. */
2785 dpyinfo->w32_focus_frame = frame;
2787 if (old_focus && old_focus->auto_lower)
2788 x_lower_frame (old_focus);
2790 if (dpyinfo->w32_focus_frame && dpyinfo->w32_focus_frame->auto_raise)
2791 dpyinfo->w32_pending_autoraise_frame = dpyinfo->w32_focus_frame;
2792 else
2793 dpyinfo->w32_pending_autoraise_frame = NULL;
2796 x_frame_rehighlight (dpyinfo);
2800 /* Handle FocusIn and FocusOut state changes for FRAME.
2801 If FRAME has focus and there exists more than one frame, puts
2802 a FOCUS_IN_EVENT into *BUFP. */
2804 static void
2805 x_focus_changed (int type, int state, struct w32_display_info *dpyinfo,
2806 struct frame *frame, struct input_event *bufp)
2808 if (type == WM_SETFOCUS)
2810 if (dpyinfo->w32_focus_event_frame != frame)
2812 x_new_focus_frame (dpyinfo, frame);
2813 dpyinfo->w32_focus_event_frame = frame;
2815 /* Don't stop displaying the initial startup message
2816 for a switch-frame event we don't need. */
2817 if (NILP (Vterminal_frame)
2818 && CONSP (Vframe_list)
2819 && !NILP (XCDR (Vframe_list)))
2821 bufp->arg = Qt;
2823 else
2825 bufp->arg = Qnil;
2828 bufp->kind = FOCUS_IN_EVENT;
2829 XSETFRAME (bufp->frame_or_window, frame);
2832 frame->output_data.x->focus_state |= state;
2834 /* TODO: IME focus? */
2836 else if (type == WM_KILLFOCUS)
2838 frame->output_data.x->focus_state &= ~state;
2840 if (dpyinfo->w32_focus_event_frame == frame)
2842 dpyinfo->w32_focus_event_frame = 0;
2843 x_new_focus_frame (dpyinfo, 0);
2845 bufp->kind = FOCUS_OUT_EVENT;
2846 XSETFRAME (bufp->frame_or_window, frame);
2849 /* TODO: IME focus? */
2854 /* The focus may have changed. Figure out if it is a real focus change,
2855 by checking both FocusIn/Out and Enter/LeaveNotify events.
2857 Returns FOCUS_IN_EVENT event in *BUFP. */
2859 static void
2860 w32_detect_focus_change (struct w32_display_info *dpyinfo, W32Msg *event,
2861 struct input_event *bufp)
2863 struct frame *frame;
2865 frame = x_any_window_to_frame (dpyinfo, event->msg.hwnd);
2866 if (! frame)
2867 return;
2869 /* On w32, this is only called from focus events, so no switch needed. */
2870 x_focus_changed (event->msg.message,
2871 (event->msg.message == WM_KILLFOCUS ?
2872 FOCUS_IMPLICIT : FOCUS_EXPLICIT),
2873 dpyinfo, frame, bufp);
2877 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2879 void
2880 x_mouse_leave (struct w32_display_info *dpyinfo)
2882 x_new_focus_frame (dpyinfo, dpyinfo->w32_focus_event_frame);
2885 /* The focus has changed, or we have redirected a frame's focus to
2886 another frame (this happens when a frame uses a surrogate
2887 mini-buffer frame). Shift the highlight as appropriate.
2889 The FRAME argument doesn't necessarily have anything to do with which
2890 frame is being highlighted or un-highlighted; we only use it to find
2891 the appropriate X display info. */
2893 static void
2894 w32_frame_rehighlight (struct frame *frame)
2896 if (! FRAME_W32_P (frame))
2897 return;
2898 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame));
2901 static void
2902 x_frame_rehighlight (struct w32_display_info *dpyinfo)
2904 struct frame *old_highlight = dpyinfo->x_highlight_frame;
2906 if (dpyinfo->w32_focus_frame)
2908 dpyinfo->x_highlight_frame
2909 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame)))
2910 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame))
2911 : dpyinfo->w32_focus_frame);
2912 if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
2914 fset_focus_frame (dpyinfo->w32_focus_frame, Qnil);
2915 dpyinfo->x_highlight_frame = dpyinfo->w32_focus_frame;
2918 else
2919 dpyinfo->x_highlight_frame = 0;
2921 if (dpyinfo->x_highlight_frame != old_highlight)
2923 if (old_highlight)
2924 frame_unhighlight (old_highlight);
2925 if (dpyinfo->x_highlight_frame)
2926 frame_highlight (dpyinfo->x_highlight_frame);
2930 /* Keyboard processing - modifier keys, etc. */
2932 /* Convert a keysym to its name. */
2934 char *
2935 x_get_keysym_name (int keysym)
2937 /* Make static so we can always return it */
2938 static char value[100];
2940 block_input ();
2941 GetKeyNameText (keysym, value, 100);
2942 unblock_input ();
2944 return value;
2947 static int
2948 codepage_for_locale (LCID locale)
2950 char cp[20];
2952 if (GetLocaleInfo (locale, LOCALE_IDEFAULTANSICODEPAGE, cp, 20) > 0)
2953 return atoi (cp);
2954 else
2955 return CP_ACP;
2959 /* Mouse clicks and mouse movement. Rah. */
2961 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2962 the state in PUP. XBUTTON provides extra information for extended mouse
2963 button messages. Returns FALSE if unable to parse the message. */
2964 BOOL
2965 parse_button (int message, int xbutton, int * pbutton, int * pup)
2967 int button = 0;
2968 int up = 0;
2970 switch (message)
2972 case WM_LBUTTONDOWN:
2973 button = 0;
2974 up = 0;
2975 break;
2976 case WM_LBUTTONUP:
2977 button = 0;
2978 up = 1;
2979 break;
2980 case WM_MBUTTONDOWN:
2981 if (NILP (Vw32_swap_mouse_buttons))
2982 button = 1;
2983 else
2984 button = 2;
2985 up = 0;
2986 break;
2987 case WM_MBUTTONUP:
2988 if (NILP (Vw32_swap_mouse_buttons))
2989 button = 1;
2990 else
2991 button = 2;
2992 up = 1;
2993 break;
2994 case WM_RBUTTONDOWN:
2995 if (NILP (Vw32_swap_mouse_buttons))
2996 button = 2;
2997 else
2998 button = 1;
2999 up = 0;
3000 break;
3001 case WM_RBUTTONUP:
3002 if (NILP (Vw32_swap_mouse_buttons))
3003 button = 2;
3004 else
3005 button = 1;
3006 up = 1;
3007 break;
3008 case WM_XBUTTONDOWN:
3009 button = xbutton + 2;
3010 up = 0;
3011 break;
3012 case WM_XBUTTONUP:
3013 button = xbutton + 2;
3014 up = 1;
3015 break;
3016 default:
3017 return (FALSE);
3020 if (pup) *pup = up;
3021 if (pbutton) *pbutton = button;
3023 return (TRUE);
3027 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3029 If the event is a button press, then note that we have grabbed
3030 the mouse. */
3032 static Lisp_Object
3033 construct_mouse_click (struct input_event *result, W32Msg *msg, struct frame *f)
3035 int button;
3036 int up;
3038 parse_button (msg->msg.message, HIWORD (msg->msg.wParam),
3039 &button, &up);
3041 /* Make the event type NO_EVENT; we'll change that when we decide
3042 otherwise. */
3043 result->kind = MOUSE_CLICK_EVENT;
3044 result->code = button;
3045 result->timestamp = msg->msg.time;
3046 result->modifiers = (msg->dwModifiers
3047 | (up
3048 ? up_modifier
3049 : down_modifier));
3051 XSETINT (result->x, LOWORD (msg->msg.lParam));
3052 XSETINT (result->y, HIWORD (msg->msg.lParam));
3053 XSETFRAME (result->frame_or_window, f);
3054 result->arg = Qnil;
3055 return Qnil;
3058 static Lisp_Object
3059 construct_mouse_wheel (struct input_event *result, W32Msg *msg, struct frame *f)
3061 POINT p;
3062 int delta;
3064 result->kind = msg->msg.message == WM_MOUSEHWHEEL ? HORIZ_WHEEL_EVENT
3065 : WHEEL_EVENT;
3066 result->code = 0;
3067 result->timestamp = msg->msg.time;
3069 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3070 forward, away from the user (up); a negative value indicates that
3071 the wheel was rotated backward, toward the user (down). */
3072 delta = GET_WHEEL_DELTA_WPARAM (msg->msg.wParam);
3074 /* The up and down modifiers indicate if the wheel was rotated up or
3075 down based on WHEEL_DELTA value. */
3076 result->modifiers = (msg->dwModifiers
3077 | ((delta < 0 ) ? down_modifier : up_modifier));
3079 /* With multiple monitors, we can legitimately get negative
3080 coordinates, so cast to short to interpret them correctly. */
3081 p.x = (short) LOWORD (msg->msg.lParam);
3082 p.y = (short) HIWORD (msg->msg.lParam);
3083 ScreenToClient (msg->msg.hwnd, &p);
3084 XSETINT (result->x, p.x);
3085 XSETINT (result->y, p.y);
3086 XSETFRAME (result->frame_or_window, f);
3087 result->arg = Qnil;
3088 return Qnil;
3091 static Lisp_Object
3092 construct_drag_n_drop (struct input_event *result, W32Msg *msg, struct frame *f)
3094 Lisp_Object files;
3095 Lisp_Object frame;
3096 HDROP hdrop;
3097 POINT p;
3098 WORD num_files;
3099 wchar_t name_w[MAX_PATH];
3100 #ifdef NTGUI_UNICODE
3101 const int use_unicode = 1;
3102 #else
3103 int use_unicode = w32_unicode_filenames;
3104 char name_a[MAX_PATH];
3105 char file[MAX_UTF8_PATH];
3106 #endif
3107 int i;
3109 result->kind = DRAG_N_DROP_EVENT;
3110 result->code = 0;
3111 result->timestamp = msg->msg.time;
3112 result->modifiers = msg->dwModifiers;
3114 hdrop = (HDROP) msg->msg.wParam;
3115 DragQueryPoint (hdrop, &p);
3117 #if 0
3118 p.x = LOWORD (msg->msg.lParam);
3119 p.y = HIWORD (msg->msg.lParam);
3120 ScreenToClient (msg->msg.hwnd, &p);
3121 #endif
3123 XSETINT (result->x, p.x);
3124 XSETINT (result->y, p.y);
3126 num_files = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0);
3127 files = Qnil;
3129 for (i = 0; i < num_files; i++)
3131 if (use_unicode)
3133 eassert (DragQueryFileW (hdrop, i, NULL, 0) < MAX_PATH);
3134 /* If DragQueryFile returns zero, it failed to fetch a file
3135 name. */
3136 if (DragQueryFileW (hdrop, i, name_w, MAX_PATH) == 0)
3137 continue;
3138 #ifdef NTGUI_UNICODE
3139 files = Fcons (from_unicode_buffer (name_w), files);
3140 #else
3141 filename_from_utf16 (name_w, file);
3142 files = Fcons (DECODE_FILE (build_unibyte_string (file)), files);
3143 #endif /* NTGUI_UNICODE */
3145 #ifndef NTGUI_UNICODE
3146 else
3148 eassert (DragQueryFileA (hdrop, i, NULL, 0) < MAX_PATH);
3149 if (DragQueryFileA (hdrop, i, name_a, MAX_PATH) == 0)
3150 continue;
3151 filename_from_ansi (name_a, file);
3152 files = Fcons (DECODE_FILE (build_unibyte_string (file)), files);
3154 #endif
3157 DragFinish (hdrop);
3159 XSETFRAME (frame, f);
3160 result->frame_or_window = frame;
3161 result->arg = files;
3162 return Qnil;
3166 #if HAVE_W32NOTIFY
3168 /* File event notifications (see w32notify.c). */
3170 Lisp_Object
3171 lispy_file_action (DWORD action)
3173 static char unknown_fmt[] = "unknown-action(%d)";
3174 Lisp_Object retval;
3176 switch (action)
3178 case FILE_ACTION_ADDED:
3179 retval = Qadded;
3180 break;
3181 case FILE_ACTION_REMOVED:
3182 retval = Qremoved;
3183 break;
3184 case FILE_ACTION_MODIFIED:
3185 retval = Qmodified;
3186 break;
3187 case FILE_ACTION_RENAMED_OLD_NAME:
3188 retval = Qrenamed_from;
3189 break;
3190 case FILE_ACTION_RENAMED_NEW_NAME:
3191 retval = Qrenamed_to;
3192 break;
3193 default:
3195 char buf[sizeof(unknown_fmt) - 1 + INT_STRLEN_BOUND (DWORD)];
3197 sprintf (buf, unknown_fmt, action);
3198 retval = intern (buf);
3200 break;
3203 return retval;
3206 #ifdef WINDOWSNT
3207 /* Put file notifications into the Emacs input event queue. This
3208 function runs when the WM_EMACS_FILENOTIFY message arrives from a
3209 watcher thread. */
3210 static void
3211 queue_notifications (struct input_event *event, W32Msg *msg, struct frame *f,
3212 int *evcount)
3214 struct notifications_set *ns = NULL;
3215 Lisp_Object frame;
3216 int done = 0;
3218 /* We cannot process notification before Emacs is fully initialized,
3219 since we need the UTF-16LE coding-system to be set up. */
3220 if (!initialized)
3221 return;
3223 XSETFRAME (frame, f);
3225 while (!done)
3227 ns = NULL;
3229 /* Find out if there is a record available in the linked list of
3230 notifications sets. If so, unlink the set from the linked
3231 list. Use critical section. */
3232 enter_crit ();
3233 if (notifications_set_head->next != notifications_set_head)
3235 ns = notifications_set_head->next;
3236 ns->prev->next = ns->next;
3237 ns->next->prev = ns->prev;
3239 else
3240 done = 1;
3241 leave_crit();
3243 if (ns)
3245 BYTE *p = ns->notifications;
3246 FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
3247 const DWORD min_size
3248 = offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
3249 DWORD info_size = ns->size;
3250 Lisp_Object cs = Qutf_16le;
3251 Lisp_Object obj = w32_get_watch_object (ns->desc);
3253 /* notifications size could be zero when the buffer of
3254 notifications overflowed on the OS level, or when the
3255 directory being watched was itself deleted. Do nothing in
3256 that case. */
3257 if (info_size
3258 && !NILP (obj) && CONSP (obj))
3260 Lisp_Object callback = XCDR (obj);
3262 while (info_size >= min_size)
3264 Lisp_Object utf_16_fn
3265 = make_unibyte_string ((char *)fni->FileName,
3266 fni->FileNameLength);
3267 /* Note: mule-conf is preloaded, so utf-16le must
3268 already be defined at this point. */
3269 Lisp_Object fname
3270 = code_convert_string_norecord (utf_16_fn, cs, 0);
3271 Lisp_Object action = lispy_file_action (fni->Action);
3273 event->kind = FILE_NOTIFY_EVENT;
3274 event->timestamp = msg->msg.time;
3275 event->modifiers = 0;
3276 event->frame_or_window = callback;
3277 event->arg = list3 (make_pointer_integer (ns->desc),
3278 action, fname);
3279 kbd_buffer_store_event (event);
3280 (*evcount)++;
3281 if (!fni->NextEntryOffset)
3282 break;
3283 p += fni->NextEntryOffset;
3284 fni = (PFILE_NOTIFY_INFORMATION)p;
3285 info_size -= fni->NextEntryOffset;
3288 /* Free this notifications set. */
3289 xfree (ns->notifications);
3290 xfree (ns);
3293 /* We've stuffed all the events ourselves, so w32_read_socket shouldn't. */
3294 event->kind = NO_EVENT;
3296 #endif /* WINDOWSNT */
3297 #endif /* HAVE_W32NOTIFY */
3300 /* Function to report a mouse movement to the mainstream Emacs code.
3301 The input handler calls this.
3303 We have received a mouse movement event, which is given in *event.
3304 If the mouse is over a different glyph than it was last time, tell
3305 the mainstream emacs code by setting mouse_moved. If not, ask for
3306 another motion event, so we can check again the next time it moves. */
3308 static int
3309 note_mouse_movement (struct frame *frame, MSG *msg)
3311 struct w32_display_info *dpyinfo;
3312 int mouse_x = LOWORD (msg->lParam);
3313 int mouse_y = HIWORD (msg->lParam);
3314 RECT *r;
3316 if (!FRAME_X_OUTPUT (frame))
3317 return 0;
3319 dpyinfo = FRAME_DISPLAY_INFO (frame);
3320 dpyinfo->last_mouse_movement_time = msg->time;
3321 dpyinfo->last_mouse_motion_frame = frame;
3322 dpyinfo->last_mouse_motion_x = mouse_x;
3323 dpyinfo->last_mouse_motion_y = mouse_y;
3325 if (msg->hwnd != FRAME_W32_WINDOW (frame))
3327 frame->mouse_moved = true;
3328 dpyinfo->last_mouse_scroll_bar = NULL;
3329 note_mouse_highlight (frame, -1, -1);
3330 dpyinfo->last_mouse_glyph_frame = NULL;
3331 return 1;
3334 /* Has the mouse moved off the glyph it was on at the last sighting? */
3335 r = &dpyinfo->last_mouse_glyph;
3336 if (frame != dpyinfo->last_mouse_glyph_frame
3337 || mouse_x < r->left || mouse_x >= r->right
3338 || mouse_y < r->top || mouse_y >= r->bottom)
3340 frame->mouse_moved = true;
3341 dpyinfo->last_mouse_scroll_bar = NULL;
3342 note_mouse_highlight (frame, mouse_x, mouse_y);
3343 /* Remember the mouse position here, as w32_mouse_position only
3344 gets called when mouse tracking is enabled but we also need
3345 to keep track of the mouse for help_echo and highlighting at
3346 other times. */
3347 remember_mouse_glyph (frame, mouse_x, mouse_y, r);
3348 dpyinfo->last_mouse_glyph_frame = frame;
3349 return 1;
3352 return 0;
3356 /************************************************************************
3357 Mouse Face
3358 ************************************************************************/
3360 static struct scroll_bar *x_window_to_scroll_bar (Window, int);
3361 static void x_scroll_bar_report_motion (struct frame **, Lisp_Object *,
3362 enum scroll_bar_part *,
3363 Lisp_Object *, Lisp_Object *,
3364 Time *);
3365 static void x_horizontal_scroll_bar_report_motion (struct frame **, Lisp_Object *,
3366 enum scroll_bar_part *,
3367 Lisp_Object *, Lisp_Object *,
3368 Time *);
3369 static void
3370 w32_define_cursor (Window window, Cursor cursor)
3372 PostMessage (window, WM_EMACS_SETCURSOR, (WPARAM) cursor, 0);
3375 /* Return the current position of the mouse.
3376 *fp should be a frame which indicates which display to ask about.
3378 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3379 and *part to the frame, window, and scroll bar part that the mouse
3380 is over. Set *x and *y to the portion and whole of the mouse's
3381 position on the scroll bar.
3383 If the mouse movement started elsewhere, set *fp to the frame the
3384 mouse is on, *bar_window to nil, and *x and *y to the character cell
3385 the mouse is over.
3387 Set *time to the server time-stamp for the time at which the mouse
3388 was at this position.
3390 Don't store anything if we don't have a valid set of values to report.
3392 This clears the mouse_moved flag, so we can wait for the next mouse
3393 movement. */
3395 static void
3396 w32_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
3397 enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
3398 Time *time)
3400 struct frame *f1;
3401 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
3403 block_input ();
3405 if (dpyinfo->last_mouse_scroll_bar && insist == 0)
3407 struct scroll_bar *bar = dpyinfo->last_mouse_scroll_bar;
3409 if (bar->horizontal)
3410 x_horizontal_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
3411 else
3412 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
3414 else
3416 POINT pt;
3418 Lisp_Object frame, tail;
3420 /* Clear the mouse-moved flag for every frame on this display. */
3421 FOR_EACH_FRAME (tail, frame)
3422 XFRAME (frame)->mouse_moved = false;
3424 dpyinfo->last_mouse_scroll_bar = NULL;
3426 GetCursorPos (&pt);
3428 /* Now we have a position on the root; find the innermost window
3429 containing the pointer. */
3431 /* If mouse was grabbed on a frame, give coords for that
3432 frame even if the mouse is now outside it. Otherwise
3433 check for window under mouse on one of our frames. */
3434 f1 = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
3435 : x_any_window_to_frame (dpyinfo, WindowFromPoint (pt)));
3437 /* If not, is it one of our scroll bars? */
3438 if (! f1)
3440 struct scroll_bar *bar
3441 = x_window_to_scroll_bar (WindowFromPoint (pt), 2);
3443 if (bar)
3444 f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3447 if (f1 == 0 && insist > 0)
3448 f1 = SELECTED_FRAME ();
3450 if (f1)
3452 /* Ok, we found a frame. Store all the values.
3453 last_mouse_glyph is a rectangle used to reduce the
3454 generation of mouse events. To not miss any motion
3455 events, we must divide the frame into rectangles of the
3456 size of the smallest character that could be displayed
3457 on it, i.e. into the same rectangles that matrices on
3458 the frame are divided into. */
3460 dpyinfo = FRAME_DISPLAY_INFO (f1);
3461 ScreenToClient (FRAME_W32_WINDOW (f1), &pt);
3462 remember_mouse_glyph (f1, pt.x, pt.y, &dpyinfo->last_mouse_glyph);
3463 dpyinfo->last_mouse_glyph_frame = f1;
3465 *bar_window = Qnil;
3466 *part = scroll_bar_above_handle;
3467 *fp = f1;
3468 XSETINT (*x, pt.x);
3469 XSETINT (*y, pt.y);
3470 *time = dpyinfo->last_mouse_movement_time;
3475 unblock_input ();
3479 /***********************************************************************
3480 Tool-bars
3481 ***********************************************************************/
3483 /* Handle mouse button event on the tool-bar of frame F, at
3484 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
3485 or ButtonRelease. */
3487 static void
3488 w32_handle_tool_bar_click (struct frame *f, struct input_event *button_event)
3490 int x = XFASTINT (button_event->x);
3491 int y = XFASTINT (button_event->y);
3493 if (button_event->modifiers & down_modifier)
3494 handle_tool_bar_click (f, x, y, 1, 0);
3495 else
3496 handle_tool_bar_click (f, x, y, 0,
3497 button_event->modifiers & ~up_modifier);
3502 /***********************************************************************
3503 Scroll bars
3504 ***********************************************************************/
3506 /* Scroll bar support. */
3508 /* Given a window ID, find the struct scroll_bar which manages it
3509 vertically. This can be called in GC, so we have to make sure to
3510 strip off mark bits. */
3512 static struct scroll_bar *
3513 x_window_to_scroll_bar (Window window_id, int type)
3515 Lisp_Object tail, frame;
3517 FOR_EACH_FRAME (tail, frame)
3519 Lisp_Object bar, condemned;
3521 /* Scan this frame's scroll bar list for a scroll bar with the
3522 right window ID. */
3523 condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
3524 for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
3525 /* This trick allows us to search both the ordinary and
3526 condemned scroll bar lists with one loop. */
3527 ! NILP (bar) || (bar = condemned,
3528 condemned = Qnil,
3529 ! NILP (bar));
3530 bar = XSCROLL_BAR (bar)->next)
3531 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar)) == window_id
3532 && (type = 2
3533 || (type == 1 && XSCROLL_BAR (bar)->horizontal)
3534 || (type == 0 && !XSCROLL_BAR (bar)->horizontal)))
3535 return XSCROLL_BAR (bar);
3538 return 0;
3543 /* Set the thumb size and position of vertical scroll bar BAR. We are currently
3544 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3546 static void
3547 w32_set_scroll_bar_thumb (struct scroll_bar *bar,
3548 int portion, int position, int whole)
3550 Window w = SCROLL_BAR_W32_WINDOW (bar);
3551 /* We use the whole scroll-bar height in the calculations below, to
3552 avoid strange effects like scrolling backwards when just clicking
3553 on the handle (without moving it). */
3554 double range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height)
3555 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3556 int sb_page, sb_pos;
3557 BOOL draggingp = bar->dragging ? TRUE : FALSE;
3558 SCROLLINFO si;
3560 /* We used to change the nPage setting while dragging the handle,
3561 but that had very strange effects (such as scrolling backwards
3562 while dragging downwards).
3564 Now, we don't change the nPage setting while dragging unless we
3565 get near to the end of the buffer, in which case we often have to
3566 resize the handle to "go all the way". */
3568 if (draggingp)
3570 int near_bottom_p;
3571 block_input ();
3572 si.cbSize = sizeof (si);
3573 si.fMask = SIF_POS | SIF_PAGE;
3574 GetScrollInfo (w, SB_CTL, &si);
3575 near_bottom_p = si.nPos + si.nPage >= range;
3576 unblock_input ();
3577 if (!near_bottom_p)
3578 return;
3581 if (whole)
3583 /* Position scroll bar at rock bottom if the bottom of the
3584 buffer is visible. This avoids shrinking the thumb away
3585 to nothing if it is held at the bottom of the buffer. */
3586 if (position + portion >= whole && !draggingp)
3588 sb_page = range * (whole - position) / whole;
3589 sb_pos = range;
3591 else
3593 sb_pos = position * range / whole;
3594 sb_page = (min (portion, (whole - position)) * range) / whole;
3597 else
3599 sb_page = range;
3600 sb_pos = 0;
3603 sb_page = max (sb_page, VERTICAL_SCROLL_BAR_MIN_HANDLE);
3605 block_input ();
3607 si.cbSize = sizeof (si);
3608 si.fMask = SIF_PAGE | SIF_POS;
3609 si.nPage = sb_page;
3610 si.nPos = sb_pos;
3612 SetScrollInfo (w, SB_CTL, &si, TRUE);
3614 unblock_input ();
3617 /* Set the thumb size and position of horizontal scroll bar BAR. We are currently
3618 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3620 static void
3621 w32_set_horizontal_scroll_bar_thumb (struct scroll_bar *bar,
3622 int portion, int position, int whole)
3624 Window w = SCROLL_BAR_W32_WINDOW (bar);
3625 SCROLLINFO si;
3627 block_input ();
3629 si.cbSize = sizeof (si);
3630 si.fMask = SIF_PAGE | SIF_POS | SIF_RANGE;
3631 si.nMin = 0;
3632 si.nMax = whole;
3633 /* Allow nPage to be one larger than nPos so we don't allow the scrolling
3634 of an already fully visible buffer. */
3635 si.nPage = min (portion, si.nMax) + 1;
3636 si.nPos = min (position, si.nMax);
3637 SetScrollInfo (w, SB_CTL, &si, TRUE);
3639 unblock_input ();
3643 /************************************************************************
3644 Scroll bars, general
3645 ************************************************************************/
3647 static HWND
3648 my_create_vscrollbar (struct frame * f, struct scroll_bar * bar)
3650 return (HWND) SendMessage (FRAME_W32_WINDOW (f),
3651 WM_EMACS_CREATEVSCROLLBAR, (WPARAM) f,
3652 (LPARAM) bar);
3655 static HWND
3656 my_create_hscrollbar (struct frame * f, struct scroll_bar * bar)
3658 return (HWND) SendMessage (FRAME_W32_WINDOW (f),
3659 WM_EMACS_CREATEHSCROLLBAR, (WPARAM) f,
3660 (LPARAM) bar);
3663 /*#define ATTACH_THREADS*/
3665 static BOOL
3666 my_show_window (struct frame *f, HWND hwnd, int how)
3668 #ifndef ATTACH_THREADS
3669 return SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SHOWWINDOW,
3670 (WPARAM) hwnd, (LPARAM) how);
3671 #else
3672 return ShowWindow (hwnd, how);
3673 #endif
3676 static void
3677 my_set_window_pos (HWND hwnd, HWND hwndAfter,
3678 int x, int y, int cx, int cy, UINT flags)
3680 #ifndef ATTACH_THREADS
3681 WINDOWPOS pos;
3682 pos.hwndInsertAfter = hwndAfter;
3683 pos.x = x;
3684 pos.y = y;
3685 pos.cx = cx;
3686 pos.cy = cy;
3687 pos.flags = flags;
3688 SendMessage (hwnd, WM_EMACS_SETWINDOWPOS, (WPARAM) &pos, 0);
3689 #else
3690 SetWindowPos (hwnd, hwndAfter, x, y, cx, cy, flags);
3691 #endif
3694 #if 0
3695 static void
3696 my_set_focus (struct frame * f, HWND hwnd)
3698 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SETFOCUS,
3699 (WPARAM) hwnd, 0);
3701 #endif
3703 static void
3704 my_set_foreground_window (HWND hwnd)
3706 SendMessage (hwnd, WM_EMACS_SETFOREGROUND, (WPARAM) hwnd, 0);
3710 static void
3711 my_destroy_window (struct frame * f, HWND hwnd)
3713 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_DESTROYWINDOW,
3714 (WPARAM) hwnd, 0);
3717 static void
3718 my_bring_window_to_top (HWND hwnd)
3720 SendMessage (hwnd, WM_EMACS_BRINGTOTOP, (WPARAM) hwnd, 0);
3723 /* Create a scroll bar and return the scroll bar vector for it. W is
3724 the Emacs window on which to create the scroll bar. TOP, LEFT,
3725 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
3726 scroll bar. */
3728 static struct scroll_bar *
3729 x_scroll_bar_create (struct window *w, int left, int top, int width, int height, bool horizontal)
3731 struct frame *f = XFRAME (WINDOW_FRAME (w));
3732 HWND hwnd;
3733 SCROLLINFO si;
3734 struct scroll_bar *bar
3735 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar, top, PVEC_OTHER);
3736 Lisp_Object barobj;
3738 block_input ();
3740 XSETWINDOW (bar->window, w);
3741 bar->top = top;
3742 bar->left = left;
3743 bar->width = width;
3744 bar->height = height;
3745 bar->start = 0;
3746 bar->end = 0;
3747 bar->dragging = 0;
3748 bar->horizontal = horizontal;
3750 /* Requires geometry to be set before call to create the real window */
3752 if (horizontal)
3753 hwnd = my_create_hscrollbar (f, bar);
3754 else
3755 hwnd = my_create_vscrollbar (f, bar);
3757 si.cbSize = sizeof (si);
3758 si.fMask = SIF_ALL;
3759 si.nMin = 0;
3760 if (horizontal)
3761 si.nMax = HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f, width)
3762 + HORIZONTAL_SCROLL_BAR_MIN_HANDLE;
3763 else
3764 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
3765 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3766 si.nPage = si.nMax;
3767 si.nPos = 0;
3769 SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3771 SET_SCROLL_BAR_W32_WINDOW (bar, hwnd);
3773 /* Add bar to its frame's list of scroll bars. */
3774 bar->next = FRAME_SCROLL_BARS (f);
3775 bar->prev = Qnil;
3776 XSETVECTOR (barobj, bar);
3777 fset_scroll_bars (f, barobj);
3778 if (! NILP (bar->next))
3779 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
3781 unblock_input ();
3783 return bar;
3787 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3788 nil. */
3790 static void
3791 x_scroll_bar_remove (struct scroll_bar *bar)
3793 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3795 block_input ();
3797 /* Destroy the window. */
3798 my_destroy_window (f, SCROLL_BAR_W32_WINDOW (bar));
3800 /* Dissociate this scroll bar from its window. */
3801 if (bar->horizontal)
3802 wset_horizontal_scroll_bar (XWINDOW (bar->window), Qnil);
3803 else
3804 wset_vertical_scroll_bar (XWINDOW (bar->window), Qnil);
3806 unblock_input ();
3809 /* Set the handle of the vertical scroll bar for WINDOW to indicate that
3810 we are displaying PORTION characters out of a total of WHOLE
3811 characters, starting at POSITION. If WINDOW has no vertical scroll
3812 bar, create one. */
3813 static void
3814 w32_set_vertical_scroll_bar (struct window *w,
3815 int portion, int whole, int position)
3817 struct frame *f = XFRAME (w->frame);
3818 Lisp_Object barobj;
3819 struct scroll_bar *bar;
3820 int top, height, left, width;
3821 int window_y, window_height;
3823 /* Get window dimensions. */
3824 window_box (w, ANY_AREA, 0, &window_y, 0, &window_height);
3825 top = window_y;
3826 height = window_height;
3828 /* Compute the left edge and the width of the scroll bar area. */
3829 left = WINDOW_SCROLL_BAR_AREA_X (w);
3830 width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
3832 /* Does the scroll bar exist yet? */
3833 if (NILP (w->vertical_scroll_bar))
3835 HDC hdc;
3836 block_input ();
3837 if (width > 0 && height > 0)
3839 hdc = get_frame_dc (f);
3840 w32_clear_area (f, hdc, left, top, width, height);
3841 release_frame_dc (f, hdc);
3843 unblock_input ();
3845 bar = x_scroll_bar_create (w, left, top, width, height, false);
3847 else
3849 /* It may just need to be moved and resized. */
3850 HWND hwnd;
3852 bar = XSCROLL_BAR (w->vertical_scroll_bar);
3853 hwnd = SCROLL_BAR_W32_WINDOW (bar);
3855 /* If already correctly positioned, do nothing. */
3856 if (bar->left == left
3857 && bar->top == top
3858 && bar->width == width
3859 && bar->height == height)
3861 /* Redraw after clear_frame. */
3862 if (!my_show_window (f, hwnd, SW_NORMAL))
3863 InvalidateRect (hwnd, NULL, FALSE);
3865 else
3867 HDC hdc;
3868 SCROLLINFO si;
3870 block_input ();
3871 if (width && height)
3873 hdc = get_frame_dc (f);
3874 /* Since Windows scroll bars are smaller than the space reserved
3875 for them on the frame, we have to clear "under" them. */
3876 w32_clear_area (f, hdc, left, top, width, height);
3877 release_frame_dc (f, hdc);
3879 /* Make sure scroll bar is "visible" before moving, to ensure the
3880 area of the parent window now exposed will be refreshed. */
3881 my_show_window (f, hwnd, SW_HIDE);
3882 MoveWindow (hwnd, left, top, width, max (height, 1), TRUE);
3884 si.cbSize = sizeof (si);
3885 si.fMask = SIF_RANGE;
3886 si.nMin = 0;
3887 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
3888 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3890 SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3892 my_show_window (f, hwnd, SW_NORMAL);
3893 /* InvalidateRect (w, NULL, FALSE); */
3895 /* Remember new settings. */
3896 bar->left = left;
3897 bar->top = top;
3898 bar->width = width;
3899 bar->height = height;
3901 unblock_input ();
3904 w32_set_scroll_bar_thumb (bar, portion, position, whole);
3905 XSETVECTOR (barobj, bar);
3906 wset_vertical_scroll_bar (w, barobj);
3909 /* Set the handle of the horizontal scroll bar for WINDOW to indicate
3910 that we are displaying PORTION characters out of a total of WHOLE
3911 characters, starting at POSITION. If WINDOW has no horizontal scroll
3912 bar, create one. */
3913 static void
3914 w32_set_horizontal_scroll_bar (struct window *w,
3915 int portion, int whole, int position)
3917 struct frame *f = XFRAME (w->frame);
3918 Lisp_Object barobj;
3919 struct scroll_bar *bar;
3920 int top, height, left, width;
3921 int window_x, window_width;
3922 int clear_left = WINDOW_LEFT_EDGE_X (w);
3923 int clear_width = WINDOW_PIXEL_WIDTH (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
3925 /* Get window dimensions. */
3926 window_box (w, ANY_AREA, &window_x, 0, &window_width, 0);
3927 left = window_x;
3928 height = WINDOW_SCROLL_BAR_AREA_HEIGHT (w);
3929 width = window_width;
3930 top = WINDOW_SCROLL_BAR_AREA_Y (w);
3932 /* Does the scroll bar exist yet? */
3933 if (NILP (w->horizontal_scroll_bar))
3935 HDC hdc;
3936 block_input ();
3937 if (width > 0 && height > 0)
3939 hdc = get_frame_dc (f);
3940 w32_clear_area (f, hdc, clear_left, top, clear_width, height);
3941 release_frame_dc (f, hdc);
3943 unblock_input ();
3945 bar = x_scroll_bar_create (w, left, top, width, height, true);
3947 else
3949 /* It may just need to be moved and resized. */
3950 HWND hwnd;
3952 bar = XSCROLL_BAR (w->horizontal_scroll_bar);
3953 hwnd = SCROLL_BAR_W32_WINDOW (bar);
3955 /* If already correctly positioned, do nothing. */
3956 if (bar->left == left && bar->top == top
3957 && bar->width == width && bar->height == height)
3959 /* Redraw after clear_frame. */
3960 if (!my_show_window (f, hwnd, SW_NORMAL))
3961 InvalidateRect (hwnd, NULL, FALSE);
3963 else
3965 HDC hdc;
3966 SCROLLINFO si;
3968 block_input ();
3969 if (width && height)
3971 hdc = get_frame_dc (f);
3972 /* Since Windows scroll bars are smaller than the space reserved
3973 for them on the frame, we have to clear "under" them. */
3974 w32_clear_area (f, hdc, clear_left, top, clear_width, height);
3975 release_frame_dc (f, hdc);
3977 /* Make sure scroll bar is "visible" before moving, to ensure the
3978 area of the parent window now exposed will be refreshed. */
3979 my_show_window (f, hwnd, SW_HIDE);
3980 MoveWindow (hwnd, left, top, width, max (height, 1), TRUE);
3982 /* +++ SetScrollInfo +++ */
3983 si.cbSize = sizeof (si);
3984 si.fMask = SIF_PAGE | SIF_POS | SIF_RANGE;
3985 si.nMin = 0;
3986 si.nMax = whole;
3987 si.nPage = min (portion, si.nMax) + 1;
3988 si.nPos = min (position, si.nMax);
3989 SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3991 my_show_window (f, hwnd, SW_NORMAL);
3992 /* InvalidateRect (w, NULL, FALSE); */
3994 /* Remember new settings. */
3995 bar->left = left;
3996 bar->top = top;
3997 bar->width = width;
3998 bar->height = height;
4000 unblock_input ();
4004 w32_set_horizontal_scroll_bar_thumb (bar, portion, position, whole);
4005 XSETVECTOR (barobj, bar);
4006 wset_horizontal_scroll_bar (w, barobj);
4010 /* The following three hooks are used when we're doing a thorough
4011 redisplay of the frame. We don't explicitly know which scroll bars
4012 are going to be deleted, because keeping track of when windows go
4013 away is a real pain - "Can you say set-window-configuration, boys
4014 and girls?" Instead, we just assert at the beginning of redisplay
4015 that *all* scroll bars are to be removed, and then save a scroll bar
4016 from the fiery pit when we actually redisplay its window. */
4018 /* Arrange for all scroll bars on FRAME to be removed at the next call
4019 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
4020 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
4022 static void
4023 w32_condemn_scroll_bars (struct frame *frame)
4025 if (!NILP (FRAME_SCROLL_BARS (frame)))
4027 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
4029 /* Prepend scrollbars to already condemned ones. */
4030 Lisp_Object last = FRAME_SCROLL_BARS (frame);
4032 while (!NILP (XSCROLL_BAR (last)->next))
4033 last = XSCROLL_BAR (last)->next;
4035 XSCROLL_BAR (last)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
4036 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = last;
4039 fset_condemned_scroll_bars (frame, FRAME_SCROLL_BARS (frame));
4040 fset_scroll_bars (frame, Qnil);
4045 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
4046 Note that WINDOW isn't necessarily condemned at all. */
4048 static void
4049 w32_redeem_scroll_bar (struct window *w)
4051 struct scroll_bar *bar;
4052 Lisp_Object barobj;
4053 struct frame *f;
4055 /* We can't redeem this window's scroll bar if it doesn't have one. */
4056 if (NILP (w->vertical_scroll_bar) && NILP (w->horizontal_scroll_bar))
4057 emacs_abort ();
4059 if (!NILP (w->vertical_scroll_bar) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
4061 bar = XSCROLL_BAR (w->vertical_scroll_bar);
4062 /* Unlink it from the condemned list. */
4063 f = XFRAME (WINDOW_FRAME (w));
4064 if (NILP (bar->prev))
4066 /* If the prev pointer is nil, it must be the first in one of
4067 the lists. */
4068 if (EQ (FRAME_SCROLL_BARS (f), w->vertical_scroll_bar))
4069 /* It's not condemned. Everything's fine. */
4070 goto horizontal;
4071 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
4072 w->vertical_scroll_bar))
4073 fset_condemned_scroll_bars (f, bar->next);
4074 else
4075 /* If its prev pointer is nil, it must be at the front of
4076 one or the other! */
4077 emacs_abort ();
4079 else
4080 XSCROLL_BAR (bar->prev)->next = bar->next;
4082 if (! NILP (bar->next))
4083 XSCROLL_BAR (bar->next)->prev = bar->prev;
4085 bar->next = FRAME_SCROLL_BARS (f);
4086 bar->prev = Qnil;
4087 XSETVECTOR (barobj, bar);
4088 fset_scroll_bars (f, barobj);
4089 if (! NILP (bar->next))
4090 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
4093 horizontal:
4094 if (!NILP (w->horizontal_scroll_bar) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w))
4096 bar = XSCROLL_BAR (w->horizontal_scroll_bar);
4097 /* Unlink it from the condemned list. */
4098 f = XFRAME (WINDOW_FRAME (w));
4099 if (NILP (bar->prev))
4101 /* If the prev pointer is nil, it must be the first in one of
4102 the lists. */
4103 if (EQ (FRAME_SCROLL_BARS (f), w->horizontal_scroll_bar))
4104 /* It's not condemned. Everything's fine. */
4105 return;
4106 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
4107 w->horizontal_scroll_bar))
4108 fset_condemned_scroll_bars (f, bar->next);
4109 else
4110 /* If its prev pointer is nil, it must be at the front of
4111 one or the other! */
4112 emacs_abort ();
4114 else
4115 XSCROLL_BAR (bar->prev)->next = bar->next;
4117 if (! NILP (bar->next))
4118 XSCROLL_BAR (bar->next)->prev = bar->prev;
4120 bar->next = FRAME_SCROLL_BARS (f);
4121 bar->prev = Qnil;
4122 XSETVECTOR (barobj, bar);
4123 fset_scroll_bars (f, barobj);
4124 if (! NILP (bar->next))
4125 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
4129 /* Remove all scroll bars on FRAME that haven't been saved since the
4130 last call to `*condemn_scroll_bars_hook'. */
4132 static void
4133 w32_judge_scroll_bars (struct frame *f)
4135 Lisp_Object bar, next;
4137 bar = FRAME_CONDEMNED_SCROLL_BARS (f);
4139 /* Clear out the condemned list now so we won't try to process any
4140 more events on the hapless scroll bars. */
4141 fset_condemned_scroll_bars (f, Qnil);
4143 for (; ! NILP (bar); bar = next)
4145 struct scroll_bar *b = XSCROLL_BAR (bar);
4147 x_scroll_bar_remove (b);
4149 next = b->next;
4150 b->next = b->prev = Qnil;
4153 /* Now there should be no references to the condemned scroll bars,
4154 and they should get garbage-collected. */
4157 /* Handle a mouse click on the vertical scroll bar BAR. If
4158 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4159 enqueued.
4161 This may be called from a signal handler, so we have to ignore GC
4162 mark bits. */
4164 static int
4165 w32_scroll_bar_handle_click (struct scroll_bar *bar, W32Msg *msg,
4166 struct input_event *emacs_event)
4168 if (! WINDOWP (bar->window))
4169 emacs_abort ();
4171 emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
4172 emacs_event->code = 0;
4173 /* not really meaningful to distinguish up/down */
4174 emacs_event->modifiers = msg->dwModifiers;
4175 emacs_event->frame_or_window = bar->window;
4176 emacs_event->arg = Qnil;
4177 emacs_event->timestamp = msg->msg.time;
4180 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height);
4181 int y;
4182 int dragging = bar->dragging;
4183 SCROLLINFO si;
4184 int sb_event = LOWORD (msg->msg.wParam);
4186 si.cbSize = sizeof (si);
4187 if (sb_event == SB_THUMBTRACK)
4188 si.fMask = SIF_TRACKPOS;
4189 else
4190 si.fMask = SIF_POS;
4192 GetScrollInfo ((HWND) msg->msg.lParam, SB_CTL, &si);
4193 if (sb_event == SB_THUMBTRACK)
4194 y = si.nTrackPos;
4195 else
4196 y = si.nPos;
4198 bar->dragging = 0;
4199 FRAME_DISPLAY_INFO (f)->last_mouse_scroll_bar_pos = msg->msg.wParam;
4201 switch (sb_event)
4203 case SB_LINEDOWN:
4204 emacs_event->part = scroll_bar_down_arrow;
4205 break;
4206 case SB_LINEUP:
4207 emacs_event->part = scroll_bar_up_arrow;
4208 break;
4209 case SB_PAGEUP:
4210 emacs_event->part = scroll_bar_above_handle;
4211 break;
4212 case SB_PAGEDOWN:
4213 emacs_event->part = scroll_bar_below_handle;
4214 break;
4215 case SB_TOP:
4216 emacs_event->part = scroll_bar_handle;
4217 y = 0;
4218 break;
4219 case SB_BOTTOM:
4220 emacs_event->part = scroll_bar_handle;
4221 y = top_range;
4222 break;
4223 case SB_THUMBTRACK:
4224 case SB_THUMBPOSITION:
4225 bar->dragging = 1; /* ??????? */
4226 emacs_event->part = scroll_bar_handle;
4228 /* "Silently" update current position. */
4230 SCROLLINFO si;
4232 si.cbSize = sizeof (si);
4233 si.fMask = SIF_POS;
4234 si.nPos = y;
4235 /* Remember apparent position (we actually lag behind the real
4236 position, so don't set that directly). */
4237 last_scroll_bar_drag_pos = y;
4239 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, FALSE);
4241 break;
4242 case SB_ENDSCROLL:
4243 /* If this is the end of a drag sequence, then reset the scroll
4244 handle size to normal and do a final redraw. Otherwise do
4245 nothing. */
4246 if (dragging)
4248 SCROLLINFO si;
4249 int start = bar->start;
4250 int end = bar->end;
4252 si.cbSize = sizeof (si);
4253 si.fMask = SIF_PAGE | SIF_POS;
4254 si.nPage = end - start + VERTICAL_SCROLL_BAR_MIN_HANDLE;
4255 si.nPos = last_scroll_bar_drag_pos;
4256 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE);
4258 /* fall through */
4259 default:
4260 emacs_event->kind = NO_EVENT;
4261 return FALSE;
4264 XSETINT (emacs_event->x, y);
4265 XSETINT (emacs_event->y, top_range);
4267 return TRUE;
4271 /* Handle a mouse click on the horizontal scroll bar BAR. If
4272 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4273 enqueued.
4275 This may be called from a signal handler, so we have to ignore GC
4276 mark bits. */
4278 static int
4279 w32_horizontal_scroll_bar_handle_click (struct scroll_bar *bar, W32Msg *msg,
4280 struct input_event *emacs_event)
4282 if (! WINDOWP (bar->window))
4283 emacs_abort ();
4285 emacs_event->kind = HORIZONTAL_SCROLL_BAR_CLICK_EVENT;
4286 emacs_event->code = 0;
4287 /* not really meaningful to distinguish left/right */
4288 emacs_event->modifiers = msg->dwModifiers;
4289 emacs_event->frame_or_window = bar->window;
4290 emacs_event->arg = Qnil;
4291 emacs_event->timestamp = msg->msg.time;
4294 int left_range = HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f, bar->width);
4295 int x, y;
4296 int dragging = bar->dragging;
4297 SCROLLINFO si;
4298 int sb_event = LOWORD (msg->msg.wParam);
4300 si.cbSize = sizeof (si);
4301 if (sb_event == SB_THUMBTRACK)
4302 si.fMask = SIF_TRACKPOS | SIF_PAGE | SIF_RANGE;
4303 else
4304 si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
4306 GetScrollInfo ((HWND) msg->msg.lParam, SB_CTL, &si);
4307 if (sb_event == SB_THUMBTRACK)
4308 x = si.nTrackPos;
4309 else
4310 x = si.nPos;
4311 y = si.nMax - si.nPage;
4313 bar->dragging = 0;
4314 FRAME_DISPLAY_INFO (f)->last_mouse_scroll_bar_pos = msg->msg.wParam;
4316 switch (sb_event)
4318 case SB_LINELEFT:
4319 emacs_event->part = scroll_bar_left_arrow;
4320 break;
4321 case SB_LINERIGHT:
4322 emacs_event->part = scroll_bar_right_arrow;
4323 break;
4324 case SB_PAGELEFT:
4325 emacs_event->part = scroll_bar_before_handle;
4326 break;
4327 case SB_PAGERIGHT:
4328 emacs_event->part = scroll_bar_after_handle;
4329 break;
4330 case SB_LEFT:
4331 emacs_event->part = scroll_bar_horizontal_handle;
4332 x = 0;
4333 break;
4334 case SB_RIGHT:
4335 emacs_event->part = scroll_bar_horizontal_handle;
4336 x = left_range;
4337 break;
4338 case SB_THUMBTRACK:
4339 case SB_THUMBPOSITION:
4340 bar->dragging = 1;
4341 emacs_event->part = scroll_bar_horizontal_handle;
4343 /* "Silently" update current position. */
4345 SCROLLINFO si;
4347 si.cbSize = sizeof (si);
4348 si.fMask = SIF_POS;
4349 si.nPos = min (x, XWINDOW (bar->window)->hscroll_whole - 1);
4350 /* Remember apparent position (we actually lag behind the real
4351 position, so don't set that directly). */
4352 last_scroll_bar_drag_pos = x;
4354 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, FALSE);
4356 break;
4357 case SB_ENDSCROLL:
4358 /* If this is the end of a drag sequence, then reset the scroll
4359 handle size to normal and do a final redraw. Otherwise do
4360 nothing. */
4361 if (dragging)
4363 SCROLLINFO si;
4365 si.cbSize = sizeof (si);
4366 si.fMask = SIF_POS;
4367 si.nPos = min (last_scroll_bar_drag_pos,
4368 XWINDOW (bar->window)->hscroll_whole - 1);
4369 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE);
4371 /* fall through */
4372 default:
4373 emacs_event->kind = NO_EVENT;
4374 return FALSE;
4377 XSETINT (emacs_event->x, x);
4378 XSETINT (emacs_event->y, y);
4380 return TRUE;
4384 /* Return information to the user about the current position of the mouse
4385 on the vertical scroll bar. */
4386 static void
4387 x_scroll_bar_report_motion (struct frame **fp, Lisp_Object *bar_window,
4388 enum scroll_bar_part *part,
4389 Lisp_Object *x, Lisp_Object *y,
4390 Time *time)
4392 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
4393 struct scroll_bar *bar = dpyinfo->last_mouse_scroll_bar;
4394 Window w = SCROLL_BAR_W32_WINDOW (bar);
4395 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
4396 int pos;
4397 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height);
4398 SCROLLINFO si;
4399 int sb_event = LOWORD (dpyinfo->last_mouse_scroll_bar_pos);
4401 block_input ();
4403 *fp = f;
4404 *bar_window = bar->window;
4406 si.cbSize = sizeof (si);
4407 if (sb_event == SB_THUMBTRACK)
4408 si.fMask = SIF_TRACKPOS | SIF_PAGE | SIF_RANGE;
4409 else
4410 si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
4412 GetScrollInfo (w, SB_CTL, &si);
4413 if (sb_event == SB_THUMBTRACK)
4414 pos = si.nTrackPos;
4415 else
4416 pos = si.nPos;
4417 top_range = si.nMax - si.nPage + 1;
4419 *part = scroll_bar_handle;
4420 if (sb_event == SB_LINEDOWN)
4421 pos++;
4423 XSETINT (*x, pos);
4424 XSETINT (*y, top_range);
4426 f->mouse_moved = false;
4427 dpyinfo->last_mouse_scroll_bar = NULL;
4429 *time = dpyinfo->last_mouse_movement_time;
4431 unblock_input ();
4434 /* Return information to the user about the current position of the mouse
4435 on the horizontal scroll bar. */
4436 static void
4437 x_horizontal_scroll_bar_report_motion (struct frame **fp, Lisp_Object *bar_window,
4438 enum scroll_bar_part *part,
4439 Lisp_Object *x, Lisp_Object *y,
4440 Time *time)
4442 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
4443 struct scroll_bar *bar = dpyinfo->last_mouse_scroll_bar;
4444 Window w = SCROLL_BAR_W32_WINDOW (bar);
4445 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
4446 int pos;
4447 int left_range = HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f, bar->width);
4448 SCROLLINFO si;
4449 int sb_event = LOWORD (dpyinfo->last_mouse_scroll_bar_pos);
4451 block_input ();
4453 *fp = f;
4454 *bar_window = bar->window;
4456 si.cbSize = sizeof (si);
4457 if (sb_event == SB_THUMBTRACK)
4458 si.fMask = SIF_TRACKPOS | SIF_PAGE | SIF_RANGE;
4459 else
4460 si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
4462 GetScrollInfo (w, SB_CTL, &si);
4463 if (sb_event == SB_THUMBTRACK)
4464 pos = si.nTrackPos;
4465 else
4466 pos = si.nPos;
4467 left_range = si.nMax - si.nPage + 1;
4469 *part = scroll_bar_handle;
4470 if (sb_event == SB_LINERIGHT)
4471 pos++;
4474 XSETINT (*y, pos);
4475 XSETINT (*x, left_range);
4477 f->mouse_moved = false;
4478 dpyinfo->last_mouse_scroll_bar = NULL;
4480 *time = dpyinfo->last_mouse_movement_time;
4482 unblock_input ();
4486 /* The screen has been cleared so we may have changed foreground or
4487 background colors, and the scroll bars may need to be redrawn.
4488 Clear out the scroll bars, and ask for expose events, so we can
4489 redraw them. */
4491 void
4492 x_scroll_bar_clear (struct frame *f)
4494 Lisp_Object bar;
4496 /* We can have scroll bars even if this is 0,
4497 if we just turned off scroll bar mode.
4498 But in that case we should not clear them. */
4499 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f)
4500 || FRAME_HAS_HORIZONTAL_SCROLL_BARS (f))
4501 for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
4502 bar = XSCROLL_BAR (bar)->next)
4504 HWND window = SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar));
4505 HDC hdc = GetDC (window);
4506 RECT rect;
4508 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4509 arranges to refresh the scroll bar if hidden. */
4510 my_show_window (f, window, SW_HIDE);
4512 GetClientRect (window, &rect);
4513 select_palette (f, hdc);
4514 w32_clear_rect (f, hdc, &rect);
4515 deselect_palette (f, hdc);
4517 ReleaseDC (window, hdc);
4521 /* The main W32 event-reading loop - w32_read_socket. */
4523 /* Record the last 100 characters stored
4524 to help debug the loss-of-chars-during-GC problem. */
4526 static int temp_index;
4527 static short temp_buffer[100];
4529 /* Temporarily store lead byte of DBCS input sequences. */
4530 static char dbcs_lead = 0;
4532 /* Read events coming from the W32 shell.
4533 This routine is called by the SIGIO handler.
4534 We return as soon as there are no more events to be read.
4536 For an overview of how Emacs input works on MS-Windows, see the
4537 commentary before w32_msg_pump in w32fns.c.
4539 We return the number of characters stored into the buffer,
4540 thus pretending to be `read'.
4542 Some of these messages are reposted back to the message queue since the
4543 system calls the windows proc directly in a context where we cannot return
4544 the data nor can we guarantee the state we are in. So if we dispatch them
4545 we will get into an infinite loop. To prevent this from ever happening we
4546 will set a variable to indicate we are in the read_socket call and indicate
4547 which message we are processing since the windows proc gets called
4548 recursively with different messages by the system.
4551 static int
4552 w32_read_socket (struct terminal *terminal,
4553 struct input_event *hold_quit)
4555 int count = 0;
4556 int check_visibility = 0;
4557 W32Msg msg;
4558 struct frame *f;
4559 struct w32_display_info *dpyinfo = &one_w32_display_info;
4560 Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
4562 block_input ();
4564 /* So people can tell when we have read the available input. */
4565 input_signal_count++;
4567 /* Process any incoming thread messages. */
4568 drain_message_queue ();
4570 /* TODO: ghostscript integration. */
4571 while (get_next_msg (&msg, FALSE))
4573 struct input_event inev;
4574 int do_help = 0;
4576 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4577 /* w32_name_of_message (msg.msg.message), */
4578 /* msg.msg.time)); */
4580 EVENT_INIT (inev);
4581 inev.kind = NO_EVENT;
4582 inev.arg = Qnil;
4584 switch (msg.msg.message)
4586 case WM_EMACS_PAINT:
4587 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4589 if (f)
4591 if (msg.rect.right == msg.rect.left ||
4592 msg.rect.bottom == msg.rect.top)
4594 /* We may get paint messages even though the client
4595 area is clipped - these are not expose events. */
4596 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f,
4597 SDATA (f->name)));
4599 else if (FRAME_VISIBLE_P (f) != 1)
4601 bool iconified = FRAME_ICONIFIED_P (f);
4603 /* Definitely not obscured, so mark as visible. */
4604 SET_FRAME_VISIBLE (f, 1);
4605 SET_FRAME_ICONIFIED (f, false);
4606 SET_FRAME_GARBAGED (f);
4607 if (!f->output_data.w32->asked_for_visible)
4608 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f,
4609 SDATA (f->name)));
4611 /* WM_PAINT serves as MapNotify as well, so report
4612 visibility changes properly. */
4613 if (iconified)
4615 inev.kind = DEICONIFY_EVENT;
4616 XSETFRAME (inev.frame_or_window, f);
4618 else if (!NILP (Vframe_list) && !NILP (XCDR (Vframe_list)))
4619 /* Force a redisplay sooner or later to update the
4620 frame titles in case this is the second frame. */
4621 record_asynch_buffer_change ();
4623 else
4625 HDC hdc = get_frame_dc (f);
4627 /* Erase background again for safety. */
4628 w32_clear_rect (f, hdc, &msg.rect);
4629 release_frame_dc (f, hdc);
4630 expose_frame (f,
4631 msg.rect.left,
4632 msg.rect.top,
4633 msg.rect.right - msg.rect.left,
4634 msg.rect.bottom - msg.rect.top);
4637 break;
4639 case WM_INPUTLANGCHANGE:
4640 /* Generate a language change event. */
4641 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4643 /* lParam contains the input language ID in its low 16 bits.
4644 Use it to update our record of the keyboard codepage. */
4645 w32_keyboard_codepage = codepage_for_locale ((LCID)(msg.msg.lParam
4646 & 0xffff));
4648 if (f)
4650 inev.kind = LANGUAGE_CHANGE_EVENT;
4651 XSETFRAME (inev.frame_or_window, f);
4652 inev.code = w32_keyboard_codepage;
4653 inev.modifiers = msg.msg.lParam & 0xffff;
4655 break;
4657 case WM_KEYDOWN:
4658 case WM_SYSKEYDOWN:
4659 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4661 if (f && !FRAME_ICONIFIED_P (f))
4663 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4664 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4666 clear_mouse_face (hlinfo);
4667 hlinfo->mouse_face_hidden = true;
4670 if (temp_index == sizeof temp_buffer / sizeof (short))
4671 temp_index = 0;
4672 temp_buffer[temp_index++] = msg.msg.wParam;
4673 inev.kind = NON_ASCII_KEYSTROKE_EVENT;
4674 inev.code = msg.msg.wParam;
4675 inev.modifiers = msg.dwModifiers;
4676 XSETFRAME (inev.frame_or_window, f);
4677 inev.timestamp = msg.msg.time;
4679 break;
4681 case WM_UNICHAR:
4682 case WM_SYSCHAR:
4683 case WM_CHAR:
4684 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4686 if (f && !FRAME_ICONIFIED_P (f))
4688 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4689 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4691 clear_mouse_face (hlinfo);
4692 hlinfo->mouse_face_hidden = true;
4695 if (temp_index == sizeof temp_buffer / sizeof (short))
4696 temp_index = 0;
4697 temp_buffer[temp_index++] = msg.msg.wParam;
4699 inev.modifiers = msg.dwModifiers;
4700 XSETFRAME (inev.frame_or_window, f);
4701 inev.timestamp = msg.msg.time;
4703 if (msg.msg.message == WM_UNICHAR)
4705 inev.code = msg.msg.wParam;
4707 else if (msg.msg.wParam < 256)
4709 wchar_t code;
4710 char dbcs[2];
4711 dbcs[0] = 0;
4712 dbcs[1] = (char) msg.msg.wParam;
4714 if (dbcs_lead)
4716 dbcs[0] = dbcs_lead;
4717 dbcs_lead = 0;
4718 if (!MultiByteToWideChar (w32_keyboard_codepage, 0,
4719 dbcs, 2, &code, 1))
4721 /* Garbage */
4722 DebPrint (("Invalid DBCS sequence: %d %d\n",
4723 dbcs[0], dbcs[1]));
4724 inev.kind = NO_EVENT;
4725 break;
4728 else if (IsDBCSLeadByteEx (w32_keyboard_codepage,
4729 (BYTE) msg.msg.wParam))
4731 dbcs_lead = (char) msg.msg.wParam;
4732 inev.kind = NO_EVENT;
4733 break;
4735 else
4737 if (!MultiByteToWideChar (w32_keyboard_codepage, 0,
4738 &dbcs[1], 1, &code, 1))
4740 /* What to do with garbage? */
4741 DebPrint (("Invalid character: %d\n", dbcs[1]));
4742 inev.kind = NO_EVENT;
4743 break;
4746 inev.code = code;
4748 else
4750 /* Windows shouldn't generate WM_CHAR events above 0xFF
4751 in non-Unicode message handlers. */
4752 DebPrint (("Non-byte WM_CHAR: %d\n", msg.msg.wParam));
4753 inev.kind = NO_EVENT;
4754 break;
4756 inev.kind = inev.code < 128 ? ASCII_KEYSTROKE_EVENT
4757 : MULTIBYTE_CHAR_KEYSTROKE_EVENT;
4759 break;
4761 case WM_APPCOMMAND:
4762 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4764 if (f && !FRAME_ICONIFIED_P (f))
4766 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4767 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4769 clear_mouse_face (hlinfo);
4770 hlinfo->mouse_face_hidden = true;
4773 if (temp_index == sizeof temp_buffer / sizeof (short))
4774 temp_index = 0;
4775 temp_buffer[temp_index++] = msg.msg.wParam;
4776 inev.kind = MULTIMEDIA_KEY_EVENT;
4777 inev.code = GET_APPCOMMAND_LPARAM (msg.msg.lParam);
4778 inev.modifiers = msg.dwModifiers;
4779 XSETFRAME (inev.frame_or_window, f);
4780 inev.timestamp = msg.msg.time;
4782 break;
4784 case WM_MOUSEMOVE:
4785 /* Ignore non-movement. */
4787 int x = LOWORD (msg.msg.lParam);
4788 int y = HIWORD (msg.msg.lParam);
4789 if (x == last_mousemove_x && y == last_mousemove_y)
4790 break;
4791 last_mousemove_x = x;
4792 last_mousemove_y = y;
4795 previous_help_echo_string = help_echo_string;
4796 help_echo_string = Qnil;
4798 f = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
4799 : x_window_to_frame (dpyinfo, msg.msg.hwnd));
4801 if (hlinfo->mouse_face_hidden)
4803 hlinfo->mouse_face_hidden = false;
4804 clear_mouse_face (hlinfo);
4807 if (f)
4809 /* Generate SELECT_WINDOW_EVENTs when needed. */
4810 if (!NILP (Vmouse_autoselect_window))
4812 static Lisp_Object last_mouse_window;
4813 Lisp_Object window = window_from_coordinates
4814 (f, LOWORD (msg.msg.lParam), HIWORD (msg.msg.lParam), 0, 0);
4816 /* Window will be selected only when it is not
4817 selected now and last mouse movement event was
4818 not in it. Minibuffer window will be selected
4819 only when it is active. */
4820 if (WINDOWP (window)
4821 && !EQ (window, last_mouse_window)
4822 && !EQ (window, selected_window)
4823 /* For click-to-focus window managers
4824 create event iff we don't leave the
4825 selected frame. */
4826 && (focus_follows_mouse
4827 || (EQ (XWINDOW (window)->frame,
4828 XWINDOW (selected_window)->frame))))
4830 inev.kind = SELECT_WINDOW_EVENT;
4831 inev.frame_or_window = window;
4833 /* Remember the last window where we saw the mouse. */
4834 last_mouse_window = window;
4836 if (!note_mouse_movement (f, &msg.msg))
4837 help_echo_string = previous_help_echo_string;
4839 else
4841 /* If we move outside the frame, then we're
4842 certainly no longer on any text in the frame. */
4843 clear_mouse_face (hlinfo);
4846 /* If the contents of the global variable help_echo_string
4847 has changed, generate a HELP_EVENT. */
4848 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4849 But it was originally changed to this to fix a bug, so I have
4850 not removed it completely in case the bug is still there. */
4851 if (help_echo_string != previous_help_echo_string ||
4852 (!NILP (help_echo_string) && !STRINGP (help_echo_string) && f->mouse_moved))
4853 #else /* This is what xterm.c does. */
4854 if (!NILP (help_echo_string)
4855 || !NILP (previous_help_echo_string))
4856 do_help = 1;
4857 #endif
4858 break;
4860 case WM_LBUTTONDOWN:
4861 case WM_LBUTTONUP:
4862 case WM_MBUTTONDOWN:
4863 case WM_MBUTTONUP:
4864 case WM_RBUTTONDOWN:
4865 case WM_RBUTTONUP:
4866 case WM_XBUTTONDOWN:
4867 case WM_XBUTTONUP:
4869 /* If we decide we want to generate an event to be seen
4870 by the rest of Emacs, we put it here. */
4871 bool tool_bar_p = 0;
4872 int button;
4873 int up;
4875 f = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
4876 : x_window_to_frame (dpyinfo, msg.msg.hwnd));
4878 if (f)
4880 construct_mouse_click (&inev, &msg, f);
4882 /* Is this in the tool-bar? */
4883 if (WINDOWP (f->tool_bar_window)
4884 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)))
4886 Lisp_Object window;
4887 int x = XFASTINT (inev.x);
4888 int y = XFASTINT (inev.y);
4890 window = window_from_coordinates (f, x, y, 0, 1);
4892 if (EQ (window, f->tool_bar_window))
4894 w32_handle_tool_bar_click (f, &inev);
4895 tool_bar_p = 1;
4899 if (tool_bar_p
4900 || (dpyinfo->w32_focus_frame
4901 && f != dpyinfo->w32_focus_frame))
4902 inev.kind = NO_EVENT;
4905 parse_button (msg.msg.message, HIWORD (msg.msg.wParam),
4906 &button, &up);
4908 if (up)
4910 dpyinfo->grabbed &= ~ (1 << button);
4912 else
4914 dpyinfo->grabbed |= (1 << button);
4915 dpyinfo->last_mouse_frame = f;
4916 /* Ignore any mouse motion that happened
4917 before this event; any subsequent mouse-movement
4918 Emacs events should reflect only motion after
4919 the ButtonPress. */
4920 if (f != 0)
4922 f->mouse_moved = false;
4923 if (!tool_bar_p)
4924 f->last_tool_bar_item = -1;
4927 break;
4930 case WM_MOUSEWHEEL:
4931 case WM_MOUSEHWHEEL:
4933 f = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
4934 : x_window_to_frame (dpyinfo, msg.msg.hwnd));
4936 if (f)
4939 if (!dpyinfo->w32_focus_frame
4940 || f == dpyinfo->w32_focus_frame)
4942 /* Emit an Emacs wheel-up/down event. */
4943 construct_mouse_wheel (&inev, &msg, f);
4945 /* Ignore any mouse motion that happened before this
4946 event; any subsequent mouse-movement Emacs events
4947 should reflect only motion after the
4948 ButtonPress. */
4949 f->mouse_moved = false;
4950 f->last_tool_bar_item = -1;
4952 dpyinfo->last_mouse_frame = f;
4954 break;
4956 case WM_DROPFILES:
4957 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4959 if (f)
4960 construct_drag_n_drop (&inev, &msg, f);
4961 break;
4963 case WM_HSCROLL:
4965 struct scroll_bar *bar =
4966 x_window_to_scroll_bar ((HWND)msg.msg.lParam, 1);
4968 if (bar)
4969 w32_horizontal_scroll_bar_handle_click (bar, &msg, &inev);
4970 break;
4973 case WM_VSCROLL:
4975 struct scroll_bar *bar =
4976 x_window_to_scroll_bar ((HWND)msg.msg.lParam, 0);
4978 if (bar)
4979 w32_scroll_bar_handle_click (bar, &msg, &inev);
4980 break;
4983 case WM_WINDOWPOSCHANGED:
4984 case WM_ACTIVATE:
4985 case WM_ACTIVATEAPP:
4986 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4987 if (f)
4989 /* Run the full-screen hook function also when we are
4990 being activated, to actually install the required
4991 size in effect, if the WAIT flag is set. This is
4992 because when the hook is run from x_set_fullscreen,
4993 the frame might not yet be visible, if that call is a
4994 result of make-frame, and in that case the hook just
4995 sets the WAIT flag. */
4996 if ((msg.msg.message == WM_WINDOWPOSCHANGED || msg.msg.wParam)
4997 && (f->want_fullscreen & FULLSCREEN_WAIT))
4999 /* Must set visibility right here since otherwise
5000 w32fullscreen_hook returns immediately. */
5001 SET_FRAME_VISIBLE (f, 1);
5002 w32fullscreen_hook (f);
5005 check_visibility = 1;
5006 break;
5008 case WM_MOVE:
5009 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
5011 if (f && !FRAME_ICONIFIED_P (f))
5012 x_real_positions (f, &f->left_pos, &f->top_pos);
5014 check_visibility = 1;
5015 break;
5017 case WM_SHOWWINDOW:
5018 /* wParam non-zero means Window is about to be shown, 0 means
5019 about to be hidden. */
5020 /* Redo the mouse-highlight after the tooltip has gone. */
5021 if (!msg.msg.wParam && msg.msg.hwnd == tip_window)
5023 tip_window = NULL;
5024 x_redo_mouse_highlight (dpyinfo);
5027 /* If window has been obscured or exposed by another window
5028 being maximized or minimized/restored, then recheck
5029 visibility of all frames. Direct changes to our own
5030 windows get handled by WM_SIZE. */
5031 #if 0
5032 if (msg.msg.lParam != 0)
5033 check_visibility = 1;
5034 else
5036 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
5037 f->async_visible = msg.msg.wParam;
5039 #endif
5041 check_visibility = 1;
5042 break;
5044 case WM_SIZE:
5045 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
5047 /* Inform lisp of whether frame has been iconified etc. */
5048 if (f)
5050 switch (msg.msg.wParam)
5052 case SIZE_MINIMIZED:
5053 SET_FRAME_VISIBLE (f, 0);
5054 SET_FRAME_ICONIFIED (f, true);
5056 inev.kind = ICONIFY_EVENT;
5057 XSETFRAME (inev.frame_or_window, f);
5058 break;
5060 case SIZE_MAXIMIZED:
5062 bool iconified = FRAME_ICONIFIED_P (f);
5063 Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
5065 SET_FRAME_VISIBLE (f, 1);
5066 SET_FRAME_ICONIFIED (f, false);
5068 /* wait_reading_process_output will notice this
5069 and update the frame's display structures. */
5070 SET_FRAME_GARBAGED (f);
5072 if (iconified)
5074 int x, y;
5076 /* Reset top and left positions of the Window
5077 here since Windows sends a WM_MOVE message
5078 BEFORE telling us the Window is minimized
5079 when the Window is iconified, with 3000,3000
5080 as the co-ords. */
5081 x_real_positions (f, &x, &y);
5082 f->left_pos = x;
5083 f->top_pos = y;
5085 inev.kind = DEICONIFY_EVENT;
5086 XSETFRAME (inev.frame_or_window, f);
5088 else if (! NILP (Vframe_list)
5089 && ! NILP (XCDR (Vframe_list)))
5090 /* Force a redisplay sooner or later
5091 to update the frame titles
5092 in case this is the second frame. */
5093 record_asynch_buffer_change ();
5095 /* Windows can send us a SIZE_MAXIMIZED message even
5096 when fullscreen is fullboth. The following is a
5097 simple hack to check that based on the fact that
5098 only a maximized fullscreen frame should have both
5099 top/left outside the screen. */
5100 if (EQ (fullscreen, Qfullwidth) || EQ (fullscreen, Qfullheight)
5101 || NILP (fullscreen))
5103 int x, y;
5105 x_real_positions (f, &x, &y);
5106 if (x < 0 && y < 0)
5107 store_frame_param (f, Qfullscreen, Qmaximized);
5111 break;
5113 case SIZE_RESTORED:
5115 bool iconified = FRAME_ICONIFIED_P (f);
5117 /* The following was made unconditional in a
5118 pathetic attempt to fix bug#16967 in revision
5119 116716 but, considered counterproductive was made
5120 conditional again in revision 116727. martin */
5121 if (iconified)
5122 SET_FRAME_VISIBLE (f, 1);
5123 SET_FRAME_ICONIFIED (f, false);
5125 /* wait_reading_process_output will notice this
5126 and update the frame's display structures. */
5127 SET_FRAME_GARBAGED (f);
5129 if (iconified)
5131 /* Reset top and left positions of the Window
5132 here since Windows sends a WM_MOVE message
5133 BEFORE telling us the Window is minimized
5134 when the Window is iconified, with 3000,3000
5135 as the co-ords. */
5136 x_real_positions (f, &f->left_pos, &f->top_pos);
5138 inev.kind = DEICONIFY_EVENT;
5139 XSETFRAME (inev.frame_or_window, f);
5141 else if (! NILP (Vframe_list)
5142 && ! NILP (XCDR (Vframe_list)))
5143 /* Force a redisplay sooner or later
5144 to update the frame titles
5145 in case this is the second frame. */
5146 record_asynch_buffer_change ();
5149 if (EQ (get_frame_param (f, Qfullscreen), Qmaximized))
5150 store_frame_param (f, Qfullscreen, Qnil);
5152 break;
5156 if (f && !FRAME_ICONIFIED_P (f) && msg.msg.wParam != SIZE_MINIMIZED)
5158 RECT rect;
5159 int /* rows, columns, */ width, height, text_width, text_height;
5161 if (GetClientRect (msg.msg.hwnd, &rect)
5162 /* GetClientRect evidently returns (0, 0, 0, 0) if
5163 called on a minimized frame. Such "dimensions"
5164 aren't useful anyway. */
5165 && !(rect.bottom == 0
5166 && rect.top == 0
5167 && rect.left == 0
5168 && rect.right == 0))
5170 height = rect.bottom - rect.top;
5171 width = rect.right - rect.left;
5172 text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, width);
5173 text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, height);
5174 /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
5175 /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
5177 /* TODO: Clip size to the screen dimensions. */
5179 /* Even if the number of character rows and columns
5180 has not changed, the font size may have changed,
5181 so we need to check the pixel dimensions as well. */
5183 if (width != FRAME_PIXEL_WIDTH (f)
5184 || height != FRAME_PIXEL_HEIGHT (f)
5185 || text_width != FRAME_TEXT_WIDTH (f)
5186 || text_height != FRAME_TEXT_HEIGHT (f))
5188 change_frame_size (f, text_width, text_height, 0, 1, 0, 1);
5189 SET_FRAME_GARBAGED (f);
5190 cancel_mouse_face (f);
5191 f->win_gravity = NorthWestGravity;
5196 check_visibility = 1;
5197 break;
5199 case WM_MOUSELEAVE:
5200 f = x_any_window_to_frame (dpyinfo, msg.msg.hwnd);
5201 if (f)
5203 if (f == hlinfo->mouse_face_mouse_frame)
5205 /* If we move outside the frame, then we're
5206 certainly no longer on any text in the frame. */
5207 clear_mouse_face (hlinfo);
5208 hlinfo->mouse_face_mouse_frame = 0;
5211 /* Generate a nil HELP_EVENT to cancel a help-echo.
5212 Do it only if there's something to cancel.
5213 Otherwise, the startup message is cleared when
5214 the mouse leaves the frame. */
5215 if (any_help_event_p)
5216 do_help = -1;
5218 break;
5220 case WM_SETFOCUS:
5221 w32_detect_focus_change (dpyinfo, &msg, &inev);
5223 dpyinfo->grabbed = 0;
5224 check_visibility = 1;
5225 break;
5227 case WM_KILLFOCUS:
5228 w32_detect_focus_change (dpyinfo, &msg, &inev);
5229 f = x_top_window_to_frame (dpyinfo, msg.msg.hwnd);
5231 if (f)
5233 if (f == hlinfo->mouse_face_mouse_frame)
5235 /* If we move outside the frame, then we're
5236 certainly no longer on any text in the frame. */
5237 clear_mouse_face (hlinfo);
5238 hlinfo->mouse_face_mouse_frame = 0;
5241 /* Generate a nil HELP_EVENT to cancel a help-echo.
5242 Do it only if there's something to cancel.
5243 Otherwise, the startup message is cleared when
5244 the mouse leaves the frame. */
5245 if (any_help_event_p)
5246 do_help = -1;
5249 dpyinfo->grabbed = 0;
5250 check_visibility = 1;
5251 break;
5253 case WM_CLOSE:
5254 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
5256 if (f)
5258 inev.kind = DELETE_WINDOW_EVENT;
5259 XSETFRAME (inev.frame_or_window, f);
5261 break;
5263 case WM_INITMENU:
5264 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
5266 if (f)
5268 inev.kind = MENU_BAR_ACTIVATE_EVENT;
5269 XSETFRAME (inev.frame_or_window, f);
5271 break;
5273 case WM_COMMAND:
5274 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
5276 if (f)
5278 extern void menubar_selection_callback
5279 (struct frame *f, void * client_data);
5280 menubar_selection_callback (f, (void *)msg.msg.wParam);
5283 check_visibility = 1;
5284 break;
5286 case WM_DISPLAYCHANGE:
5287 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
5289 if (f)
5291 Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
5293 dpyinfo->n_cbits = msg.msg.wParam;
5294 /* The new display could have a different resolution, in
5295 which case we must reconsider what fullscreen means.
5296 The following code is untested yet. */
5297 if (!NILP (fullscreen))
5299 x_set_fullscreen (f, fullscreen, fullscreen);
5300 w32fullscreen_hook (f);
5303 DebPrint (("display change: %d %d\n",
5304 (short) LOWORD (msg.msg.lParam),
5305 (short) HIWORD (msg.msg.lParam)));
5308 check_visibility = 1;
5309 break;
5311 #if HAVE_W32NOTIFY
5312 case WM_EMACS_FILENOTIFY:
5313 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
5314 if (f)
5315 queue_notifications (&inev, &msg, f, &count);
5316 break;
5317 #endif
5319 default:
5320 /* Check for messages registered at runtime. */
5321 if (msg.msg.message == msh_mousewheel)
5323 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5324 msg.msg.message = WM_MOUSEWHEEL;
5325 prepend_msg (&msg);
5327 break;
5330 if (inev.kind != NO_EVENT)
5332 kbd_buffer_store_event_hold (&inev, hold_quit);
5333 count++;
5336 if (do_help
5337 && !(hold_quit && hold_quit->kind != NO_EVENT))
5339 Lisp_Object frame;
5341 if (f)
5342 XSETFRAME (frame, f);
5343 else
5344 frame = Qnil;
5346 if (do_help > 0)
5348 if (NILP (help_echo_string))
5350 help_echo_object = help_echo_window = Qnil;
5351 help_echo_pos = -1;
5354 any_help_event_p = 1;
5355 gen_help_event (help_echo_string, frame, help_echo_window,
5356 help_echo_object, help_echo_pos);
5358 else
5360 help_echo_string = Qnil;
5361 gen_help_event (Qnil, frame, Qnil, Qnil, 0);
5363 count++;
5367 /* If the focus was just given to an autoraising frame,
5368 raise it now. FIXME: handle more than one such frame. */
5369 if (dpyinfo->w32_pending_autoraise_frame)
5371 x_raise_frame (dpyinfo->w32_pending_autoraise_frame);
5372 dpyinfo->w32_pending_autoraise_frame = NULL;
5375 /* Check which frames are still visible, if we have enqueued any user
5376 events or been notified of events that may affect visibility. We
5377 do this here because there doesn't seem to be any direct
5378 notification from Windows that the visibility of a window has
5379 changed (at least, not in all cases). */
5380 if (count > 0 || check_visibility)
5382 Lisp_Object tail, frame;
5384 FOR_EACH_FRAME (tail, frame)
5386 struct frame *f = XFRAME (frame);
5387 /* The tooltip has been drawn already. Avoid the
5388 SET_FRAME_GARBAGED below. */
5389 if (EQ (frame, tip_frame))
5390 continue;
5392 /* Check "visible" frames and mark each as obscured or not.
5393 Note that visible is nonzero for unobscured and obscured
5394 frames, but zero for hidden and iconified frames. */
5395 if (FRAME_W32_P (f) && FRAME_VISIBLE_P (f))
5397 RECT clipbox;
5398 HDC hdc;
5399 bool obscured;
5401 enter_crit ();
5402 /* Query clipping rectangle for the entire window area
5403 (GetWindowDC), not just the client portion (GetDC).
5404 Otherwise, the scrollbars and menubar aren't counted as
5405 part of the visible area of the frame, and we may think
5406 the frame is obscured when really a scrollbar is still
5407 visible and gets WM_PAINT messages above. */
5408 hdc = GetWindowDC (FRAME_W32_WINDOW (f));
5409 GetClipBox (hdc, &clipbox);
5410 ReleaseDC (FRAME_W32_WINDOW (f), hdc);
5411 leave_crit ();
5413 obscured = FRAME_OBSCURED_P (f);
5415 if (clipbox.right == clipbox.left || clipbox.bottom == clipbox.top)
5417 /* Frame has become completely obscured so mark as such (we
5418 do this by setting visible to 2 so that FRAME_VISIBLE_P
5419 is still true, but redisplay will skip it). */
5420 SET_FRAME_VISIBLE (f, 2);
5422 if (!obscured)
5423 DebPrint (("frame %p (%s) obscured\n", f, SDATA (f->name)));
5425 else
5427 /* Frame is not obscured, so mark it as such. */
5428 SET_FRAME_VISIBLE (f, 1);
5430 if (obscured)
5432 SET_FRAME_GARBAGED (f);
5433 DebPrint (("obscured frame %p (%s) found to be visible\n",
5434 f, SDATA (f->name)));
5436 /* Force a redisplay sooner or later. */
5437 record_asynch_buffer_change ();
5444 unblock_input ();
5445 return count;
5450 /***********************************************************************
5451 Text Cursor
5452 ***********************************************************************/
5454 /* Set clipping for output in glyph row ROW. W is the window in which
5455 we operate. GC is the graphics context to set clipping in.
5457 ROW may be a text row or, e.g., a mode line. Text rows must be
5458 clipped to the interior of the window dedicated to text display,
5459 mode lines must be clipped to the whole window. */
5461 static void
5462 w32_clip_to_row (struct window *w, struct glyph_row *row,
5463 enum glyph_row_area area, HDC hdc)
5465 RECT clip_rect;
5466 int window_x, window_y, window_width;
5468 window_box (w, area, &window_x, &window_y, &window_width, 0);
5470 clip_rect.left = window_x;
5471 clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
5472 clip_rect.top = max (clip_rect.top, window_y);
5473 clip_rect.right = clip_rect.left + window_width;
5474 clip_rect.bottom = clip_rect.top + row->visible_height;
5476 w32_set_clip_rectangle (hdc, &clip_rect);
5480 /* Draw a hollow box cursor on window W in glyph row ROW. */
5482 static void
5483 x_draw_hollow_cursor (struct window *w, struct glyph_row *row)
5485 struct frame *f = XFRAME (WINDOW_FRAME (w));
5486 HDC hdc;
5487 RECT rect;
5488 int left, top, h;
5489 struct glyph *cursor_glyph;
5490 HBRUSH hb = CreateSolidBrush (f->output_data.w32->cursor_pixel);
5492 /* Get the glyph the cursor is on. If we can't tell because
5493 the current matrix is invalid or such, give up. */
5494 cursor_glyph = get_phys_cursor_glyph (w);
5495 if (cursor_glyph == NULL)
5497 DeleteObject (hb);
5498 return;
5501 /* Compute frame-relative coordinates for phys cursor. */
5502 get_phys_cursor_geometry (w, row, cursor_glyph, &left, &top, &h);
5503 rect.left = left;
5504 /* When on R2L character, show cursor at the right edge of the
5505 glyph, unless the cursor box is as wide as the glyph or wider
5506 (the latter happens when x-stretch-cursor is non-nil). */
5507 if ((cursor_glyph->resolved_level & 1) != 0
5508 && cursor_glyph->pixel_width > w->phys_cursor_width)
5509 rect.left += cursor_glyph->pixel_width - w->phys_cursor_width;
5510 rect.top = top;
5511 rect.bottom = rect.top + h;
5512 rect.right = rect.left + w->phys_cursor_width;
5514 hdc = get_frame_dc (f);
5515 /* Set clipping, draw the rectangle, and reset clipping again. */
5516 w32_clip_to_row (w, row, TEXT_AREA, hdc);
5517 FrameRect (hdc, &rect, hb);
5518 DeleteObject (hb);
5519 w32_set_clip_rectangle (hdc, NULL);
5520 release_frame_dc (f, hdc);
5524 /* Draw a bar cursor on window W in glyph row ROW.
5526 Implementation note: One would like to draw a bar cursor with an
5527 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5528 Unfortunately, I didn't find a font yet that has this property set.
5529 --gerd. */
5531 static void
5532 x_draw_bar_cursor (struct window *w, struct glyph_row *row,
5533 int width, enum text_cursor_kinds kind)
5535 struct frame *f = XFRAME (w->frame);
5536 struct glyph *cursor_glyph;
5538 /* If cursor is out of bounds, don't draw garbage. This can happen
5539 in mini-buffer windows when switching between echo area glyphs
5540 and mini-buffer. */
5541 cursor_glyph = get_phys_cursor_glyph (w);
5542 if (cursor_glyph == NULL)
5543 return;
5545 /* If on an image, draw like a normal cursor. That's usually better
5546 visible than drawing a bar, esp. if the image is large so that
5547 the bar might not be in the window. */
5548 if (cursor_glyph->type == IMAGE_GLYPH)
5550 struct glyph_row *row;
5551 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
5552 draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
5554 else
5556 COLORREF cursor_color = f->output_data.w32->cursor_pixel;
5557 struct face *face = FACE_FROM_ID (f, cursor_glyph->face_id);
5558 int x;
5559 HDC hdc;
5561 /* If the glyph's background equals the color we normally draw
5562 the bar cursor in, the bar cursor in its normal color is
5563 invisible. Use the glyph's foreground color instead in this
5564 case, on the assumption that the glyph's colors are chosen so
5565 that the glyph is legible. */
5566 if (face->background == cursor_color)
5567 cursor_color = face->foreground;
5569 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
5571 hdc = get_frame_dc (f);
5572 w32_clip_to_row (w, row, TEXT_AREA, hdc);
5574 if (kind == BAR_CURSOR)
5576 if (width < 0)
5577 width = FRAME_CURSOR_WIDTH (f);
5578 width = min (cursor_glyph->pixel_width, width);
5580 w->phys_cursor_width = width;
5582 /* If the character under cursor is R2L, draw the bar cursor
5583 on the right of its glyph, rather than on the left. */
5584 if ((cursor_glyph->resolved_level & 1) != 0)
5585 x += cursor_glyph->pixel_width - width;
5587 w32_fill_area (f, hdc, cursor_color, x,
5588 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
5589 width, row->height);
5591 else /* HBAR_CURSOR */
5593 int dummy_x, dummy_y, dummy_h;
5595 if (width < 0)
5596 width = row->height;
5598 width = min (row->height, width);
5600 get_phys_cursor_geometry (w, row, cursor_glyph, &dummy_x,
5601 &dummy_y, &dummy_h);
5602 if ((cursor_glyph->resolved_level & 1) != 0
5603 && cursor_glyph->pixel_width > w->phys_cursor_width)
5604 x += cursor_glyph->pixel_width - w->phys_cursor_width;
5605 w32_fill_area (f, hdc, cursor_color, x,
5606 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
5607 row->height - width),
5608 w->phys_cursor_width, width);
5611 w32_set_clip_rectangle (hdc, NULL);
5612 release_frame_dc (f, hdc);
5617 /* RIF: Define cursor CURSOR on frame F. */
5619 static void
5620 w32_define_frame_cursor (struct frame *f, Cursor cursor)
5622 w32_define_cursor (FRAME_W32_WINDOW (f), cursor);
5626 /* RIF: Clear area on frame F. */
5628 static void
5629 w32_clear_frame_area (struct frame *f, int x, int y, int width, int height)
5631 HDC hdc;
5633 hdc = get_frame_dc (f);
5634 w32_clear_area (f, hdc, x, y, width, height);
5635 release_frame_dc (f, hdc);
5638 /* RIF: Draw or clear cursor on window W. */
5640 static void
5641 w32_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
5642 int x, int y, enum text_cursor_kinds cursor_type,
5643 int cursor_width, bool on_p, bool active_p)
5645 if (on_p)
5647 /* If the user wants to use the system caret, make sure our own
5648 cursor remains invisible. */
5649 if (w32_use_visible_system_caret)
5651 /* Call to erase_phys_cursor here seems to use the
5652 wrong values of w->phys_cursor, as they have been
5653 overwritten before this function was called. */
5654 if (w->phys_cursor_type != NO_CURSOR)
5655 erase_phys_cursor (w);
5657 cursor_type = w->phys_cursor_type = NO_CURSOR;
5658 w->phys_cursor_width = -1;
5660 else
5662 w->phys_cursor_type = cursor_type;
5665 w->phys_cursor_on_p = true;
5667 /* If this is the active cursor, we need to track it with the
5668 system caret, so third party software like screen magnifiers
5669 and speech synthesizers can follow the cursor. */
5670 if (active_p)
5672 struct frame *f = XFRAME (WINDOW_FRAME (w));
5673 HWND hwnd = FRAME_W32_WINDOW (f);
5675 w32_system_caret_x
5676 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
5677 w32_system_caret_y
5678 = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y)
5679 + glyph_row->ascent - w->phys_cursor_ascent);
5680 w32_system_caret_window = w;
5681 w32_system_caret_hdr_height = WINDOW_HEADER_LINE_HEIGHT (w);
5682 w32_system_caret_mode_height = WINDOW_MODE_LINE_HEIGHT (w);
5684 PostMessage (hwnd, WM_IME_STARTCOMPOSITION, 0, 0);
5686 /* If the size of the active cursor changed, destroy the old
5687 system caret. */
5688 if (w32_system_caret_hwnd
5689 && (w32_system_caret_height != w->phys_cursor_height))
5690 PostMessage (hwnd, WM_EMACS_DESTROY_CARET, 0, 0);
5692 w32_system_caret_height = w->phys_cursor_height;
5694 /* Move the system caret. */
5695 PostMessage (hwnd, WM_EMACS_TRACK_CARET, 0, 0);
5698 if (glyph_row->exact_window_width_line_p
5699 && (glyph_row->reversed_p
5700 ? (w->phys_cursor.hpos < 0)
5701 : (w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])))
5703 glyph_row->cursor_in_fringe_p = true;
5704 draw_fringe_bitmap (w, glyph_row, glyph_row->reversed_p);
5705 return;
5708 switch (cursor_type)
5710 case HOLLOW_BOX_CURSOR:
5711 x_draw_hollow_cursor (w, glyph_row);
5712 break;
5714 case FILLED_BOX_CURSOR:
5715 draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
5716 break;
5718 case BAR_CURSOR:
5719 x_draw_bar_cursor (w, glyph_row, cursor_width, BAR_CURSOR);
5720 break;
5722 case HBAR_CURSOR:
5723 x_draw_bar_cursor (w, glyph_row, cursor_width, HBAR_CURSOR);
5724 break;
5726 case NO_CURSOR:
5727 w->phys_cursor_width = 0;
5728 break;
5730 default:
5731 emacs_abort ();
5738 /* Icons. */
5740 bool
5741 x_bitmap_icon (struct frame *f, Lisp_Object icon)
5743 HANDLE main_icon;
5744 HANDLE small_icon = NULL;
5746 if (FRAME_W32_WINDOW (f) == 0)
5747 return 1;
5749 if (NILP (icon))
5750 main_icon = LoadIcon (hinst, EMACS_CLASS);
5751 else if (STRINGP (icon))
5753 /* Load the main icon from the named file. */
5754 main_icon = LoadImage (NULL, (LPCTSTR) SDATA (icon), IMAGE_ICON, 0, 0,
5755 LR_DEFAULTSIZE | LR_LOADFROMFILE);
5756 /* Try to load a small icon to go with it. */
5757 small_icon = LoadImage (NULL, (LPCSTR) SDATA (icon), IMAGE_ICON,
5758 GetSystemMetrics (SM_CXSMICON),
5759 GetSystemMetrics (SM_CYSMICON),
5760 LR_LOADFROMFILE);
5762 else if (SYMBOLP (icon))
5764 LPCTSTR name;
5766 if (EQ (icon, intern ("application")))
5767 name = (LPCTSTR) IDI_APPLICATION;
5768 else if (EQ (icon, intern ("hand")))
5769 name = (LPCTSTR) IDI_HAND;
5770 else if (EQ (icon, intern ("question")))
5771 name = (LPCTSTR) IDI_QUESTION;
5772 else if (EQ (icon, intern ("exclamation")))
5773 name = (LPCTSTR) IDI_EXCLAMATION;
5774 else if (EQ (icon, intern ("asterisk")))
5775 name = (LPCTSTR) IDI_ASTERISK;
5776 else if (EQ (icon, intern ("winlogo")))
5777 name = (LPCTSTR) IDI_WINLOGO;
5778 else
5779 return 1;
5781 main_icon = LoadIcon (NULL, name);
5783 else
5784 return 1;
5786 if (main_icon == NULL)
5787 return 1;
5789 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_BIG,
5790 (LPARAM) main_icon);
5792 /* If there is a small icon that goes with it, set that too. */
5793 if (small_icon)
5794 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_SMALL,
5795 (LPARAM) small_icon);
5797 return 0;
5801 /************************************************************************
5802 Handling X errors
5803 ************************************************************************/
5805 /* Display Error Handling functions not used on W32. Listing them here
5806 helps diff stay in step when comparing w32term.c with xterm.c.
5808 x_error_catcher (display, error)
5809 x_catch_errors (dpy)
5810 x_catch_errors_unwind (old_val)
5811 x_check_errors (dpy, format)
5812 x_fully_uncatch_errors ()
5813 x_had_errors_p (dpy)
5814 x_clear_errors (dpy)
5815 x_uncatch_errors (dpy, count)
5816 x_trace_wire ()
5817 x_connection_signal (signalnum)
5818 x_connection_closed (dpy, error_message)
5819 x_error_quitter (display, error)
5820 x_error_handler (display, error)
5821 x_io_error_quitter (display)
5826 /* Changing the font of the frame. */
5828 Lisp_Object
5829 x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
5831 struct font *font = XFONT_OBJECT (font_object);
5832 int unit, font_ascent, font_descent;
5834 if (fontset < 0)
5835 fontset = fontset_from_font (font_object);
5836 FRAME_FONTSET (f) = fontset;
5837 if (FRAME_FONT (f) == font)
5838 /* This font is already set in frame F. There's nothing more to
5839 do. */
5840 return font_object;
5842 FRAME_FONT (f) = font;
5843 FRAME_BASELINE_OFFSET (f) = font->baseline_offset;
5844 FRAME_COLUMN_WIDTH (f) = unit = font->average_width;
5845 get_font_ascent_descent (font, &font_ascent, &font_descent);
5846 FRAME_LINE_HEIGHT (f) = font_ascent + font_descent;
5848 /* Compute number of scrollbar columns. */
5849 unit = FRAME_COLUMN_WIDTH (f);
5850 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
5851 FRAME_CONFIG_SCROLL_BAR_COLS (f)
5852 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + unit - 1) / unit;
5853 else
5855 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + unit - 1) / unit;
5856 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) =
5857 FRAME_CONFIG_SCROLL_BAR_COLS (f) * unit;
5860 /* Now make the frame display the given font. */
5861 if (FRAME_X_WINDOW (f) != 0)
5863 /* Don't change the size of a tip frame; there's no point in
5864 doing it because it's done in Fx_show_tip, and it leads to
5865 problems because the tip frame has no widget. */
5866 if (NILP (tip_frame) || XFRAME (tip_frame) != f)
5867 adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
5868 FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 3,
5869 false, Qfont);
5872 /* X version sets font of input methods here also. */
5874 return font_object;
5878 /***********************************************************************
5879 TODO: W32 Input Methods
5880 ***********************************************************************/
5881 /* Listing missing functions from xterm.c helps diff stay in step.
5883 xim_destroy_callback (xim, client_data, call_data)
5884 xim_open_dpy (dpyinfo, resource_name)
5885 struct xim_inst_t
5886 xim_instantiate_callback (display, client_data, call_data)
5887 xim_initialize (dpyinfo, resource_name)
5888 xim_close_dpy (dpyinfo)
5893 /* Calculate the absolute position in frame F
5894 from its current recorded position values and gravity. */
5896 void
5897 x_calc_absolute_position (struct frame *f)
5899 int flags = f->size_hint_flags;
5901 /* The sum of the widths of the frame's left and right borders, and
5902 the sum of the heights of the frame's top and bottom borders (in
5903 pixels) drawn by Windows. */
5904 unsigned int left_right_borders_width, top_bottom_borders_height;
5906 /* Try to get the actual values of these two variables. We compute
5907 the border width (height) by subtracting the width (height) of
5908 the frame's client area from the width (height) of the frame's
5909 entire window. */
5910 WINDOWPLACEMENT wp = { 0 };
5911 RECT client_rect = { 0 };
5913 if (GetWindowPlacement (FRAME_W32_WINDOW (f), &wp)
5914 && GetClientRect (FRAME_W32_WINDOW (f), &client_rect))
5916 left_right_borders_width =
5917 (wp.rcNormalPosition.right - wp.rcNormalPosition.left) -
5918 (client_rect.right - client_rect.left);
5920 top_bottom_borders_height =
5921 (wp.rcNormalPosition.bottom - wp.rcNormalPosition.top) -
5922 (client_rect.bottom - client_rect.top);
5924 else
5926 /* Use sensible default values. */
5927 left_right_borders_width = 8;
5928 top_bottom_borders_height = 32;
5931 /* With multiple monitors, we can legitimately get negative
5932 coordinates (for monitors above or to the left of the primary
5933 monitor). Find the display origin to ensure negative positions
5934 are computed correctly (Bug#21173). */
5935 int display_left = 0;
5936 int display_top = 0;
5937 if (flags & (XNegative | YNegative))
5939 Lisp_Object list;
5941 list = Fw32_display_monitor_attributes_list (Qnil);
5942 while (CONSP (list))
5944 Lisp_Object attributes = CAR(list);
5945 Lisp_Object geometry;
5946 Lisp_Object monitor_left, monitor_top;
5948 list = CDR(list);
5950 geometry = Fassoc (Qgeometry, attributes);
5951 if (!NILP (geometry))
5953 monitor_left = Fnth (make_number (1), geometry);
5954 monitor_top = Fnth (make_number (2), geometry);
5956 display_left = min (display_left, XINT (monitor_left));
5957 display_top = min (display_top, XINT (monitor_top));
5962 /* Treat negative positions as relative to the rightmost bottommost
5963 position that fits on the screen. */
5964 if (flags & XNegative)
5965 f->left_pos = (x_display_pixel_width (FRAME_DISPLAY_INFO (f))
5966 + display_left
5967 - FRAME_PIXEL_WIDTH (f)
5968 + f->left_pos
5969 - (left_right_borders_width - 1));
5971 if (flags & YNegative)
5972 f->top_pos = (x_display_pixel_height (FRAME_DISPLAY_INFO (f))
5973 + display_top
5974 - FRAME_PIXEL_HEIGHT (f)
5975 + f->top_pos
5976 - (top_bottom_borders_height - 1));
5978 /* The left_pos and top_pos are now relative to the top and left
5979 screen edges, so the flags should correspond. */
5980 f->size_hint_flags &= ~ (XNegative | YNegative);
5983 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5984 to really change the position, and 0 when calling from
5985 x_make_frame_visible (in that case, XOFF and YOFF are the current
5986 position values). It is -1 when calling from x_set_frame_parameters,
5987 which means, do adjust for borders but don't change the gravity. */
5989 void
5990 x_set_offset (struct frame *f, register int xoff, register int yoff,
5991 int change_gravity)
5993 int modified_top, modified_left;
5995 if (change_gravity > 0)
5997 f->top_pos = yoff;
5998 f->left_pos = xoff;
5999 f->size_hint_flags &= ~ (XNegative | YNegative);
6000 if (xoff < 0)
6001 f->size_hint_flags |= XNegative;
6002 if (yoff < 0)
6003 f->size_hint_flags |= YNegative;
6004 f->win_gravity = NorthWestGravity;
6006 x_calc_absolute_position (f);
6008 block_input ();
6009 x_wm_set_size_hint (f, (long) 0, false);
6011 modified_left = f->left_pos;
6012 modified_top = f->top_pos;
6014 my_set_window_pos (FRAME_W32_WINDOW (f),
6015 NULL,
6016 modified_left, modified_top,
6017 0, 0,
6018 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
6019 unblock_input ();
6022 static void
6023 w32fullscreen_hook (struct frame *f)
6025 if (FRAME_VISIBLE_P (f))
6027 HWND hwnd = FRAME_W32_WINDOW(f);
6028 DWORD dwStyle = GetWindowLong (hwnd, GWL_STYLE);
6029 RECT rect;
6030 enum fullscreen_type prev_fsmode = FRAME_PREV_FSMODE (f);
6032 block_input();
6033 f->want_fullscreen &= ~FULLSCREEN_WAIT;
6035 if (FRAME_PREV_FSMODE (f) == FULLSCREEN_NONE)
6036 GetWindowPlacement (hwnd, &FRAME_NORMAL_PLACEMENT (f));
6038 if (FRAME_PREV_FSMODE (f) == FULLSCREEN_BOTH)
6040 SetWindowLong (hwnd, GWL_STYLE, dwStyle | WS_OVERLAPPEDWINDOW);
6041 SetWindowPlacement (hwnd, &FRAME_NORMAL_PLACEMENT (f));
6043 else if (FRAME_PREV_FSMODE (f) == FULLSCREEN_HEIGHT
6044 || FRAME_PREV_FSMODE (f) == FULLSCREEN_WIDTH)
6045 SetWindowPlacement (hwnd, &FRAME_NORMAL_PLACEMENT (f));
6047 FRAME_PREV_FSMODE (f) = f->want_fullscreen;
6049 if (f->want_fullscreen == FULLSCREEN_NONE)
6050 ShowWindow (hwnd, SW_SHOWNORMAL);
6051 else if (f->want_fullscreen == FULLSCREEN_MAXIMIZED)
6053 if (prev_fsmode == FULLSCREEN_BOTH || prev_fsmode == FULLSCREEN_WIDTH
6054 || prev_fsmode == FULLSCREEN_HEIGHT)
6055 /* Make window normal since otherwise the subsequent
6056 maximization might fail in some cases. */
6057 ShowWindow (hwnd, SW_SHOWNORMAL);
6058 ShowWindow (hwnd, SW_MAXIMIZE);
6060 else if (f->want_fullscreen == FULLSCREEN_BOTH)
6062 int menu_bar_height = GetSystemMetrics (SM_CYMENU);
6064 w32_fullscreen_rect (hwnd, f->want_fullscreen,
6065 FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
6066 SetWindowLong (hwnd, GWL_STYLE, dwStyle & ~WS_OVERLAPPEDWINDOW);
6067 SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
6068 rect.right - rect.left, rect.bottom - rect.top,
6069 SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
6070 change_frame_size
6071 (f, FRAME_PIXEL_TO_TEXT_WIDTH (f, rect.right - rect.left),
6072 FRAME_PIXEL_TO_TEXT_HEIGHT (f, (rect.bottom - rect.top
6073 - menu_bar_height)),
6074 0, 1, 0, 1);
6076 else
6078 ShowWindow (hwnd, SW_SHOWNORMAL);
6079 w32_fullscreen_rect (hwnd, f->want_fullscreen,
6080 FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
6081 SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
6082 rect.right - rect.left, rect.bottom - rect.top, 0);
6084 if (f->want_fullscreen == FULLSCREEN_WIDTH)
6086 int border_width = GetSystemMetrics (SM_CXFRAME);
6088 change_frame_size
6089 (f, (FRAME_PIXEL_TO_TEXT_WIDTH
6090 (f, rect.right - rect.left - 2 * border_width)),
6091 0, 0, 1, 0, 1);
6093 else
6095 int border_height = GetSystemMetrics (SM_CYFRAME);
6096 /* Won't work for wrapped menu bar. */
6097 int menu_bar_height = GetSystemMetrics (SM_CYMENU);
6098 int title_height = GetSystemMetrics (SM_CYCAPTION);
6100 change_frame_size
6101 (f, 0, (FRAME_PIXEL_TO_TEXT_HEIGHT
6102 (f, rect.bottom - rect.top - 2 * border_height
6103 - title_height - menu_bar_height)),
6104 0, 1, 0, 1);
6108 f->want_fullscreen = FULLSCREEN_NONE;
6109 unblock_input ();
6111 if (f->want_fullscreen == FULLSCREEN_BOTH
6112 || f->want_fullscreen == FULLSCREEN_WIDTH
6113 || f->want_fullscreen == FULLSCREEN_HEIGHT)
6114 do_pending_window_change (0);
6117 else
6118 f->want_fullscreen |= FULLSCREEN_WAIT;
6121 /* Call this to change the size of frame F's x-window.
6122 If CHANGE_GRAVITY, change to top-left-corner window gravity
6123 for this size change and subsequent size changes.
6124 Otherwise we leave the window gravity unchanged. */
6126 void
6127 x_set_window_size (struct frame *f, bool change_gravity,
6128 int width, int height, bool pixelwise)
6130 int pixelwidth, pixelheight;
6131 Lisp_Object fullscreen = get_frame_param (f, Qfullscreen);
6132 RECT rect;
6133 MENUBARINFO info;
6134 int menu_bar_height;
6136 block_input ();
6138 /* Get the height of the menu bar here. It's used below to detect
6139 whether the menu bar is wrapped. It's also used to specify the
6140 third argument for AdjustWindowRect. FRAME_EXTERNAL_MENU_BAR which
6141 has been used before for that reason is unreliable because it only
6142 specifies whether we _want_ a menu bar for this frame and not
6143 whether this frame _has_ a menu bar. See bug#22105. */
6144 info.cbSize = sizeof (info);
6145 info.rcBar.top = info.rcBar.bottom = 0;
6146 GetMenuBarInfo (FRAME_W32_WINDOW (f), 0xFFFFFFFD, 0, &info);
6147 menu_bar_height = info.rcBar.bottom - info.rcBar.top;
6149 if (pixelwise)
6151 pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
6152 pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
6154 else
6156 pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width);
6157 pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
6160 if (w32_add_wrapped_menu_bar_lines)
6162 /* When the menu bar wraps sending a SetWindowPos shrinks the
6163 height of the frame then the wrapped menu bar lines are not
6164 accounted for (Bug#15174 and Bug#18720). Here we add these
6165 extra lines to the frame height. */
6166 int default_menu_bar_height;
6168 /* Why is (apparently) SM_CYMENUSIZE needed here instead of
6169 SM_CYMENU ?? */
6170 default_menu_bar_height = GetSystemMetrics (SM_CYMENUSIZE);
6172 if ((default_menu_bar_height > 0)
6173 && (menu_bar_height > default_menu_bar_height)
6174 && ((menu_bar_height % default_menu_bar_height) == 0))
6175 pixelheight = pixelheight + menu_bar_height - default_menu_bar_height;
6178 f->win_gravity = NorthWestGravity;
6179 x_wm_set_size_hint (f, (long) 0, false);
6181 rect.left = rect.top = 0;
6182 rect.right = pixelwidth;
6183 rect.bottom = pixelheight;
6185 AdjustWindowRect (&rect, f->output_data.w32->dwStyle, menu_bar_height > 0);
6187 if (!(f->after_make_frame)
6188 && !(f->want_fullscreen & FULLSCREEN_WAIT)
6189 && FRAME_VISIBLE_P (f))
6191 RECT window_rect;
6193 GetWindowRect (FRAME_W32_WINDOW (f), &window_rect);
6195 if (EQ (fullscreen, Qmaximized)
6196 || EQ (fullscreen, Qfullboth)
6197 || EQ (fullscreen, Qfullwidth))
6199 rect.left = window_rect.left;
6200 rect.right = window_rect.right;
6201 pixelwidth = 0;
6203 if (EQ (fullscreen, Qmaximized)
6204 || EQ (fullscreen, Qfullboth)
6205 || EQ (fullscreen, Qfullheight))
6207 rect.top = window_rect.top;
6208 rect.bottom = window_rect.bottom;
6209 pixelheight = 0;
6213 if (pixelwidth > 0 || pixelheight > 0)
6215 frame_size_history_add
6216 (f, Qx_set_window_size_1, width, height,
6217 list2 (Fcons (make_number (pixelwidth),
6218 make_number (pixelheight)),
6219 Fcons (make_number (rect.right - rect.left),
6220 make_number (rect.bottom - rect.top))));
6222 my_set_window_pos (FRAME_W32_WINDOW (f), NULL,
6223 0, 0,
6224 rect.right - rect.left,
6225 rect.bottom - rect.top,
6226 SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
6228 change_frame_size (f,
6229 ((pixelwidth == 0)
6230 ? 0 : FRAME_PIXEL_TO_TEXT_WIDTH (f, pixelwidth)),
6231 ((pixelheight == 0)
6232 ? 0 : FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelheight)),
6233 0, 1, 0, 1);
6234 SET_FRAME_GARBAGED (f);
6236 /* If cursor was outside the new size, mark it as off. */
6237 mark_window_cursors_off (XWINDOW (f->root_window));
6239 /* Clear out any recollection of where the mouse highlighting was,
6240 since it might be in a place that's outside the new frame size.
6241 Actually checking whether it is outside is a pain in the neck,
6242 so don't try--just let the highlighting be done afresh with new
6243 size. */
6244 cancel_mouse_face (f);
6247 unblock_input ();
6249 do_pending_window_change (false);
6252 /* Mouse warping. */
6254 void
6255 frame_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y)
6257 UINT trail_num = 0;
6258 BOOL ret = false;
6259 RECT rect;
6260 POINT pt;
6262 block_input ();
6264 GetClientRect (FRAME_W32_WINDOW (f), &rect);
6265 pt.x = rect.left + pix_x;
6266 pt.y = rect.top + pix_y;
6267 ClientToScreen (FRAME_W32_WINDOW (f), &pt);
6269 /* When "mouse trails" are in effect, moving the mouse cursor
6270 sometimes leaves behind an annoying "ghost" of the pointer.
6271 Avoid that by momentarily switching off mouse trails. */
6272 if (os_subtype == OS_NT
6273 && w32_major_version + w32_minor_version >= 6)
6274 ret = SystemParametersInfo (SPI_GETMOUSETRAILS, 0, &trail_num, 0);
6275 SetCursorPos (pt.x, pt.y);
6276 if (ret)
6277 SystemParametersInfo (SPI_SETMOUSETRAILS, trail_num, NULL, 0);
6279 unblock_input ();
6283 /* focus shifting, raising and lowering. */
6285 void
6286 x_focus_frame (struct frame *f)
6288 #if 0
6289 struct w32_display_info *dpyinfo = &one_w32_display_info;
6290 #endif
6292 /* Give input focus to frame. */
6293 block_input ();
6294 #if 0
6295 /* Try not to change its Z-order if possible. */
6296 if (x_window_to_frame (dpyinfo, GetForegroundWindow ()))
6297 my_set_focus (f, FRAME_W32_WINDOW (f));
6298 else
6299 #endif
6300 my_set_foreground_window (FRAME_W32_WINDOW (f));
6301 unblock_input ();
6304 /* Raise frame F. */
6305 void
6306 x_raise_frame (struct frame *f)
6308 block_input ();
6310 /* Strictly speaking, raise-frame should only change the frame's Z
6311 order, leaving input focus unchanged. This is reasonable behavior
6312 on X where the usual policy is point-to-focus. However, this
6313 behavior would be very odd on Windows where the usual policy is
6314 click-to-focus.
6316 On X, if the mouse happens to be over the raised frame, it gets
6317 input focus anyway (so the window with focus will never be
6318 completely obscured) - if not, then just moving the mouse over it
6319 is sufficient to give it focus. On Windows, the user must actually
6320 click on the frame (preferably the title bar so as not to move
6321 point), which is more awkward. Also, no other Windows program
6322 raises a window to the top but leaves another window (possibly now
6323 completely obscured) with input focus.
6325 Because there is a system setting on Windows that allows the user
6326 to choose the point to focus policy, we make the strict semantics
6327 optional, but by default we grab focus when raising. */
6329 if (NILP (Vw32_grab_focus_on_raise))
6331 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6332 not already the foreground application: the frame is raised
6333 above all other frames belonging to us, but not above the
6334 current top window. To achieve that, we have to resort to this
6335 more cumbersome method. */
6337 HDWP handle = BeginDeferWindowPos (2);
6338 if (handle)
6340 handle = DeferWindowPos (handle,
6341 FRAME_W32_WINDOW (f),
6342 HWND_TOP,
6343 0, 0, 0, 0,
6344 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
6345 if (handle)
6347 handle = DeferWindowPos (handle,
6348 GetForegroundWindow (),
6349 FRAME_W32_WINDOW (f),
6350 0, 0, 0, 0,
6351 SWP_NOSIZE | SWP_NOMOVE |
6352 SWP_NOACTIVATE);
6353 if (handle)
6354 EndDeferWindowPos (handle);
6358 else
6360 my_bring_window_to_top (FRAME_W32_WINDOW (f));
6363 unblock_input ();
6366 /* Lower frame F. */
6367 void
6368 x_lower_frame (struct frame *f)
6370 block_input ();
6371 my_set_window_pos (FRAME_W32_WINDOW (f),
6372 HWND_BOTTOM,
6373 0, 0, 0, 0,
6374 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
6375 unblock_input ();
6378 static void
6379 w32_frame_raise_lower (struct frame *f, bool raise_flag)
6381 if (! FRAME_W32_P (f))
6382 return;
6384 if (raise_flag)
6385 x_raise_frame (f);
6386 else
6387 x_lower_frame (f);
6390 /* Change of visibility. */
6392 /* This tries to wait until the frame is really visible.
6393 However, if the window manager asks the user where to position
6394 the frame, this will return before the user finishes doing that.
6395 The frame will not actually be visible at that time,
6396 but it will become visible later when the window manager
6397 finishes with it. */
6399 void
6400 x_make_frame_visible (struct frame *f)
6402 block_input ();
6404 x_set_bitmap_icon (f);
6406 if (! FRAME_VISIBLE_P (f))
6408 /* We test FRAME_GARBAGED_P here to make sure we don't
6409 call x_set_offset a second time
6410 if we get to x_make_frame_visible a second time
6411 before the window gets really visible. */
6412 if (! FRAME_ICONIFIED_P (f)
6413 && ! f->output_data.w32->asked_for_visible)
6415 RECT workarea_rect;
6416 RECT window_rect;
6418 /* Adjust vertical window position in order to avoid being
6419 covered by a taskbar placed at the bottom of the desktop. */
6420 SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0);
6421 GetWindowRect (FRAME_W32_WINDOW (f), &window_rect);
6422 if (window_rect.bottom > workarea_rect.bottom
6423 && window_rect.top > workarea_rect.top)
6424 f->top_pos = max (window_rect.top
6425 - window_rect.bottom + workarea_rect.bottom,
6426 workarea_rect.top);
6428 x_set_offset (f, f->left_pos, f->top_pos, 0);
6431 f->output_data.w32->asked_for_visible = 1;
6433 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
6434 causes unexpected behavior when unminimizing frames that were
6435 previously maximized. But only SW_SHOWNORMAL works properly for
6436 frames that were truely hidden (using make-frame-invisible), so
6437 we need it to avoid Bug#5482. It seems that iconified is only
6438 set for minimized windows that are still visible, so use that to
6439 determine the appropriate flag to pass ShowWindow. */
6440 my_show_window (f, FRAME_W32_WINDOW (f),
6441 FRAME_ICONIFIED_P (f) ? SW_RESTORE : SW_SHOWNORMAL);
6444 /* Synchronize to ensure Emacs knows the frame is visible
6445 before we do anything else. We do this loop with input not blocked
6446 so that incoming events are handled. */
6448 Lisp_Object frame;
6449 int count;
6451 /* This must come after we set COUNT. */
6452 unblock_input ();
6454 XSETFRAME (frame, f);
6456 /* Wait until the frame is visible. Process X events until a
6457 MapNotify event has been seen, or until we think we won't get a
6458 MapNotify at all.. */
6459 for (count = input_signal_count + 10;
6460 input_signal_count < count && !FRAME_VISIBLE_P (f);)
6462 /* Force processing of queued events. */
6463 /* TODO: x_sync equivalent? */
6465 /* Machines that do polling rather than SIGIO have been observed
6466 to go into a busy-wait here. So we'll fake an alarm signal
6467 to let the handler know that there's something to be read.
6468 We used to raise a real alarm, but it seems that the handler
6469 isn't always enabled here. This is probably a bug. */
6470 if (input_polling_used ())
6472 /* It could be confusing if a real alarm arrives while processing
6473 the fake one. Turn it off and let the handler reset it. */
6474 int old_poll_suppress_count = poll_suppress_count;
6475 poll_suppress_count = 1;
6476 poll_for_input_1 ();
6477 poll_suppress_count = old_poll_suppress_count;
6483 /* Change from mapped state to withdrawn state. */
6485 /* Make the frame visible (mapped and not iconified). */
6487 void
6488 x_make_frame_invisible (struct frame *f)
6490 /* Don't keep the highlight on an invisible frame. */
6491 if (FRAME_DISPLAY_INFO (f)->x_highlight_frame == f)
6492 FRAME_DISPLAY_INFO (f)->x_highlight_frame = 0;
6494 block_input ();
6496 my_show_window (f, FRAME_W32_WINDOW (f), SW_HIDE);
6498 /* We can't distinguish this from iconification
6499 just by the event that we get from the server.
6500 So we can't win using the usual strategy of letting
6501 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6502 and synchronize with the server to make sure we agree. */
6503 SET_FRAME_VISIBLE (f, 0);
6504 SET_FRAME_ICONIFIED (f, false);
6506 unblock_input ();
6509 /* Change window state from mapped to iconified. */
6511 void
6512 x_iconify_frame (struct frame *f)
6514 /* Don't keep the highlight on an invisible frame. */
6515 if (FRAME_DISPLAY_INFO (f)->x_highlight_frame == f)
6516 FRAME_DISPLAY_INFO (f)->x_highlight_frame = 0;
6518 if (FRAME_ICONIFIED_P (f))
6519 return;
6521 block_input ();
6523 x_set_bitmap_icon (f);
6525 /* Simulate the user minimizing the frame. */
6526 SendMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, SC_MINIMIZE, 0);
6528 SET_FRAME_VISIBLE (f, 0);
6529 SET_FRAME_ICONIFIED (f, true);
6531 unblock_input ();
6535 /* Free X resources of frame F. */
6537 void
6538 x_free_frame_resources (struct frame *f)
6540 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
6541 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
6543 block_input ();
6545 /* We must free faces before destroying windows because some
6546 font-driver (e.g. xft) access a window while finishing a
6547 face. */
6548 free_frame_faces (f);
6550 if (FRAME_W32_WINDOW (f))
6551 my_destroy_window (f, FRAME_W32_WINDOW (f));
6553 free_frame_menubar (f);
6555 xfree (f->output_data.w32);
6556 f->output_data.w32 = NULL;
6558 if (f == dpyinfo->w32_focus_frame)
6559 dpyinfo->w32_focus_frame = 0;
6560 if (f == dpyinfo->w32_focus_event_frame)
6561 dpyinfo->w32_focus_event_frame = 0;
6562 if (f == dpyinfo->x_highlight_frame)
6563 dpyinfo->x_highlight_frame = 0;
6564 if (f == hlinfo->mouse_face_mouse_frame)
6565 reset_mouse_highlight (hlinfo);
6567 unblock_input ();
6571 /* Destroy the window of frame F. */
6572 void
6573 x_destroy_window (struct frame *f)
6575 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
6577 x_free_frame_resources (f);
6578 dpyinfo->reference_count--;
6582 /* Setting window manager hints. */
6584 /* Set the normal size hints for the window manager, for frame F.
6585 FLAGS is the flags word to use--or 0 meaning preserve the flags
6586 that the window now has.
6587 If USER_POSITION, set the USPosition
6588 flag (this is useful when FLAGS is 0). */
6589 void
6590 x_wm_set_size_hint (struct frame *f, long flags, bool user_position)
6592 Window window = FRAME_W32_WINDOW (f);
6594 enter_crit ();
6596 SetWindowLong (window, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
6597 SetWindowLong (window, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
6598 SetWindowLong (window, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
6599 SetWindowLong (window, WND_VSCROLLBAR_INDEX, FRAME_SCROLL_BAR_AREA_WIDTH (f));
6600 SetWindowLong (window, WND_HSCROLLBAR_INDEX, FRAME_SCROLL_BAR_AREA_HEIGHT (f));
6602 leave_crit ();
6605 /***********************************************************************
6606 Fonts
6607 ***********************************************************************/
6609 #ifdef GLYPH_DEBUG
6611 /* Check that FONT is valid on frame F. It is if it can be found in F's
6612 font table. */
6614 static void
6615 x_check_font (struct frame *f, struct font *font)
6617 eassert (font != NULL && ! NILP (font->props[FONT_TYPE_INDEX]));
6618 if (font->driver->check)
6619 eassert (font->driver->check (f, font) == 0);
6622 #endif /* GLYPH_DEBUG */
6624 /* Show hourglass cursor on frame F. */
6626 static void
6627 w32_show_hourglass (struct frame *f)
6629 if (!menubar_in_use && !current_popup_menu)
6631 struct w32_output *w32 = FRAME_X_OUTPUT (f);
6633 w32->hourglass_p = 1;
6634 SetCursor (w32->hourglass_cursor);
6638 /* Hide hourglass cursor on frame F. */
6640 static void
6641 w32_hide_hourglass (struct frame *f)
6643 struct w32_output *w32 = FRAME_X_OUTPUT (f);
6645 w32->hourglass_p = 0;
6646 if (f->pointer_invisible)
6647 SetCursor (NULL);
6648 else
6649 SetCursor (w32->current_cursor);
6652 /* FIXME: old code did that, but I don't know why. Anyway,
6653 this is used for non-GUI frames (see cancel_hourglass). */
6655 void
6656 w32_arrow_cursor (void)
6658 SetCursor (w32_load_cursor (IDC_ARROW));
6661 static void
6662 w32_toggle_invisible_pointer (struct frame *f, bool invisible)
6664 block_input ();
6666 if (f->pointer_invisible != invisible)
6668 f->pointer_invisible = invisible;
6669 w32_define_cursor (FRAME_W32_WINDOW (f),
6670 f->output_data.w32->current_cursor);
6673 unblock_input ();
6676 /***********************************************************************
6677 Initialization
6678 ***********************************************************************/
6680 static int w32_initialized = 0;
6682 void
6683 w32_initialize_display_info (Lisp_Object display_name)
6685 struct w32_display_info *dpyinfo = &one_w32_display_info;
6687 memset (dpyinfo, 0, sizeof (*dpyinfo));
6689 dpyinfo->name_list_element = Fcons (display_name, Qnil);
6690 dpyinfo->w32_id_name = xmalloc (SCHARS (Vinvocation_name)
6691 + SCHARS (Vsystem_name) + 2);
6692 sprintf (dpyinfo->w32_id_name, "%s@%s",
6693 SDATA (Vinvocation_name), SDATA (Vsystem_name));
6695 /* Default Console mode values - overridden when running in GUI mode
6696 with values obtained from system metrics. */
6697 dpyinfo->resx = 1;
6698 dpyinfo->resy = 1;
6699 dpyinfo->n_planes = 1;
6700 dpyinfo->n_cbits = 4;
6701 dpyinfo->n_fonts = 0;
6702 dpyinfo->smallest_font_height = 1;
6703 dpyinfo->smallest_char_width = 1;
6704 dpyinfo->vertical_scroll_bar_cursor = w32_load_cursor (IDC_ARROW);
6705 dpyinfo->horizontal_scroll_bar_cursor = w32_load_cursor (IDC_ARROW);
6706 /* TODO: dpyinfo->gray */
6708 reset_mouse_highlight (&dpyinfo->mouse_highlight);
6711 /* Create an xrdb-style database of resources to supersede registry settings.
6712 The database is just a concatenation of C strings, finished by an additional
6713 \0. The strings are submitted to some basic normalization, so
6715 [ *]option[ *]:[ *]value...
6717 becomes
6719 option:value...
6721 but any whitespace following value is not removed. */
6723 static char *
6724 w32_make_rdb (char *xrm_option)
6726 char *buffer = xmalloc (strlen (xrm_option) + 2);
6727 char *current = buffer;
6728 char ch;
6729 int in_option = 1;
6730 int before_value = 0;
6732 do {
6733 ch = *xrm_option++;
6735 if (ch == '\n')
6737 *current++ = '\0';
6738 in_option = 1;
6739 before_value = 0;
6741 else if (ch != ' ')
6743 *current++ = ch;
6744 if (in_option && (ch == ':'))
6746 in_option = 0;
6747 before_value = 1;
6749 else if (before_value)
6751 before_value = 0;
6754 else if (!(in_option || before_value))
6756 *current++ = ch;
6758 } while (ch);
6760 *current = '\0';
6762 return buffer;
6765 extern frame_parm_handler w32_frame_parm_handlers[];
6767 static struct redisplay_interface w32_redisplay_interface =
6769 w32_frame_parm_handlers,
6770 x_produce_glyphs,
6771 x_write_glyphs,
6772 x_insert_glyphs,
6773 x_clear_end_of_line,
6774 x_scroll_run,
6775 x_after_update_window_line,
6776 x_update_window_begin,
6777 x_update_window_end,
6778 0, /* flush_display */
6779 x_clear_window_mouse_face,
6780 x_get_glyph_overhangs,
6781 x_fix_overlapping_area,
6782 w32_draw_fringe_bitmap,
6783 w32_define_fringe_bitmap,
6784 w32_destroy_fringe_bitmap,
6785 w32_compute_glyph_string_overhangs,
6786 x_draw_glyph_string,
6787 w32_define_frame_cursor,
6788 w32_clear_frame_area,
6789 w32_draw_window_cursor,
6790 w32_draw_vertical_window_border,
6791 w32_draw_window_divider,
6792 w32_shift_glyphs_for_insert,
6793 w32_show_hourglass,
6794 w32_hide_hourglass
6797 static void x_delete_terminal (struct terminal *term);
6799 static struct terminal *
6800 w32_create_terminal (struct w32_display_info *dpyinfo)
6802 struct terminal *terminal;
6804 terminal = create_terminal (output_w32, &w32_redisplay_interface);
6806 terminal->display_info.w32 = dpyinfo;
6807 dpyinfo->terminal = terminal;
6809 /* MSVC does not type K&R functions with no arguments correctly, and
6810 so we must explicitly cast them. */
6811 terminal->clear_frame_hook = x_clear_frame;
6812 terminal->ins_del_lines_hook = x_ins_del_lines;
6813 terminal->delete_glyphs_hook = x_delete_glyphs;
6814 terminal->ring_bell_hook = w32_ring_bell;
6815 terminal->toggle_invisible_pointer_hook = w32_toggle_invisible_pointer;
6816 terminal->update_begin_hook = x_update_begin;
6817 terminal->update_end_hook = x_update_end;
6818 terminal->read_socket_hook = w32_read_socket;
6819 terminal->frame_up_to_date_hook = w32_frame_up_to_date;
6820 terminal->mouse_position_hook = w32_mouse_position;
6821 terminal->frame_rehighlight_hook = w32_frame_rehighlight;
6822 terminal->frame_raise_lower_hook = w32_frame_raise_lower;
6823 terminal->fullscreen_hook = w32fullscreen_hook;
6824 terminal->menu_show_hook = w32_menu_show;
6825 terminal->popup_dialog_hook = w32_popup_dialog;
6826 terminal->set_vertical_scroll_bar_hook = w32_set_vertical_scroll_bar;
6827 terminal->set_horizontal_scroll_bar_hook = w32_set_horizontal_scroll_bar;
6828 terminal->condemn_scroll_bars_hook = w32_condemn_scroll_bars;
6829 terminal->redeem_scroll_bar_hook = w32_redeem_scroll_bar;
6830 terminal->judge_scroll_bars_hook = w32_judge_scroll_bars;
6831 terminal->delete_frame_hook = x_destroy_window;
6832 terminal->delete_terminal_hook = x_delete_terminal;
6833 /* Other hooks are NULL by default. */
6835 /* We don't yet support separate terminals on W32, so don't try to share
6836 keyboards between virtual terminals that are on the same physical
6837 terminal like X does. */
6838 terminal->kboard = allocate_kboard (Qw32);
6839 /* Don't let the initial kboard remain current longer than necessary.
6840 That would cause problems if a file loaded on startup tries to
6841 prompt in the mini-buffer. */
6842 if (current_kboard == initial_kboard)
6843 current_kboard = terminal->kboard;
6844 terminal->kboard->reference_count++;
6846 return terminal;
6849 static void
6850 x_delete_terminal (struct terminal *terminal)
6852 struct w32_display_info *dpyinfo = terminal->display_info.w32;
6854 /* Protect against recursive calls. delete_frame in
6855 delete_terminal calls us back when it deletes our last frame. */
6856 if (!terminal->name)
6857 return;
6859 block_input ();
6861 x_delete_display (dpyinfo);
6862 unblock_input ();
6865 struct w32_display_info *
6866 w32_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
6868 struct w32_display_info *dpyinfo;
6869 struct terminal *terminal;
6870 HDC hdc;
6872 block_input ();
6874 if (!w32_initialized)
6876 w32_initialize ();
6877 w32_initialized = 1;
6880 w32_initialize_display_info (display_name);
6882 dpyinfo = &one_w32_display_info;
6883 terminal = w32_create_terminal (dpyinfo);
6885 /* Set the name of the terminal. */
6886 terminal->name = xlispstrdup (display_name);
6888 dpyinfo->xrdb = xrm_option ? w32_make_rdb (xrm_option) : NULL;
6890 /* Put this display on the chain. */
6891 dpyinfo->next = x_display_list;
6892 x_display_list = dpyinfo;
6894 hdc = GetDC (NULL);
6896 dpyinfo->root_window = GetDesktopWindow ();
6897 dpyinfo->n_planes = GetDeviceCaps (hdc, PLANES);
6898 dpyinfo->n_cbits = GetDeviceCaps (hdc, BITSPIXEL);
6899 dpyinfo->resx = GetDeviceCaps (hdc, LOGPIXELSX);
6900 dpyinfo->resy = GetDeviceCaps (hdc, LOGPIXELSY);
6901 dpyinfo->has_palette = GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE;
6902 ReleaseDC (NULL, hdc);
6904 /* initialize palette with white and black */
6906 XColor color;
6907 w32_defined_color (0, "white", &color, 1);
6908 w32_defined_color (0, "black", &color, 1);
6911 #ifdef WINDOWSNT
6912 /* Add the default keyboard. When !WINDOWSNT, we're using the
6913 standard Emacs console handling machinery and don't need an
6914 explicit FD here. */
6915 add_keyboard_wait_descriptor (0);
6916 #elif CYGWIN
6917 /* /dev/windows wakes us up when we have a thread message pending. */
6918 add_keyboard_wait_descriptor (w32_message_fd);
6919 #endif
6921 /* Create Fringe Bitmaps and store them for later use.
6923 On W32, bitmaps are all unsigned short, as Windows requires
6924 bitmap data to be Word aligned. For some reason they are
6925 horizontally reflected compared to how they appear on X, so we
6926 need to bitswap and convert to unsigned shorts before creating
6927 the bitmaps. */
6928 w32_init_fringe (terminal->rif);
6930 unblock_input ();
6932 return dpyinfo;
6935 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6936 void
6937 x_delete_display (struct w32_display_info *dpyinfo)
6939 /* FIXME: the only display info apparently can't be deleted. */
6940 /* free palette table */
6942 struct w32_palette_entry * plist;
6944 plist = dpyinfo->color_list;
6945 while (plist)
6947 struct w32_palette_entry * pentry = plist;
6948 plist = plist->next;
6949 xfree (pentry);
6951 dpyinfo->color_list = NULL;
6952 if (dpyinfo->palette)
6953 DeleteObject (dpyinfo->palette);
6955 w32_reset_fringes ();
6959 /* Set up use of W32. */
6961 void
6962 w32_init_main_thread (void)
6964 dwMainThreadId = GetCurrentThreadId ();
6965 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6966 GetCurrentProcess (), &hMainThread, 0, TRUE,
6967 DUPLICATE_SAME_ACCESS);
6972 DWORD WINAPI w32_msg_worker (void * arg);
6974 static void
6975 w32_initialize (void)
6977 HANDLE shell;
6978 HRESULT (WINAPI * set_user_model) (const wchar_t * id);
6980 baud_rate = 19200;
6982 w32_system_caret_hwnd = NULL;
6983 w32_system_caret_height = 0;
6984 w32_system_caret_x = 0;
6985 w32_system_caret_y = 0;
6987 /* On Windows 7 and later, we need to set the user model ID
6988 to associate emacsclient launched files with Emacs frames
6989 in the UI. */
6990 shell = GetModuleHandle ("shell32.dll");
6991 if (shell)
6993 set_user_model
6994 = (void *) GetProcAddress (shell,
6995 "SetCurrentProcessExplicitAppUserModelID");
6997 /* If the function is defined, then we are running on Windows 7
6998 or newer, and the UI uses this to group related windows
6999 together. Since emacs, runemacs, emacsclient are related, we
7000 want them grouped even though the executables are different,
7001 so we need to set a consistent ID between them. */
7002 if (set_user_model)
7003 set_user_model (L"GNU.Emacs");
7006 #ifdef CYGWIN
7007 if ((w32_message_fd = emacs_open ("/dev/windows", O_RDWR, 0)) == -1)
7008 fatal ("opening /dev/windows: %s", strerror (errno));
7009 #endif /* CYGWIN */
7011 /* Initialize w32_use_visible_system_caret based on whether a screen
7012 reader is in use. */
7013 if (!SystemParametersInfo (SPI_GETSCREENREADER, 0,
7014 &w32_use_visible_system_caret, 0))
7015 w32_use_visible_system_caret = 0;
7017 any_help_event_p = 0;
7019 /* Initialize input mode: interrupt_input off, no flow control, allow
7020 8 bit character input, standard quit char. */
7021 Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
7024 LCID input_locale_id = LOWORD (GetKeyboardLayout (0));
7025 w32_keyboard_codepage = codepage_for_locale (input_locale_id);
7028 /* Create the window thread - it will terminate itself when the app
7029 terminates */
7030 init_crit ();
7032 /* Wait for thread to start */
7034 MSG msg;
7036 PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
7038 hWindowsThread = CreateThread (NULL, 0,
7039 w32_msg_worker,
7040 0, 0, &dwWindowsThreadId);
7042 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
7045 /* It is desirable that mainThread should have the same notion of
7046 focus window and active window as windowsThread. Unfortunately, the
7047 following call to AttachThreadInput, which should do precisely what
7048 we need, causes major problems when Emacs is linked as a console
7049 program. Unfortunately, we have good reasons for doing that, so
7050 instead we need to send messages to windowsThread to make some API
7051 calls for us (ones that affect, or depend on, the active/focus
7052 window state.) */
7053 #ifdef ATTACH_THREADS
7054 AttachThreadInput (dwMainThreadId, dwWindowsThreadId, TRUE);
7055 #endif
7057 /* Dynamically link to optional system components. */
7059 HMODULE user_lib = GetModuleHandle ("user32.dll");
7061 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7063 LOAD_PROC (user_lib, SetLayeredWindowAttributes);
7065 #undef LOAD_PROC
7067 /* Ensure scrollbar handles are at least 5 pixels. */
7068 vertical_scroll_bar_min_handle = 5;
7069 horizontal_scroll_bar_min_handle = 5;
7071 /* For either kind of scroll bar, take account of the arrows; these
7072 effectively form the border of the main scroll bar range. */
7073 vertical_scroll_bar_top_border = vertical_scroll_bar_bottom_border
7074 = GetSystemMetrics (SM_CYVSCROLL);
7075 horizontal_scroll_bar_left_border = horizontal_scroll_bar_right_border
7076 = GetSystemMetrics (SM_CYHSCROLL);
7080 void
7081 syms_of_w32term (void)
7083 DEFSYM (Qvendor_specific_keysyms, "vendor-specific-keysyms");
7085 DEFSYM (Qadded, "added");
7086 DEFSYM (Qremoved, "removed");
7087 DEFSYM (Qmodified, "modified");
7088 DEFSYM (Qrenamed_from, "renamed-from");
7089 DEFSYM (Qrenamed_to, "renamed-to");
7091 DEFVAR_INT ("w32-num-mouse-buttons",
7092 w32_num_mouse_buttons,
7093 doc: /* Number of physical mouse buttons. */);
7094 w32_num_mouse_buttons = 2;
7096 DEFVAR_LISP ("w32-swap-mouse-buttons",
7097 Vw32_swap_mouse_buttons,
7098 doc: /* Swap the mapping of middle and right mouse buttons.
7099 When nil, middle button is mouse-2 and right button is mouse-3. */);
7100 Vw32_swap_mouse_buttons = Qnil;
7102 DEFVAR_LISP ("w32-grab-focus-on-raise",
7103 Vw32_grab_focus_on_raise,
7104 doc: /* Raised frame grabs input focus.
7105 When t, `raise-frame' grabs input focus as well. This fits well
7106 with the normal Windows click-to-focus policy, but might not be
7107 desirable when using a point-to-focus policy. */);
7108 Vw32_grab_focus_on_raise = Qt;
7110 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7111 Vw32_capslock_is_shiftlock,
7112 doc: /* Apply CapsLock state to non character input keys.
7113 When nil, CapsLock only affects normal character input keys. */);
7114 Vw32_capslock_is_shiftlock = Qnil;
7116 DEFVAR_LISP ("w32-recognize-altgr",
7117 Vw32_recognize_altgr,
7118 doc: /* Recognize right-alt and left-ctrl as AltGr.
7119 When nil, the right-alt and left-ctrl key combination is
7120 interpreted normally. */);
7121 Vw32_recognize_altgr = Qt;
7123 DEFVAR_BOOL ("w32-use-visible-system-caret",
7124 w32_use_visible_system_caret,
7125 doc: /* Flag to make the system caret visible.
7126 When this is non-nil, Emacs will indicate the position of point by
7127 using the system caret instead of drawing its own cursor. Some screen
7128 reader software does not track the system cursor properly when it is
7129 invisible, and gets confused by Emacs drawing its own cursor, so this
7130 variable is initialized to t when Emacs detects that screen reader
7131 software is running as it starts up.
7133 When this variable is set, other variables affecting the appearance of
7134 the cursor have no effect. */);
7136 w32_use_visible_system_caret = 0;
7138 /* We don't yet support this, but defining this here avoids whining
7139 from cus-start.el and other places, like "M-x set-variable". */
7140 DEFVAR_BOOL ("x-use-underline-position-properties",
7141 x_use_underline_position_properties,
7142 doc: /* Non-nil means make use of UNDERLINE_POSITION font properties.
7143 A value of nil means ignore them. If you encounter fonts with bogus
7144 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7145 to 4.1, set this to nil. You can also use `underline-minimum-offset'
7146 to override the font's UNDERLINE_POSITION for small font display
7147 sizes. */);
7148 x_use_underline_position_properties = 0;
7150 DEFVAR_BOOL ("x-underline-at-descent-line",
7151 x_underline_at_descent_line,
7152 doc: /* Non-nil means to draw the underline at the same place as the descent line.
7153 A value of nil means to draw the underline according to the value of the
7154 variable `x-use-underline-position-properties', which is usually at the
7155 baseline level. The default value is nil. */);
7156 x_underline_at_descent_line = 0;
7158 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars,
7159 doc: /* Which toolkit scroll bars Emacs uses, if any.
7160 A value of nil means Emacs doesn't use toolkit scroll bars.
7161 With the X Window system, the value is a symbol describing the
7162 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
7163 With MS Windows or Nextstep, the value is t. */);
7164 Vx_toolkit_scroll_bars = Qt;
7166 DEFVAR_BOOL ("w32-unicode-filenames",
7167 w32_unicode_filenames,
7168 doc: /* Non-nil means use Unicode APIs when passing file names to the OS.
7169 A value of nil means file names passed to the OS APIs and returned
7170 from those APIs are encoded/decoded using the ANSI codepage
7171 specified by `file-name-coding-system'.
7173 This variable is set to non-nil by default when Emacs runs on Windows
7174 systems of the NT family, including W2K, XP, Vista, Windows 7 and
7175 Windows 8. It is set to nil on Windows 9X. */);
7176 w32_unicode_filenames = 0;
7179 /* FIXME: The following variable will be (hopefully) removed
7180 before Emacs 25.1 gets released. */
7182 DEFVAR_BOOL ("w32-add-wrapped-menu-bar-lines",
7183 w32_add_wrapped_menu_bar_lines,
7184 doc: /* Non-nil means frame resizing accounts for wrapped menu bar lines.
7185 A value of nil means frame resizing does not add the height of wrapped
7186 menu bar lines when sending a frame resize request to the Windows API.
7187 This usually means that the resulting frame height is off by the number
7188 of wrapped menu bar lines. If this is non-nil, Emacs adds the height of
7189 wrapped menu bar lines when sending frame resize requests to the Windows
7190 API. */);
7191 w32_add_wrapped_menu_bar_lines = 1;
7193 /* Tell Emacs about this window system. */
7194 Fprovide (Qw32, Qnil);