1 /* Implementation of GUI terminal on the Microsoft Windows API.
3 Copyright (C) 1989, 1993-2017 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/>. */
24 #include "blockinput.h"
26 #include "w32common.h" /* for OS version info */
32 #include <fcntl.h> /* for O_RDWR */
39 #include "termhooks.h"
45 #include "menu.h" /* for w32_menu_show */
48 #include "w32.h" /* for filename_from_utf16, filename_from_ansi */
52 #include <io.h> /* for get_osfhandle */
60 #if 0 /* TODO: stipple */
61 #include "bitmaps/gray.xbm"
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))
79 /* Non-zero means that a HELP_EVENT has been generated since Emacs
82 static int any_help_event_p
;
84 extern unsigned int msh_mousewheel
;
86 extern int w32_codepage_for_font (char *fontname
);
87 extern Cursor
w32_load_cursor (LPCTSTR name
);
89 #define x_any_window_to_frame x_window_to_frame
90 #define x_top_window_to_frame x_window_to_frame
93 /* This is display since w32 does not support multiple ones. */
94 struct w32_display_info one_w32_display_info
;
95 struct w32_display_info
*x_display_list
;
97 #if _WIN32_WINNT < 0x0500 && !defined(MINGW_W64)
98 /* Pre Windows 2000, this was not available, but define it here so
99 that Emacs compiled on such a platform will run on newer versions.
100 MinGW64 defines these unconditionally, so avoid redefining. */
102 typedef struct tagWCRANGE
108 typedef struct tagGLYPHSET
112 DWORD cGlyphsSupported
;
117 #endif /* compiling for pre-Win2k */
119 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
120 BOOL (WINAPI
*pfnSetLayeredWindowAttributes
) (HWND
, COLORREF
, BYTE
, DWORD
);
123 #define LWA_ALPHA 0x02
125 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
126 later targets by MSVC headers. */
127 #ifndef WS_EX_LAYERED
128 #define WS_EX_LAYERED 0x80000
131 /* SM_CXVIRTUALSCREEN and SM_CYVIRTUALSCREEN are not defined on 95 and
133 #ifndef SM_CXVIRTUALSCREEN
134 #define SM_CXVIRTUALSCREEN 78
136 #ifndef SM_CYVIRTUALSCREEN
137 #define SM_CYVIRTUALSCREEN 79
140 /* The handle of the frame that currently owns the system caret. */
141 HWND w32_system_caret_hwnd
;
142 int w32_system_caret_height
;
143 int w32_system_caret_x
;
144 int w32_system_caret_y
;
145 struct window
*w32_system_caret_window
;
146 int w32_system_caret_hdr_height
;
147 int w32_system_caret_mode_height
;
148 DWORD dwWindowsThreadId
= 0;
149 HANDLE hWindowsThread
= NULL
;
150 DWORD dwMainThreadId
= 0;
151 HANDLE hMainThread
= NULL
;
153 int vertical_scroll_bar_min_handle
;
154 int horizontal_scroll_bar_min_handle
;
155 int vertical_scroll_bar_top_border
;
156 int vertical_scroll_bar_bottom_border
;
157 int horizontal_scroll_bar_left_border
;
158 int horizontal_scroll_bar_right_border
;
160 int last_scroll_bar_drag_pos
;
162 /* Keyboard code page - may be changed by language-change events. */
163 int w32_keyboard_codepage
;
165 /* Incremented by w32_read_socket whenever it really tries to read
167 static int volatile input_signal_count
;
170 int w32_message_fd
= -1;
173 static void w32_handle_tool_bar_click (struct frame
*,
174 struct input_event
*);
175 static void w32_define_cursor (Window
, Cursor
);
177 void x_lower_frame (struct frame
*);
178 void x_scroll_bar_clear (struct frame
*);
179 void x_raise_frame (struct frame
*);
180 void x_wm_set_window_state (struct frame
*, int);
181 void x_wm_set_icon_pixmap (struct frame
*, int);
182 static void w32_initialize (void);
183 static void x_update_end (struct frame
*);
184 static void w32_frame_up_to_date (struct frame
*);
185 static void x_clear_frame (struct frame
*);
186 static void frame_highlight (struct frame
*);
187 static void frame_unhighlight (struct frame
*);
188 static void x_new_focus_frame (struct w32_display_info
*,
190 static void x_focus_changed (int, int, struct w32_display_info
*,
191 struct frame
*, struct input_event
*);
192 static void w32_detect_focus_change (struct w32_display_info
*,
193 W32Msg
*, struct input_event
*);
194 static void w32_frame_rehighlight (struct frame
*);
195 static void x_frame_rehighlight (struct w32_display_info
*);
196 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
197 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
198 enum text_cursor_kinds
);
199 static void w32_clip_to_row (struct window
*, struct glyph_row
*,
200 enum glyph_row_area
, HDC
);
201 static BOOL
my_show_window (struct frame
*, HWND
, int);
202 static void my_set_window_pos (HWND
, HWND
, int, int, int, int, UINT
);
204 static void my_set_focus (struct frame
*, HWND
);
206 static void my_set_foreground_window (HWND
);
207 static void my_destroy_window (struct frame
*, HWND
);
208 static void w32fullscreen_hook (struct frame
*);
211 static void x_check_font (struct frame
*, struct font
*);
215 /***********************************************************************
217 ***********************************************************************/
221 /* This is a function useful for recording debugging information about
222 the sequence of occurrences in this file. */
230 struct record event_record
[100];
232 int event_record_index
;
234 record_event (char *locus
, int type
)
236 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
237 event_record_index
= 0;
239 event_record
[event_record_index
].locus
= locus
;
240 event_record
[event_record_index
].type
= type
;
241 event_record_index
++;
248 XChangeGC (void *ignore
, XGCValues
*gc
, unsigned long mask
,
251 if (mask
& GCForeground
)
252 gc
->foreground
= xgcv
->foreground
;
253 if (mask
& GCBackground
)
254 gc
->background
= xgcv
->background
;
256 gc
->font
= xgcv
->font
;
260 XCreateGC (void *ignore
, HWND wignore
, unsigned long mask
, XGCValues
*xgcv
)
262 XGCValues
*gc
= xzalloc (sizeof (XGCValues
));
264 XChangeGC (ignore
, gc
, mask
, xgcv
);
269 #if 0 /* unused for now, see x_draw_image_glyph_string below */
271 XGetGCValues (void *ignore
, XGCValues
*gc
,
272 unsigned long mask
, XGCValues
*xgcv
)
274 XChangeGC (ignore
, xgcv
, mask
, gc
);
279 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
283 HRGN clip_region
= CreateRectRgnIndirect (rect
);
284 SelectClipRgn (hdc
, clip_region
);
285 DeleteObject (clip_region
);
288 SelectClipRgn (hdc
, NULL
);
291 /* Restore clipping rectangle in S */
293 w32_restore_glyph_string_clip (struct glyph_string
*s
)
296 int n
= s
->num_clips
;
299 w32_set_clip_rectangle (s
->hdc
, r
);
302 HRGN clip1
= CreateRectRgnIndirect (r
);
303 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
304 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
305 SelectClipRgn (s
->hdc
, clip1
);
306 DeleteObject (clip1
);
307 DeleteObject (clip2
);
312 Draw a wavy line under S. The wave fills wave_height pixels from y0.
318 wave_height = 3 | * * * *
323 w32_draw_underwave (struct glyph_string
*s
, COLORREF color
)
325 int wave_height
= 3, wave_length
= 2;
326 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, odd
, xmax
;
327 XRectangle wave_clip
, string_clip
, final_clip
;
328 RECT w32_final_clip
, w32_string_clip
;
332 dy
= wave_height
- 1;
334 y0
= s
->ybase
- wave_height
+ 3;
338 /* Find and set clipping rectangle */
342 wave_clip
.width
= width
;
343 wave_clip
.height
= wave_height
;
345 get_glyph_string_clip_rect (s
, &w32_string_clip
);
346 CONVERT_TO_XRECT (string_clip
, w32_string_clip
);
348 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
351 hp
= CreatePen (PS_SOLID
, 0, color
);
352 oldhp
= SelectObject (s
->hdc
, hp
);
353 CONVERT_FROM_XRECT (final_clip
, w32_final_clip
);
354 w32_set_clip_rectangle (s
->hdc
, &w32_final_clip
);
368 MoveToEx (s
->hdc
, x1
, y1
, NULL
);
372 LineTo (s
->hdc
, x2
, y2
);
374 x2
+= dx
, y2
= y0
+ odd
*dy
;
378 /* Restore previous pen and clipping rectangle(s) */
379 w32_restore_glyph_string_clip (s
);
380 SelectObject (s
->hdc
, oldhp
);
384 /* Draw a hollow rectangle at the specified position. */
386 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
387 int width
, int height
)
392 hb
= CreateSolidBrush (gc
->background
);
393 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
394 oldhb
= SelectObject (hdc
, hb
);
395 oldhp
= SelectObject (hdc
, hp
);
397 /* We enlarge WIDTH and HEIGHT by 1 to be bug-compatible to the
398 brain-dead design of XDrawRectangle, which draws a rectangle that
399 is 1 pixel wider and higher than its arguments WIDTH and HEIGHT.
400 This allows us to keep the code that calls this function similar
401 to the corresponding code in xterm.c. For the details, see
402 http://lists.gnu.org/archives/html/emacs-devel/2014-10/msg00546.html. */
403 Rectangle (hdc
, x
, y
, x
+ width
+ 1, y
+ height
+ 1);
405 SelectObject (hdc
, oldhb
);
406 SelectObject (hdc
, oldhp
);
411 /* Draw a filled rectangle at the specified position. */
413 w32_fill_rect (struct frame
*f
, HDC hdc
, COLORREF pix
, RECT
*lprect
)
417 hb
= CreateSolidBrush (pix
);
418 FillRect (hdc
, lprect
, hb
);
423 w32_clear_window (struct frame
*f
)
426 HDC hdc
= get_frame_dc (f
);
428 /* Under certain conditions, this can be called at startup with
429 a console frame pointer before the GUI frame is created. An HDC
430 of 0 indicates this. */
433 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
434 w32_clear_rect (f
, hdc
, &rect
);
437 release_frame_dc (f
, hdc
);
440 #define OPAQUE_FRAME 255
443 x_set_frame_alpha (struct frame
*f
)
445 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
447 double alpha_min
= 1.0;
450 HWND window
= FRAME_W32_WINDOW (f
);
452 /* Older versions of Windows do not support transparency. */
453 if (!pfnSetLayeredWindowAttributes
)
456 if (dpyinfo
->w32_focus_frame
== f
)
461 if (FLOATP (Vframe_alpha_lower_limit
))
462 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
463 else if (INTEGERP (Vframe_alpha_lower_limit
))
464 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
468 else if (alpha
> 1.0)
470 else if (alpha
< alpha_min
&& alpha_min
<= 1.0)
473 opac
= alpha
* OPAQUE_FRAME
;
475 ex_style
= GetWindowLong (window
, GWL_EXSTYLE
);
477 if (opac
== OPAQUE_FRAME
)
478 ex_style
&= ~WS_EX_LAYERED
;
480 ex_style
|= WS_EX_LAYERED
;
482 SetWindowLong (window
, GWL_EXSTYLE
, ex_style
);
484 if (opac
!= OPAQUE_FRAME
)
485 pfnSetLayeredWindowAttributes (window
, 0, opac
, LWA_ALPHA
);
489 x_display_pixel_height (struct w32_display_info
*dpyinfo
)
491 int pixels
= GetSystemMetrics (SM_CYVIRTUALSCREEN
);
494 /* Fallback for Windows 95 or NT 4.0. */
495 pixels
= GetSystemMetrics (SM_CYSCREEN
);
501 x_display_pixel_width (struct w32_display_info
*dpyinfo
)
503 int pixels
= GetSystemMetrics (SM_CXVIRTUALSCREEN
);
506 /* Fallback for Windows 95 or NT 4.0. */
507 pixels
= GetSystemMetrics (SM_CXSCREEN
);
513 /***********************************************************************
514 Starting and ending an update
515 ***********************************************************************/
517 /* Start an update of frame F. This function is installed as a hook
518 for update_begin, i.e. it is called when update_begin is called.
519 This function is called prior to calls to x_update_window_begin for
520 each window being updated. */
523 x_update_begin (struct frame
*f
)
525 struct w32_display_info
*display_info
= FRAME_DISPLAY_INFO (f
);
527 if (! FRAME_W32_P (f
))
530 /* Regenerate display palette before drawing if list of requested
531 colors has changed. */
532 if (display_info
->regen_palette
)
534 w32_regenerate_palette (f
);
535 display_info
->regen_palette
= FALSE
;
540 /* Start update of window W. */
543 x_update_window_begin (struct window
*w
)
545 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
546 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
548 /* Hide the system caret during an update. */
549 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
551 SendMessageTimeout (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0,
555 w
->output_cursor
= w
->cursor
;
559 if (f
== hlinfo
->mouse_face_mouse_frame
)
561 /* Don't do highlighting for mouse motion during the update. */
562 hlinfo
->mouse_face_defer
= true;
564 /* If F needs to be redrawn, simply forget about any prior mouse
566 if (FRAME_GARBAGED_P (f
))
567 hlinfo
->mouse_face_window
= Qnil
;
569 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
570 their mouse_face_p flag set, which means that they are always
571 unequal to rows in a desired matrix which never have that
572 flag set. So, rows containing mouse-face glyphs are never
573 scrolled, and we don't have to switch the mouse highlight off
574 here to prevent it from being scrolled. */
576 /* Can we tell that this update does not affect the window
577 where the mouse highlight is? If so, no need to turn off.
578 Likewise, don't do anything if the frame is garbaged;
579 in that case, the frame's current matrix that we would use
580 is all wrong, and we will redisplay that line anyway. */
581 if (!NILP (hlinfo
->mouse_face_window
)
582 && w
== XWINDOW (hlinfo
->mouse_face_window
))
586 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
587 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
590 if (i
< w
->desired_matrix
->nrows
)
591 clear_mouse_face (hlinfo
);
599 /* Draw a vertical window border from (x,y0) to (x,y1) */
602 w32_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
604 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
614 hdc
= get_frame_dc (f
);
615 face
= FACE_FROM_ID_OR_NULL (f
, VERTICAL_BORDER_FACE_ID
);
617 w32_fill_rect (f
, hdc
, face
->foreground
, &r
);
619 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
621 release_frame_dc (f
, hdc
);
625 /* Draw a window divider from (x0, y0) to (x1, y1) */
628 w32_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
630 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
631 HDC hdc
= get_frame_dc (f
);
632 struct face
*face
= FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_FACE_ID
);
633 struct face
*face_first
634 = FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
635 struct face
*face_last
636 = FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
637 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
638 unsigned long color_first
= (face_first
639 ? face_first
->foreground
640 : FRAME_FOREGROUND_PIXEL (f
));
641 unsigned long color_last
= (face_last
642 ? face_last
->foreground
643 : FRAME_FOREGROUND_PIXEL (f
));
645 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
648 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x0
+ 1, y1
);
649 w32_fill_area_abs (f
, hdc
, color
, x0
+ 1, y0
, x1
- 1, y1
);
650 w32_fill_area_abs (f
, hdc
, color_last
, x1
- 1, y0
, x1
, y1
);
652 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
655 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x1
, y0
+ 1);
656 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
+ 1, x1
, y1
- 1);
657 w32_fill_area_abs (f
, hdc
, color_last
, x0
, y1
- 1, x1
, y1
);
660 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
, x1
, y1
);
662 release_frame_dc (f
, hdc
);
665 /* End update of window W.
667 Draw vertical borders between horizontally adjacent windows, and
668 display W's cursor if CURSOR_ON_P is non-zero.
670 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
671 glyphs in mouse-face were overwritten. In that case we have to
672 make sure that the mouse-highlight is properly redrawn.
674 W may be a menu bar pseudo-window in case we don't have X toolkit
675 support. Such windows don't have a cursor, so don't display it
679 x_update_window_end (struct window
*w
, bool cursor_on_p
,
680 bool mouse_face_overwritten_p
)
682 if (!w
->pseudo_window_p
)
687 display_and_set_cursor (w
, true,
688 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
689 w
->output_cursor
.x
, w
->output_cursor
.y
);
691 if (draw_window_fringes (w
, true))
693 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
694 x_draw_right_divider (w
);
696 x_draw_vertical_border (w
);
702 /* If a row with mouse-face was overwritten, arrange for
703 XTframe_up_to_date to redisplay the mouse highlight. */
704 if (mouse_face_overwritten_p
)
706 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
708 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
709 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
710 hlinfo
->mouse_face_window
= Qnil
;
713 /* Unhide the caret. This won't actually show the cursor, unless it
714 was visible before the corresponding call to HideCaret in
715 x_update_window_begin. */
716 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
718 SendMessageTimeout (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0,
724 /* End update of frame F. This function is installed as a hook in
728 x_update_end (struct frame
*f
)
730 if (! FRAME_W32_P (f
))
733 /* Mouse highlight may be displayed again. */
734 MOUSE_HL_INFO (f
)->mouse_face_defer
= false;
738 /* This function is called from various places in xdisp.c
739 whenever a complete update has been performed. */
742 w32_frame_up_to_date (struct frame
*f
)
745 FRAME_MOUSE_UPDATE (f
);
749 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
750 arrow bitmaps, or clear the fringes if no bitmaps are required
751 before DESIRED_ROW is made current. This function is called from
752 update_window_line only if it is known that there are differences
753 between bitmaps to be drawn between current row and DESIRED_ROW. */
756 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
763 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
764 desired_row
->redraw_fringe_bitmaps_p
= true;
766 /* When a window has disappeared, make sure that no rest of
767 full-width rows stays visible in the internal border. Could
768 check here if updated window is the leftmost/rightmost window,
769 but I guess it's not worth doing since vertically split windows
770 are almost never used, internal border is rarely set, and the
771 overhead is very small. */
772 if (windows_or_buffers_changed
773 && desired_row
->full_width_p
774 && (f
= XFRAME (w
->frame
),
775 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
777 && (height
= desired_row
->visible_height
,
780 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
784 HDC hdc
= get_frame_dc (f
);
785 struct face
*face
= FACE_FROM_ID_OR_NULL (f
, INTERNAL_BORDER_FACE_ID
);
789 /* Fill border with internal border face. */
790 unsigned long color
= face
->background
;
792 w32_fill_area (f
, hdc
, color
, 0, y
, width
, height
);
793 w32_fill_area (f
, hdc
, color
, FRAME_PIXEL_WIDTH (f
) - width
,
798 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
799 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
802 release_frame_dc (f
, hdc
);
809 /* Draw the bitmap WHICH in one of the left or right fringes of
810 window W. ROW is the glyph row for which to display the bitmap; it
811 determines the vertical position at which the bitmap has to be
815 w32_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
,
816 struct draw_fringe_bitmap_params
*p
)
818 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
820 struct face
*face
= p
->face
;
822 hdc
= get_frame_dc (f
);
824 /* Must clip because of partially visible lines. */
825 w32_clip_to_row (w
, row
, ANY_AREA
, hdc
);
827 if (p
->bx
>= 0 && !p
->overlay_p
)
828 w32_fill_area (f
, hdc
, face
->background
,
829 p
->bx
, p
->by
, p
->nx
, p
->ny
);
831 if (p
->which
&& p
->which
< max_fringe_bmp
)
833 HBITMAP pixmap
= fringe_bmp
[p
->which
];
837 compat_hdc
= CreateCompatibleDC (hdc
);
841 horig_obj
= SelectObject (compat_hdc
, pixmap
);
843 /* Paint overlays transparently. */
846 HBRUSH h_brush
, h_orig_brush
;
848 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
849 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
850 h_brush
= CreateSolidBrush (face
->foreground
);
851 h_orig_brush
= SelectObject (hdc
, h_brush
);
853 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
854 compat_hdc
, 0, p
->dh
,
856 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
857 compat_hdc
, 0, p
->dh
,
859 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
860 compat_hdc
, 0, p
->dh
,
863 SelectObject (hdc
, h_orig_brush
);
864 DeleteObject (h_brush
);
868 SetTextColor (hdc
, face
->background
);
869 SetBkColor (hdc
, (p
->cursor_p
870 ? f
->output_data
.w32
->cursor_pixel
871 : face
->foreground
));
873 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
874 compat_hdc
, 0, p
->dh
,
878 SelectObject (compat_hdc
, horig_obj
);
879 DeleteDC (compat_hdc
);
883 w32_set_clip_rectangle (hdc
, NULL
);
885 release_frame_dc (f
, hdc
);
889 w32_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
891 if (which
>= max_fringe_bmp
)
893 int i
= max_fringe_bmp
;
894 max_fringe_bmp
= which
+ 20;
895 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
896 while (i
< max_fringe_bmp
)
900 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
904 w32_destroy_fringe_bitmap (int which
)
906 if (which
>= max_fringe_bmp
)
909 if (fringe_bmp
[which
])
910 DeleteObject (fringe_bmp
[which
]);
911 fringe_bmp
[which
] = 0;
914 /***********************************************************************
916 ***********************************************************************/
918 /* Function prototypes of this page. */
920 static void x_set_glyph_string_clipping (struct glyph_string
*);
921 static void x_set_glyph_string_gc (struct glyph_string
*);
922 static void x_draw_glyph_string_background (struct glyph_string
*,
924 static void x_draw_glyph_string_foreground (struct glyph_string
*);
925 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
926 static void x_draw_glyph_string_box (struct glyph_string
*);
927 static void x_draw_glyph_string (struct glyph_string
*);
928 static void x_set_cursor_gc (struct glyph_string
*);
929 static void x_set_mode_line_face_gc (struct glyph_string
*);
930 static void x_set_mouse_face_gc (struct glyph_string
*);
931 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
932 static void w32_setup_relief_color (struct frame
*, struct relief
*,
933 double, int, COLORREF
);
934 static void x_setup_relief_colors (struct glyph_string
*);
935 static void x_draw_image_glyph_string (struct glyph_string
*);
936 static void x_draw_image_relief (struct glyph_string
*);
937 static void x_draw_image_foreground (struct glyph_string
*);
938 static void w32_draw_image_foreground_1 (struct glyph_string
*, HBITMAP
);
939 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
941 static void w32_draw_relief_rect (struct frame
*, int, int, int, int,
942 int, int, int, int, int, int,
944 static void w32_draw_box_rect (struct glyph_string
*, int, int, int, int,
945 int, bool, bool, RECT
*);
948 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
952 x_set_cursor_gc (struct glyph_string
*s
)
954 if (s
->font
== FRAME_FONT (s
->f
)
955 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
956 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
957 /* Sometimes we are not called for each change in the default
958 face's background color (e.g., bug#26851), so the additional
959 test in the next line gives us a chance to resync. */
960 && s
->f
->output_data
.w32
->cursor_gc
->foreground
== s
->face
->background
962 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
965 /* Cursor on non-default face: must merge. */
969 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
970 xgcv
.foreground
= s
->face
->background
;
972 /* If the glyph would be invisible, try a different foreground. */
973 if (xgcv
.foreground
== xgcv
.background
)
974 xgcv
.foreground
= s
->face
->foreground
;
975 if (xgcv
.foreground
== xgcv
.background
)
976 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
977 if (xgcv
.foreground
== xgcv
.background
)
978 xgcv
.foreground
= s
->face
->foreground
;
980 /* Make sure the cursor is distinct from text in this face. */
981 if (xgcv
.background
== s
->face
->background
982 && xgcv
.foreground
== s
->face
->foreground
)
984 xgcv
.background
= s
->face
->foreground
;
985 xgcv
.foreground
= s
->face
->background
;
988 IF_DEBUG (x_check_font (s
->f
, s
->font
));
990 mask
= GCForeground
| GCBackground
| GCFont
;
992 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
993 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
996 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
997 = XCreateGC (NULL
, FRAME_W32_WINDOW (s
->f
), mask
, &xgcv
);
999 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1004 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1007 x_set_mouse_face_gc (struct glyph_string
*s
)
1012 /* What face has to be used last for the mouse face? */
1013 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
1014 face
= FACE_FROM_ID_OR_NULL (s
->f
, face_id
);
1016 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1018 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1019 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1021 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1022 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1023 prepare_face_for_display (s
->f
, s
->face
);
1025 /* If font in this face is same as S->font, use it. */
1026 if (s
->font
== s
->face
->font
)
1027 s
->gc
= s
->face
->gc
;
1030 /* Otherwise construct scratch_cursor_gc with values from FACE
1035 xgcv
.background
= s
->face
->background
;
1036 xgcv
.foreground
= s
->face
->foreground
;
1037 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1038 xgcv
.font
= s
->font
;
1039 mask
= GCForeground
| GCBackground
| GCFont
;
1041 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1042 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1045 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1046 = XCreateGC (NULL
, FRAME_W32_WINDOW (s
->f
), mask
, &xgcv
);
1048 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1051 eassert (s
->gc
!= 0);
1055 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1056 Faces to use in the mode line have already been computed when the
1057 matrix was built, so there isn't much to do, here. */
1060 x_set_mode_line_face_gc (struct glyph_string
*s
)
1062 s
->gc
= s
->face
->gc
;
1066 /* Set S->gc of glyph string S for drawing that glyph string. Set
1067 S->stippled_p to a non-zero value if the face of S has a stipple
1071 x_set_glyph_string_gc (struct glyph_string
*s
)
1073 prepare_face_for_display (s
->f
, s
->face
);
1075 if (s
->hl
== DRAW_NORMAL_TEXT
)
1077 s
->gc
= s
->face
->gc
;
1078 s
->stippled_p
= s
->face
->stipple
!= 0;
1080 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1082 x_set_mode_line_face_gc (s
);
1083 s
->stippled_p
= s
->face
->stipple
!= 0;
1085 else if (s
->hl
== DRAW_CURSOR
)
1087 x_set_cursor_gc (s
);
1088 s
->stippled_p
= false;
1090 else if (s
->hl
== DRAW_MOUSE_FACE
)
1092 x_set_mouse_face_gc (s
);
1093 s
->stippled_p
= s
->face
->stipple
!= 0;
1095 else if (s
->hl
== DRAW_IMAGE_RAISED
1096 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1098 s
->gc
= s
->face
->gc
;
1099 s
->stippled_p
= s
->face
->stipple
!= 0;
1104 /* GC must have been set. */
1105 eassert (s
->gc
!= 0);
1109 /* Set clipping for output of glyph string S. S may be part of a mode
1110 line or menu if we don't have X toolkit support. */
1113 x_set_glyph_string_clipping (struct glyph_string
*s
)
1116 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1119 w32_set_clip_rectangle (s
->hdc
, r
);
1122 HRGN clip1
= CreateRectRgnIndirect (r
);
1123 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
1124 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
1125 SelectClipRgn (s
->hdc
, clip1
);
1126 DeleteObject (clip1
);
1127 DeleteObject (clip2
);
1132 /* Set SRC's clipping for output of glyph string DST. This is called
1133 when we are drawing DST's left_overhang or right_overhang only in
1137 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
,
1138 struct glyph_string
*dst
)
1143 r
.right
= r
.left
+ src
->width
;
1145 r
.bottom
= r
.top
+ src
->height
;
1148 w32_set_clip_rectangle (dst
->hdc
, &r
);
1152 Compute left and right overhang of glyph string S. */
1155 w32_compute_glyph_string_overhangs (struct glyph_string
*s
)
1158 && s
->first_glyph
->type
== CHAR_GLYPH
1159 && !s
->font_not_found_p
)
1161 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1162 struct font
*font
= s
->font
;
1163 struct font_metrics metrics
;
1166 for (i
= 0; i
< s
->nchars
; i
++)
1167 code
[i
] = s
->char2b
[i
];
1168 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1169 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1170 ? metrics
.rbearing
- metrics
.width
: 0);
1171 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1175 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1176 s
->left_overhang
= -s
->cmp
->lbearing
;
1180 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1183 x_clear_glyph_string_rect (struct glyph_string
*s
,
1184 int x
, int y
, int w
, int h
)
1191 /* Take clipping into account. */
1192 if (s
->gc
->clip_mask
== Rect
)
1194 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1195 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1196 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1197 - s
->gc
->clip_rectangle
.left
);
1198 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1199 - s
->gc
->clip_rectangle
.top
);
1202 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1207 /* Draw the background of glyph_string S. If S->background_filled_p
1208 is non-zero don't draw it. FORCE_P non-zero means draw the
1209 background even if it wouldn't be drawn normally. This is used
1210 when a string preceding S draws into the background of S, or S
1211 contains the first component of a composition. */
1214 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1216 /* Nothing to do if background has already been drawn or if it
1217 shouldn't be drawn in the first place. */
1218 if (!s
->background_filled_p
)
1220 int box_line_width
= max (s
->face
->box_line_width
, 0);
1222 #if 0 /* TODO: stipple */
1225 /* Fill background with a stipple pattern. */
1226 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1227 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), s
->gc
, s
->x
,
1228 s
->y
+ box_line_width
,
1229 s
->background_width
,
1230 s
->height
- 2 * box_line_width
);
1231 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1232 s
->background_filled_p
= true;
1236 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1237 /* When xdisp.c ignores FONT_HEIGHT, we cannot trust
1238 font dimensions, since the actual glyphs might be
1239 much smaller. So in that case we always clear the
1240 rectangle with background color. */
1241 || FONT_TOO_HIGH (s
->font
)
1242 || s
->font_not_found_p
1243 || s
->extends_to_end_of_line_p
1246 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1247 s
->background_width
,
1248 s
->height
- 2 * box_line_width
);
1249 s
->background_filled_p
= true;
1255 /* Draw the foreground of glyph string S. */
1258 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1262 /* If first glyph of S has a left box line, start drawing the text
1263 of S to the right of that box line. */
1264 if (s
->face
->box
!= FACE_NO_BOX
1265 && s
->first_glyph
->left_box_line_p
)
1266 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1270 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1271 SetBkColor (s
->hdc
, s
->gc
->background
);
1272 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1274 /* Draw characters of S as rectangles if S's font could not be
1276 if (s
->font_not_found_p
)
1278 for (i
= 0; i
< s
->nchars
; ++i
)
1280 struct glyph
*g
= s
->first_glyph
+ i
;
1282 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1284 x
+= g
->pixel_width
;
1289 struct font
*font
= s
->font
;
1290 int boff
= font
->baseline_offset
;
1294 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1296 if (font
->vertical_centering
)
1297 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1299 y
= s
->ybase
- boff
;
1301 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1302 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, false);
1304 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, true);
1305 if (s
->face
->overstrike
)
1306 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, false);
1308 SelectObject (s
->hdc
, old_font
);
1312 /* Draw the foreground of composite glyph string S. */
1315 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1318 struct font
*font
= s
->font
;
1320 /* If first glyph of S has a left box line, start drawing the text
1321 of S to the right of that box line. */
1322 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1323 && s
->first_glyph
->left_box_line_p
)
1324 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1328 /* S is a glyph string for a composition. S->cmp_from is the index
1329 of the first character drawn for glyphs of this composition.
1330 S->cmp_from == 0 means we are drawing the very first character of
1331 this composition. */
1333 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1334 SetBkColor (s
->hdc
, s
->gc
->background
);
1335 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1337 /* Draw a rectangle for the composition if the font for the very
1338 first character of the composition could not be loaded. */
1339 if (s
->font_not_found_p
)
1341 if (s
->cmp_from
== 0)
1342 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1345 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1350 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1352 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1353 /* TAB in a composition means display glyphs with padding
1354 space on the left or right. */
1355 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1357 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1358 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1360 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, false);
1361 if (s
->face
->overstrike
)
1362 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, false);
1364 SelectObject (s
->hdc
, old_font
);
1368 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1374 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1376 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1378 glyph
= LGSTRING_GLYPH (gstring
, i
);
1379 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1380 width
+= LGLYPH_WIDTH (glyph
);
1383 int xoff
, yoff
, wadjust
;
1387 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1390 xoff
= LGLYPH_XOFF (glyph
);
1391 yoff
= LGLYPH_YOFF (glyph
);
1392 wadjust
= LGLYPH_WADJUST (glyph
);
1393 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, false);
1400 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1402 SelectObject (s
->hdc
, old_font
);
1407 /* Draw the foreground of glyph string S for glyphless characters. */
1410 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1412 struct glyph
*glyph
= s
->first_glyph
;
1415 bool with_background
;
1417 /* If first glyph of S has a left box line, start drawing the text
1418 of S to the right of that box line. */
1419 if (s
->face
->box
!= FACE_NO_BOX
1420 && s
->first_glyph
->left_box_line_p
)
1421 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1425 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1426 SetBkColor (s
->hdc
, s
->gc
->background
);
1427 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1430 with_background
= ((s
->for_overlaps
1431 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))) == 0;
1432 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1434 char buf
[7], *str
= NULL
;
1435 int len
= glyph
->u
.glyphless
.len
;
1437 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1440 && CHAR_TABLE_P (Vglyphless_char_display
)
1441 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1445 = (! glyph
->u
.glyphless
.for_no_font
1446 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1447 glyph
->u
.glyphless
.ch
)
1448 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1449 if (STRINGP (acronym
))
1450 str
= SSDATA (acronym
);
1453 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1455 sprintf ((char *) buf
, "%0*X",
1456 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1457 (unsigned int) glyph
->u
.glyphless
.ch
);
1461 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1462 w32_draw_rectangle (s
->hdc
, s
->gc
,
1463 x
, s
->ybase
- glyph
->ascent
,
1464 glyph
->pixel_width
- 1,
1465 glyph
->ascent
+ glyph
->descent
- 1);
1468 struct font
*font
= s
->font
;
1469 int upper_len
= (len
+ 1) / 2;
1473 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1474 /* It is certain that all LEN characters in STR are ASCII. */
1475 for (j
= 0; j
< len
; j
++)
1477 code
= font
->driver
->encode_char (font
, str
[j
]);
1478 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1480 font
->driver
->draw (s
, 0, upper_len
,
1481 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1482 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1484 font
->driver
->draw (s
, upper_len
, len
,
1485 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1486 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1488 SelectObject (s
->hdc
, old_font
);
1490 x
+= glyph
->pixel_width
;
1495 /* Brightness beyond which a color won't have its highlight brightness
1498 Nominally, highlight colors for `3d' faces are calculated by
1499 brightening an object's color by a constant scale factor, but this
1500 doesn't yield good results for dark colors, so for colors whose
1501 brightness is less than this value (on a scale of 0-255) have to
1502 use an additional additive factor.
1504 The value here is set so that the default menu-bar/mode-line color
1505 (grey75) will not have its highlights changed at all. */
1506 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1509 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1510 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1511 If this produces the same color as COLOR, try a color where all RGB
1512 values have DELTA added. Return the allocated color in *COLOR.
1513 DISPLAY is the X display, CMAP is the colormap to operate on.
1514 Value is non-zero if successful. */
1517 w32_alloc_lighter_color (struct frame
*f
, COLORREF
*color
,
1518 double factor
, int delta
)
1523 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1526 /* Change RGB values by specified FACTOR. Avoid overflow! */
1527 eassert (factor
>= 0);
1528 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1529 min (0xff, factor
* GetGValue (*color
)),
1530 min (0xff, factor
* GetBValue (*color
)));
1532 /* Calculate brightness of COLOR. */
1533 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1534 + GetBValue (*color
)) / 6;
1536 /* We only boost colors that are darker than
1537 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1538 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1539 /* Make an additive adjustment to NEW, because it's dark enough so
1540 that scaling by FACTOR alone isn't enough. */
1542 /* How far below the limit this color is (0 - 1, 1 being darker). */
1543 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1544 /* The additive adjustment. */
1545 int min_delta
= delta
* dimness
* factor
/ 2;
1548 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1549 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1550 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1552 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1553 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1554 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1558 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1559 max (0, min (0xff, delta
+ GetGValue (*color
))),
1560 max (0, min (0xff, delta
+ GetBValue (*color
))));
1562 /* TODO: Map to palette and retry with delta if same? */
1563 /* TODO: Free colors (if using palette)? */
1573 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1574 colors in COLORS. On W32, we no longer try to map colors to
1577 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1581 for (i
= 0; i
< ncolors
; i
++)
1583 DWORD pixel
= colors
[i
].pixel
;
1584 /* Convert to a 16 bit value in range 0 - 0xffff. */
1585 colors
[i
].red
= GetRValue (pixel
) * 257;
1586 colors
[i
].green
= GetGValue (pixel
) * 257;
1587 colors
[i
].blue
= GetBValue (pixel
) * 257;
1592 x_query_color (struct frame
*f
, XColor
*color
)
1594 x_query_colors (f
, color
, 1);
1598 /* Set up the foreground color for drawing relief lines of glyph
1599 string S. RELIEF is a pointer to a struct relief containing the GC
1600 with which lines will be drawn. Use a color that is FACTOR or
1601 DELTA lighter or darker than the relief's background which is found
1602 in S->f->output_data.x->relief_background. If such a color cannot
1603 be allocated, use DEFAULT_PIXEL, instead. */
1606 w32_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
1607 int delta
, COLORREF default_pixel
)
1610 struct w32_output
*di
= f
->output_data
.w32
;
1611 unsigned long mask
= GCForeground
;
1613 COLORREF background
= di
->relief_background
;
1615 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1618 /* TODO: Free colors (if using palette)? */
1620 /* Allocate new color. */
1621 xgcv
.foreground
= default_pixel
;
1623 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1624 xgcv
.foreground
= relief
->pixel
= pixel
;
1626 if (relief
->gc
== 0)
1628 #if 0 /* TODO: stipple */
1629 xgcv
.stipple
= dpyinfo
->gray
;
1632 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1635 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1639 /* Set up colors for the relief lines around glyph string S. */
1642 x_setup_relief_colors (struct glyph_string
*s
)
1644 struct w32_output
*di
= s
->f
->output_data
.w32
;
1647 if (s
->face
->use_box_color_for_shadows_p
)
1648 color
= s
->face
->box_color
;
1649 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1651 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1652 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1654 color
= s
->gc
->background
;
1656 if (di
->white_relief
.gc
== 0
1657 || color
!= di
->relief_background
)
1659 di
->relief_background
= color
;
1660 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1661 WHITE_PIX_DEFAULT (s
->f
));
1662 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1663 BLACK_PIX_DEFAULT (s
->f
));
1668 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1669 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1670 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1671 relief. LEFT_P non-zero means draw a relief on the left side of
1672 the rectangle. RIGHT_P non-zero means draw a relief on the right
1673 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1677 w32_draw_relief_rect (struct frame
*f
,
1678 int left_x
, int top_y
, int right_x
, int bottom_y
,
1679 int width
, int raised_p
,
1680 int top_p
, int bot_p
, int left_p
, int right_p
,
1685 HDC hdc
= get_frame_dc (f
);
1688 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1690 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1692 w32_set_clip_rectangle (hdc
, clip_rect
);
1696 for (i
= 0; i
< width
; ++i
)
1697 w32_fill_area (f
, hdc
, gc
.foreground
,
1698 left_x
+ i
* left_p
, top_y
+ i
,
1699 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1703 for (i
= 0; i
< width
; ++i
)
1704 w32_fill_area (f
, hdc
, gc
.foreground
,
1705 left_x
+ i
, top_y
+ (i
+ 1) * top_p
, 1,
1706 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1709 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1711 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1715 for (i
= 0; i
< width
; ++i
)
1716 w32_fill_area (f
, hdc
, gc
.foreground
,
1717 left_x
+ i
* left_p
, bottom_y
- i
,
1718 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1722 for (i
= 0; i
< width
; ++i
)
1723 w32_fill_area (f
, hdc
, gc
.foreground
,
1724 right_x
- i
, top_y
+ (i
+ 1) * top_p
, 1,
1725 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1727 w32_set_clip_rectangle (hdc
, NULL
);
1729 release_frame_dc (f
, hdc
);
1733 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1734 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1735 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1736 left side of the rectangle. RIGHT_P non-zero means draw a line
1737 on the right side of the rectangle. CLIP_RECT is the clipping
1738 rectangle to use when drawing. */
1741 w32_draw_box_rect (struct glyph_string
*s
,
1742 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1743 bool left_p
, bool right_p
, RECT
*clip_rect
)
1745 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1748 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1749 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1754 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1755 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1759 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1760 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1765 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1766 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1769 w32_set_clip_rectangle (s
->hdc
, NULL
);
1773 /* Draw a box around glyph string S. */
1776 x_draw_glyph_string_box (struct glyph_string
*s
)
1778 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
;
1779 bool left_p
, right_p
, raised_p
;
1780 struct glyph
*last_glyph
;
1783 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1784 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1785 : window_box_right (s
->w
, s
->area
));
1787 /* The glyph that may have a right box line. */
1788 last_glyph
= (s
->cmp
|| s
->img
1790 : s
->first_glyph
+ s
->nchars
- 1);
1792 width
= eabs (s
->face
->box_line_width
);
1793 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1795 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1797 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1799 bottom_y
= top_y
+ s
->height
- 1;
1801 left_p
= (s
->first_glyph
->left_box_line_p
1802 || (s
->hl
== DRAW_MOUSE_FACE
1804 || s
->prev
->hl
!= s
->hl
)));
1805 right_p
= (last_glyph
->right_box_line_p
1806 || (s
->hl
== DRAW_MOUSE_FACE
1808 || s
->next
->hl
!= s
->hl
)));
1810 get_glyph_string_clip_rect (s
, &clip_rect
);
1812 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1813 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1814 left_p
, right_p
, &clip_rect
);
1817 x_setup_relief_colors (s
);
1818 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1819 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1824 /* Draw foreground of image glyph string S. */
1827 x_draw_image_foreground (struct glyph_string
*s
)
1830 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1832 /* If first glyph of S has a left box line, start drawing it to the
1833 right of that line. */
1834 if (s
->face
->box
!= FACE_NO_BOX
1835 && s
->first_glyph
->left_box_line_p
1837 x
+= eabs (s
->face
->box_line_width
);
1839 /* If there is a margin around the image, adjust x- and y-position
1841 if (s
->slice
.x
== 0)
1842 x
+= s
->img
->hmargin
;
1843 if (s
->slice
.y
== 0)
1844 y
+= s
->img
->vmargin
;
1850 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
1851 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1852 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
1853 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1854 SetBkColor (compat_hdc
, RGB (255, 255, 255));
1855 SetTextColor (s
->hdc
, RGB (0, 0, 0));
1856 x_set_glyph_string_clipping (s
);
1860 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
1861 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1863 SetTextColor (s
->hdc
, RGB (255, 255, 255));
1864 SetBkColor (s
->hdc
, RGB (0, 0, 0));
1866 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1867 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1868 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1869 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1870 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1871 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1873 SelectObject (mask_dc
, mask_orig_obj
);
1878 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1879 SetBkColor (s
->hdc
, s
->gc
->background
);
1881 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1882 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1884 /* When the image has a mask, we can expect that at
1885 least part of a mouse highlight or a block cursor will
1886 be visible. If the image doesn't have a mask, make
1887 a block cursor visible by drawing a rectangle around
1888 the image. I believe it's looking better if we do
1889 nothing here for mouse-face. */
1890 if (s
->hl
== DRAW_CURSOR
)
1892 int r
= s
->img
->relief
;
1894 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
1895 s
->slice
.width
+ r
*2 - 1,
1896 s
->slice
.height
+ r
*2 - 1);
1900 w32_set_clip_rectangle (s
->hdc
, NULL
);
1901 SelectObject (s
->hdc
, orig_brush
);
1902 DeleteObject (fg_brush
);
1903 SelectObject (compat_hdc
, orig_obj
);
1904 DeleteDC (compat_hdc
);
1907 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
1908 s
->slice
.width
- 1, s
->slice
.height
- 1);
1910 RestoreDC (s
->hdc
,-1);
1914 /* Draw a relief around the image glyph string S. */
1917 x_draw_image_relief (struct glyph_string
*s
)
1919 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
1920 int extra_x
, extra_y
;
1923 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1925 /* If first glyph of S has a left box line, start drawing it to the
1926 right of that line. */
1927 if (s
->face
->box
!= FACE_NO_BOX
1928 && s
->first_glyph
->left_box_line_p
1930 x
+= eabs (s
->face
->box_line_width
);
1932 /* If there is a margin around the image, adjust x- and y-position
1934 if (s
->slice
.x
== 0)
1935 x
+= s
->img
->hmargin
;
1936 if (s
->slice
.y
== 0)
1937 y
+= s
->img
->vmargin
;
1939 if (s
->hl
== DRAW_IMAGE_SUNKEN
1940 || s
->hl
== DRAW_IMAGE_RAISED
)
1942 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
1943 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
1944 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
1948 thick
= eabs (s
->img
->relief
);
1949 raised_p
= s
->img
->relief
> 0;
1952 x1
= x
+ s
->slice
.width
- 1;
1953 y1
= y
+ s
->slice
.height
- 1;
1955 extra_x
= extra_y
= 0;
1956 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
1958 if (CONSP (Vtool_bar_button_margin
)
1959 && INTEGERP (XCAR (Vtool_bar_button_margin
))
1960 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
1962 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
1963 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
1965 else if (INTEGERP (Vtool_bar_button_margin
))
1966 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
1969 top_p
= bot_p
= left_p
= right_p
= 0;
1971 if (s
->slice
.x
== 0)
1972 x
-= thick
+ extra_x
, left_p
= 1;
1973 if (s
->slice
.y
== 0)
1974 y
-= thick
+ extra_y
, top_p
= 1;
1975 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
1976 x1
+= thick
+ extra_x
, right_p
= 1;
1977 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
1978 y1
+= thick
+ extra_y
, bot_p
= 1;
1980 x_setup_relief_colors (s
);
1981 get_glyph_string_clip_rect (s
, &r
);
1982 w32_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
1983 top_p
, bot_p
, left_p
, right_p
, &r
);
1987 /* Draw the foreground of image glyph string S to PIXMAP. */
1990 w32_draw_image_foreground_1 (struct glyph_string
*s
, HBITMAP pixmap
)
1992 HDC hdc
= CreateCompatibleDC (s
->hdc
);
1993 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
1995 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1997 /* If first glyph of S has a left box line, start drawing it to the
1998 right of that line. */
1999 if (s
->face
->box
!= FACE_NO_BOX
2000 && s
->first_glyph
->left_box_line_p
2002 x
+= eabs (s
->face
->box_line_width
);
2004 /* If there is a margin around the image, adjust x- and y-position
2006 if (s
->slice
.x
== 0)
2007 x
+= s
->img
->hmargin
;
2008 if (s
->slice
.y
== 0)
2009 y
+= s
->img
->vmargin
;
2013 HDC compat_hdc
= CreateCompatibleDC (hdc
);
2014 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2015 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
2016 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2020 HDC mask_dc
= CreateCompatibleDC (hdc
);
2021 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2023 SetTextColor (hdc
, RGB (0, 0, 0));
2024 SetBkColor (hdc
, RGB (255, 255, 255));
2025 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2026 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2027 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2028 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2029 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2030 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2032 SelectObject (mask_dc
, mask_orig_obj
);
2037 SetTextColor (hdc
, s
->gc
->foreground
);
2038 SetBkColor (hdc
, s
->gc
->background
);
2040 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2041 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2043 /* When the image has a mask, we can expect that at
2044 least part of a mouse highlight or a block cursor will
2045 be visible. If the image doesn't have a mask, make
2046 a block cursor visible by drawing a rectangle around
2047 the image. I believe it's looking better if we do
2048 nothing here for mouse-face. */
2049 if (s
->hl
== DRAW_CURSOR
)
2051 int r
= s
->img
->relief
;
2053 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2054 s
->slice
.width
+ r
*2 - 1,
2055 s
->slice
.height
+ r
*2 - 1);
2059 SelectObject (hdc
, orig_brush
);
2060 DeleteObject (fg_brush
);
2061 SelectObject (compat_hdc
, orig_obj
);
2062 DeleteDC (compat_hdc
);
2065 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2066 s
->slice
.width
- 1, s
->slice
.height
- 1);
2068 SelectObject (hdc
, orig_hdc_obj
);
2073 /* Draw part of the background of glyph string S. X, Y, W, and H
2074 give the rectangle to draw. */
2077 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2079 #if 0 /* TODO: stipple */
2082 /* Fill background with a stipple pattern. */
2083 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2084 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), s
->gc
, x
, y
, w
, h
);
2085 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2089 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2093 /* Draw image glyph string S.
2096 s->x +-------------------------
2099 | +-------------------------
2102 | | +-------------------
2108 x_draw_image_glyph_string (struct glyph_string
*s
)
2111 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2112 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2117 if (s
->slice
.y
== 0)
2118 height
-= box_line_vwidth
;
2119 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2120 height
-= box_line_vwidth
;
2122 /* Fill background with face under the image. Do it only if row is
2123 taller than image or if image has a clip mask to reduce
2125 s
->stippled_p
= s
->face
->stipple
!= 0;
2126 if (height
> s
->slice
.height
2130 || s
->img
->pixmap
== 0
2131 || s
->width
!= s
->background_width
)
2133 width
= s
->background_width
;
2135 if (s
->first_glyph
->left_box_line_p
2138 x
+= box_line_hwidth
;
2139 width
-= box_line_hwidth
;
2143 if (s
->slice
.y
== 0)
2144 y
+= box_line_vwidth
;
2146 #if 0 /* TODO: figure out if we need to do this on Windows. */
2149 /* Create a pixmap as large as the glyph string. Fill it
2150 with the background color. Copy the image to it, using
2151 its mask. Copy the temporary pixmap to the display. */
2152 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2153 int depth
= DefaultDepthOfScreen (screen
);
2155 /* Create a pixmap as large as the glyph string. */
2156 pixmap
= XCreatePixmap (s
->display
, FRAME_W32_WINDOW (s
->f
),
2157 s
->background_width
,
2160 /* Don't clip in the following because we're working on the
2162 XSetClipMask (s
->display
, s
->gc
, None
);
2164 /* Fill the pixmap with the background color/stipple. */
2167 /* Fill background with a stipple pattern. */
2168 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2169 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2170 0, 0, s
->background_width
, s
->height
);
2171 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2176 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2178 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2179 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2180 0, 0, s
->background_width
, s
->height
);
2181 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2186 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
2188 s
->background_filled_p
= true;
2191 /* Draw the foreground. */
2194 w32_draw_image_foreground_1 (s
, pixmap
);
2195 x_set_glyph_string_clipping (s
);
2197 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2198 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2199 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2200 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2202 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2203 SetBkColor (s
->hdc
, s
->gc
->background
);
2204 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2205 compat_hdc
, 0, 0, SRCCOPY
);
2207 SelectObject (s
->hdc
, orig_brush
);
2208 DeleteObject (fg_brush
);
2209 SelectObject (compat_hdc
, orig_obj
);
2210 DeleteDC (compat_hdc
);
2212 DeleteObject (pixmap
);
2216 x_draw_image_foreground (s
);
2218 /* If we must draw a relief around the image, do it. */
2220 || s
->hl
== DRAW_IMAGE_RAISED
2221 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2222 x_draw_image_relief (s
);
2226 /* Draw stretch glyph string S. */
2229 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2231 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2233 if (s
->hl
== DRAW_CURSOR
2234 && !x_stretch_cursor_p
)
2236 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2237 wide as the stretch glyph. */
2238 int width
, background_width
= s
->background_width
;
2241 if (!s
->row
->reversed_p
)
2243 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2247 background_width
-= left_x
- x
;
2253 /* In R2L rows, draw the cursor on the right edge of the
2255 int right_x
= window_box_right (s
->w
, TEXT_AREA
);
2257 if (x
+ background_width
> right_x
)
2258 background_width
-= x
- right_x
;
2259 x
+= background_width
;
2261 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2262 if (s
->row
->reversed_p
)
2266 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2268 /* Clear rest using the GC of the original non-cursor face. */
2269 if (width
< background_width
)
2271 XGCValues
*gc
= s
->face
->gc
;
2273 int w
= background_width
- width
, h
= s
->height
;
2277 if (!s
->row
->reversed_p
)
2281 if (s
->row
->mouse_face_p
2282 && cursor_in_mouse_face_p (s
->w
))
2284 x_set_mouse_face_gc (s
);
2290 get_glyph_string_clip_rect (s
, &r
);
2291 w32_set_clip_rectangle (hdc
, &r
);
2293 #if 0 /* TODO: stipple */
2294 if (s
->face
->stipple
)
2296 /* Fill background with a stipple pattern. */
2297 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2298 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), gc
, x
, y
, w
, h
);
2299 XSetFillStyle (s
->display
, gc
, FillSolid
);
2304 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2308 else if (!s
->background_filled_p
)
2310 int background_width
= s
->background_width
;
2311 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2313 /* Don't draw into left margin, fringe or scrollbar area
2314 except for header line and mode line. */
2315 if (x
< left_x
&& !s
->row
->mode_line_p
)
2317 background_width
-= left_x
- x
;
2320 if (background_width
> 0)
2321 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2324 s
->background_filled_p
= true;
2328 /* Draw glyph string S. */
2331 x_draw_glyph_string (struct glyph_string
*s
)
2333 bool relief_drawn_p
= 0;
2335 /* If S draws into the background of its successor, draw the
2336 background of the successor first so that S can draw into it.
2337 This makes S->next use XDrawString instead of XDrawImageString. */
2338 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2341 struct glyph_string
*next
;
2342 for (width
= 0, next
= s
->next
;
2343 next
&& width
< s
->right_overhang
;
2344 width
+= next
->width
, next
= next
->next
)
2345 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2347 x_set_glyph_string_gc (next
);
2348 x_set_glyph_string_clipping (next
);
2349 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2350 x_draw_stretch_glyph_string (next
);
2352 x_draw_glyph_string_background (next
, true);
2353 next
->num_clips
= 0;
2357 /* Set up S->gc, set clipping and draw S. */
2358 x_set_glyph_string_gc (s
);
2360 /* Draw relief (if any) in advance for char/composition so that the
2361 glyph string can be drawn over it. */
2362 if (!s
->for_overlaps
2363 && s
->face
->box
!= FACE_NO_BOX
2364 && (s
->first_glyph
->type
== CHAR_GLYPH
2365 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2368 x_set_glyph_string_clipping (s
);
2369 x_draw_glyph_string_background (s
, true);
2370 x_draw_glyph_string_box (s
);
2371 x_set_glyph_string_clipping (s
);
2374 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2376 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2377 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2378 /* We must clip just this glyph. left_overhang part has already
2379 drawn when s->prev was drawn, and right_overhang part will be
2380 drawn later when s->next is drawn. */
2381 x_set_glyph_string_clipping_exactly (s
, s
);
2383 x_set_glyph_string_clipping (s
);
2385 switch (s
->first_glyph
->type
)
2388 x_draw_image_glyph_string (s
);
2392 x_draw_stretch_glyph_string (s
);
2396 if (s
->for_overlaps
)
2397 s
->background_filled_p
= true;
2399 x_draw_glyph_string_background (s
, false);
2400 x_draw_glyph_string_foreground (s
);
2403 case COMPOSITE_GLYPH
:
2404 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2405 && ! s
->first_glyph
->u
.cmp
.automatic
))
2406 s
->background_filled_p
= true;
2408 x_draw_glyph_string_background (s
, true);
2409 x_draw_composite_glyph_string_foreground (s
);
2412 case GLYPHLESS_GLYPH
:
2413 if (s
->for_overlaps
)
2414 s
->background_filled_p
= true;
2416 x_draw_glyph_string_background (s
, false);
2417 x_draw_glyphless_glyph_string_foreground (s
);
2424 if (!s
->for_overlaps
)
2426 /* Draw underline. */
2427 if (s
->face
->underline_p
)
2429 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2433 if (s
->face
->underline_defaulted_p
)
2434 color
= s
->gc
->foreground
;
2436 color
= s
->face
->underline_color
;
2438 w32_draw_underwave (s
, color
);
2440 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2442 unsigned long thickness
, position
;
2445 if (s
->prev
&& s
->prev
->face
->underline_p
2446 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2448 /* We use the same underline style as the previous one. */
2449 thickness
= s
->prev
->underline_thickness
;
2450 position
= s
->prev
->underline_position
;
2454 struct font
*font
= font_for_underline_metrics (s
);
2456 /* Get the underline thickness. Default is 1 pixel. */
2457 if (font
&& font
->underline_thickness
> 0)
2458 thickness
= font
->underline_thickness
;
2461 if (x_underline_at_descent_line
|| !font
)
2462 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2465 /* Get the underline position. This is the recommended
2466 vertical offset in pixels from the baseline to the top of
2467 the underline. This is a signed value according to the
2468 specs, and its default is
2470 ROUND ((maximum_descent) / 2), with
2471 ROUND (x) = floor (x + 0.5) */
2473 if (x_use_underline_position_properties
2474 && font
->underline_position
>= 0)
2475 position
= font
->underline_position
;
2477 position
= (font
->descent
+ 1) / 2;
2479 position
= max (position
, underline_minimum_offset
);
2481 /* Check the sanity of thickness and position. We should
2482 avoid drawing underline out of the current line area. */
2483 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2484 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2485 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2486 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2487 s
->underline_thickness
= thickness
;
2488 s
->underline_position
= position
;
2489 y
= s
->ybase
+ position
;
2490 if (s
->face
->underline_defaulted_p
)
2492 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2497 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2502 /* Draw overline. */
2503 if (s
->face
->overline_p
)
2505 unsigned long dy
= 0, h
= 1;
2507 if (s
->face
->overline_color_defaulted_p
)
2509 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2510 s
->y
+ dy
, s
->width
, h
);
2514 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2515 s
->y
+ dy
, s
->width
, h
);
2519 /* Draw strike-through. */
2520 if (s
->face
->strike_through_p
2521 && !FONT_TEXTMETRIC (s
->font
).tmStruckOut
)
2523 /* Y-coordinate and height of the glyph string's first
2524 glyph. We cannot use s->y and s->height because those
2525 could be larger if there are taller display elements
2526 (e.g., characters displayed with a larger font) in the
2528 int glyph_y
= s
->ybase
- s
->first_glyph
->ascent
;
2529 int glyph_height
= s
->first_glyph
->ascent
+ s
->first_glyph
->descent
;
2530 /* Strike-through width and offset from the glyph string's
2532 unsigned long h
= 1;
2533 unsigned long dy
= (glyph_height
- h
) / 2;
2535 if (s
->face
->strike_through_color_defaulted_p
)
2537 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2538 glyph_y
+ dy
, s
->width
, h
);
2542 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2543 glyph_y
+ dy
, s
->width
, h
);
2547 /* Draw relief if not yet drawn. */
2548 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2549 x_draw_glyph_string_box (s
);
2553 struct glyph_string
*prev
;
2555 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2556 if (prev
->hl
!= s
->hl
2557 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2559 /* As prev was drawn while clipped to its own area, we
2560 must draw the right_overhang part using s->hl now. */
2561 enum draw_glyphs_face save
= prev
->hl
;
2564 x_set_glyph_string_gc (prev
);
2565 x_set_glyph_string_clipping_exactly (s
, prev
);
2566 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2567 x_draw_glyph_string_foreground (prev
);
2569 x_draw_composite_glyph_string_foreground (prev
);
2570 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2572 prev
->num_clips
= 0;
2578 struct glyph_string
*next
;
2580 for (next
= s
->next
; next
; next
= next
->next
)
2581 if (next
->hl
!= s
->hl
2582 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2584 /* As next will be drawn while clipped to its own area,
2585 we must draw the left_overhang part using s->hl now. */
2586 enum draw_glyphs_face save
= next
->hl
;
2589 x_set_glyph_string_gc (next
);
2590 x_set_glyph_string_clipping_exactly (s
, next
);
2591 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2592 x_draw_glyph_string_foreground (next
);
2594 x_draw_composite_glyph_string_foreground (next
);
2595 w32_set_clip_rectangle (next
->hdc
, NULL
);
2597 next
->num_clips
= 0;
2598 next
->clip_head
= s
->next
;
2603 /* Reset clipping. */
2604 w32_set_clip_rectangle (s
->hdc
, NULL
);
2609 /* Shift display to make room for inserted glyphs. */
2612 w32_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
,
2613 int width
, int height
, int shift_by
)
2617 hdc
= get_frame_dc (f
);
2618 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2619 hdc
, x
, y
, SRCCOPY
);
2621 release_frame_dc (f
, hdc
);
2625 /* Delete N glyphs at the nominal cursor position. Not implemented
2629 x_delete_glyphs (struct frame
*f
, register int n
)
2631 if (! FRAME_W32_P (f
))
2638 /* Clear entire frame. */
2641 x_clear_frame (struct frame
*f
)
2643 if (! FRAME_W32_P (f
))
2646 /* Clearing the frame will erase any cursor, so mark them all as no
2648 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2652 w32_clear_window (f
);
2654 /* We have to clear the scroll bars, too. If we have changed
2655 colors or something like that, then they should be notified. */
2656 x_scroll_bar_clear (f
);
2662 /* Make audible bell. */
2665 w32_ring_bell (struct frame
*f
)
2669 if (FRAME_W32_P (f
) && visible_bell
)
2672 HWND hwnd
= FRAME_W32_WINDOW (f
);
2674 for (i
= 0; i
< 5; i
++)
2676 FlashWindow (hwnd
, TRUE
);
2679 FlashWindow (hwnd
, FALSE
);
2682 w32_sys_ring_bell (f
);
2687 /***********************************************************************
2689 ***********************************************************************/
2691 /* Perform an insert-lines or delete-lines operation, inserting N
2692 lines or deleting -N lines at vertical position VPOS. */
2695 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
2697 if (! FRAME_W32_P (f
))
2704 /* Scroll part of the display as described by RUN. */
2707 x_scroll_run (struct window
*w
, struct run
*run
)
2709 struct frame
*f
= XFRAME (w
->frame
);
2710 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2711 HWND hwnd
= FRAME_W32_WINDOW (f
);
2714 /* Get frame-relative bounding box of the text display area of W,
2715 without mode lines. Include in this box the left and right
2717 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
2719 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2720 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2721 bottom_y
= y
+ height
;
2725 /* Scrolling up. Make sure we don't copy part of the mode
2726 line at the bottom. */
2727 if (from_y
+ run
->height
> bottom_y
)
2728 height
= bottom_y
- from_y
;
2730 height
= run
->height
;
2731 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2735 /* Scrolling down. Make sure we don't copy over the mode line.
2737 if (to_y
+ run
->height
> bottom_y
)
2738 height
= bottom_y
- to_y
;
2740 height
= run
->height
;
2741 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2746 /* Cursor off. Will be switched on again in x_update_window_end. */
2752 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2753 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2755 from
.left
= to
.left
= x
;
2756 from
.right
= to
.right
= x
+ width
;
2758 from
.bottom
= from_y
+ height
;
2760 to
.bottom
= bottom_y
;
2762 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2763 NULL
, SW_INVALIDATE
);
2765 /* Combine this with what we expect to be dirty. This covers the
2766 case where not all of the region we expect is actually dirty. */
2767 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2769 /* If the dirty region is not what we expected, redraw the entire frame. */
2770 if (!EqualRgn (combined
, expect_dirty
))
2771 SET_FRAME_GARBAGED (f
);
2773 DeleteObject (dirty
);
2774 DeleteObject (combined
);
2778 DeleteObject (expect_dirty
);
2783 /***********************************************************************
2785 ***********************************************************************/
2788 frame_highlight (struct frame
*f
)
2790 x_update_cursor (f
, 1);
2791 x_set_frame_alpha (f
);
2795 frame_unhighlight (struct frame
*f
)
2797 x_update_cursor (f
, 1);
2798 x_set_frame_alpha (f
);
2801 /* The focus has changed. Update the frames as necessary to reflect
2802 the new situation. Note that we can't change the selected frame
2803 here, because the Lisp code we are interrupting might become confused.
2804 Each event gets marked with the frame in which it occurred, so the
2805 Lisp code can tell when the switch took place by examining the events. */
2808 x_new_focus_frame (struct w32_display_info
*dpyinfo
, struct frame
*frame
)
2810 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2812 if (frame
!= dpyinfo
->w32_focus_frame
)
2814 /* Set this before calling other routines, so that they see
2815 the correct value of w32_focus_frame. */
2816 dpyinfo
->w32_focus_frame
= frame
;
2818 if (old_focus
&& old_focus
->auto_lower
)
2819 x_lower_frame (old_focus
);
2821 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2822 dpyinfo
->w32_pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2824 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
2827 x_frame_rehighlight (dpyinfo
);
2831 /* Handle FocusIn and FocusOut state changes for FRAME.
2832 If FRAME has focus and there exists more than one frame, puts
2833 a FOCUS_IN_EVENT into *BUFP. */
2836 x_focus_changed (int type
, int state
, struct w32_display_info
*dpyinfo
,
2837 struct frame
*frame
, struct input_event
*bufp
)
2839 if (type
== WM_SETFOCUS
)
2841 if (dpyinfo
->w32_focus_event_frame
!= frame
)
2843 x_new_focus_frame (dpyinfo
, frame
);
2844 dpyinfo
->w32_focus_event_frame
= frame
;
2846 /* Don't stop displaying the initial startup message
2847 for a switch-frame event we don't need. */
2848 if (NILP (Vterminal_frame
)
2849 && CONSP (Vframe_list
)
2850 && !NILP (XCDR (Vframe_list
)))
2859 bufp
->kind
= FOCUS_IN_EVENT
;
2860 XSETFRAME (bufp
->frame_or_window
, frame
);
2863 frame
->output_data
.x
->focus_state
|= state
;
2865 /* TODO: IME focus? */
2867 else if (type
== WM_KILLFOCUS
)
2869 frame
->output_data
.x
->focus_state
&= ~state
;
2871 if (dpyinfo
->w32_focus_event_frame
== frame
)
2873 dpyinfo
->w32_focus_event_frame
= 0;
2874 x_new_focus_frame (dpyinfo
, 0);
2876 bufp
->kind
= FOCUS_OUT_EVENT
;
2877 XSETFRAME (bufp
->frame_or_window
, frame
);
2880 /* TODO: IME focus? */
2885 /* The focus may have changed. Figure out if it is a real focus change,
2886 by checking both FocusIn/Out and Enter/LeaveNotify events.
2888 Returns FOCUS_IN_EVENT event in *BUFP. */
2891 w32_detect_focus_change (struct w32_display_info
*dpyinfo
, W32Msg
*event
,
2892 struct input_event
*bufp
)
2894 struct frame
*frame
;
2896 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
2900 /* On w32, this is only called from focus events, so no switch needed. */
2901 x_focus_changed (event
->msg
.message
,
2902 (event
->msg
.message
== WM_KILLFOCUS
?
2903 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
2904 dpyinfo
, frame
, bufp
);
2909 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2912 x_mouse_leave (struct w32_display_info
*dpyinfo
)
2914 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2918 /* The focus has changed, or we have redirected a frame's focus to
2919 another frame (this happens when a frame uses a surrogate
2920 mini-buffer frame). Shift the highlight as appropriate.
2922 The FRAME argument doesn't necessarily have anything to do with which
2923 frame is being highlighted or un-highlighted; we only use it to find
2924 the appropriate X display info. */
2927 w32_frame_rehighlight (struct frame
*frame
)
2929 if (! FRAME_W32_P (frame
))
2931 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
2935 x_frame_rehighlight (struct w32_display_info
*dpyinfo
)
2937 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2939 if (dpyinfo
->w32_focus_frame
)
2941 dpyinfo
->x_highlight_frame
2942 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2943 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2944 : dpyinfo
->w32_focus_frame
);
2945 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
2947 fset_focus_frame (dpyinfo
->w32_focus_frame
, Qnil
);
2948 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
2952 dpyinfo
->x_highlight_frame
= 0;
2954 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
2957 frame_unhighlight (old_highlight
);
2958 if (dpyinfo
->x_highlight_frame
)
2959 frame_highlight (dpyinfo
->x_highlight_frame
);
2963 /* Keyboard processing - modifier keys, etc. */
2965 /* Convert a keysym to its name. */
2968 x_get_keysym_name (int keysym
)
2970 /* Make static so we can always return it */
2971 static char value
[100];
2974 GetKeyNameText (keysym
, value
, 100);
2981 codepage_for_locale (LCID locale
)
2985 if (GetLocaleInfo (locale
, LOCALE_IDEFAULTANSICODEPAGE
, cp
, 20) > 0)
2992 /* Mouse clicks and mouse movement. Rah. */
2994 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2995 the state in PUP. XBUTTON provides extra information for extended mouse
2996 button messages. Returns FALSE if unable to parse the message. */
2998 parse_button (int message
, int xbutton
, int * pbutton
, int * pup
)
3005 case WM_LBUTTONDOWN
:
3013 case WM_MBUTTONDOWN
:
3014 if (NILP (Vw32_swap_mouse_buttons
))
3021 if (NILP (Vw32_swap_mouse_buttons
))
3027 case WM_RBUTTONDOWN
:
3028 if (NILP (Vw32_swap_mouse_buttons
))
3035 if (NILP (Vw32_swap_mouse_buttons
))
3041 case WM_XBUTTONDOWN
:
3042 button
= xbutton
+ 2;
3046 button
= xbutton
+ 2;
3054 if (pbutton
) *pbutton
= button
;
3060 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3062 If the event is a button press, then note that we have grabbed
3066 construct_mouse_click (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3071 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3074 /* Make the event type NO_EVENT; we'll change that when we decide
3076 result
->kind
= MOUSE_CLICK_EVENT
;
3077 result
->code
= button
;
3078 result
->timestamp
= msg
->msg
.time
;
3079 result
->modifiers
= (msg
->dwModifiers
3084 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3085 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3086 XSETFRAME (result
->frame_or_window
, f
);
3092 construct_mouse_wheel (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3097 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3100 result
->timestamp
= msg
->msg
.time
;
3102 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3103 forward, away from the user (up); a negative value indicates that
3104 the wheel was rotated backward, toward the user (down). */
3105 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3107 /* The up and down modifiers indicate if the wheel was rotated up or
3108 down based on WHEEL_DELTA value. */
3109 result
->modifiers
= (msg
->dwModifiers
3110 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3112 /* With multiple monitors, we can legitimately get negative
3113 coordinates, so cast to short to interpret them correctly. */
3114 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3115 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3116 /* For the case that F's w32 window is not msg->msg.hwnd. */
3117 ScreenToClient (FRAME_W32_WINDOW (f
), &p
);
3118 XSETINT (result
->x
, p
.x
);
3119 XSETINT (result
->y
, p
.y
);
3120 XSETFRAME (result
->frame_or_window
, f
);
3126 construct_drag_n_drop (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3133 wchar_t name_w
[MAX_PATH
];
3134 #ifdef NTGUI_UNICODE
3135 const int use_unicode
= 1;
3137 int use_unicode
= w32_unicode_filenames
;
3138 char name_a
[MAX_PATH
];
3139 char file
[MAX_UTF8_PATH
];
3143 result
->kind
= DRAG_N_DROP_EVENT
;
3145 result
->timestamp
= msg
->msg
.time
;
3146 result
->modifiers
= msg
->dwModifiers
;
3148 hdrop
= (HDROP
) msg
->msg
.wParam
;
3149 DragQueryPoint (hdrop
, &p
);
3152 p
.x
= LOWORD (msg
->msg
.lParam
);
3153 p
.y
= HIWORD (msg
->msg
.lParam
);
3154 ScreenToClient (msg
->msg
.hwnd
, &p
);
3157 XSETINT (result
->x
, p
.x
);
3158 XSETINT (result
->y
, p
.y
);
3160 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3163 for (i
= 0; i
< num_files
; i
++)
3167 eassert (DragQueryFileW (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3168 /* If DragQueryFile returns zero, it failed to fetch a file
3170 if (DragQueryFileW (hdrop
, i
, name_w
, MAX_PATH
) == 0)
3172 #ifdef NTGUI_UNICODE
3173 files
= Fcons (from_unicode_buffer (name_w
), files
);
3175 filename_from_utf16 (name_w
, file
);
3176 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3177 #endif /* NTGUI_UNICODE */
3179 #ifndef NTGUI_UNICODE
3182 eassert (DragQueryFileA (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3183 if (DragQueryFileA (hdrop
, i
, name_a
, MAX_PATH
) == 0)
3185 filename_from_ansi (name_a
, file
);
3186 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3193 XSETFRAME (frame
, f
);
3194 result
->frame_or_window
= frame
;
3195 result
->arg
= files
;
3202 /* File event notifications (see w32notify.c). */
3205 lispy_file_action (DWORD action
)
3207 static char unknown_fmt
[] = "unknown-action(%d)";
3212 case FILE_ACTION_ADDED
:
3215 case FILE_ACTION_REMOVED
:
3218 case FILE_ACTION_MODIFIED
:
3221 case FILE_ACTION_RENAMED_OLD_NAME
:
3222 retval
= Qrenamed_from
;
3224 case FILE_ACTION_RENAMED_NEW_NAME
:
3225 retval
= Qrenamed_to
;
3229 char buf
[sizeof(unknown_fmt
) - 1 + INT_STRLEN_BOUND (DWORD
)];
3231 sprintf (buf
, unknown_fmt
, action
);
3232 retval
= intern (buf
);
3241 /* Put file notifications into the Emacs input event queue. This
3242 function runs when the WM_EMACS_FILENOTIFY message arrives from a
3245 queue_notifications (struct input_event
*event
, W32Msg
*msg
, struct frame
*f
,
3248 struct notifications_set
*ns
= NULL
;
3252 /* We cannot process notification before Emacs is fully initialized,
3253 since we need the UTF-16LE coding-system to be set up. */
3257 XSETFRAME (frame
, f
);
3263 /* Find out if there is a record available in the linked list of
3264 notifications sets. If so, unlink the set from the linked
3265 list. Use critical section. */
3267 if (notifications_set_head
->next
!= notifications_set_head
)
3269 ns
= notifications_set_head
->next
;
3270 ns
->prev
->next
= ns
->next
;
3271 ns
->next
->prev
= ns
->prev
;
3279 BYTE
*p
= ns
->notifications
;
3280 FILE_NOTIFY_INFORMATION
*fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3281 const DWORD min_size
3282 = offsetof (FILE_NOTIFY_INFORMATION
, FileName
) + sizeof(wchar_t);
3283 DWORD info_size
= ns
->size
;
3284 Lisp_Object cs
= Qutf_16le
;
3285 Lisp_Object obj
= w32_get_watch_object (ns
->desc
);
3287 /* notifications size could be zero when the buffer of
3288 notifications overflowed on the OS level, or when the
3289 directory being watched was itself deleted. Do nothing in
3292 && !NILP (obj
) && CONSP (obj
))
3294 Lisp_Object callback
= XCDR (obj
);
3296 while (info_size
>= min_size
)
3298 Lisp_Object utf_16_fn
3299 = make_unibyte_string ((char *)fni
->FileName
,
3300 fni
->FileNameLength
);
3301 /* Note: mule-conf is preloaded, so utf-16le must
3302 already be defined at this point. */
3304 = code_convert_string_norecord (utf_16_fn
, cs
, 0);
3305 Lisp_Object action
= lispy_file_action (fni
->Action
);
3307 event
->kind
= FILE_NOTIFY_EVENT
;
3308 event
->timestamp
= msg
->msg
.time
;
3309 event
->modifiers
= 0;
3310 event
->frame_or_window
= callback
;
3311 event
->arg
= list3 (make_pointer_integer (ns
->desc
),
3313 kbd_buffer_store_event (event
);
3315 if (!fni
->NextEntryOffset
)
3317 p
+= fni
->NextEntryOffset
;
3318 fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3319 info_size
-= fni
->NextEntryOffset
;
3322 /* Free this notifications set. */
3323 xfree (ns
->notifications
);
3327 /* We've stuffed all the events ourselves, so w32_read_socket shouldn't. */
3328 event
->kind
= NO_EVENT
;
3330 #endif /* WINDOWSNT */
3331 #endif /* HAVE_W32NOTIFY */
3334 /* Function to report a mouse movement to the mainstream Emacs code.
3335 The input handler calls this.
3337 We have received a mouse movement event, which is given in *event.
3338 If the mouse is over a different glyph than it was last time, tell
3339 the mainstream emacs code by setting mouse_moved. If not, ask for
3340 another motion event, so we can check again the next time it moves. */
3343 note_mouse_movement (struct frame
*frame
, MSG
*msg
)
3345 struct w32_display_info
*dpyinfo
;
3346 int mouse_x
= LOWORD (msg
->lParam
);
3347 int mouse_y
= HIWORD (msg
->lParam
);
3350 if (!FRAME_X_OUTPUT (frame
))
3353 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
3354 dpyinfo
->last_mouse_movement_time
= msg
->time
;
3355 dpyinfo
->last_mouse_motion_frame
= frame
;
3356 dpyinfo
->last_mouse_motion_x
= mouse_x
;
3357 dpyinfo
->last_mouse_motion_y
= mouse_y
;
3359 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3361 frame
->mouse_moved
= true;
3362 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3363 note_mouse_highlight (frame
, -1, -1);
3364 dpyinfo
->last_mouse_glyph_frame
= NULL
;
3368 /* Has the mouse moved off the glyph it was on at the last sighting? */
3369 r
= &dpyinfo
->last_mouse_glyph
;
3370 if (frame
!= dpyinfo
->last_mouse_glyph_frame
3371 || mouse_x
< r
->left
|| mouse_x
>= r
->right
3372 || mouse_y
< r
->top
|| mouse_y
>= r
->bottom
)
3374 frame
->mouse_moved
= true;
3375 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3376 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3377 /* Remember the mouse position here, as w32_mouse_position only
3378 gets called when mouse tracking is enabled but we also need
3379 to keep track of the mouse for help_echo and highlighting at
3381 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, r
);
3382 dpyinfo
->last_mouse_glyph_frame
= frame
;
3390 /************************************************************************
3392 ************************************************************************/
3394 static struct scroll_bar
*x_window_to_scroll_bar (Window
, int);
3395 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3396 enum scroll_bar_part
*,
3397 Lisp_Object
*, Lisp_Object
*,
3399 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3400 enum scroll_bar_part
*,
3401 Lisp_Object
*, Lisp_Object
*,
3404 w32_define_cursor (Window window
, Cursor cursor
)
3406 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3409 /* Return the current position of the mouse.
3410 *fp should be a frame which indicates which display to ask about.
3412 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3413 and *part to the frame, window, and scroll bar part that the mouse
3414 is over. Set *x and *y to the portion and whole of the mouse's
3415 position on the scroll bar.
3417 If the mouse movement started elsewhere, set *fp to the frame the
3418 mouse is on, *bar_window to nil, and *x and *y to the character cell
3421 Set *time to the server time-stamp for the time at which the mouse
3422 was at this position.
3424 Don't store anything if we don't have a valid set of values to report.
3426 This clears the mouse_moved flag, so we can wait for the next mouse
3430 w32_mouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
3431 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
3434 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
3438 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
3440 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
3442 if (bar
->horizontal
)
3443 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3445 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3450 Lisp_Object frame
, tail
;
3451 struct frame
*f1
= NULL
;
3453 /* Clear the mouse-moved flag for every frame on this display. */
3454 FOR_EACH_FRAME (tail
, frame
)
3455 XFRAME (frame
)->mouse_moved
= false;
3457 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3461 /* Now we have a position on the root; find the innermost window
3462 containing the pointer. */
3464 /* If mouse was grabbed on a frame, give coords for that
3465 frame even if the mouse is now outside it. Otherwise
3466 check for window under mouse on one of our frames. */
3467 if (x_mouse_grabbed (dpyinfo
))
3468 f1
= dpyinfo
->last_mouse_frame
;
3471 HWND wfp
= WindowFromPoint (pt
);
3475 f1
= x_any_window_to_frame (dpyinfo
, wfp
);
3478 HWND cwfp
= ChildWindowFromPoint (wfp
, pt
);
3482 struct frame
*f2
= x_any_window_to_frame (dpyinfo
, cwfp
);
3484 /* If a child window was found, make sure that its
3485 frame is a child frame (Bug#26615, maybe). */
3486 if (f2
&& FRAME_PARENT_FRAME (f2
))
3493 /* If not, is it one of our scroll bars? */
3496 struct scroll_bar
*bar
3497 = x_window_to_scroll_bar (WindowFromPoint (pt
), 2);
3500 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3503 if (f1
== 0 && insist
> 0)
3504 f1
= SELECTED_FRAME ();
3508 /* Ok, we found a frame. Store all the values.
3509 last_mouse_glyph is a rectangle used to reduce the
3510 generation of mouse events. To not miss any motion
3511 events, we must divide the frame into rectangles of the
3512 size of the smallest character that could be displayed
3513 on it, i.e. into the same rectangles that matrices on
3514 the frame are divided into. */
3516 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
3517 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3518 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &dpyinfo
->last_mouse_glyph
);
3519 dpyinfo
->last_mouse_glyph_frame
= f1
;
3522 *part
= scroll_bar_above_handle
;
3526 *time
= dpyinfo
->last_mouse_movement_time
;
3535 /***********************************************************************
3537 ***********************************************************************/
3539 /* Handle mouse button event on the tool-bar of frame F, at
3540 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
3541 or ButtonRelease. */
3544 w32_handle_tool_bar_click (struct frame
*f
, struct input_event
*button_event
)
3546 int x
= XFASTINT (button_event
->x
);
3547 int y
= XFASTINT (button_event
->y
);
3549 if (button_event
->modifiers
& down_modifier
)
3550 handle_tool_bar_click (f
, x
, y
, 1, 0);
3552 handle_tool_bar_click (f
, x
, y
, 0,
3553 button_event
->modifiers
& ~up_modifier
);
3558 /***********************************************************************
3560 ***********************************************************************/
3562 /* Scroll bar support. */
3564 /* Given a window ID, find the struct scroll_bar which manages it
3565 vertically. This can be called in GC, so we have to make sure to
3566 strip off mark bits. */
3568 static struct scroll_bar
*
3569 x_window_to_scroll_bar (Window window_id
, int type
)
3571 Lisp_Object tail
, frame
;
3573 FOR_EACH_FRAME (tail
, frame
)
3575 Lisp_Object bar
, condemned
;
3577 /* Scan this frame's scroll bar list for a scroll bar with the
3579 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3580 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3581 /* This trick allows us to search both the ordinary and
3582 condemned scroll bar lists with one loop. */
3583 ! NILP (bar
) || (bar
= condemned
,
3586 bar
= XSCROLL_BAR (bar
)->next
)
3587 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
3589 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
3590 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
3591 return XSCROLL_BAR (bar
);
3599 /* Set the thumb size and position of vertical scroll bar BAR. We are currently
3600 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3603 w32_set_scroll_bar_thumb (struct scroll_bar
*bar
,
3604 int portion
, int position
, int whole
)
3606 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3607 /* We use the whole scroll-bar height in the calculations below, to
3608 avoid strange effects like scrolling backwards when just clicking
3609 on the handle (without moving it). */
3610 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
)
3611 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3612 int sb_page
, sb_pos
;
3613 BOOL draggingp
= bar
->dragging
? TRUE
: FALSE
;
3616 /* We used to change the nPage setting while dragging the handle,
3617 but that had very strange effects (such as scrolling backwards
3618 while dragging downwards).
3620 Now, we don't change the nPage setting while dragging unless we
3621 get near to the end of the buffer, in which case we often have to
3622 resize the handle to "go all the way". */
3628 si
.cbSize
= sizeof (si
);
3629 si
.fMask
= SIF_POS
| SIF_PAGE
;
3630 GetScrollInfo (w
, SB_CTL
, &si
);
3631 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3639 /* Position scroll bar at rock bottom if the bottom of the
3640 buffer is visible. This avoids shrinking the thumb away
3641 to nothing if it is held at the bottom of the buffer. */
3642 if (position
+ portion
>= whole
&& !draggingp
)
3644 sb_page
= range
* (whole
- position
) / whole
;
3649 sb_pos
= position
* range
/ whole
;
3650 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3659 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3663 si
.cbSize
= sizeof (si
);
3664 si
.fMask
= SIF_PAGE
| SIF_POS
;
3668 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3673 /* Set the thumb size and position of horizontal scroll bar BAR. We are currently
3674 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3677 w32_set_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
3678 int portion
, int position
, int whole
)
3680 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3685 si
.cbSize
= sizeof (si
);
3686 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
3689 /* Allow nPage to be one larger than nPos so we don't allow the scrolling
3690 of an already fully visible buffer. */
3691 si
.nPage
= min (portion
, si
.nMax
) + 1;
3692 si
.nPos
= min (position
, si
.nMax
);
3693 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3699 /************************************************************************
3700 Scroll bars, general
3701 ************************************************************************/
3704 my_create_vscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3706 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3707 WM_EMACS_CREATEVSCROLLBAR
, (WPARAM
) f
,
3712 my_create_hscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3714 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3715 WM_EMACS_CREATEHSCROLLBAR
, (WPARAM
) f
,
3719 /*#define ATTACH_THREADS*/
3722 my_show_window (struct frame
*f
, HWND hwnd
, int how
)
3724 #ifndef ATTACH_THREADS
3725 return SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3726 (WPARAM
) hwnd
, (LPARAM
) how
, 0, 6000, NULL
);
3728 return ShowWindow (hwnd
, how
);
3733 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3734 int x
, int y
, int cx
, int cy
, UINT flags
)
3736 #ifndef ATTACH_THREADS
3738 pos
.hwndInsertAfter
= hwndAfter
;
3744 SendMessageTimeout (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0,
3747 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3753 my_set_focus (struct frame
* f
, HWND hwnd
)
3755 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3756 (WPARAM
) hwnd
, 0, 0, 6000, NULL
);
3761 my_set_foreground_window (HWND hwnd
)
3763 SendMessageTimeout (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0,
3769 my_destroy_window (struct frame
* f
, HWND hwnd
)
3771 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3772 (WPARAM
) hwnd
, 0, 0, 6000, NULL
);
3776 my_bring_window_to_top (HWND hwnd
)
3778 SendMessageTimeout (hwnd
, WM_EMACS_BRINGTOTOP
, (WPARAM
) hwnd
, 0,
3782 /* Create a scroll bar and return the scroll bar vector for it. W is
3783 the Emacs window on which to create the scroll bar. TOP, LEFT,
3784 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
3787 static struct scroll_bar
*
3788 x_scroll_bar_create (struct window
*w
, int left
, int top
, int width
, int height
, bool horizontal
)
3790 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3793 struct scroll_bar
*bar
3794 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, top
, PVEC_OTHER
);
3799 XSETWINDOW (bar
->window
, w
);
3803 bar
->height
= height
;
3807 bar
->horizontal
= horizontal
;
3809 /* Requires geometry to be set before call to create the real window */
3812 hwnd
= my_create_hscrollbar (f
, bar
);
3814 hwnd
= my_create_vscrollbar (f
, bar
);
3816 si
.cbSize
= sizeof (si
);
3820 si
.nMax
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
)
3821 + HORIZONTAL_SCROLL_BAR_MIN_HANDLE
;
3823 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3824 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3828 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3830 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3832 /* Add bar to its frame's list of scroll bars. */
3833 bar
->next
= FRAME_SCROLL_BARS (f
);
3835 XSETVECTOR (barobj
, bar
);
3836 fset_scroll_bars (f
, barobj
);
3837 if (! NILP (bar
->next
))
3838 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3846 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3850 x_scroll_bar_remove (struct scroll_bar
*bar
)
3852 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3856 /* Destroy the window. */
3857 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3859 /* Dissociate this scroll bar from its window. */
3860 if (bar
->horizontal
)
3861 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3863 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3868 /* Set the handle of the vertical scroll bar for WINDOW to indicate that
3869 we are displaying PORTION characters out of a total of WHOLE
3870 characters, starting at POSITION. If WINDOW has no vertical scroll
3873 w32_set_vertical_scroll_bar (struct window
*w
,
3874 int portion
, int whole
, int position
)
3876 struct frame
*f
= XFRAME (w
->frame
);
3878 struct scroll_bar
*bar
;
3879 int top
, height
, left
, width
;
3880 int window_y
, window_height
;
3882 /* Get window dimensions. */
3883 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
3885 height
= window_height
;
3887 /* Compute the left edge and the width of the scroll bar area. */
3888 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3889 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
3891 /* Does the scroll bar exist yet? */
3892 if (NILP (w
->vertical_scroll_bar
))
3896 if (width
> 0 && height
> 0)
3898 hdc
= get_frame_dc (f
);
3899 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3900 release_frame_dc (f
, hdc
);
3904 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, false);
3908 /* It may just need to be moved and resized. */
3911 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3912 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3914 /* If already correctly positioned, do nothing. */
3915 if (bar
->left
== left
3917 && bar
->width
== width
3918 && bar
->height
== height
)
3920 /* Redraw after clear_frame. */
3921 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3922 InvalidateRect (hwnd
, NULL
, FALSE
);
3930 if (width
&& height
)
3932 hdc
= get_frame_dc (f
);
3933 /* Since Windows scroll bars are smaller than the space reserved
3934 for them on the frame, we have to clear "under" them. */
3935 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3936 release_frame_dc (f
, hdc
);
3937 x_clear_under_internal_border (f
);
3939 /* Make sure scroll bar is "visible" before moving, to ensure the
3940 area of the parent window now exposed will be refreshed. */
3941 my_show_window (f
, hwnd
, SW_HIDE
);
3942 /** MoveWindow (hwnd, left, top, width, max (height, 1), TRUE); **/
3943 /* Try to not draw over child frames. */
3944 SetWindowPos (hwnd
, HWND_BOTTOM
, left
, top
, width
, max (height
, 1),
3947 si
.cbSize
= sizeof (si
);
3948 si
.fMask
= SIF_RANGE
;
3950 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3951 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3953 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3955 my_show_window (f
, hwnd
, SW_NORMAL
);
3956 /* InvalidateRect (w, NULL, FALSE); */
3958 /* Remember new settings. */
3962 bar
->height
= height
;
3967 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3968 XSETVECTOR (barobj
, bar
);
3969 wset_vertical_scroll_bar (w
, barobj
);
3972 /* Set the handle of the horizontal scroll bar for WINDOW to indicate
3973 that we are displaying PORTION characters out of a total of WHOLE
3974 characters, starting at POSITION. If WINDOW has no horizontal scroll
3977 w32_set_horizontal_scroll_bar (struct window
*w
,
3978 int portion
, int whole
, int position
)
3980 struct frame
*f
= XFRAME (w
->frame
);
3982 struct scroll_bar
*bar
;
3983 int top
, height
, left
, width
;
3984 int window_x
, window_width
;
3985 int clear_left
= WINDOW_LEFT_EDGE_X (w
);
3986 int clear_width
= WINDOW_PIXEL_WIDTH (w
) - WINDOW_RIGHT_DIVIDER_WIDTH (w
);
3988 /* Get window dimensions. */
3989 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
3991 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
3992 width
= window_width
;
3993 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
3995 /* Does the scroll bar exist yet? */
3996 if (NILP (w
->horizontal_scroll_bar
))
4000 if (width
> 0 && height
> 0)
4002 hdc
= get_frame_dc (f
);
4003 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
4004 release_frame_dc (f
, hdc
);
4008 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, true);
4012 /* It may just need to be moved and resized. */
4015 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
4016 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
4018 /* If already correctly positioned, do nothing. */
4019 if (bar
->left
== left
&& bar
->top
== top
4020 && bar
->width
== width
&& bar
->height
== height
)
4022 /* Redraw after clear_frame. */
4023 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
4024 InvalidateRect (hwnd
, NULL
, FALSE
);
4032 if (width
&& height
)
4034 hdc
= get_frame_dc (f
);
4035 /* Since Windows scroll bars are smaller than the space reserved
4036 for them on the frame, we have to clear "under" them. */
4037 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
4038 release_frame_dc (f
, hdc
);
4039 x_clear_under_internal_border (f
);
4041 /* Make sure scroll bar is "visible" before moving, to ensure the
4042 area of the parent window now exposed will be refreshed. */
4043 my_show_window (f
, hwnd
, SW_HIDE
);
4044 /** MoveWindow (hwnd, left, top, width, max (height, 1), TRUE); **/
4045 /* Try to not draw over child frames. */
4046 SetWindowPos (hwnd
, HWND_BOTTOM
, left
, top
, max (width
, 1), height
,
4049 /* +++ SetScrollInfo +++ */
4050 si
.cbSize
= sizeof (si
);
4051 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
4054 si
.nPage
= min (portion
, si
.nMax
) + 1;
4055 si
.nPos
= min (position
, si
.nMax
);
4056 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
4058 my_show_window (f
, hwnd
, SW_NORMAL
);
4059 /* InvalidateRect (w, NULL, FALSE); */
4061 /* Remember new settings. */
4065 bar
->height
= height
;
4071 w32_set_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
4072 XSETVECTOR (barobj
, bar
);
4073 wset_horizontal_scroll_bar (w
, barobj
);
4077 /* The following three hooks are used when we're doing a thorough
4078 redisplay of the frame. We don't explicitly know which scroll bars
4079 are going to be deleted, because keeping track of when windows go
4080 away is a real pain - "Can you say set-window-configuration, boys
4081 and girls?" Instead, we just assert at the beginning of redisplay
4082 that *all* scroll bars are to be removed, and then save a scroll bar
4083 from the fiery pit when we actually redisplay its window. */
4085 /* Arrange for all scroll bars on FRAME to be removed at the next call
4086 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
4087 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
4090 w32_condemn_scroll_bars (struct frame
*frame
)
4092 if (!NILP (FRAME_SCROLL_BARS (frame
)))
4094 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
4096 /* Prepend scrollbars to already condemned ones. */
4097 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
4099 while (!NILP (XSCROLL_BAR (last
)->next
))
4100 last
= XSCROLL_BAR (last
)->next
;
4102 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
4103 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
4106 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
4107 fset_scroll_bars (frame
, Qnil
);
4112 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
4113 Note that WINDOW isn't necessarily condemned at all. */
4116 w32_redeem_scroll_bar (struct window
*w
)
4118 struct scroll_bar
*bar
;
4122 /* We can't redeem this window's scroll bar if it doesn't have one. */
4123 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
4126 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4128 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4129 /* Unlink it from the condemned list. */
4130 f
= XFRAME (WINDOW_FRAME (w
));
4131 if (NILP (bar
->prev
))
4133 /* If the prev pointer is nil, it must be the first in one of
4135 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
4136 /* It's not condemned. Everything's fine. */
4138 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4139 w
->vertical_scroll_bar
))
4140 fset_condemned_scroll_bars (f
, bar
->next
);
4142 /* If its prev pointer is nil, it must be at the front of
4143 one or the other! */
4147 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4149 if (! NILP (bar
->next
))
4150 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4152 bar
->next
= FRAME_SCROLL_BARS (f
);
4154 XSETVECTOR (barobj
, bar
);
4155 fset_scroll_bars (f
, barobj
);
4156 if (! NILP (bar
->next
))
4157 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4161 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
4163 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
4164 /* Unlink it from the condemned list. */
4165 f
= XFRAME (WINDOW_FRAME (w
));
4166 if (NILP (bar
->prev
))
4168 /* If the prev pointer is nil, it must be the first in one of
4170 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
4171 /* It's not condemned. Everything's fine. */
4173 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4174 w
->horizontal_scroll_bar
))
4175 fset_condemned_scroll_bars (f
, bar
->next
);
4177 /* If its prev pointer is nil, it must be at the front of
4178 one or the other! */
4182 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4184 if (! NILP (bar
->next
))
4185 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4187 bar
->next
= FRAME_SCROLL_BARS (f
);
4189 XSETVECTOR (barobj
, bar
);
4190 fset_scroll_bars (f
, barobj
);
4191 if (! NILP (bar
->next
))
4192 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4196 /* Remove all scroll bars on FRAME that haven't been saved since the
4197 last call to `*condemn_scroll_bars_hook'. */
4200 w32_judge_scroll_bars (struct frame
*f
)
4202 Lisp_Object bar
, next
;
4204 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
4206 /* Clear out the condemned list now so we won't try to process any
4207 more events on the hapless scroll bars. */
4208 fset_condemned_scroll_bars (f
, Qnil
);
4210 for (; ! NILP (bar
); bar
= next
)
4212 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
4214 x_scroll_bar_remove (b
);
4217 b
->next
= b
->prev
= Qnil
;
4220 /* Now there should be no references to the condemned scroll bars,
4221 and they should get garbage-collected. */
4224 /* Handle a mouse click on the vertical scroll bar BAR. If
4225 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4228 This may be called from a signal handler, so we have to ignore GC
4232 w32_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4233 struct input_event
*emacs_event
)
4235 if (! WINDOWP (bar
->window
))
4238 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
4239 emacs_event
->code
= 0;
4240 /* not really meaningful to distinguish up/down */
4241 emacs_event
->modifiers
= msg
->dwModifiers
;
4242 emacs_event
->frame_or_window
= bar
->window
;
4243 emacs_event
->arg
= Qnil
;
4244 emacs_event
->timestamp
= msg
->msg
.time
;
4247 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4249 int dragging
= bar
->dragging
;
4251 int sb_event
= LOWORD (msg
->msg
.wParam
);
4253 si
.cbSize
= sizeof (si
);
4254 if (sb_event
== SB_THUMBTRACK
)
4255 si
.fMask
= SIF_TRACKPOS
;
4259 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4260 if (sb_event
== SB_THUMBTRACK
)
4266 struct frame
*f
; /* Value is not used. */
4267 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4272 emacs_event
->part
= scroll_bar_down_arrow
;
4275 emacs_event
->part
= scroll_bar_up_arrow
;
4278 emacs_event
->part
= scroll_bar_above_handle
;
4281 emacs_event
->part
= scroll_bar_below_handle
;
4284 emacs_event
->part
= scroll_bar_handle
;
4288 emacs_event
->part
= scroll_bar_handle
;
4292 case SB_THUMBPOSITION
:
4293 bar
->dragging
= 1; /* ??????? */
4294 emacs_event
->part
= scroll_bar_handle
;
4296 /* "Silently" update current position. */
4300 si
.cbSize
= sizeof (si
);
4303 /* Remember apparent position (we actually lag behind the real
4304 position, so don't set that directly). */
4305 last_scroll_bar_drag_pos
= y
;
4307 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4311 /* If this is the end of a drag sequence, then reset the scroll
4312 handle size to normal and do a final redraw. Otherwise do
4317 int start
= bar
->start
;
4320 si
.cbSize
= sizeof (si
);
4321 si
.fMask
= SIF_PAGE
| SIF_POS
;
4322 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4323 si
.nPos
= last_scroll_bar_drag_pos
;
4324 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4328 emacs_event
->kind
= NO_EVENT
;
4332 XSETINT (emacs_event
->x
, y
);
4333 XSETINT (emacs_event
->y
, top_range
);
4339 /* Handle a mouse click on the horizontal scroll bar BAR. If
4340 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4343 This may be called from a signal handler, so we have to ignore GC
4347 w32_horizontal_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4348 struct input_event
*emacs_event
)
4350 if (! WINDOWP (bar
->window
))
4353 emacs_event
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
4354 emacs_event
->code
= 0;
4355 /* not really meaningful to distinguish left/right */
4356 emacs_event
->modifiers
= msg
->dwModifiers
;
4357 emacs_event
->frame_or_window
= bar
->window
;
4358 emacs_event
->arg
= Qnil
;
4359 emacs_event
->timestamp
= msg
->msg
.time
;
4362 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4364 int dragging
= bar
->dragging
;
4366 int sb_event
= LOWORD (msg
->msg
.wParam
);
4368 si
.cbSize
= sizeof (si
);
4369 if (sb_event
== SB_THUMBTRACK
)
4370 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4372 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4374 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4375 if (sb_event
== SB_THUMBTRACK
)
4379 y
= si
.nMax
- si
.nPage
;
4382 struct frame
*f
; /* Value is not used. */
4383 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4388 emacs_event
->part
= scroll_bar_left_arrow
;
4391 emacs_event
->part
= scroll_bar_right_arrow
;
4394 emacs_event
->part
= scroll_bar_before_handle
;
4397 emacs_event
->part
= scroll_bar_after_handle
;
4400 emacs_event
->part
= scroll_bar_horizontal_handle
;
4404 emacs_event
->part
= scroll_bar_horizontal_handle
;
4408 case SB_THUMBPOSITION
:
4410 emacs_event
->part
= scroll_bar_horizontal_handle
;
4412 /* "Silently" update current position. */
4416 si
.cbSize
= sizeof (si
);
4418 si
.nPos
= min (x
, XWINDOW (bar
->window
)->hscroll_whole
- 1);
4419 /* Remember apparent position (we actually lag behind the real
4420 position, so don't set that directly). */
4421 last_scroll_bar_drag_pos
= x
;
4423 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4427 /* If this is the end of a drag sequence, then reset the scroll
4428 handle size to normal and do a final redraw. Otherwise do
4434 si
.cbSize
= sizeof (si
);
4436 si
.nPos
= min (last_scroll_bar_drag_pos
,
4437 XWINDOW (bar
->window
)->hscroll_whole
- 1);
4438 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4442 emacs_event
->kind
= NO_EVENT
;
4446 XSETINT (emacs_event
->x
, x
);
4447 XSETINT (emacs_event
->y
, y
);
4453 /* Return information to the user about the current position of the mouse
4454 on the vertical scroll bar. */
4456 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4457 enum scroll_bar_part
*part
,
4458 Lisp_Object
*x
, Lisp_Object
*y
,
4461 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4462 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4463 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4464 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4466 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4468 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4473 *bar_window
= bar
->window
;
4475 si
.cbSize
= sizeof (si
);
4476 if (sb_event
== SB_THUMBTRACK
)
4477 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4479 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4481 GetScrollInfo (w
, SB_CTL
, &si
);
4482 if (sb_event
== SB_THUMBTRACK
)
4486 top_range
= si
.nMax
- si
.nPage
+ 1;
4488 *part
= scroll_bar_handle
;
4489 if (sb_event
== SB_LINEDOWN
)
4493 XSETINT (*y
, top_range
);
4495 f
->mouse_moved
= false;
4496 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4498 *time
= dpyinfo
->last_mouse_movement_time
;
4503 /* Return information to the user about the current position of the mouse
4504 on the horizontal scroll bar. */
4506 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4507 enum scroll_bar_part
*part
,
4508 Lisp_Object
*x
, Lisp_Object
*y
,
4511 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4512 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4513 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4514 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4516 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4518 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4523 *bar_window
= bar
->window
;
4525 si
.cbSize
= sizeof (si
);
4526 if (sb_event
== SB_THUMBTRACK
)
4527 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4529 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4531 GetScrollInfo (w
, SB_CTL
, &si
);
4532 if (sb_event
== SB_THUMBTRACK
)
4536 left_range
= si
.nMax
- si
.nPage
+ 1;
4538 *part
= scroll_bar_handle
;
4539 if (sb_event
== SB_LINERIGHT
)
4544 XSETINT (*x
, left_range
);
4546 f
->mouse_moved
= false;
4547 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4549 *time
= dpyinfo
->last_mouse_movement_time
;
4555 /* The screen has been cleared so we may have changed foreground or
4556 background colors, and the scroll bars may need to be redrawn.
4557 Clear out the scroll bars, and ask for expose events, so we can
4561 x_scroll_bar_clear (struct frame
*f
)
4565 /* We can have scroll bars even if this is 0,
4566 if we just turned off scroll bar mode.
4567 But in that case we should not clear them. */
4568 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4569 || FRAME_HAS_HORIZONTAL_SCROLL_BARS (f
))
4570 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4571 bar
= XSCROLL_BAR (bar
)->next
)
4573 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4574 HDC hdc
= GetDC (window
);
4577 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4578 arranges to refresh the scroll bar if hidden. */
4579 my_show_window (f
, window
, SW_HIDE
);
4581 GetClientRect (window
, &rect
);
4582 select_palette (f
, hdc
);
4583 w32_clear_rect (f
, hdc
, &rect
);
4584 x_clear_under_internal_border (f
);
4585 deselect_palette (f
, hdc
);
4587 ReleaseDC (window
, hdc
);
4591 /* The main W32 event-reading loop - w32_read_socket. */
4593 /* Record the last 100 characters stored
4594 to help debug the loss-of-chars-during-GC problem. */
4596 static int temp_index
;
4597 static short temp_buffer
[100];
4599 /* Temporarily store lead byte of DBCS input sequences. */
4600 static char dbcs_lead
= 0;
4602 /* Read events coming from the W32 shell.
4603 This routine is called by the SIGIO handler.
4604 We return as soon as there are no more events to be read.
4606 For an overview of how Emacs input works on MS-Windows, see the
4607 commentary before w32_msg_pump in w32fns.c.
4609 We return the number of characters stored into the buffer,
4610 thus pretending to be `read'.
4612 Some of these messages are reposted back to the message queue since the
4613 system calls the windows proc directly in a context where we cannot return
4614 the data nor can we guarantee the state we are in. So if we dispatch them
4615 we will get into an infinite loop. To prevent this from ever happening we
4616 will set a variable to indicate we are in the read_socket call and indicate
4617 which message we are processing since the windows proc gets called
4618 recursively with different messages by the system.
4621 extern void menubar_selection_callback (struct frame
*, void *);
4624 w32_read_socket (struct terminal
*terminal
,
4625 struct input_event
*hold_quit
)
4628 int check_visibility
= 0;
4631 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4632 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
4636 /* So people can tell when we have read the available input. */
4637 input_signal_count
++;
4639 /* Process any incoming thread messages. */
4640 drain_message_queue ();
4642 /* TODO: ghostscript integration. */
4643 while (get_next_msg (&msg
, FALSE
))
4645 struct input_event inev
;
4648 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4649 /* w32_name_of_message (msg.msg.message), */
4650 /* msg.msg.time)); */
4653 inev
.kind
= NO_EVENT
;
4656 switch (msg
.msg
.message
)
4658 case WM_EMACS_PAINT
:
4659 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4663 if (msg
.rect
.right
== msg
.rect
.left
||
4664 msg
.rect
.bottom
== msg
.rect
.top
)
4666 /* We may get paint messages even though the client
4667 area is clipped - these are not expose events. */
4668 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4671 else if (FRAME_VISIBLE_P (f
) != 1)
4673 bool iconified
= FRAME_ICONIFIED_P (f
);
4675 /* Definitely not obscured, so mark as visible. */
4676 SET_FRAME_VISIBLE (f
, 1);
4677 SET_FRAME_ICONIFIED (f
, false);
4678 SET_FRAME_GARBAGED (f
);
4679 if (!f
->output_data
.w32
->asked_for_visible
)
4680 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4683 /* WM_PAINT serves as MapNotify as well, so report
4684 visibility changes properly. */
4687 inev
.kind
= DEICONIFY_EVENT
;
4688 XSETFRAME (inev
.frame_or_window
, f
);
4690 else if (!NILP (Vframe_list
) && !NILP (XCDR (Vframe_list
)))
4691 /* Force a redisplay sooner or later to update the
4692 frame titles in case this is the second frame. */
4693 record_asynch_buffer_change ();
4697 /* Erase background again for safety. But don't do
4698 that if the frame's 'garbaged' flag is set, since
4699 in that case expose_frame will do nothing, and if
4700 the various redisplay flags happen to be unset,
4701 we are left with a blank frame. */
4702 if (!FRAME_GARBAGED_P (f
) || FRAME_PARENT_FRAME (f
))
4704 HDC hdc
= get_frame_dc (f
);
4706 w32_clear_rect (f
, hdc
, &msg
.rect
);
4707 release_frame_dc (f
, hdc
);
4712 msg
.rect
.right
- msg
.rect
.left
,
4713 msg
.rect
.bottom
- msg
.rect
.top
);
4714 x_clear_under_internal_border (f
);
4719 case WM_INPUTLANGCHANGE
:
4720 /* Generate a language change event. */
4721 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4723 /* lParam contains the input language ID in its low 16 bits.
4724 Use it to update our record of the keyboard codepage. */
4725 w32_keyboard_codepage
= codepage_for_locale ((LCID
)(msg
.msg
.lParam
4730 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4731 XSETFRAME (inev
.frame_or_window
, f
);
4732 inev
.code
= w32_keyboard_codepage
;
4733 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4739 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4741 if (f
&& !FRAME_ICONIFIED_P (f
))
4743 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4744 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4746 clear_mouse_face (hlinfo
);
4747 hlinfo
->mouse_face_hidden
= true;
4750 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4752 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4753 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4754 inev
.code
= msg
.msg
.wParam
;
4755 inev
.modifiers
= msg
.dwModifiers
;
4756 XSETFRAME (inev
.frame_or_window
, f
);
4757 inev
.timestamp
= msg
.msg
.time
;
4764 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4766 if (f
&& !FRAME_ICONIFIED_P (f
))
4768 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4769 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4771 clear_mouse_face (hlinfo
);
4772 hlinfo
->mouse_face_hidden
= true;
4775 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4777 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4779 inev
.modifiers
= msg
.dwModifiers
;
4780 XSETFRAME (inev
.frame_or_window
, f
);
4781 inev
.timestamp
= msg
.msg
.time
;
4783 if (msg
.msg
.message
== WM_UNICHAR
)
4785 inev
.code
= msg
.msg
.wParam
;
4787 else if (msg
.msg
.wParam
< 256)
4792 dbcs
[1] = (char) msg
.msg
.wParam
;
4796 dbcs
[0] = dbcs_lead
;
4798 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4802 DebPrint (("Invalid DBCS sequence: %d %d\n",
4804 inev
.kind
= NO_EVENT
;
4808 else if (IsDBCSLeadByteEx (w32_keyboard_codepage
,
4809 (BYTE
) msg
.msg
.wParam
))
4811 dbcs_lead
= (char) msg
.msg
.wParam
;
4812 inev
.kind
= NO_EVENT
;
4817 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4818 &dbcs
[1], 1, &code
, 1))
4820 /* What to do with garbage? */
4821 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4822 inev
.kind
= NO_EVENT
;
4830 /* Windows shouldn't generate WM_CHAR events above 0xFF
4831 in non-Unicode message handlers. */
4832 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4833 inev
.kind
= NO_EVENT
;
4836 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4837 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4842 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4844 if (f
&& !FRAME_ICONIFIED_P (f
))
4846 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4847 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4849 clear_mouse_face (hlinfo
);
4850 hlinfo
->mouse_face_hidden
= true;
4853 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4855 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4856 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4857 inev
.code
= GET_APPCOMMAND_LPARAM (msg
.msg
.lParam
);
4858 inev
.modifiers
= msg
.dwModifiers
;
4859 XSETFRAME (inev
.frame_or_window
, f
);
4860 inev
.timestamp
= msg
.msg
.time
;
4865 /* Ignore non-movement. */
4867 int x
= LOWORD (msg
.msg
.lParam
);
4868 int y
= HIWORD (msg
.msg
.lParam
);
4869 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4871 last_mousemove_x
= x
;
4872 last_mousemove_y
= y
;
4875 previous_help_echo_string
= help_echo_string
;
4876 help_echo_string
= Qnil
;
4878 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4879 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4881 if (hlinfo
->mouse_face_hidden
)
4883 hlinfo
->mouse_face_hidden
= false;
4884 clear_mouse_face (hlinfo
);
4889 /* Maybe generate SELECT_WINDOW_EVENTs for
4890 `mouse-autoselect-window'. */
4891 if (!NILP (Vmouse_autoselect_window
)
4892 && (f
== XFRAME (selected_frame
)
4893 /* Switch to f from another frame iff
4894 focus_follows_mouse is set and f accepts
4896 || (!NILP (focus_follows_mouse
)
4897 && !FRAME_NO_ACCEPT_FOCUS (f
))))
4899 static Lisp_Object last_mouse_window
;
4900 Lisp_Object window
= window_from_coordinates
4901 (f
, LOWORD (msg
.msg
.lParam
), HIWORD (msg
.msg
.lParam
), 0, 0);
4903 /* Window will be selected only when it is not
4904 selected now and last mouse movement event was
4905 not in it. Minibuffer window will be selected
4906 only when it is active. */
4907 if (WINDOWP (window
)
4908 && !EQ (window
, last_mouse_window
)
4909 && !EQ (window
, selected_window
))
4911 inev
.kind
= SELECT_WINDOW_EVENT
;
4912 inev
.frame_or_window
= window
;
4915 /* Remember the last window where we saw the mouse. */
4916 last_mouse_window
= window
;
4919 if (!note_mouse_movement (f
, &msg
.msg
))
4920 help_echo_string
= previous_help_echo_string
;
4924 /* If we move outside the frame, then we're
4925 certainly no longer on any text in the frame. */
4926 clear_mouse_face (hlinfo
);
4929 /* If the contents of the global variable help_echo_string
4930 has changed, generate a HELP_EVENT. */
4931 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4932 But it was originally changed to this to fix a bug, so I have
4933 not removed it completely in case the bug is still there. */
4934 if (help_echo_string
!= previous_help_echo_string
||
4935 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4936 #else /* This is what xterm.c does. */
4937 if (!NILP (help_echo_string
)
4938 || !NILP (previous_help_echo_string
))
4943 case WM_LBUTTONDOWN
:
4945 case WM_MBUTTONDOWN
:
4947 case WM_RBUTTONDOWN
:
4949 case WM_XBUTTONDOWN
:
4952 /* If we decide we want to generate an event to be seen
4953 by the rest of Emacs, we put it here. */
4954 bool tool_bar_p
= 0;
4958 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4959 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4963 construct_mouse_click (&inev
, &msg
, f
);
4965 /* Is this in the tool-bar? */
4966 if (WINDOWP (f
->tool_bar_window
)
4967 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4970 int x
= XFASTINT (inev
.x
);
4971 int y
= XFASTINT (inev
.y
);
4973 window
= window_from_coordinates (f
, x
, y
, 0, 1);
4975 if (EQ (window
, f
->tool_bar_window
))
4977 w32_handle_tool_bar_click (f
, &inev
);
4983 || (dpyinfo
->w32_focus_frame
4984 && f
!= dpyinfo
->w32_focus_frame
4985 /* This does not help when the click happens in
4986 a grand-parent frame. */
4987 && !frame_ancestor_p (f
, dpyinfo
->w32_focus_frame
)))
4988 inev
.kind
= NO_EVENT
;
4991 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4996 dpyinfo
->grabbed
&= ~ (1 << button
);
5000 dpyinfo
->grabbed
|= (1 << button
);
5001 dpyinfo
->last_mouse_frame
= f
;
5002 /* Ignore any mouse motion that happened
5003 before this event; any subsequent mouse-movement
5004 Emacs events should reflect only motion after
5008 f
->mouse_moved
= false;
5010 f
->last_tool_bar_item
= -1;
5017 case WM_MOUSEHWHEEL
:
5019 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
5020 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
5024 if (!dpyinfo
->w32_focus_frame
5025 || f
== dpyinfo
->w32_focus_frame
)
5026 /* Emit an Emacs wheel-up/down event. */
5028 construct_mouse_wheel (&inev
, &msg
, f
);
5030 /* Ignore any mouse motion that happened before this
5031 event; any subsequent mouse-movement Emacs events
5032 should reflect only motion after the ButtonPress. */
5033 f
->mouse_moved
= false;
5034 f
->last_tool_bar_item
= -1;
5035 dpyinfo
->last_mouse_frame
= f
;
5037 else if (FRAME_NO_ACCEPT_FOCUS (f
)
5038 && !x_mouse_grabbed (dpyinfo
))
5040 Lisp_Object frame1
= get_frame_param (f
, Qmouse_wheel_frame
);
5041 struct frame
*f1
= FRAMEP (frame1
) ? XFRAME (frame1
) : NULL
;
5043 if (f1
&& FRAME_LIVE_P (f1
) && FRAME_W32_P (f1
))
5045 construct_mouse_wheel (&inev
, &msg
, f1
);
5046 f1
->mouse_moved
= false;
5047 f1
->last_tool_bar_item
= -1;
5048 dpyinfo
->last_mouse_frame
= f1
;
5051 dpyinfo
->last_mouse_frame
= f
;
5054 dpyinfo
->last_mouse_frame
= f
;
5057 dpyinfo
->last_mouse_frame
= f
;
5062 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5065 construct_drag_n_drop (&inev
, &msg
, f
);
5070 struct scroll_bar
*bar
=
5071 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 1);
5074 w32_horizontal_scroll_bar_handle_click (bar
, &msg
, &inev
);
5080 struct scroll_bar
*bar
=
5081 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 0);
5084 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
5088 case WM_WINDOWPOSCHANGED
:
5090 case WM_ACTIVATEAPP
:
5091 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5094 /* Run the full-screen hook function also when we are
5095 being activated, to actually install the required
5096 size in effect, if the WAIT flag is set. This is
5097 because when the hook is run from x_set_fullscreen,
5098 the frame might not yet be visible, if that call is a
5099 result of make-frame, and in that case the hook just
5100 sets the WAIT flag. */
5101 if ((msg
.msg
.message
== WM_WINDOWPOSCHANGED
|| msg
.msg
.wParam
)
5102 && (f
->want_fullscreen
& FULLSCREEN_WAIT
))
5104 /* Must set visibility right here since otherwise
5105 w32fullscreen_hook returns immediately. */
5106 SET_FRAME_VISIBLE (f
, 1);
5107 w32fullscreen_hook (f
);
5111 check_visibility
= 1;
5115 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5117 if (f
&& FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P(f
))
5119 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5120 inev
.kind
= MOVE_FRAME_EVENT
;
5121 XSETFRAME (inev
.frame_or_window
, f
);
5124 check_visibility
= 1;
5128 /* wParam non-zero means Window is about to be shown, 0 means
5129 about to be hidden. */
5130 /* Redo the mouse-highlight after the tooltip has gone. */
5131 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
5134 x_redo_mouse_highlight (dpyinfo
);
5137 /* If window has been obscured or exposed by another window
5138 being maximized or minimized/restored, then recheck
5139 visibility of all frames. Direct changes to our own
5140 windows get handled by WM_SIZE. */
5142 if (msg
.msg
.lParam
!= 0)
5143 check_visibility
= 1;
5146 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5147 f
->async_visible
= msg
.msg
.wParam
;
5151 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5153 x_clear_under_internal_border (f
);
5155 check_visibility
= 1;
5159 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5161 /* Inform lisp of whether frame has been iconified etc. */
5164 switch (msg
.msg
.wParam
)
5166 case SIZE_MINIMIZED
:
5167 SET_FRAME_VISIBLE (f
, 0);
5168 SET_FRAME_ICONIFIED (f
, true);
5170 inev
.kind
= ICONIFY_EVENT
;
5171 XSETFRAME (inev
.frame_or_window
, f
);
5174 case SIZE_MAXIMIZED
:
5176 bool iconified
= FRAME_ICONIFIED_P (f
);
5177 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5179 SET_FRAME_VISIBLE (f
, 1);
5180 SET_FRAME_ICONIFIED (f
, false);
5182 /* wait_reading_process_output will notice this
5183 and update the frame's display structures. */
5184 SET_FRAME_GARBAGED (f
);
5190 /* Reset top and left positions of the Window
5191 here since Windows sends a WM_MOVE message
5192 BEFORE telling us the Window is minimized
5193 when the Window is iconified, with 3000,3000
5195 x_real_positions (f
, &x
, &y
);
5199 inev
.kind
= DEICONIFY_EVENT
;
5200 XSETFRAME (inev
.frame_or_window
, f
);
5202 else if (! NILP (Vframe_list
)
5203 && ! NILP (XCDR (Vframe_list
)))
5204 /* Force a redisplay sooner or later
5205 to update the frame titles
5206 in case this is the second frame. */
5207 record_asynch_buffer_change ();
5209 /* Windows can send us a SIZE_MAXIMIZED message even
5210 when fullscreen is fullboth. The following is a
5211 simple hack to check that based on the fact that
5212 only a maximized fullscreen frame should have both
5213 top/left outside the screen. */
5214 if (EQ (fullscreen
, Qfullwidth
) || EQ (fullscreen
, Qfullheight
)
5215 || NILP (fullscreen
))
5219 x_real_positions (f
, &x
, &y
);
5221 store_frame_param (f
, Qfullscreen
, Qmaximized
);
5229 bool iconified
= FRAME_ICONIFIED_P (f
);
5231 /* The following was made unconditional in a
5232 pathetic attempt to fix bug#16967 in revision
5233 116716 but, considered counterproductive was made
5234 conditional again in revision 116727. martin */
5236 SET_FRAME_VISIBLE (f
, 1);
5237 SET_FRAME_ICONIFIED (f
, false);
5239 /* wait_reading_process_output will notice this
5240 and update the frame's display structures. */
5241 SET_FRAME_GARBAGED (f
);
5245 /* Reset top and left positions of the Window
5246 here since Windows sends a WM_MOVE message
5247 BEFORE telling us the Window is minimized
5248 when the Window is iconified, with 3000,3000
5250 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5252 inev
.kind
= DEICONIFY_EVENT
;
5253 XSETFRAME (inev
.frame_or_window
, f
);
5255 else if (! NILP (Vframe_list
)
5256 && ! NILP (XCDR (Vframe_list
)))
5257 /* Force a redisplay sooner or later
5258 to update the frame titles
5259 in case this is the second frame. */
5260 record_asynch_buffer_change ();
5263 if (EQ (get_frame_param (f
, Qfullscreen
), Qmaximized
))
5264 store_frame_param (f
, Qfullscreen
, Qnil
);
5270 if (f
&& !FRAME_ICONIFIED_P (f
) && msg
.msg
.wParam
!= SIZE_MINIMIZED
)
5273 int /* rows, columns, */ width
, height
, text_width
, text_height
;
5275 if (GetClientRect (msg
.msg
.hwnd
, &rect
)
5276 /* GetClientRect evidently returns (0, 0, 0, 0) if
5277 called on a minimized frame. Such "dimensions"
5278 aren't useful anyway. */
5279 && !(rect
.bottom
== 0
5282 && rect
.right
== 0))
5284 height
= rect
.bottom
- rect
.top
;
5285 width
= rect
.right
- rect
.left
;
5286 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, width
);
5287 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, height
);
5288 /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
5289 /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
5291 /* TODO: Clip size to the screen dimensions. */
5293 /* Even if the number of character rows and columns
5294 has not changed, the font size may have changed,
5295 so we need to check the pixel dimensions as well. */
5297 if (width
!= FRAME_PIXEL_WIDTH (f
)
5298 || height
!= FRAME_PIXEL_HEIGHT (f
)
5299 || text_width
!= FRAME_TEXT_WIDTH (f
)
5300 || text_height
!= FRAME_TEXT_HEIGHT (f
))
5302 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
5303 SET_FRAME_GARBAGED (f
);
5304 cancel_mouse_face (f
);
5305 f
->win_gravity
= NorthWestGravity
;
5310 check_visibility
= 1;
5314 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5317 if (f
== hlinfo
->mouse_face_mouse_frame
)
5319 /* If we move outside the frame, then we're
5320 certainly no longer on any text in the frame. */
5321 clear_mouse_face (hlinfo
);
5322 hlinfo
->mouse_face_mouse_frame
= 0;
5325 /* Generate a nil HELP_EVENT to cancel a help-echo.
5326 Do it only if there's something to cancel.
5327 Otherwise, the startup message is cleared when
5328 the mouse leaves the frame. */
5329 if (any_help_event_p
)
5335 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5337 dpyinfo
->grabbed
= 0;
5338 check_visibility
= 1;
5342 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5343 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5347 if (f
== hlinfo
->mouse_face_mouse_frame
)
5349 /* If we move outside the frame, then we're
5350 certainly no longer on any text in the frame. */
5351 clear_mouse_face (hlinfo
);
5352 hlinfo
->mouse_face_mouse_frame
= 0;
5355 /* Generate a nil HELP_EVENT to cancel a help-echo.
5356 Do it only if there's something to cancel.
5357 Otherwise, the startup message is cleared when
5358 the mouse leaves the frame. */
5359 if (any_help_event_p
)
5363 dpyinfo
->grabbed
= 0;
5364 check_visibility
= 1;
5368 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5372 inev
.kind
= DELETE_WINDOW_EVENT
;
5373 XSETFRAME (inev
.frame_or_window
, f
);
5378 inev
.kind
= END_SESSION_EVENT
;
5382 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5386 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
5387 XSETFRAME (inev
.frame_or_window
, f
);
5392 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5396 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
5399 check_visibility
= 1;
5402 case WM_DISPLAYCHANGE
:
5403 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5407 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5409 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
5410 /* The new display could have a different resolution, in
5411 which case we must reconsider what fullscreen means.
5412 The following code is untested yet. */
5413 if (!NILP (fullscreen
))
5415 x_set_fullscreen (f
, fullscreen
, fullscreen
);
5416 w32fullscreen_hook (f
);
5419 DebPrint (("display change: %d %d\n",
5420 (short) LOWORD (msg
.msg
.lParam
),
5421 (short) HIWORD (msg
.msg
.lParam
)));
5424 check_visibility
= 1;
5428 case WM_EMACS_FILENOTIFY
:
5429 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5431 queue_notifications (&inev
, &msg
, f
, &count
);
5436 /* Check for messages registered at runtime. */
5437 if (msg
.msg
.message
== msh_mousewheel
)
5439 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5440 msg
.msg
.message
= WM_MOUSEWHEEL
;
5446 if (inev
.kind
!= NO_EVENT
)
5448 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5453 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5458 XSETFRAME (frame
, f
);
5464 if (NILP (help_echo_string
))
5466 help_echo_object
= help_echo_window
= Qnil
;
5470 any_help_event_p
= 1;
5471 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5472 help_echo_object
, help_echo_pos
);
5476 help_echo_string
= Qnil
;
5477 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5483 /* If the focus was just given to an autoraising frame,
5484 raise it now. FIXME: handle more than one such frame. */
5485 if (dpyinfo
->w32_pending_autoraise_frame
)
5487 x_raise_frame (dpyinfo
->w32_pending_autoraise_frame
);
5488 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
5491 /* Check which frames are still visible, if we have enqueued any user
5492 events or been notified of events that may affect visibility. We
5493 do this here because there doesn't seem to be any direct
5494 notification from Windows that the visibility of a window has
5495 changed (at least, not in all cases). */
5496 if (count
> 0 || check_visibility
)
5498 Lisp_Object tail
, frame
;
5500 FOR_EACH_FRAME (tail
, frame
)
5502 struct frame
*f
= XFRAME (frame
);
5503 /* The tooltip has been drawn already. Avoid the
5504 SET_FRAME_GARBAGED below. */
5505 if (EQ (frame
, tip_frame
))
5508 /* Check "visible" frames and mark each as obscured or not.
5509 Note that visible is nonzero for unobscured and obscured
5510 frames, but zero for hidden and iconified frames. */
5511 if (FRAME_W32_P (f
) && FRAME_VISIBLE_P (f
))
5518 /* Query clipping rectangle for the entire window area
5519 (GetWindowDC), not just the client portion (GetDC).
5520 Otherwise, the scrollbars and menubar aren't counted as
5521 part of the visible area of the frame, and we may think
5522 the frame is obscured when really a scrollbar is still
5523 visible and gets WM_PAINT messages above. */
5524 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5525 GetClipBox (hdc
, &clipbox
);
5526 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5529 obscured
= FRAME_OBSCURED_P (f
);
5531 if (clipbox
.right
== clipbox
.left
|| clipbox
.bottom
== clipbox
.top
)
5533 /* Frame has become completely obscured so mark as such (we
5534 do this by setting visible to 2 so that FRAME_VISIBLE_P
5535 is still true, but redisplay will skip it). */
5536 SET_FRAME_VISIBLE (f
, 2);
5539 DebPrint (("frame %p (%s) obscured\n", f
, SDATA (f
->name
)));
5543 /* Frame is not obscured, so mark it as such. */
5544 SET_FRAME_VISIBLE (f
, 1);
5548 SET_FRAME_GARBAGED (f
);
5549 DebPrint (("obscured frame %p (%s) found to be visible\n",
5550 f
, SDATA (f
->name
)));
5552 /* Force a redisplay sooner or later. */
5553 record_asynch_buffer_change ();
5566 /***********************************************************************
5568 ***********************************************************************/
5570 /* Set clipping for output in glyph row ROW. W is the window in which
5571 we operate. GC is the graphics context to set clipping in.
5573 ROW may be a text row or, e.g., a mode line. Text rows must be
5574 clipped to the interior of the window dedicated to text display,
5575 mode lines must be clipped to the whole window. */
5578 w32_clip_to_row (struct window
*w
, struct glyph_row
*row
,
5579 enum glyph_row_area area
, HDC hdc
)
5582 int window_x
, window_y
, window_width
;
5584 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5586 clip_rect
.left
= window_x
;
5587 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5588 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5589 clip_rect
.right
= clip_rect
.left
+ window_width
;
5590 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5592 w32_set_clip_rectangle (hdc
, &clip_rect
);
5596 /* Draw a hollow box cursor on window W in glyph row ROW. */
5599 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
5601 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5605 struct glyph
*cursor_glyph
;
5606 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5608 /* Get the glyph the cursor is on. If we can't tell because
5609 the current matrix is invalid or such, give up. */
5610 cursor_glyph
= get_phys_cursor_glyph (w
);
5611 if (cursor_glyph
== NULL
)
5617 /* Compute frame-relative coordinates for phys cursor. */
5618 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5620 /* When on R2L character, show cursor at the right edge of the
5621 glyph, unless the cursor box is as wide as the glyph or wider
5622 (the latter happens when x-stretch-cursor is non-nil). */
5623 if ((cursor_glyph
->resolved_level
& 1) != 0
5624 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5625 rect
.left
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5627 rect
.bottom
= rect
.top
+ h
;
5628 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5630 hdc
= get_frame_dc (f
);
5631 /* Set clipping, draw the rectangle, and reset clipping again. */
5632 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5633 FrameRect (hdc
, &rect
, hb
);
5635 w32_set_clip_rectangle (hdc
, NULL
);
5636 release_frame_dc (f
, hdc
);
5640 /* Draw a bar cursor on window W in glyph row ROW.
5642 Implementation note: One would like to draw a bar cursor with an
5643 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5644 Unfortunately, I didn't find a font yet that has this property set.
5648 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
,
5649 int width
, enum text_cursor_kinds kind
)
5651 struct frame
*f
= XFRAME (w
->frame
);
5652 struct glyph
*cursor_glyph
;
5654 /* If cursor is out of bounds, don't draw garbage. This can happen
5655 in mini-buffer windows when switching between echo area glyphs
5657 cursor_glyph
= get_phys_cursor_glyph (w
);
5658 if (cursor_glyph
== NULL
)
5661 /* If on an image, draw like a normal cursor. That's usually better
5662 visible than drawing a bar, esp. if the image is large so that
5663 the bar might not be in the window. */
5664 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5666 struct glyph_row
*row
;
5667 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5668 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5672 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5673 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5677 /* If the glyph's background equals the color we normally draw
5678 the bar cursor in, the bar cursor in its normal color is
5679 invisible. Use the glyph's foreground color instead in this
5680 case, on the assumption that the glyph's colors are chosen so
5681 that the glyph is legible. */
5682 if (face
->background
== cursor_color
)
5683 cursor_color
= face
->foreground
;
5685 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5687 hdc
= get_frame_dc (f
);
5688 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5690 if (kind
== BAR_CURSOR
)
5693 width
= FRAME_CURSOR_WIDTH (f
);
5694 width
= min (cursor_glyph
->pixel_width
, width
);
5696 w
->phys_cursor_width
= width
;
5698 /* If the character under cursor is R2L, draw the bar cursor
5699 on the right of its glyph, rather than on the left. */
5700 if ((cursor_glyph
->resolved_level
& 1) != 0)
5701 x
+= cursor_glyph
->pixel_width
- width
;
5703 w32_fill_area (f
, hdc
, cursor_color
, x
,
5704 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5705 width
, row
->height
);
5707 else /* HBAR_CURSOR */
5709 int dummy_x
, dummy_y
, dummy_h
;
5712 width
= row
->height
;
5714 width
= min (row
->height
, width
);
5716 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
5717 &dummy_y
, &dummy_h
);
5718 if ((cursor_glyph
->resolved_level
& 1) != 0
5719 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5720 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5721 w32_fill_area (f
, hdc
, cursor_color
, x
,
5722 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5723 row
->height
- width
),
5724 w
->phys_cursor_width
, width
);
5727 w32_set_clip_rectangle (hdc
, NULL
);
5728 release_frame_dc (f
, hdc
);
5733 /* RIF: Define cursor CURSOR on frame F. */
5736 w32_define_frame_cursor (struct frame
*f
, Cursor cursor
)
5738 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5742 /* RIF: Clear area on frame F. */
5745 w32_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
5749 hdc
= get_frame_dc (f
);
5750 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5751 release_frame_dc (f
, hdc
);
5754 /* RIF: Draw or clear cursor on window W. */
5757 w32_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
,
5758 int x
, int y
, enum text_cursor_kinds cursor_type
,
5759 int cursor_width
, bool on_p
, bool active_p
)
5763 /* If the user wants to use the system caret, make sure our own
5764 cursor remains invisible. */
5765 if (w32_use_visible_system_caret
)
5767 /* Call to erase_phys_cursor here seems to use the
5768 wrong values of w->phys_cursor, as they have been
5769 overwritten before this function was called. */
5770 if (w
->phys_cursor_type
!= NO_CURSOR
)
5771 erase_phys_cursor (w
);
5773 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5774 w
->phys_cursor_width
= -1;
5778 w
->phys_cursor_type
= cursor_type
;
5781 w
->phys_cursor_on_p
= true;
5783 /* If this is the active cursor, we need to track it with the
5784 system caret, so third party software like screen magnifiers
5785 and speech synthesizers can follow the cursor. */
5788 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5789 HWND hwnd
= FRAME_W32_WINDOW (f
);
5792 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5794 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5795 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5796 w32_system_caret_window
= w
;
5797 w32_system_caret_hdr_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
5798 w32_system_caret_mode_height
= WINDOW_MODE_LINE_HEIGHT (w
);
5800 PostMessage (hwnd
, WM_IME_STARTCOMPOSITION
, 0, 0);
5802 /* If the size of the active cursor changed, destroy the old
5804 if (w32_system_caret_hwnd
5805 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5806 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5808 w32_system_caret_height
= w
->phys_cursor_height
;
5810 /* Move the system caret. */
5811 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5814 if (glyph_row
->exact_window_width_line_p
5815 && (glyph_row
->reversed_p
5816 ? (w
->phys_cursor
.hpos
< 0)
5817 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
5819 glyph_row
->cursor_in_fringe_p
= true;
5820 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
5824 switch (cursor_type
)
5826 case HOLLOW_BOX_CURSOR
:
5827 x_draw_hollow_cursor (w
, glyph_row
);
5830 case FILLED_BOX_CURSOR
:
5831 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5835 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5839 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5843 w
->phys_cursor_width
= 0;
5857 x_bitmap_icon (struct frame
*f
, Lisp_Object icon
)
5860 HANDLE small_icon
= NULL
;
5862 if (FRAME_W32_WINDOW (f
) == 0)
5866 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5867 else if (STRINGP (icon
))
5869 /* Load the main icon from the named file. */
5870 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5871 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5872 /* Try to load a small icon to go with it. */
5873 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5874 GetSystemMetrics (SM_CXSMICON
),
5875 GetSystemMetrics (SM_CYSMICON
),
5878 else if (SYMBOLP (icon
))
5882 if (EQ (icon
, intern ("application")))
5883 name
= (LPCTSTR
) IDI_APPLICATION
;
5884 else if (EQ (icon
, intern ("hand")))
5885 name
= (LPCTSTR
) IDI_HAND
;
5886 else if (EQ (icon
, intern ("question")))
5887 name
= (LPCTSTR
) IDI_QUESTION
;
5888 else if (EQ (icon
, intern ("exclamation")))
5889 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5890 else if (EQ (icon
, intern ("asterisk")))
5891 name
= (LPCTSTR
) IDI_ASTERISK
;
5892 else if (EQ (icon
, intern ("winlogo")))
5893 name
= (LPCTSTR
) IDI_WINLOGO
;
5897 main_icon
= LoadIcon (NULL
, name
);
5902 if (main_icon
== NULL
)
5905 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5906 (LPARAM
) main_icon
);
5908 /* If there is a small icon that goes with it, set that too. */
5910 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5911 (LPARAM
) small_icon
);
5917 /************************************************************************
5919 ************************************************************************/
5921 /* Display Error Handling functions not used on W32. Listing them here
5922 helps diff stay in step when comparing w32term.c with xterm.c.
5924 x_error_catcher (display, error)
5925 x_catch_errors (dpy)
5926 x_catch_errors_unwind (old_val)
5927 x_check_errors (dpy, format)
5928 x_fully_uncatch_errors ()
5929 x_had_errors_p (dpy)
5930 x_clear_errors (dpy)
5931 x_uncatch_errors (dpy, count)
5933 x_connection_signal (signalnum)
5934 x_connection_closed (dpy, error_message)
5935 x_error_quitter (display, error)
5936 x_error_handler (display, error)
5937 x_io_error_quitter (display)
5942 /* Changing the font of the frame. */
5945 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
5947 struct font
*font
= XFONT_OBJECT (font_object
);
5948 int unit
, font_ascent
, font_descent
;
5951 fontset
= fontset_from_font (font_object
);
5952 FRAME_FONTSET (f
) = fontset
;
5953 if (FRAME_FONT (f
) == font
)
5954 /* This font is already set in frame F. There's nothing more to
5958 FRAME_FONT (f
) = font
;
5959 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5960 FRAME_COLUMN_WIDTH (f
) = unit
= font
->average_width
;
5961 get_font_ascent_descent (font
, &font_ascent
, &font_descent
);
5962 FRAME_LINE_HEIGHT (f
) = font_ascent
+ font_descent
;
5964 /* Compute number of scrollbar columns. */
5965 unit
= FRAME_COLUMN_WIDTH (f
);
5966 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5967 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5968 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
5971 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
5972 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) =
5973 FRAME_CONFIG_SCROLL_BAR_COLS (f
) * unit
;
5976 /* Now make the frame display the given font. */
5977 if (FRAME_X_WINDOW (f
) != 0)
5979 /* Don't change the size of a tip frame; there's no point in
5980 doing it because it's done in Fx_show_tip, and it leads to
5981 problems because the tip frame has no widget. */
5982 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5983 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
5984 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
5988 /* X version sets font of input methods here also. */
5994 /***********************************************************************
5995 TODO: W32 Input Methods
5996 ***********************************************************************/
5997 /* Listing missing functions from xterm.c helps diff stay in step.
5999 xim_destroy_callback (xim, client_data, call_data)
6000 xim_open_dpy (dpyinfo, resource_name)
6002 xim_instantiate_callback (display, client_data, call_data)
6003 xim_initialize (dpyinfo, resource_name)
6004 xim_close_dpy (dpyinfo)
6009 /* Calculate the absolute position in frame F
6010 from its current recorded position values and gravity. */
6013 x_calc_absolute_position (struct frame
*f
)
6015 int flags
= f
->size_hint_flags
;
6017 /* The sum of the widths of the frame's left and right borders, and
6018 the sum of the heights of the frame's top and bottom borders (in
6019 pixels) drawn by Windows. */
6020 unsigned int left_right_borders_width
, top_bottom_borders_height
;
6022 /* Try to get the actual values of these two variables. We compute
6023 the border width (height) by subtracting the width (height) of
6024 the frame's client area from the width (height) of the frame's
6026 WINDOWPLACEMENT wp
= { 0 };
6027 RECT client_rect
= { 0 };
6029 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
6030 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
6032 left_right_borders_width
=
6033 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
6034 (client_rect
.right
- client_rect
.left
);
6036 top_bottom_borders_height
=
6037 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
6038 (client_rect
.bottom
- client_rect
.top
);
6042 /* Use sensible default values. */
6043 left_right_borders_width
= 8;
6044 top_bottom_borders_height
= 32;
6047 /* With multiple monitors, we can legitimately get negative
6048 coordinates (for monitors above or to the left of the primary
6049 monitor). Find the display origin to ensure negative positions
6050 are computed correctly (Bug#21173). */
6051 int display_left
= 0;
6052 int display_top
= 0;
6053 struct frame
*p
= FRAME_PARENT_FRAME (f
);
6055 if (flags
& (XNegative
| YNegative
))
6059 list
= Fw32_display_monitor_attributes_list (Qnil
);
6060 while (CONSP (list
))
6062 Lisp_Object attributes
= CAR(list
);
6063 Lisp_Object geometry
;
6064 Lisp_Object monitor_left
, monitor_top
;
6068 geometry
= Fassoc (Qgeometry
, attributes
);
6069 if (!NILP (geometry
))
6071 monitor_left
= Fnth (make_number (1), geometry
);
6072 monitor_top
= Fnth (make_number (2), geometry
);
6074 display_left
= min (display_left
, XINT (monitor_left
));
6075 display_top
= min (display_top
, XINT (monitor_top
));
6080 /* Treat negative positions as relative to the rightmost bottommost
6081 position that fits on the screen. */
6082 if (flags
& XNegative
)
6085 f
->left_pos
= (FRAME_PIXEL_WIDTH (p
)
6086 - FRAME_PIXEL_WIDTH (f
)
6088 - (left_right_borders_width
- 1));
6090 f
->left_pos
= (x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
6092 - FRAME_PIXEL_WIDTH (f
)
6094 - (left_right_borders_width
- 1));
6097 if (flags
& YNegative
)
6100 f
->top_pos
= (FRAME_PIXEL_HEIGHT (p
)
6101 - FRAME_PIXEL_HEIGHT (f
)
6103 - (top_bottom_borders_height
- 1));
6105 f
->top_pos
= (x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
6107 - FRAME_PIXEL_HEIGHT (f
)
6109 - (top_bottom_borders_height
- 1));
6112 /* The left_pos and top_pos are now relative to the top and left
6113 screen edges, so the flags should correspond. */
6114 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6117 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
6118 to really change the position, and 0 when calling from
6119 x_make_frame_visible (in that case, XOFF and YOFF are the current
6120 position values). It is -1 when calling from x_set_frame_parameters,
6121 which means, do adjust for borders but don't change the gravity. */
6124 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
,
6127 int modified_top
, modified_left
;
6129 if (change_gravity
> 0)
6133 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6135 f
->size_hint_flags
|= XNegative
;
6137 f
->size_hint_flags
|= YNegative
;
6138 f
->win_gravity
= NorthWestGravity
;
6140 x_calc_absolute_position (f
);
6143 x_wm_set_size_hint (f
, (long) 0, false);
6145 modified_left
= f
->left_pos
;
6146 modified_top
= f
->top_pos
;
6148 if (!FRAME_PARENT_FRAME (f
))
6149 my_set_window_pos (FRAME_W32_WINDOW (f
), NULL
,
6150 modified_left
, modified_top
,
6152 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6154 my_set_window_pos (FRAME_W32_WINDOW (f
), HWND_TOP
,
6155 modified_left
, modified_top
,
6157 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6162 w32fullscreen_hook (struct frame
*f
)
6164 if (FRAME_VISIBLE_P (f
))
6166 HWND hwnd
= FRAME_W32_WINDOW(f
);
6167 DWORD dwStyle
= GetWindowLong (hwnd
, GWL_STYLE
);
6169 enum fullscreen_type prev_fsmode
= FRAME_PREV_FSMODE (f
);
6172 f
->want_fullscreen
&= ~FULLSCREEN_WAIT
;
6174 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_NONE
)
6175 GetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6177 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_BOTH
)
6179 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
| WS_OVERLAPPEDWINDOW
);
6180 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6182 else if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_HEIGHT
6183 || FRAME_PREV_FSMODE (f
) == FULLSCREEN_WIDTH
)
6184 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6186 FRAME_PREV_FSMODE (f
) = f
->want_fullscreen
;
6188 if (f
->want_fullscreen
== FULLSCREEN_NONE
)
6189 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6190 else if (f
->want_fullscreen
== FULLSCREEN_MAXIMIZED
)
6192 if (prev_fsmode
== FULLSCREEN_BOTH
|| prev_fsmode
== FULLSCREEN_WIDTH
6193 || prev_fsmode
== FULLSCREEN_HEIGHT
)
6194 /* Make window normal since otherwise the subsequent
6195 maximization might fail in some cases. */
6196 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6197 ShowWindow (hwnd
, SW_MAXIMIZE
);
6199 else if (f
->want_fullscreen
== FULLSCREEN_BOTH
)
6201 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6203 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6204 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6205 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
& ~WS_OVERLAPPEDWINDOW
);
6206 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6207 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
,
6208 SWP_NOOWNERZORDER
| SWP_FRAMECHANGED
);
6210 (f
, FRAME_PIXEL_TO_TEXT_WIDTH (f
, rect
.right
- rect
.left
),
6211 FRAME_PIXEL_TO_TEXT_HEIGHT (f
, (rect
.bottom
- rect
.top
6212 - menu_bar_height
)),
6217 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6218 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6219 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6220 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6221 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, 0);
6223 if (f
->want_fullscreen
== FULLSCREEN_WIDTH
)
6225 int border_width
= GetSystemMetrics (SM_CXFRAME
);
6228 (f
, (FRAME_PIXEL_TO_TEXT_WIDTH
6229 (f
, rect
.right
- rect
.left
- 2 * border_width
)),
6234 int border_height
= GetSystemMetrics (SM_CYFRAME
);
6235 /* Won't work for wrapped menu bar. */
6236 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6237 int title_height
= GetSystemMetrics (SM_CYCAPTION
);
6240 (f
, 0, (FRAME_PIXEL_TO_TEXT_HEIGHT
6241 (f
, rect
.bottom
- rect
.top
- 2 * border_height
6242 - title_height
- menu_bar_height
)),
6247 f
->want_fullscreen
= FULLSCREEN_NONE
;
6250 if (f
->want_fullscreen
== FULLSCREEN_BOTH
6251 || f
->want_fullscreen
== FULLSCREEN_WIDTH
6252 || f
->want_fullscreen
== FULLSCREEN_HEIGHT
)
6253 do_pending_window_change (0);
6257 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
6260 /* Call this to change the size of frame F's x-window.
6261 If CHANGE_GRAVITY, change to top-left-corner window gravity
6262 for this size change and subsequent size changes.
6263 Otherwise we leave the window gravity unchanged. */
6266 x_set_window_size (struct frame
*f
, bool change_gravity
,
6267 int width
, int height
, bool pixelwise
)
6269 int pixelwidth
, pixelheight
;
6270 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
6273 int menu_bar_height
;
6277 /* Get the height of the menu bar here. It's used below to detect
6278 whether the menu bar is wrapped. It's also used to specify the
6279 third argument for AdjustWindowRect. See bug#22105. */
6280 info
.cbSize
= sizeof (info
);
6281 info
.rcBar
.top
= info
.rcBar
.bottom
= 0;
6282 GetMenuBarInfo (FRAME_W32_WINDOW (f
), 0xFFFFFFFD, 0, &info
);
6283 menu_bar_height
= info
.rcBar
.bottom
- info
.rcBar
.top
;
6287 pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
6288 pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
6292 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
);
6293 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
);
6296 if (w32_add_wrapped_menu_bar_lines
)
6298 /* When the menu bar wraps sending a SetWindowPos shrinks the
6299 height of the frame then the wrapped menu bar lines are not
6300 accounted for (Bug#15174 and Bug#18720). Here we add these
6301 extra lines to the frame height. */
6302 int default_menu_bar_height
;
6304 /* Why is (apparently) SM_CYMENUSIZE needed here instead of
6306 default_menu_bar_height
= GetSystemMetrics (SM_CYMENUSIZE
);
6308 if ((default_menu_bar_height
> 0)
6309 && (menu_bar_height
> default_menu_bar_height
)
6310 && ((menu_bar_height
% default_menu_bar_height
) == 0))
6311 pixelheight
= pixelheight
+ menu_bar_height
- default_menu_bar_height
;
6314 f
->win_gravity
= NorthWestGravity
;
6315 x_wm_set_size_hint (f
, (long) 0, false);
6317 rect
.left
= rect
.top
= 0;
6318 rect
.right
= pixelwidth
;
6319 rect
.bottom
= pixelheight
;
6321 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
, menu_bar_height
> 0);
6323 if (!(f
->after_make_frame
)
6324 && !(f
->want_fullscreen
& FULLSCREEN_WAIT
)
6325 && FRAME_VISIBLE_P (f
))
6329 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6331 if (EQ (fullscreen
, Qmaximized
)
6332 || EQ (fullscreen
, Qfullboth
)
6333 || EQ (fullscreen
, Qfullwidth
))
6335 rect
.left
= window_rect
.left
;
6336 rect
.right
= window_rect
.right
;
6339 if (EQ (fullscreen
, Qmaximized
)
6340 || EQ (fullscreen
, Qfullboth
)
6341 || EQ (fullscreen
, Qfullheight
))
6343 rect
.top
= window_rect
.top
;
6344 rect
.bottom
= window_rect
.bottom
;
6349 if (pixelwidth
> 0 || pixelheight
> 0)
6351 frame_size_history_add
6352 (f
, Qx_set_window_size_1
, width
, height
,
6353 list2 (Fcons (make_number (pixelwidth
),
6354 make_number (pixelheight
)),
6355 Fcons (make_number (rect
.right
- rect
.left
),
6356 make_number (rect
.bottom
- rect
.top
))));
6358 if (!FRAME_PARENT_FRAME (f
))
6359 my_set_window_pos (FRAME_W32_WINDOW (f
), NULL
,
6361 rect
.right
- rect
.left
,
6362 rect
.bottom
- rect
.top
,
6363 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6365 my_set_window_pos (FRAME_W32_WINDOW (f
), HWND_TOP
,
6367 rect
.right
- rect
.left
,
6368 rect
.bottom
- rect
.top
,
6369 SWP_NOMOVE
| SWP_NOACTIVATE
);
6371 change_frame_size (f
,
6373 ? 0 : FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
)),
6375 ? 0 : FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
)),
6377 SET_FRAME_GARBAGED (f
);
6379 /* If cursor was outside the new size, mark it as off. */
6380 mark_window_cursors_off (XWINDOW (f
->root_window
));
6382 /* Clear out any recollection of where the mouse highlighting was,
6383 since it might be in a place that's outside the new frame size.
6384 Actually checking whether it is outside is a pain in the neck,
6385 so don't try--just let the highlighting be done afresh with new
6387 cancel_mouse_face (f
);
6392 do_pending_window_change (false);
6395 /* Mouse warping. */
6398 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
6407 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
6408 pt
.x
= rect
.left
+ pix_x
;
6409 pt
.y
= rect
.top
+ pix_y
;
6410 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
6412 /* When "mouse trails" are in effect, moving the mouse cursor
6413 sometimes leaves behind an annoying "ghost" of the pointer.
6414 Avoid that by momentarily switching off mouse trails. */
6415 if (os_subtype
== OS_NT
6416 && w32_major_version
+ w32_minor_version
>= 6)
6417 ret
= SystemParametersInfo (SPI_GETMOUSETRAILS
, 0, &trail_num
, 0);
6418 SetCursorPos (pt
.x
, pt
.y
);
6420 SystemParametersInfo (SPI_SETMOUSETRAILS
, trail_num
, NULL
, 0);
6426 /* Focus shifting, raising and lowering. */
6428 /* The NOACTIVATE argument has no effect on Windows. According to the
6429 Windows API: An application cannot activate an inactive window
6430 without also bringing it to the top of the Z order. */
6433 x_focus_frame (struct frame
*f
, bool noactivate
)
6436 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6439 /* Give input focus to frame. */
6442 /* Try not to change its Z-order if possible. */
6443 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
6444 my_set_focus (f
, FRAME_W32_WINDOW (f
));
6447 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6451 /* Raise frame F. */
6453 x_raise_frame (struct frame
*f
)
6457 /* Strictly speaking, raise-frame should only change the frame's Z
6458 order, leaving input focus unchanged. This is reasonable behavior
6459 on X where the usual policy is point-to-focus. However, this
6460 behavior would be very odd on Windows where the usual policy is
6463 On X, if the mouse happens to be over the raised frame, it gets
6464 input focus anyway (so the window with focus will never be
6465 completely obscured) - if not, then just moving the mouse over it
6466 is sufficient to give it focus. On Windows, the user must actually
6467 click on the frame (preferably the title bar so as not to move
6468 point), which is more awkward. Also, no other Windows program
6469 raises a window to the top but leaves another window (possibly now
6470 completely obscured) with input focus.
6472 Because there is a system setting on Windows that allows the user
6473 to choose the point to focus policy, we make the strict semantics
6474 optional, but by default we grab focus when raising. */
6476 if (NILP (Vw32_grab_focus_on_raise
))
6478 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6479 not already the foreground application: the frame is raised
6480 above all other frames belonging to us, but not above the
6481 current top window. To achieve that, we have to resort to this
6482 more cumbersome method. */
6484 HDWP handle
= BeginDeferWindowPos (2);
6487 handle
= DeferWindowPos (handle
,
6488 FRAME_W32_WINDOW (f
),
6491 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6494 handle
= DeferWindowPos (handle
,
6495 GetForegroundWindow (),
6496 FRAME_W32_WINDOW (f
),
6498 SWP_NOSIZE
| SWP_NOMOVE
|
6501 EndDeferWindowPos (handle
);
6507 my_bring_window_to_top (FRAME_W32_WINDOW (f
));
6513 /* Lower frame F. */
6515 x_lower_frame (struct frame
*f
)
6518 my_set_window_pos (FRAME_W32_WINDOW (f
),
6521 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6526 w32_frame_raise_lower (struct frame
*f
, bool raise_flag
)
6528 if (! FRAME_W32_P (f
))
6537 /* Change of visibility. */
6539 /* This tries to wait until the frame is really visible.
6540 However, if the window manager asks the user where to position
6541 the frame, this will return before the user finishes doing that.
6542 The frame will not actually be visible at that time,
6543 but it will become visible later when the window manager
6544 finishes with it. */
6547 x_make_frame_visible (struct frame
*f
)
6551 x_set_bitmap_icon (f
);
6553 if (! FRAME_VISIBLE_P (f
))
6555 /* We test FRAME_GARBAGED_P here to make sure we don't
6556 call x_set_offset a second time
6557 if we get to x_make_frame_visible a second time
6558 before the window gets really visible. */
6559 if (! FRAME_ICONIFIED_P (f
)
6560 && ! f
->output_data
.w32
->asked_for_visible
)
6562 if (!FRAME_PARENT_FRAME (f
))
6567 /* Adjust vertical window position in order to avoid being
6568 covered by a taskbar placed at the bottom of the desktop. */
6569 SystemParametersInfo (SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6570 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6571 if (window_rect
.bottom
> workarea_rect
.bottom
6572 && window_rect
.top
> workarea_rect
.top
)
6573 f
->top_pos
= max (window_rect
.top
6574 - window_rect
.bottom
+ workarea_rect
.bottom
,
6578 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6581 f
->output_data
.w32
->asked_for_visible
= 1;
6583 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
6584 causes unexpected behavior when unminimizing frames that were
6585 previously maximized. But only SW_SHOWNORMAL works properly for
6586 frames that were truely hidden (using make-frame-invisible), so
6587 we need it to avoid Bug#5482. It seems that iconified is only
6588 set for minimized windows that are still visible, so use that to
6589 determine the appropriate flag to pass ShowWindow. */
6590 my_show_window (f
, FRAME_W32_WINDOW (f
),
6591 FRAME_ICONIFIED_P (f
)
6593 : FRAME_NO_FOCUS_ON_MAP (f
)
6598 /* Synchronize to ensure Emacs knows the frame is visible
6599 before we do anything else. We do this loop with input not blocked
6600 so that incoming events are handled. */
6605 /* This must come after we set COUNT. */
6608 XSETFRAME (frame
, f
);
6610 /* Wait until the frame is visible. Process X events until a
6611 MapNotify event has been seen, or until we think we won't get a
6612 MapNotify at all.. */
6613 for (count
= input_signal_count
+ 10;
6614 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6616 /* Force processing of queued events. */
6617 /* TODO: x_sync equivalent? */
6619 /* Machines that do polling rather than SIGIO have been observed
6620 to go into a busy-wait here. So we'll fake an alarm signal
6621 to let the handler know that there's something to be read.
6622 We used to raise a real alarm, but it seems that the handler
6623 isn't always enabled here. This is probably a bug. */
6624 if (input_polling_used ())
6626 /* It could be confusing if a real alarm arrives while processing
6627 the fake one. Turn it off and let the handler reset it. */
6628 int old_poll_suppress_count
= poll_suppress_count
;
6629 poll_suppress_count
= 1;
6630 poll_for_input_1 ();
6631 poll_suppress_count
= old_poll_suppress_count
;
6637 /* Change from mapped state to withdrawn state. */
6639 /* Make the frame visible (mapped and not iconified). */
6642 x_make_frame_invisible (struct frame
*f
)
6644 /* Don't keep the highlight on an invisible frame. */
6645 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6646 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6650 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6652 /* We can't distinguish this from iconification
6653 just by the event that we get from the server.
6654 So we can't win using the usual strategy of letting
6655 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6656 and synchronize with the server to make sure we agree. */
6657 SET_FRAME_VISIBLE (f
, 0);
6658 SET_FRAME_ICONIFIED (f
, false);
6663 /* Change window state from mapped to iconified. */
6666 x_iconify_frame (struct frame
*f
)
6668 /* Don't keep the highlight on an invisible frame. */
6669 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6670 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6672 if (FRAME_ICONIFIED_P (f
))
6677 x_set_bitmap_icon (f
);
6679 /* Simulate the user minimizing the frame. */
6680 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0,
6683 SET_FRAME_VISIBLE (f
, 0);
6684 SET_FRAME_ICONIFIED (f
, true);
6690 /* Free X resources of frame F. */
6693 x_free_frame_resources (struct frame
*f
)
6695 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6696 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
6700 /* We must free faces before destroying windows because some
6701 font-driver (e.g. xft) access a window while finishing a
6703 free_frame_faces (f
);
6705 if (FRAME_W32_WINDOW (f
))
6706 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6708 free_frame_menubar (f
);
6710 xfree (f
->output_data
.w32
);
6711 f
->output_data
.w32
= NULL
;
6713 if (f
== dpyinfo
->w32_focus_frame
)
6714 dpyinfo
->w32_focus_frame
= 0;
6715 if (f
== dpyinfo
->w32_focus_event_frame
)
6716 dpyinfo
->w32_focus_event_frame
= 0;
6717 if (f
== dpyinfo
->x_highlight_frame
)
6718 dpyinfo
->x_highlight_frame
= 0;
6719 if (f
== hlinfo
->mouse_face_mouse_frame
)
6720 reset_mouse_highlight (hlinfo
);
6726 /* Destroy the window of frame F. */
6728 x_destroy_window (struct frame
*f
)
6730 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6732 x_free_frame_resources (f
);
6733 dpyinfo
->reference_count
--;
6737 /* Setting window manager hints. */
6739 /* Set the normal size hints for the window manager, for frame F.
6740 FLAGS is the flags word to use--or 0 meaning preserve the flags
6741 that the window now has.
6742 If USER_POSITION, set the USPosition
6743 flag (this is useful when FLAGS is 0). */
6745 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
6747 Window window
= FRAME_W32_WINDOW (f
);
6751 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6752 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6753 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6754 SetWindowLong (window
, WND_VSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_WIDTH (f
));
6755 SetWindowLong (window
, WND_HSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_HEIGHT (f
));
6760 /***********************************************************************
6762 ***********************************************************************/
6766 /* Check that FONT is valid on frame F. It is if it can be found in F's
6770 x_check_font (struct frame
*f
, struct font
*font
)
6772 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
6773 if (font
->driver
->check
)
6774 eassert (font
->driver
->check (f
, font
) == 0);
6777 #endif /* GLYPH_DEBUG */
6779 /* Show hourglass cursor on frame F. */
6782 w32_show_hourglass (struct frame
*f
)
6784 if (!menubar_in_use
&& !current_popup_menu
)
6786 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6788 w32
->hourglass_p
= 1;
6789 SetCursor (w32
->hourglass_cursor
);
6793 /* Hide hourglass cursor on frame F. */
6796 w32_hide_hourglass (struct frame
*f
)
6798 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6800 w32
->hourglass_p
= 0;
6801 if (f
->pointer_invisible
)
6804 SetCursor (w32
->current_cursor
);
6807 /* FIXME: old code did that, but I don't know why. Anyway,
6808 this is used for non-GUI frames (see cancel_hourglass). */
6811 w32_arrow_cursor (void)
6813 SetCursor (w32_load_cursor (IDC_ARROW
));
6817 w32_toggle_invisible_pointer (struct frame
*f
, bool invisible
)
6821 if (f
->pointer_invisible
!= invisible
)
6823 f
->pointer_invisible
= invisible
;
6824 w32_define_cursor (FRAME_W32_WINDOW (f
),
6825 f
->output_data
.w32
->current_cursor
);
6831 /***********************************************************************
6833 ***********************************************************************/
6835 static int w32_initialized
= 0;
6838 w32_initialize_display_info (Lisp_Object display_name
)
6840 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6842 memset (dpyinfo
, 0, sizeof (*dpyinfo
));
6844 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
6845 dpyinfo
->w32_id_name
= xmalloc (SCHARS (Vinvocation_name
)
6846 + SCHARS (Vsystem_name
) + 2);
6847 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6848 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6850 /* Default Console mode values - overridden when running in GUI mode
6851 with values obtained from system metrics. */
6854 dpyinfo
->n_planes
= 1;
6855 dpyinfo
->n_cbits
= 4;
6856 dpyinfo
->n_fonts
= 0;
6857 dpyinfo
->smallest_font_height
= 1;
6858 dpyinfo
->smallest_char_width
= 1;
6859 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6860 dpyinfo
->horizontal_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6861 /* TODO: dpyinfo->gray */
6863 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
6866 /* Create an xrdb-style database of resources to supersede registry settings.
6867 The database is just a concatenation of C strings, finished by an additional
6868 \0. The strings are submitted to some basic normalization, so
6870 [ *]option[ *]:[ *]value...
6876 but any whitespace following value is not removed. */
6879 w32_make_rdb (char *xrm_option
)
6881 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6882 char *current
= buffer
;
6885 int before_value
= 0;
6899 if (in_option
&& (ch
== ':'))
6904 else if (before_value
)
6909 else if (!(in_option
|| before_value
))
6920 extern frame_parm_handler w32_frame_parm_handlers
[];
6922 static struct redisplay_interface w32_redisplay_interface
=
6924 w32_frame_parm_handlers
,
6928 x_clear_end_of_line
,
6930 x_after_update_window_line
,
6931 x_update_window_begin
,
6932 x_update_window_end
,
6933 0, /* flush_display */
6934 x_clear_window_mouse_face
,
6935 x_get_glyph_overhangs
,
6936 x_fix_overlapping_area
,
6937 w32_draw_fringe_bitmap
,
6938 w32_define_fringe_bitmap
,
6939 w32_destroy_fringe_bitmap
,
6940 w32_compute_glyph_string_overhangs
,
6941 x_draw_glyph_string
,
6942 w32_define_frame_cursor
,
6943 w32_clear_frame_area
,
6944 w32_draw_window_cursor
,
6945 w32_draw_vertical_window_border
,
6946 w32_draw_window_divider
,
6947 w32_shift_glyphs_for_insert
,
6952 static void x_delete_terminal (struct terminal
*term
);
6954 static struct terminal
*
6955 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6957 struct terminal
*terminal
;
6959 terminal
= create_terminal (output_w32
, &w32_redisplay_interface
);
6961 terminal
->display_info
.w32
= dpyinfo
;
6962 dpyinfo
->terminal
= terminal
;
6964 /* MSVC does not type K&R functions with no arguments correctly, and
6965 so we must explicitly cast them. */
6966 terminal
->clear_frame_hook
= x_clear_frame
;
6967 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6968 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6969 terminal
->ring_bell_hook
= w32_ring_bell
;
6970 terminal
->toggle_invisible_pointer_hook
= w32_toggle_invisible_pointer
;
6971 terminal
->update_begin_hook
= x_update_begin
;
6972 terminal
->update_end_hook
= x_update_end
;
6973 terminal
->read_socket_hook
= w32_read_socket
;
6974 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6975 terminal
->mouse_position_hook
= w32_mouse_position
;
6976 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6977 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6978 terminal
->fullscreen_hook
= w32fullscreen_hook
;
6979 terminal
->menu_show_hook
= w32_menu_show
;
6980 terminal
->popup_dialog_hook
= w32_popup_dialog
;
6981 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6982 terminal
->set_horizontal_scroll_bar_hook
= w32_set_horizontal_scroll_bar
;
6983 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6984 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6985 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6986 terminal
->delete_frame_hook
= x_destroy_window
;
6987 terminal
->delete_terminal_hook
= x_delete_terminal
;
6988 /* Other hooks are NULL by default. */
6990 /* We don't yet support separate terminals on W32, so don't try to share
6991 keyboards between virtual terminals that are on the same physical
6992 terminal like X does. */
6993 terminal
->kboard
= allocate_kboard (Qw32
);
6994 /* Don't let the initial kboard remain current longer than necessary.
6995 That would cause problems if a file loaded on startup tries to
6996 prompt in the mini-buffer. */
6997 if (current_kboard
== initial_kboard
)
6998 current_kboard
= terminal
->kboard
;
6999 terminal
->kboard
->reference_count
++;
7005 x_delete_terminal (struct terminal
*terminal
)
7007 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
7009 /* Protect against recursive calls. delete_frame in
7010 delete_terminal calls us back when it deletes our last frame. */
7011 if (!terminal
->name
)
7016 x_delete_display (dpyinfo
);
7020 struct w32_display_info
*
7021 w32_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
7023 struct w32_display_info
*dpyinfo
;
7024 struct terminal
*terminal
;
7029 if (!w32_initialized
)
7032 w32_initialized
= 1;
7035 w32_initialize_display_info (display_name
);
7037 dpyinfo
= &one_w32_display_info
;
7038 terminal
= w32_create_terminal (dpyinfo
);
7040 /* Set the name of the terminal. */
7041 terminal
->name
= xlispstrdup (display_name
);
7043 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
7045 /* Put this display on the chain. */
7046 dpyinfo
->next
= x_display_list
;
7047 x_display_list
= dpyinfo
;
7051 dpyinfo
->root_window
= GetDesktopWindow ();
7052 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
7053 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
7054 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
7055 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
7056 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
7057 ReleaseDC (NULL
, hdc
);
7059 /* initialize palette with white and black */
7062 w32_defined_color (0, "white", &color
, 1);
7063 w32_defined_color (0, "black", &color
, 1);
7067 /* Add the default keyboard. When !WINDOWSNT, we're using the
7068 standard Emacs console handling machinery and don't need an
7069 explicit FD here. */
7070 add_keyboard_wait_descriptor (0);
7072 /* /dev/windows wakes us up when we have a thread message pending. */
7073 add_keyboard_wait_descriptor (w32_message_fd
);
7076 /* Create Fringe Bitmaps and store them for later use.
7078 On W32, bitmaps are all unsigned short, as Windows requires
7079 bitmap data to be Word aligned. For some reason they are
7080 horizontally reflected compared to how they appear on X, so we
7081 need to bitswap and convert to unsigned shorts before creating
7083 w32_init_fringe (terminal
->rif
);
7090 /* Get rid of display DPYINFO, assuming all frames are already gone. */
7092 x_delete_display (struct w32_display_info
*dpyinfo
)
7094 /* FIXME: the only display info apparently can't be deleted. */
7095 /* free palette table */
7097 struct w32_palette_entry
* plist
;
7099 plist
= dpyinfo
->color_list
;
7102 struct w32_palette_entry
* pentry
= plist
;
7103 plist
= plist
->next
;
7106 dpyinfo
->color_list
= NULL
;
7107 if (dpyinfo
->palette
)
7108 DeleteObject (dpyinfo
->palette
);
7110 w32_reset_fringes ();
7114 /* Set up use of W32. */
7117 w32_init_main_thread (void)
7119 dwMainThreadId
= GetCurrentThreadId ();
7120 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
7121 GetCurrentProcess (), &hMainThread
, 0, TRUE
,
7122 DUPLICATE_SAME_ACCESS
);
7127 DWORD WINAPI
w32_msg_worker (void * arg
);
7130 w32_initialize (void)
7133 HRESULT (WINAPI
* set_user_model
) (const wchar_t * id
);
7137 w32_system_caret_hwnd
= NULL
;
7138 w32_system_caret_height
= 0;
7139 w32_system_caret_x
= 0;
7140 w32_system_caret_y
= 0;
7142 /* On Windows 7 and later, we need to set the user model ID
7143 to associate emacsclient launched files with Emacs frames
7145 shell
= GetModuleHandle ("shell32.dll");
7149 = (void *) GetProcAddress (shell
,
7150 "SetCurrentProcessExplicitAppUserModelID");
7152 /* If the function is defined, then we are running on Windows 7
7153 or newer, and the UI uses this to group related windows
7154 together. Since emacs, runemacs, emacsclient are related, we
7155 want them grouped even though the executables are different,
7156 so we need to set a consistent ID between them. */
7158 set_user_model (L
"GNU.Emacs");
7162 if ((w32_message_fd
= emacs_open ("/dev/windows", O_RDWR
, 0)) == -1)
7163 fatal ("opening /dev/windows: %s", strerror (errno
));
7166 /* Initialize w32_use_visible_system_caret based on whether a screen
7167 reader is in use. */
7168 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
7169 &w32_use_visible_system_caret
, 0))
7170 w32_use_visible_system_caret
= 0;
7172 any_help_event_p
= 0;
7174 /* Initialize input mode: interrupt_input off, no flow control, allow
7175 8 bit character input, standard quit char. */
7176 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
7179 LCID input_locale_id
= LOWORD (GetKeyboardLayout (0));
7180 w32_keyboard_codepage
= codepage_for_locale (input_locale_id
);
7183 /* Create the window thread - it will terminate itself when the app
7187 /* Wait for thread to start */
7191 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
7193 hWindowsThread
= CreateThread (NULL
, 0,
7195 0, 0, &dwWindowsThreadId
);
7197 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
7200 /* It is desirable that mainThread should have the same notion of
7201 focus window and active window as windowsThread. Unfortunately, the
7202 following call to AttachThreadInput, which should do precisely what
7203 we need, causes major problems when Emacs is linked as a console
7204 program. Unfortunately, we have good reasons for doing that, so
7205 instead we need to send messages to windowsThread to make some API
7206 calls for us (ones that affect, or depend on, the active/focus
7208 #ifdef ATTACH_THREADS
7209 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
7212 /* Dynamically link to optional system components. */
7214 HMODULE user_lib
= GetModuleHandle ("user32.dll");
7216 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7218 LOAD_PROC (user_lib
, SetLayeredWindowAttributes
);
7222 /* Ensure scrollbar handles are at least 5 pixels. */
7223 vertical_scroll_bar_min_handle
= 5;
7224 horizontal_scroll_bar_min_handle
= 5;
7226 /* For either kind of scroll bar, take account of the arrows; these
7227 effectively form the border of the main scroll bar range. */
7228 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
7229 = GetSystemMetrics (SM_CYVSCROLL
);
7230 horizontal_scroll_bar_left_border
= horizontal_scroll_bar_right_border
7231 = GetSystemMetrics (SM_CYHSCROLL
);
7236 syms_of_w32term (void)
7238 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
7240 DEFSYM (Qadded
, "added");
7241 DEFSYM (Qremoved
, "removed");
7242 DEFSYM (Qmodified
, "modified");
7243 DEFSYM (Qrenamed_from
, "renamed-from");
7244 DEFSYM (Qrenamed_to
, "renamed-to");
7246 DEFVAR_INT ("w32-num-mouse-buttons",
7247 w32_num_mouse_buttons
,
7248 doc
: /* Number of physical mouse buttons. */);
7249 w32_num_mouse_buttons
= 2;
7251 DEFVAR_LISP ("w32-swap-mouse-buttons",
7252 Vw32_swap_mouse_buttons
,
7253 doc
: /* Swap the mapping of middle and right mouse buttons.
7254 When nil, middle button is mouse-2 and right button is mouse-3. */);
7255 Vw32_swap_mouse_buttons
= Qnil
;
7257 DEFVAR_LISP ("w32-grab-focus-on-raise",
7258 Vw32_grab_focus_on_raise
,
7259 doc
: /* Raised frame grabs input focus.
7260 When t, `raise-frame' grabs input focus as well. This fits well
7261 with the normal Windows click-to-focus policy, but might not be
7262 desirable when using a point-to-focus policy. */);
7263 Vw32_grab_focus_on_raise
= Qt
;
7265 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7266 Vw32_capslock_is_shiftlock
,
7267 doc
: /* Apply CapsLock state to non character input keys.
7268 When nil, CapsLock only affects normal character input keys. */);
7269 Vw32_capslock_is_shiftlock
= Qnil
;
7271 DEFVAR_LISP ("w32-recognize-altgr",
7272 Vw32_recognize_altgr
,
7273 doc
: /* Recognize right-alt and left-ctrl as AltGr.
7274 When nil, the right-alt and left-ctrl key combination is
7275 interpreted normally. */);
7276 Vw32_recognize_altgr
= Qt
;
7278 DEFVAR_BOOL ("w32-use-visible-system-caret",
7279 w32_use_visible_system_caret
,
7280 doc
: /* Flag to make the system caret visible.
7281 When this is non-nil, Emacs will indicate the position of point by
7282 using the system caret instead of drawing its own cursor. Some screen
7283 reader software does not track the system cursor properly when it is
7284 invisible, and gets confused by Emacs drawing its own cursor, so this
7285 variable is initialized to t when Emacs detects that screen reader
7286 software is running as it starts up.
7288 When this variable is set, other variables affecting the appearance of
7289 the cursor have no effect. */);
7291 w32_use_visible_system_caret
= 0;
7293 /* We don't yet support this, but defining this here avoids whining
7294 from cus-start.el and other places, like "M-x set-variable". */
7295 DEFVAR_BOOL ("x-use-underline-position-properties",
7296 x_use_underline_position_properties
,
7297 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
7298 A value of nil means ignore them. If you encounter fonts with bogus
7299 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7300 to 4.1, set this to nil. You can also use `underline-minimum-offset'
7301 to override the font's UNDERLINE_POSITION for small font display
7303 x_use_underline_position_properties
= 0;
7305 DEFVAR_BOOL ("x-underline-at-descent-line",
7306 x_underline_at_descent_line
,
7307 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
7308 A value of nil means to draw the underline according to the value of the
7309 variable `x-use-underline-position-properties', which is usually at the
7310 baseline level. The default value is nil. */);
7311 x_underline_at_descent_line
= 0;
7313 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
7314 doc
: /* Which toolkit scroll bars Emacs uses, if any.
7315 A value of nil means Emacs doesn't use toolkit scroll bars.
7316 With the X Window system, the value is a symbol describing the
7317 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
7318 With MS Windows or Nextstep, the value is t. */);
7319 Vx_toolkit_scroll_bars
= Qt
;
7321 DEFVAR_BOOL ("w32-unicode-filenames",
7322 w32_unicode_filenames
,
7323 doc
: /* Non-nil means use Unicode APIs when passing file names to the OS.
7324 A value of nil means file names passed to the OS APIs and returned
7325 from those APIs are encoded/decoded using the ANSI codepage
7326 specified by `file-name-coding-system'.
7328 This variable is set to non-nil by default when Emacs runs on Windows
7329 systems of the NT family, including W2K, XP, Vista, Windows 7 and
7330 Windows 8. It is set to nil on Windows 9X. */);
7331 if (os_subtype
== OS_9X
)
7332 w32_unicode_filenames
= 0;
7334 w32_unicode_filenames
= 1;
7337 /* FIXME: The following variable will be (hopefully) removed
7338 before Emacs 25.1 gets released. */
7340 DEFVAR_BOOL ("w32-add-wrapped-menu-bar-lines",
7341 w32_add_wrapped_menu_bar_lines
,
7342 doc
: /* Non-nil means frame resizing accounts for wrapped menu bar lines.
7343 A value of nil means frame resizing does not add the height of wrapped
7344 menu bar lines when sending a frame resize request to the Windows API.
7345 This usually means that the resulting frame height is off by the number
7346 of wrapped menu bar lines. If this is non-nil, Emacs adds the height of
7347 wrapped menu bar lines when sending frame resize requests to the Windows
7349 w32_add_wrapped_menu_bar_lines
= 1;
7351 /* Tell Emacs about this window system. */
7352 Fprovide (Qw32
, Qnil
);