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 */
40 #include "termhooks.h"
46 #include "menu.h" /* for w32_menu_show */
49 #include "w32.h" /* for filename_from_utf16, filename_from_ansi */
53 #include <io.h> /* for get_osfhandle */
61 #if 0 /* TODO: stipple */
62 #include "bitmaps/gray.xbm"
67 static int max_fringe_bmp
= 0;
68 static HBITMAP
*fringe_bmp
= 0;
70 /* Temporary variables for w32_read_socket. */
72 static int last_mousemove_x
= 0;
73 static int last_mousemove_y
= 0;
75 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
76 #ifndef GET_WHEEL_DELTA_WPARAM
77 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
80 /* Non-zero means that a HELP_EVENT has been generated since Emacs
83 static int any_help_event_p
;
85 extern unsigned int msh_mousewheel
;
87 extern int w32_codepage_for_font (char *fontname
);
88 extern Cursor
w32_load_cursor (LPCTSTR name
);
90 #define x_any_window_to_frame x_window_to_frame
91 #define x_top_window_to_frame x_window_to_frame
94 /* This is display since w32 does not support multiple ones. */
95 struct w32_display_info one_w32_display_info
;
96 struct w32_display_info
*x_display_list
;
98 #if _WIN32_WINNT < 0x0500 && !defined(MINGW_W64)
99 /* Pre Windows 2000, this was not available, but define it here so
100 that Emacs compiled on such a platform will run on newer versions.
101 MinGW64 defines these unconditionally, so avoid redefining. */
103 typedef struct tagWCRANGE
109 typedef struct tagGLYPHSET
113 DWORD cGlyphsSupported
;
118 #endif /* compiling for pre-Win2k */
120 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
121 BOOL (WINAPI
*pfnSetLayeredWindowAttributes
) (HWND
, COLORREF
, BYTE
, DWORD
);
124 #define LWA_ALPHA 0x02
126 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
127 later targets by MSVC headers. */
128 #ifndef WS_EX_LAYERED
129 #define WS_EX_LAYERED 0x80000
132 /* SM_CXVIRTUALSCREEN and SM_CYVIRTUALSCREEN are not defined on 95 and
134 #ifndef SM_CXVIRTUALSCREEN
135 #define SM_CXVIRTUALSCREEN 78
137 #ifndef SM_CYVIRTUALSCREEN
138 #define SM_CYVIRTUALSCREEN 79
141 /* The handle of the frame that currently owns the system caret. */
142 HWND w32_system_caret_hwnd
;
143 int w32_system_caret_height
;
144 int w32_system_caret_x
;
145 int w32_system_caret_y
;
146 struct window
*w32_system_caret_window
;
147 int w32_system_caret_hdr_height
;
148 int w32_system_caret_mode_height
;
149 DWORD dwWindowsThreadId
= 0;
150 HANDLE hWindowsThread
= NULL
;
151 DWORD dwMainThreadId
= 0;
152 HANDLE hMainThread
= NULL
;
154 int vertical_scroll_bar_min_handle
;
155 int horizontal_scroll_bar_min_handle
;
156 int vertical_scroll_bar_top_border
;
157 int vertical_scroll_bar_bottom_border
;
158 int horizontal_scroll_bar_left_border
;
159 int horizontal_scroll_bar_right_border
;
161 int last_scroll_bar_drag_pos
;
163 /* Keyboard code page - may be changed by language-change events. */
164 int w32_keyboard_codepage
;
166 /* Incremented by w32_read_socket whenever it really tries to read
168 static int volatile input_signal_count
;
171 int w32_message_fd
= -1;
174 static void w32_handle_tool_bar_click (struct frame
*,
175 struct input_event
*);
176 static void w32_define_cursor (Window
, Cursor
);
178 void x_lower_frame (struct frame
*);
179 void x_scroll_bar_clear (struct frame
*);
180 void x_raise_frame (struct frame
*);
181 void x_wm_set_window_state (struct frame
*, int);
182 void x_wm_set_icon_pixmap (struct frame
*, int);
183 static void w32_initialize (void);
184 static void x_update_end (struct frame
*);
185 static void w32_frame_up_to_date (struct frame
*);
186 static void x_clear_frame (struct frame
*);
187 static void frame_highlight (struct frame
*);
188 static void frame_unhighlight (struct frame
*);
189 static void x_new_focus_frame (struct w32_display_info
*,
191 static void x_focus_changed (int, int, struct w32_display_info
*,
192 struct frame
*, struct input_event
*);
193 static void w32_detect_focus_change (struct w32_display_info
*,
194 W32Msg
*, struct input_event
*);
195 static void w32_frame_rehighlight (struct frame
*);
196 static void x_frame_rehighlight (struct w32_display_info
*);
197 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
198 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
199 enum text_cursor_kinds
);
200 static void w32_clip_to_row (struct window
*, struct glyph_row
*,
201 enum glyph_row_area
, HDC
);
202 static BOOL
my_show_window (struct frame
*, HWND
, int);
203 static void my_set_window_pos (HWND
, HWND
, int, int, int, int, UINT
);
205 static void my_set_focus (struct frame
*, HWND
);
207 static void my_set_foreground_window (HWND
);
208 static void my_destroy_window (struct frame
*, HWND
);
209 static void w32fullscreen_hook (struct frame
*);
212 static void x_check_font (struct frame
*, struct font
*);
216 /***********************************************************************
218 ***********************************************************************/
222 /* This is a function useful for recording debugging information about
223 the sequence of occurrences in this file. */
231 struct record event_record
[100];
233 int event_record_index
;
235 record_event (char *locus
, int type
)
237 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
238 event_record_index
= 0;
240 event_record
[event_record_index
].locus
= locus
;
241 event_record
[event_record_index
].type
= type
;
242 event_record_index
++;
249 XChangeGC (void *ignore
, XGCValues
*gc
, unsigned long mask
,
252 if (mask
& GCForeground
)
253 gc
->foreground
= xgcv
->foreground
;
254 if (mask
& GCBackground
)
255 gc
->background
= xgcv
->background
;
257 gc
->font
= xgcv
->font
;
261 XCreateGC (void *ignore
, HWND wignore
, unsigned long mask
, XGCValues
*xgcv
)
263 XGCValues
*gc
= xzalloc (sizeof (XGCValues
));
265 XChangeGC (ignore
, gc
, mask
, xgcv
);
270 #if 0 /* unused for now, see x_draw_image_glyph_string below */
272 XGetGCValues (void *ignore
, XGCValues
*gc
,
273 unsigned long mask
, XGCValues
*xgcv
)
275 XChangeGC (ignore
, xgcv
, mask
, gc
);
280 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
284 HRGN clip_region
= CreateRectRgnIndirect (rect
);
285 SelectClipRgn (hdc
, clip_region
);
286 DeleteObject (clip_region
);
289 SelectClipRgn (hdc
, NULL
);
292 /* Restore clipping rectangle in S */
294 w32_restore_glyph_string_clip (struct glyph_string
*s
)
297 int n
= s
->num_clips
;
300 w32_set_clip_rectangle (s
->hdc
, r
);
303 HRGN clip1
= CreateRectRgnIndirect (r
);
304 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
305 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
306 SelectClipRgn (s
->hdc
, clip1
);
307 DeleteObject (clip1
);
308 DeleteObject (clip2
);
313 x_get_scale_factor(struct w32_display_info
*dpyinfo
, int *scale_x
, int *scale_y
)
315 const int base_res
= 96;
317 *scale_x
= *scale_y
= 1;
321 if (dpyinfo
->resx
> base_res
)
322 *scale_x
= floor (dpyinfo
->resx
/ base_res
);
323 if (dpyinfo
->resy
> base_res
)
324 *scale_y
= floor (dpyinfo
->resy
/ base_res
);
329 Draw a wavy line under S. The wave fills wave_height pixels from y0.
335 wave_height = 3 | * * * *
340 w32_draw_underwave (struct glyph_string
*s
, COLORREF color
)
342 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (s
->f
);
344 int scale_x
, scale_y
;
345 x_get_scale_factor (dpyinfo
, &scale_x
, &scale_y
);
347 int wave_height
= 3 * scale_y
, wave_length
= 2 * scale_x
, thickness
= scale_y
;
348 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, odd
, xmax
;
349 XRectangle wave_clip
, string_clip
, final_clip
;
350 RECT w32_final_clip
, w32_string_clip
;
354 dy
= wave_height
- 1;
356 y0
= s
->ybase
+ wave_height
/ 2 - scale_y
;
360 /* Find and set clipping rectangle */
364 wave_clip
.width
= width
;
365 wave_clip
.height
= wave_height
;
367 get_glyph_string_clip_rect (s
, &w32_string_clip
);
368 CONVERT_TO_XRECT (string_clip
, w32_string_clip
);
370 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
373 hp
= CreatePen (PS_SOLID
, thickness
, color
);
374 oldhp
= SelectObject (s
->hdc
, hp
);
375 CONVERT_FROM_XRECT (final_clip
, w32_final_clip
);
376 w32_set_clip_rectangle (s
->hdc
, &w32_final_clip
);
390 MoveToEx (s
->hdc
, x1
, y1
, NULL
);
394 LineTo (s
->hdc
, x2
, y2
);
396 x2
+= dx
, y2
= y0
+ odd
*dy
;
400 /* Restore previous pen and clipping rectangle(s) */
401 w32_restore_glyph_string_clip (s
);
402 SelectObject (s
->hdc
, oldhp
);
406 /* Draw a hollow rectangle at the specified position. */
408 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
409 int width
, int height
)
414 hb
= CreateSolidBrush (gc
->background
);
415 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
416 oldhb
= SelectObject (hdc
, hb
);
417 oldhp
= SelectObject (hdc
, hp
);
419 /* We enlarge WIDTH and HEIGHT by 1 to be bug-compatible to the
420 brain-dead design of XDrawRectangle, which draws a rectangle that
421 is 1 pixel wider and higher than its arguments WIDTH and HEIGHT.
422 This allows us to keep the code that calls this function similar
423 to the corresponding code in xterm.c. For the details, see
424 http://lists.gnu.org/archives/html/emacs-devel/2014-10/msg00546.html. */
425 Rectangle (hdc
, x
, y
, x
+ width
+ 1, y
+ height
+ 1);
427 SelectObject (hdc
, oldhb
);
428 SelectObject (hdc
, oldhp
);
433 /* Draw a filled rectangle at the specified position. */
435 w32_fill_rect (struct frame
*f
, HDC hdc
, COLORREF pix
, RECT
*lprect
)
439 hb
= CreateSolidBrush (pix
);
440 FillRect (hdc
, lprect
, hb
);
445 w32_clear_window (struct frame
*f
)
448 HDC hdc
= get_frame_dc (f
);
450 /* Under certain conditions, this can be called at startup with
451 a console frame pointer before the GUI frame is created. An HDC
452 of 0 indicates this. */
455 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
456 w32_clear_rect (f
, hdc
, &rect
);
459 release_frame_dc (f
, hdc
);
462 #define OPAQUE_FRAME 255
465 x_set_frame_alpha (struct frame
*f
)
467 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
469 double alpha_min
= 1.0;
472 HWND window
= FRAME_W32_WINDOW (f
);
474 /* Older versions of Windows do not support transparency. */
475 if (!pfnSetLayeredWindowAttributes
)
478 if (dpyinfo
->w32_focus_frame
== f
)
483 if (FLOATP (Vframe_alpha_lower_limit
))
484 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
485 else if (INTEGERP (Vframe_alpha_lower_limit
))
486 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
490 else if (alpha
> 1.0)
492 else if (alpha
< alpha_min
&& alpha_min
<= 1.0)
495 opac
= alpha
* OPAQUE_FRAME
;
497 ex_style
= GetWindowLong (window
, GWL_EXSTYLE
);
499 if (opac
== OPAQUE_FRAME
)
500 ex_style
&= ~WS_EX_LAYERED
;
502 ex_style
|= WS_EX_LAYERED
;
504 SetWindowLong (window
, GWL_EXSTYLE
, ex_style
);
506 if (opac
!= OPAQUE_FRAME
)
507 pfnSetLayeredWindowAttributes (window
, 0, opac
, LWA_ALPHA
);
511 x_display_pixel_height (struct w32_display_info
*dpyinfo
)
513 int pixels
= GetSystemMetrics (SM_CYVIRTUALSCREEN
);
516 /* Fallback for Windows 95 or NT 4.0. */
517 pixels
= GetSystemMetrics (SM_CYSCREEN
);
523 x_display_pixel_width (struct w32_display_info
*dpyinfo
)
525 int pixels
= GetSystemMetrics (SM_CXVIRTUALSCREEN
);
528 /* Fallback for Windows 95 or NT 4.0. */
529 pixels
= GetSystemMetrics (SM_CXSCREEN
);
535 /***********************************************************************
536 Starting and ending an update
537 ***********************************************************************/
539 /* Start an update of frame F. This function is installed as a hook
540 for update_begin, i.e. it is called when update_begin is called.
541 This function is called prior to calls to x_update_window_begin for
542 each window being updated. */
545 x_update_begin (struct frame
*f
)
547 struct w32_display_info
*display_info
= FRAME_DISPLAY_INFO (f
);
549 if (! FRAME_W32_P (f
))
552 /* Regenerate display palette before drawing if list of requested
553 colors has changed. */
554 if (display_info
->regen_palette
)
556 w32_regenerate_palette (f
);
557 display_info
->regen_palette
= FALSE
;
562 /* Start update of window W. */
565 x_update_window_begin (struct window
*w
)
567 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
568 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
570 /* Hide the system caret during an update. */
571 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
573 SendMessageTimeout (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0,
577 w
->output_cursor
= w
->cursor
;
581 if (f
== hlinfo
->mouse_face_mouse_frame
)
583 /* Don't do highlighting for mouse motion during the update. */
584 hlinfo
->mouse_face_defer
= true;
586 /* If F needs to be redrawn, simply forget about any prior mouse
588 if (FRAME_GARBAGED_P (f
))
589 hlinfo
->mouse_face_window
= Qnil
;
591 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
592 their mouse_face_p flag set, which means that they are always
593 unequal to rows in a desired matrix which never have that
594 flag set. So, rows containing mouse-face glyphs are never
595 scrolled, and we don't have to switch the mouse highlight off
596 here to prevent it from being scrolled. */
598 /* Can we tell that this update does not affect the window
599 where the mouse highlight is? If so, no need to turn off.
600 Likewise, don't do anything if the frame is garbaged;
601 in that case, the frame's current matrix that we would use
602 is all wrong, and we will redisplay that line anyway. */
603 if (!NILP (hlinfo
->mouse_face_window
)
604 && w
== XWINDOW (hlinfo
->mouse_face_window
))
608 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
609 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
612 if (i
< w
->desired_matrix
->nrows
)
613 clear_mouse_face (hlinfo
);
621 /* Draw a vertical window border from (x,y0) to (x,y1) */
624 w32_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
626 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
636 hdc
= get_frame_dc (f
);
637 face
= FACE_FROM_ID_OR_NULL (f
, VERTICAL_BORDER_FACE_ID
);
639 w32_fill_rect (f
, hdc
, face
->foreground
, &r
);
641 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
643 release_frame_dc (f
, hdc
);
647 /* Draw a window divider from (x0, y0) to (x1, y1) */
650 w32_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
652 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
653 HDC hdc
= get_frame_dc (f
);
654 struct face
*face
= FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_FACE_ID
);
655 struct face
*face_first
656 = FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
657 struct face
*face_last
658 = FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
659 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
660 unsigned long color_first
= (face_first
661 ? face_first
->foreground
662 : FRAME_FOREGROUND_PIXEL (f
));
663 unsigned long color_last
= (face_last
664 ? face_last
->foreground
665 : FRAME_FOREGROUND_PIXEL (f
));
667 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
670 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x0
+ 1, y1
);
671 w32_fill_area_abs (f
, hdc
, color
, x0
+ 1, y0
, x1
- 1, y1
);
672 w32_fill_area_abs (f
, hdc
, color_last
, x1
- 1, y0
, x1
, y1
);
674 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
677 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x1
, y0
+ 1);
678 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
+ 1, x1
, y1
- 1);
679 w32_fill_area_abs (f
, hdc
, color_last
, x0
, y1
- 1, x1
, y1
);
682 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
, x1
, y1
);
684 release_frame_dc (f
, hdc
);
687 /* End update of window W.
689 Draw vertical borders between horizontally adjacent windows, and
690 display W's cursor if CURSOR_ON_P is non-zero.
692 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
693 glyphs in mouse-face were overwritten. In that case we have to
694 make sure that the mouse-highlight is properly redrawn.
696 W may be a menu bar pseudo-window in case we don't have X toolkit
697 support. Such windows don't have a cursor, so don't display it
701 x_update_window_end (struct window
*w
, bool cursor_on_p
,
702 bool mouse_face_overwritten_p
)
704 if (!w
->pseudo_window_p
)
709 display_and_set_cursor (w
, true,
710 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
711 w
->output_cursor
.x
, w
->output_cursor
.y
);
713 if (draw_window_fringes (w
, true))
715 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
716 x_draw_right_divider (w
);
718 x_draw_vertical_border (w
);
724 /* If a row with mouse-face was overwritten, arrange for
725 XTframe_up_to_date to redisplay the mouse highlight. */
726 if (mouse_face_overwritten_p
)
728 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
730 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
731 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
732 hlinfo
->mouse_face_window
= Qnil
;
735 /* Unhide the caret. This won't actually show the cursor, unless it
736 was visible before the corresponding call to HideCaret in
737 x_update_window_begin. */
738 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
740 SendMessageTimeout (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0,
746 /* End update of frame F. This function is installed as a hook in
750 x_update_end (struct frame
*f
)
752 if (! FRAME_W32_P (f
))
755 /* Mouse highlight may be displayed again. */
756 MOUSE_HL_INFO (f
)->mouse_face_defer
= false;
760 /* This function is called from various places in xdisp.c
761 whenever a complete update has been performed. */
764 w32_frame_up_to_date (struct frame
*f
)
767 FRAME_MOUSE_UPDATE (f
);
771 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
772 arrow bitmaps, or clear the fringes if no bitmaps are required
773 before DESIRED_ROW is made current. This function is called from
774 update_window_line only if it is known that there are differences
775 between bitmaps to be drawn between current row and DESIRED_ROW. */
778 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
785 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
786 desired_row
->redraw_fringe_bitmaps_p
= true;
788 /* When a window has disappeared, make sure that no rest of
789 full-width rows stays visible in the internal border. Could
790 check here if updated window is the leftmost/rightmost window,
791 but I guess it's not worth doing since vertically split windows
792 are almost never used, internal border is rarely set, and the
793 overhead is very small. */
794 if (windows_or_buffers_changed
795 && desired_row
->full_width_p
796 && (f
= XFRAME (w
->frame
),
797 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
799 && (height
= desired_row
->visible_height
,
802 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
806 HDC hdc
= get_frame_dc (f
);
807 struct face
*face
= FACE_FROM_ID_OR_NULL (f
, INTERNAL_BORDER_FACE_ID
);
811 /* Fill border with internal border face. */
812 unsigned long color
= face
->background
;
814 w32_fill_area (f
, hdc
, color
, 0, y
, width
, height
);
815 w32_fill_area (f
, hdc
, color
, FRAME_PIXEL_WIDTH (f
) - width
,
820 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
821 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
824 release_frame_dc (f
, hdc
);
831 /* Draw the bitmap WHICH in one of the left or right fringes of
832 window W. ROW is the glyph row for which to display the bitmap; it
833 determines the vertical position at which the bitmap has to be
837 w32_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
,
838 struct draw_fringe_bitmap_params
*p
)
840 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
842 struct face
*face
= p
->face
;
844 hdc
= get_frame_dc (f
);
846 /* Must clip because of partially visible lines. */
847 w32_clip_to_row (w
, row
, ANY_AREA
, hdc
);
849 if (p
->bx
>= 0 && !p
->overlay_p
)
850 w32_fill_area (f
, hdc
, face
->background
,
851 p
->bx
, p
->by
, p
->nx
, p
->ny
);
853 if (p
->which
&& p
->which
< max_fringe_bmp
)
855 HBITMAP pixmap
= fringe_bmp
[p
->which
];
859 compat_hdc
= CreateCompatibleDC (hdc
);
863 horig_obj
= SelectObject (compat_hdc
, pixmap
);
865 /* Paint overlays transparently. */
868 HBRUSH h_brush
, h_orig_brush
;
870 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
871 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
872 h_brush
= CreateSolidBrush (face
->foreground
);
873 h_orig_brush
= SelectObject (hdc
, h_brush
);
875 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
876 compat_hdc
, 0, p
->dh
,
878 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
879 compat_hdc
, 0, p
->dh
,
881 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
882 compat_hdc
, 0, p
->dh
,
885 SelectObject (hdc
, h_orig_brush
);
886 DeleteObject (h_brush
);
890 SetTextColor (hdc
, face
->background
);
891 SetBkColor (hdc
, (p
->cursor_p
892 ? f
->output_data
.w32
->cursor_pixel
893 : face
->foreground
));
895 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
896 compat_hdc
, 0, p
->dh
,
900 SelectObject (compat_hdc
, horig_obj
);
901 DeleteDC (compat_hdc
);
905 w32_set_clip_rectangle (hdc
, NULL
);
907 release_frame_dc (f
, hdc
);
911 w32_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
913 if (which
>= max_fringe_bmp
)
915 int i
= max_fringe_bmp
;
916 max_fringe_bmp
= which
+ 20;
917 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
918 while (i
< max_fringe_bmp
)
922 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
926 w32_destroy_fringe_bitmap (int which
)
928 if (which
>= max_fringe_bmp
)
931 if (fringe_bmp
[which
])
932 DeleteObject (fringe_bmp
[which
]);
933 fringe_bmp
[which
] = 0;
936 /***********************************************************************
938 ***********************************************************************/
940 /* Function prototypes of this page. */
942 static void x_set_glyph_string_clipping (struct glyph_string
*);
943 static void x_set_glyph_string_gc (struct glyph_string
*);
944 static void x_draw_glyph_string_background (struct glyph_string
*,
946 static void x_draw_glyph_string_foreground (struct glyph_string
*);
947 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
948 static void x_draw_glyph_string_box (struct glyph_string
*);
949 static void x_draw_glyph_string (struct glyph_string
*);
950 static void x_set_cursor_gc (struct glyph_string
*);
951 static void x_set_mode_line_face_gc (struct glyph_string
*);
952 static void x_set_mouse_face_gc (struct glyph_string
*);
953 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
954 static void w32_setup_relief_color (struct frame
*, struct relief
*,
955 double, int, COLORREF
);
956 static void x_setup_relief_colors (struct glyph_string
*);
957 static void x_draw_image_glyph_string (struct glyph_string
*);
958 static void x_draw_image_relief (struct glyph_string
*);
959 static void x_draw_image_foreground (struct glyph_string
*);
960 static void w32_draw_image_foreground_1 (struct glyph_string
*, HBITMAP
);
961 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
963 static void w32_draw_relief_rect (struct frame
*, int, int, int, int,
964 int, int, int, int, int, int,
966 static void w32_draw_box_rect (struct glyph_string
*, int, int, int, int,
967 int, bool, bool, RECT
*);
970 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
974 x_set_cursor_gc (struct glyph_string
*s
)
976 if (s
->font
== FRAME_FONT (s
->f
)
977 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
978 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
979 /* Sometimes we are not called for each change in the default
980 face's background color (e.g., bug#26851), so the additional
981 test in the next line gives us a chance to resync. */
982 && s
->f
->output_data
.w32
->cursor_gc
->foreground
== s
->face
->background
984 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
987 /* Cursor on non-default face: must merge. */
991 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
992 xgcv
.foreground
= s
->face
->background
;
994 /* If the glyph would be invisible, try a different foreground. */
995 if (xgcv
.foreground
== xgcv
.background
)
996 xgcv
.foreground
= s
->face
->foreground
;
997 if (xgcv
.foreground
== xgcv
.background
)
998 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
999 if (xgcv
.foreground
== xgcv
.background
)
1000 xgcv
.foreground
= s
->face
->foreground
;
1002 /* Make sure the cursor is distinct from text in this face. */
1003 if (xgcv
.background
== s
->face
->background
1004 && xgcv
.foreground
== s
->face
->foreground
)
1006 xgcv
.background
= s
->face
->foreground
;
1007 xgcv
.foreground
= s
->face
->background
;
1010 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1011 xgcv
.font
= s
->font
;
1012 mask
= GCForeground
| GCBackground
| GCFont
;
1014 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1015 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1018 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1019 = XCreateGC (NULL
, FRAME_W32_WINDOW (s
->f
), mask
, &xgcv
);
1021 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1026 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1029 x_set_mouse_face_gc (struct glyph_string
*s
)
1034 /* What face has to be used last for the mouse face? */
1035 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
1036 face
= FACE_FROM_ID_OR_NULL (s
->f
, face_id
);
1038 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1040 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1041 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1043 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1044 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1045 prepare_face_for_display (s
->f
, s
->face
);
1047 /* If font in this face is same as S->font, use it. */
1048 if (s
->font
== s
->face
->font
)
1049 s
->gc
= s
->face
->gc
;
1052 /* Otherwise construct scratch_cursor_gc with values from FACE
1057 xgcv
.background
= s
->face
->background
;
1058 xgcv
.foreground
= s
->face
->foreground
;
1059 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1060 xgcv
.font
= s
->font
;
1061 mask
= GCForeground
| GCBackground
| GCFont
;
1063 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1064 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1067 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1068 = XCreateGC (NULL
, FRAME_W32_WINDOW (s
->f
), mask
, &xgcv
);
1070 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1073 eassert (s
->gc
!= 0);
1077 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1078 Faces to use in the mode line have already been computed when the
1079 matrix was built, so there isn't much to do, here. */
1082 x_set_mode_line_face_gc (struct glyph_string
*s
)
1084 s
->gc
= s
->face
->gc
;
1088 /* Set S->gc of glyph string S for drawing that glyph string. Set
1089 S->stippled_p to a non-zero value if the face of S has a stipple
1093 x_set_glyph_string_gc (struct glyph_string
*s
)
1095 prepare_face_for_display (s
->f
, s
->face
);
1097 if (s
->hl
== DRAW_NORMAL_TEXT
)
1099 s
->gc
= s
->face
->gc
;
1100 s
->stippled_p
= s
->face
->stipple
!= 0;
1102 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1104 x_set_mode_line_face_gc (s
);
1105 s
->stippled_p
= s
->face
->stipple
!= 0;
1107 else if (s
->hl
== DRAW_CURSOR
)
1109 x_set_cursor_gc (s
);
1110 s
->stippled_p
= false;
1112 else if (s
->hl
== DRAW_MOUSE_FACE
)
1114 x_set_mouse_face_gc (s
);
1115 s
->stippled_p
= s
->face
->stipple
!= 0;
1117 else if (s
->hl
== DRAW_IMAGE_RAISED
1118 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1120 s
->gc
= s
->face
->gc
;
1121 s
->stippled_p
= s
->face
->stipple
!= 0;
1126 /* GC must have been set. */
1127 eassert (s
->gc
!= 0);
1131 /* Set clipping for output of glyph string S. S may be part of a mode
1132 line or menu if we don't have X toolkit support. */
1135 x_set_glyph_string_clipping (struct glyph_string
*s
)
1138 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1141 w32_set_clip_rectangle (s
->hdc
, r
);
1144 HRGN clip1
= CreateRectRgnIndirect (r
);
1145 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
1146 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
1147 SelectClipRgn (s
->hdc
, clip1
);
1148 DeleteObject (clip1
);
1149 DeleteObject (clip2
);
1154 /* Set SRC's clipping for output of glyph string DST. This is called
1155 when we are drawing DST's left_overhang or right_overhang only in
1159 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
,
1160 struct glyph_string
*dst
)
1165 r
.right
= r
.left
+ src
->width
;
1167 r
.bottom
= r
.top
+ src
->height
;
1170 w32_set_clip_rectangle (dst
->hdc
, &r
);
1174 Compute left and right overhang of glyph string S. */
1177 w32_compute_glyph_string_overhangs (struct glyph_string
*s
)
1180 && s
->first_glyph
->type
== CHAR_GLYPH
1181 && !s
->font_not_found_p
)
1183 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1184 struct font
*font
= s
->font
;
1185 struct font_metrics metrics
;
1188 for (i
= 0; i
< s
->nchars
; i
++)
1189 code
[i
] = s
->char2b
[i
];
1190 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1191 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1192 ? metrics
.rbearing
- metrics
.width
: 0);
1193 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1197 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1198 s
->left_overhang
= -s
->cmp
->lbearing
;
1202 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1205 x_clear_glyph_string_rect (struct glyph_string
*s
,
1206 int x
, int y
, int w
, int h
)
1213 /* Take clipping into account. */
1214 if (s
->gc
->clip_mask
== Rect
)
1216 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1217 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1218 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1219 - s
->gc
->clip_rectangle
.left
);
1220 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1221 - s
->gc
->clip_rectangle
.top
);
1224 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1229 /* Draw the background of glyph_string S. If S->background_filled_p
1230 is non-zero don't draw it. FORCE_P non-zero means draw the
1231 background even if it wouldn't be drawn normally. This is used
1232 when a string preceding S draws into the background of S, or S
1233 contains the first component of a composition. */
1236 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1238 /* Nothing to do if background has already been drawn or if it
1239 shouldn't be drawn in the first place. */
1240 if (!s
->background_filled_p
)
1242 int box_line_width
= max (s
->face
->box_line_width
, 0);
1244 #if 0 /* TODO: stipple */
1247 /* Fill background with a stipple pattern. */
1248 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1249 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), s
->gc
, s
->x
,
1250 s
->y
+ box_line_width
,
1251 s
->background_width
,
1252 s
->height
- 2 * box_line_width
);
1253 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1254 s
->background_filled_p
= true;
1258 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1259 /* When xdisp.c ignores FONT_HEIGHT, we cannot trust
1260 font dimensions, since the actual glyphs might be
1261 much smaller. So in that case we always clear the
1262 rectangle with background color. */
1263 || FONT_TOO_HIGH (s
->font
)
1264 || s
->font_not_found_p
1265 || s
->extends_to_end_of_line_p
1268 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1269 s
->background_width
,
1270 s
->height
- 2 * box_line_width
);
1271 s
->background_filled_p
= true;
1277 /* Draw the foreground of glyph string S. */
1280 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1284 /* If first glyph of S has a left box line, start drawing the text
1285 of S to the right of that box line. */
1286 if (s
->face
->box
!= FACE_NO_BOX
1287 && s
->first_glyph
->left_box_line_p
)
1288 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1292 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1293 SetBkColor (s
->hdc
, s
->gc
->background
);
1294 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1296 /* Draw characters of S as rectangles if S's font could not be
1298 if (s
->font_not_found_p
)
1300 for (i
= 0; i
< s
->nchars
; ++i
)
1302 struct glyph
*g
= s
->first_glyph
+ i
;
1304 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1306 x
+= g
->pixel_width
;
1311 struct font
*font
= s
->font
;
1312 int boff
= font
->baseline_offset
;
1316 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1318 if (font
->vertical_centering
)
1319 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1321 y
= s
->ybase
- boff
;
1323 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1324 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, false);
1326 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, true);
1327 if (s
->face
->overstrike
)
1328 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, false);
1330 SelectObject (s
->hdc
, old_font
);
1334 /* Draw the foreground of composite glyph string S. */
1337 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1340 struct font
*font
= s
->font
;
1342 /* If first glyph of S has a left box line, start drawing the text
1343 of S to the right of that box line. */
1344 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1345 && s
->first_glyph
->left_box_line_p
)
1346 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1350 /* S is a glyph string for a composition. S->cmp_from is the index
1351 of the first character drawn for glyphs of this composition.
1352 S->cmp_from == 0 means we are drawing the very first character of
1353 this composition. */
1355 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1356 SetBkColor (s
->hdc
, s
->gc
->background
);
1357 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1359 /* Draw a rectangle for the composition if the font for the very
1360 first character of the composition could not be loaded. */
1361 if (s
->font_not_found_p
)
1363 if (s
->cmp_from
== 0)
1364 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1367 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1372 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1374 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1375 /* TAB in a composition means display glyphs with padding
1376 space on the left or right. */
1377 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1379 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1380 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1382 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, false);
1383 if (s
->face
->overstrike
)
1384 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, false);
1386 SelectObject (s
->hdc
, old_font
);
1390 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1396 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1398 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1400 glyph
= LGSTRING_GLYPH (gstring
, i
);
1401 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1402 width
+= LGLYPH_WIDTH (glyph
);
1405 int xoff
, yoff
, wadjust
;
1409 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1412 xoff
= LGLYPH_XOFF (glyph
);
1413 yoff
= LGLYPH_YOFF (glyph
);
1414 wadjust
= LGLYPH_WADJUST (glyph
);
1415 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, false);
1422 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1424 SelectObject (s
->hdc
, old_font
);
1429 /* Draw the foreground of glyph string S for glyphless characters. */
1432 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1434 struct glyph
*glyph
= s
->first_glyph
;
1437 bool with_background
;
1439 /* If first glyph of S has a left box line, start drawing the text
1440 of S to the right of that box line. */
1441 if (s
->face
->box
!= FACE_NO_BOX
1442 && s
->first_glyph
->left_box_line_p
)
1443 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1447 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1448 SetBkColor (s
->hdc
, s
->gc
->background
);
1449 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1452 with_background
= ((s
->for_overlaps
1453 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))) == 0;
1454 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1456 char buf
[7], *str
= NULL
;
1457 int len
= glyph
->u
.glyphless
.len
;
1459 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1462 && CHAR_TABLE_P (Vglyphless_char_display
)
1463 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1467 = (! glyph
->u
.glyphless
.for_no_font
1468 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1469 glyph
->u
.glyphless
.ch
)
1470 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1471 if (STRINGP (acronym
))
1472 str
= SSDATA (acronym
);
1475 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1477 sprintf ((char *) buf
, "%0*X",
1478 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1479 (unsigned int) glyph
->u
.glyphless
.ch
);
1483 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1484 w32_draw_rectangle (s
->hdc
, s
->gc
,
1485 x
, s
->ybase
- glyph
->ascent
,
1486 glyph
->pixel_width
- 1,
1487 glyph
->ascent
+ glyph
->descent
- 1);
1490 struct font
*font
= s
->font
;
1491 int upper_len
= (len
+ 1) / 2;
1495 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1496 /* It is certain that all LEN characters in STR are ASCII. */
1497 for (j
= 0; j
< len
; j
++)
1499 code
= font
->driver
->encode_char (font
, str
[j
]);
1500 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1502 font
->driver
->draw (s
, 0, upper_len
,
1503 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1504 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1506 font
->driver
->draw (s
, upper_len
, len
,
1507 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1508 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1510 SelectObject (s
->hdc
, old_font
);
1512 x
+= glyph
->pixel_width
;
1517 /* Brightness beyond which a color won't have its highlight brightness
1520 Nominally, highlight colors for `3d' faces are calculated by
1521 brightening an object's color by a constant scale factor, but this
1522 doesn't yield good results for dark colors, so for colors whose
1523 brightness is less than this value (on a scale of 0-255) have to
1524 use an additional additive factor.
1526 The value here is set so that the default menu-bar/mode-line color
1527 (grey75) will not have its highlights changed at all. */
1528 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1531 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1532 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1533 If this produces the same color as COLOR, try a color where all RGB
1534 values have DELTA added. Return the allocated color in *COLOR.
1535 DISPLAY is the X display, CMAP is the colormap to operate on.
1536 Value is non-zero if successful. */
1539 w32_alloc_lighter_color (struct frame
*f
, COLORREF
*color
,
1540 double factor
, int delta
)
1545 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1548 /* Change RGB values by specified FACTOR. Avoid overflow! */
1549 eassert (factor
>= 0);
1550 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1551 min (0xff, factor
* GetGValue (*color
)),
1552 min (0xff, factor
* GetBValue (*color
)));
1554 /* Calculate brightness of COLOR. */
1555 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1556 + GetBValue (*color
)) / 6;
1558 /* We only boost colors that are darker than
1559 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1560 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1561 /* Make an additive adjustment to NEW, because it's dark enough so
1562 that scaling by FACTOR alone isn't enough. */
1564 /* How far below the limit this color is (0 - 1, 1 being darker). */
1565 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1566 /* The additive adjustment. */
1567 int min_delta
= delta
* dimness
* factor
/ 2;
1570 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1571 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1572 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1574 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1575 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1576 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1580 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1581 max (0, min (0xff, delta
+ GetGValue (*color
))),
1582 max (0, min (0xff, delta
+ GetBValue (*color
))));
1584 /* TODO: Map to palette and retry with delta if same? */
1585 /* TODO: Free colors (if using palette)? */
1595 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1596 colors in COLORS. On W32, we no longer try to map colors to
1599 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1603 for (i
= 0; i
< ncolors
; i
++)
1605 DWORD pixel
= colors
[i
].pixel
;
1606 /* Convert to a 16 bit value in range 0 - 0xffff. */
1607 colors
[i
].red
= GetRValue (pixel
) * 257;
1608 colors
[i
].green
= GetGValue (pixel
) * 257;
1609 colors
[i
].blue
= GetBValue (pixel
) * 257;
1614 x_query_color (struct frame
*f
, XColor
*color
)
1616 x_query_colors (f
, color
, 1);
1620 /* Set up the foreground color for drawing relief lines of glyph
1621 string S. RELIEF is a pointer to a struct relief containing the GC
1622 with which lines will be drawn. Use a color that is FACTOR or
1623 DELTA lighter or darker than the relief's background which is found
1624 in S->f->output_data.x->relief_background. If such a color cannot
1625 be allocated, use DEFAULT_PIXEL, instead. */
1628 w32_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
1629 int delta
, COLORREF default_pixel
)
1632 struct w32_output
*di
= f
->output_data
.w32
;
1633 unsigned long mask
= GCForeground
;
1635 COLORREF background
= di
->relief_background
;
1637 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1640 /* TODO: Free colors (if using palette)? */
1642 /* Allocate new color. */
1643 xgcv
.foreground
= default_pixel
;
1645 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1646 xgcv
.foreground
= relief
->pixel
= pixel
;
1648 if (relief
->gc
== 0)
1650 #if 0 /* TODO: stipple */
1651 xgcv
.stipple
= dpyinfo
->gray
;
1654 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1657 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1661 /* Set up colors for the relief lines around glyph string S. */
1664 x_setup_relief_colors (struct glyph_string
*s
)
1666 struct w32_output
*di
= s
->f
->output_data
.w32
;
1669 if (s
->face
->use_box_color_for_shadows_p
)
1670 color
= s
->face
->box_color
;
1671 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1673 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1674 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1676 color
= s
->gc
->background
;
1678 if (di
->white_relief
.gc
== 0
1679 || color
!= di
->relief_background
)
1681 di
->relief_background
= color
;
1682 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1683 WHITE_PIX_DEFAULT (s
->f
));
1684 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1685 BLACK_PIX_DEFAULT (s
->f
));
1690 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1691 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1692 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1693 relief. LEFT_P non-zero means draw a relief on the left side of
1694 the rectangle. RIGHT_P non-zero means draw a relief on the right
1695 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1699 w32_draw_relief_rect (struct frame
*f
,
1700 int left_x
, int top_y
, int right_x
, int bottom_y
,
1701 int width
, int raised_p
,
1702 int top_p
, int bot_p
, int left_p
, int right_p
,
1707 HDC hdc
= get_frame_dc (f
);
1710 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1712 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1714 w32_set_clip_rectangle (hdc
, clip_rect
);
1718 for (i
= 0; i
< width
; ++i
)
1719 w32_fill_area (f
, hdc
, gc
.foreground
,
1720 left_x
+ i
* left_p
, top_y
+ i
,
1721 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1725 for (i
= 0; i
< width
; ++i
)
1726 w32_fill_area (f
, hdc
, gc
.foreground
,
1727 left_x
+ i
, top_y
+ (i
+ 1) * top_p
, 1,
1728 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1731 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1733 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1737 for (i
= 0; i
< width
; ++i
)
1738 w32_fill_area (f
, hdc
, gc
.foreground
,
1739 left_x
+ i
* left_p
, bottom_y
- i
,
1740 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1744 for (i
= 0; i
< width
; ++i
)
1745 w32_fill_area (f
, hdc
, gc
.foreground
,
1746 right_x
- i
, top_y
+ (i
+ 1) * top_p
, 1,
1747 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1749 w32_set_clip_rectangle (hdc
, NULL
);
1751 release_frame_dc (f
, hdc
);
1755 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1756 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1757 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1758 left side of the rectangle. RIGHT_P non-zero means draw a line
1759 on the right side of the rectangle. CLIP_RECT is the clipping
1760 rectangle to use when drawing. */
1763 w32_draw_box_rect (struct glyph_string
*s
,
1764 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1765 bool left_p
, bool right_p
, RECT
*clip_rect
)
1767 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1770 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1771 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1776 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1777 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1781 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1782 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1787 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1788 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1791 w32_set_clip_rectangle (s
->hdc
, NULL
);
1795 /* Draw a box around glyph string S. */
1798 x_draw_glyph_string_box (struct glyph_string
*s
)
1800 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
;
1801 bool left_p
, right_p
, raised_p
;
1802 struct glyph
*last_glyph
;
1805 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1806 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1807 : window_box_right (s
->w
, s
->area
));
1809 /* The glyph that may have a right box line. */
1810 last_glyph
= (s
->cmp
|| s
->img
1812 : s
->first_glyph
+ s
->nchars
- 1);
1814 width
= eabs (s
->face
->box_line_width
);
1815 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1817 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1819 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1821 bottom_y
= top_y
+ s
->height
- 1;
1823 left_p
= (s
->first_glyph
->left_box_line_p
1824 || (s
->hl
== DRAW_MOUSE_FACE
1826 || s
->prev
->hl
!= s
->hl
)));
1827 right_p
= (last_glyph
->right_box_line_p
1828 || (s
->hl
== DRAW_MOUSE_FACE
1830 || s
->next
->hl
!= s
->hl
)));
1832 get_glyph_string_clip_rect (s
, &clip_rect
);
1834 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1835 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1836 left_p
, right_p
, &clip_rect
);
1839 x_setup_relief_colors (s
);
1840 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1841 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1846 /* Draw foreground of image glyph string S. */
1849 x_draw_image_foreground (struct glyph_string
*s
)
1852 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1854 /* If first glyph of S has a left box line, start drawing it to the
1855 right of that line. */
1856 if (s
->face
->box
!= FACE_NO_BOX
1857 && s
->first_glyph
->left_box_line_p
1859 x
+= eabs (s
->face
->box_line_width
);
1861 /* If there is a margin around the image, adjust x- and y-position
1863 if (s
->slice
.x
== 0)
1864 x
+= s
->img
->hmargin
;
1865 if (s
->slice
.y
== 0)
1866 y
+= s
->img
->vmargin
;
1872 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
1873 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1874 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
1875 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1876 SetBkColor (compat_hdc
, RGB (255, 255, 255));
1877 SetTextColor (s
->hdc
, RGB (0, 0, 0));
1878 x_set_glyph_string_clipping (s
);
1882 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
1883 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1885 SetTextColor (s
->hdc
, RGB (255, 255, 255));
1886 SetBkColor (s
->hdc
, RGB (0, 0, 0));
1888 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1889 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1890 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1891 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1892 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1893 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1895 SelectObject (mask_dc
, mask_orig_obj
);
1900 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1901 SetBkColor (s
->hdc
, s
->gc
->background
);
1903 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1904 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1906 /* When the image has a mask, we can expect that at
1907 least part of a mouse highlight or a block cursor will
1908 be visible. If the image doesn't have a mask, make
1909 a block cursor visible by drawing a rectangle around
1910 the image. I believe it's looking better if we do
1911 nothing here for mouse-face. */
1912 if (s
->hl
== DRAW_CURSOR
)
1914 int r
= s
->img
->relief
;
1916 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
1917 s
->slice
.width
+ r
*2 - 1,
1918 s
->slice
.height
+ r
*2 - 1);
1922 w32_set_clip_rectangle (s
->hdc
, NULL
);
1923 SelectObject (s
->hdc
, orig_brush
);
1924 DeleteObject (fg_brush
);
1925 SelectObject (compat_hdc
, orig_obj
);
1926 DeleteDC (compat_hdc
);
1929 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
1930 s
->slice
.width
- 1, s
->slice
.height
- 1);
1932 RestoreDC (s
->hdc
,-1);
1936 /* Draw a relief around the image glyph string S. */
1939 x_draw_image_relief (struct glyph_string
*s
)
1941 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
1942 int extra_x
, extra_y
;
1945 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1947 /* If first glyph of S has a left box line, start drawing it to the
1948 right of that line. */
1949 if (s
->face
->box
!= FACE_NO_BOX
1950 && s
->first_glyph
->left_box_line_p
1952 x
+= eabs (s
->face
->box_line_width
);
1954 /* If there is a margin around the image, adjust x- and y-position
1956 if (s
->slice
.x
== 0)
1957 x
+= s
->img
->hmargin
;
1958 if (s
->slice
.y
== 0)
1959 y
+= s
->img
->vmargin
;
1961 if (s
->hl
== DRAW_IMAGE_SUNKEN
1962 || s
->hl
== DRAW_IMAGE_RAISED
)
1964 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
1965 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
1966 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
1970 thick
= eabs (s
->img
->relief
);
1971 raised_p
= s
->img
->relief
> 0;
1974 x1
= x
+ s
->slice
.width
- 1;
1975 y1
= y
+ s
->slice
.height
- 1;
1977 extra_x
= extra_y
= 0;
1978 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
1980 if (CONSP (Vtool_bar_button_margin
)
1981 && INTEGERP (XCAR (Vtool_bar_button_margin
))
1982 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
1984 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
1985 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
1987 else if (INTEGERP (Vtool_bar_button_margin
))
1988 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
1991 top_p
= bot_p
= left_p
= right_p
= 0;
1993 if (s
->slice
.x
== 0)
1994 x
-= thick
+ extra_x
, left_p
= 1;
1995 if (s
->slice
.y
== 0)
1996 y
-= thick
+ extra_y
, top_p
= 1;
1997 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
1998 x1
+= thick
+ extra_x
, right_p
= 1;
1999 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
2000 y1
+= thick
+ extra_y
, bot_p
= 1;
2002 x_setup_relief_colors (s
);
2003 get_glyph_string_clip_rect (s
, &r
);
2004 w32_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
2005 top_p
, bot_p
, left_p
, right_p
, &r
);
2009 /* Draw the foreground of image glyph string S to PIXMAP. */
2012 w32_draw_image_foreground_1 (struct glyph_string
*s
, HBITMAP pixmap
)
2014 HDC hdc
= CreateCompatibleDC (s
->hdc
);
2015 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
2017 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2019 /* If first glyph of S has a left box line, start drawing it to the
2020 right of that line. */
2021 if (s
->face
->box
!= FACE_NO_BOX
2022 && s
->first_glyph
->left_box_line_p
2024 x
+= eabs (s
->face
->box_line_width
);
2026 /* If there is a margin around the image, adjust x- and y-position
2028 if (s
->slice
.x
== 0)
2029 x
+= s
->img
->hmargin
;
2030 if (s
->slice
.y
== 0)
2031 y
+= s
->img
->vmargin
;
2035 HDC compat_hdc
= CreateCompatibleDC (hdc
);
2036 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2037 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
2038 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2042 HDC mask_dc
= CreateCompatibleDC (hdc
);
2043 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2045 SetTextColor (hdc
, RGB (0, 0, 0));
2046 SetBkColor (hdc
, RGB (255, 255, 255));
2047 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2048 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2049 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2050 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2051 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2052 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2054 SelectObject (mask_dc
, mask_orig_obj
);
2059 SetTextColor (hdc
, s
->gc
->foreground
);
2060 SetBkColor (hdc
, s
->gc
->background
);
2062 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2063 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2065 /* When the image has a mask, we can expect that at
2066 least part of a mouse highlight or a block cursor will
2067 be visible. If the image doesn't have a mask, make
2068 a block cursor visible by drawing a rectangle around
2069 the image. I believe it's looking better if we do
2070 nothing here for mouse-face. */
2071 if (s
->hl
== DRAW_CURSOR
)
2073 int r
= s
->img
->relief
;
2075 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2076 s
->slice
.width
+ r
*2 - 1,
2077 s
->slice
.height
+ r
*2 - 1);
2081 SelectObject (hdc
, orig_brush
);
2082 DeleteObject (fg_brush
);
2083 SelectObject (compat_hdc
, orig_obj
);
2084 DeleteDC (compat_hdc
);
2087 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2088 s
->slice
.width
- 1, s
->slice
.height
- 1);
2090 SelectObject (hdc
, orig_hdc_obj
);
2095 /* Draw part of the background of glyph string S. X, Y, W, and H
2096 give the rectangle to draw. */
2099 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2101 #if 0 /* TODO: stipple */
2104 /* Fill background with a stipple pattern. */
2105 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2106 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), s
->gc
, x
, y
, w
, h
);
2107 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2111 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2115 /* Draw image glyph string S.
2118 s->x +-------------------------
2121 | +-------------------------
2124 | | +-------------------
2130 x_draw_image_glyph_string (struct glyph_string
*s
)
2133 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2134 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2139 if (s
->slice
.y
== 0)
2140 height
-= box_line_vwidth
;
2141 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2142 height
-= box_line_vwidth
;
2144 /* Fill background with face under the image. Do it only if row is
2145 taller than image or if image has a clip mask to reduce
2147 s
->stippled_p
= s
->face
->stipple
!= 0;
2148 if (height
> s
->slice
.height
2152 || s
->img
->pixmap
== 0
2153 || s
->width
!= s
->background_width
)
2155 width
= s
->background_width
;
2157 if (s
->first_glyph
->left_box_line_p
2160 x
+= box_line_hwidth
;
2161 width
-= box_line_hwidth
;
2165 if (s
->slice
.y
== 0)
2166 y
+= box_line_vwidth
;
2168 #if 0 /* TODO: figure out if we need to do this on Windows. */
2171 /* Create a pixmap as large as the glyph string. Fill it
2172 with the background color. Copy the image to it, using
2173 its mask. Copy the temporary pixmap to the display. */
2174 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2175 int depth
= DefaultDepthOfScreen (screen
);
2177 /* Create a pixmap as large as the glyph string. */
2178 pixmap
= XCreatePixmap (s
->display
, FRAME_W32_WINDOW (s
->f
),
2179 s
->background_width
,
2182 /* Don't clip in the following because we're working on the
2184 XSetClipMask (s
->display
, s
->gc
, None
);
2186 /* Fill the pixmap with the background color/stipple. */
2189 /* Fill background with a stipple pattern. */
2190 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2191 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2192 0, 0, s
->background_width
, s
->height
);
2193 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2198 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2200 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2201 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2202 0, 0, s
->background_width
, s
->height
);
2203 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2208 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
2210 s
->background_filled_p
= true;
2213 /* Draw the foreground. */
2216 w32_draw_image_foreground_1 (s
, pixmap
);
2217 x_set_glyph_string_clipping (s
);
2219 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2220 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2221 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2222 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2224 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2225 SetBkColor (s
->hdc
, s
->gc
->background
);
2226 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2227 compat_hdc
, 0, 0, SRCCOPY
);
2229 SelectObject (s
->hdc
, orig_brush
);
2230 DeleteObject (fg_brush
);
2231 SelectObject (compat_hdc
, orig_obj
);
2232 DeleteDC (compat_hdc
);
2234 DeleteObject (pixmap
);
2238 x_draw_image_foreground (s
);
2240 /* If we must draw a relief around the image, do it. */
2242 || s
->hl
== DRAW_IMAGE_RAISED
2243 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2244 x_draw_image_relief (s
);
2248 /* Draw stretch glyph string S. */
2251 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2253 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2255 if (s
->hl
== DRAW_CURSOR
2256 && !x_stretch_cursor_p
)
2258 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2259 wide as the stretch glyph. */
2260 int width
, background_width
= s
->background_width
;
2263 if (!s
->row
->reversed_p
)
2265 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2269 background_width
-= left_x
- x
;
2275 /* In R2L rows, draw the cursor on the right edge of the
2277 int right_x
= window_box_right (s
->w
, TEXT_AREA
);
2279 if (x
+ background_width
> right_x
)
2280 background_width
-= x
- right_x
;
2281 x
+= background_width
;
2283 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2284 if (s
->row
->reversed_p
)
2288 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2290 /* Clear rest using the GC of the original non-cursor face. */
2291 if (width
< background_width
)
2293 XGCValues
*gc
= s
->face
->gc
;
2295 int w
= background_width
- width
, h
= s
->height
;
2299 if (!s
->row
->reversed_p
)
2303 if (s
->row
->mouse_face_p
2304 && cursor_in_mouse_face_p (s
->w
))
2306 x_set_mouse_face_gc (s
);
2312 get_glyph_string_clip_rect (s
, &r
);
2313 w32_set_clip_rectangle (hdc
, &r
);
2315 #if 0 /* TODO: stipple */
2316 if (s
->face
->stipple
)
2318 /* Fill background with a stipple pattern. */
2319 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2320 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), gc
, x
, y
, w
, h
);
2321 XSetFillStyle (s
->display
, gc
, FillSolid
);
2326 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2330 else if (!s
->background_filled_p
)
2332 int background_width
= s
->background_width
;
2333 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2335 /* Don't draw into left margin, fringe or scrollbar area
2336 except for header line and mode line. */
2337 if (x
< left_x
&& !s
->row
->mode_line_p
)
2339 background_width
-= left_x
- x
;
2342 if (background_width
> 0)
2343 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2346 s
->background_filled_p
= true;
2350 /* Draw glyph string S. */
2353 x_draw_glyph_string (struct glyph_string
*s
)
2355 bool relief_drawn_p
= 0;
2357 /* If S draws into the background of its successor, draw the
2358 background of the successor first so that S can draw into it.
2359 This makes S->next use XDrawString instead of XDrawImageString. */
2360 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2363 struct glyph_string
*next
;
2364 for (width
= 0, next
= s
->next
;
2365 next
&& width
< s
->right_overhang
;
2366 width
+= next
->width
, next
= next
->next
)
2367 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2369 x_set_glyph_string_gc (next
);
2370 x_set_glyph_string_clipping (next
);
2371 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2372 x_draw_stretch_glyph_string (next
);
2374 x_draw_glyph_string_background (next
, true);
2375 next
->num_clips
= 0;
2379 /* Set up S->gc, set clipping and draw S. */
2380 x_set_glyph_string_gc (s
);
2382 /* Draw relief (if any) in advance for char/composition so that the
2383 glyph string can be drawn over it. */
2384 if (!s
->for_overlaps
2385 && s
->face
->box
!= FACE_NO_BOX
2386 && (s
->first_glyph
->type
== CHAR_GLYPH
2387 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2390 x_set_glyph_string_clipping (s
);
2391 x_draw_glyph_string_background (s
, true);
2392 x_draw_glyph_string_box (s
);
2393 x_set_glyph_string_clipping (s
);
2396 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2398 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2399 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2400 /* We must clip just this glyph. left_overhang part has already
2401 drawn when s->prev was drawn, and right_overhang part will be
2402 drawn later when s->next is drawn. */
2403 x_set_glyph_string_clipping_exactly (s
, s
);
2405 x_set_glyph_string_clipping (s
);
2407 switch (s
->first_glyph
->type
)
2410 x_draw_image_glyph_string (s
);
2414 x_draw_stretch_glyph_string (s
);
2418 if (s
->for_overlaps
)
2419 s
->background_filled_p
= true;
2421 x_draw_glyph_string_background (s
, false);
2422 x_draw_glyph_string_foreground (s
);
2425 case COMPOSITE_GLYPH
:
2426 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2427 && ! s
->first_glyph
->u
.cmp
.automatic
))
2428 s
->background_filled_p
= true;
2430 x_draw_glyph_string_background (s
, true);
2431 x_draw_composite_glyph_string_foreground (s
);
2434 case GLYPHLESS_GLYPH
:
2435 if (s
->for_overlaps
)
2436 s
->background_filled_p
= true;
2438 x_draw_glyph_string_background (s
, false);
2439 x_draw_glyphless_glyph_string_foreground (s
);
2446 if (!s
->for_overlaps
)
2448 /* Draw underline. */
2449 if (s
->face
->underline_p
)
2451 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2455 if (s
->face
->underline_defaulted_p
)
2456 color
= s
->gc
->foreground
;
2458 color
= s
->face
->underline_color
;
2460 w32_draw_underwave (s
, color
);
2462 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2464 unsigned long thickness
, position
;
2467 if (s
->prev
&& s
->prev
->face
->underline_p
2468 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2470 /* We use the same underline style as the previous one. */
2471 thickness
= s
->prev
->underline_thickness
;
2472 position
= s
->prev
->underline_position
;
2476 struct font
*font
= font_for_underline_metrics (s
);
2478 /* Get the underline thickness. Default is 1 pixel. */
2479 if (font
&& font
->underline_thickness
> 0)
2480 thickness
= font
->underline_thickness
;
2483 if (x_underline_at_descent_line
|| !font
)
2484 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2487 /* Get the underline position. This is the recommended
2488 vertical offset in pixels from the baseline to the top of
2489 the underline. This is a signed value according to the
2490 specs, and its default is
2492 ROUND ((maximum_descent) / 2), with
2493 ROUND (x) = floor (x + 0.5) */
2495 if (x_use_underline_position_properties
2496 && font
->underline_position
>= 0)
2497 position
= font
->underline_position
;
2499 position
= (font
->descent
+ 1) / 2;
2501 position
= max (position
, underline_minimum_offset
);
2503 /* Check the sanity of thickness and position. We should
2504 avoid drawing underline out of the current line area. */
2505 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2506 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2507 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2508 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2509 s
->underline_thickness
= thickness
;
2510 s
->underline_position
= position
;
2511 y
= s
->ybase
+ position
;
2512 if (s
->face
->underline_defaulted_p
)
2514 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2519 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2524 /* Draw overline. */
2525 if (s
->face
->overline_p
)
2527 unsigned long dy
= 0, h
= 1;
2529 if (s
->face
->overline_color_defaulted_p
)
2531 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2532 s
->y
+ dy
, s
->width
, h
);
2536 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2537 s
->y
+ dy
, s
->width
, h
);
2541 /* Draw strike-through. */
2542 if (s
->face
->strike_through_p
2543 && !FONT_TEXTMETRIC (s
->font
).tmStruckOut
)
2545 /* Y-coordinate and height of the glyph string's first
2546 glyph. We cannot use s->y and s->height because those
2547 could be larger if there are taller display elements
2548 (e.g., characters displayed with a larger font) in the
2550 int glyph_y
= s
->ybase
- s
->first_glyph
->ascent
;
2551 int glyph_height
= s
->first_glyph
->ascent
+ s
->first_glyph
->descent
;
2552 /* Strike-through width and offset from the glyph string's
2554 unsigned long h
= 1;
2555 unsigned long dy
= (glyph_height
- h
) / 2;
2557 if (s
->face
->strike_through_color_defaulted_p
)
2559 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2560 glyph_y
+ dy
, s
->width
, h
);
2564 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2565 glyph_y
+ dy
, s
->width
, h
);
2569 /* Draw relief if not yet drawn. */
2570 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2571 x_draw_glyph_string_box (s
);
2575 struct glyph_string
*prev
;
2577 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2578 if (prev
->hl
!= s
->hl
2579 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2581 /* As prev was drawn while clipped to its own area, we
2582 must draw the right_overhang part using s->hl now. */
2583 enum draw_glyphs_face save
= prev
->hl
;
2586 x_set_glyph_string_gc (prev
);
2587 x_set_glyph_string_clipping_exactly (s
, prev
);
2588 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2589 x_draw_glyph_string_foreground (prev
);
2591 x_draw_composite_glyph_string_foreground (prev
);
2592 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2594 prev
->num_clips
= 0;
2600 struct glyph_string
*next
;
2602 for (next
= s
->next
; next
; next
= next
->next
)
2603 if (next
->hl
!= s
->hl
2604 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2606 /* As next will be drawn while clipped to its own area,
2607 we must draw the left_overhang part using s->hl now. */
2608 enum draw_glyphs_face save
= next
->hl
;
2611 x_set_glyph_string_gc (next
);
2612 x_set_glyph_string_clipping_exactly (s
, next
);
2613 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2614 x_draw_glyph_string_foreground (next
);
2616 x_draw_composite_glyph_string_foreground (next
);
2617 w32_set_clip_rectangle (next
->hdc
, NULL
);
2619 next
->num_clips
= 0;
2620 next
->clip_head
= s
->next
;
2625 /* Reset clipping. */
2626 w32_set_clip_rectangle (s
->hdc
, NULL
);
2631 /* Shift display to make room for inserted glyphs. */
2634 w32_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
,
2635 int width
, int height
, int shift_by
)
2639 hdc
= get_frame_dc (f
);
2640 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2641 hdc
, x
, y
, SRCCOPY
);
2643 release_frame_dc (f
, hdc
);
2647 /* Delete N glyphs at the nominal cursor position. Not implemented
2651 x_delete_glyphs (struct frame
*f
, register int n
)
2653 if (! FRAME_W32_P (f
))
2660 /* Clear entire frame. */
2663 x_clear_frame (struct frame
*f
)
2665 if (! FRAME_W32_P (f
))
2668 /* Clearing the frame will erase any cursor, so mark them all as no
2670 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2674 w32_clear_window (f
);
2676 /* We have to clear the scroll bars, too. If we have changed
2677 colors or something like that, then they should be notified. */
2678 x_scroll_bar_clear (f
);
2684 /* Make audible bell. */
2687 w32_ring_bell (struct frame
*f
)
2691 if (FRAME_W32_P (f
) && visible_bell
)
2694 HWND hwnd
= FRAME_W32_WINDOW (f
);
2696 for (i
= 0; i
< 5; i
++)
2698 FlashWindow (hwnd
, TRUE
);
2701 FlashWindow (hwnd
, FALSE
);
2704 w32_sys_ring_bell (f
);
2709 /***********************************************************************
2711 ***********************************************************************/
2713 /* Perform an insert-lines or delete-lines operation, inserting N
2714 lines or deleting -N lines at vertical position VPOS. */
2717 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
2719 if (! FRAME_W32_P (f
))
2726 /* Scroll part of the display as described by RUN. */
2729 x_scroll_run (struct window
*w
, struct run
*run
)
2731 struct frame
*f
= XFRAME (w
->frame
);
2732 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2733 HWND hwnd
= FRAME_W32_WINDOW (f
);
2736 /* Get frame-relative bounding box of the text display area of W,
2737 without mode lines. Include in this box the left and right
2739 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
2741 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2742 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2743 bottom_y
= y
+ height
;
2747 /* Scrolling up. Make sure we don't copy part of the mode
2748 line at the bottom. */
2749 if (from_y
+ run
->height
> bottom_y
)
2750 height
= bottom_y
- from_y
;
2752 height
= run
->height
;
2753 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2757 /* Scrolling down. Make sure we don't copy over the mode line.
2759 if (to_y
+ run
->height
> bottom_y
)
2760 height
= bottom_y
- to_y
;
2762 height
= run
->height
;
2763 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2768 /* Cursor off. Will be switched on again in x_update_window_end. */
2774 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2775 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2777 from
.left
= to
.left
= x
;
2778 from
.right
= to
.right
= x
+ width
;
2780 from
.bottom
= from_y
+ height
;
2782 to
.bottom
= bottom_y
;
2784 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2785 NULL
, SW_INVALIDATE
);
2787 /* Combine this with what we expect to be dirty. This covers the
2788 case where not all of the region we expect is actually dirty. */
2789 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2791 /* If the dirty region is not what we expected, redraw the entire frame. */
2792 if (!EqualRgn (combined
, expect_dirty
))
2793 SET_FRAME_GARBAGED (f
);
2795 DeleteObject (dirty
);
2796 DeleteObject (combined
);
2800 DeleteObject (expect_dirty
);
2805 /***********************************************************************
2807 ***********************************************************************/
2810 frame_highlight (struct frame
*f
)
2812 x_update_cursor (f
, 1);
2813 x_set_frame_alpha (f
);
2817 frame_unhighlight (struct frame
*f
)
2819 x_update_cursor (f
, 1);
2820 x_set_frame_alpha (f
);
2823 /* The focus has changed. Update the frames as necessary to reflect
2824 the new situation. Note that we can't change the selected frame
2825 here, because the Lisp code we are interrupting might become confused.
2826 Each event gets marked with the frame in which it occurred, so the
2827 Lisp code can tell when the switch took place by examining the events. */
2830 x_new_focus_frame (struct w32_display_info
*dpyinfo
, struct frame
*frame
)
2832 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2834 if (frame
!= dpyinfo
->w32_focus_frame
)
2836 /* Set this before calling other routines, so that they see
2837 the correct value of w32_focus_frame. */
2838 dpyinfo
->w32_focus_frame
= frame
;
2840 if (old_focus
&& old_focus
->auto_lower
)
2841 x_lower_frame (old_focus
);
2843 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2844 dpyinfo
->w32_pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2846 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
2849 x_frame_rehighlight (dpyinfo
);
2853 /* Handle FocusIn and FocusOut state changes for FRAME.
2854 If FRAME has focus and there exists more than one frame, puts
2855 a FOCUS_IN_EVENT into *BUFP. */
2858 x_focus_changed (int type
, int state
, struct w32_display_info
*dpyinfo
,
2859 struct frame
*frame
, struct input_event
*bufp
)
2861 if (type
== WM_SETFOCUS
)
2863 if (dpyinfo
->w32_focus_event_frame
!= frame
)
2865 x_new_focus_frame (dpyinfo
, frame
);
2866 dpyinfo
->w32_focus_event_frame
= frame
;
2868 /* Don't stop displaying the initial startup message
2869 for a switch-frame event we don't need. */
2870 if (NILP (Vterminal_frame
)
2871 && CONSP (Vframe_list
)
2872 && !NILP (XCDR (Vframe_list
)))
2881 bufp
->kind
= FOCUS_IN_EVENT
;
2882 XSETFRAME (bufp
->frame_or_window
, frame
);
2885 frame
->output_data
.x
->focus_state
|= state
;
2887 /* TODO: IME focus? */
2889 else if (type
== WM_KILLFOCUS
)
2891 frame
->output_data
.x
->focus_state
&= ~state
;
2893 if (dpyinfo
->w32_focus_event_frame
== frame
)
2895 dpyinfo
->w32_focus_event_frame
= 0;
2896 x_new_focus_frame (dpyinfo
, 0);
2898 bufp
->kind
= FOCUS_OUT_EVENT
;
2899 XSETFRAME (bufp
->frame_or_window
, frame
);
2902 /* TODO: IME focus? */
2907 /* The focus may have changed. Figure out if it is a real focus change,
2908 by checking both FocusIn/Out and Enter/LeaveNotify events.
2910 Returns FOCUS_IN_EVENT event in *BUFP. */
2913 w32_detect_focus_change (struct w32_display_info
*dpyinfo
, W32Msg
*event
,
2914 struct input_event
*bufp
)
2916 struct frame
*frame
;
2918 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
2922 /* On w32, this is only called from focus events, so no switch needed. */
2923 x_focus_changed (event
->msg
.message
,
2924 (event
->msg
.message
== WM_KILLFOCUS
?
2925 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
2926 dpyinfo
, frame
, bufp
);
2931 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2934 x_mouse_leave (struct w32_display_info
*dpyinfo
)
2936 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2940 /* The focus has changed, or we have redirected a frame's focus to
2941 another frame (this happens when a frame uses a surrogate
2942 mini-buffer frame). Shift the highlight as appropriate.
2944 The FRAME argument doesn't necessarily have anything to do with which
2945 frame is being highlighted or un-highlighted; we only use it to find
2946 the appropriate X display info. */
2949 w32_frame_rehighlight (struct frame
*frame
)
2951 if (! FRAME_W32_P (frame
))
2953 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
2957 x_frame_rehighlight (struct w32_display_info
*dpyinfo
)
2959 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2961 if (dpyinfo
->w32_focus_frame
)
2963 dpyinfo
->x_highlight_frame
2964 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2965 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2966 : dpyinfo
->w32_focus_frame
);
2967 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
2969 fset_focus_frame (dpyinfo
->w32_focus_frame
, Qnil
);
2970 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
2974 dpyinfo
->x_highlight_frame
= 0;
2976 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
2979 frame_unhighlight (old_highlight
);
2980 if (dpyinfo
->x_highlight_frame
)
2981 frame_highlight (dpyinfo
->x_highlight_frame
);
2985 /* Keyboard processing - modifier keys, etc. */
2987 /* Convert a keysym to its name. */
2990 x_get_keysym_name (int keysym
)
2992 /* Make static so we can always return it */
2993 static char value
[100];
2996 GetKeyNameText (keysym
, value
, 100);
3003 codepage_for_locale (LCID locale
)
3007 if (GetLocaleInfo (locale
, LOCALE_IDEFAULTANSICODEPAGE
, cp
, 20) > 0)
3014 /* Mouse clicks and mouse movement. Rah. */
3016 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
3017 the state in PUP. XBUTTON provides extra information for extended mouse
3018 button messages. Returns FALSE if unable to parse the message. */
3020 parse_button (int message
, int xbutton
, int * pbutton
, int * pup
)
3027 case WM_LBUTTONDOWN
:
3035 case WM_MBUTTONDOWN
:
3036 if (NILP (Vw32_swap_mouse_buttons
))
3043 if (NILP (Vw32_swap_mouse_buttons
))
3049 case WM_RBUTTONDOWN
:
3050 if (NILP (Vw32_swap_mouse_buttons
))
3057 if (NILP (Vw32_swap_mouse_buttons
))
3063 case WM_XBUTTONDOWN
:
3064 button
= xbutton
+ 2;
3068 button
= xbutton
+ 2;
3076 if (pbutton
) *pbutton
= button
;
3082 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3084 If the event is a button press, then note that we have grabbed
3088 construct_mouse_click (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3093 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3096 /* Make the event type NO_EVENT; we'll change that when we decide
3098 result
->kind
= MOUSE_CLICK_EVENT
;
3099 result
->code
= button
;
3100 result
->timestamp
= msg
->msg
.time
;
3101 result
->modifiers
= (msg
->dwModifiers
3106 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3107 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3108 XSETFRAME (result
->frame_or_window
, f
);
3114 construct_mouse_wheel (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3119 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3122 result
->timestamp
= msg
->msg
.time
;
3124 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3125 forward, away from the user (up); a negative value indicates that
3126 the wheel was rotated backward, toward the user (down). */
3127 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3129 /* The up and down modifiers indicate if the wheel was rotated up or
3130 down based on WHEEL_DELTA value. */
3131 result
->modifiers
= (msg
->dwModifiers
3132 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3134 /* With multiple monitors, we can legitimately get negative
3135 coordinates, so cast to short to interpret them correctly. */
3136 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3137 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3138 /* For the case that F's w32 window is not msg->msg.hwnd. */
3139 ScreenToClient (FRAME_W32_WINDOW (f
), &p
);
3140 XSETINT (result
->x
, p
.x
);
3141 XSETINT (result
->y
, p
.y
);
3142 XSETFRAME (result
->frame_or_window
, f
);
3148 construct_drag_n_drop (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3155 wchar_t name_w
[MAX_PATH
];
3156 #ifdef NTGUI_UNICODE
3157 const int use_unicode
= 1;
3159 int use_unicode
= w32_unicode_filenames
;
3160 char name_a
[MAX_PATH
];
3161 char file
[MAX_UTF8_PATH
];
3165 result
->kind
= DRAG_N_DROP_EVENT
;
3167 result
->timestamp
= msg
->msg
.time
;
3168 result
->modifiers
= msg
->dwModifiers
;
3170 hdrop
= (HDROP
) msg
->msg
.wParam
;
3171 DragQueryPoint (hdrop
, &p
);
3174 p
.x
= LOWORD (msg
->msg
.lParam
);
3175 p
.y
= HIWORD (msg
->msg
.lParam
);
3176 ScreenToClient (msg
->msg
.hwnd
, &p
);
3179 XSETINT (result
->x
, p
.x
);
3180 XSETINT (result
->y
, p
.y
);
3182 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3185 for (i
= 0; i
< num_files
; i
++)
3189 eassert (DragQueryFileW (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3190 /* If DragQueryFile returns zero, it failed to fetch a file
3192 if (DragQueryFileW (hdrop
, i
, name_w
, MAX_PATH
) == 0)
3194 #ifdef NTGUI_UNICODE
3195 files
= Fcons (from_unicode_buffer (name_w
), files
);
3197 filename_from_utf16 (name_w
, file
);
3198 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3199 #endif /* NTGUI_UNICODE */
3201 #ifndef NTGUI_UNICODE
3204 eassert (DragQueryFileA (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3205 if (DragQueryFileA (hdrop
, i
, name_a
, MAX_PATH
) == 0)
3207 filename_from_ansi (name_a
, file
);
3208 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3215 XSETFRAME (frame
, f
);
3216 result
->frame_or_window
= frame
;
3217 result
->arg
= files
;
3224 /* File event notifications (see w32notify.c). */
3227 lispy_file_action (DWORD action
)
3229 static char unknown_fmt
[] = "unknown-action(%d)";
3234 case FILE_ACTION_ADDED
:
3237 case FILE_ACTION_REMOVED
:
3240 case FILE_ACTION_MODIFIED
:
3243 case FILE_ACTION_RENAMED_OLD_NAME
:
3244 retval
= Qrenamed_from
;
3246 case FILE_ACTION_RENAMED_NEW_NAME
:
3247 retval
= Qrenamed_to
;
3251 char buf
[sizeof(unknown_fmt
) - 1 + INT_STRLEN_BOUND (DWORD
)];
3253 sprintf (buf
, unknown_fmt
, action
);
3254 retval
= intern (buf
);
3263 /* Put file notifications into the Emacs input event queue. This
3264 function runs when the WM_EMACS_FILENOTIFY message arrives from a
3267 queue_notifications (struct input_event
*event
, W32Msg
*msg
, struct frame
*f
,
3270 struct notifications_set
*ns
= NULL
;
3274 /* We cannot process notification before Emacs is fully initialized,
3275 since we need the UTF-16LE coding-system to be set up. */
3279 XSETFRAME (frame
, f
);
3285 /* Find out if there is a record available in the linked list of
3286 notifications sets. If so, unlink the set from the linked
3287 list. Use critical section. */
3289 if (notifications_set_head
->next
!= notifications_set_head
)
3291 ns
= notifications_set_head
->next
;
3292 ns
->prev
->next
= ns
->next
;
3293 ns
->next
->prev
= ns
->prev
;
3301 BYTE
*p
= ns
->notifications
;
3302 FILE_NOTIFY_INFORMATION
*fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3303 const DWORD min_size
3304 = offsetof (FILE_NOTIFY_INFORMATION
, FileName
) + sizeof(wchar_t);
3305 DWORD info_size
= ns
->size
;
3306 Lisp_Object cs
= Qutf_16le
;
3307 Lisp_Object obj
= w32_get_watch_object (ns
->desc
);
3309 /* notifications size could be zero when the buffer of
3310 notifications overflowed on the OS level, or when the
3311 directory being watched was itself deleted. Do nothing in
3314 && !NILP (obj
) && CONSP (obj
))
3316 Lisp_Object callback
= XCDR (obj
);
3318 while (info_size
>= min_size
)
3320 Lisp_Object utf_16_fn
3321 = make_unibyte_string ((char *)fni
->FileName
,
3322 fni
->FileNameLength
);
3323 /* Note: mule-conf is preloaded, so utf-16le must
3324 already be defined at this point. */
3326 = code_convert_string_norecord (utf_16_fn
, cs
, 0);
3327 Lisp_Object action
= lispy_file_action (fni
->Action
);
3329 event
->kind
= FILE_NOTIFY_EVENT
;
3330 event
->timestamp
= msg
->msg
.time
;
3331 event
->modifiers
= 0;
3332 event
->frame_or_window
= callback
;
3333 event
->arg
= list3 (make_pointer_integer (ns
->desc
),
3335 kbd_buffer_store_event (event
);
3337 if (!fni
->NextEntryOffset
)
3339 p
+= fni
->NextEntryOffset
;
3340 fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3341 info_size
-= fni
->NextEntryOffset
;
3344 /* Free this notifications set. */
3345 xfree (ns
->notifications
);
3349 /* We've stuffed all the events ourselves, so w32_read_socket shouldn't. */
3350 event
->kind
= NO_EVENT
;
3352 #endif /* WINDOWSNT */
3353 #endif /* HAVE_W32NOTIFY */
3356 /* Function to report a mouse movement to the mainstream Emacs code.
3357 The input handler calls this.
3359 We have received a mouse movement event, which is given in *event.
3360 If the mouse is over a different glyph than it was last time, tell
3361 the mainstream emacs code by setting mouse_moved. If not, ask for
3362 another motion event, so we can check again the next time it moves. */
3365 note_mouse_movement (struct frame
*frame
, MSG
*msg
)
3367 struct w32_display_info
*dpyinfo
;
3368 int mouse_x
= LOWORD (msg
->lParam
);
3369 int mouse_y
= HIWORD (msg
->lParam
);
3372 if (!FRAME_X_OUTPUT (frame
))
3375 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
3376 dpyinfo
->last_mouse_movement_time
= msg
->time
;
3377 dpyinfo
->last_mouse_motion_frame
= frame
;
3378 dpyinfo
->last_mouse_motion_x
= mouse_x
;
3379 dpyinfo
->last_mouse_motion_y
= mouse_y
;
3381 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3383 frame
->mouse_moved
= true;
3384 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3385 note_mouse_highlight (frame
, -1, -1);
3386 dpyinfo
->last_mouse_glyph_frame
= NULL
;
3390 /* Has the mouse moved off the glyph it was on at the last sighting? */
3391 r
= &dpyinfo
->last_mouse_glyph
;
3392 if (frame
!= dpyinfo
->last_mouse_glyph_frame
3393 || mouse_x
< r
->left
|| mouse_x
>= r
->right
3394 || mouse_y
< r
->top
|| mouse_y
>= r
->bottom
)
3396 frame
->mouse_moved
= true;
3397 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3398 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3399 /* Remember the mouse position here, as w32_mouse_position only
3400 gets called when mouse tracking is enabled but we also need
3401 to keep track of the mouse for help_echo and highlighting at
3403 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, r
);
3404 dpyinfo
->last_mouse_glyph_frame
= frame
;
3412 /************************************************************************
3414 ************************************************************************/
3416 static struct scroll_bar
*x_window_to_scroll_bar (Window
, int);
3417 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3418 enum scroll_bar_part
*,
3419 Lisp_Object
*, Lisp_Object
*,
3421 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3422 enum scroll_bar_part
*,
3423 Lisp_Object
*, Lisp_Object
*,
3426 w32_define_cursor (Window window
, Cursor cursor
)
3428 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3431 /* Return the current position of the mouse.
3432 *fp should be a frame which indicates which display to ask about.
3434 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3435 and *part to the frame, window, and scroll bar part that the mouse
3436 is over. Set *x and *y to the portion and whole of the mouse's
3437 position on the scroll bar.
3439 If the mouse movement started elsewhere, set *fp to the frame the
3440 mouse is on, *bar_window to nil, and *x and *y to the character cell
3443 Set *time to the server time-stamp for the time at which the mouse
3444 was at this position.
3446 Don't store anything if we don't have a valid set of values to report.
3448 This clears the mouse_moved flag, so we can wait for the next mouse
3452 w32_mouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
3453 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
3456 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
3460 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
3462 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
3464 if (bar
->horizontal
)
3465 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3467 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3472 Lisp_Object frame
, tail
;
3473 struct frame
*f1
= NULL
;
3475 /* Clear the mouse-moved flag for every frame on this display. */
3476 FOR_EACH_FRAME (tail
, frame
)
3477 XFRAME (frame
)->mouse_moved
= false;
3479 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3483 /* Now we have a position on the root; find the innermost window
3484 containing the pointer. */
3486 /* If mouse was grabbed on a frame, give coords for that
3487 frame even if the mouse is now outside it. Otherwise
3488 check for window under mouse on one of our frames. */
3489 if (x_mouse_grabbed (dpyinfo
))
3490 f1
= dpyinfo
->last_mouse_frame
;
3493 HWND wfp
= WindowFromPoint (pt
);
3497 f1
= x_any_window_to_frame (dpyinfo
, wfp
);
3500 HWND cwfp
= ChildWindowFromPoint (wfp
, pt
);
3504 struct frame
*f2
= x_any_window_to_frame (dpyinfo
, cwfp
);
3506 /* If a child window was found, make sure that its
3507 frame is a child frame (Bug#26615, maybe). */
3508 if (f2
&& FRAME_PARENT_FRAME (f2
))
3515 /* If not, is it one of our scroll bars? */
3518 struct scroll_bar
*bar
3519 = x_window_to_scroll_bar (WindowFromPoint (pt
), 2);
3522 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3525 if (f1
== 0 && insist
> 0)
3526 f1
= SELECTED_FRAME ();
3530 /* Ok, we found a frame. Store all the values.
3531 last_mouse_glyph is a rectangle used to reduce the
3532 generation of mouse events. To not miss any motion
3533 events, we must divide the frame into rectangles of the
3534 size of the smallest character that could be displayed
3535 on it, i.e. into the same rectangles that matrices on
3536 the frame are divided into. */
3538 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
3539 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3540 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &dpyinfo
->last_mouse_glyph
);
3541 dpyinfo
->last_mouse_glyph_frame
= f1
;
3544 *part
= scroll_bar_above_handle
;
3548 *time
= dpyinfo
->last_mouse_movement_time
;
3557 /***********************************************************************
3559 ***********************************************************************/
3561 /* Handle mouse button event on the tool-bar of frame F, at
3562 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
3563 or ButtonRelease. */
3566 w32_handle_tool_bar_click (struct frame
*f
, struct input_event
*button_event
)
3568 int x
= XFASTINT (button_event
->x
);
3569 int y
= XFASTINT (button_event
->y
);
3571 if (button_event
->modifiers
& down_modifier
)
3572 handle_tool_bar_click (f
, x
, y
, 1, 0);
3574 handle_tool_bar_click (f
, x
, y
, 0,
3575 button_event
->modifiers
& ~up_modifier
);
3580 /***********************************************************************
3582 ***********************************************************************/
3584 /* Scroll bar support. */
3586 /* Given a window ID, find the struct scroll_bar which manages it
3587 vertically. This can be called in GC, so we have to make sure to
3588 strip off mark bits. */
3590 static struct scroll_bar
*
3591 x_window_to_scroll_bar (Window window_id
, int type
)
3593 Lisp_Object tail
, frame
;
3595 FOR_EACH_FRAME (tail
, frame
)
3597 Lisp_Object bar
, condemned
;
3599 /* Scan this frame's scroll bar list for a scroll bar with the
3601 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3602 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3603 /* This trick allows us to search both the ordinary and
3604 condemned scroll bar lists with one loop. */
3605 ! NILP (bar
) || (bar
= condemned
,
3608 bar
= XSCROLL_BAR (bar
)->next
)
3609 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
3611 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
3612 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
3613 return XSCROLL_BAR (bar
);
3621 /* Set the thumb size and position of vertical scroll bar BAR. We are currently
3622 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3625 w32_set_scroll_bar_thumb (struct scroll_bar
*bar
,
3626 int portion
, int position
, int whole
)
3628 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3629 /* We use the whole scroll-bar height in the calculations below, to
3630 avoid strange effects like scrolling backwards when just clicking
3631 on the handle (without moving it). */
3632 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
)
3633 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3634 int sb_page
, sb_pos
;
3635 BOOL draggingp
= bar
->dragging
? TRUE
: FALSE
;
3638 /* We used to change the nPage setting while dragging the handle,
3639 but that had very strange effects (such as scrolling backwards
3640 while dragging downwards).
3642 Now, we don't change the nPage setting while dragging unless we
3643 get near to the end of the buffer, in which case we often have to
3644 resize the handle to "go all the way". */
3650 si
.cbSize
= sizeof (si
);
3651 si
.fMask
= SIF_POS
| SIF_PAGE
;
3652 GetScrollInfo (w
, SB_CTL
, &si
);
3653 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3661 /* Position scroll bar at rock bottom if the bottom of the
3662 buffer is visible. This avoids shrinking the thumb away
3663 to nothing if it is held at the bottom of the buffer. */
3664 if (position
+ portion
>= whole
&& !draggingp
)
3666 sb_page
= range
* (whole
- position
) / whole
;
3671 sb_pos
= position
* range
/ whole
;
3672 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3681 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3685 si
.cbSize
= sizeof (si
);
3686 si
.fMask
= SIF_PAGE
| SIF_POS
;
3690 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3695 /* Set the thumb size and position of horizontal scroll bar BAR. We are currently
3696 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3699 w32_set_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
3700 int portion
, int position
, int whole
)
3702 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3707 si
.cbSize
= sizeof (si
);
3708 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
3711 /* Allow nPage to be one larger than nPos so we don't allow the scrolling
3712 of an already fully visible buffer. */
3713 si
.nPage
= min (portion
, si
.nMax
) + 1;
3714 si
.nPos
= min (position
, si
.nMax
);
3715 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3721 /************************************************************************
3722 Scroll bars, general
3723 ************************************************************************/
3726 my_create_vscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3728 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3729 WM_EMACS_CREATEVSCROLLBAR
, (WPARAM
) f
,
3734 my_create_hscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3736 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3737 WM_EMACS_CREATEHSCROLLBAR
, (WPARAM
) f
,
3741 /*#define ATTACH_THREADS*/
3744 my_show_window (struct frame
*f
, HWND hwnd
, int how
)
3746 #ifndef ATTACH_THREADS
3747 return SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3748 (WPARAM
) hwnd
, (LPARAM
) how
, 0, 6000, NULL
);
3750 return ShowWindow (hwnd
, how
);
3755 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3756 int x
, int y
, int cx
, int cy
, UINT flags
)
3758 #ifndef ATTACH_THREADS
3760 pos
.hwndInsertAfter
= hwndAfter
;
3766 SendMessageTimeout (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0,
3769 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3775 my_set_focus (struct frame
* f
, HWND hwnd
)
3777 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3778 (WPARAM
) hwnd
, 0, 0, 6000, NULL
);
3783 my_set_foreground_window (HWND hwnd
)
3785 SendMessageTimeout (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0,
3791 my_destroy_window (struct frame
* f
, HWND hwnd
)
3793 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3794 (WPARAM
) hwnd
, 0, 0, 6000, NULL
);
3798 my_bring_window_to_top (HWND hwnd
)
3800 SendMessageTimeout (hwnd
, WM_EMACS_BRINGTOTOP
, (WPARAM
) hwnd
, 0,
3804 /* Create a scroll bar and return the scroll bar vector for it. W is
3805 the Emacs window on which to create the scroll bar. TOP, LEFT,
3806 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
3809 static struct scroll_bar
*
3810 x_scroll_bar_create (struct window
*w
, int left
, int top
, int width
, int height
, bool horizontal
)
3812 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3815 struct scroll_bar
*bar
3816 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, top
, PVEC_OTHER
);
3821 XSETWINDOW (bar
->window
, w
);
3825 bar
->height
= height
;
3829 bar
->horizontal
= horizontal
;
3831 /* Requires geometry to be set before call to create the real window */
3834 hwnd
= my_create_hscrollbar (f
, bar
);
3836 hwnd
= my_create_vscrollbar (f
, bar
);
3838 si
.cbSize
= sizeof (si
);
3842 si
.nMax
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
)
3843 + HORIZONTAL_SCROLL_BAR_MIN_HANDLE
;
3845 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3846 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3850 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3852 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3854 /* Add bar to its frame's list of scroll bars. */
3855 bar
->next
= FRAME_SCROLL_BARS (f
);
3857 XSETVECTOR (barobj
, bar
);
3858 fset_scroll_bars (f
, barobj
);
3859 if (! NILP (bar
->next
))
3860 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3868 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3872 x_scroll_bar_remove (struct scroll_bar
*bar
)
3874 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3878 /* Destroy the window. */
3879 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3881 /* Dissociate this scroll bar from its window. */
3882 if (bar
->horizontal
)
3883 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3885 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3890 /* Set the handle of the vertical scroll bar for WINDOW to indicate that
3891 we are displaying PORTION characters out of a total of WHOLE
3892 characters, starting at POSITION. If WINDOW has no vertical scroll
3895 w32_set_vertical_scroll_bar (struct window
*w
,
3896 int portion
, int whole
, int position
)
3898 struct frame
*f
= XFRAME (w
->frame
);
3900 struct scroll_bar
*bar
;
3901 int top
, height
, left
, width
;
3902 int window_y
, window_height
;
3904 /* Get window dimensions. */
3905 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
3907 height
= window_height
;
3909 /* Compute the left edge and the width of the scroll bar area. */
3910 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3911 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
3913 /* Does the scroll bar exist yet? */
3914 if (NILP (w
->vertical_scroll_bar
))
3918 if (width
> 0 && height
> 0)
3920 hdc
= get_frame_dc (f
);
3921 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3922 release_frame_dc (f
, hdc
);
3926 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, false);
3930 /* It may just need to be moved and resized. */
3933 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3934 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3936 /* If already correctly positioned, do nothing. */
3937 if (bar
->left
== left
3939 && bar
->width
== width
3940 && bar
->height
== height
)
3942 /* Redraw after clear_frame. */
3943 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3944 InvalidateRect (hwnd
, NULL
, FALSE
);
3952 if (width
&& height
)
3954 hdc
= get_frame_dc (f
);
3955 /* Since Windows scroll bars are smaller than the space reserved
3956 for them on the frame, we have to clear "under" them. */
3957 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3958 release_frame_dc (f
, hdc
);
3959 x_clear_under_internal_border (f
);
3961 /* Make sure scroll bar is "visible" before moving, to ensure the
3962 area of the parent window now exposed will be refreshed. */
3963 my_show_window (f
, hwnd
, SW_HIDE
);
3964 /** MoveWindow (hwnd, left, top, width, max (height, 1), TRUE); **/
3965 /* Try to not draw over child frames. */
3966 SetWindowPos (hwnd
, HWND_BOTTOM
, left
, top
, width
, max (height
, 1),
3969 si
.cbSize
= sizeof (si
);
3970 si
.fMask
= SIF_RANGE
;
3972 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3973 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3975 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3977 my_show_window (f
, hwnd
, SW_NORMAL
);
3978 /* InvalidateRect (w, NULL, FALSE); */
3980 /* Remember new settings. */
3984 bar
->height
= height
;
3989 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3990 XSETVECTOR (barobj
, bar
);
3991 wset_vertical_scroll_bar (w
, barobj
);
3994 /* Set the handle of the horizontal scroll bar for WINDOW to indicate
3995 that we are displaying PORTION characters out of a total of WHOLE
3996 characters, starting at POSITION. If WINDOW has no horizontal scroll
3999 w32_set_horizontal_scroll_bar (struct window
*w
,
4000 int portion
, int whole
, int position
)
4002 struct frame
*f
= XFRAME (w
->frame
);
4004 struct scroll_bar
*bar
;
4005 int top
, height
, left
, width
;
4006 int window_x
, window_width
;
4007 int clear_left
= WINDOW_LEFT_EDGE_X (w
);
4008 int clear_width
= WINDOW_PIXEL_WIDTH (w
) - WINDOW_RIGHT_DIVIDER_WIDTH (w
);
4010 /* Get window dimensions. */
4011 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
4013 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
4014 width
= window_width
;
4015 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
4017 /* Does the scroll bar exist yet? */
4018 if (NILP (w
->horizontal_scroll_bar
))
4022 if (width
> 0 && height
> 0)
4024 hdc
= get_frame_dc (f
);
4025 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
4026 release_frame_dc (f
, hdc
);
4030 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, true);
4034 /* It may just need to be moved and resized. */
4037 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
4038 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
4040 /* If already correctly positioned, do nothing. */
4041 if (bar
->left
== left
&& bar
->top
== top
4042 && bar
->width
== width
&& bar
->height
== height
)
4044 /* Redraw after clear_frame. */
4045 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
4046 InvalidateRect (hwnd
, NULL
, FALSE
);
4054 if (width
&& height
)
4056 hdc
= get_frame_dc (f
);
4057 /* Since Windows scroll bars are smaller than the space reserved
4058 for them on the frame, we have to clear "under" them. */
4059 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
4060 release_frame_dc (f
, hdc
);
4061 x_clear_under_internal_border (f
);
4063 /* Make sure scroll bar is "visible" before moving, to ensure the
4064 area of the parent window now exposed will be refreshed. */
4065 my_show_window (f
, hwnd
, SW_HIDE
);
4066 /** MoveWindow (hwnd, left, top, width, max (height, 1), TRUE); **/
4067 /* Try to not draw over child frames. */
4068 SetWindowPos (hwnd
, HWND_BOTTOM
, left
, top
, max (width
, 1), height
,
4071 /* +++ SetScrollInfo +++ */
4072 si
.cbSize
= sizeof (si
);
4073 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
4076 si
.nPage
= min (portion
, si
.nMax
) + 1;
4077 si
.nPos
= min (position
, si
.nMax
);
4078 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
4080 my_show_window (f
, hwnd
, SW_NORMAL
);
4081 /* InvalidateRect (w, NULL, FALSE); */
4083 /* Remember new settings. */
4087 bar
->height
= height
;
4093 w32_set_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
4094 XSETVECTOR (barobj
, bar
);
4095 wset_horizontal_scroll_bar (w
, barobj
);
4099 /* The following three hooks are used when we're doing a thorough
4100 redisplay of the frame. We don't explicitly know which scroll bars
4101 are going to be deleted, because keeping track of when windows go
4102 away is a real pain - "Can you say set-window-configuration, boys
4103 and girls?" Instead, we just assert at the beginning of redisplay
4104 that *all* scroll bars are to be removed, and then save a scroll bar
4105 from the fiery pit when we actually redisplay its window. */
4107 /* Arrange for all scroll bars on FRAME to be removed at the next call
4108 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
4109 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
4112 w32_condemn_scroll_bars (struct frame
*frame
)
4114 if (!NILP (FRAME_SCROLL_BARS (frame
)))
4116 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
4118 /* Prepend scrollbars to already condemned ones. */
4119 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
4121 while (!NILP (XSCROLL_BAR (last
)->next
))
4122 last
= XSCROLL_BAR (last
)->next
;
4124 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
4125 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
4128 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
4129 fset_scroll_bars (frame
, Qnil
);
4134 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
4135 Note that WINDOW isn't necessarily condemned at all. */
4138 w32_redeem_scroll_bar (struct window
*w
)
4140 struct scroll_bar
*bar
;
4144 /* We can't redeem this window's scroll bar if it doesn't have one. */
4145 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
4148 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4150 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4151 /* Unlink it from the condemned list. */
4152 f
= XFRAME (WINDOW_FRAME (w
));
4153 if (NILP (bar
->prev
))
4155 /* If the prev pointer is nil, it must be the first in one of
4157 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
4158 /* It's not condemned. Everything's fine. */
4160 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4161 w
->vertical_scroll_bar
))
4162 fset_condemned_scroll_bars (f
, bar
->next
);
4164 /* If its prev pointer is nil, it must be at the front of
4165 one or the other! */
4169 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4171 if (! NILP (bar
->next
))
4172 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4174 bar
->next
= FRAME_SCROLL_BARS (f
);
4176 XSETVECTOR (barobj
, bar
);
4177 fset_scroll_bars (f
, barobj
);
4178 if (! NILP (bar
->next
))
4179 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4183 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
4185 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
4186 /* Unlink it from the condemned list. */
4187 f
= XFRAME (WINDOW_FRAME (w
));
4188 if (NILP (bar
->prev
))
4190 /* If the prev pointer is nil, it must be the first in one of
4192 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
4193 /* It's not condemned. Everything's fine. */
4195 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4196 w
->horizontal_scroll_bar
))
4197 fset_condemned_scroll_bars (f
, bar
->next
);
4199 /* If its prev pointer is nil, it must be at the front of
4200 one or the other! */
4204 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4206 if (! NILP (bar
->next
))
4207 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4209 bar
->next
= FRAME_SCROLL_BARS (f
);
4211 XSETVECTOR (barobj
, bar
);
4212 fset_scroll_bars (f
, barobj
);
4213 if (! NILP (bar
->next
))
4214 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4218 /* Remove all scroll bars on FRAME that haven't been saved since the
4219 last call to `*condemn_scroll_bars_hook'. */
4222 w32_judge_scroll_bars (struct frame
*f
)
4224 Lisp_Object bar
, next
;
4226 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
4228 /* Clear out the condemned list now so we won't try to process any
4229 more events on the hapless scroll bars. */
4230 fset_condemned_scroll_bars (f
, Qnil
);
4232 for (; ! NILP (bar
); bar
= next
)
4234 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
4236 x_scroll_bar_remove (b
);
4239 b
->next
= b
->prev
= Qnil
;
4242 /* Now there should be no references to the condemned scroll bars,
4243 and they should get garbage-collected. */
4246 /* Handle a mouse click on the vertical scroll bar BAR. If
4247 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4250 This may be called from a signal handler, so we have to ignore GC
4254 w32_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4255 struct input_event
*emacs_event
)
4257 if (! WINDOWP (bar
->window
))
4260 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
4261 emacs_event
->code
= 0;
4262 /* not really meaningful to distinguish up/down */
4263 emacs_event
->modifiers
= msg
->dwModifiers
;
4264 emacs_event
->frame_or_window
= bar
->window
;
4265 emacs_event
->arg
= Qnil
;
4266 emacs_event
->timestamp
= msg
->msg
.time
;
4269 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4271 int dragging
= bar
->dragging
;
4273 int sb_event
= LOWORD (msg
->msg
.wParam
);
4275 si
.cbSize
= sizeof (si
);
4276 if (sb_event
== SB_THUMBTRACK
)
4277 si
.fMask
= SIF_TRACKPOS
;
4281 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4282 if (sb_event
== SB_THUMBTRACK
)
4288 struct frame
*f
; /* Value is not used. */
4289 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4294 emacs_event
->part
= scroll_bar_down_arrow
;
4297 emacs_event
->part
= scroll_bar_up_arrow
;
4300 emacs_event
->part
= scroll_bar_above_handle
;
4303 emacs_event
->part
= scroll_bar_below_handle
;
4306 emacs_event
->part
= scroll_bar_handle
;
4310 emacs_event
->part
= scroll_bar_handle
;
4314 case SB_THUMBPOSITION
:
4315 bar
->dragging
= 1; /* ??????? */
4316 emacs_event
->part
= scroll_bar_handle
;
4318 /* "Silently" update current position. */
4322 si
.cbSize
= sizeof (si
);
4325 /* Remember apparent position (we actually lag behind the real
4326 position, so don't set that directly). */
4327 last_scroll_bar_drag_pos
= y
;
4329 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4333 /* If this is the end of a drag sequence, then reset the scroll
4334 handle size to normal and do a final redraw. Otherwise do
4339 int start
= bar
->start
;
4342 si
.cbSize
= sizeof (si
);
4343 si
.fMask
= SIF_PAGE
| SIF_POS
;
4344 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4345 si
.nPos
= last_scroll_bar_drag_pos
;
4346 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4350 emacs_event
->kind
= NO_EVENT
;
4354 XSETINT (emacs_event
->x
, y
);
4355 XSETINT (emacs_event
->y
, top_range
);
4361 /* Handle a mouse click on the horizontal scroll bar BAR. If
4362 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4365 This may be called from a signal handler, so we have to ignore GC
4369 w32_horizontal_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4370 struct input_event
*emacs_event
)
4372 if (! WINDOWP (bar
->window
))
4375 emacs_event
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
4376 emacs_event
->code
= 0;
4377 /* not really meaningful to distinguish left/right */
4378 emacs_event
->modifiers
= msg
->dwModifiers
;
4379 emacs_event
->frame_or_window
= bar
->window
;
4380 emacs_event
->arg
= Qnil
;
4381 emacs_event
->timestamp
= msg
->msg
.time
;
4384 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4386 int dragging
= bar
->dragging
;
4388 int sb_event
= LOWORD (msg
->msg
.wParam
);
4390 si
.cbSize
= sizeof (si
);
4391 if (sb_event
== SB_THUMBTRACK
)
4392 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4394 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4396 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4397 if (sb_event
== SB_THUMBTRACK
)
4401 y
= si
.nMax
- si
.nPage
;
4404 struct frame
*f
; /* Value is not used. */
4405 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4410 emacs_event
->part
= scroll_bar_left_arrow
;
4413 emacs_event
->part
= scroll_bar_right_arrow
;
4416 emacs_event
->part
= scroll_bar_before_handle
;
4419 emacs_event
->part
= scroll_bar_after_handle
;
4422 emacs_event
->part
= scroll_bar_horizontal_handle
;
4426 emacs_event
->part
= scroll_bar_horizontal_handle
;
4430 case SB_THUMBPOSITION
:
4432 emacs_event
->part
= scroll_bar_horizontal_handle
;
4434 /* "Silently" update current position. */
4438 si
.cbSize
= sizeof (si
);
4440 si
.nPos
= min (x
, XWINDOW (bar
->window
)->hscroll_whole
- 1);
4441 /* Remember apparent position (we actually lag behind the real
4442 position, so don't set that directly). */
4443 last_scroll_bar_drag_pos
= x
;
4445 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4449 /* If this is the end of a drag sequence, then reset the scroll
4450 handle size to normal and do a final redraw. Otherwise do
4456 si
.cbSize
= sizeof (si
);
4458 si
.nPos
= min (last_scroll_bar_drag_pos
,
4459 XWINDOW (bar
->window
)->hscroll_whole
- 1);
4460 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4464 emacs_event
->kind
= NO_EVENT
;
4468 XSETINT (emacs_event
->x
, x
);
4469 XSETINT (emacs_event
->y
, y
);
4475 /* Return information to the user about the current position of the mouse
4476 on the vertical scroll bar. */
4478 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4479 enum scroll_bar_part
*part
,
4480 Lisp_Object
*x
, Lisp_Object
*y
,
4483 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4484 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4485 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4486 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4488 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4490 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4495 *bar_window
= bar
->window
;
4497 si
.cbSize
= sizeof (si
);
4498 if (sb_event
== SB_THUMBTRACK
)
4499 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4501 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4503 GetScrollInfo (w
, SB_CTL
, &si
);
4504 if (sb_event
== SB_THUMBTRACK
)
4508 top_range
= si
.nMax
- si
.nPage
+ 1;
4510 *part
= scroll_bar_handle
;
4511 if (sb_event
== SB_LINEDOWN
)
4515 XSETINT (*y
, top_range
);
4517 f
->mouse_moved
= false;
4518 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4520 *time
= dpyinfo
->last_mouse_movement_time
;
4525 /* Return information to the user about the current position of the mouse
4526 on the horizontal scroll bar. */
4528 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4529 enum scroll_bar_part
*part
,
4530 Lisp_Object
*x
, Lisp_Object
*y
,
4533 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4534 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4535 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4536 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4538 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4540 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4545 *bar_window
= bar
->window
;
4547 si
.cbSize
= sizeof (si
);
4548 if (sb_event
== SB_THUMBTRACK
)
4549 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4551 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4553 GetScrollInfo (w
, SB_CTL
, &si
);
4554 if (sb_event
== SB_THUMBTRACK
)
4558 left_range
= si
.nMax
- si
.nPage
+ 1;
4560 *part
= scroll_bar_handle
;
4561 if (sb_event
== SB_LINERIGHT
)
4566 XSETINT (*x
, left_range
);
4568 f
->mouse_moved
= false;
4569 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4571 *time
= dpyinfo
->last_mouse_movement_time
;
4577 /* The screen has been cleared so we may have changed foreground or
4578 background colors, and the scroll bars may need to be redrawn.
4579 Clear out the scroll bars, and ask for expose events, so we can
4583 x_scroll_bar_clear (struct frame
*f
)
4587 /* We can have scroll bars even if this is 0,
4588 if we just turned off scroll bar mode.
4589 But in that case we should not clear them. */
4590 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4591 || FRAME_HAS_HORIZONTAL_SCROLL_BARS (f
))
4592 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4593 bar
= XSCROLL_BAR (bar
)->next
)
4595 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4596 HDC hdc
= GetDC (window
);
4599 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4600 arranges to refresh the scroll bar if hidden. */
4601 my_show_window (f
, window
, SW_HIDE
);
4603 GetClientRect (window
, &rect
);
4604 select_palette (f
, hdc
);
4605 w32_clear_rect (f
, hdc
, &rect
);
4606 x_clear_under_internal_border (f
);
4607 deselect_palette (f
, hdc
);
4609 ReleaseDC (window
, hdc
);
4613 /* The main W32 event-reading loop - w32_read_socket. */
4615 /* Record the last 100 characters stored
4616 to help debug the loss-of-chars-during-GC problem. */
4618 static int temp_index
;
4619 static short temp_buffer
[100];
4621 /* Temporarily store lead byte of DBCS input sequences. */
4622 static char dbcs_lead
= 0;
4624 /* Read events coming from the W32 shell.
4625 This routine is called by the SIGIO handler.
4626 We return as soon as there are no more events to be read.
4628 For an overview of how Emacs input works on MS-Windows, see the
4629 commentary before w32_msg_pump in w32fns.c.
4631 We return the number of characters stored into the buffer,
4632 thus pretending to be `read'.
4634 Some of these messages are reposted back to the message queue since the
4635 system calls the windows proc directly in a context where we cannot return
4636 the data nor can we guarantee the state we are in. So if we dispatch them
4637 we will get into an infinite loop. To prevent this from ever happening we
4638 will set a variable to indicate we are in the read_socket call and indicate
4639 which message we are processing since the windows proc gets called
4640 recursively with different messages by the system.
4643 extern void menubar_selection_callback (struct frame
*, void *);
4646 w32_read_socket (struct terminal
*terminal
,
4647 struct input_event
*hold_quit
)
4650 int check_visibility
= 0;
4653 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4654 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
4658 /* So people can tell when we have read the available input. */
4659 input_signal_count
++;
4661 /* Process any incoming thread messages. */
4662 drain_message_queue ();
4664 /* TODO: ghostscript integration. */
4665 while (get_next_msg (&msg
, FALSE
))
4667 struct input_event inev
;
4670 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4671 /* w32_name_of_message (msg.msg.message), */
4672 /* msg.msg.time)); */
4675 inev
.kind
= NO_EVENT
;
4678 switch (msg
.msg
.message
)
4680 case WM_EMACS_PAINT
:
4681 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4685 if (msg
.rect
.right
== msg
.rect
.left
||
4686 msg
.rect
.bottom
== msg
.rect
.top
)
4688 /* We may get paint messages even though the client
4689 area is clipped - these are not expose events. */
4690 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4693 else if (FRAME_VISIBLE_P (f
) != 1)
4695 bool iconified
= FRAME_ICONIFIED_P (f
);
4697 /* Definitely not obscured, so mark as visible. */
4698 SET_FRAME_VISIBLE (f
, 1);
4699 SET_FRAME_ICONIFIED (f
, false);
4700 SET_FRAME_GARBAGED (f
);
4701 if (!f
->output_data
.w32
->asked_for_visible
)
4702 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4705 /* WM_PAINT serves as MapNotify as well, so report
4706 visibility changes properly. */
4709 inev
.kind
= DEICONIFY_EVENT
;
4710 XSETFRAME (inev
.frame_or_window
, f
);
4712 else if (!NILP (Vframe_list
) && !NILP (XCDR (Vframe_list
)))
4713 /* Force a redisplay sooner or later to update the
4714 frame titles in case this is the second frame. */
4715 record_asynch_buffer_change ();
4719 /* Erase background again for safety. But don't do
4720 that if the frame's 'garbaged' flag is set, since
4721 in that case expose_frame will do nothing, and if
4722 the various redisplay flags happen to be unset,
4723 we are left with a blank frame. */
4724 if (!FRAME_GARBAGED_P (f
) || FRAME_PARENT_FRAME (f
))
4726 HDC hdc
= get_frame_dc (f
);
4728 w32_clear_rect (f
, hdc
, &msg
.rect
);
4729 release_frame_dc (f
, hdc
);
4734 msg
.rect
.right
- msg
.rect
.left
,
4735 msg
.rect
.bottom
- msg
.rect
.top
);
4736 x_clear_under_internal_border (f
);
4741 case WM_INPUTLANGCHANGE
:
4742 /* Generate a language change event. */
4743 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4745 /* lParam contains the input language ID in its low 16 bits.
4746 Use it to update our record of the keyboard codepage. */
4747 w32_keyboard_codepage
= codepage_for_locale ((LCID
)(msg
.msg
.lParam
4752 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4753 XSETFRAME (inev
.frame_or_window
, f
);
4754 inev
.code
= w32_keyboard_codepage
;
4755 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4761 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4763 if (f
&& !FRAME_ICONIFIED_P (f
))
4765 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4766 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4768 clear_mouse_face (hlinfo
);
4769 hlinfo
->mouse_face_hidden
= true;
4772 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4774 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4775 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4776 inev
.code
= msg
.msg
.wParam
;
4777 inev
.modifiers
= msg
.dwModifiers
;
4778 XSETFRAME (inev
.frame_or_window
, f
);
4779 inev
.timestamp
= msg
.msg
.time
;
4786 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4788 if (f
&& !FRAME_ICONIFIED_P (f
))
4790 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4791 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4793 clear_mouse_face (hlinfo
);
4794 hlinfo
->mouse_face_hidden
= true;
4797 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4799 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4801 inev
.modifiers
= msg
.dwModifiers
;
4802 XSETFRAME (inev
.frame_or_window
, f
);
4803 inev
.timestamp
= msg
.msg
.time
;
4805 if (msg
.msg
.message
== WM_UNICHAR
)
4807 inev
.code
= msg
.msg
.wParam
;
4809 else if (msg
.msg
.wParam
< 256)
4814 dbcs
[1] = (char) msg
.msg
.wParam
;
4818 dbcs
[0] = dbcs_lead
;
4820 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4824 DebPrint (("Invalid DBCS sequence: %d %d\n",
4826 inev
.kind
= NO_EVENT
;
4830 else if (IsDBCSLeadByteEx (w32_keyboard_codepage
,
4831 (BYTE
) msg
.msg
.wParam
))
4833 dbcs_lead
= (char) msg
.msg
.wParam
;
4834 inev
.kind
= NO_EVENT
;
4839 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4840 &dbcs
[1], 1, &code
, 1))
4842 /* What to do with garbage? */
4843 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4844 inev
.kind
= NO_EVENT
;
4852 /* Windows shouldn't generate WM_CHAR events above 0xFF
4853 in non-Unicode message handlers. */
4854 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4855 inev
.kind
= NO_EVENT
;
4858 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4859 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4864 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4866 if (f
&& !FRAME_ICONIFIED_P (f
))
4868 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4869 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4871 clear_mouse_face (hlinfo
);
4872 hlinfo
->mouse_face_hidden
= true;
4875 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4877 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4878 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4879 inev
.code
= GET_APPCOMMAND_LPARAM (msg
.msg
.lParam
);
4880 inev
.modifiers
= msg
.dwModifiers
;
4881 XSETFRAME (inev
.frame_or_window
, f
);
4882 inev
.timestamp
= msg
.msg
.time
;
4887 /* Ignore non-movement. */
4889 int x
= LOWORD (msg
.msg
.lParam
);
4890 int y
= HIWORD (msg
.msg
.lParam
);
4891 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4893 last_mousemove_x
= x
;
4894 last_mousemove_y
= y
;
4897 previous_help_echo_string
= help_echo_string
;
4898 help_echo_string
= Qnil
;
4900 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4901 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4903 if (hlinfo
->mouse_face_hidden
)
4905 hlinfo
->mouse_face_hidden
= false;
4906 clear_mouse_face (hlinfo
);
4911 /* Maybe generate SELECT_WINDOW_EVENTs for
4912 `mouse-autoselect-window'. */
4913 if (!NILP (Vmouse_autoselect_window
)
4914 && (f
== XFRAME (selected_frame
)
4915 /* Switch to f from another frame iff
4916 focus_follows_mouse is set and f accepts
4918 || (!NILP (focus_follows_mouse
)
4919 && !FRAME_NO_ACCEPT_FOCUS (f
))))
4921 static Lisp_Object last_mouse_window
;
4922 Lisp_Object window
= window_from_coordinates
4923 (f
, LOWORD (msg
.msg
.lParam
), HIWORD (msg
.msg
.lParam
), 0, 0);
4925 /* Window will be selected only when it is not
4926 selected now and last mouse movement event was
4927 not in it. Minibuffer window will be selected
4928 only when it is active. */
4929 if (WINDOWP (window
)
4930 && !EQ (window
, last_mouse_window
)
4931 && !EQ (window
, selected_window
))
4933 inev
.kind
= SELECT_WINDOW_EVENT
;
4934 inev
.frame_or_window
= window
;
4937 /* Remember the last window where we saw the mouse. */
4938 last_mouse_window
= window
;
4941 if (!note_mouse_movement (f
, &msg
.msg
))
4942 help_echo_string
= previous_help_echo_string
;
4946 /* If we move outside the frame, then we're
4947 certainly no longer on any text in the frame. */
4948 clear_mouse_face (hlinfo
);
4951 /* If the contents of the global variable help_echo_string
4952 has changed, generate a HELP_EVENT. */
4953 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4954 But it was originally changed to this to fix a bug, so I have
4955 not removed it completely in case the bug is still there. */
4956 if (help_echo_string
!= previous_help_echo_string
||
4957 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4958 #else /* This is what xterm.c does. */
4959 if (!NILP (help_echo_string
)
4960 || !NILP (previous_help_echo_string
))
4965 case WM_LBUTTONDOWN
:
4967 case WM_MBUTTONDOWN
:
4969 case WM_RBUTTONDOWN
:
4971 case WM_XBUTTONDOWN
:
4974 /* If we decide we want to generate an event to be seen
4975 by the rest of Emacs, we put it here. */
4976 bool tool_bar_p
= 0;
4980 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4981 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4985 construct_mouse_click (&inev
, &msg
, f
);
4987 /* Is this in the tool-bar? */
4988 if (WINDOWP (f
->tool_bar_window
)
4989 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4992 int x
= XFASTINT (inev
.x
);
4993 int y
= XFASTINT (inev
.y
);
4995 window
= window_from_coordinates (f
, x
, y
, 0, 1);
4997 if (EQ (window
, f
->tool_bar_window
))
4999 w32_handle_tool_bar_click (f
, &inev
);
5005 || (dpyinfo
->w32_focus_frame
5006 && f
!= dpyinfo
->w32_focus_frame
5007 /* This does not help when the click happens in
5008 a grand-parent frame. */
5009 && !frame_ancestor_p (f
, dpyinfo
->w32_focus_frame
)))
5010 inev
.kind
= NO_EVENT
;
5013 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
5018 dpyinfo
->grabbed
&= ~ (1 << button
);
5022 dpyinfo
->grabbed
|= (1 << button
);
5023 dpyinfo
->last_mouse_frame
= f
;
5024 /* Ignore any mouse motion that happened
5025 before this event; any subsequent mouse-movement
5026 Emacs events should reflect only motion after
5030 f
->mouse_moved
= false;
5032 f
->last_tool_bar_item
= -1;
5039 case WM_MOUSEHWHEEL
:
5041 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
5042 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
5046 if (!dpyinfo
->w32_focus_frame
5047 || f
== dpyinfo
->w32_focus_frame
)
5048 /* Emit an Emacs wheel-up/down event. */
5050 construct_mouse_wheel (&inev
, &msg
, f
);
5052 /* Ignore any mouse motion that happened before this
5053 event; any subsequent mouse-movement Emacs events
5054 should reflect only motion after the ButtonPress. */
5055 f
->mouse_moved
= false;
5056 f
->last_tool_bar_item
= -1;
5057 dpyinfo
->last_mouse_frame
= f
;
5059 else if (FRAME_NO_ACCEPT_FOCUS (f
)
5060 && !x_mouse_grabbed (dpyinfo
))
5062 Lisp_Object frame1
= get_frame_param (f
, Qmouse_wheel_frame
);
5063 struct frame
*f1
= FRAMEP (frame1
) ? XFRAME (frame1
) : NULL
;
5065 if (f1
&& FRAME_LIVE_P (f1
) && FRAME_W32_P (f1
))
5067 construct_mouse_wheel (&inev
, &msg
, f1
);
5068 f1
->mouse_moved
= false;
5069 f1
->last_tool_bar_item
= -1;
5070 dpyinfo
->last_mouse_frame
= f1
;
5073 dpyinfo
->last_mouse_frame
= f
;
5076 dpyinfo
->last_mouse_frame
= f
;
5079 dpyinfo
->last_mouse_frame
= f
;
5084 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5087 construct_drag_n_drop (&inev
, &msg
, f
);
5092 struct scroll_bar
*bar
=
5093 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 1);
5096 w32_horizontal_scroll_bar_handle_click (bar
, &msg
, &inev
);
5102 struct scroll_bar
*bar
=
5103 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 0);
5106 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
5110 case WM_WINDOWPOSCHANGED
:
5111 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5116 int /* rows, columns, */ width
, height
, text_width
, text_height
;
5118 if (GetClientRect (msg
.msg
.hwnd
, &rect
)
5119 /* GetClientRect evidently returns (0, 0, 0, 0) if
5120 called on a minimized frame. Such "dimensions"
5121 aren't useful anyway. */
5122 && !(rect
.bottom
== 0
5125 && rect
.right
== 0))
5127 height
= rect
.bottom
- rect
.top
;
5128 width
= rect
.right
- rect
.left
;
5129 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, width
);
5130 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, height
);
5131 /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
5132 /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
5134 /* TODO: Clip size to the screen dimensions. */
5136 /* Even if the number of character rows and columns
5137 has not changed, the font size may have changed,
5138 so we need to check the pixel dimensions as well. */
5140 if (width
!= FRAME_PIXEL_WIDTH (f
)
5141 || height
!= FRAME_PIXEL_HEIGHT (f
)
5142 || text_width
!= FRAME_TEXT_WIDTH (f
)
5143 || text_height
!= FRAME_TEXT_HEIGHT (f
))
5145 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
5146 SET_FRAME_GARBAGED (f
);
5147 cancel_mouse_face (f
);
5148 f
->win_gravity
= NorthWestGravity
;
5153 check_visibility
= 1;
5157 case WM_ACTIVATEAPP
:
5158 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5161 /* Run the full-screen hook function also when we are
5162 being activated, to actually install the required
5163 size in effect, if the WAIT flag is set. This is
5164 because when the hook is run from x_set_fullscreen,
5165 the frame might not yet be visible, if that call is a
5166 result of make-frame, and in that case the hook just
5167 sets the WAIT flag. */
5168 if ((msg
.msg
.message
== WM_WINDOWPOSCHANGED
|| msg
.msg
.wParam
)
5169 && (f
->want_fullscreen
& FULLSCREEN_WAIT
))
5171 /* Must set visibility right here since otherwise
5172 w32fullscreen_hook returns immediately. */
5173 SET_FRAME_VISIBLE (f
, 1);
5174 w32fullscreen_hook (f
);
5178 check_visibility
= 1;
5182 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5184 if (f
&& FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P(f
))
5186 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5187 inev
.kind
= MOVE_FRAME_EVENT
;
5188 XSETFRAME (inev
.frame_or_window
, f
);
5191 check_visibility
= 1;
5195 /* wParam non-zero means Window is about to be shown, 0 means
5196 about to be hidden. */
5197 /* Redo the mouse-highlight after the tooltip has gone. */
5198 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
5201 x_redo_mouse_highlight (dpyinfo
);
5204 /* If window has been obscured or exposed by another window
5205 being maximized or minimized/restored, then recheck
5206 visibility of all frames. Direct changes to our own
5207 windows get handled by WM_SIZE. */
5209 if (msg
.msg
.lParam
!= 0)
5210 check_visibility
= 1;
5213 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5214 f
->async_visible
= msg
.msg
.wParam
;
5218 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5220 x_clear_under_internal_border (f
);
5222 check_visibility
= 1;
5226 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5228 /* Inform lisp of whether frame has been iconified etc. */
5231 switch (msg
.msg
.wParam
)
5233 case SIZE_MINIMIZED
:
5234 SET_FRAME_VISIBLE (f
, 0);
5235 SET_FRAME_ICONIFIED (f
, true);
5237 inev
.kind
= ICONIFY_EVENT
;
5238 XSETFRAME (inev
.frame_or_window
, f
);
5241 case SIZE_MAXIMIZED
:
5243 bool iconified
= FRAME_ICONIFIED_P (f
);
5244 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5246 SET_FRAME_VISIBLE (f
, 1);
5247 SET_FRAME_ICONIFIED (f
, false);
5249 /* wait_reading_process_output will notice this
5250 and update the frame's display structures. */
5251 SET_FRAME_GARBAGED (f
);
5257 /* Reset top and left positions of the Window
5258 here since Windows sends a WM_MOVE message
5259 BEFORE telling us the Window is minimized
5260 when the Window is iconified, with 3000,3000
5262 x_real_positions (f
, &x
, &y
);
5266 inev
.kind
= DEICONIFY_EVENT
;
5267 XSETFRAME (inev
.frame_or_window
, f
);
5269 else if (! NILP (Vframe_list
)
5270 && ! NILP (XCDR (Vframe_list
)))
5271 /* Force a redisplay sooner or later
5272 to update the frame titles
5273 in case this is the second frame. */
5274 record_asynch_buffer_change ();
5276 /* Windows can send us a SIZE_MAXIMIZED message even
5277 when fullscreen is fullboth. The following is a
5278 simple hack to check that based on the fact that
5279 only a maximized fullscreen frame should have both
5280 top/left outside the screen. */
5281 if (EQ (fullscreen
, Qfullwidth
) || EQ (fullscreen
, Qfullheight
)
5282 || NILP (fullscreen
))
5286 x_real_positions (f
, &x
, &y
);
5288 store_frame_param (f
, Qfullscreen
, Qmaximized
);
5296 bool iconified
= FRAME_ICONIFIED_P (f
);
5298 /* The following was made unconditional in a
5299 pathetic attempt to fix bug#16967 in revision
5300 116716 but, considered counterproductive was made
5301 conditional again in revision 116727. martin */
5303 SET_FRAME_VISIBLE (f
, 1);
5304 SET_FRAME_ICONIFIED (f
, false);
5306 /* wait_reading_process_output will notice this
5307 and update the frame's display structures. */
5308 SET_FRAME_GARBAGED (f
);
5312 /* Reset top and left positions of the Window
5313 here since Windows sends a WM_MOVE message
5314 BEFORE telling us the Window is minimized
5315 when the Window is iconified, with 3000,3000
5317 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5319 inev
.kind
= DEICONIFY_EVENT
;
5320 XSETFRAME (inev
.frame_or_window
, f
);
5322 else if (! NILP (Vframe_list
)
5323 && ! NILP (XCDR (Vframe_list
)))
5324 /* Force a redisplay sooner or later
5325 to update the frame titles
5326 in case this is the second frame. */
5327 record_asynch_buffer_change ();
5330 if (EQ (get_frame_param (f
, Qfullscreen
), Qmaximized
))
5331 store_frame_param (f
, Qfullscreen
, Qnil
);
5337 if (f
&& !FRAME_ICONIFIED_P (f
) && msg
.msg
.wParam
!= SIZE_MINIMIZED
)
5340 int /* rows, columns, */ width
, height
, text_width
, text_height
;
5342 if (GetClientRect (msg
.msg
.hwnd
, &rect
)
5343 /* GetClientRect evidently returns (0, 0, 0, 0) if
5344 called on a minimized frame. Such "dimensions"
5345 aren't useful anyway. */
5346 && !(rect
.bottom
== 0
5349 && rect
.right
== 0))
5351 height
= rect
.bottom
- rect
.top
;
5352 width
= rect
.right
- rect
.left
;
5353 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, width
);
5354 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, height
);
5355 /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
5356 /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
5358 /* TODO: Clip size to the screen dimensions. */
5360 /* Even if the number of character rows and columns
5361 has not changed, the font size may have changed,
5362 so we need to check the pixel dimensions as well. */
5364 if (width
!= FRAME_PIXEL_WIDTH (f
)
5365 || height
!= FRAME_PIXEL_HEIGHT (f
)
5366 || text_width
!= FRAME_TEXT_WIDTH (f
)
5367 || text_height
!= FRAME_TEXT_HEIGHT (f
))
5369 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
5370 SET_FRAME_GARBAGED (f
);
5371 cancel_mouse_face (f
);
5372 f
->win_gravity
= NorthWestGravity
;
5377 check_visibility
= 1;
5381 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5384 if (f
== hlinfo
->mouse_face_mouse_frame
)
5386 /* If we move outside the frame, then we're
5387 certainly no longer on any text in the frame. */
5388 clear_mouse_face (hlinfo
);
5389 hlinfo
->mouse_face_mouse_frame
= 0;
5392 /* Generate a nil HELP_EVENT to cancel a help-echo.
5393 Do it only if there's something to cancel.
5394 Otherwise, the startup message is cleared when
5395 the mouse leaves the frame. */
5396 if (any_help_event_p
)
5402 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5404 dpyinfo
->grabbed
= 0;
5405 check_visibility
= 1;
5409 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5410 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5414 if (f
== hlinfo
->mouse_face_mouse_frame
)
5416 /* If we move outside the frame, then we're
5417 certainly no longer on any text in the frame. */
5418 clear_mouse_face (hlinfo
);
5419 hlinfo
->mouse_face_mouse_frame
= 0;
5422 /* Generate a nil HELP_EVENT to cancel a help-echo.
5423 Do it only if there's something to cancel.
5424 Otherwise, the startup message is cleared when
5425 the mouse leaves the frame. */
5426 if (any_help_event_p
)
5430 dpyinfo
->grabbed
= 0;
5431 check_visibility
= 1;
5435 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5439 inev
.kind
= DELETE_WINDOW_EVENT
;
5440 XSETFRAME (inev
.frame_or_window
, f
);
5445 inev
.kind
= END_SESSION_EVENT
;
5449 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5453 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
5454 XSETFRAME (inev
.frame_or_window
, f
);
5459 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5463 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
5466 check_visibility
= 1;
5469 case WM_DISPLAYCHANGE
:
5470 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5474 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5476 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
5477 /* The new display could have a different resolution, in
5478 which case we must reconsider what fullscreen means.
5479 The following code is untested yet. */
5480 if (!NILP (fullscreen
))
5482 x_set_fullscreen (f
, fullscreen
, fullscreen
);
5483 w32fullscreen_hook (f
);
5486 DebPrint (("display change: %d %d\n",
5487 (short) LOWORD (msg
.msg
.lParam
),
5488 (short) HIWORD (msg
.msg
.lParam
)));
5491 check_visibility
= 1;
5495 case WM_EMACS_FILENOTIFY
:
5496 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5498 queue_notifications (&inev
, &msg
, f
, &count
);
5503 /* Check for messages registered at runtime. */
5504 if (msg
.msg
.message
== msh_mousewheel
)
5506 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5507 msg
.msg
.message
= WM_MOUSEWHEEL
;
5513 if (inev
.kind
!= NO_EVENT
)
5515 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5520 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5525 XSETFRAME (frame
, f
);
5531 if (NILP (help_echo_string
))
5533 help_echo_object
= help_echo_window
= Qnil
;
5537 any_help_event_p
= 1;
5538 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5539 help_echo_object
, help_echo_pos
);
5543 help_echo_string
= Qnil
;
5544 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5550 /* If the focus was just given to an autoraising frame,
5551 raise it now. FIXME: handle more than one such frame. */
5552 if (dpyinfo
->w32_pending_autoraise_frame
)
5554 x_raise_frame (dpyinfo
->w32_pending_autoraise_frame
);
5555 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
5558 /* Check which frames are still visible, if we have enqueued any user
5559 events or been notified of events that may affect visibility. We
5560 do this here because there doesn't seem to be any direct
5561 notification from Windows that the visibility of a window has
5562 changed (at least, not in all cases). */
5563 if (count
> 0 || check_visibility
)
5565 Lisp_Object tail
, frame
;
5567 FOR_EACH_FRAME (tail
, frame
)
5569 struct frame
*f
= XFRAME (frame
);
5570 /* The tooltip has been drawn already. Avoid the
5571 SET_FRAME_GARBAGED below. */
5572 if (EQ (frame
, tip_frame
))
5575 /* Check "visible" frames and mark each as obscured or not.
5576 Note that visible is nonzero for unobscured and obscured
5577 frames, but zero for hidden and iconified frames. */
5578 if (FRAME_W32_P (f
) && FRAME_VISIBLE_P (f
))
5585 /* Query clipping rectangle for the entire window area
5586 (GetWindowDC), not just the client portion (GetDC).
5587 Otherwise, the scrollbars and menubar aren't counted as
5588 part of the visible area of the frame, and we may think
5589 the frame is obscured when really a scrollbar is still
5590 visible and gets WM_PAINT messages above. */
5591 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5592 GetClipBox (hdc
, &clipbox
);
5593 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5596 obscured
= FRAME_OBSCURED_P (f
);
5598 if (clipbox
.right
== clipbox
.left
|| clipbox
.bottom
== clipbox
.top
)
5600 /* Frame has become completely obscured so mark as such (we
5601 do this by setting visible to 2 so that FRAME_VISIBLE_P
5602 is still true, but redisplay will skip it). */
5603 SET_FRAME_VISIBLE (f
, 2);
5606 DebPrint (("frame %p (%s) obscured\n", f
, SDATA (f
->name
)));
5610 /* Frame is not obscured, so mark it as such. */
5611 SET_FRAME_VISIBLE (f
, 1);
5615 SET_FRAME_GARBAGED (f
);
5616 DebPrint (("obscured frame %p (%s) found to be visible\n",
5617 f
, SDATA (f
->name
)));
5619 /* Force a redisplay sooner or later. */
5620 record_asynch_buffer_change ();
5633 /***********************************************************************
5635 ***********************************************************************/
5637 /* Set clipping for output in glyph row ROW. W is the window in which
5638 we operate. GC is the graphics context to set clipping in.
5640 ROW may be a text row or, e.g., a mode line. Text rows must be
5641 clipped to the interior of the window dedicated to text display,
5642 mode lines must be clipped to the whole window. */
5645 w32_clip_to_row (struct window
*w
, struct glyph_row
*row
,
5646 enum glyph_row_area area
, HDC hdc
)
5649 int window_x
, window_y
, window_width
;
5651 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5653 clip_rect
.left
= window_x
;
5654 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5655 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5656 clip_rect
.right
= clip_rect
.left
+ window_width
;
5657 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5659 w32_set_clip_rectangle (hdc
, &clip_rect
);
5663 /* Draw a hollow box cursor on window W in glyph row ROW. */
5666 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
5668 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5672 struct glyph
*cursor_glyph
;
5673 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5675 /* Get the glyph the cursor is on. If we can't tell because
5676 the current matrix is invalid or such, give up. */
5677 cursor_glyph
= get_phys_cursor_glyph (w
);
5678 if (cursor_glyph
== NULL
)
5684 /* Compute frame-relative coordinates for phys cursor. */
5685 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5687 /* When on R2L character, show cursor at the right edge of the
5688 glyph, unless the cursor box is as wide as the glyph or wider
5689 (the latter happens when x-stretch-cursor is non-nil). */
5690 if ((cursor_glyph
->resolved_level
& 1) != 0
5691 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5692 rect
.left
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5694 rect
.bottom
= rect
.top
+ h
;
5695 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5697 hdc
= get_frame_dc (f
);
5698 /* Set clipping, draw the rectangle, and reset clipping again. */
5699 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5700 FrameRect (hdc
, &rect
, hb
);
5702 w32_set_clip_rectangle (hdc
, NULL
);
5703 release_frame_dc (f
, hdc
);
5707 /* Draw a bar cursor on window W in glyph row ROW.
5709 Implementation note: One would like to draw a bar cursor with an
5710 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5711 Unfortunately, I didn't find a font yet that has this property set.
5715 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
,
5716 int width
, enum text_cursor_kinds kind
)
5718 struct frame
*f
= XFRAME (w
->frame
);
5719 struct glyph
*cursor_glyph
;
5721 /* If cursor is out of bounds, don't draw garbage. This can happen
5722 in mini-buffer windows when switching between echo area glyphs
5724 cursor_glyph
= get_phys_cursor_glyph (w
);
5725 if (cursor_glyph
== NULL
)
5728 /* If on an image, draw like a normal cursor. That's usually better
5729 visible than drawing a bar, esp. if the image is large so that
5730 the bar might not be in the window. */
5731 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5733 struct glyph_row
*row
;
5734 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5735 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5739 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5740 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5744 /* If the glyph's background equals the color we normally draw
5745 the bar cursor in, the bar cursor in its normal color is
5746 invisible. Use the glyph's foreground color instead in this
5747 case, on the assumption that the glyph's colors are chosen so
5748 that the glyph is legible. */
5749 if (face
->background
== cursor_color
)
5750 cursor_color
= face
->foreground
;
5752 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5754 hdc
= get_frame_dc (f
);
5755 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5757 if (kind
== BAR_CURSOR
)
5760 width
= FRAME_CURSOR_WIDTH (f
);
5761 width
= min (cursor_glyph
->pixel_width
, width
);
5763 w
->phys_cursor_width
= width
;
5765 /* If the character under cursor is R2L, draw the bar cursor
5766 on the right of its glyph, rather than on the left. */
5767 if ((cursor_glyph
->resolved_level
& 1) != 0)
5768 x
+= cursor_glyph
->pixel_width
- width
;
5770 w32_fill_area (f
, hdc
, cursor_color
, x
,
5771 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5772 width
, row
->height
);
5774 else /* HBAR_CURSOR */
5776 int dummy_x
, dummy_y
, dummy_h
;
5779 width
= row
->height
;
5781 width
= min (row
->height
, width
);
5783 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
5784 &dummy_y
, &dummy_h
);
5785 if ((cursor_glyph
->resolved_level
& 1) != 0
5786 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5787 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5788 w32_fill_area (f
, hdc
, cursor_color
, x
,
5789 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5790 row
->height
- width
),
5791 w
->phys_cursor_width
, width
);
5794 w32_set_clip_rectangle (hdc
, NULL
);
5795 release_frame_dc (f
, hdc
);
5800 /* RIF: Define cursor CURSOR on frame F. */
5803 w32_define_frame_cursor (struct frame
*f
, Cursor cursor
)
5805 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5809 /* RIF: Clear area on frame F. */
5812 w32_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
5816 hdc
= get_frame_dc (f
);
5817 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5818 release_frame_dc (f
, hdc
);
5821 /* RIF: Draw or clear cursor on window W. */
5824 w32_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
,
5825 int x
, int y
, enum text_cursor_kinds cursor_type
,
5826 int cursor_width
, bool on_p
, bool active_p
)
5830 /* If the user wants to use the system caret, make sure our own
5831 cursor remains invisible. */
5832 if (w32_use_visible_system_caret
)
5834 /* Call to erase_phys_cursor here seems to use the
5835 wrong values of w->phys_cursor, as they have been
5836 overwritten before this function was called. */
5837 if (w
->phys_cursor_type
!= NO_CURSOR
)
5838 erase_phys_cursor (w
);
5840 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5841 w
->phys_cursor_width
= -1;
5845 w
->phys_cursor_type
= cursor_type
;
5848 w
->phys_cursor_on_p
= true;
5850 /* If this is the active cursor, we need to track it with the
5851 system caret, so third party software like screen magnifiers
5852 and speech synthesizers can follow the cursor. */
5855 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5856 HWND hwnd
= FRAME_W32_WINDOW (f
);
5859 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5861 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5862 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5863 w32_system_caret_window
= w
;
5864 w32_system_caret_hdr_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
5865 w32_system_caret_mode_height
= WINDOW_MODE_LINE_HEIGHT (w
);
5867 PostMessage (hwnd
, WM_IME_STARTCOMPOSITION
, 0, 0);
5869 /* If the size of the active cursor changed, destroy the old
5871 if (w32_system_caret_hwnd
5872 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5873 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5875 w32_system_caret_height
= w
->phys_cursor_height
;
5877 /* Move the system caret. */
5878 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5881 if (glyph_row
->exact_window_width_line_p
5882 && (glyph_row
->reversed_p
5883 ? (w
->phys_cursor
.hpos
< 0)
5884 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
5886 glyph_row
->cursor_in_fringe_p
= true;
5887 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
5891 switch (cursor_type
)
5893 case HOLLOW_BOX_CURSOR
:
5894 x_draw_hollow_cursor (w
, glyph_row
);
5897 case FILLED_BOX_CURSOR
:
5898 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5902 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5906 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5910 w
->phys_cursor_width
= 0;
5924 x_bitmap_icon (struct frame
*f
, Lisp_Object icon
)
5927 HANDLE small_icon
= NULL
;
5929 if (FRAME_W32_WINDOW (f
) == 0)
5933 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5934 else if (STRINGP (icon
))
5936 /* Load the main icon from the named file. */
5937 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5938 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5939 /* Try to load a small icon to go with it. */
5940 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5941 GetSystemMetrics (SM_CXSMICON
),
5942 GetSystemMetrics (SM_CYSMICON
),
5945 else if (SYMBOLP (icon
))
5949 if (EQ (icon
, intern ("application")))
5950 name
= (LPCTSTR
) IDI_APPLICATION
;
5951 else if (EQ (icon
, intern ("hand")))
5952 name
= (LPCTSTR
) IDI_HAND
;
5953 else if (EQ (icon
, intern ("question")))
5954 name
= (LPCTSTR
) IDI_QUESTION
;
5955 else if (EQ (icon
, intern ("exclamation")))
5956 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5957 else if (EQ (icon
, intern ("asterisk")))
5958 name
= (LPCTSTR
) IDI_ASTERISK
;
5959 else if (EQ (icon
, intern ("winlogo")))
5960 name
= (LPCTSTR
) IDI_WINLOGO
;
5964 main_icon
= LoadIcon (NULL
, name
);
5969 if (main_icon
== NULL
)
5972 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5973 (LPARAM
) main_icon
);
5975 /* If there is a small icon that goes with it, set that too. */
5977 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5978 (LPARAM
) small_icon
);
5984 /************************************************************************
5986 ************************************************************************/
5988 /* Display Error Handling functions not used on W32. Listing them here
5989 helps diff stay in step when comparing w32term.c with xterm.c.
5991 x_error_catcher (display, error)
5992 x_catch_errors (dpy)
5993 x_catch_errors_unwind (old_val)
5994 x_check_errors (dpy, format)
5995 x_fully_uncatch_errors ()
5996 x_had_errors_p (dpy)
5997 x_clear_errors (dpy)
5998 x_uncatch_errors (dpy, count)
6000 x_connection_signal (signalnum)
6001 x_connection_closed (dpy, error_message)
6002 x_error_quitter (display, error)
6003 x_error_handler (display, error)
6004 x_io_error_quitter (display)
6009 /* Changing the font of the frame. */
6012 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
6014 struct font
*font
= XFONT_OBJECT (font_object
);
6015 int unit
, font_ascent
, font_descent
;
6018 fontset
= fontset_from_font (font_object
);
6019 FRAME_FONTSET (f
) = fontset
;
6020 if (FRAME_FONT (f
) == font
)
6021 /* This font is already set in frame F. There's nothing more to
6025 FRAME_FONT (f
) = font
;
6026 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
6027 FRAME_COLUMN_WIDTH (f
) = unit
= font
->average_width
;
6028 get_font_ascent_descent (font
, &font_ascent
, &font_descent
);
6029 FRAME_LINE_HEIGHT (f
) = font_ascent
+ font_descent
;
6031 /* Compute number of scrollbar columns. */
6032 unit
= FRAME_COLUMN_WIDTH (f
);
6033 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
6034 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
6035 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
6038 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
6039 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) =
6040 FRAME_CONFIG_SCROLL_BAR_COLS (f
) * unit
;
6043 /* Now make the frame display the given font. */
6044 if (FRAME_X_WINDOW (f
) != 0)
6046 /* Don't change the size of a tip frame; there's no point in
6047 doing it because it's done in Fx_show_tip, and it leads to
6048 problems because the tip frame has no widget. */
6049 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
6050 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
6051 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
6055 /* X version sets font of input methods here also. */
6061 /***********************************************************************
6062 TODO: W32 Input Methods
6063 ***********************************************************************/
6064 /* Listing missing functions from xterm.c helps diff stay in step.
6066 xim_destroy_callback (xim, client_data, call_data)
6067 xim_open_dpy (dpyinfo, resource_name)
6069 xim_instantiate_callback (display, client_data, call_data)
6070 xim_initialize (dpyinfo, resource_name)
6071 xim_close_dpy (dpyinfo)
6076 /* Calculate the absolute position in frame F
6077 from its current recorded position values and gravity. */
6080 x_calc_absolute_position (struct frame
*f
)
6082 int flags
= f
->size_hint_flags
;
6084 /* The sum of the widths of the frame's left and right borders, and
6085 the sum of the heights of the frame's top and bottom borders (in
6086 pixels) drawn by Windows. */
6087 unsigned int left_right_borders_width
, top_bottom_borders_height
;
6089 /* Try to get the actual values of these two variables. We compute
6090 the border width (height) by subtracting the width (height) of
6091 the frame's client area from the width (height) of the frame's
6093 WINDOWPLACEMENT wp
= { 0 };
6094 RECT client_rect
= { 0 };
6096 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
6097 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
6099 left_right_borders_width
=
6100 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
6101 (client_rect
.right
- client_rect
.left
);
6103 top_bottom_borders_height
=
6104 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
6105 (client_rect
.bottom
- client_rect
.top
);
6109 /* Use sensible default values. */
6110 left_right_borders_width
= 8;
6111 top_bottom_borders_height
= 32;
6114 /* With multiple monitors, we can legitimately get negative
6115 coordinates (for monitors above or to the left of the primary
6116 monitor). Find the display origin to ensure negative positions
6117 are computed correctly (Bug#21173). */
6118 int display_left
= 0;
6119 int display_top
= 0;
6120 struct frame
*p
= FRAME_PARENT_FRAME (f
);
6122 if (!p
&& flags
& (XNegative
| YNegative
))
6126 list
= Fw32_display_monitor_attributes_list (Qnil
);
6127 while (CONSP (list
))
6129 Lisp_Object attributes
= CAR(list
);
6130 Lisp_Object geometry
;
6131 Lisp_Object monitor_left
, monitor_top
;
6135 geometry
= Fassoc (Qgeometry
, attributes
, Qnil
);
6136 if (!NILP (geometry
))
6138 monitor_left
= Fnth (make_number (1), geometry
);
6139 monitor_top
= Fnth (make_number (2), geometry
);
6141 display_left
= min (display_left
, XINT (monitor_left
));
6142 display_top
= min (display_top
, XINT (monitor_top
));
6147 /* Treat negative positions as relative to the rightmost bottommost
6148 position that fits on the screen or parent frame.
6150 I see no need for subtracting 1 from the border widths - is there
6151 any on the remaining platforms? Here these subtractions did put
6152 the last pixel line/column of a frame off-display when, for
6153 example, a (set-frame-parameter nil 'left '(- 0)) specification was
6154 used - martin 20017-05-05. */
6155 if (flags
& XNegative
)
6158 f
->left_pos
= (FRAME_PIXEL_WIDTH (p
)
6159 - FRAME_PIXEL_WIDTH (f
)
6161 - left_right_borders_width
);
6163 f
->left_pos
= (x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
6165 - FRAME_PIXEL_WIDTH (f
)
6167 - left_right_borders_width
);
6170 if (flags
& YNegative
)
6173 f
->top_pos
= (FRAME_PIXEL_HEIGHT (p
)
6174 - FRAME_PIXEL_HEIGHT (f
)
6176 - top_bottom_borders_height
);
6178 f
->top_pos
= (x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
6180 - FRAME_PIXEL_HEIGHT (f
)
6182 - top_bottom_borders_height
);
6185 /* The left_pos and top_pos are now relative to the top and left
6186 screen edges, so the flags should correspond. */
6187 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6190 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
6191 to really change the position, and 0 when calling from
6192 x_make_frame_visible (in that case, XOFF and YOFF are the current
6193 position values). It is -1 when calling from x_set_frame_parameters,
6194 which means, do adjust for borders but don't change the gravity. */
6197 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
,
6200 int modified_top
, modified_left
;
6202 if (change_gravity
> 0)
6206 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6208 f
->size_hint_flags
|= XNegative
;
6210 f
->size_hint_flags
|= YNegative
;
6211 f
->win_gravity
= NorthWestGravity
;
6213 x_calc_absolute_position (f
);
6216 x_wm_set_size_hint (f
, (long) 0, false);
6218 modified_left
= f
->left_pos
;
6219 modified_top
= f
->top_pos
;
6221 if (!FRAME_PARENT_FRAME (f
))
6222 my_set_window_pos (FRAME_W32_WINDOW (f
), NULL
,
6223 modified_left
, modified_top
,
6225 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6227 my_set_window_pos (FRAME_W32_WINDOW (f
), HWND_TOP
,
6228 modified_left
, modified_top
,
6230 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6235 w32fullscreen_hook (struct frame
*f
)
6237 if (FRAME_VISIBLE_P (f
))
6239 HWND hwnd
= FRAME_W32_WINDOW(f
);
6240 DWORD dwStyle
= GetWindowLong (hwnd
, GWL_STYLE
);
6242 enum fullscreen_type prev_fsmode
= FRAME_PREV_FSMODE (f
);
6245 f
->want_fullscreen
&= ~FULLSCREEN_WAIT
;
6247 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_NONE
)
6248 GetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6250 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_BOTH
)
6252 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
| WS_OVERLAPPEDWINDOW
);
6253 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6255 else if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_HEIGHT
6256 || FRAME_PREV_FSMODE (f
) == FULLSCREEN_WIDTH
)
6257 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6259 FRAME_PREV_FSMODE (f
) = f
->want_fullscreen
;
6261 if (f
->want_fullscreen
== FULLSCREEN_NONE
)
6262 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6263 else if (f
->want_fullscreen
== FULLSCREEN_MAXIMIZED
)
6265 if (prev_fsmode
== FULLSCREEN_BOTH
|| prev_fsmode
== FULLSCREEN_WIDTH
6266 || prev_fsmode
== FULLSCREEN_HEIGHT
)
6267 /* Make window normal since otherwise the subsequent
6268 maximization might fail in some cases. */
6269 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6270 ShowWindow (hwnd
, SW_MAXIMIZE
);
6272 else if (f
->want_fullscreen
== FULLSCREEN_BOTH
)
6274 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6276 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6277 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6278 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
& ~WS_OVERLAPPEDWINDOW
);
6279 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6280 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
,
6281 SWP_NOOWNERZORDER
| SWP_FRAMECHANGED
);
6283 (f
, FRAME_PIXEL_TO_TEXT_WIDTH (f
, rect
.right
- rect
.left
),
6284 FRAME_PIXEL_TO_TEXT_HEIGHT (f
, (rect
.bottom
- rect
.top
6285 - menu_bar_height
)),
6290 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6291 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6292 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6293 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6294 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, 0);
6296 if (f
->want_fullscreen
== FULLSCREEN_WIDTH
)
6298 int border_width
= GetSystemMetrics (SM_CXFRAME
);
6301 (f
, (FRAME_PIXEL_TO_TEXT_WIDTH
6302 (f
, rect
.right
- rect
.left
- 2 * border_width
)),
6307 int border_height
= GetSystemMetrics (SM_CYFRAME
);
6308 /* Won't work for wrapped menu bar. */
6309 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6310 int title_height
= GetSystemMetrics (SM_CYCAPTION
);
6313 (f
, 0, (FRAME_PIXEL_TO_TEXT_HEIGHT
6314 (f
, rect
.bottom
- rect
.top
- 2 * border_height
6315 - title_height
- menu_bar_height
)),
6320 f
->want_fullscreen
= FULLSCREEN_NONE
;
6323 if (f
->want_fullscreen
== FULLSCREEN_BOTH
6324 || f
->want_fullscreen
== FULLSCREEN_WIDTH
6325 || f
->want_fullscreen
== FULLSCREEN_HEIGHT
)
6326 do_pending_window_change (0);
6330 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
6333 /* Call this to change the size of frame F's x-window.
6334 If CHANGE_GRAVITY, change to top-left-corner window gravity
6335 for this size change and subsequent size changes.
6336 Otherwise we leave the window gravity unchanged. */
6339 x_set_window_size (struct frame
*f
, bool change_gravity
,
6340 int width
, int height
, bool pixelwise
)
6342 int pixelwidth
, pixelheight
;
6343 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
6346 int menu_bar_height
;
6350 /* Get the height of the menu bar here. It's used below to detect
6351 whether the menu bar is wrapped. It's also used to specify the
6352 third argument for AdjustWindowRect. See bug#22105. */
6353 info
.cbSize
= sizeof (info
);
6354 info
.rcBar
.top
= info
.rcBar
.bottom
= 0;
6355 GetMenuBarInfo (FRAME_W32_WINDOW (f
), 0xFFFFFFFD, 0, &info
);
6356 menu_bar_height
= info
.rcBar
.bottom
- info
.rcBar
.top
;
6360 pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
6361 pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
6365 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
);
6366 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
);
6369 if (w32_add_wrapped_menu_bar_lines
)
6371 /* When the menu bar wraps sending a SetWindowPos shrinks the
6372 height of the frame then the wrapped menu bar lines are not
6373 accounted for (Bug#15174 and Bug#18720). Here we add these
6374 extra lines to the frame height. */
6375 int default_menu_bar_height
;
6377 /* Why is (apparently) SM_CYMENUSIZE needed here instead of
6379 default_menu_bar_height
= GetSystemMetrics (SM_CYMENUSIZE
);
6381 if ((default_menu_bar_height
> 0)
6382 && (menu_bar_height
> default_menu_bar_height
)
6383 && ((menu_bar_height
% default_menu_bar_height
) == 0))
6384 pixelheight
= pixelheight
+ menu_bar_height
- default_menu_bar_height
;
6387 f
->win_gravity
= NorthWestGravity
;
6388 x_wm_set_size_hint (f
, (long) 0, false);
6390 rect
.left
= rect
.top
= 0;
6391 rect
.right
= pixelwidth
;
6392 rect
.bottom
= pixelheight
;
6394 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
, menu_bar_height
> 0);
6396 if (!(f
->after_make_frame
)
6397 && !(f
->want_fullscreen
& FULLSCREEN_WAIT
)
6398 && FRAME_VISIBLE_P (f
))
6402 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6404 if (EQ (fullscreen
, Qmaximized
)
6405 || EQ (fullscreen
, Qfullboth
)
6406 || EQ (fullscreen
, Qfullwidth
))
6408 rect
.left
= window_rect
.left
;
6409 rect
.right
= window_rect
.right
;
6412 if (EQ (fullscreen
, Qmaximized
)
6413 || EQ (fullscreen
, Qfullboth
)
6414 || EQ (fullscreen
, Qfullheight
))
6416 rect
.top
= window_rect
.top
;
6417 rect
.bottom
= window_rect
.bottom
;
6422 if (pixelwidth
> 0 || pixelheight
> 0)
6424 frame_size_history_add
6425 (f
, Qx_set_window_size_1
, width
, height
,
6426 list2 (Fcons (make_number (pixelwidth
),
6427 make_number (pixelheight
)),
6428 Fcons (make_number (rect
.right
- rect
.left
),
6429 make_number (rect
.bottom
- rect
.top
))));
6431 if (!FRAME_PARENT_FRAME (f
))
6432 my_set_window_pos (FRAME_W32_WINDOW (f
), NULL
,
6434 rect
.right
- rect
.left
,
6435 rect
.bottom
- rect
.top
,
6436 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6438 my_set_window_pos (FRAME_W32_WINDOW (f
), HWND_TOP
,
6440 rect
.right
- rect
.left
,
6441 rect
.bottom
- rect
.top
,
6442 SWP_NOMOVE
| SWP_NOACTIVATE
);
6444 change_frame_size (f
,
6446 ? 0 : FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
)),
6448 ? 0 : FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
)),
6450 SET_FRAME_GARBAGED (f
);
6452 /* If cursor was outside the new size, mark it as off. */
6453 mark_window_cursors_off (XWINDOW (f
->root_window
));
6455 /* Clear out any recollection of where the mouse highlighting was,
6456 since it might be in a place that's outside the new frame size.
6457 Actually checking whether it is outside is a pain in the neck,
6458 so don't try--just let the highlighting be done afresh with new
6460 cancel_mouse_face (f
);
6465 do_pending_window_change (false);
6468 /* Mouse warping. */
6471 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
6480 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
6481 pt
.x
= rect
.left
+ pix_x
;
6482 pt
.y
= rect
.top
+ pix_y
;
6483 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
6485 /* When "mouse trails" are in effect, moving the mouse cursor
6486 sometimes leaves behind an annoying "ghost" of the pointer.
6487 Avoid that by momentarily switching off mouse trails. */
6488 if (os_subtype
== OS_NT
6489 && w32_major_version
+ w32_minor_version
>= 6)
6490 ret
= SystemParametersInfo (SPI_GETMOUSETRAILS
, 0, &trail_num
, 0);
6491 SetCursorPos (pt
.x
, pt
.y
);
6493 SystemParametersInfo (SPI_SETMOUSETRAILS
, trail_num
, NULL
, 0);
6499 /* Focus shifting, raising and lowering. */
6501 /* The NOACTIVATE argument has no effect on Windows. According to the
6502 Windows API: An application cannot activate an inactive window
6503 without also bringing it to the top of the Z order. */
6506 x_focus_frame (struct frame
*f
, bool noactivate
)
6509 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6512 /* Give input focus to frame. */
6515 /* Try not to change its Z-order if possible. */
6516 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
6517 my_set_focus (f
, FRAME_W32_WINDOW (f
));
6520 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6524 /* Raise frame F. */
6526 x_raise_frame (struct frame
*f
)
6530 /* Strictly speaking, raise-frame should only change the frame's Z
6531 order, leaving input focus unchanged. This is reasonable behavior
6532 on X where the usual policy is point-to-focus. However, this
6533 behavior would be very odd on Windows where the usual policy is
6536 On X, if the mouse happens to be over the raised frame, it gets
6537 input focus anyway (so the window with focus will never be
6538 completely obscured) - if not, then just moving the mouse over it
6539 is sufficient to give it focus. On Windows, the user must actually
6540 click on the frame (preferably the title bar so as not to move
6541 point), which is more awkward. Also, no other Windows program
6542 raises a window to the top but leaves another window (possibly now
6543 completely obscured) with input focus.
6545 Because there is a system setting on Windows that allows the user
6546 to choose the point to focus policy, we make the strict semantics
6547 optional, but by default we grab focus when raising. */
6549 if (NILP (Vw32_grab_focus_on_raise
))
6551 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6552 not already the foreground application: the frame is raised
6553 above all other frames belonging to us, but not above the
6554 current top window. To achieve that, we have to resort to this
6555 more cumbersome method. */
6557 HDWP handle
= BeginDeferWindowPos (2);
6560 handle
= DeferWindowPos (handle
,
6561 FRAME_W32_WINDOW (f
),
6564 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6567 handle
= DeferWindowPos (handle
,
6568 GetForegroundWindow (),
6569 FRAME_W32_WINDOW (f
),
6571 SWP_NOSIZE
| SWP_NOMOVE
|
6574 EndDeferWindowPos (handle
);
6580 my_bring_window_to_top (FRAME_W32_WINDOW (f
));
6586 /* Lower frame F. */
6588 x_lower_frame (struct frame
*f
)
6591 my_set_window_pos (FRAME_W32_WINDOW (f
),
6594 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6599 w32_frame_raise_lower (struct frame
*f
, bool raise_flag
)
6601 if (! FRAME_W32_P (f
))
6610 /* Change of visibility. */
6612 /* This tries to wait until the frame is really visible.
6613 However, if the window manager asks the user where to position
6614 the frame, this will return before the user finishes doing that.
6615 The frame will not actually be visible at that time,
6616 but it will become visible later when the window manager
6617 finishes with it. */
6620 x_make_frame_visible (struct frame
*f
)
6624 x_set_bitmap_icon (f
);
6626 if (! FRAME_VISIBLE_P (f
))
6628 /* We test FRAME_GARBAGED_P here to make sure we don't
6629 call x_set_offset a second time
6630 if we get to x_make_frame_visible a second time
6631 before the window gets really visible. */
6632 if (! FRAME_ICONIFIED_P (f
)
6633 && ! f
->output_data
.w32
->asked_for_visible
)
6635 if (!FRAME_PARENT_FRAME (f
))
6640 /* Adjust vertical window position in order to avoid being
6641 covered by a taskbar placed at the bottom of the desktop. */
6642 SystemParametersInfo (SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6643 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6644 if (window_rect
.bottom
> workarea_rect
.bottom
6645 && window_rect
.top
> workarea_rect
.top
)
6646 f
->top_pos
= max (window_rect
.top
6647 - window_rect
.bottom
+ workarea_rect
.bottom
,
6651 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6654 f
->output_data
.w32
->asked_for_visible
= 1;
6656 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
6657 causes unexpected behavior when unminimizing frames that were
6658 previously maximized. But only SW_SHOWNORMAL works properly for
6659 frames that were truely hidden (using make-frame-invisible), so
6660 we need it to avoid Bug#5482. It seems that iconified is only
6661 set for minimized windows that are still visible, so use that to
6662 determine the appropriate flag to pass ShowWindow. */
6663 my_show_window (f
, FRAME_W32_WINDOW (f
),
6664 FRAME_ICONIFIED_P (f
)
6666 : FRAME_NO_FOCUS_ON_MAP (f
)
6671 /* Synchronize to ensure Emacs knows the frame is visible
6672 before we do anything else. We do this loop with input not blocked
6673 so that incoming events are handled. */
6678 /* This must come after we set COUNT. */
6681 XSETFRAME (frame
, f
);
6683 /* Wait until the frame is visible. Process X events until a
6684 MapNotify event has been seen, or until we think we won't get a
6685 MapNotify at all.. */
6686 for (count
= input_signal_count
+ 10;
6687 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6689 /* Force processing of queued events. */
6690 /* TODO: x_sync equivalent? */
6692 /* Machines that do polling rather than SIGIO have been observed
6693 to go into a busy-wait here. So we'll fake an alarm signal
6694 to let the handler know that there's something to be read.
6695 We used to raise a real alarm, but it seems that the handler
6696 isn't always enabled here. This is probably a bug. */
6697 if (input_polling_used ())
6699 /* It could be confusing if a real alarm arrives while processing
6700 the fake one. Turn it off and let the handler reset it. */
6701 int old_poll_suppress_count
= poll_suppress_count
;
6702 poll_suppress_count
= 1;
6703 poll_for_input_1 ();
6704 poll_suppress_count
= old_poll_suppress_count
;
6710 /* Change from mapped state to withdrawn state. */
6712 /* Make the frame visible (mapped and not iconified). */
6715 x_make_frame_invisible (struct frame
*f
)
6717 /* Don't keep the highlight on an invisible frame. */
6718 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6719 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6723 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6725 /* We can't distinguish this from iconification
6726 just by the event that we get from the server.
6727 So we can't win using the usual strategy of letting
6728 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6729 and synchronize with the server to make sure we agree. */
6730 SET_FRAME_VISIBLE (f
, 0);
6731 SET_FRAME_ICONIFIED (f
, false);
6736 /* Change window state from mapped to iconified. */
6739 x_iconify_frame (struct frame
*f
)
6741 /* Don't keep the highlight on an invisible frame. */
6742 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6743 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6745 if (FRAME_ICONIFIED_P (f
))
6750 x_set_bitmap_icon (f
);
6752 /* Simulate the user minimizing the frame. */
6753 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0,
6756 SET_FRAME_VISIBLE (f
, 0);
6757 SET_FRAME_ICONIFIED (f
, true);
6763 /* Free X resources of frame F. */
6766 x_free_frame_resources (struct frame
*f
)
6768 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6769 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
6773 /* We must free faces before destroying windows because some
6774 font-driver (e.g. xft) access a window while finishing a
6776 free_frame_faces (f
);
6778 if (FRAME_W32_WINDOW (f
))
6779 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6781 free_frame_menubar (f
);
6783 xfree (f
->output_data
.w32
);
6784 f
->output_data
.w32
= NULL
;
6786 if (f
== dpyinfo
->w32_focus_frame
)
6787 dpyinfo
->w32_focus_frame
= 0;
6788 if (f
== dpyinfo
->w32_focus_event_frame
)
6789 dpyinfo
->w32_focus_event_frame
= 0;
6790 if (f
== dpyinfo
->x_highlight_frame
)
6791 dpyinfo
->x_highlight_frame
= 0;
6792 if (f
== hlinfo
->mouse_face_mouse_frame
)
6793 reset_mouse_highlight (hlinfo
);
6799 /* Destroy the window of frame F. */
6801 x_destroy_window (struct frame
*f
)
6803 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6805 x_free_frame_resources (f
);
6806 dpyinfo
->reference_count
--;
6810 /* Setting window manager hints. */
6812 /* Set the normal size hints for the window manager, for frame F.
6813 FLAGS is the flags word to use--or 0 meaning preserve the flags
6814 that the window now has.
6815 If USER_POSITION, set the USPosition
6816 flag (this is useful when FLAGS is 0). */
6818 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
6820 Window window
= FRAME_W32_WINDOW (f
);
6824 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6825 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6826 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6827 SetWindowLong (window
, WND_VSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_WIDTH (f
));
6828 SetWindowLong (window
, WND_HSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_HEIGHT (f
));
6833 /***********************************************************************
6835 ***********************************************************************/
6839 /* Check that FONT is valid on frame F. It is if it can be found in F's
6843 x_check_font (struct frame
*f
, struct font
*font
)
6845 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
6846 if (font
->driver
->check
)
6847 eassert (font
->driver
->check (f
, font
) == 0);
6850 #endif /* GLYPH_DEBUG */
6852 /* Show hourglass cursor on frame F. */
6855 w32_show_hourglass (struct frame
*f
)
6857 if (!menubar_in_use
&& !current_popup_menu
)
6859 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6861 w32
->hourglass_p
= 1;
6862 SetCursor (w32
->hourglass_cursor
);
6866 /* Hide hourglass cursor on frame F. */
6869 w32_hide_hourglass (struct frame
*f
)
6871 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6873 w32
->hourglass_p
= 0;
6874 if (f
->pointer_invisible
)
6877 SetCursor (w32
->current_cursor
);
6880 /* FIXME: old code did that, but I don't know why. Anyway,
6881 this is used for non-GUI frames (see cancel_hourglass). */
6884 w32_arrow_cursor (void)
6886 SetCursor (w32_load_cursor (IDC_ARROW
));
6890 w32_toggle_invisible_pointer (struct frame
*f
, bool invisible
)
6894 if (f
->pointer_invisible
!= invisible
)
6896 f
->pointer_invisible
= invisible
;
6897 w32_define_cursor (FRAME_W32_WINDOW (f
),
6898 f
->output_data
.w32
->current_cursor
);
6904 /***********************************************************************
6906 ***********************************************************************/
6908 static int w32_initialized
= 0;
6911 w32_initialize_display_info (Lisp_Object display_name
)
6913 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6915 memset (dpyinfo
, 0, sizeof (*dpyinfo
));
6917 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
6918 dpyinfo
->w32_id_name
= xmalloc (SCHARS (Vinvocation_name
)
6919 + SCHARS (Vsystem_name
) + 2);
6920 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6921 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6923 /* Default Console mode values - overridden when running in GUI mode
6924 with values obtained from system metrics. */
6927 dpyinfo
->n_planes
= 1;
6928 dpyinfo
->n_cbits
= 4;
6929 dpyinfo
->n_fonts
= 0;
6930 dpyinfo
->smallest_font_height
= 1;
6931 dpyinfo
->smallest_char_width
= 1;
6932 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6933 dpyinfo
->horizontal_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6934 /* TODO: dpyinfo->gray */
6936 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
6939 /* Create an xrdb-style database of resources to supersede registry settings.
6940 The database is just a concatenation of C strings, finished by an additional
6941 \0. The strings are submitted to some basic normalization, so
6943 [ *]option[ *]:[ *]value...
6949 but any whitespace following value is not removed. */
6952 w32_make_rdb (char *xrm_option
)
6954 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6955 char *current
= buffer
;
6958 int before_value
= 0;
6972 if (in_option
&& (ch
== ':'))
6977 else if (before_value
)
6982 else if (!(in_option
|| before_value
))
6993 extern frame_parm_handler w32_frame_parm_handlers
[];
6995 static struct redisplay_interface w32_redisplay_interface
=
6997 w32_frame_parm_handlers
,
7001 x_clear_end_of_line
,
7003 x_after_update_window_line
,
7004 x_update_window_begin
,
7005 x_update_window_end
,
7006 0, /* flush_display */
7007 x_clear_window_mouse_face
,
7008 x_get_glyph_overhangs
,
7009 x_fix_overlapping_area
,
7010 w32_draw_fringe_bitmap
,
7011 w32_define_fringe_bitmap
,
7012 w32_destroy_fringe_bitmap
,
7013 w32_compute_glyph_string_overhangs
,
7014 x_draw_glyph_string
,
7015 w32_define_frame_cursor
,
7016 w32_clear_frame_area
,
7017 w32_draw_window_cursor
,
7018 w32_draw_vertical_window_border
,
7019 w32_draw_window_divider
,
7020 w32_shift_glyphs_for_insert
,
7025 static void x_delete_terminal (struct terminal
*term
);
7027 static struct terminal
*
7028 w32_create_terminal (struct w32_display_info
*dpyinfo
)
7030 struct terminal
*terminal
;
7032 terminal
= create_terminal (output_w32
, &w32_redisplay_interface
);
7034 terminal
->display_info
.w32
= dpyinfo
;
7035 dpyinfo
->terminal
= terminal
;
7037 /* MSVC does not type K&R functions with no arguments correctly, and
7038 so we must explicitly cast them. */
7039 terminal
->clear_frame_hook
= x_clear_frame
;
7040 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
7041 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
7042 terminal
->ring_bell_hook
= w32_ring_bell
;
7043 terminal
->toggle_invisible_pointer_hook
= w32_toggle_invisible_pointer
;
7044 terminal
->update_begin_hook
= x_update_begin
;
7045 terminal
->update_end_hook
= x_update_end
;
7046 terminal
->read_socket_hook
= w32_read_socket
;
7047 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
7048 terminal
->mouse_position_hook
= w32_mouse_position
;
7049 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
7050 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
7051 terminal
->fullscreen_hook
= w32fullscreen_hook
;
7052 terminal
->menu_show_hook
= w32_menu_show
;
7053 terminal
->popup_dialog_hook
= w32_popup_dialog
;
7054 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
7055 terminal
->set_horizontal_scroll_bar_hook
= w32_set_horizontal_scroll_bar
;
7056 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
7057 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
7058 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
7059 terminal
->delete_frame_hook
= x_destroy_window
;
7060 terminal
->delete_terminal_hook
= x_delete_terminal
;
7061 /* Other hooks are NULL by default. */
7063 /* We don't yet support separate terminals on W32, so don't try to share
7064 keyboards between virtual terminals that are on the same physical
7065 terminal like X does. */
7066 terminal
->kboard
= allocate_kboard (Qw32
);
7067 /* Don't let the initial kboard remain current longer than necessary.
7068 That would cause problems if a file loaded on startup tries to
7069 prompt in the mini-buffer. */
7070 if (current_kboard
== initial_kboard
)
7071 current_kboard
= terminal
->kboard
;
7072 terminal
->kboard
->reference_count
++;
7078 x_delete_terminal (struct terminal
*terminal
)
7080 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
7082 /* Protect against recursive calls. delete_frame in
7083 delete_terminal calls us back when it deletes our last frame. */
7084 if (!terminal
->name
)
7089 x_delete_display (dpyinfo
);
7093 struct w32_display_info
*
7094 w32_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
7096 struct w32_display_info
*dpyinfo
;
7097 struct terminal
*terminal
;
7102 if (!w32_initialized
)
7105 w32_initialized
= 1;
7108 w32_initialize_display_info (display_name
);
7110 dpyinfo
= &one_w32_display_info
;
7111 terminal
= w32_create_terminal (dpyinfo
);
7113 /* Set the name of the terminal. */
7114 terminal
->name
= xlispstrdup (display_name
);
7116 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
7118 /* Put this display on the chain. */
7119 dpyinfo
->next
= x_display_list
;
7120 x_display_list
= dpyinfo
;
7124 dpyinfo
->root_window
= GetDesktopWindow ();
7125 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
7126 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
7127 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
7128 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
7129 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
7130 ReleaseDC (NULL
, hdc
);
7132 /* initialize palette with white and black */
7135 w32_defined_color (0, "white", &color
, 1);
7136 w32_defined_color (0, "black", &color
, 1);
7140 /* Add the default keyboard. When !WINDOWSNT, we're using the
7141 standard Emacs console handling machinery and don't need an
7142 explicit FD here. */
7143 add_keyboard_wait_descriptor (0);
7145 /* /dev/windows wakes us up when we have a thread message pending. */
7146 add_keyboard_wait_descriptor (w32_message_fd
);
7149 /* Create Fringe Bitmaps and store them for later use.
7151 On W32, bitmaps are all unsigned short, as Windows requires
7152 bitmap data to be Word aligned. For some reason they are
7153 horizontally reflected compared to how they appear on X, so we
7154 need to bitswap and convert to unsigned shorts before creating
7156 w32_init_fringe (terminal
->rif
);
7163 /* Get rid of display DPYINFO, assuming all frames are already gone. */
7165 x_delete_display (struct w32_display_info
*dpyinfo
)
7167 /* FIXME: the only display info apparently can't be deleted. */
7168 /* free palette table */
7170 struct w32_palette_entry
* plist
;
7172 plist
= dpyinfo
->color_list
;
7175 struct w32_palette_entry
* pentry
= plist
;
7176 plist
= plist
->next
;
7179 dpyinfo
->color_list
= NULL
;
7180 if (dpyinfo
->palette
)
7181 DeleteObject (dpyinfo
->palette
);
7183 w32_reset_fringes ();
7187 /* Set up use of W32. */
7190 w32_init_main_thread (void)
7192 dwMainThreadId
= GetCurrentThreadId ();
7193 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
7194 GetCurrentProcess (), &hMainThread
, 0, TRUE
,
7195 DUPLICATE_SAME_ACCESS
);
7200 DWORD WINAPI
w32_msg_worker (void * arg
);
7203 w32_initialize (void)
7206 HRESULT (WINAPI
* set_user_model
) (const wchar_t * id
);
7210 w32_system_caret_hwnd
= NULL
;
7211 w32_system_caret_height
= 0;
7212 w32_system_caret_x
= 0;
7213 w32_system_caret_y
= 0;
7215 /* On Windows 7 and later, we need to set the user model ID
7216 to associate emacsclient launched files with Emacs frames
7218 shell
= GetModuleHandle ("shell32.dll");
7222 = (void *) GetProcAddress (shell
,
7223 "SetCurrentProcessExplicitAppUserModelID");
7225 /* If the function is defined, then we are running on Windows 7
7226 or newer, and the UI uses this to group related windows
7227 together. Since emacs, runemacs, emacsclient are related, we
7228 want them grouped even though the executables are different,
7229 so we need to set a consistent ID between them. */
7231 set_user_model (L
"GNU.Emacs");
7235 if ((w32_message_fd
= emacs_open ("/dev/windows", O_RDWR
, 0)) == -1)
7236 fatal ("opening /dev/windows: %s", strerror (errno
));
7239 /* Initialize w32_use_visible_system_caret based on whether a screen
7240 reader is in use. */
7241 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
7242 &w32_use_visible_system_caret
, 0))
7243 w32_use_visible_system_caret
= 0;
7245 any_help_event_p
= 0;
7247 /* Initialize input mode: interrupt_input off, no flow control, allow
7248 8 bit character input, standard quit char. */
7249 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
7252 LCID input_locale_id
= LOWORD (GetKeyboardLayout (0));
7253 w32_keyboard_codepage
= codepage_for_locale (input_locale_id
);
7256 /* Create the window thread - it will terminate itself when the app
7260 /* Wait for thread to start */
7264 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
7266 hWindowsThread
= CreateThread (NULL
, 0,
7268 0, 0, &dwWindowsThreadId
);
7270 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
7273 /* It is desirable that mainThread should have the same notion of
7274 focus window and active window as windowsThread. Unfortunately, the
7275 following call to AttachThreadInput, which should do precisely what
7276 we need, causes major problems when Emacs is linked as a console
7277 program. Unfortunately, we have good reasons for doing that, so
7278 instead we need to send messages to windowsThread to make some API
7279 calls for us (ones that affect, or depend on, the active/focus
7281 #ifdef ATTACH_THREADS
7282 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
7285 /* Dynamically link to optional system components. */
7287 HMODULE user_lib
= GetModuleHandle ("user32.dll");
7289 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7291 LOAD_PROC (user_lib
, SetLayeredWindowAttributes
);
7295 /* Ensure scrollbar handles are at least 5 pixels. */
7296 vertical_scroll_bar_min_handle
= 5;
7297 horizontal_scroll_bar_min_handle
= 5;
7299 /* For either kind of scroll bar, take account of the arrows; these
7300 effectively form the border of the main scroll bar range. */
7301 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
7302 = GetSystemMetrics (SM_CYVSCROLL
);
7303 horizontal_scroll_bar_left_border
= horizontal_scroll_bar_right_border
7304 = GetSystemMetrics (SM_CYHSCROLL
);
7309 syms_of_w32term (void)
7311 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
7313 DEFSYM (Qadded
, "added");
7314 DEFSYM (Qremoved
, "removed");
7315 DEFSYM (Qmodified
, "modified");
7316 DEFSYM (Qrenamed_from
, "renamed-from");
7317 DEFSYM (Qrenamed_to
, "renamed-to");
7319 DEFVAR_INT ("w32-num-mouse-buttons",
7320 w32_num_mouse_buttons
,
7321 doc
: /* Number of physical mouse buttons. */);
7322 w32_num_mouse_buttons
= 2;
7324 DEFVAR_LISP ("w32-swap-mouse-buttons",
7325 Vw32_swap_mouse_buttons
,
7326 doc
: /* Swap the mapping of middle and right mouse buttons.
7327 When nil, middle button is mouse-2 and right button is mouse-3. */);
7328 Vw32_swap_mouse_buttons
= Qnil
;
7330 DEFVAR_LISP ("w32-grab-focus-on-raise",
7331 Vw32_grab_focus_on_raise
,
7332 doc
: /* Raised frame grabs input focus.
7333 When t, `raise-frame' grabs input focus as well. This fits well
7334 with the normal Windows click-to-focus policy, but might not be
7335 desirable when using a point-to-focus policy. */);
7336 Vw32_grab_focus_on_raise
= Qt
;
7338 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7339 Vw32_capslock_is_shiftlock
,
7340 doc
: /* Apply CapsLock state to non character input keys.
7341 When nil, CapsLock only affects normal character input keys. */);
7342 Vw32_capslock_is_shiftlock
= Qnil
;
7344 DEFVAR_LISP ("w32-recognize-altgr",
7345 Vw32_recognize_altgr
,
7346 doc
: /* Recognize right-alt and left-ctrl as AltGr.
7347 When nil, the right-alt and left-ctrl key combination is
7348 interpreted normally. */);
7349 Vw32_recognize_altgr
= Qt
;
7351 DEFVAR_BOOL ("w32-use-visible-system-caret",
7352 w32_use_visible_system_caret
,
7353 doc
: /* Flag to make the system caret visible.
7354 When this is non-nil, Emacs will indicate the position of point by
7355 using the system caret instead of drawing its own cursor. Some screen
7356 reader software does not track the system cursor properly when it is
7357 invisible, and gets confused by Emacs drawing its own cursor, so this
7358 variable is initialized to t when Emacs detects that screen reader
7359 software is running as it starts up.
7361 When this variable is set, other variables affecting the appearance of
7362 the cursor have no effect. */);
7364 w32_use_visible_system_caret
= 0;
7366 /* We don't yet support this, but defining this here avoids whining
7367 from cus-start.el and other places, like "M-x set-variable". */
7368 DEFVAR_BOOL ("x-use-underline-position-properties",
7369 x_use_underline_position_properties
,
7370 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
7371 A value of nil means ignore them. If you encounter fonts with bogus
7372 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7373 to 4.1, set this to nil. You can also use `underline-minimum-offset'
7374 to override the font's UNDERLINE_POSITION for small font display
7376 x_use_underline_position_properties
= 0;
7378 DEFVAR_BOOL ("x-underline-at-descent-line",
7379 x_underline_at_descent_line
,
7380 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
7381 A value of nil means to draw the underline according to the value of the
7382 variable `x-use-underline-position-properties', which is usually at the
7383 baseline level. The default value is nil. */);
7384 x_underline_at_descent_line
= 0;
7386 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
7387 doc
: /* Which toolkit scroll bars Emacs uses, if any.
7388 A value of nil means Emacs doesn't use toolkit scroll bars.
7389 With the X Window system, the value is a symbol describing the
7390 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
7391 With MS Windows or Nextstep, the value is t. */);
7392 Vx_toolkit_scroll_bars
= Qt
;
7394 DEFVAR_BOOL ("w32-unicode-filenames",
7395 w32_unicode_filenames
,
7396 doc
: /* Non-nil means use Unicode APIs when passing file names to the OS.
7397 A value of nil means file names passed to the OS APIs and returned
7398 from those APIs are encoded/decoded using the ANSI codepage
7399 specified by `file-name-coding-system'.
7401 This variable is set to non-nil by default when Emacs runs on Windows
7402 systems of the NT family, including W2K, XP, Vista, Windows 7 and
7403 Windows 8. It is set to nil on Windows 9X. */);
7404 if (os_subtype
== OS_9X
)
7405 w32_unicode_filenames
= 0;
7407 w32_unicode_filenames
= 1;
7410 /* FIXME: The following variable will be (hopefully) removed
7411 before Emacs 25.1 gets released. */
7413 DEFVAR_BOOL ("w32-add-wrapped-menu-bar-lines",
7414 w32_add_wrapped_menu_bar_lines
,
7415 doc
: /* Non-nil means frame resizing accounts for wrapped menu bar lines.
7416 A value of nil means frame resizing does not add the height of wrapped
7417 menu bar lines when sending a frame resize request to the Windows API.
7418 This usually means that the resulting frame height is off by the number
7419 of wrapped menu bar lines. If this is non-nil, Emacs adds the height of
7420 wrapped menu bar lines when sending frame resize requests to the Windows
7422 w32_add_wrapped_menu_bar_lines
= 1;
7424 /* Tell Emacs about this window system. */
7425 Fprovide (Qw32
, Qnil
);