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 xgcv
.font
= NULL
; /* avoid compiler warnings */
1649 if (relief
->gc
== 0)
1651 #if 0 /* TODO: stipple */
1652 xgcv
.stipple
= dpyinfo
->gray
;
1655 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1658 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1662 /* Set up colors for the relief lines around glyph string S. */
1665 x_setup_relief_colors (struct glyph_string
*s
)
1667 struct w32_output
*di
= s
->f
->output_data
.w32
;
1670 if (s
->face
->use_box_color_for_shadows_p
)
1671 color
= s
->face
->box_color
;
1672 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1674 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1675 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1677 color
= s
->gc
->background
;
1679 if (di
->white_relief
.gc
== 0
1680 || color
!= di
->relief_background
)
1682 di
->relief_background
= color
;
1683 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1684 WHITE_PIX_DEFAULT (s
->f
));
1685 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1686 BLACK_PIX_DEFAULT (s
->f
));
1691 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1692 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1693 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1694 relief. LEFT_P non-zero means draw a relief on the left side of
1695 the rectangle. RIGHT_P non-zero means draw a relief on the right
1696 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1700 w32_draw_relief_rect (struct frame
*f
,
1701 int left_x
, int top_y
, int right_x
, int bottom_y
,
1702 int width
, int raised_p
,
1703 int top_p
, int bot_p
, int left_p
, int right_p
,
1708 HDC hdc
= get_frame_dc (f
);
1711 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1713 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1715 w32_set_clip_rectangle (hdc
, clip_rect
);
1719 for (i
= 0; i
< width
; ++i
)
1720 w32_fill_area (f
, hdc
, gc
.foreground
,
1721 left_x
+ i
* left_p
, top_y
+ i
,
1722 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1726 for (i
= 0; i
< width
; ++i
)
1727 w32_fill_area (f
, hdc
, gc
.foreground
,
1728 left_x
+ i
, top_y
+ (i
+ 1) * top_p
, 1,
1729 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1732 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1734 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1738 for (i
= 0; i
< width
; ++i
)
1739 w32_fill_area (f
, hdc
, gc
.foreground
,
1740 left_x
+ i
* left_p
, bottom_y
- i
,
1741 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1745 for (i
= 0; i
< width
; ++i
)
1746 w32_fill_area (f
, hdc
, gc
.foreground
,
1747 right_x
- i
, top_y
+ (i
+ 1) * top_p
, 1,
1748 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1750 w32_set_clip_rectangle (hdc
, NULL
);
1752 release_frame_dc (f
, hdc
);
1756 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1757 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1758 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1759 left side of the rectangle. RIGHT_P non-zero means draw a line
1760 on the right side of the rectangle. CLIP_RECT is the clipping
1761 rectangle to use when drawing. */
1764 w32_draw_box_rect (struct glyph_string
*s
,
1765 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1766 bool left_p
, bool right_p
, RECT
*clip_rect
)
1768 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1771 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1772 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1777 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1778 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1782 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1783 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1788 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1789 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1792 w32_set_clip_rectangle (s
->hdc
, NULL
);
1796 /* Draw a box around glyph string S. */
1799 x_draw_glyph_string_box (struct glyph_string
*s
)
1801 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
;
1802 bool left_p
, right_p
, raised_p
;
1803 struct glyph
*last_glyph
;
1806 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1807 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1808 : window_box_right (s
->w
, s
->area
));
1810 /* The glyph that may have a right box line. */
1811 last_glyph
= (s
->cmp
|| s
->img
1813 : s
->first_glyph
+ s
->nchars
- 1);
1815 width
= eabs (s
->face
->box_line_width
);
1816 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1818 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1820 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1822 bottom_y
= top_y
+ s
->height
- 1;
1824 left_p
= (s
->first_glyph
->left_box_line_p
1825 || (s
->hl
== DRAW_MOUSE_FACE
1827 || s
->prev
->hl
!= s
->hl
)));
1828 right_p
= (last_glyph
->right_box_line_p
1829 || (s
->hl
== DRAW_MOUSE_FACE
1831 || s
->next
->hl
!= s
->hl
)));
1833 get_glyph_string_clip_rect (s
, &clip_rect
);
1835 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1836 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1837 left_p
, right_p
, &clip_rect
);
1840 x_setup_relief_colors (s
);
1841 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1842 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1847 /* Draw foreground of image glyph string S. */
1850 x_draw_image_foreground (struct glyph_string
*s
)
1853 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1855 /* If first glyph of S has a left box line, start drawing it to the
1856 right of that line. */
1857 if (s
->face
->box
!= FACE_NO_BOX
1858 && s
->first_glyph
->left_box_line_p
1860 x
+= eabs (s
->face
->box_line_width
);
1862 /* If there is a margin around the image, adjust x- and y-position
1864 if (s
->slice
.x
== 0)
1865 x
+= s
->img
->hmargin
;
1866 if (s
->slice
.y
== 0)
1867 y
+= s
->img
->vmargin
;
1873 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
1874 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1875 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
1876 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1877 SetBkColor (compat_hdc
, RGB (255, 255, 255));
1878 SetTextColor (s
->hdc
, RGB (0, 0, 0));
1879 x_set_glyph_string_clipping (s
);
1883 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
1884 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1886 SetTextColor (s
->hdc
, RGB (255, 255, 255));
1887 SetBkColor (s
->hdc
, RGB (0, 0, 0));
1889 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1890 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1891 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1892 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1893 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1894 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1896 SelectObject (mask_dc
, mask_orig_obj
);
1901 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1902 SetBkColor (s
->hdc
, s
->gc
->background
);
1904 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1905 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1907 /* When the image has a mask, we can expect that at
1908 least part of a mouse highlight or a block cursor will
1909 be visible. If the image doesn't have a mask, make
1910 a block cursor visible by drawing a rectangle around
1911 the image. I believe it's looking better if we do
1912 nothing here for mouse-face. */
1913 if (s
->hl
== DRAW_CURSOR
)
1915 int r
= s
->img
->relief
;
1917 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
1918 s
->slice
.width
+ r
*2 - 1,
1919 s
->slice
.height
+ r
*2 - 1);
1923 w32_set_clip_rectangle (s
->hdc
, NULL
);
1924 SelectObject (s
->hdc
, orig_brush
);
1925 DeleteObject (fg_brush
);
1926 SelectObject (compat_hdc
, orig_obj
);
1927 DeleteDC (compat_hdc
);
1930 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
1931 s
->slice
.width
- 1, s
->slice
.height
- 1);
1933 RestoreDC (s
->hdc
,-1);
1937 /* Draw a relief around the image glyph string S. */
1940 x_draw_image_relief (struct glyph_string
*s
)
1942 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
1943 int extra_x
, extra_y
;
1946 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1948 /* If first glyph of S has a left box line, start drawing it to the
1949 right of that line. */
1950 if (s
->face
->box
!= FACE_NO_BOX
1951 && s
->first_glyph
->left_box_line_p
1953 x
+= eabs (s
->face
->box_line_width
);
1955 /* If there is a margin around the image, adjust x- and y-position
1957 if (s
->slice
.x
== 0)
1958 x
+= s
->img
->hmargin
;
1959 if (s
->slice
.y
== 0)
1960 y
+= s
->img
->vmargin
;
1962 if (s
->hl
== DRAW_IMAGE_SUNKEN
1963 || s
->hl
== DRAW_IMAGE_RAISED
)
1965 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
1966 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
1967 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
1971 thick
= eabs (s
->img
->relief
);
1972 raised_p
= s
->img
->relief
> 0;
1975 x1
= x
+ s
->slice
.width
- 1;
1976 y1
= y
+ s
->slice
.height
- 1;
1978 extra_x
= extra_y
= 0;
1979 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
1981 if (CONSP (Vtool_bar_button_margin
)
1982 && INTEGERP (XCAR (Vtool_bar_button_margin
))
1983 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
1985 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
1986 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
1988 else if (INTEGERP (Vtool_bar_button_margin
))
1989 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
1992 top_p
= bot_p
= left_p
= right_p
= 0;
1994 if (s
->slice
.x
== 0)
1995 x
-= thick
+ extra_x
, left_p
= 1;
1996 if (s
->slice
.y
== 0)
1997 y
-= thick
+ extra_y
, top_p
= 1;
1998 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
1999 x1
+= thick
+ extra_x
, right_p
= 1;
2000 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
2001 y1
+= thick
+ extra_y
, bot_p
= 1;
2003 x_setup_relief_colors (s
);
2004 get_glyph_string_clip_rect (s
, &r
);
2005 w32_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
2006 top_p
, bot_p
, left_p
, right_p
, &r
);
2010 /* Draw the foreground of image glyph string S to PIXMAP. */
2013 w32_draw_image_foreground_1 (struct glyph_string
*s
, HBITMAP pixmap
)
2015 HDC hdc
= CreateCompatibleDC (s
->hdc
);
2016 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
2018 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2020 /* If first glyph of S has a left box line, start drawing it to the
2021 right of that line. */
2022 if (s
->face
->box
!= FACE_NO_BOX
2023 && s
->first_glyph
->left_box_line_p
2025 x
+= eabs (s
->face
->box_line_width
);
2027 /* If there is a margin around the image, adjust x- and y-position
2029 if (s
->slice
.x
== 0)
2030 x
+= s
->img
->hmargin
;
2031 if (s
->slice
.y
== 0)
2032 y
+= s
->img
->vmargin
;
2036 HDC compat_hdc
= CreateCompatibleDC (hdc
);
2037 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2038 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
2039 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2043 HDC mask_dc
= CreateCompatibleDC (hdc
);
2044 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2046 SetTextColor (hdc
, RGB (0, 0, 0));
2047 SetBkColor (hdc
, RGB (255, 255, 255));
2048 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2049 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2050 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2051 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2052 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2053 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2055 SelectObject (mask_dc
, mask_orig_obj
);
2060 SetTextColor (hdc
, s
->gc
->foreground
);
2061 SetBkColor (hdc
, s
->gc
->background
);
2063 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2064 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2066 /* When the image has a mask, we can expect that at
2067 least part of a mouse highlight or a block cursor will
2068 be visible. If the image doesn't have a mask, make
2069 a block cursor visible by drawing a rectangle around
2070 the image. I believe it's looking better if we do
2071 nothing here for mouse-face. */
2072 if (s
->hl
== DRAW_CURSOR
)
2074 int r
= s
->img
->relief
;
2076 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2077 s
->slice
.width
+ r
*2 - 1,
2078 s
->slice
.height
+ r
*2 - 1);
2082 SelectObject (hdc
, orig_brush
);
2083 DeleteObject (fg_brush
);
2084 SelectObject (compat_hdc
, orig_obj
);
2085 DeleteDC (compat_hdc
);
2088 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2089 s
->slice
.width
- 1, s
->slice
.height
- 1);
2091 SelectObject (hdc
, orig_hdc_obj
);
2096 /* Draw part of the background of glyph string S. X, Y, W, and H
2097 give the rectangle to draw. */
2100 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2102 #if 0 /* TODO: stipple */
2105 /* Fill background with a stipple pattern. */
2106 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2107 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), s
->gc
, x
, y
, w
, h
);
2108 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2112 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2116 /* Draw image glyph string S.
2119 s->x +-------------------------
2122 | +-------------------------
2125 | | +-------------------
2131 x_draw_image_glyph_string (struct glyph_string
*s
)
2134 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2135 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2140 if (s
->slice
.y
== 0)
2141 height
-= box_line_vwidth
;
2142 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2143 height
-= box_line_vwidth
;
2145 /* Fill background with face under the image. Do it only if row is
2146 taller than image or if image has a clip mask to reduce
2148 s
->stippled_p
= s
->face
->stipple
!= 0;
2149 if (height
> s
->slice
.height
2153 || s
->img
->pixmap
== 0
2154 || s
->width
!= s
->background_width
)
2156 width
= s
->background_width
;
2158 if (s
->first_glyph
->left_box_line_p
2161 x
+= box_line_hwidth
;
2162 width
-= box_line_hwidth
;
2166 if (s
->slice
.y
== 0)
2167 y
+= box_line_vwidth
;
2169 #if 0 /* TODO: figure out if we need to do this on Windows. */
2172 /* Create a pixmap as large as the glyph string. Fill it
2173 with the background color. Copy the image to it, using
2174 its mask. Copy the temporary pixmap to the display. */
2175 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2176 int depth
= DefaultDepthOfScreen (screen
);
2178 /* Create a pixmap as large as the glyph string. */
2179 pixmap
= XCreatePixmap (s
->display
, FRAME_W32_WINDOW (s
->f
),
2180 s
->background_width
,
2183 /* Don't clip in the following because we're working on the
2185 XSetClipMask (s
->display
, s
->gc
, None
);
2187 /* Fill the pixmap with the background color/stipple. */
2190 /* Fill background with a stipple pattern. */
2191 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2192 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2193 0, 0, s
->background_width
, s
->height
);
2194 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2199 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2201 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2202 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2203 0, 0, s
->background_width
, s
->height
);
2204 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2209 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
2211 s
->background_filled_p
= true;
2214 /* Draw the foreground. */
2217 w32_draw_image_foreground_1 (s
, pixmap
);
2218 x_set_glyph_string_clipping (s
);
2220 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2221 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2222 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2223 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2225 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2226 SetBkColor (s
->hdc
, s
->gc
->background
);
2227 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2228 compat_hdc
, 0, 0, SRCCOPY
);
2230 SelectObject (s
->hdc
, orig_brush
);
2231 DeleteObject (fg_brush
);
2232 SelectObject (compat_hdc
, orig_obj
);
2233 DeleteDC (compat_hdc
);
2235 DeleteObject (pixmap
);
2239 x_draw_image_foreground (s
);
2241 /* If we must draw a relief around the image, do it. */
2243 || s
->hl
== DRAW_IMAGE_RAISED
2244 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2245 x_draw_image_relief (s
);
2249 /* Draw stretch glyph string S. */
2252 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2254 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2256 if (s
->hl
== DRAW_CURSOR
2257 && !x_stretch_cursor_p
)
2259 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2260 wide as the stretch glyph. */
2261 int width
, background_width
= s
->background_width
;
2264 if (!s
->row
->reversed_p
)
2266 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2270 background_width
-= left_x
- x
;
2276 /* In R2L rows, draw the cursor on the right edge of the
2278 int right_x
= window_box_right (s
->w
, TEXT_AREA
);
2280 if (x
+ background_width
> right_x
)
2281 background_width
-= x
- right_x
;
2282 x
+= background_width
;
2284 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2285 if (s
->row
->reversed_p
)
2289 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2291 /* Clear rest using the GC of the original non-cursor face. */
2292 if (width
< background_width
)
2294 XGCValues
*gc
= s
->face
->gc
;
2296 int w
= background_width
- width
, h
= s
->height
;
2300 if (!s
->row
->reversed_p
)
2304 if (s
->row
->mouse_face_p
2305 && cursor_in_mouse_face_p (s
->w
))
2307 x_set_mouse_face_gc (s
);
2313 get_glyph_string_clip_rect (s
, &r
);
2314 w32_set_clip_rectangle (hdc
, &r
);
2316 #if 0 /* TODO: stipple */
2317 if (s
->face
->stipple
)
2319 /* Fill background with a stipple pattern. */
2320 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2321 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), gc
, x
, y
, w
, h
);
2322 XSetFillStyle (s
->display
, gc
, FillSolid
);
2327 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2331 else if (!s
->background_filled_p
)
2333 int background_width
= s
->background_width
;
2334 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2336 /* Don't draw into left margin, fringe or scrollbar area
2337 except for header line and mode line. */
2338 if (x
< left_x
&& !s
->row
->mode_line_p
)
2340 background_width
-= left_x
- x
;
2343 if (background_width
> 0)
2344 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2347 s
->background_filled_p
= true;
2351 /* Draw glyph string S. */
2354 x_draw_glyph_string (struct glyph_string
*s
)
2356 bool relief_drawn_p
= 0;
2358 /* If S draws into the background of its successor, draw the
2359 background of the successor first so that S can draw into it.
2360 This makes S->next use XDrawString instead of XDrawImageString. */
2361 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2364 struct glyph_string
*next
;
2365 for (width
= 0, next
= s
->next
;
2366 next
&& width
< s
->right_overhang
;
2367 width
+= next
->width
, next
= next
->next
)
2368 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2370 x_set_glyph_string_gc (next
);
2371 x_set_glyph_string_clipping (next
);
2372 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2373 x_draw_stretch_glyph_string (next
);
2375 x_draw_glyph_string_background (next
, true);
2376 next
->num_clips
= 0;
2380 /* Set up S->gc, set clipping and draw S. */
2381 x_set_glyph_string_gc (s
);
2383 /* Draw relief (if any) in advance for char/composition so that the
2384 glyph string can be drawn over it. */
2385 if (!s
->for_overlaps
2386 && s
->face
->box
!= FACE_NO_BOX
2387 && (s
->first_glyph
->type
== CHAR_GLYPH
2388 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2391 x_set_glyph_string_clipping (s
);
2392 x_draw_glyph_string_background (s
, true);
2393 x_draw_glyph_string_box (s
);
2394 x_set_glyph_string_clipping (s
);
2397 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2399 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2400 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2401 /* We must clip just this glyph. left_overhang part has already
2402 drawn when s->prev was drawn, and right_overhang part will be
2403 drawn later when s->next is drawn. */
2404 x_set_glyph_string_clipping_exactly (s
, s
);
2406 x_set_glyph_string_clipping (s
);
2408 switch (s
->first_glyph
->type
)
2411 x_draw_image_glyph_string (s
);
2415 x_draw_stretch_glyph_string (s
);
2419 if (s
->for_overlaps
)
2420 s
->background_filled_p
= true;
2422 x_draw_glyph_string_background (s
, false);
2423 x_draw_glyph_string_foreground (s
);
2426 case COMPOSITE_GLYPH
:
2427 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2428 && ! s
->first_glyph
->u
.cmp
.automatic
))
2429 s
->background_filled_p
= true;
2431 x_draw_glyph_string_background (s
, true);
2432 x_draw_composite_glyph_string_foreground (s
);
2435 case GLYPHLESS_GLYPH
:
2436 if (s
->for_overlaps
)
2437 s
->background_filled_p
= true;
2439 x_draw_glyph_string_background (s
, false);
2440 x_draw_glyphless_glyph_string_foreground (s
);
2447 if (!s
->for_overlaps
)
2449 /* Draw underline. */
2450 if (s
->face
->underline_p
)
2452 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2456 if (s
->face
->underline_defaulted_p
)
2457 color
= s
->gc
->foreground
;
2459 color
= s
->face
->underline_color
;
2461 w32_draw_underwave (s
, color
);
2463 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2465 unsigned long thickness
, position
;
2468 if (s
->prev
&& s
->prev
->face
->underline_p
2469 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2471 /* We use the same underline style as the previous one. */
2472 thickness
= s
->prev
->underline_thickness
;
2473 position
= s
->prev
->underline_position
;
2477 struct font
*font
= font_for_underline_metrics (s
);
2479 /* Get the underline thickness. Default is 1 pixel. */
2480 if (font
&& font
->underline_thickness
> 0)
2481 thickness
= font
->underline_thickness
;
2484 if (x_underline_at_descent_line
|| !font
)
2485 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2488 /* Get the underline position. This is the recommended
2489 vertical offset in pixels from the baseline to the top of
2490 the underline. This is a signed value according to the
2491 specs, and its default is
2493 ROUND ((maximum_descent) / 2), with
2494 ROUND (x) = floor (x + 0.5) */
2496 if (x_use_underline_position_properties
2497 && font
->underline_position
>= 0)
2498 position
= font
->underline_position
;
2500 position
= (font
->descent
+ 1) / 2;
2502 position
= max (position
, underline_minimum_offset
);
2504 /* Check the sanity of thickness and position. We should
2505 avoid drawing underline out of the current line area. */
2506 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2507 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2508 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2509 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2510 s
->underline_thickness
= thickness
;
2511 s
->underline_position
= position
;
2512 y
= s
->ybase
+ position
;
2513 if (s
->face
->underline_defaulted_p
)
2515 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2520 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2525 /* Draw overline. */
2526 if (s
->face
->overline_p
)
2528 unsigned long dy
= 0, h
= 1;
2530 if (s
->face
->overline_color_defaulted_p
)
2532 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2533 s
->y
+ dy
, s
->width
, h
);
2537 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2538 s
->y
+ dy
, s
->width
, h
);
2542 /* Draw strike-through. */
2543 if (s
->face
->strike_through_p
2544 && !FONT_TEXTMETRIC (s
->font
).tmStruckOut
)
2546 /* Y-coordinate and height of the glyph string's first
2547 glyph. We cannot use s->y and s->height because those
2548 could be larger if there are taller display elements
2549 (e.g., characters displayed with a larger font) in the
2551 int glyph_y
= s
->ybase
- s
->first_glyph
->ascent
;
2552 int glyph_height
= s
->first_glyph
->ascent
+ s
->first_glyph
->descent
;
2553 /* Strike-through width and offset from the glyph string's
2555 unsigned long h
= 1;
2556 unsigned long dy
= (glyph_height
- h
) / 2;
2558 if (s
->face
->strike_through_color_defaulted_p
)
2560 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2561 glyph_y
+ dy
, s
->width
, h
);
2565 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2566 glyph_y
+ dy
, s
->width
, h
);
2570 /* Draw relief if not yet drawn. */
2571 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2572 x_draw_glyph_string_box (s
);
2576 struct glyph_string
*prev
;
2578 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2579 if (prev
->hl
!= s
->hl
2580 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2582 /* As prev was drawn while clipped to its own area, we
2583 must draw the right_overhang part using s->hl now. */
2584 enum draw_glyphs_face save
= prev
->hl
;
2587 x_set_glyph_string_gc (prev
);
2588 x_set_glyph_string_clipping_exactly (s
, prev
);
2589 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2590 x_draw_glyph_string_foreground (prev
);
2592 x_draw_composite_glyph_string_foreground (prev
);
2593 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2595 prev
->num_clips
= 0;
2601 struct glyph_string
*next
;
2603 for (next
= s
->next
; next
; next
= next
->next
)
2604 if (next
->hl
!= s
->hl
2605 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2607 /* As next will be drawn while clipped to its own area,
2608 we must draw the left_overhang part using s->hl now. */
2609 enum draw_glyphs_face save
= next
->hl
;
2612 x_set_glyph_string_gc (next
);
2613 x_set_glyph_string_clipping_exactly (s
, next
);
2614 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2615 x_draw_glyph_string_foreground (next
);
2617 x_draw_composite_glyph_string_foreground (next
);
2618 w32_set_clip_rectangle (next
->hdc
, NULL
);
2620 next
->num_clips
= 0;
2621 next
->clip_head
= s
->next
;
2626 /* Reset clipping. */
2627 w32_set_clip_rectangle (s
->hdc
, NULL
);
2632 /* Shift display to make room for inserted glyphs. */
2635 w32_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
,
2636 int width
, int height
, int shift_by
)
2640 hdc
= get_frame_dc (f
);
2641 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2642 hdc
, x
, y
, SRCCOPY
);
2644 release_frame_dc (f
, hdc
);
2648 /* Delete N glyphs at the nominal cursor position. Not implemented
2652 x_delete_glyphs (struct frame
*f
, register int n
)
2654 if (! FRAME_W32_P (f
))
2661 /* Clear entire frame. */
2664 x_clear_frame (struct frame
*f
)
2666 if (! FRAME_W32_P (f
))
2669 /* Clearing the frame will erase any cursor, so mark them all as no
2671 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2675 w32_clear_window (f
);
2677 /* We have to clear the scroll bars, too. If we have changed
2678 colors or something like that, then they should be notified. */
2679 x_scroll_bar_clear (f
);
2685 /* Make audible bell. */
2688 w32_ring_bell (struct frame
*f
)
2692 if (FRAME_W32_P (f
) && visible_bell
)
2695 HWND hwnd
= FRAME_W32_WINDOW (f
);
2697 for (i
= 0; i
< 5; i
++)
2699 FlashWindow (hwnd
, TRUE
);
2702 FlashWindow (hwnd
, FALSE
);
2705 w32_sys_ring_bell (f
);
2710 /***********************************************************************
2712 ***********************************************************************/
2714 /* Perform an insert-lines or delete-lines operation, inserting N
2715 lines or deleting -N lines at vertical position VPOS. */
2718 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
2720 if (! FRAME_W32_P (f
))
2727 /* Scroll part of the display as described by RUN. */
2730 x_scroll_run (struct window
*w
, struct run
*run
)
2732 struct frame
*f
= XFRAME (w
->frame
);
2733 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2734 HWND hwnd
= FRAME_W32_WINDOW (f
);
2737 /* Get frame-relative bounding box of the text display area of W,
2738 without mode lines. Include in this box the left and right
2740 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
2742 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2743 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2744 bottom_y
= y
+ height
;
2748 /* Scrolling up. Make sure we don't copy part of the mode
2749 line at the bottom. */
2750 if (from_y
+ run
->height
> bottom_y
)
2751 height
= bottom_y
- from_y
;
2753 height
= run
->height
;
2754 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2758 /* Scrolling down. Make sure we don't copy over the mode line.
2760 if (to_y
+ run
->height
> bottom_y
)
2761 height
= bottom_y
- to_y
;
2763 height
= run
->height
;
2764 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2769 /* Cursor off. Will be switched on again in x_update_window_end. */
2775 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2776 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2778 from
.left
= to
.left
= x
;
2779 from
.right
= to
.right
= x
+ width
;
2781 from
.bottom
= from_y
+ height
;
2783 to
.bottom
= bottom_y
;
2785 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2786 NULL
, SW_INVALIDATE
);
2788 /* Combine this with what we expect to be dirty. This covers the
2789 case where not all of the region we expect is actually dirty. */
2790 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2792 /* If the dirty region is not what we expected, redraw the entire frame. */
2793 if (!EqualRgn (combined
, expect_dirty
))
2794 SET_FRAME_GARBAGED (f
);
2796 DeleteObject (dirty
);
2797 DeleteObject (combined
);
2801 DeleteObject (expect_dirty
);
2806 /***********************************************************************
2808 ***********************************************************************/
2811 frame_highlight (struct frame
*f
)
2813 x_update_cursor (f
, 1);
2814 x_set_frame_alpha (f
);
2818 frame_unhighlight (struct frame
*f
)
2820 x_update_cursor (f
, 1);
2821 x_set_frame_alpha (f
);
2824 /* The focus has changed. Update the frames as necessary to reflect
2825 the new situation. Note that we can't change the selected frame
2826 here, because the Lisp code we are interrupting might become confused.
2827 Each event gets marked with the frame in which it occurred, so the
2828 Lisp code can tell when the switch took place by examining the events. */
2831 x_new_focus_frame (struct w32_display_info
*dpyinfo
, struct frame
*frame
)
2833 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2835 if (frame
!= dpyinfo
->w32_focus_frame
)
2837 /* Set this before calling other routines, so that they see
2838 the correct value of w32_focus_frame. */
2839 dpyinfo
->w32_focus_frame
= frame
;
2841 if (old_focus
&& old_focus
->auto_lower
)
2842 x_lower_frame (old_focus
);
2844 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2845 dpyinfo
->w32_pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2847 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
2850 x_frame_rehighlight (dpyinfo
);
2854 /* Handle FocusIn and FocusOut state changes for FRAME.
2855 If FRAME has focus and there exists more than one frame, puts
2856 a FOCUS_IN_EVENT into *BUFP. */
2859 x_focus_changed (int type
, int state
, struct w32_display_info
*dpyinfo
,
2860 struct frame
*frame
, struct input_event
*bufp
)
2862 if (type
== WM_SETFOCUS
)
2864 if (dpyinfo
->w32_focus_event_frame
!= frame
)
2866 x_new_focus_frame (dpyinfo
, frame
);
2867 dpyinfo
->w32_focus_event_frame
= frame
;
2869 /* Don't stop displaying the initial startup message
2870 for a switch-frame event we don't need. */
2871 if (NILP (Vterminal_frame
)
2872 && CONSP (Vframe_list
)
2873 && !NILP (XCDR (Vframe_list
)))
2882 bufp
->kind
= FOCUS_IN_EVENT
;
2883 XSETFRAME (bufp
->frame_or_window
, frame
);
2886 frame
->output_data
.x
->focus_state
|= state
;
2888 /* TODO: IME focus? */
2890 else if (type
== WM_KILLFOCUS
)
2892 frame
->output_data
.x
->focus_state
&= ~state
;
2894 if (dpyinfo
->w32_focus_event_frame
== frame
)
2896 dpyinfo
->w32_focus_event_frame
= 0;
2897 x_new_focus_frame (dpyinfo
, 0);
2899 bufp
->kind
= FOCUS_OUT_EVENT
;
2900 XSETFRAME (bufp
->frame_or_window
, frame
);
2903 /* TODO: IME focus? */
2908 /* The focus may have changed. Figure out if it is a real focus change,
2909 by checking both FocusIn/Out and Enter/LeaveNotify events.
2911 Returns FOCUS_IN_EVENT event in *BUFP. */
2914 w32_detect_focus_change (struct w32_display_info
*dpyinfo
, W32Msg
*event
,
2915 struct input_event
*bufp
)
2917 struct frame
*frame
;
2919 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
2923 /* On w32, this is only called from focus events, so no switch needed. */
2924 x_focus_changed (event
->msg
.message
,
2925 (event
->msg
.message
== WM_KILLFOCUS
?
2926 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
2927 dpyinfo
, frame
, bufp
);
2932 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2935 x_mouse_leave (struct w32_display_info
*dpyinfo
)
2937 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2941 /* The focus has changed, or we have redirected a frame's focus to
2942 another frame (this happens when a frame uses a surrogate
2943 mini-buffer frame). Shift the highlight as appropriate.
2945 The FRAME argument doesn't necessarily have anything to do with which
2946 frame is being highlighted or un-highlighted; we only use it to find
2947 the appropriate X display info. */
2950 w32_frame_rehighlight (struct frame
*frame
)
2952 if (! FRAME_W32_P (frame
))
2954 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
2958 x_frame_rehighlight (struct w32_display_info
*dpyinfo
)
2960 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2962 if (dpyinfo
->w32_focus_frame
)
2964 dpyinfo
->x_highlight_frame
2965 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2966 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2967 : dpyinfo
->w32_focus_frame
);
2968 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
2970 fset_focus_frame (dpyinfo
->w32_focus_frame
, Qnil
);
2971 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
2975 dpyinfo
->x_highlight_frame
= 0;
2977 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
2980 frame_unhighlight (old_highlight
);
2981 if (dpyinfo
->x_highlight_frame
)
2982 frame_highlight (dpyinfo
->x_highlight_frame
);
2986 /* Keyboard processing - modifier keys, etc. */
2988 /* Convert a keysym to its name. */
2991 x_get_keysym_name (int keysym
)
2993 /* Make static so we can always return it */
2994 static char value
[100];
2997 GetKeyNameText (keysym
, value
, 100);
3004 codepage_for_locale (LCID locale
)
3008 if (GetLocaleInfo (locale
, LOCALE_IDEFAULTANSICODEPAGE
, cp
, 20) > 0)
3015 /* Mouse clicks and mouse movement. Rah. */
3017 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
3018 the state in PUP. XBUTTON provides extra information for extended mouse
3019 button messages. Returns FALSE if unable to parse the message. */
3021 parse_button (int message
, int xbutton
, int * pbutton
, int * pup
)
3028 case WM_LBUTTONDOWN
:
3036 case WM_MBUTTONDOWN
:
3037 if (NILP (Vw32_swap_mouse_buttons
))
3044 if (NILP (Vw32_swap_mouse_buttons
))
3050 case WM_RBUTTONDOWN
:
3051 if (NILP (Vw32_swap_mouse_buttons
))
3058 if (NILP (Vw32_swap_mouse_buttons
))
3064 case WM_XBUTTONDOWN
:
3065 button
= xbutton
+ 2;
3069 button
= xbutton
+ 2;
3077 if (pbutton
) *pbutton
= button
;
3083 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3085 If the event is a button press, then note that we have grabbed
3089 construct_mouse_click (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3094 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3097 /* Make the event type NO_EVENT; we'll change that when we decide
3099 result
->kind
= MOUSE_CLICK_EVENT
;
3100 result
->code
= button
;
3101 result
->timestamp
= msg
->msg
.time
;
3102 result
->modifiers
= (msg
->dwModifiers
3107 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3108 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3109 XSETFRAME (result
->frame_or_window
, f
);
3115 construct_mouse_wheel (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3120 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3123 result
->timestamp
= msg
->msg
.time
;
3125 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3126 forward, away from the user (up); a negative value indicates that
3127 the wheel was rotated backward, toward the user (down). */
3128 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3130 /* The up and down modifiers indicate if the wheel was rotated up or
3131 down based on WHEEL_DELTA value. */
3132 result
->modifiers
= (msg
->dwModifiers
3133 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3135 /* With multiple monitors, we can legitimately get negative
3136 coordinates, so cast to short to interpret them correctly. */
3137 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3138 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3139 /* For the case that F's w32 window is not msg->msg.hwnd. */
3140 ScreenToClient (FRAME_W32_WINDOW (f
), &p
);
3141 XSETINT (result
->x
, p
.x
);
3142 XSETINT (result
->y
, p
.y
);
3143 XSETFRAME (result
->frame_or_window
, f
);
3149 construct_drag_n_drop (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3156 wchar_t name_w
[MAX_PATH
];
3157 #ifdef NTGUI_UNICODE
3158 const int use_unicode
= 1;
3160 int use_unicode
= w32_unicode_filenames
;
3161 char name_a
[MAX_PATH
];
3162 char file
[MAX_UTF8_PATH
];
3166 result
->kind
= DRAG_N_DROP_EVENT
;
3168 result
->timestamp
= msg
->msg
.time
;
3169 result
->modifiers
= msg
->dwModifiers
;
3171 hdrop
= (HDROP
) msg
->msg
.wParam
;
3172 DragQueryPoint (hdrop
, &p
);
3175 p
.x
= LOWORD (msg
->msg
.lParam
);
3176 p
.y
= HIWORD (msg
->msg
.lParam
);
3177 ScreenToClient (msg
->msg
.hwnd
, &p
);
3180 XSETINT (result
->x
, p
.x
);
3181 XSETINT (result
->y
, p
.y
);
3183 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3186 for (i
= 0; i
< num_files
; i
++)
3190 eassert (DragQueryFileW (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3191 /* If DragQueryFile returns zero, it failed to fetch a file
3193 if (DragQueryFileW (hdrop
, i
, name_w
, MAX_PATH
) == 0)
3195 #ifdef NTGUI_UNICODE
3196 files
= Fcons (from_unicode_buffer (name_w
), files
);
3198 filename_from_utf16 (name_w
, file
);
3199 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3200 #endif /* NTGUI_UNICODE */
3202 #ifndef NTGUI_UNICODE
3205 eassert (DragQueryFileA (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3206 if (DragQueryFileA (hdrop
, i
, name_a
, MAX_PATH
) == 0)
3208 filename_from_ansi (name_a
, file
);
3209 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3216 XSETFRAME (frame
, f
);
3217 result
->frame_or_window
= frame
;
3218 result
->arg
= files
;
3225 /* File event notifications (see w32notify.c). */
3228 lispy_file_action (DWORD action
)
3230 static char unknown_fmt
[] = "unknown-action(%d)";
3235 case FILE_ACTION_ADDED
:
3238 case FILE_ACTION_REMOVED
:
3241 case FILE_ACTION_MODIFIED
:
3244 case FILE_ACTION_RENAMED_OLD_NAME
:
3245 retval
= Qrenamed_from
;
3247 case FILE_ACTION_RENAMED_NEW_NAME
:
3248 retval
= Qrenamed_to
;
3252 char buf
[sizeof(unknown_fmt
) - 1 + INT_STRLEN_BOUND (DWORD
)];
3254 sprintf (buf
, unknown_fmt
, action
);
3255 retval
= intern (buf
);
3264 /* Put file notifications into the Emacs input event queue. This
3265 function runs when the WM_EMACS_FILENOTIFY message arrives from a
3268 queue_notifications (struct input_event
*event
, W32Msg
*msg
, struct frame
*f
,
3271 struct notifications_set
*ns
= NULL
;
3275 /* We cannot process notification before Emacs is fully initialized,
3276 since we need the UTF-16LE coding-system to be set up. */
3280 XSETFRAME (frame
, f
);
3286 /* Find out if there is a record available in the linked list of
3287 notifications sets. If so, unlink the set from the linked
3288 list. Use critical section. */
3290 if (notifications_set_head
->next
!= notifications_set_head
)
3292 ns
= notifications_set_head
->next
;
3293 ns
->prev
->next
= ns
->next
;
3294 ns
->next
->prev
= ns
->prev
;
3302 BYTE
*p
= ns
->notifications
;
3303 FILE_NOTIFY_INFORMATION
*fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3304 const DWORD min_size
3305 = offsetof (FILE_NOTIFY_INFORMATION
, FileName
) + sizeof(wchar_t);
3306 DWORD info_size
= ns
->size
;
3307 Lisp_Object cs
= Qutf_16le
;
3308 Lisp_Object obj
= w32_get_watch_object (ns
->desc
);
3310 /* notifications size could be zero when the buffer of
3311 notifications overflowed on the OS level, or when the
3312 directory being watched was itself deleted. Do nothing in
3315 && !NILP (obj
) && CONSP (obj
))
3317 Lisp_Object callback
= XCDR (obj
);
3319 while (info_size
>= min_size
)
3321 Lisp_Object utf_16_fn
3322 = make_unibyte_string ((char *)fni
->FileName
,
3323 fni
->FileNameLength
);
3324 /* Note: mule-conf is preloaded, so utf-16le must
3325 already be defined at this point. */
3327 = code_convert_string_norecord (utf_16_fn
, cs
, 0);
3328 Lisp_Object action
= lispy_file_action (fni
->Action
);
3330 event
->kind
= FILE_NOTIFY_EVENT
;
3331 event
->timestamp
= msg
->msg
.time
;
3332 event
->modifiers
= 0;
3333 event
->frame_or_window
= callback
;
3334 event
->arg
= list3 (make_pointer_integer (ns
->desc
),
3336 kbd_buffer_store_event (event
);
3338 if (!fni
->NextEntryOffset
)
3340 p
+= fni
->NextEntryOffset
;
3341 fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3342 info_size
-= fni
->NextEntryOffset
;
3345 /* Free this notifications set. */
3346 xfree (ns
->notifications
);
3350 /* We've stuffed all the events ourselves, so w32_read_socket shouldn't. */
3351 event
->kind
= NO_EVENT
;
3353 #endif /* WINDOWSNT */
3354 #endif /* HAVE_W32NOTIFY */
3357 /* Function to report a mouse movement to the mainstream Emacs code.
3358 The input handler calls this.
3360 We have received a mouse movement event, which is given in *event.
3361 If the mouse is over a different glyph than it was last time, tell
3362 the mainstream emacs code by setting mouse_moved. If not, ask for
3363 another motion event, so we can check again the next time it moves. */
3366 note_mouse_movement (struct frame
*frame
, MSG
*msg
)
3368 struct w32_display_info
*dpyinfo
;
3369 int mouse_x
= LOWORD (msg
->lParam
);
3370 int mouse_y
= HIWORD (msg
->lParam
);
3373 if (!FRAME_X_OUTPUT (frame
))
3376 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
3377 dpyinfo
->last_mouse_movement_time
= msg
->time
;
3378 dpyinfo
->last_mouse_motion_frame
= frame
;
3379 dpyinfo
->last_mouse_motion_x
= mouse_x
;
3380 dpyinfo
->last_mouse_motion_y
= mouse_y
;
3382 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3384 frame
->mouse_moved
= true;
3385 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3386 note_mouse_highlight (frame
, -1, -1);
3387 dpyinfo
->last_mouse_glyph_frame
= NULL
;
3391 /* Has the mouse moved off the glyph it was on at the last sighting? */
3392 r
= &dpyinfo
->last_mouse_glyph
;
3393 if (frame
!= dpyinfo
->last_mouse_glyph_frame
3394 || mouse_x
< r
->left
|| mouse_x
>= r
->right
3395 || mouse_y
< r
->top
|| mouse_y
>= r
->bottom
)
3397 frame
->mouse_moved
= true;
3398 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3399 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3400 /* Remember the mouse position here, as w32_mouse_position only
3401 gets called when mouse tracking is enabled but we also need
3402 to keep track of the mouse for help_echo and highlighting at
3404 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, r
);
3405 dpyinfo
->last_mouse_glyph_frame
= frame
;
3413 /************************************************************************
3415 ************************************************************************/
3417 static struct scroll_bar
*x_window_to_scroll_bar (Window
, int);
3418 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3419 enum scroll_bar_part
*,
3420 Lisp_Object
*, Lisp_Object
*,
3422 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3423 enum scroll_bar_part
*,
3424 Lisp_Object
*, Lisp_Object
*,
3427 w32_define_cursor (Window window
, Cursor cursor
)
3429 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3432 /* Return the current position of the mouse.
3433 *fp should be a frame which indicates which display to ask about.
3435 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3436 and *part to the frame, window, and scroll bar part that the mouse
3437 is over. Set *x and *y to the portion and whole of the mouse's
3438 position on the scroll bar.
3440 If the mouse movement started elsewhere, set *fp to the frame the
3441 mouse is on, *bar_window to nil, and *x and *y to the character cell
3444 Set *time to the server time-stamp for the time at which the mouse
3445 was at this position.
3447 Don't store anything if we don't have a valid set of values to report.
3449 This clears the mouse_moved flag, so we can wait for the next mouse
3453 w32_mouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
3454 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
3457 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
3461 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
3463 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
3465 if (bar
->horizontal
)
3466 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3468 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3473 Lisp_Object frame
, tail
;
3474 struct frame
*f1
= NULL
;
3476 /* Clear the mouse-moved flag for every frame on this display. */
3477 FOR_EACH_FRAME (tail
, frame
)
3478 XFRAME (frame
)->mouse_moved
= false;
3480 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3484 /* Now we have a position on the root; find the innermost window
3485 containing the pointer. */
3487 /* If mouse was grabbed on a frame, give coords for that
3488 frame even if the mouse is now outside it. Otherwise
3489 check for window under mouse on one of our frames. */
3490 if (x_mouse_grabbed (dpyinfo
))
3491 f1
= dpyinfo
->last_mouse_frame
;
3494 HWND wfp
= WindowFromPoint (pt
);
3498 f1
= x_any_window_to_frame (dpyinfo
, wfp
);
3501 HWND cwfp
= ChildWindowFromPoint (wfp
, pt
);
3505 struct frame
*f2
= x_any_window_to_frame (dpyinfo
, cwfp
);
3507 /* If a child window was found, make sure that its
3508 frame is a child frame (Bug#26615, maybe). */
3509 if (f2
&& FRAME_PARENT_FRAME (f2
))
3516 /* If not, is it one of our scroll bars? */
3519 struct scroll_bar
*bar
3520 = x_window_to_scroll_bar (WindowFromPoint (pt
), 2);
3523 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3526 if (f1
== 0 && insist
> 0)
3527 f1
= SELECTED_FRAME ();
3531 /* Ok, we found a frame. Store all the values.
3532 last_mouse_glyph is a rectangle used to reduce the
3533 generation of mouse events. To not miss any motion
3534 events, we must divide the frame into rectangles of the
3535 size of the smallest character that could be displayed
3536 on it, i.e. into the same rectangles that matrices on
3537 the frame are divided into. */
3539 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
3540 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3541 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &dpyinfo
->last_mouse_glyph
);
3542 dpyinfo
->last_mouse_glyph_frame
= f1
;
3545 *part
= scroll_bar_above_handle
;
3549 *time
= dpyinfo
->last_mouse_movement_time
;
3558 /***********************************************************************
3560 ***********************************************************************/
3562 /* Handle mouse button event on the tool-bar of frame F, at
3563 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
3564 or ButtonRelease. */
3567 w32_handle_tool_bar_click (struct frame
*f
, struct input_event
*button_event
)
3569 int x
= XFASTINT (button_event
->x
);
3570 int y
= XFASTINT (button_event
->y
);
3572 if (button_event
->modifiers
& down_modifier
)
3573 handle_tool_bar_click (f
, x
, y
, 1, 0);
3575 handle_tool_bar_click (f
, x
, y
, 0,
3576 button_event
->modifiers
& ~up_modifier
);
3581 /***********************************************************************
3583 ***********************************************************************/
3585 /* Scroll bar support. */
3587 /* Given a window ID, find the struct scroll_bar which manages it
3588 vertically. This can be called in GC, so we have to make sure to
3589 strip off mark bits. */
3591 static struct scroll_bar
*
3592 x_window_to_scroll_bar (Window window_id
, int type
)
3594 Lisp_Object tail
, frame
;
3596 FOR_EACH_FRAME (tail
, frame
)
3598 Lisp_Object bar
, condemned
;
3600 /* Scan this frame's scroll bar list for a scroll bar with the
3602 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3603 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3604 /* This trick allows us to search both the ordinary and
3605 condemned scroll bar lists with one loop. */
3606 ! NILP (bar
) || (bar
= condemned
,
3609 bar
= XSCROLL_BAR (bar
)->next
)
3610 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
3612 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
3613 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
3614 return XSCROLL_BAR (bar
);
3622 /* Set the thumb size and position of vertical scroll bar BAR. We are currently
3623 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3626 w32_set_scroll_bar_thumb (struct scroll_bar
*bar
,
3627 int portion
, int position
, int whole
)
3629 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3630 /* We use the whole scroll-bar height in the calculations below, to
3631 avoid strange effects like scrolling backwards when just clicking
3632 on the handle (without moving it). */
3633 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
)
3634 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3635 int sb_page
, sb_pos
;
3636 BOOL draggingp
= bar
->dragging
? TRUE
: FALSE
;
3639 /* We used to change the nPage setting while dragging the handle,
3640 but that had very strange effects (such as scrolling backwards
3641 while dragging downwards).
3643 Now, we don't change the nPage setting while dragging unless we
3644 get near to the end of the buffer, in which case we often have to
3645 resize the handle to "go all the way". */
3651 si
.cbSize
= sizeof (si
);
3652 si
.fMask
= SIF_POS
| SIF_PAGE
;
3653 GetScrollInfo (w
, SB_CTL
, &si
);
3654 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3662 /* Position scroll bar at rock bottom if the bottom of the
3663 buffer is visible. This avoids shrinking the thumb away
3664 to nothing if it is held at the bottom of the buffer. */
3665 if (position
+ portion
>= whole
&& !draggingp
)
3667 sb_page
= range
* (whole
- position
) / whole
;
3672 sb_pos
= position
* range
/ whole
;
3673 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3682 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3686 si
.cbSize
= sizeof (si
);
3687 si
.fMask
= SIF_PAGE
| SIF_POS
;
3691 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3696 /* Set the thumb size and position of horizontal scroll bar BAR. We are currently
3697 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3700 w32_set_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
3701 int portion
, int position
, int whole
)
3703 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3708 si
.cbSize
= sizeof (si
);
3709 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
3712 /* Allow nPage to be one larger than nPos so we don't allow the scrolling
3713 of an already fully visible buffer. */
3714 si
.nPage
= min (portion
, si
.nMax
) + 1;
3715 si
.nPos
= min (position
, si
.nMax
);
3716 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3722 /************************************************************************
3723 Scroll bars, general
3724 ************************************************************************/
3727 my_create_vscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3729 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3730 WM_EMACS_CREATEVSCROLLBAR
, (WPARAM
) f
,
3735 my_create_hscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3737 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3738 WM_EMACS_CREATEHSCROLLBAR
, (WPARAM
) f
,
3742 /*#define ATTACH_THREADS*/
3745 my_show_window (struct frame
*f
, HWND hwnd
, int how
)
3747 #ifndef ATTACH_THREADS
3748 return SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3749 (WPARAM
) hwnd
, (LPARAM
) how
, 0, 6000, NULL
);
3751 return ShowWindow (hwnd
, how
);
3756 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3757 int x
, int y
, int cx
, int cy
, UINT flags
)
3759 #ifndef ATTACH_THREADS
3761 pos
.hwndInsertAfter
= hwndAfter
;
3767 SendMessageTimeout (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0,
3770 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3776 my_set_focus (struct frame
* f
, HWND hwnd
)
3778 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3779 (WPARAM
) hwnd
, 0, 0, 6000, NULL
);
3784 my_set_foreground_window (HWND hwnd
)
3786 SendMessageTimeout (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0,
3792 my_destroy_window (struct frame
* f
, HWND hwnd
)
3794 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3795 (WPARAM
) hwnd
, 0, 0, 6000, NULL
);
3799 my_bring_window_to_top (HWND hwnd
)
3801 SendMessageTimeout (hwnd
, WM_EMACS_BRINGTOTOP
, (WPARAM
) hwnd
, 0,
3805 /* Create a scroll bar and return the scroll bar vector for it. W is
3806 the Emacs window on which to create the scroll bar. TOP, LEFT,
3807 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
3810 static struct scroll_bar
*
3811 x_scroll_bar_create (struct window
*w
, int left
, int top
, int width
, int height
, bool horizontal
)
3813 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3816 struct scroll_bar
*bar
3817 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, top
, PVEC_OTHER
);
3822 XSETWINDOW (bar
->window
, w
);
3826 bar
->height
= height
;
3830 bar
->horizontal
= horizontal
;
3832 /* Requires geometry to be set before call to create the real window */
3835 hwnd
= my_create_hscrollbar (f
, bar
);
3837 hwnd
= my_create_vscrollbar (f
, bar
);
3839 si
.cbSize
= sizeof (si
);
3843 si
.nMax
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
)
3844 + HORIZONTAL_SCROLL_BAR_MIN_HANDLE
;
3846 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3847 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3851 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3853 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3855 /* Add bar to its frame's list of scroll bars. */
3856 bar
->next
= FRAME_SCROLL_BARS (f
);
3858 XSETVECTOR (barobj
, bar
);
3859 fset_scroll_bars (f
, barobj
);
3860 if (! NILP (bar
->next
))
3861 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3869 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3873 x_scroll_bar_remove (struct scroll_bar
*bar
)
3875 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3879 /* Destroy the window. */
3880 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3882 /* Dissociate this scroll bar from its window. */
3883 if (bar
->horizontal
)
3884 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3886 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3891 /* Set the handle of the vertical scroll bar for WINDOW to indicate that
3892 we are displaying PORTION characters out of a total of WHOLE
3893 characters, starting at POSITION. If WINDOW has no vertical scroll
3896 w32_set_vertical_scroll_bar (struct window
*w
,
3897 int portion
, int whole
, int position
)
3899 struct frame
*f
= XFRAME (w
->frame
);
3901 struct scroll_bar
*bar
;
3902 int top
, height
, left
, width
;
3903 int window_y
, window_height
;
3905 /* Get window dimensions. */
3906 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
3908 height
= window_height
;
3910 /* Compute the left edge and the width of the scroll bar area. */
3911 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3912 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
3914 /* Does the scroll bar exist yet? */
3915 if (NILP (w
->vertical_scroll_bar
))
3919 if (width
> 0 && height
> 0)
3921 hdc
= get_frame_dc (f
);
3922 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3923 release_frame_dc (f
, hdc
);
3927 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, false);
3931 /* It may just need to be moved and resized. */
3934 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3935 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3937 /* If already correctly positioned, do nothing. */
3938 if (bar
->left
== left
3940 && bar
->width
== width
3941 && bar
->height
== height
)
3943 /* Redraw after clear_frame. */
3944 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3945 InvalidateRect (hwnd
, NULL
, FALSE
);
3953 if (width
&& height
)
3955 hdc
= get_frame_dc (f
);
3956 /* Since Windows scroll bars are smaller than the space reserved
3957 for them on the frame, we have to clear "under" them. */
3958 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3959 release_frame_dc (f
, hdc
);
3960 x_clear_under_internal_border (f
);
3962 /* Make sure scroll bar is "visible" before moving, to ensure the
3963 area of the parent window now exposed will be refreshed. */
3964 my_show_window (f
, hwnd
, SW_HIDE
);
3965 /** MoveWindow (hwnd, left, top, width, max (height, 1), TRUE); **/
3966 /* Try to not draw over child frames. */
3967 SetWindowPos (hwnd
, HWND_BOTTOM
, left
, top
, width
, max (height
, 1),
3970 si
.cbSize
= sizeof (si
);
3971 si
.fMask
= SIF_RANGE
;
3973 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3974 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3976 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3978 my_show_window (f
, hwnd
, SW_NORMAL
);
3979 /* InvalidateRect (w, NULL, FALSE); */
3981 /* Remember new settings. */
3985 bar
->height
= height
;
3990 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3991 XSETVECTOR (barobj
, bar
);
3992 wset_vertical_scroll_bar (w
, barobj
);
3995 /* Set the handle of the horizontal scroll bar for WINDOW to indicate
3996 that we are displaying PORTION characters out of a total of WHOLE
3997 characters, starting at POSITION. If WINDOW has no horizontal scroll
4000 w32_set_horizontal_scroll_bar (struct window
*w
,
4001 int portion
, int whole
, int position
)
4003 struct frame
*f
= XFRAME (w
->frame
);
4005 struct scroll_bar
*bar
;
4006 int top
, height
, left
, width
;
4007 int window_x
, window_width
;
4008 int clear_left
= WINDOW_LEFT_EDGE_X (w
);
4009 int clear_width
= WINDOW_PIXEL_WIDTH (w
) - WINDOW_RIGHT_DIVIDER_WIDTH (w
);
4011 /* Get window dimensions. */
4012 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
4014 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
4015 width
= window_width
;
4016 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
4018 /* Does the scroll bar exist yet? */
4019 if (NILP (w
->horizontal_scroll_bar
))
4023 if (width
> 0 && height
> 0)
4025 hdc
= get_frame_dc (f
);
4026 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
4027 release_frame_dc (f
, hdc
);
4031 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, true);
4035 /* It may just need to be moved and resized. */
4038 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
4039 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
4041 /* If already correctly positioned, do nothing. */
4042 if (bar
->left
== left
&& bar
->top
== top
4043 && bar
->width
== width
&& bar
->height
== height
)
4045 /* Redraw after clear_frame. */
4046 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
4047 InvalidateRect (hwnd
, NULL
, FALSE
);
4055 if (width
&& height
)
4057 hdc
= get_frame_dc (f
);
4058 /* Since Windows scroll bars are smaller than the space reserved
4059 for them on the frame, we have to clear "under" them. */
4060 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
4061 release_frame_dc (f
, hdc
);
4062 x_clear_under_internal_border (f
);
4064 /* Make sure scroll bar is "visible" before moving, to ensure the
4065 area of the parent window now exposed will be refreshed. */
4066 my_show_window (f
, hwnd
, SW_HIDE
);
4067 /** MoveWindow (hwnd, left, top, width, max (height, 1), TRUE); **/
4068 /* Try to not draw over child frames. */
4069 SetWindowPos (hwnd
, HWND_BOTTOM
, left
, top
, max (width
, 1), height
,
4072 /* +++ SetScrollInfo +++ */
4073 si
.cbSize
= sizeof (si
);
4074 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
4077 si
.nPage
= min (portion
, si
.nMax
) + 1;
4078 si
.nPos
= min (position
, si
.nMax
);
4079 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
4081 my_show_window (f
, hwnd
, SW_NORMAL
);
4082 /* InvalidateRect (w, NULL, FALSE); */
4084 /* Remember new settings. */
4088 bar
->height
= height
;
4094 w32_set_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
4095 XSETVECTOR (barobj
, bar
);
4096 wset_horizontal_scroll_bar (w
, barobj
);
4100 /* The following three hooks are used when we're doing a thorough
4101 redisplay of the frame. We don't explicitly know which scroll bars
4102 are going to be deleted, because keeping track of when windows go
4103 away is a real pain - "Can you say set-window-configuration, boys
4104 and girls?" Instead, we just assert at the beginning of redisplay
4105 that *all* scroll bars are to be removed, and then save a scroll bar
4106 from the fiery pit when we actually redisplay its window. */
4108 /* Arrange for all scroll bars on FRAME to be removed at the next call
4109 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
4110 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
4113 w32_condemn_scroll_bars (struct frame
*frame
)
4115 if (!NILP (FRAME_SCROLL_BARS (frame
)))
4117 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
4119 /* Prepend scrollbars to already condemned ones. */
4120 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
4122 while (!NILP (XSCROLL_BAR (last
)->next
))
4123 last
= XSCROLL_BAR (last
)->next
;
4125 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
4126 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
4129 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
4130 fset_scroll_bars (frame
, Qnil
);
4135 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
4136 Note that WINDOW isn't necessarily condemned at all. */
4139 w32_redeem_scroll_bar (struct window
*w
)
4141 struct scroll_bar
*bar
;
4145 /* We can't redeem this window's scroll bar if it doesn't have one. */
4146 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
4149 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4151 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4152 /* Unlink it from the condemned list. */
4153 f
= XFRAME (WINDOW_FRAME (w
));
4154 if (NILP (bar
->prev
))
4156 /* If the prev pointer is nil, it must be the first in one of
4158 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
4159 /* It's not condemned. Everything's fine. */
4161 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4162 w
->vertical_scroll_bar
))
4163 fset_condemned_scroll_bars (f
, bar
->next
);
4165 /* If its prev pointer is nil, it must be at the front of
4166 one or the other! */
4170 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4172 if (! NILP (bar
->next
))
4173 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4175 bar
->next
= FRAME_SCROLL_BARS (f
);
4177 XSETVECTOR (barobj
, bar
);
4178 fset_scroll_bars (f
, barobj
);
4179 if (! NILP (bar
->next
))
4180 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4184 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
4186 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
4187 /* Unlink it from the condemned list. */
4188 f
= XFRAME (WINDOW_FRAME (w
));
4189 if (NILP (bar
->prev
))
4191 /* If the prev pointer is nil, it must be the first in one of
4193 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
4194 /* It's not condemned. Everything's fine. */
4196 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4197 w
->horizontal_scroll_bar
))
4198 fset_condemned_scroll_bars (f
, bar
->next
);
4200 /* If its prev pointer is nil, it must be at the front of
4201 one or the other! */
4205 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4207 if (! NILP (bar
->next
))
4208 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4210 bar
->next
= FRAME_SCROLL_BARS (f
);
4212 XSETVECTOR (barobj
, bar
);
4213 fset_scroll_bars (f
, barobj
);
4214 if (! NILP (bar
->next
))
4215 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4219 /* Remove all scroll bars on FRAME that haven't been saved since the
4220 last call to `*condemn_scroll_bars_hook'. */
4223 w32_judge_scroll_bars (struct frame
*f
)
4225 Lisp_Object bar
, next
;
4227 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
4229 /* Clear out the condemned list now so we won't try to process any
4230 more events on the hapless scroll bars. */
4231 fset_condemned_scroll_bars (f
, Qnil
);
4233 for (; ! NILP (bar
); bar
= next
)
4235 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
4237 x_scroll_bar_remove (b
);
4240 b
->next
= b
->prev
= Qnil
;
4243 /* Now there should be no references to the condemned scroll bars,
4244 and they should get garbage-collected. */
4247 /* Handle a mouse click on the vertical scroll bar BAR. If
4248 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4251 This may be called from a signal handler, so we have to ignore GC
4255 w32_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4256 struct input_event
*emacs_event
)
4258 if (! WINDOWP (bar
->window
))
4261 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
4262 emacs_event
->code
= 0;
4263 /* not really meaningful to distinguish up/down */
4264 emacs_event
->modifiers
= msg
->dwModifiers
;
4265 emacs_event
->frame_or_window
= bar
->window
;
4266 emacs_event
->arg
= Qnil
;
4267 emacs_event
->timestamp
= msg
->msg
.time
;
4270 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4272 int dragging
= bar
->dragging
;
4274 int sb_event
= LOWORD (msg
->msg
.wParam
);
4276 si
.cbSize
= sizeof (si
);
4277 if (sb_event
== SB_THUMBTRACK
)
4278 si
.fMask
= SIF_TRACKPOS
;
4282 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4283 if (sb_event
== SB_THUMBTRACK
)
4289 struct frame
*f
; /* Value is not used. */
4290 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4295 emacs_event
->part
= scroll_bar_down_arrow
;
4298 emacs_event
->part
= scroll_bar_up_arrow
;
4301 emacs_event
->part
= scroll_bar_above_handle
;
4304 emacs_event
->part
= scroll_bar_below_handle
;
4307 emacs_event
->part
= scroll_bar_handle
;
4311 emacs_event
->part
= scroll_bar_handle
;
4315 case SB_THUMBPOSITION
:
4316 bar
->dragging
= 1; /* ??????? */
4317 emacs_event
->part
= scroll_bar_handle
;
4319 /* "Silently" update current position. */
4323 si
.cbSize
= sizeof (si
);
4326 /* Remember apparent position (we actually lag behind the real
4327 position, so don't set that directly). */
4328 last_scroll_bar_drag_pos
= y
;
4330 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4334 /* If this is the end of a drag sequence, then reset the scroll
4335 handle size to normal and do a final redraw. Otherwise do
4340 int start
= bar
->start
;
4343 si
.cbSize
= sizeof (si
);
4344 si
.fMask
= SIF_PAGE
| SIF_POS
;
4345 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4346 si
.nPos
= last_scroll_bar_drag_pos
;
4347 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4352 emacs_event
->kind
= NO_EVENT
;
4356 XSETINT (emacs_event
->x
, y
);
4357 XSETINT (emacs_event
->y
, top_range
);
4363 /* Handle a mouse click on the horizontal scroll bar BAR. If
4364 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4367 This may be called from a signal handler, so we have to ignore GC
4371 w32_horizontal_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4372 struct input_event
*emacs_event
)
4374 if (! WINDOWP (bar
->window
))
4377 emacs_event
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
4378 emacs_event
->code
= 0;
4379 /* not really meaningful to distinguish left/right */
4380 emacs_event
->modifiers
= msg
->dwModifiers
;
4381 emacs_event
->frame_or_window
= bar
->window
;
4382 emacs_event
->arg
= Qnil
;
4383 emacs_event
->timestamp
= msg
->msg
.time
;
4386 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4388 int dragging
= bar
->dragging
;
4390 int sb_event
= LOWORD (msg
->msg
.wParam
);
4392 si
.cbSize
= sizeof (si
);
4393 if (sb_event
== SB_THUMBTRACK
)
4394 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4396 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4398 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4399 if (sb_event
== SB_THUMBTRACK
)
4403 y
= si
.nMax
- si
.nPage
;
4406 struct frame
*f
; /* Value is not used. */
4407 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4412 emacs_event
->part
= scroll_bar_left_arrow
;
4415 emacs_event
->part
= scroll_bar_right_arrow
;
4418 emacs_event
->part
= scroll_bar_before_handle
;
4421 emacs_event
->part
= scroll_bar_after_handle
;
4424 emacs_event
->part
= scroll_bar_horizontal_handle
;
4428 emacs_event
->part
= scroll_bar_horizontal_handle
;
4432 case SB_THUMBPOSITION
:
4434 emacs_event
->part
= scroll_bar_horizontal_handle
;
4436 /* "Silently" update current position. */
4440 si
.cbSize
= sizeof (si
);
4442 si
.nPos
= min (x
, XWINDOW (bar
->window
)->hscroll_whole
- 1);
4443 /* Remember apparent position (we actually lag behind the real
4444 position, so don't set that directly). */
4445 last_scroll_bar_drag_pos
= x
;
4447 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4451 /* If this is the end of a drag sequence, then reset the scroll
4452 handle size to normal and do a final redraw. Otherwise do
4458 si
.cbSize
= sizeof (si
);
4460 si
.nPos
= min (last_scroll_bar_drag_pos
,
4461 XWINDOW (bar
->window
)->hscroll_whole
- 1);
4462 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4467 emacs_event
->kind
= NO_EVENT
;
4471 XSETINT (emacs_event
->x
, x
);
4472 XSETINT (emacs_event
->y
, y
);
4478 /* Return information to the user about the current position of the mouse
4479 on the vertical scroll bar. */
4481 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4482 enum scroll_bar_part
*part
,
4483 Lisp_Object
*x
, Lisp_Object
*y
,
4486 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4487 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4488 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4489 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4491 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4493 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4498 *bar_window
= bar
->window
;
4500 si
.cbSize
= sizeof (si
);
4501 if (sb_event
== SB_THUMBTRACK
)
4502 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4504 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4506 GetScrollInfo (w
, SB_CTL
, &si
);
4507 if (sb_event
== SB_THUMBTRACK
)
4511 top_range
= si
.nMax
- si
.nPage
+ 1;
4513 *part
= scroll_bar_handle
;
4514 if (sb_event
== SB_LINEDOWN
)
4518 XSETINT (*y
, top_range
);
4520 f
->mouse_moved
= false;
4521 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4523 *time
= dpyinfo
->last_mouse_movement_time
;
4528 /* Return information to the user about the current position of the mouse
4529 on the horizontal scroll bar. */
4531 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4532 enum scroll_bar_part
*part
,
4533 Lisp_Object
*x
, Lisp_Object
*y
,
4536 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4537 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4538 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4539 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4541 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4543 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4548 *bar_window
= bar
->window
;
4550 si
.cbSize
= sizeof (si
);
4551 if (sb_event
== SB_THUMBTRACK
)
4552 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4554 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4556 GetScrollInfo (w
, SB_CTL
, &si
);
4557 if (sb_event
== SB_THUMBTRACK
)
4561 left_range
= si
.nMax
- si
.nPage
+ 1;
4563 *part
= scroll_bar_handle
;
4564 if (sb_event
== SB_LINERIGHT
)
4569 XSETINT (*x
, left_range
);
4571 f
->mouse_moved
= false;
4572 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4574 *time
= dpyinfo
->last_mouse_movement_time
;
4580 /* The screen has been cleared so we may have changed foreground or
4581 background colors, and the scroll bars may need to be redrawn.
4582 Clear out the scroll bars, and ask for expose events, so we can
4586 x_scroll_bar_clear (struct frame
*f
)
4590 /* We can have scroll bars even if this is 0,
4591 if we just turned off scroll bar mode.
4592 But in that case we should not clear them. */
4593 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4594 || FRAME_HAS_HORIZONTAL_SCROLL_BARS (f
))
4595 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4596 bar
= XSCROLL_BAR (bar
)->next
)
4598 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4599 HDC hdc
= GetDC (window
);
4602 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4603 arranges to refresh the scroll bar if hidden. */
4604 my_show_window (f
, window
, SW_HIDE
);
4606 GetClientRect (window
, &rect
);
4607 select_palette (f
, hdc
);
4608 w32_clear_rect (f
, hdc
, &rect
);
4609 x_clear_under_internal_border (f
);
4610 deselect_palette (f
, hdc
);
4612 ReleaseDC (window
, hdc
);
4616 /* The main W32 event-reading loop - w32_read_socket. */
4618 /* Record the last 100 characters stored
4619 to help debug the loss-of-chars-during-GC problem. */
4621 static int temp_index
;
4622 static short temp_buffer
[100];
4624 /* Temporarily store lead byte of DBCS input sequences. */
4625 static char dbcs_lead
= 0;
4627 /* Read events coming from the W32 shell.
4628 This routine is called by the SIGIO handler.
4629 We return as soon as there are no more events to be read.
4631 For an overview of how Emacs input works on MS-Windows, see the
4632 commentary before w32_msg_pump in w32fns.c.
4634 We return the number of characters stored into the buffer,
4635 thus pretending to be `read'.
4637 Some of these messages are reposted back to the message queue since the
4638 system calls the windows proc directly in a context where we cannot return
4639 the data nor can we guarantee the state we are in. So if we dispatch them
4640 we will get into an infinite loop. To prevent this from ever happening we
4641 will set a variable to indicate we are in the read_socket call and indicate
4642 which message we are processing since the windows proc gets called
4643 recursively with different messages by the system.
4646 extern void menubar_selection_callback (struct frame
*, void *);
4649 w32_read_socket (struct terminal
*terminal
,
4650 struct input_event
*hold_quit
)
4653 int check_visibility
= 0;
4656 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4657 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
4661 /* So people can tell when we have read the available input. */
4662 input_signal_count
++;
4664 /* Process any incoming thread messages. */
4665 drain_message_queue ();
4667 /* TODO: ghostscript integration. */
4668 while (get_next_msg (&msg
, FALSE
))
4670 struct input_event inev
;
4673 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4674 /* w32_name_of_message (msg.msg.message), */
4675 /* msg.msg.time)); */
4678 inev
.kind
= NO_EVENT
;
4681 switch (msg
.msg
.message
)
4683 case WM_EMACS_PAINT
:
4684 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4688 if (msg
.rect
.right
== msg
.rect
.left
||
4689 msg
.rect
.bottom
== msg
.rect
.top
)
4691 /* We may get paint messages even though the client
4692 area is clipped - these are not expose events. */
4693 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4696 else if (FRAME_VISIBLE_P (f
) != 1)
4698 bool iconified
= FRAME_ICONIFIED_P (f
);
4700 /* Definitely not obscured, so mark as visible. */
4701 SET_FRAME_VISIBLE (f
, 1);
4702 SET_FRAME_ICONIFIED (f
, false);
4703 SET_FRAME_GARBAGED (f
);
4704 if (!f
->output_data
.w32
->asked_for_visible
)
4705 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4708 /* WM_PAINT serves as MapNotify as well, so report
4709 visibility changes properly. */
4712 inev
.kind
= DEICONIFY_EVENT
;
4713 XSETFRAME (inev
.frame_or_window
, f
);
4715 else if (!NILP (Vframe_list
) && !NILP (XCDR (Vframe_list
)))
4716 /* Force a redisplay sooner or later to update the
4717 frame titles in case this is the second frame. */
4718 record_asynch_buffer_change ();
4722 /* Erase background again for safety. But don't do
4723 that if the frame's 'garbaged' flag is set, since
4724 in that case expose_frame will do nothing, and if
4725 the various redisplay flags happen to be unset,
4726 we are left with a blank frame. */
4727 if (!FRAME_GARBAGED_P (f
) || FRAME_PARENT_FRAME (f
))
4729 HDC hdc
= get_frame_dc (f
);
4731 w32_clear_rect (f
, hdc
, &msg
.rect
);
4732 release_frame_dc (f
, hdc
);
4737 msg
.rect
.right
- msg
.rect
.left
,
4738 msg
.rect
.bottom
- msg
.rect
.top
);
4739 x_clear_under_internal_border (f
);
4744 case WM_INPUTLANGCHANGE
:
4745 /* Generate a language change event. */
4746 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4748 /* lParam contains the input language ID in its low 16 bits.
4749 Use it to update our record of the keyboard codepage. */
4750 w32_keyboard_codepage
= codepage_for_locale ((LCID
)(msg
.msg
.lParam
4755 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4756 XSETFRAME (inev
.frame_or_window
, f
);
4757 inev
.code
= w32_keyboard_codepage
;
4758 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4764 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4766 if (f
&& !FRAME_ICONIFIED_P (f
))
4768 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4769 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4771 clear_mouse_face (hlinfo
);
4772 hlinfo
->mouse_face_hidden
= true;
4775 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4777 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4778 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4779 inev
.code
= msg
.msg
.wParam
;
4780 inev
.modifiers
= msg
.dwModifiers
;
4781 XSETFRAME (inev
.frame_or_window
, f
);
4782 inev
.timestamp
= msg
.msg
.time
;
4789 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4791 if (f
&& !FRAME_ICONIFIED_P (f
))
4793 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4794 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4796 clear_mouse_face (hlinfo
);
4797 hlinfo
->mouse_face_hidden
= true;
4800 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4802 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4804 inev
.modifiers
= msg
.dwModifiers
;
4805 XSETFRAME (inev
.frame_or_window
, f
);
4806 inev
.timestamp
= msg
.msg
.time
;
4808 if (msg
.msg
.message
== WM_UNICHAR
)
4810 inev
.code
= msg
.msg
.wParam
;
4812 else if (msg
.msg
.wParam
< 256)
4817 dbcs
[1] = (char) msg
.msg
.wParam
;
4821 dbcs
[0] = dbcs_lead
;
4823 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4827 DebPrint (("Invalid DBCS sequence: %d %d\n",
4829 inev
.kind
= NO_EVENT
;
4833 else if (IsDBCSLeadByteEx (w32_keyboard_codepage
,
4834 (BYTE
) msg
.msg
.wParam
))
4836 dbcs_lead
= (char) msg
.msg
.wParam
;
4837 inev
.kind
= NO_EVENT
;
4842 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4843 &dbcs
[1], 1, &code
, 1))
4845 /* What to do with garbage? */
4846 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4847 inev
.kind
= NO_EVENT
;
4855 /* Windows shouldn't generate WM_CHAR events above 0xFF
4856 in non-Unicode message handlers. */
4857 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4858 inev
.kind
= NO_EVENT
;
4861 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4862 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4867 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4869 if (f
&& !FRAME_ICONIFIED_P (f
))
4871 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4872 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4874 clear_mouse_face (hlinfo
);
4875 hlinfo
->mouse_face_hidden
= true;
4878 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4880 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4881 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4882 inev
.code
= GET_APPCOMMAND_LPARAM (msg
.msg
.lParam
);
4883 inev
.modifiers
= msg
.dwModifiers
;
4884 XSETFRAME (inev
.frame_or_window
, f
);
4885 inev
.timestamp
= msg
.msg
.time
;
4890 /* Ignore non-movement. */
4892 int x
= LOWORD (msg
.msg
.lParam
);
4893 int y
= HIWORD (msg
.msg
.lParam
);
4894 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4896 last_mousemove_x
= x
;
4897 last_mousemove_y
= y
;
4900 previous_help_echo_string
= help_echo_string
;
4901 help_echo_string
= Qnil
;
4903 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4904 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4906 if (hlinfo
->mouse_face_hidden
)
4908 hlinfo
->mouse_face_hidden
= false;
4909 clear_mouse_face (hlinfo
);
4914 /* Maybe generate SELECT_WINDOW_EVENTs for
4915 `mouse-autoselect-window'. */
4916 if (!NILP (Vmouse_autoselect_window
)
4917 && (f
== XFRAME (selected_frame
)
4918 /* Switch to f from another frame iff
4919 focus_follows_mouse is set and f accepts
4921 || (!NILP (focus_follows_mouse
)
4922 && !FRAME_NO_ACCEPT_FOCUS (f
))))
4924 static Lisp_Object last_mouse_window
;
4925 Lisp_Object window
= window_from_coordinates
4926 (f
, LOWORD (msg
.msg
.lParam
), HIWORD (msg
.msg
.lParam
), 0, 0);
4928 /* Window will be selected only when it is not
4929 selected now and last mouse movement event was
4930 not in it. Minibuffer window will be selected
4931 only when it is active. */
4932 if (WINDOWP (window
)
4933 && !EQ (window
, last_mouse_window
)
4934 && !EQ (window
, selected_window
))
4936 inev
.kind
= SELECT_WINDOW_EVENT
;
4937 inev
.frame_or_window
= window
;
4940 /* Remember the last window where we saw the mouse. */
4941 last_mouse_window
= window
;
4944 if (!note_mouse_movement (f
, &msg
.msg
))
4945 help_echo_string
= previous_help_echo_string
;
4949 /* If we move outside the frame, then we're
4950 certainly no longer on any text in the frame. */
4951 clear_mouse_face (hlinfo
);
4954 /* If the contents of the global variable help_echo_string
4955 has changed, generate a HELP_EVENT. */
4956 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4957 But it was originally changed to this to fix a bug, so I have
4958 not removed it completely in case the bug is still there. */
4959 if (help_echo_string
!= previous_help_echo_string
||
4960 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4961 #else /* This is what xterm.c does. */
4962 if (!NILP (help_echo_string
)
4963 || !NILP (previous_help_echo_string
))
4968 case WM_LBUTTONDOWN
:
4970 case WM_MBUTTONDOWN
:
4972 case WM_RBUTTONDOWN
:
4974 case WM_XBUTTONDOWN
:
4977 /* If we decide we want to generate an event to be seen
4978 by the rest of Emacs, we put it here. */
4979 bool tool_bar_p
= 0;
4983 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4984 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4988 construct_mouse_click (&inev
, &msg
, f
);
4990 /* Is this in the tool-bar? */
4991 if (WINDOWP (f
->tool_bar_window
)
4992 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4995 int x
= XFASTINT (inev
.x
);
4996 int y
= XFASTINT (inev
.y
);
4998 window
= window_from_coordinates (f
, x
, y
, 0, 1);
5000 if (EQ (window
, f
->tool_bar_window
))
5002 w32_handle_tool_bar_click (f
, &inev
);
5008 || (dpyinfo
->w32_focus_frame
5009 && f
!= dpyinfo
->w32_focus_frame
5010 /* This does not help when the click happens in
5011 a grand-parent frame. */
5012 && !frame_ancestor_p (f
, dpyinfo
->w32_focus_frame
)))
5013 inev
.kind
= NO_EVENT
;
5016 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
5021 dpyinfo
->grabbed
&= ~ (1 << button
);
5025 dpyinfo
->grabbed
|= (1 << button
);
5026 dpyinfo
->last_mouse_frame
= f
;
5027 /* Ignore any mouse motion that happened
5028 before this event; any subsequent mouse-movement
5029 Emacs events should reflect only motion after
5033 f
->mouse_moved
= false;
5035 f
->last_tool_bar_item
= -1;
5042 case WM_MOUSEHWHEEL
:
5044 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
5045 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
5049 if (!dpyinfo
->w32_focus_frame
5050 || f
== dpyinfo
->w32_focus_frame
)
5051 /* Emit an Emacs wheel-up/down event. */
5053 construct_mouse_wheel (&inev
, &msg
, f
);
5055 /* Ignore any mouse motion that happened before this
5056 event; any subsequent mouse-movement Emacs events
5057 should reflect only motion after the ButtonPress. */
5058 f
->mouse_moved
= false;
5059 f
->last_tool_bar_item
= -1;
5060 dpyinfo
->last_mouse_frame
= f
;
5062 else if (FRAME_NO_ACCEPT_FOCUS (f
)
5063 && !x_mouse_grabbed (dpyinfo
))
5065 Lisp_Object frame1
= get_frame_param (f
, Qmouse_wheel_frame
);
5066 struct frame
*f1
= FRAMEP (frame1
) ? XFRAME (frame1
) : NULL
;
5068 if (f1
&& FRAME_LIVE_P (f1
) && FRAME_W32_P (f1
))
5070 construct_mouse_wheel (&inev
, &msg
, f1
);
5071 f1
->mouse_moved
= false;
5072 f1
->last_tool_bar_item
= -1;
5073 dpyinfo
->last_mouse_frame
= f1
;
5076 dpyinfo
->last_mouse_frame
= f
;
5079 dpyinfo
->last_mouse_frame
= f
;
5082 dpyinfo
->last_mouse_frame
= f
;
5087 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5090 construct_drag_n_drop (&inev
, &msg
, f
);
5095 struct scroll_bar
*bar
=
5096 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 1);
5099 w32_horizontal_scroll_bar_handle_click (bar
, &msg
, &inev
);
5105 struct scroll_bar
*bar
=
5106 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 0);
5109 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
5113 case WM_WINDOWPOSCHANGED
:
5114 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5119 int /* rows, columns, */ width
, height
, text_width
, text_height
;
5121 if (GetClientRect (msg
.msg
.hwnd
, &rect
)
5122 /* GetClientRect evidently returns (0, 0, 0, 0) if
5123 called on a minimized frame. Such "dimensions"
5124 aren't useful anyway. */
5125 && !(rect
.bottom
== 0
5128 && rect
.right
== 0))
5130 height
= rect
.bottom
- rect
.top
;
5131 width
= rect
.right
- rect
.left
;
5132 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, width
);
5133 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, height
);
5134 /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
5135 /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
5137 /* TODO: Clip size to the screen dimensions. */
5139 /* Even if the number of character rows and columns
5140 has not changed, the font size may have changed,
5141 so we need to check the pixel dimensions as well. */
5143 if (width
!= FRAME_PIXEL_WIDTH (f
)
5144 || height
!= FRAME_PIXEL_HEIGHT (f
)
5145 || text_width
!= FRAME_TEXT_WIDTH (f
)
5146 || text_height
!= FRAME_TEXT_HEIGHT (f
))
5148 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
5149 SET_FRAME_GARBAGED (f
);
5150 cancel_mouse_face (f
);
5151 f
->win_gravity
= NorthWestGravity
;
5156 check_visibility
= 1;
5160 case WM_ACTIVATEAPP
:
5161 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5164 /* Run the full-screen hook function also when we are
5165 being activated, to actually install the required
5166 size in effect, if the WAIT flag is set. This is
5167 because when the hook is run from x_set_fullscreen,
5168 the frame might not yet be visible, if that call is a
5169 result of make-frame, and in that case the hook just
5170 sets the WAIT flag. */
5171 if ((msg
.msg
.message
== WM_WINDOWPOSCHANGED
|| msg
.msg
.wParam
)
5172 && (f
->want_fullscreen
& FULLSCREEN_WAIT
))
5174 /* Must set visibility right here since otherwise
5175 w32fullscreen_hook returns immediately. */
5176 SET_FRAME_VISIBLE (f
, 1);
5177 w32fullscreen_hook (f
);
5181 check_visibility
= 1;
5185 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5187 if (f
&& FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P(f
))
5189 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5190 inev
.kind
= MOVE_FRAME_EVENT
;
5191 XSETFRAME (inev
.frame_or_window
, f
);
5194 check_visibility
= 1;
5198 /* wParam non-zero means Window is about to be shown, 0 means
5199 about to be hidden. */
5200 /* Redo the mouse-highlight after the tooltip has gone. */
5201 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
5204 x_redo_mouse_highlight (dpyinfo
);
5207 /* If window has been obscured or exposed by another window
5208 being maximized or minimized/restored, then recheck
5209 visibility of all frames. Direct changes to our own
5210 windows get handled by WM_SIZE. */
5212 if (msg
.msg
.lParam
!= 0)
5213 check_visibility
= 1;
5216 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5217 f
->async_visible
= msg
.msg
.wParam
;
5221 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5223 x_clear_under_internal_border (f
);
5225 check_visibility
= 1;
5229 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5231 /* Inform lisp of whether frame has been iconified etc. */
5234 switch (msg
.msg
.wParam
)
5236 case SIZE_MINIMIZED
:
5237 SET_FRAME_VISIBLE (f
, 0);
5238 SET_FRAME_ICONIFIED (f
, true);
5240 inev
.kind
= ICONIFY_EVENT
;
5241 XSETFRAME (inev
.frame_or_window
, f
);
5244 case SIZE_MAXIMIZED
:
5246 bool iconified
= FRAME_ICONIFIED_P (f
);
5247 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5249 SET_FRAME_VISIBLE (f
, 1);
5250 SET_FRAME_ICONIFIED (f
, false);
5252 /* wait_reading_process_output will notice this
5253 and update the frame's display structures. */
5254 SET_FRAME_GARBAGED (f
);
5260 /* Reset top and left positions of the Window
5261 here since Windows sends a WM_MOVE message
5262 BEFORE telling us the Window is minimized
5263 when the Window is iconified, with 3000,3000
5265 x_real_positions (f
, &x
, &y
);
5269 inev
.kind
= DEICONIFY_EVENT
;
5270 XSETFRAME (inev
.frame_or_window
, f
);
5272 else if (! NILP (Vframe_list
)
5273 && ! NILP (XCDR (Vframe_list
)))
5274 /* Force a redisplay sooner or later
5275 to update the frame titles
5276 in case this is the second frame. */
5277 record_asynch_buffer_change ();
5279 /* Windows can send us a SIZE_MAXIMIZED message even
5280 when fullscreen is fullboth. The following is a
5281 simple hack to check that based on the fact that
5282 only a maximized fullscreen frame should have both
5283 top/left outside the screen. */
5284 if (EQ (fullscreen
, Qfullwidth
) || EQ (fullscreen
, Qfullheight
)
5285 || NILP (fullscreen
))
5289 x_real_positions (f
, &x
, &y
);
5291 store_frame_param (f
, Qfullscreen
, Qmaximized
);
5299 bool iconified
= FRAME_ICONIFIED_P (f
);
5301 /* The following was made unconditional in a
5302 pathetic attempt to fix bug#16967 in revision
5303 116716 but, considered counterproductive was made
5304 conditional again in revision 116727. martin */
5306 SET_FRAME_VISIBLE (f
, 1);
5307 SET_FRAME_ICONIFIED (f
, false);
5309 /* wait_reading_process_output will notice this
5310 and update the frame's display structures. */
5311 SET_FRAME_GARBAGED (f
);
5315 /* Reset top and left positions of the Window
5316 here since Windows sends a WM_MOVE message
5317 BEFORE telling us the Window is minimized
5318 when the Window is iconified, with 3000,3000
5320 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5322 inev
.kind
= DEICONIFY_EVENT
;
5323 XSETFRAME (inev
.frame_or_window
, f
);
5325 else if (! NILP (Vframe_list
)
5326 && ! NILP (XCDR (Vframe_list
)))
5327 /* Force a redisplay sooner or later
5328 to update the frame titles
5329 in case this is the second frame. */
5330 record_asynch_buffer_change ();
5333 if (EQ (get_frame_param (f
, Qfullscreen
), Qmaximized
))
5334 store_frame_param (f
, Qfullscreen
, Qnil
);
5340 if (f
&& !FRAME_ICONIFIED_P (f
) && msg
.msg
.wParam
!= SIZE_MINIMIZED
)
5343 int /* rows, columns, */ width
, height
, text_width
, text_height
;
5345 if (GetClientRect (msg
.msg
.hwnd
, &rect
)
5346 /* GetClientRect evidently returns (0, 0, 0, 0) if
5347 called on a minimized frame. Such "dimensions"
5348 aren't useful anyway. */
5349 && !(rect
.bottom
== 0
5352 && rect
.right
== 0))
5354 height
= rect
.bottom
- rect
.top
;
5355 width
= rect
.right
- rect
.left
;
5356 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, width
);
5357 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, height
);
5358 /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
5359 /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
5361 /* TODO: Clip size to the screen dimensions. */
5363 /* Even if the number of character rows and columns
5364 has not changed, the font size may have changed,
5365 so we need to check the pixel dimensions as well. */
5367 if (width
!= FRAME_PIXEL_WIDTH (f
)
5368 || height
!= FRAME_PIXEL_HEIGHT (f
)
5369 || text_width
!= FRAME_TEXT_WIDTH (f
)
5370 || text_height
!= FRAME_TEXT_HEIGHT (f
))
5372 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
5373 SET_FRAME_GARBAGED (f
);
5374 cancel_mouse_face (f
);
5375 f
->win_gravity
= NorthWestGravity
;
5380 check_visibility
= 1;
5384 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5387 if (f
== hlinfo
->mouse_face_mouse_frame
)
5389 /* If we move outside the frame, then we're
5390 certainly no longer on any text in the frame. */
5391 clear_mouse_face (hlinfo
);
5392 hlinfo
->mouse_face_mouse_frame
= 0;
5395 /* Generate a nil HELP_EVENT to cancel a help-echo.
5396 Do it only if there's something to cancel.
5397 Otherwise, the startup message is cleared when
5398 the mouse leaves the frame. */
5399 if (any_help_event_p
)
5405 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5407 dpyinfo
->grabbed
= 0;
5408 check_visibility
= 1;
5412 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5413 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5417 if (f
== hlinfo
->mouse_face_mouse_frame
)
5419 /* If we move outside the frame, then we're
5420 certainly no longer on any text in the frame. */
5421 clear_mouse_face (hlinfo
);
5422 hlinfo
->mouse_face_mouse_frame
= 0;
5425 /* Generate a nil HELP_EVENT to cancel a help-echo.
5426 Do it only if there's something to cancel.
5427 Otherwise, the startup message is cleared when
5428 the mouse leaves the frame. */
5429 if (any_help_event_p
)
5433 dpyinfo
->grabbed
= 0;
5434 check_visibility
= 1;
5438 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5442 inev
.kind
= DELETE_WINDOW_EVENT
;
5443 XSETFRAME (inev
.frame_or_window
, f
);
5448 inev
.kind
= END_SESSION_EVENT
;
5452 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5456 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
5457 XSETFRAME (inev
.frame_or_window
, f
);
5462 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5466 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
5469 check_visibility
= 1;
5472 case WM_DISPLAYCHANGE
:
5473 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5477 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5479 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
5480 /* The new display could have a different resolution, in
5481 which case we must reconsider what fullscreen means.
5482 The following code is untested yet. */
5483 if (!NILP (fullscreen
))
5485 x_set_fullscreen (f
, fullscreen
, fullscreen
);
5486 w32fullscreen_hook (f
);
5489 DebPrint (("display change: %d %d\n",
5490 (short) LOWORD (msg
.msg
.lParam
),
5491 (short) HIWORD (msg
.msg
.lParam
)));
5494 check_visibility
= 1;
5498 case WM_EMACS_FILENOTIFY
:
5499 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5501 queue_notifications (&inev
, &msg
, f
, &count
);
5506 /* Check for messages registered at runtime. */
5507 if (msg
.msg
.message
== msh_mousewheel
)
5509 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5510 msg
.msg
.message
= WM_MOUSEWHEEL
;
5516 if (inev
.kind
!= NO_EVENT
)
5518 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5523 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5528 XSETFRAME (frame
, f
);
5534 if (NILP (help_echo_string
))
5536 help_echo_object
= help_echo_window
= Qnil
;
5540 any_help_event_p
= 1;
5541 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5542 help_echo_object
, help_echo_pos
);
5546 help_echo_string
= Qnil
;
5547 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5553 /* If the focus was just given to an autoraising frame,
5554 raise it now. FIXME: handle more than one such frame. */
5555 if (dpyinfo
->w32_pending_autoraise_frame
)
5557 x_raise_frame (dpyinfo
->w32_pending_autoraise_frame
);
5558 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
5561 /* Check which frames are still visible, if we have enqueued any user
5562 events or been notified of events that may affect visibility. We
5563 do this here because there doesn't seem to be any direct
5564 notification from Windows that the visibility of a window has
5565 changed (at least, not in all cases). */
5566 if (count
> 0 || check_visibility
)
5568 Lisp_Object tail
, frame
;
5570 FOR_EACH_FRAME (tail
, frame
)
5572 struct frame
*f
= XFRAME (frame
);
5573 /* The tooltip has been drawn already. Avoid the
5574 SET_FRAME_GARBAGED below. */
5575 if (EQ (frame
, tip_frame
))
5578 /* Check "visible" frames and mark each as obscured or not.
5579 Note that visible is nonzero for unobscured and obscured
5580 frames, but zero for hidden and iconified frames. */
5581 if (FRAME_W32_P (f
) && FRAME_VISIBLE_P (f
))
5588 /* Query clipping rectangle for the entire window area
5589 (GetWindowDC), not just the client portion (GetDC).
5590 Otherwise, the scrollbars and menubar aren't counted as
5591 part of the visible area of the frame, and we may think
5592 the frame is obscured when really a scrollbar is still
5593 visible and gets WM_PAINT messages above. */
5594 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5595 GetClipBox (hdc
, &clipbox
);
5596 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5599 obscured
= FRAME_OBSCURED_P (f
);
5601 if (clipbox
.right
== clipbox
.left
|| clipbox
.bottom
== clipbox
.top
)
5603 /* Frame has become completely obscured so mark as such (we
5604 do this by setting visible to 2 so that FRAME_VISIBLE_P
5605 is still true, but redisplay will skip it). */
5606 SET_FRAME_VISIBLE (f
, 2);
5609 DebPrint (("frame %p (%s) obscured\n", f
, SDATA (f
->name
)));
5613 /* Frame is not obscured, so mark it as such. */
5614 SET_FRAME_VISIBLE (f
, 1);
5618 SET_FRAME_GARBAGED (f
);
5619 DebPrint (("obscured frame %p (%s) found to be visible\n",
5620 f
, SDATA (f
->name
)));
5622 /* Force a redisplay sooner or later. */
5623 record_asynch_buffer_change ();
5636 /***********************************************************************
5638 ***********************************************************************/
5640 /* Set clipping for output in glyph row ROW. W is the window in which
5641 we operate. GC is the graphics context to set clipping in.
5643 ROW may be a text row or, e.g., a mode line. Text rows must be
5644 clipped to the interior of the window dedicated to text display,
5645 mode lines must be clipped to the whole window. */
5648 w32_clip_to_row (struct window
*w
, struct glyph_row
*row
,
5649 enum glyph_row_area area
, HDC hdc
)
5652 int window_x
, window_y
, window_width
;
5654 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5656 clip_rect
.left
= window_x
;
5657 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5658 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5659 clip_rect
.right
= clip_rect
.left
+ window_width
;
5660 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5662 w32_set_clip_rectangle (hdc
, &clip_rect
);
5666 /* Draw a hollow box cursor on window W in glyph row ROW. */
5669 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
5671 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5675 struct glyph
*cursor_glyph
;
5676 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5678 /* Get the glyph the cursor is on. If we can't tell because
5679 the current matrix is invalid or such, give up. */
5680 cursor_glyph
= get_phys_cursor_glyph (w
);
5681 if (cursor_glyph
== NULL
)
5687 /* Compute frame-relative coordinates for phys cursor. */
5688 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5690 /* When on R2L character, show cursor at the right edge of the
5691 glyph, unless the cursor box is as wide as the glyph or wider
5692 (the latter happens when x-stretch-cursor is non-nil). */
5693 if ((cursor_glyph
->resolved_level
& 1) != 0
5694 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5695 rect
.left
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5697 rect
.bottom
= rect
.top
+ h
;
5698 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5700 hdc
= get_frame_dc (f
);
5701 /* Set clipping, draw the rectangle, and reset clipping again. */
5702 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5703 FrameRect (hdc
, &rect
, hb
);
5705 w32_set_clip_rectangle (hdc
, NULL
);
5706 release_frame_dc (f
, hdc
);
5710 /* Draw a bar cursor on window W in glyph row ROW.
5712 Implementation note: One would like to draw a bar cursor with an
5713 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5714 Unfortunately, I didn't find a font yet that has this property set.
5718 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
,
5719 int width
, enum text_cursor_kinds kind
)
5721 struct frame
*f
= XFRAME (w
->frame
);
5722 struct glyph
*cursor_glyph
;
5724 /* If cursor is out of bounds, don't draw garbage. This can happen
5725 in mini-buffer windows when switching between echo area glyphs
5727 cursor_glyph
= get_phys_cursor_glyph (w
);
5728 if (cursor_glyph
== NULL
)
5731 /* If on an image, draw like a normal cursor. That's usually better
5732 visible than drawing a bar, esp. if the image is large so that
5733 the bar might not be in the window. */
5734 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5736 struct glyph_row
*row
;
5737 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5738 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5742 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5743 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5747 /* If the glyph's background equals the color we normally draw
5748 the bar cursor in, the bar cursor in its normal color is
5749 invisible. Use the glyph's foreground color instead in this
5750 case, on the assumption that the glyph's colors are chosen so
5751 that the glyph is legible. */
5752 if (face
->background
== cursor_color
)
5753 cursor_color
= face
->foreground
;
5755 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5757 hdc
= get_frame_dc (f
);
5758 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5760 if (kind
== BAR_CURSOR
)
5763 width
= FRAME_CURSOR_WIDTH (f
);
5764 width
= min (cursor_glyph
->pixel_width
, width
);
5766 w
->phys_cursor_width
= width
;
5768 /* If the character under cursor is R2L, draw the bar cursor
5769 on the right of its glyph, rather than on the left. */
5770 if ((cursor_glyph
->resolved_level
& 1) != 0)
5771 x
+= cursor_glyph
->pixel_width
- width
;
5773 w32_fill_area (f
, hdc
, cursor_color
, x
,
5774 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5775 width
, row
->height
);
5777 else /* HBAR_CURSOR */
5779 int dummy_x
, dummy_y
, dummy_h
;
5782 width
= row
->height
;
5784 width
= min (row
->height
, width
);
5786 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
5787 &dummy_y
, &dummy_h
);
5788 if ((cursor_glyph
->resolved_level
& 1) != 0
5789 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5790 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5791 w32_fill_area (f
, hdc
, cursor_color
, x
,
5792 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5793 row
->height
- width
),
5794 w
->phys_cursor_width
, width
);
5797 w32_set_clip_rectangle (hdc
, NULL
);
5798 release_frame_dc (f
, hdc
);
5803 /* RIF: Define cursor CURSOR on frame F. */
5806 w32_define_frame_cursor (struct frame
*f
, Cursor cursor
)
5808 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5812 /* RIF: Clear area on frame F. */
5815 w32_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
5819 hdc
= get_frame_dc (f
);
5820 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5821 release_frame_dc (f
, hdc
);
5824 /* RIF: Draw or clear cursor on window W. */
5827 w32_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
,
5828 int x
, int y
, enum text_cursor_kinds cursor_type
,
5829 int cursor_width
, bool on_p
, bool active_p
)
5833 /* If the user wants to use the system caret, make sure our own
5834 cursor remains invisible. */
5835 if (w32_use_visible_system_caret
)
5837 /* Call to erase_phys_cursor here seems to use the
5838 wrong values of w->phys_cursor, as they have been
5839 overwritten before this function was called. */
5840 if (w
->phys_cursor_type
!= NO_CURSOR
)
5841 erase_phys_cursor (w
);
5843 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5844 w
->phys_cursor_width
= -1;
5848 w
->phys_cursor_type
= cursor_type
;
5851 w
->phys_cursor_on_p
= true;
5853 /* If this is the active cursor, we need to track it with the
5854 system caret, so third party software like screen magnifiers
5855 and speech synthesizers can follow the cursor. */
5858 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5859 HWND hwnd
= FRAME_W32_WINDOW (f
);
5862 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5864 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5865 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5866 w32_system_caret_window
= w
;
5867 w32_system_caret_hdr_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
5868 w32_system_caret_mode_height
= WINDOW_MODE_LINE_HEIGHT (w
);
5870 PostMessage (hwnd
, WM_IME_STARTCOMPOSITION
, 0, 0);
5872 /* If the size of the active cursor changed, destroy the old
5874 if (w32_system_caret_hwnd
5875 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5876 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5878 w32_system_caret_height
= w
->phys_cursor_height
;
5880 /* Move the system caret. */
5881 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5884 if (glyph_row
->exact_window_width_line_p
5885 && (glyph_row
->reversed_p
5886 ? (w
->phys_cursor
.hpos
< 0)
5887 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
5889 glyph_row
->cursor_in_fringe_p
= true;
5890 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
5894 switch (cursor_type
)
5896 case HOLLOW_BOX_CURSOR
:
5897 x_draw_hollow_cursor (w
, glyph_row
);
5900 case FILLED_BOX_CURSOR
:
5901 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5905 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5909 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5913 w
->phys_cursor_width
= 0;
5927 x_bitmap_icon (struct frame
*f
, Lisp_Object icon
)
5930 HANDLE small_icon
= NULL
;
5932 if (FRAME_W32_WINDOW (f
) == 0)
5936 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5937 else if (STRINGP (icon
))
5939 /* Load the main icon from the named file. */
5940 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5941 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5942 /* Try to load a small icon to go with it. */
5943 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5944 GetSystemMetrics (SM_CXSMICON
),
5945 GetSystemMetrics (SM_CYSMICON
),
5948 else if (SYMBOLP (icon
))
5952 if (EQ (icon
, intern ("application")))
5953 name
= (LPCTSTR
) IDI_APPLICATION
;
5954 else if (EQ (icon
, intern ("hand")))
5955 name
= (LPCTSTR
) IDI_HAND
;
5956 else if (EQ (icon
, intern ("question")))
5957 name
= (LPCTSTR
) IDI_QUESTION
;
5958 else if (EQ (icon
, intern ("exclamation")))
5959 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5960 else if (EQ (icon
, intern ("asterisk")))
5961 name
= (LPCTSTR
) IDI_ASTERISK
;
5962 else if (EQ (icon
, intern ("winlogo")))
5963 name
= (LPCTSTR
) IDI_WINLOGO
;
5967 main_icon
= LoadIcon (NULL
, name
);
5972 if (main_icon
== NULL
)
5975 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5976 (LPARAM
) main_icon
);
5978 /* If there is a small icon that goes with it, set that too. */
5980 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5981 (LPARAM
) small_icon
);
5987 /************************************************************************
5989 ************************************************************************/
5991 /* Display Error Handling functions not used on W32. Listing them here
5992 helps diff stay in step when comparing w32term.c with xterm.c.
5994 x_error_catcher (display, error)
5995 x_catch_errors (dpy)
5996 x_catch_errors_unwind (old_val)
5997 x_check_errors (dpy, format)
5998 x_fully_uncatch_errors ()
5999 x_had_errors_p (dpy)
6000 x_clear_errors (dpy)
6001 x_uncatch_errors (dpy, count)
6003 x_connection_signal (signalnum)
6004 x_connection_closed (dpy, error_message)
6005 x_error_quitter (display, error)
6006 x_error_handler (display, error)
6007 x_io_error_quitter (display)
6012 /* Changing the font of the frame. */
6015 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
6017 struct font
*font
= XFONT_OBJECT (font_object
);
6018 int unit
, font_ascent
, font_descent
;
6021 fontset
= fontset_from_font (font_object
);
6022 FRAME_FONTSET (f
) = fontset
;
6023 if (FRAME_FONT (f
) == font
)
6024 /* This font is already set in frame F. There's nothing more to
6028 FRAME_FONT (f
) = font
;
6029 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
6030 FRAME_COLUMN_WIDTH (f
) = unit
= font
->average_width
;
6031 get_font_ascent_descent (font
, &font_ascent
, &font_descent
);
6032 FRAME_LINE_HEIGHT (f
) = font_ascent
+ font_descent
;
6034 /* Compute number of scrollbar columns. */
6035 unit
= FRAME_COLUMN_WIDTH (f
);
6036 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
6037 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
6038 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
6041 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
6042 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) =
6043 FRAME_CONFIG_SCROLL_BAR_COLS (f
) * unit
;
6046 /* Now make the frame display the given font. */
6047 if (FRAME_X_WINDOW (f
) != 0)
6049 /* Don't change the size of a tip frame; there's no point in
6050 doing it because it's done in Fx_show_tip, and it leads to
6051 problems because the tip frame has no widget. */
6052 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
6053 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
6054 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
6058 /* X version sets font of input methods here also. */
6064 /***********************************************************************
6065 TODO: W32 Input Methods
6066 ***********************************************************************/
6067 /* Listing missing functions from xterm.c helps diff stay in step.
6069 xim_destroy_callback (xim, client_data, call_data)
6070 xim_open_dpy (dpyinfo, resource_name)
6072 xim_instantiate_callback (display, client_data, call_data)
6073 xim_initialize (dpyinfo, resource_name)
6074 xim_close_dpy (dpyinfo)
6079 /* Calculate the absolute position in frame F
6080 from its current recorded position values and gravity. */
6083 x_calc_absolute_position (struct frame
*f
)
6085 int flags
= f
->size_hint_flags
;
6087 /* The sum of the widths of the frame's left and right borders, and
6088 the sum of the heights of the frame's top and bottom borders (in
6089 pixels) drawn by Windows. */
6090 unsigned int left_right_borders_width
, top_bottom_borders_height
;
6092 /* Try to get the actual values of these two variables. We compute
6093 the border width (height) by subtracting the width (height) of
6094 the frame's client area from the width (height) of the frame's
6096 WINDOWPLACEMENT wp
= { 0 };
6097 RECT client_rect
= { 0 };
6099 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
6100 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
6102 left_right_borders_width
=
6103 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
6104 (client_rect
.right
- client_rect
.left
);
6106 top_bottom_borders_height
=
6107 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
6108 (client_rect
.bottom
- client_rect
.top
);
6112 /* Use sensible default values. */
6113 left_right_borders_width
= 8;
6114 top_bottom_borders_height
= 32;
6117 /* With multiple monitors, we can legitimately get negative
6118 coordinates (for monitors above or to the left of the primary
6119 monitor). Find the display origin to ensure negative positions
6120 are computed correctly (Bug#21173). */
6121 int display_left
= 0;
6122 int display_top
= 0;
6123 struct frame
*p
= FRAME_PARENT_FRAME (f
);
6125 if (!p
&& flags
& (XNegative
| YNegative
))
6129 list
= Fw32_display_monitor_attributes_list (Qnil
);
6130 while (CONSP (list
))
6132 Lisp_Object attributes
= CAR(list
);
6133 Lisp_Object geometry
;
6134 Lisp_Object monitor_left
, monitor_top
;
6138 geometry
= Fassoc (Qgeometry
, attributes
, Qnil
);
6139 if (!NILP (geometry
))
6141 monitor_left
= Fnth (make_number (1), geometry
);
6142 monitor_top
= Fnth (make_number (2), geometry
);
6144 display_left
= min (display_left
, XINT (monitor_left
));
6145 display_top
= min (display_top
, XINT (monitor_top
));
6150 /* Treat negative positions as relative to the rightmost bottommost
6151 position that fits on the screen or parent frame.
6153 I see no need for subtracting 1 from the border widths - is there
6154 any on the remaining platforms? Here these subtractions did put
6155 the last pixel line/column of a frame off-display when, for
6156 example, a (set-frame-parameter nil 'left '(- 0)) specification was
6157 used - martin 20017-05-05. */
6158 if (flags
& XNegative
)
6161 f
->left_pos
= (FRAME_PIXEL_WIDTH (p
)
6162 - FRAME_PIXEL_WIDTH (f
)
6164 - left_right_borders_width
);
6166 f
->left_pos
= (x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
6168 - FRAME_PIXEL_WIDTH (f
)
6170 - left_right_borders_width
);
6173 if (flags
& YNegative
)
6176 f
->top_pos
= (FRAME_PIXEL_HEIGHT (p
)
6177 - FRAME_PIXEL_HEIGHT (f
)
6179 - top_bottom_borders_height
);
6181 f
->top_pos
= (x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
6183 - FRAME_PIXEL_HEIGHT (f
)
6185 - top_bottom_borders_height
);
6188 /* The left_pos and top_pos are now relative to the top and left
6189 screen edges, so the flags should correspond. */
6190 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6193 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
6194 to really change the position, and 0 when calling from
6195 x_make_frame_visible (in that case, XOFF and YOFF are the current
6196 position values). It is -1 when calling from x_set_frame_parameters,
6197 which means, do adjust for borders but don't change the gravity. */
6200 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
,
6203 int modified_top
, modified_left
;
6205 if (change_gravity
> 0)
6209 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6211 f
->size_hint_flags
|= XNegative
;
6213 f
->size_hint_flags
|= YNegative
;
6214 f
->win_gravity
= NorthWestGravity
;
6216 x_calc_absolute_position (f
);
6219 x_wm_set_size_hint (f
, (long) 0, false);
6221 modified_left
= f
->left_pos
;
6222 modified_top
= f
->top_pos
;
6224 if (!FRAME_PARENT_FRAME (f
))
6225 my_set_window_pos (FRAME_W32_WINDOW (f
), NULL
,
6226 modified_left
, modified_top
,
6228 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6230 my_set_window_pos (FRAME_W32_WINDOW (f
), HWND_TOP
,
6231 modified_left
, modified_top
,
6233 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6238 w32fullscreen_hook (struct frame
*f
)
6240 if (FRAME_VISIBLE_P (f
))
6242 HWND hwnd
= FRAME_W32_WINDOW(f
);
6243 DWORD dwStyle
= GetWindowLong (hwnd
, GWL_STYLE
);
6245 enum fullscreen_type prev_fsmode
= FRAME_PREV_FSMODE (f
);
6248 f
->want_fullscreen
&= ~FULLSCREEN_WAIT
;
6250 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_NONE
)
6251 GetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6253 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_BOTH
)
6255 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
| WS_OVERLAPPEDWINDOW
);
6256 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6258 else if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_HEIGHT
6259 || FRAME_PREV_FSMODE (f
) == FULLSCREEN_WIDTH
)
6260 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6262 FRAME_PREV_FSMODE (f
) = f
->want_fullscreen
;
6264 if (f
->want_fullscreen
== FULLSCREEN_NONE
)
6265 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6266 else if (f
->want_fullscreen
== FULLSCREEN_MAXIMIZED
)
6268 if (prev_fsmode
== FULLSCREEN_BOTH
|| prev_fsmode
== FULLSCREEN_WIDTH
6269 || prev_fsmode
== FULLSCREEN_HEIGHT
)
6270 /* Make window normal since otherwise the subsequent
6271 maximization might fail in some cases. */
6272 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6273 ShowWindow (hwnd
, SW_MAXIMIZE
);
6275 else if (f
->want_fullscreen
== FULLSCREEN_BOTH
)
6277 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6279 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6280 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6281 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
& ~WS_OVERLAPPEDWINDOW
);
6282 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6283 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
,
6284 SWP_NOOWNERZORDER
| SWP_FRAMECHANGED
);
6286 (f
, FRAME_PIXEL_TO_TEXT_WIDTH (f
, rect
.right
- rect
.left
),
6287 FRAME_PIXEL_TO_TEXT_HEIGHT (f
, (rect
.bottom
- rect
.top
6288 - menu_bar_height
)),
6293 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6294 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6295 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6296 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6297 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, 0);
6299 if (f
->want_fullscreen
== FULLSCREEN_WIDTH
)
6301 int border_width
= GetSystemMetrics (SM_CXFRAME
);
6304 (f
, (FRAME_PIXEL_TO_TEXT_WIDTH
6305 (f
, rect
.right
- rect
.left
- 2 * border_width
)),
6310 int border_height
= GetSystemMetrics (SM_CYFRAME
);
6311 /* Won't work for wrapped menu bar. */
6312 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6313 int title_height
= GetSystemMetrics (SM_CYCAPTION
);
6316 (f
, 0, (FRAME_PIXEL_TO_TEXT_HEIGHT
6317 (f
, rect
.bottom
- rect
.top
- 2 * border_height
6318 - title_height
- menu_bar_height
)),
6323 f
->want_fullscreen
= FULLSCREEN_NONE
;
6326 if (f
->want_fullscreen
== FULLSCREEN_BOTH
6327 || f
->want_fullscreen
== FULLSCREEN_WIDTH
6328 || f
->want_fullscreen
== FULLSCREEN_HEIGHT
)
6329 do_pending_window_change (0);
6333 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
6336 /* Call this to change the size of frame F's x-window.
6337 If CHANGE_GRAVITY, change to top-left-corner window gravity
6338 for this size change and subsequent size changes.
6339 Otherwise we leave the window gravity unchanged. */
6342 x_set_window_size (struct frame
*f
, bool change_gravity
,
6343 int width
, int height
, bool pixelwise
)
6345 int pixelwidth
, pixelheight
;
6346 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
6349 int menu_bar_height
;
6353 /* Get the height of the menu bar here. It's used below to detect
6354 whether the menu bar is wrapped. It's also used to specify the
6355 third argument for AdjustWindowRect. See bug#22105. */
6356 info
.cbSize
= sizeof (info
);
6357 info
.rcBar
.top
= info
.rcBar
.bottom
= 0;
6358 GetMenuBarInfo (FRAME_W32_WINDOW (f
), 0xFFFFFFFD, 0, &info
);
6359 menu_bar_height
= info
.rcBar
.bottom
- info
.rcBar
.top
;
6363 pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
6364 pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
6368 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
);
6369 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
);
6372 if (w32_add_wrapped_menu_bar_lines
)
6374 /* When the menu bar wraps sending a SetWindowPos shrinks the
6375 height of the frame then the wrapped menu bar lines are not
6376 accounted for (Bug#15174 and Bug#18720). Here we add these
6377 extra lines to the frame height. */
6378 int default_menu_bar_height
;
6380 /* Why is (apparently) SM_CYMENUSIZE needed here instead of
6382 default_menu_bar_height
= GetSystemMetrics (SM_CYMENUSIZE
);
6384 if ((default_menu_bar_height
> 0)
6385 && (menu_bar_height
> default_menu_bar_height
)
6386 && ((menu_bar_height
% default_menu_bar_height
) == 0))
6387 pixelheight
= pixelheight
+ menu_bar_height
- default_menu_bar_height
;
6390 f
->win_gravity
= NorthWestGravity
;
6391 x_wm_set_size_hint (f
, (long) 0, false);
6393 rect
.left
= rect
.top
= 0;
6394 rect
.right
= pixelwidth
;
6395 rect
.bottom
= pixelheight
;
6397 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
, menu_bar_height
> 0);
6399 if (!(f
->after_make_frame
)
6400 && !(f
->want_fullscreen
& FULLSCREEN_WAIT
)
6401 && FRAME_VISIBLE_P (f
))
6405 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6407 if (EQ (fullscreen
, Qmaximized
)
6408 || EQ (fullscreen
, Qfullboth
)
6409 || EQ (fullscreen
, Qfullwidth
))
6411 rect
.left
= window_rect
.left
;
6412 rect
.right
= window_rect
.right
;
6415 if (EQ (fullscreen
, Qmaximized
)
6416 || EQ (fullscreen
, Qfullboth
)
6417 || EQ (fullscreen
, Qfullheight
))
6419 rect
.top
= window_rect
.top
;
6420 rect
.bottom
= window_rect
.bottom
;
6425 if (pixelwidth
> 0 || pixelheight
> 0)
6427 frame_size_history_add
6428 (f
, Qx_set_window_size_1
, width
, height
,
6429 list2 (Fcons (make_number (pixelwidth
),
6430 make_number (pixelheight
)),
6431 Fcons (make_number (rect
.right
- rect
.left
),
6432 make_number (rect
.bottom
- rect
.top
))));
6434 if (!FRAME_PARENT_FRAME (f
))
6435 my_set_window_pos (FRAME_W32_WINDOW (f
), NULL
,
6437 rect
.right
- rect
.left
,
6438 rect
.bottom
- rect
.top
,
6439 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6441 my_set_window_pos (FRAME_W32_WINDOW (f
), HWND_TOP
,
6443 rect
.right
- rect
.left
,
6444 rect
.bottom
- rect
.top
,
6445 SWP_NOMOVE
| SWP_NOACTIVATE
);
6447 change_frame_size (f
,
6449 ? 0 : FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
)),
6451 ? 0 : FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
)),
6453 SET_FRAME_GARBAGED (f
);
6455 /* If cursor was outside the new size, mark it as off. */
6456 mark_window_cursors_off (XWINDOW (f
->root_window
));
6458 /* Clear out any recollection of where the mouse highlighting was,
6459 since it might be in a place that's outside the new frame size.
6460 Actually checking whether it is outside is a pain in the neck,
6461 so don't try--just let the highlighting be done afresh with new
6463 cancel_mouse_face (f
);
6468 do_pending_window_change (false);
6471 /* Mouse warping. */
6474 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
6483 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
6484 pt
.x
= rect
.left
+ pix_x
;
6485 pt
.y
= rect
.top
+ pix_y
;
6486 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
6488 /* When "mouse trails" are in effect, moving the mouse cursor
6489 sometimes leaves behind an annoying "ghost" of the pointer.
6490 Avoid that by momentarily switching off mouse trails. */
6491 if (os_subtype
== OS_NT
6492 && w32_major_version
+ w32_minor_version
>= 6)
6493 ret
= SystemParametersInfo (SPI_GETMOUSETRAILS
, 0, &trail_num
, 0);
6494 SetCursorPos (pt
.x
, pt
.y
);
6496 SystemParametersInfo (SPI_SETMOUSETRAILS
, trail_num
, NULL
, 0);
6502 /* Focus shifting, raising and lowering. */
6504 /* The NOACTIVATE argument has no effect on Windows. According to the
6505 Windows API: An application cannot activate an inactive window
6506 without also bringing it to the top of the Z order. */
6509 x_focus_frame (struct frame
*f
, bool noactivate
)
6512 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6515 /* Give input focus to frame. */
6518 /* Try not to change its Z-order if possible. */
6519 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
6520 my_set_focus (f
, FRAME_W32_WINDOW (f
));
6523 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6527 /* Raise frame F. */
6529 x_raise_frame (struct frame
*f
)
6533 /* Strictly speaking, raise-frame should only change the frame's Z
6534 order, leaving input focus unchanged. This is reasonable behavior
6535 on X where the usual policy is point-to-focus. However, this
6536 behavior would be very odd on Windows where the usual policy is
6539 On X, if the mouse happens to be over the raised frame, it gets
6540 input focus anyway (so the window with focus will never be
6541 completely obscured) - if not, then just moving the mouse over it
6542 is sufficient to give it focus. On Windows, the user must actually
6543 click on the frame (preferably the title bar so as not to move
6544 point), which is more awkward. Also, no other Windows program
6545 raises a window to the top but leaves another window (possibly now
6546 completely obscured) with input focus.
6548 Because there is a system setting on Windows that allows the user
6549 to choose the point to focus policy, we make the strict semantics
6550 optional, but by default we grab focus when raising. */
6552 if (NILP (Vw32_grab_focus_on_raise
))
6554 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6555 not already the foreground application: the frame is raised
6556 above all other frames belonging to us, but not above the
6557 current top window. To achieve that, we have to resort to this
6558 more cumbersome method. */
6560 HDWP handle
= BeginDeferWindowPos (2);
6563 handle
= DeferWindowPos (handle
,
6564 FRAME_W32_WINDOW (f
),
6567 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6570 handle
= DeferWindowPos (handle
,
6571 GetForegroundWindow (),
6572 FRAME_W32_WINDOW (f
),
6574 SWP_NOSIZE
| SWP_NOMOVE
|
6577 EndDeferWindowPos (handle
);
6583 my_bring_window_to_top (FRAME_W32_WINDOW (f
));
6589 /* Lower frame F. */
6591 x_lower_frame (struct frame
*f
)
6594 my_set_window_pos (FRAME_W32_WINDOW (f
),
6597 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6602 w32_frame_raise_lower (struct frame
*f
, bool raise_flag
)
6604 if (! FRAME_W32_P (f
))
6613 /* Change of visibility. */
6615 /* This tries to wait until the frame is really visible.
6616 However, if the window manager asks the user where to position
6617 the frame, this will return before the user finishes doing that.
6618 The frame will not actually be visible at that time,
6619 but it will become visible later when the window manager
6620 finishes with it. */
6623 x_make_frame_visible (struct frame
*f
)
6627 x_set_bitmap_icon (f
);
6629 if (! FRAME_VISIBLE_P (f
))
6631 /* We test FRAME_GARBAGED_P here to make sure we don't
6632 call x_set_offset a second time
6633 if we get to x_make_frame_visible a second time
6634 before the window gets really visible. */
6635 if (! FRAME_ICONIFIED_P (f
)
6636 && ! f
->output_data
.w32
->asked_for_visible
)
6638 if (!FRAME_PARENT_FRAME (f
))
6643 /* Adjust vertical window position in order to avoid being
6644 covered by a taskbar placed at the bottom of the desktop. */
6645 SystemParametersInfo (SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6646 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6647 if (window_rect
.bottom
> workarea_rect
.bottom
6648 && window_rect
.top
> workarea_rect
.top
)
6649 f
->top_pos
= max (window_rect
.top
6650 - window_rect
.bottom
+ workarea_rect
.bottom
,
6654 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6657 f
->output_data
.w32
->asked_for_visible
= 1;
6659 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
6660 causes unexpected behavior when unminimizing frames that were
6661 previously maximized. But only SW_SHOWNORMAL works properly for
6662 frames that were truely hidden (using make-frame-invisible), so
6663 we need it to avoid Bug#5482. It seems that iconified is only
6664 set for minimized windows that are still visible, so use that to
6665 determine the appropriate flag to pass ShowWindow. */
6666 my_show_window (f
, FRAME_W32_WINDOW (f
),
6667 FRAME_ICONIFIED_P (f
)
6669 : FRAME_NO_FOCUS_ON_MAP (f
)
6674 /* Synchronize to ensure Emacs knows the frame is visible
6675 before we do anything else. We do this loop with input not blocked
6676 so that incoming events are handled. */
6681 /* This must come after we set COUNT. */
6684 XSETFRAME (frame
, f
);
6686 /* Wait until the frame is visible. Process X events until a
6687 MapNotify event has been seen, or until we think we won't get a
6688 MapNotify at all.. */
6689 for (count
= input_signal_count
+ 10;
6690 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6692 /* Force processing of queued events. */
6693 /* TODO: x_sync equivalent? */
6695 /* Machines that do polling rather than SIGIO have been observed
6696 to go into a busy-wait here. So we'll fake an alarm signal
6697 to let the handler know that there's something to be read.
6698 We used to raise a real alarm, but it seems that the handler
6699 isn't always enabled here. This is probably a bug. */
6700 if (input_polling_used ())
6702 /* It could be confusing if a real alarm arrives while processing
6703 the fake one. Turn it off and let the handler reset it. */
6704 int old_poll_suppress_count
= poll_suppress_count
;
6705 poll_suppress_count
= 1;
6706 poll_for_input_1 ();
6707 poll_suppress_count
= old_poll_suppress_count
;
6713 /* Change from mapped state to withdrawn state. */
6715 /* Make the frame visible (mapped and not iconified). */
6718 x_make_frame_invisible (struct frame
*f
)
6720 /* Don't keep the highlight on an invisible frame. */
6721 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6722 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6726 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6728 /* We can't distinguish this from iconification
6729 just by the event that we get from the server.
6730 So we can't win using the usual strategy of letting
6731 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6732 and synchronize with the server to make sure we agree. */
6733 SET_FRAME_VISIBLE (f
, 0);
6734 SET_FRAME_ICONIFIED (f
, false);
6739 /* Change window state from mapped to iconified. */
6742 x_iconify_frame (struct frame
*f
)
6744 /* Don't keep the highlight on an invisible frame. */
6745 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6746 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6748 if (FRAME_ICONIFIED_P (f
))
6753 x_set_bitmap_icon (f
);
6755 /* Simulate the user minimizing the frame. */
6756 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0,
6759 SET_FRAME_VISIBLE (f
, 0);
6760 SET_FRAME_ICONIFIED (f
, true);
6766 /* Free X resources of frame F. */
6769 x_free_frame_resources (struct frame
*f
)
6771 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6772 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
6776 /* We must free faces before destroying windows because some
6777 font-driver (e.g. xft) access a window while finishing a
6779 free_frame_faces (f
);
6781 if (FRAME_W32_WINDOW (f
))
6782 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6784 free_frame_menubar (f
);
6786 xfree (f
->output_data
.w32
);
6787 f
->output_data
.w32
= NULL
;
6789 if (f
== dpyinfo
->w32_focus_frame
)
6790 dpyinfo
->w32_focus_frame
= 0;
6791 if (f
== dpyinfo
->w32_focus_event_frame
)
6792 dpyinfo
->w32_focus_event_frame
= 0;
6793 if (f
== dpyinfo
->x_highlight_frame
)
6794 dpyinfo
->x_highlight_frame
= 0;
6795 if (f
== hlinfo
->mouse_face_mouse_frame
)
6796 reset_mouse_highlight (hlinfo
);
6802 /* Destroy the window of frame F. */
6804 x_destroy_window (struct frame
*f
)
6806 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6808 x_free_frame_resources (f
);
6809 dpyinfo
->reference_count
--;
6813 /* Setting window manager hints. */
6815 /* Set the normal size hints for the window manager, for frame F.
6816 FLAGS is the flags word to use--or 0 meaning preserve the flags
6817 that the window now has.
6818 If USER_POSITION, set the USPosition
6819 flag (this is useful when FLAGS is 0). */
6821 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
6823 Window window
= FRAME_W32_WINDOW (f
);
6827 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6828 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6829 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6830 SetWindowLong (window
, WND_VSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_WIDTH (f
));
6831 SetWindowLong (window
, WND_HSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_HEIGHT (f
));
6836 /***********************************************************************
6838 ***********************************************************************/
6842 /* Check that FONT is valid on frame F. It is if it can be found in F's
6846 x_check_font (struct frame
*f
, struct font
*font
)
6848 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
6849 if (font
->driver
->check
)
6850 eassert (font
->driver
->check (f
, font
) == 0);
6853 #endif /* GLYPH_DEBUG */
6855 /* Show hourglass cursor on frame F. */
6858 w32_show_hourglass (struct frame
*f
)
6860 if (!menubar_in_use
&& !current_popup_menu
)
6862 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6864 w32
->hourglass_p
= 1;
6865 SetCursor (w32
->hourglass_cursor
);
6869 /* Hide hourglass cursor on frame F. */
6872 w32_hide_hourglass (struct frame
*f
)
6874 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6876 w32
->hourglass_p
= 0;
6877 if (f
->pointer_invisible
)
6880 SetCursor (w32
->current_cursor
);
6883 /* FIXME: old code did that, but I don't know why. Anyway,
6884 this is used for non-GUI frames (see cancel_hourglass). */
6887 w32_arrow_cursor (void)
6889 SetCursor (w32_load_cursor (IDC_ARROW
));
6893 w32_toggle_invisible_pointer (struct frame
*f
, bool invisible
)
6897 if (f
->pointer_invisible
!= invisible
)
6899 f
->pointer_invisible
= invisible
;
6900 w32_define_cursor (FRAME_W32_WINDOW (f
),
6901 f
->output_data
.w32
->current_cursor
);
6907 /***********************************************************************
6909 ***********************************************************************/
6911 static int w32_initialized
= 0;
6914 w32_initialize_display_info (Lisp_Object display_name
)
6916 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6918 memset (dpyinfo
, 0, sizeof (*dpyinfo
));
6920 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
6921 dpyinfo
->w32_id_name
= xmalloc (SCHARS (Vinvocation_name
)
6922 + SCHARS (Vsystem_name
) + 2);
6923 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6924 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6926 /* Default Console mode values - overridden when running in GUI mode
6927 with values obtained from system metrics. */
6930 dpyinfo
->n_planes
= 1;
6931 dpyinfo
->n_cbits
= 4;
6932 dpyinfo
->n_fonts
= 0;
6933 dpyinfo
->smallest_font_height
= 1;
6934 dpyinfo
->smallest_char_width
= 1;
6935 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6936 dpyinfo
->horizontal_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6937 /* TODO: dpyinfo->gray */
6939 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
6942 /* Create an xrdb-style database of resources to supersede registry settings.
6943 The database is just a concatenation of C strings, finished by an additional
6944 \0. The strings are submitted to some basic normalization, so
6946 [ *]option[ *]:[ *]value...
6952 but any whitespace following value is not removed. */
6955 w32_make_rdb (char *xrm_option
)
6957 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6958 char *current
= buffer
;
6961 int before_value
= 0;
6975 if (in_option
&& (ch
== ':'))
6980 else if (before_value
)
6985 else if (!(in_option
|| before_value
))
6996 extern frame_parm_handler w32_frame_parm_handlers
[];
6998 static struct redisplay_interface w32_redisplay_interface
=
7000 w32_frame_parm_handlers
,
7004 x_clear_end_of_line
,
7006 x_after_update_window_line
,
7007 x_update_window_begin
,
7008 x_update_window_end
,
7009 0, /* flush_display */
7010 x_clear_window_mouse_face
,
7011 x_get_glyph_overhangs
,
7012 x_fix_overlapping_area
,
7013 w32_draw_fringe_bitmap
,
7014 w32_define_fringe_bitmap
,
7015 w32_destroy_fringe_bitmap
,
7016 w32_compute_glyph_string_overhangs
,
7017 x_draw_glyph_string
,
7018 w32_define_frame_cursor
,
7019 w32_clear_frame_area
,
7020 w32_draw_window_cursor
,
7021 w32_draw_vertical_window_border
,
7022 w32_draw_window_divider
,
7023 w32_shift_glyphs_for_insert
,
7028 static void x_delete_terminal (struct terminal
*term
);
7030 static struct terminal
*
7031 w32_create_terminal (struct w32_display_info
*dpyinfo
)
7033 struct terminal
*terminal
;
7035 terminal
= create_terminal (output_w32
, &w32_redisplay_interface
);
7037 terminal
->display_info
.w32
= dpyinfo
;
7038 dpyinfo
->terminal
= terminal
;
7040 /* MSVC does not type K&R functions with no arguments correctly, and
7041 so we must explicitly cast them. */
7042 terminal
->clear_frame_hook
= x_clear_frame
;
7043 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
7044 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
7045 terminal
->ring_bell_hook
= w32_ring_bell
;
7046 terminal
->toggle_invisible_pointer_hook
= w32_toggle_invisible_pointer
;
7047 terminal
->update_begin_hook
= x_update_begin
;
7048 terminal
->update_end_hook
= x_update_end
;
7049 terminal
->read_socket_hook
= w32_read_socket
;
7050 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
7051 terminal
->mouse_position_hook
= w32_mouse_position
;
7052 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
7053 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
7054 terminal
->fullscreen_hook
= w32fullscreen_hook
;
7055 terminal
->menu_show_hook
= w32_menu_show
;
7056 terminal
->popup_dialog_hook
= w32_popup_dialog
;
7057 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
7058 terminal
->set_horizontal_scroll_bar_hook
= w32_set_horizontal_scroll_bar
;
7059 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
7060 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
7061 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
7062 terminal
->delete_frame_hook
= x_destroy_window
;
7063 terminal
->delete_terminal_hook
= x_delete_terminal
;
7064 /* Other hooks are NULL by default. */
7066 /* We don't yet support separate terminals on W32, so don't try to share
7067 keyboards between virtual terminals that are on the same physical
7068 terminal like X does. */
7069 terminal
->kboard
= allocate_kboard (Qw32
);
7070 /* Don't let the initial kboard remain current longer than necessary.
7071 That would cause problems if a file loaded on startup tries to
7072 prompt in the mini-buffer. */
7073 if (current_kboard
== initial_kboard
)
7074 current_kboard
= terminal
->kboard
;
7075 terminal
->kboard
->reference_count
++;
7081 x_delete_terminal (struct terminal
*terminal
)
7083 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
7085 /* Protect against recursive calls. delete_frame in
7086 delete_terminal calls us back when it deletes our last frame. */
7087 if (!terminal
->name
)
7092 x_delete_display (dpyinfo
);
7096 struct w32_display_info
*
7097 w32_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
7099 struct w32_display_info
*dpyinfo
;
7100 struct terminal
*terminal
;
7105 if (!w32_initialized
)
7108 w32_initialized
= 1;
7111 w32_initialize_display_info (display_name
);
7113 dpyinfo
= &one_w32_display_info
;
7114 terminal
= w32_create_terminal (dpyinfo
);
7116 /* Set the name of the terminal. */
7117 terminal
->name
= xlispstrdup (display_name
);
7119 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
7121 /* Put this display on the chain. */
7122 dpyinfo
->next
= x_display_list
;
7123 x_display_list
= dpyinfo
;
7127 dpyinfo
->root_window
= GetDesktopWindow ();
7128 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
7129 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
7130 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
7131 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
7132 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
7133 ReleaseDC (NULL
, hdc
);
7135 /* initialize palette with white and black */
7138 w32_defined_color (0, "white", &color
, 1);
7139 w32_defined_color (0, "black", &color
, 1);
7143 /* Add the default keyboard. When !WINDOWSNT, we're using the
7144 standard Emacs console handling machinery and don't need an
7145 explicit FD here. */
7146 add_keyboard_wait_descriptor (0);
7148 /* /dev/windows wakes us up when we have a thread message pending. */
7149 add_keyboard_wait_descriptor (w32_message_fd
);
7152 /* Create Fringe Bitmaps and store them for later use.
7154 On W32, bitmaps are all unsigned short, as Windows requires
7155 bitmap data to be Word aligned. For some reason they are
7156 horizontally reflected compared to how they appear on X, so we
7157 need to bitswap and convert to unsigned shorts before creating
7159 w32_init_fringe (terminal
->rif
);
7166 /* Get rid of display DPYINFO, assuming all frames are already gone. */
7168 x_delete_display (struct w32_display_info
*dpyinfo
)
7170 /* FIXME: the only display info apparently can't be deleted. */
7171 /* free palette table */
7173 struct w32_palette_entry
* plist
;
7175 plist
= dpyinfo
->color_list
;
7178 struct w32_palette_entry
* pentry
= plist
;
7179 plist
= plist
->next
;
7182 dpyinfo
->color_list
= NULL
;
7183 if (dpyinfo
->palette
)
7184 DeleteObject (dpyinfo
->palette
);
7186 w32_reset_fringes ();
7190 /* Set up use of W32. */
7193 w32_init_main_thread (void)
7195 dwMainThreadId
= GetCurrentThreadId ();
7196 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
7197 GetCurrentProcess (), &hMainThread
, 0, TRUE
,
7198 DUPLICATE_SAME_ACCESS
);
7203 DWORD WINAPI
w32_msg_worker (void * arg
);
7206 w32_initialize (void)
7209 HRESULT (WINAPI
* set_user_model
) (const wchar_t * id
);
7213 w32_system_caret_hwnd
= NULL
;
7214 w32_system_caret_height
= 0;
7215 w32_system_caret_x
= 0;
7216 w32_system_caret_y
= 0;
7218 /* On Windows 7 and later, we need to set the user model ID
7219 to associate emacsclient launched files with Emacs frames
7221 shell
= GetModuleHandle ("shell32.dll");
7225 = (void *) GetProcAddress (shell
,
7226 "SetCurrentProcessExplicitAppUserModelID");
7228 /* If the function is defined, then we are running on Windows 7
7229 or newer, and the UI uses this to group related windows
7230 together. Since emacs, runemacs, emacsclient are related, we
7231 want them grouped even though the executables are different,
7232 so we need to set a consistent ID between them. */
7234 set_user_model (L
"GNU.Emacs");
7238 if ((w32_message_fd
= emacs_open ("/dev/windows", O_RDWR
, 0)) == -1)
7239 fatal ("opening /dev/windows: %s", strerror (errno
));
7242 /* Initialize w32_use_visible_system_caret based on whether a screen
7243 reader is in use. */
7244 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
7245 &w32_use_visible_system_caret
, 0))
7246 w32_use_visible_system_caret
= 0;
7248 any_help_event_p
= 0;
7250 /* Initialize input mode: interrupt_input off, no flow control, allow
7251 8 bit character input, standard quit char. */
7252 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
7255 LCID input_locale_id
= LOWORD (GetKeyboardLayout (0));
7256 w32_keyboard_codepage
= codepage_for_locale (input_locale_id
);
7259 /* Create the window thread - it will terminate itself when the app
7263 /* Wait for thread to start */
7267 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
7269 hWindowsThread
= CreateThread (NULL
, 0,
7271 0, 0, &dwWindowsThreadId
);
7273 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
7276 /* It is desirable that mainThread should have the same notion of
7277 focus window and active window as windowsThread. Unfortunately, the
7278 following call to AttachThreadInput, which should do precisely what
7279 we need, causes major problems when Emacs is linked as a console
7280 program. Unfortunately, we have good reasons for doing that, so
7281 instead we need to send messages to windowsThread to make some API
7282 calls for us (ones that affect, or depend on, the active/focus
7284 #ifdef ATTACH_THREADS
7285 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
7288 /* Dynamically link to optional system components. */
7290 HMODULE user_lib
= GetModuleHandle ("user32.dll");
7292 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7294 LOAD_PROC (user_lib
, SetLayeredWindowAttributes
);
7298 /* Ensure scrollbar handles are at least 5 pixels. */
7299 vertical_scroll_bar_min_handle
= 5;
7300 horizontal_scroll_bar_min_handle
= 5;
7302 /* For either kind of scroll bar, take account of the arrows; these
7303 effectively form the border of the main scroll bar range. */
7304 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
7305 = GetSystemMetrics (SM_CYVSCROLL
);
7306 horizontal_scroll_bar_left_border
= horizontal_scroll_bar_right_border
7307 = GetSystemMetrics (SM_CYHSCROLL
);
7312 syms_of_w32term (void)
7314 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
7316 DEFSYM (Qadded
, "added");
7317 DEFSYM (Qremoved
, "removed");
7318 DEFSYM (Qmodified
, "modified");
7319 DEFSYM (Qrenamed_from
, "renamed-from");
7320 DEFSYM (Qrenamed_to
, "renamed-to");
7322 DEFVAR_INT ("w32-num-mouse-buttons",
7323 w32_num_mouse_buttons
,
7324 doc
: /* Number of physical mouse buttons. */);
7325 w32_num_mouse_buttons
= 2;
7327 DEFVAR_LISP ("w32-swap-mouse-buttons",
7328 Vw32_swap_mouse_buttons
,
7329 doc
: /* Swap the mapping of middle and right mouse buttons.
7330 When nil, middle button is mouse-2 and right button is mouse-3. */);
7331 Vw32_swap_mouse_buttons
= Qnil
;
7333 DEFVAR_LISP ("w32-grab-focus-on-raise",
7334 Vw32_grab_focus_on_raise
,
7335 doc
: /* Raised frame grabs input focus.
7336 When t, `raise-frame' grabs input focus as well. This fits well
7337 with the normal Windows click-to-focus policy, but might not be
7338 desirable when using a point-to-focus policy. */);
7339 Vw32_grab_focus_on_raise
= Qt
;
7341 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7342 Vw32_capslock_is_shiftlock
,
7343 doc
: /* Apply CapsLock state to non character input keys.
7344 When nil, CapsLock only affects normal character input keys. */);
7345 Vw32_capslock_is_shiftlock
= Qnil
;
7347 DEFVAR_LISP ("w32-recognize-altgr",
7348 Vw32_recognize_altgr
,
7349 doc
: /* Recognize right-alt and left-ctrl as AltGr.
7350 When nil, the right-alt and left-ctrl key combination is
7351 interpreted normally. */);
7352 Vw32_recognize_altgr
= Qt
;
7354 DEFVAR_BOOL ("w32-use-visible-system-caret",
7355 w32_use_visible_system_caret
,
7356 doc
: /* Flag to make the system caret visible.
7357 When this is non-nil, Emacs will indicate the position of point by
7358 using the system caret instead of drawing its own cursor. Some screen
7359 reader software does not track the system cursor properly when it is
7360 invisible, and gets confused by Emacs drawing its own cursor, so this
7361 variable is initialized to t when Emacs detects that screen reader
7362 software is running as it starts up.
7364 When this variable is set, other variables affecting the appearance of
7365 the cursor have no effect. */);
7367 w32_use_visible_system_caret
= 0;
7369 /* We don't yet support this, but defining this here avoids whining
7370 from cus-start.el and other places, like "M-x set-variable". */
7371 DEFVAR_BOOL ("x-use-underline-position-properties",
7372 x_use_underline_position_properties
,
7373 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
7374 A value of nil means ignore them. If you encounter fonts with bogus
7375 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7376 to 4.1, set this to nil. You can also use `underline-minimum-offset'
7377 to override the font's UNDERLINE_POSITION for small font display
7379 x_use_underline_position_properties
= 0;
7381 DEFVAR_BOOL ("x-underline-at-descent-line",
7382 x_underline_at_descent_line
,
7383 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
7384 A value of nil means to draw the underline according to the value of the
7385 variable `x-use-underline-position-properties', which is usually at the
7386 baseline level. The default value is nil. */);
7387 x_underline_at_descent_line
= 0;
7389 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
7390 doc
: /* Which toolkit scroll bars Emacs uses, if any.
7391 A value of nil means Emacs doesn't use toolkit scroll bars.
7392 With the X Window system, the value is a symbol describing the
7393 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
7394 With MS Windows or Nextstep, the value is t. */);
7395 Vx_toolkit_scroll_bars
= Qt
;
7397 DEFVAR_BOOL ("w32-unicode-filenames",
7398 w32_unicode_filenames
,
7399 doc
: /* Non-nil means use Unicode APIs when passing file names to the OS.
7400 A value of nil means file names passed to the OS APIs and returned
7401 from those APIs are encoded/decoded using the ANSI codepage
7402 specified by `file-name-coding-system'.
7404 This variable is set to non-nil by default when Emacs runs on Windows
7405 systems of the NT family, including W2K, XP, Vista, Windows 7 and
7406 Windows 8. It is set to nil on Windows 9X. */);
7407 if (os_subtype
== OS_9X
)
7408 w32_unicode_filenames
= 0;
7410 w32_unicode_filenames
= 1;
7413 /* FIXME: The following variable will be (hopefully) removed
7414 before Emacs 25.1 gets released. */
7416 DEFVAR_BOOL ("w32-add-wrapped-menu-bar-lines",
7417 w32_add_wrapped_menu_bar_lines
,
7418 doc
: /* Non-nil means frame resizing accounts for wrapped menu bar lines.
7419 A value of nil means frame resizing does not add the height of wrapped
7420 menu bar lines when sending a frame resize request to the Windows API.
7421 This usually means that the resulting frame height is off by the number
7422 of wrapped menu bar lines. If this is non-nil, Emacs adds the height of
7423 wrapped menu bar lines when sending frame resize requests to the Windows
7425 w32_add_wrapped_menu_bar_lines
= 1;
7427 /* Tell Emacs about this window system. */
7428 Fprovide (Qw32
, Qnil
);