1 /* Implementation of GUI terminal on the Microsoft Windows API.
3 Copyright (C) 1989, 1993-2017 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or (at
10 your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
24 #include "blockinput.h"
26 #include "w32common.h" /* for OS version info */
32 #include <fcntl.h> /* for O_RDWR */
39 #include "termhooks.h"
45 #include "menu.h" /* for w32_menu_show */
48 #include "w32.h" /* for filename_from_utf16, filename_from_ansi */
52 #include <io.h> /* for get_osfhandle */
60 #if 0 /* TODO: stipple */
61 #include "bitmaps/gray.xbm"
66 static int max_fringe_bmp
= 0;
67 static HBITMAP
*fringe_bmp
= 0;
69 /* Temporary variables for w32_read_socket. */
71 static int last_mousemove_x
= 0;
72 static int last_mousemove_y
= 0;
74 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
75 #ifndef GET_WHEEL_DELTA_WPARAM
76 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
79 /* Non-zero means that a HELP_EVENT has been generated since Emacs
82 static int any_help_event_p
;
84 extern unsigned int msh_mousewheel
;
86 extern int w32_codepage_for_font (char *fontname
);
87 extern Cursor
w32_load_cursor (LPCTSTR name
);
89 #define x_any_window_to_frame x_window_to_frame
90 #define x_top_window_to_frame x_window_to_frame
93 /* This is display since w32 does not support multiple ones. */
94 struct w32_display_info one_w32_display_info
;
95 struct w32_display_info
*x_display_list
;
97 #if _WIN32_WINNT < 0x0500 && !defined(MINGW_W64)
98 /* Pre Windows 2000, this was not available, but define it here so
99 that Emacs compiled on such a platform will run on newer versions.
100 MinGW64 defines these unconditionally, so avoid redefining. */
102 typedef struct tagWCRANGE
108 typedef struct tagGLYPHSET
112 DWORD cGlyphsSupported
;
117 #endif /* compiling for pre-Win2k */
119 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
120 BOOL (WINAPI
*pfnSetLayeredWindowAttributes
) (HWND
, COLORREF
, BYTE
, DWORD
);
123 #define LWA_ALPHA 0x02
125 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
126 later targets by MSVC headers. */
127 #ifndef WS_EX_LAYERED
128 #define WS_EX_LAYERED 0x80000
131 /* SM_CXVIRTUALSCREEN and SM_CYVIRTUALSCREEN are not defined on 95 and
133 #ifndef SM_CXVIRTUALSCREEN
134 #define SM_CXVIRTUALSCREEN 78
136 #ifndef SM_CYVIRTUALSCREEN
137 #define SM_CYVIRTUALSCREEN 79
140 /* The handle of the frame that currently owns the system caret. */
141 HWND w32_system_caret_hwnd
;
142 int w32_system_caret_height
;
143 int w32_system_caret_x
;
144 int w32_system_caret_y
;
145 struct window
*w32_system_caret_window
;
146 int w32_system_caret_hdr_height
;
147 int w32_system_caret_mode_height
;
148 DWORD dwWindowsThreadId
= 0;
149 HANDLE hWindowsThread
= NULL
;
150 DWORD dwMainThreadId
= 0;
151 HANDLE hMainThread
= NULL
;
153 int vertical_scroll_bar_min_handle
;
154 int horizontal_scroll_bar_min_handle
;
155 int vertical_scroll_bar_top_border
;
156 int vertical_scroll_bar_bottom_border
;
157 int horizontal_scroll_bar_left_border
;
158 int horizontal_scroll_bar_right_border
;
160 int last_scroll_bar_drag_pos
;
162 /* Keyboard code page - may be changed by language-change events. */
163 int w32_keyboard_codepage
;
165 /* Incremented by w32_read_socket whenever it really tries to read
167 static int volatile input_signal_count
;
170 int w32_message_fd
= -1;
173 static void w32_handle_tool_bar_click (struct frame
*,
174 struct input_event
*);
175 static void w32_define_cursor (Window
, Cursor
);
177 void x_lower_frame (struct frame
*);
178 void x_scroll_bar_clear (struct frame
*);
179 void x_raise_frame (struct frame
*);
180 void x_wm_set_window_state (struct frame
*, int);
181 void x_wm_set_icon_pixmap (struct frame
*, int);
182 static void w32_initialize (void);
183 static void x_update_end (struct frame
*);
184 static void w32_frame_up_to_date (struct frame
*);
185 static void x_clear_frame (struct frame
*);
186 static void frame_highlight (struct frame
*);
187 static void frame_unhighlight (struct frame
*);
188 static void x_new_focus_frame (struct w32_display_info
*,
190 static void x_focus_changed (int, int, struct w32_display_info
*,
191 struct frame
*, struct input_event
*);
192 static void w32_detect_focus_change (struct w32_display_info
*,
193 W32Msg
*, struct input_event
*);
194 static void w32_frame_rehighlight (struct frame
*);
195 static void x_frame_rehighlight (struct w32_display_info
*);
196 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
197 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
198 enum text_cursor_kinds
);
199 static void w32_clip_to_row (struct window
*, struct glyph_row
*,
200 enum glyph_row_area
, HDC
);
201 static BOOL
my_show_window (struct frame
*, HWND
, int);
202 static void my_set_window_pos (HWND
, HWND
, int, int, int, int, UINT
);
204 static void my_set_focus (struct frame
*, HWND
);
206 static void my_set_foreground_window (HWND
);
207 static void my_destroy_window (struct frame
*, HWND
);
208 static void w32fullscreen_hook (struct frame
*);
211 static void x_check_font (struct frame
*, struct font
*);
215 /***********************************************************************
217 ***********************************************************************/
221 /* This is a function useful for recording debugging information about
222 the sequence of occurrences in this file. */
230 struct record event_record
[100];
232 int event_record_index
;
234 record_event (char *locus
, int type
)
236 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
237 event_record_index
= 0;
239 event_record
[event_record_index
].locus
= locus
;
240 event_record
[event_record_index
].type
= type
;
241 event_record_index
++;
248 XChangeGC (void *ignore
, XGCValues
*gc
, unsigned long mask
,
251 if (mask
& GCForeground
)
252 gc
->foreground
= xgcv
->foreground
;
253 if (mask
& GCBackground
)
254 gc
->background
= xgcv
->background
;
256 gc
->font
= xgcv
->font
;
260 XCreateGC (void *ignore
, HWND wignore
, unsigned long mask
, XGCValues
*xgcv
)
262 XGCValues
*gc
= xzalloc (sizeof (XGCValues
));
264 XChangeGC (ignore
, gc
, mask
, xgcv
);
269 #if 0 /* unused for now, see x_draw_image_glyph_string below */
271 XGetGCValues (void *ignore
, XGCValues
*gc
,
272 unsigned long mask
, XGCValues
*xgcv
)
274 XChangeGC (ignore
, xgcv
, mask
, gc
);
279 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
283 HRGN clip_region
= CreateRectRgnIndirect (rect
);
284 SelectClipRgn (hdc
, clip_region
);
285 DeleteObject (clip_region
);
288 SelectClipRgn (hdc
, NULL
);
291 /* Restore clipping rectangle in S */
293 w32_restore_glyph_string_clip (struct glyph_string
*s
)
296 int n
= s
->num_clips
;
299 w32_set_clip_rectangle (s
->hdc
, r
);
302 HRGN clip1
= CreateRectRgnIndirect (r
);
303 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
304 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
305 SelectClipRgn (s
->hdc
, clip1
);
306 DeleteObject (clip1
);
307 DeleteObject (clip2
);
312 Draw a wavy line under S. The wave fills wave_height pixels from y0.
318 wave_height = 3 | * * * *
323 w32_draw_underwave (struct glyph_string
*s
, COLORREF color
)
325 int wave_height
= 3, wave_length
= 2;
326 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, odd
, xmax
;
327 XRectangle wave_clip
, string_clip
, final_clip
;
328 RECT w32_final_clip
, w32_string_clip
;
332 dy
= wave_height
- 1;
334 y0
= s
->ybase
- wave_height
+ 3;
338 /* Find and set clipping rectangle */
342 wave_clip
.width
= width
;
343 wave_clip
.height
= wave_height
;
345 get_glyph_string_clip_rect (s
, &w32_string_clip
);
346 CONVERT_TO_XRECT (string_clip
, w32_string_clip
);
348 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
351 hp
= CreatePen (PS_SOLID
, 0, color
);
352 oldhp
= SelectObject (s
->hdc
, hp
);
353 CONVERT_FROM_XRECT (final_clip
, w32_final_clip
);
354 w32_set_clip_rectangle (s
->hdc
, &w32_final_clip
);
368 MoveToEx (s
->hdc
, x1
, y1
, NULL
);
372 LineTo (s
->hdc
, x2
, y2
);
374 x2
+= dx
, y2
= y0
+ odd
*dy
;
378 /* Restore previous pen and clipping rectangle(s) */
379 w32_restore_glyph_string_clip (s
);
380 SelectObject (s
->hdc
, oldhp
);
384 /* Draw a hollow rectangle at the specified position. */
386 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
387 int width
, int height
)
392 hb
= CreateSolidBrush (gc
->background
);
393 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
394 oldhb
= SelectObject (hdc
, hb
);
395 oldhp
= SelectObject (hdc
, hp
);
397 /* We enlarge WIDTH and HEIGHT by 1 to be bug-compatible to the
398 brain-dead design of XDrawRectangle, which draws a rectangle that
399 is 1 pixel wider and higher than its arguments WIDTH and HEIGHT.
400 This allows us to keep the code that calls this function similar
401 to the corresponding code in xterm.c. For the details, see
402 http://lists.gnu.org/archives/html/emacs-devel/2014-10/msg00546.html. */
403 Rectangle (hdc
, x
, y
, x
+ width
+ 1, y
+ height
+ 1);
405 SelectObject (hdc
, oldhb
);
406 SelectObject (hdc
, oldhp
);
411 /* Draw a filled rectangle at the specified position. */
413 w32_fill_rect (struct frame
*f
, HDC hdc
, COLORREF pix
, RECT
*lprect
)
417 hb
= CreateSolidBrush (pix
);
418 FillRect (hdc
, lprect
, hb
);
423 w32_clear_window (struct frame
*f
)
426 HDC hdc
= get_frame_dc (f
);
428 /* Under certain conditions, this can be called at startup with
429 a console frame pointer before the GUI frame is created. An HDC
430 of 0 indicates this. */
433 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
434 w32_clear_rect (f
, hdc
, &rect
);
437 release_frame_dc (f
, hdc
);
440 #define OPAQUE_FRAME 255
443 x_set_frame_alpha (struct frame
*f
)
445 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
447 double alpha_min
= 1.0;
450 HWND window
= FRAME_W32_WINDOW (f
);
452 /* Older versions of Windows do not support transparency. */
453 if (!pfnSetLayeredWindowAttributes
)
456 if (dpyinfo
->w32_focus_frame
== f
)
461 if (FLOATP (Vframe_alpha_lower_limit
))
462 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
463 else if (INTEGERP (Vframe_alpha_lower_limit
))
464 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
468 else if (alpha
> 1.0)
470 else if (alpha
< alpha_min
&& alpha_min
<= 1.0)
473 opac
= alpha
* OPAQUE_FRAME
;
475 ex_style
= GetWindowLong (window
, GWL_EXSTYLE
);
477 if (opac
== OPAQUE_FRAME
)
478 ex_style
&= ~WS_EX_LAYERED
;
480 ex_style
|= WS_EX_LAYERED
;
482 SetWindowLong (window
, GWL_EXSTYLE
, ex_style
);
484 if (opac
!= OPAQUE_FRAME
)
485 pfnSetLayeredWindowAttributes (window
, 0, opac
, LWA_ALPHA
);
489 x_display_pixel_height (struct w32_display_info
*dpyinfo
)
491 int pixels
= GetSystemMetrics (SM_CYVIRTUALSCREEN
);
494 /* Fallback for Windows 95 or NT 4.0. */
495 pixels
= GetSystemMetrics (SM_CYSCREEN
);
501 x_display_pixel_width (struct w32_display_info
*dpyinfo
)
503 int pixels
= GetSystemMetrics (SM_CXVIRTUALSCREEN
);
506 /* Fallback for Windows 95 or NT 4.0. */
507 pixels
= GetSystemMetrics (SM_CXSCREEN
);
513 /***********************************************************************
514 Starting and ending an update
515 ***********************************************************************/
517 /* Start an update of frame F. This function is installed as a hook
518 for update_begin, i.e. it is called when update_begin is called.
519 This function is called prior to calls to x_update_window_begin for
520 each window being updated. */
523 x_update_begin (struct frame
*f
)
525 struct w32_display_info
*display_info
= FRAME_DISPLAY_INFO (f
);
527 if (! FRAME_W32_P (f
))
530 /* Regenerate display palette before drawing if list of requested
531 colors has changed. */
532 if (display_info
->regen_palette
)
534 w32_regenerate_palette (f
);
535 display_info
->regen_palette
= FALSE
;
540 /* Start update of window W. */
543 x_update_window_begin (struct window
*w
)
545 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
546 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
548 /* Hide the system caret during an update. */
549 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
551 SendMessageTimeout (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0,
555 w
->output_cursor
= w
->cursor
;
559 if (f
== hlinfo
->mouse_face_mouse_frame
)
561 /* Don't do highlighting for mouse motion during the update. */
562 hlinfo
->mouse_face_defer
= true;
564 /* If F needs to be redrawn, simply forget about any prior mouse
566 if (FRAME_GARBAGED_P (f
))
567 hlinfo
->mouse_face_window
= Qnil
;
569 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
570 their mouse_face_p flag set, which means that they are always
571 unequal to rows in a desired matrix which never have that
572 flag set. So, rows containing mouse-face glyphs are never
573 scrolled, and we don't have to switch the mouse highlight off
574 here to prevent it from being scrolled. */
576 /* Can we tell that this update does not affect the window
577 where the mouse highlight is? If so, no need to turn off.
578 Likewise, don't do anything if the frame is garbaged;
579 in that case, the frame's current matrix that we would use
580 is all wrong, and we will redisplay that line anyway. */
581 if (!NILP (hlinfo
->mouse_face_window
)
582 && w
== XWINDOW (hlinfo
->mouse_face_window
))
586 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
587 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
590 if (i
< w
->desired_matrix
->nrows
)
591 clear_mouse_face (hlinfo
);
599 /* Draw a vertical window border from (x,y0) to (x,y1) */
602 w32_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
604 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
614 hdc
= get_frame_dc (f
);
615 face
= FACE_FROM_ID_OR_NULL (f
, VERTICAL_BORDER_FACE_ID
);
617 w32_fill_rect (f
, hdc
, face
->foreground
, &r
);
619 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
621 release_frame_dc (f
, hdc
);
625 /* Draw a window divider from (x0, y0) to (x1, y1) */
628 w32_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
630 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
631 HDC hdc
= get_frame_dc (f
);
632 struct face
*face
= FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_FACE_ID
);
633 struct face
*face_first
634 = FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
635 struct face
*face_last
636 = FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
637 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
638 unsigned long color_first
= (face_first
639 ? face_first
->foreground
640 : FRAME_FOREGROUND_PIXEL (f
));
641 unsigned long color_last
= (face_last
642 ? face_last
->foreground
643 : FRAME_FOREGROUND_PIXEL (f
));
645 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
648 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x0
+ 1, y1
);
649 w32_fill_area_abs (f
, hdc
, color
, x0
+ 1, y0
, x1
- 1, y1
);
650 w32_fill_area_abs (f
, hdc
, color_last
, x1
- 1, y0
, x1
, y1
);
652 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
655 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x1
, y0
+ 1);
656 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
+ 1, x1
, y1
- 1);
657 w32_fill_area_abs (f
, hdc
, color_last
, x0
, y1
- 1, x1
, y1
);
660 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
, x1
, y1
);
662 release_frame_dc (f
, hdc
);
665 /* End update of window W.
667 Draw vertical borders between horizontally adjacent windows, and
668 display W's cursor if CURSOR_ON_P is non-zero.
670 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
671 glyphs in mouse-face were overwritten. In that case we have to
672 make sure that the mouse-highlight is properly redrawn.
674 W may be a menu bar pseudo-window in case we don't have X toolkit
675 support. Such windows don't have a cursor, so don't display it
679 x_update_window_end (struct window
*w
, bool cursor_on_p
,
680 bool mouse_face_overwritten_p
)
682 if (!w
->pseudo_window_p
)
687 display_and_set_cursor (w
, true,
688 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
689 w
->output_cursor
.x
, w
->output_cursor
.y
);
691 if (draw_window_fringes (w
, true))
693 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
694 x_draw_right_divider (w
);
696 x_draw_vertical_border (w
);
702 /* If a row with mouse-face was overwritten, arrange for
703 XTframe_up_to_date to redisplay the mouse highlight. */
704 if (mouse_face_overwritten_p
)
706 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
708 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
709 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
710 hlinfo
->mouse_face_window
= Qnil
;
713 /* Unhide the caret. This won't actually show the cursor, unless it
714 was visible before the corresponding call to HideCaret in
715 x_update_window_begin. */
716 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
718 SendMessageTimeout (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0,
724 /* End update of frame F. This function is installed as a hook in
728 x_update_end (struct frame
*f
)
730 if (! FRAME_W32_P (f
))
733 /* Mouse highlight may be displayed again. */
734 MOUSE_HL_INFO (f
)->mouse_face_defer
= false;
738 /* This function is called from various places in xdisp.c
739 whenever a complete update has been performed. */
742 w32_frame_up_to_date (struct frame
*f
)
745 FRAME_MOUSE_UPDATE (f
);
749 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
750 arrow bitmaps, or clear the fringes if no bitmaps are required
751 before DESIRED_ROW is made current. This function is called from
752 update_window_line only if it is known that there are differences
753 between bitmaps to be drawn between current row and DESIRED_ROW. */
756 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
763 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
764 desired_row
->redraw_fringe_bitmaps_p
= true;
766 /* When a window has disappeared, make sure that no rest of
767 full-width rows stays visible in the internal border. Could
768 check here if updated window is the leftmost/rightmost window,
769 but I guess it's not worth doing since vertically split windows
770 are almost never used, internal border is rarely set, and the
771 overhead is very small. */
772 if (windows_or_buffers_changed
773 && desired_row
->full_width_p
774 && (f
= XFRAME (w
->frame
),
775 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
777 && (height
= desired_row
->visible_height
,
780 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
784 HDC hdc
= get_frame_dc (f
);
785 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
786 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
788 release_frame_dc (f
, hdc
);
795 /* Draw the bitmap WHICH in one of the left or right fringes of
796 window W. ROW is the glyph row for which to display the bitmap; it
797 determines the vertical position at which the bitmap has to be
801 w32_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
,
802 struct draw_fringe_bitmap_params
*p
)
804 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
806 struct face
*face
= p
->face
;
808 hdc
= get_frame_dc (f
);
810 /* Must clip because of partially visible lines. */
811 w32_clip_to_row (w
, row
, ANY_AREA
, hdc
);
813 if (p
->bx
>= 0 && !p
->overlay_p
)
814 w32_fill_area (f
, hdc
, face
->background
,
815 p
->bx
, p
->by
, p
->nx
, p
->ny
);
817 if (p
->which
&& p
->which
< max_fringe_bmp
)
819 HBITMAP pixmap
= fringe_bmp
[p
->which
];
823 compat_hdc
= CreateCompatibleDC (hdc
);
827 horig_obj
= SelectObject (compat_hdc
, pixmap
);
829 /* Paint overlays transparently. */
832 HBRUSH h_brush
, h_orig_brush
;
834 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
835 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
836 h_brush
= CreateSolidBrush (face
->foreground
);
837 h_orig_brush
= SelectObject (hdc
, h_brush
);
839 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
840 compat_hdc
, 0, p
->dh
,
842 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
843 compat_hdc
, 0, p
->dh
,
845 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
846 compat_hdc
, 0, p
->dh
,
849 SelectObject (hdc
, h_orig_brush
);
850 DeleteObject (h_brush
);
854 SetTextColor (hdc
, face
->background
);
855 SetBkColor (hdc
, (p
->cursor_p
856 ? f
->output_data
.w32
->cursor_pixel
857 : face
->foreground
));
859 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
860 compat_hdc
, 0, p
->dh
,
864 SelectObject (compat_hdc
, horig_obj
);
865 DeleteDC (compat_hdc
);
869 w32_set_clip_rectangle (hdc
, NULL
);
871 release_frame_dc (f
, hdc
);
875 w32_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
877 if (which
>= max_fringe_bmp
)
879 int i
= max_fringe_bmp
;
880 max_fringe_bmp
= which
+ 20;
881 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
882 while (i
< max_fringe_bmp
)
886 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
890 w32_destroy_fringe_bitmap (int which
)
892 if (which
>= max_fringe_bmp
)
895 if (fringe_bmp
[which
])
896 DeleteObject (fringe_bmp
[which
]);
897 fringe_bmp
[which
] = 0;
900 /***********************************************************************
902 ***********************************************************************/
904 /* Function prototypes of this page. */
906 static void x_set_glyph_string_clipping (struct glyph_string
*);
907 static void x_set_glyph_string_gc (struct glyph_string
*);
908 static void x_draw_glyph_string_background (struct glyph_string
*,
910 static void x_draw_glyph_string_foreground (struct glyph_string
*);
911 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
912 static void x_draw_glyph_string_box (struct glyph_string
*);
913 static void x_draw_glyph_string (struct glyph_string
*);
914 static void x_set_cursor_gc (struct glyph_string
*);
915 static void x_set_mode_line_face_gc (struct glyph_string
*);
916 static void x_set_mouse_face_gc (struct glyph_string
*);
917 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
918 static void w32_setup_relief_color (struct frame
*, struct relief
*,
919 double, int, COLORREF
);
920 static void x_setup_relief_colors (struct glyph_string
*);
921 static void x_draw_image_glyph_string (struct glyph_string
*);
922 static void x_draw_image_relief (struct glyph_string
*);
923 static void x_draw_image_foreground (struct glyph_string
*);
924 static void w32_draw_image_foreground_1 (struct glyph_string
*, HBITMAP
);
925 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
927 static void w32_draw_relief_rect (struct frame
*, int, int, int, int,
928 int, int, int, int, int, int,
930 static void w32_draw_box_rect (struct glyph_string
*, int, int, int, int,
931 int, bool, bool, RECT
*);
934 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
938 x_set_cursor_gc (struct glyph_string
*s
)
940 if (s
->font
== FRAME_FONT (s
->f
)
941 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
942 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
944 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
947 /* Cursor on non-default face: must merge. */
951 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
952 xgcv
.foreground
= s
->face
->background
;
954 /* If the glyph would be invisible, try a different foreground. */
955 if (xgcv
.foreground
== xgcv
.background
)
956 xgcv
.foreground
= s
->face
->foreground
;
957 if (xgcv
.foreground
== xgcv
.background
)
958 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
959 if (xgcv
.foreground
== xgcv
.background
)
960 xgcv
.foreground
= s
->face
->foreground
;
962 /* Make sure the cursor is distinct from text in this face. */
963 if (xgcv
.background
== s
->face
->background
964 && xgcv
.foreground
== s
->face
->foreground
)
966 xgcv
.background
= s
->face
->foreground
;
967 xgcv
.foreground
= s
->face
->background
;
970 IF_DEBUG (x_check_font (s
->f
, s
->font
));
972 mask
= GCForeground
| GCBackground
| GCFont
;
974 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
975 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
978 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
979 = XCreateGC (NULL
, FRAME_W32_WINDOW (s
->f
), mask
, &xgcv
);
981 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
986 /* Set up S->gc of glyph string S for drawing text in mouse face. */
989 x_set_mouse_face_gc (struct glyph_string
*s
)
994 /* What face has to be used last for the mouse face? */
995 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
996 face
= FACE_FROM_ID_OR_NULL (s
->f
, face_id
);
998 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1000 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1001 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1003 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1004 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1005 prepare_face_for_display (s
->f
, s
->face
);
1007 /* If font in this face is same as S->font, use it. */
1008 if (s
->font
== s
->face
->font
)
1009 s
->gc
= s
->face
->gc
;
1012 /* Otherwise construct scratch_cursor_gc with values from FACE
1017 xgcv
.background
= s
->face
->background
;
1018 xgcv
.foreground
= s
->face
->foreground
;
1019 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1020 xgcv
.font
= s
->font
;
1021 mask
= GCForeground
| GCBackground
| GCFont
;
1023 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1024 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1027 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1028 = XCreateGC (NULL
, FRAME_W32_WINDOW (s
->f
), mask
, &xgcv
);
1030 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1033 eassert (s
->gc
!= 0);
1037 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1038 Faces to use in the mode line have already been computed when the
1039 matrix was built, so there isn't much to do, here. */
1042 x_set_mode_line_face_gc (struct glyph_string
*s
)
1044 s
->gc
= s
->face
->gc
;
1048 /* Set S->gc of glyph string S for drawing that glyph string. Set
1049 S->stippled_p to a non-zero value if the face of S has a stipple
1053 x_set_glyph_string_gc (struct glyph_string
*s
)
1055 prepare_face_for_display (s
->f
, s
->face
);
1057 if (s
->hl
== DRAW_NORMAL_TEXT
)
1059 s
->gc
= s
->face
->gc
;
1060 s
->stippled_p
= s
->face
->stipple
!= 0;
1062 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1064 x_set_mode_line_face_gc (s
);
1065 s
->stippled_p
= s
->face
->stipple
!= 0;
1067 else if (s
->hl
== DRAW_CURSOR
)
1069 x_set_cursor_gc (s
);
1070 s
->stippled_p
= false;
1072 else if (s
->hl
== DRAW_MOUSE_FACE
)
1074 x_set_mouse_face_gc (s
);
1075 s
->stippled_p
= s
->face
->stipple
!= 0;
1077 else if (s
->hl
== DRAW_IMAGE_RAISED
1078 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1080 s
->gc
= s
->face
->gc
;
1081 s
->stippled_p
= s
->face
->stipple
!= 0;
1086 /* GC must have been set. */
1087 eassert (s
->gc
!= 0);
1091 /* Set clipping for output of glyph string S. S may be part of a mode
1092 line or menu if we don't have X toolkit support. */
1095 x_set_glyph_string_clipping (struct glyph_string
*s
)
1098 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1101 w32_set_clip_rectangle (s
->hdc
, r
);
1104 HRGN clip1
= CreateRectRgnIndirect (r
);
1105 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
1106 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
1107 SelectClipRgn (s
->hdc
, clip1
);
1108 DeleteObject (clip1
);
1109 DeleteObject (clip2
);
1114 /* Set SRC's clipping for output of glyph string DST. This is called
1115 when we are drawing DST's left_overhang or right_overhang only in
1119 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
,
1120 struct glyph_string
*dst
)
1125 r
.right
= r
.left
+ src
->width
;
1127 r
.bottom
= r
.top
+ src
->height
;
1130 w32_set_clip_rectangle (dst
->hdc
, &r
);
1134 Compute left and right overhang of glyph string S. */
1137 w32_compute_glyph_string_overhangs (struct glyph_string
*s
)
1140 && s
->first_glyph
->type
== CHAR_GLYPH
1141 && !s
->font_not_found_p
)
1143 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1144 struct font
*font
= s
->font
;
1145 struct font_metrics metrics
;
1148 for (i
= 0; i
< s
->nchars
; i
++)
1149 code
[i
] = s
->char2b
[i
];
1150 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1151 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1152 ? metrics
.rbearing
- metrics
.width
: 0);
1153 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1157 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1158 s
->left_overhang
= -s
->cmp
->lbearing
;
1162 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1165 x_clear_glyph_string_rect (struct glyph_string
*s
,
1166 int x
, int y
, int w
, int h
)
1173 /* Take clipping into account. */
1174 if (s
->gc
->clip_mask
== Rect
)
1176 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1177 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1178 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1179 - s
->gc
->clip_rectangle
.left
);
1180 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1181 - s
->gc
->clip_rectangle
.top
);
1184 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1189 /* Draw the background of glyph_string S. If S->background_filled_p
1190 is non-zero don't draw it. FORCE_P non-zero means draw the
1191 background even if it wouldn't be drawn normally. This is used
1192 when a string preceding S draws into the background of S, or S
1193 contains the first component of a composition. */
1196 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1198 /* Nothing to do if background has already been drawn or if it
1199 shouldn't be drawn in the first place. */
1200 if (!s
->background_filled_p
)
1202 int box_line_width
= max (s
->face
->box_line_width
, 0);
1204 #if 0 /* TODO: stipple */
1207 /* Fill background with a stipple pattern. */
1208 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1209 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), s
->gc
, s
->x
,
1210 s
->y
+ box_line_width
,
1211 s
->background_width
,
1212 s
->height
- 2 * box_line_width
);
1213 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1214 s
->background_filled_p
= true;
1218 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1219 /* When xdisp.c ignores FONT_HEIGHT, we cannot trust
1220 font dimensions, since the actual glyphs might be
1221 much smaller. So in that case we always clear the
1222 rectangle with background color. */
1223 || FONT_TOO_HIGH (s
->font
)
1224 || s
->font_not_found_p
1225 || s
->extends_to_end_of_line_p
1228 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1229 s
->background_width
,
1230 s
->height
- 2 * box_line_width
);
1231 s
->background_filled_p
= true;
1237 /* Draw the foreground of glyph string S. */
1240 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1244 /* If first glyph of S has a left box line, start drawing the text
1245 of S to the right of that box line. */
1246 if (s
->face
->box
!= FACE_NO_BOX
1247 && s
->first_glyph
->left_box_line_p
)
1248 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1252 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1253 SetBkColor (s
->hdc
, s
->gc
->background
);
1254 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1256 /* Draw characters of S as rectangles if S's font could not be
1258 if (s
->font_not_found_p
)
1260 for (i
= 0; i
< s
->nchars
; ++i
)
1262 struct glyph
*g
= s
->first_glyph
+ i
;
1264 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1266 x
+= g
->pixel_width
;
1271 struct font
*font
= s
->font
;
1272 int boff
= font
->baseline_offset
;
1276 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1278 if (font
->vertical_centering
)
1279 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1281 y
= s
->ybase
- boff
;
1283 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1284 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, false);
1286 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, true);
1287 if (s
->face
->overstrike
)
1288 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, false);
1290 SelectObject (s
->hdc
, old_font
);
1294 /* Draw the foreground of composite glyph string S. */
1297 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1300 struct font
*font
= s
->font
;
1302 /* If first glyph of S has a left box line, start drawing the text
1303 of S to the right of that box line. */
1304 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1305 && s
->first_glyph
->left_box_line_p
)
1306 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1310 /* S is a glyph string for a composition. S->cmp_from is the index
1311 of the first character drawn for glyphs of this composition.
1312 S->cmp_from == 0 means we are drawing the very first character of
1313 this composition. */
1315 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1316 SetBkColor (s
->hdc
, s
->gc
->background
);
1317 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1319 /* Draw a rectangle for the composition if the font for the very
1320 first character of the composition could not be loaded. */
1321 if (s
->font_not_found_p
)
1323 if (s
->cmp_from
== 0)
1324 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1327 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1332 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1334 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1335 /* TAB in a composition means display glyphs with padding
1336 space on the left or right. */
1337 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1339 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1340 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1342 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, false);
1343 if (s
->face
->overstrike
)
1344 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, false);
1346 SelectObject (s
->hdc
, old_font
);
1350 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1356 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1358 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1360 glyph
= LGSTRING_GLYPH (gstring
, i
);
1361 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1362 width
+= LGLYPH_WIDTH (glyph
);
1365 int xoff
, yoff
, wadjust
;
1369 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1372 xoff
= LGLYPH_XOFF (glyph
);
1373 yoff
= LGLYPH_YOFF (glyph
);
1374 wadjust
= LGLYPH_WADJUST (glyph
);
1375 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, false);
1382 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1384 SelectObject (s
->hdc
, old_font
);
1389 /* Draw the foreground of glyph string S for glyphless characters. */
1392 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1394 struct glyph
*glyph
= s
->first_glyph
;
1397 bool with_background
;
1399 /* If first glyph of S has a left box line, start drawing the text
1400 of S to the right of that box line. */
1401 if (s
->face
->box
!= FACE_NO_BOX
1402 && s
->first_glyph
->left_box_line_p
)
1403 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1407 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1408 SetBkColor (s
->hdc
, s
->gc
->background
);
1409 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1412 with_background
= ((s
->for_overlaps
1413 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))) == 0;
1414 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1416 char buf
[7], *str
= NULL
;
1417 int len
= glyph
->u
.glyphless
.len
;
1419 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1422 && CHAR_TABLE_P (Vglyphless_char_display
)
1423 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1427 = (! glyph
->u
.glyphless
.for_no_font
1428 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1429 glyph
->u
.glyphless
.ch
)
1430 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1431 if (STRINGP (acronym
))
1432 str
= SSDATA (acronym
);
1435 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1437 sprintf ((char *) buf
, "%0*X",
1438 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1439 (unsigned int) glyph
->u
.glyphless
.ch
);
1443 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1444 w32_draw_rectangle (s
->hdc
, s
->gc
,
1445 x
, s
->ybase
- glyph
->ascent
,
1446 glyph
->pixel_width
- 1,
1447 glyph
->ascent
+ glyph
->descent
- 1);
1450 struct font
*font
= s
->font
;
1451 int upper_len
= (len
+ 1) / 2;
1455 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1456 /* It is certain that all LEN characters in STR are ASCII. */
1457 for (j
= 0; j
< len
; j
++)
1459 code
= font
->driver
->encode_char (font
, str
[j
]);
1460 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1462 font
->driver
->draw (s
, 0, upper_len
,
1463 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1464 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1466 font
->driver
->draw (s
, upper_len
, len
,
1467 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1468 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1470 SelectObject (s
->hdc
, old_font
);
1472 x
+= glyph
->pixel_width
;
1477 /* Brightness beyond which a color won't have its highlight brightness
1480 Nominally, highlight colors for `3d' faces are calculated by
1481 brightening an object's color by a constant scale factor, but this
1482 doesn't yield good results for dark colors, so for colors whose
1483 brightness is less than this value (on a scale of 0-255) have to
1484 use an additional additive factor.
1486 The value here is set so that the default menu-bar/mode-line color
1487 (grey75) will not have its highlights changed at all. */
1488 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1491 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1492 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1493 If this produces the same color as COLOR, try a color where all RGB
1494 values have DELTA added. Return the allocated color in *COLOR.
1495 DISPLAY is the X display, CMAP is the colormap to operate on.
1496 Value is non-zero if successful. */
1499 w32_alloc_lighter_color (struct frame
*f
, COLORREF
*color
,
1500 double factor
, int delta
)
1505 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1508 /* Change RGB values by specified FACTOR. Avoid overflow! */
1509 eassert (factor
>= 0);
1510 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1511 min (0xff, factor
* GetGValue (*color
)),
1512 min (0xff, factor
* GetBValue (*color
)));
1514 /* Calculate brightness of COLOR. */
1515 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1516 + GetBValue (*color
)) / 6;
1518 /* We only boost colors that are darker than
1519 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1520 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1521 /* Make an additive adjustment to NEW, because it's dark enough so
1522 that scaling by FACTOR alone isn't enough. */
1524 /* How far below the limit this color is (0 - 1, 1 being darker). */
1525 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1526 /* The additive adjustment. */
1527 int min_delta
= delta
* dimness
* factor
/ 2;
1530 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1531 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1532 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1534 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1535 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1536 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1540 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1541 max (0, min (0xff, delta
+ GetGValue (*color
))),
1542 max (0, min (0xff, delta
+ GetBValue (*color
))));
1544 /* TODO: Map to palette and retry with delta if same? */
1545 /* TODO: Free colors (if using palette)? */
1555 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1556 colors in COLORS. On W32, we no longer try to map colors to
1559 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1563 for (i
= 0; i
< ncolors
; i
++)
1565 DWORD pixel
= colors
[i
].pixel
;
1566 /* Convert to a 16 bit value in range 0 - 0xffff. */
1567 colors
[i
].red
= GetRValue (pixel
) * 257;
1568 colors
[i
].green
= GetGValue (pixel
) * 257;
1569 colors
[i
].blue
= GetBValue (pixel
) * 257;
1574 x_query_color (struct frame
*f
, XColor
*color
)
1576 x_query_colors (f
, color
, 1);
1580 /* Set up the foreground color for drawing relief lines of glyph
1581 string S. RELIEF is a pointer to a struct relief containing the GC
1582 with which lines will be drawn. Use a color that is FACTOR or
1583 DELTA lighter or darker than the relief's background which is found
1584 in S->f->output_data.x->relief_background. If such a color cannot
1585 be allocated, use DEFAULT_PIXEL, instead. */
1588 w32_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
1589 int delta
, COLORREF default_pixel
)
1592 struct w32_output
*di
= f
->output_data
.w32
;
1593 unsigned long mask
= GCForeground
;
1595 COLORREF background
= di
->relief_background
;
1597 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1600 /* TODO: Free colors (if using palette)? */
1602 /* Allocate new color. */
1603 xgcv
.foreground
= default_pixel
;
1605 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1606 xgcv
.foreground
= relief
->pixel
= pixel
;
1608 if (relief
->gc
== 0)
1610 #if 0 /* TODO: stipple */
1611 xgcv
.stipple
= dpyinfo
->gray
;
1614 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1617 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1621 /* Set up colors for the relief lines around glyph string S. */
1624 x_setup_relief_colors (struct glyph_string
*s
)
1626 struct w32_output
*di
= s
->f
->output_data
.w32
;
1629 if (s
->face
->use_box_color_for_shadows_p
)
1630 color
= s
->face
->box_color
;
1631 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1633 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1634 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1636 color
= s
->gc
->background
;
1638 if (di
->white_relief
.gc
== 0
1639 || color
!= di
->relief_background
)
1641 di
->relief_background
= color
;
1642 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1643 WHITE_PIX_DEFAULT (s
->f
));
1644 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1645 BLACK_PIX_DEFAULT (s
->f
));
1650 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1651 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1652 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1653 relief. LEFT_P non-zero means draw a relief on the left side of
1654 the rectangle. RIGHT_P non-zero means draw a relief on the right
1655 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1659 w32_draw_relief_rect (struct frame
*f
,
1660 int left_x
, int top_y
, int right_x
, int bottom_y
,
1661 int width
, int raised_p
,
1662 int top_p
, int bot_p
, int left_p
, int right_p
,
1667 HDC hdc
= get_frame_dc (f
);
1670 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1672 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1674 w32_set_clip_rectangle (hdc
, clip_rect
);
1678 for (i
= 0; i
< width
; ++i
)
1679 w32_fill_area (f
, hdc
, gc
.foreground
,
1680 left_x
+ i
* left_p
, top_y
+ i
,
1681 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1685 for (i
= 0; i
< width
; ++i
)
1686 w32_fill_area (f
, hdc
, gc
.foreground
,
1687 left_x
+ i
, top_y
+ (i
+ 1) * top_p
, 1,
1688 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1691 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1693 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1697 for (i
= 0; i
< width
; ++i
)
1698 w32_fill_area (f
, hdc
, gc
.foreground
,
1699 left_x
+ i
* left_p
, bottom_y
- i
,
1700 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1704 for (i
= 0; i
< width
; ++i
)
1705 w32_fill_area (f
, hdc
, gc
.foreground
,
1706 right_x
- i
, top_y
+ (i
+ 1) * top_p
, 1,
1707 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1709 w32_set_clip_rectangle (hdc
, NULL
);
1711 release_frame_dc (f
, hdc
);
1715 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1716 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1717 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1718 left side of the rectangle. RIGHT_P non-zero means draw a line
1719 on the right side of the rectangle. CLIP_RECT is the clipping
1720 rectangle to use when drawing. */
1723 w32_draw_box_rect (struct glyph_string
*s
,
1724 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1725 bool left_p
, bool right_p
, RECT
*clip_rect
)
1727 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1730 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1731 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1736 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1737 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1741 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1742 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1747 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1748 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1751 w32_set_clip_rectangle (s
->hdc
, NULL
);
1755 /* Draw a box around glyph string S. */
1758 x_draw_glyph_string_box (struct glyph_string
*s
)
1760 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
;
1761 bool left_p
, right_p
, raised_p
;
1762 struct glyph
*last_glyph
;
1765 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1766 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1767 : window_box_right (s
->w
, s
->area
));
1769 /* The glyph that may have a right box line. */
1770 last_glyph
= (s
->cmp
|| s
->img
1772 : s
->first_glyph
+ s
->nchars
- 1);
1774 width
= eabs (s
->face
->box_line_width
);
1775 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1777 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1779 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1781 bottom_y
= top_y
+ s
->height
- 1;
1783 left_p
= (s
->first_glyph
->left_box_line_p
1784 || (s
->hl
== DRAW_MOUSE_FACE
1786 || s
->prev
->hl
!= s
->hl
)));
1787 right_p
= (last_glyph
->right_box_line_p
1788 || (s
->hl
== DRAW_MOUSE_FACE
1790 || s
->next
->hl
!= s
->hl
)));
1792 get_glyph_string_clip_rect (s
, &clip_rect
);
1794 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1795 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1796 left_p
, right_p
, &clip_rect
);
1799 x_setup_relief_colors (s
);
1800 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1801 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1806 /* Draw foreground of image glyph string S. */
1809 x_draw_image_foreground (struct glyph_string
*s
)
1812 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1814 /* If first glyph of S has a left box line, start drawing it to the
1815 right of that line. */
1816 if (s
->face
->box
!= FACE_NO_BOX
1817 && s
->first_glyph
->left_box_line_p
1819 x
+= eabs (s
->face
->box_line_width
);
1821 /* If there is a margin around the image, adjust x- and y-position
1823 if (s
->slice
.x
== 0)
1824 x
+= s
->img
->hmargin
;
1825 if (s
->slice
.y
== 0)
1826 y
+= s
->img
->vmargin
;
1832 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
1833 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1834 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
1835 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1836 SetBkColor (compat_hdc
, RGB (255, 255, 255));
1837 SetTextColor (s
->hdc
, RGB (0, 0, 0));
1838 x_set_glyph_string_clipping (s
);
1842 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
1843 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1845 SetTextColor (s
->hdc
, RGB (255, 255, 255));
1846 SetBkColor (s
->hdc
, RGB (0, 0, 0));
1848 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1849 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1850 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1851 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1852 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1853 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1855 SelectObject (mask_dc
, mask_orig_obj
);
1860 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1861 SetBkColor (s
->hdc
, s
->gc
->background
);
1863 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1864 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1866 /* When the image has a mask, we can expect that at
1867 least part of a mouse highlight or a block cursor will
1868 be visible. If the image doesn't have a mask, make
1869 a block cursor visible by drawing a rectangle around
1870 the image. I believe it's looking better if we do
1871 nothing here for mouse-face. */
1872 if (s
->hl
== DRAW_CURSOR
)
1874 int r
= s
->img
->relief
;
1876 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
1877 s
->slice
.width
+ r
*2 - 1,
1878 s
->slice
.height
+ r
*2 - 1);
1882 w32_set_clip_rectangle (s
->hdc
, NULL
);
1883 SelectObject (s
->hdc
, orig_brush
);
1884 DeleteObject (fg_brush
);
1885 SelectObject (compat_hdc
, orig_obj
);
1886 DeleteDC (compat_hdc
);
1889 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
1890 s
->slice
.width
- 1, s
->slice
.height
- 1);
1892 RestoreDC (s
->hdc
,-1);
1896 /* Draw a relief around the image glyph string S. */
1899 x_draw_image_relief (struct glyph_string
*s
)
1901 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
1902 int extra_x
, extra_y
;
1905 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1907 /* If first glyph of S has a left box line, start drawing it to the
1908 right of that line. */
1909 if (s
->face
->box
!= FACE_NO_BOX
1910 && s
->first_glyph
->left_box_line_p
1912 x
+= eabs (s
->face
->box_line_width
);
1914 /* If there is a margin around the image, adjust x- and y-position
1916 if (s
->slice
.x
== 0)
1917 x
+= s
->img
->hmargin
;
1918 if (s
->slice
.y
== 0)
1919 y
+= s
->img
->vmargin
;
1921 if (s
->hl
== DRAW_IMAGE_SUNKEN
1922 || s
->hl
== DRAW_IMAGE_RAISED
)
1924 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
1925 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
1926 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
1930 thick
= eabs (s
->img
->relief
);
1931 raised_p
= s
->img
->relief
> 0;
1934 x1
= x
+ s
->slice
.width
- 1;
1935 y1
= y
+ s
->slice
.height
- 1;
1937 extra_x
= extra_y
= 0;
1938 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
1940 if (CONSP (Vtool_bar_button_margin
)
1941 && INTEGERP (XCAR (Vtool_bar_button_margin
))
1942 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
1944 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
1945 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
1947 else if (INTEGERP (Vtool_bar_button_margin
))
1948 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
1951 top_p
= bot_p
= left_p
= right_p
= 0;
1953 if (s
->slice
.x
== 0)
1954 x
-= thick
+ extra_x
, left_p
= 1;
1955 if (s
->slice
.y
== 0)
1956 y
-= thick
+ extra_y
, top_p
= 1;
1957 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
1958 x1
+= thick
+ extra_x
, right_p
= 1;
1959 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
1960 y1
+= thick
+ extra_y
, bot_p
= 1;
1962 x_setup_relief_colors (s
);
1963 get_glyph_string_clip_rect (s
, &r
);
1964 w32_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
1965 top_p
, bot_p
, left_p
, right_p
, &r
);
1969 /* Draw the foreground of image glyph string S to PIXMAP. */
1972 w32_draw_image_foreground_1 (struct glyph_string
*s
, HBITMAP pixmap
)
1974 HDC hdc
= CreateCompatibleDC (s
->hdc
);
1975 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
1977 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1979 /* If first glyph of S has a left box line, start drawing it to the
1980 right of that line. */
1981 if (s
->face
->box
!= FACE_NO_BOX
1982 && s
->first_glyph
->left_box_line_p
1984 x
+= eabs (s
->face
->box_line_width
);
1986 /* If there is a margin around the image, adjust x- and y-position
1988 if (s
->slice
.x
== 0)
1989 x
+= s
->img
->hmargin
;
1990 if (s
->slice
.y
== 0)
1991 y
+= s
->img
->vmargin
;
1995 HDC compat_hdc
= CreateCompatibleDC (hdc
);
1996 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1997 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
1998 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2002 HDC mask_dc
= CreateCompatibleDC (hdc
);
2003 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2005 SetTextColor (hdc
, RGB (0, 0, 0));
2006 SetBkColor (hdc
, RGB (255, 255, 255));
2007 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2008 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2009 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2010 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2011 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2012 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2014 SelectObject (mask_dc
, mask_orig_obj
);
2019 SetTextColor (hdc
, s
->gc
->foreground
);
2020 SetBkColor (hdc
, s
->gc
->background
);
2022 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2023 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2025 /* When the image has a mask, we can expect that at
2026 least part of a mouse highlight or a block cursor will
2027 be visible. If the image doesn't have a mask, make
2028 a block cursor visible by drawing a rectangle around
2029 the image. I believe it's looking better if we do
2030 nothing here for mouse-face. */
2031 if (s
->hl
== DRAW_CURSOR
)
2033 int r
= s
->img
->relief
;
2035 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2036 s
->slice
.width
+ r
*2 - 1,
2037 s
->slice
.height
+ r
*2 - 1);
2041 SelectObject (hdc
, orig_brush
);
2042 DeleteObject (fg_brush
);
2043 SelectObject (compat_hdc
, orig_obj
);
2044 DeleteDC (compat_hdc
);
2047 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2048 s
->slice
.width
- 1, s
->slice
.height
- 1);
2050 SelectObject (hdc
, orig_hdc_obj
);
2055 /* Draw part of the background of glyph string S. X, Y, W, and H
2056 give the rectangle to draw. */
2059 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2061 #if 0 /* TODO: stipple */
2064 /* Fill background with a stipple pattern. */
2065 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2066 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), s
->gc
, x
, y
, w
, h
);
2067 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2071 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2075 /* Draw image glyph string S.
2078 s->x +-------------------------
2081 | +-------------------------
2084 | | +-------------------
2090 x_draw_image_glyph_string (struct glyph_string
*s
)
2093 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2094 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2099 if (s
->slice
.y
== 0)
2100 height
-= box_line_vwidth
;
2101 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2102 height
-= box_line_vwidth
;
2104 /* Fill background with face under the image. Do it only if row is
2105 taller than image or if image has a clip mask to reduce
2107 s
->stippled_p
= s
->face
->stipple
!= 0;
2108 if (height
> s
->slice
.height
2112 || s
->img
->pixmap
== 0
2113 || s
->width
!= s
->background_width
)
2115 width
= s
->background_width
;
2117 if (s
->first_glyph
->left_box_line_p
2120 x
+= box_line_hwidth
;
2121 width
-= box_line_hwidth
;
2125 if (s
->slice
.y
== 0)
2126 y
+= box_line_vwidth
;
2128 #if 0 /* TODO: figure out if we need to do this on Windows. */
2131 /* Create a pixmap as large as the glyph string. Fill it
2132 with the background color. Copy the image to it, using
2133 its mask. Copy the temporary pixmap to the display. */
2134 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2135 int depth
= DefaultDepthOfScreen (screen
);
2137 /* Create a pixmap as large as the glyph string. */
2138 pixmap
= XCreatePixmap (s
->display
, FRAME_W32_WINDOW (s
->f
),
2139 s
->background_width
,
2142 /* Don't clip in the following because we're working on the
2144 XSetClipMask (s
->display
, s
->gc
, None
);
2146 /* Fill the pixmap with the background color/stipple. */
2149 /* Fill background with a stipple pattern. */
2150 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2151 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2152 0, 0, s
->background_width
, s
->height
);
2153 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2158 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2160 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2161 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2162 0, 0, s
->background_width
, s
->height
);
2163 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2168 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
2170 s
->background_filled_p
= true;
2173 /* Draw the foreground. */
2176 w32_draw_image_foreground_1 (s
, pixmap
);
2177 x_set_glyph_string_clipping (s
);
2179 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2180 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2181 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2182 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2184 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2185 SetBkColor (s
->hdc
, s
->gc
->background
);
2186 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2187 compat_hdc
, 0, 0, SRCCOPY
);
2189 SelectObject (s
->hdc
, orig_brush
);
2190 DeleteObject (fg_brush
);
2191 SelectObject (compat_hdc
, orig_obj
);
2192 DeleteDC (compat_hdc
);
2194 DeleteObject (pixmap
);
2198 x_draw_image_foreground (s
);
2200 /* If we must draw a relief around the image, do it. */
2202 || s
->hl
== DRAW_IMAGE_RAISED
2203 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2204 x_draw_image_relief (s
);
2208 /* Draw stretch glyph string S. */
2211 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2213 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2215 if (s
->hl
== DRAW_CURSOR
2216 && !x_stretch_cursor_p
)
2218 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2219 wide as the stretch glyph. */
2220 int width
, background_width
= s
->background_width
;
2223 if (!s
->row
->reversed_p
)
2225 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2229 background_width
-= left_x
- x
;
2235 /* In R2L rows, draw the cursor on the right edge of the
2237 int right_x
= window_box_right (s
->w
, TEXT_AREA
);
2239 if (x
+ background_width
> right_x
)
2240 background_width
-= x
- right_x
;
2241 x
+= background_width
;
2243 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2244 if (s
->row
->reversed_p
)
2248 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2250 /* Clear rest using the GC of the original non-cursor face. */
2251 if (width
< background_width
)
2253 XGCValues
*gc
= s
->face
->gc
;
2255 int w
= background_width
- width
, h
= s
->height
;
2259 if (!s
->row
->reversed_p
)
2263 if (s
->row
->mouse_face_p
2264 && cursor_in_mouse_face_p (s
->w
))
2266 x_set_mouse_face_gc (s
);
2272 get_glyph_string_clip_rect (s
, &r
);
2273 w32_set_clip_rectangle (hdc
, &r
);
2275 #if 0 /* TODO: stipple */
2276 if (s
->face
->stipple
)
2278 /* Fill background with a stipple pattern. */
2279 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2280 XFillRectangle (s
->display
, FRAME_W32_WINDOW (s
->f
), gc
, x
, y
, w
, h
);
2281 XSetFillStyle (s
->display
, gc
, FillSolid
);
2286 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2290 else if (!s
->background_filled_p
)
2292 int background_width
= s
->background_width
;
2293 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2295 /* Don't draw into left margin, fringe or scrollbar area
2296 except for header line and mode line. */
2297 if (x
< left_x
&& !s
->row
->mode_line_p
)
2299 background_width
-= left_x
- x
;
2302 if (background_width
> 0)
2303 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2306 s
->background_filled_p
= true;
2310 /* Draw glyph string S. */
2313 x_draw_glyph_string (struct glyph_string
*s
)
2315 bool relief_drawn_p
= 0;
2317 /* If S draws into the background of its successor, draw the
2318 background of the successor first so that S can draw into it.
2319 This makes S->next use XDrawString instead of XDrawImageString. */
2320 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2323 struct glyph_string
*next
;
2324 for (width
= 0, next
= s
->next
;
2325 next
&& width
< s
->right_overhang
;
2326 width
+= next
->width
, next
= next
->next
)
2327 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2329 x_set_glyph_string_gc (next
);
2330 x_set_glyph_string_clipping (next
);
2331 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2332 x_draw_stretch_glyph_string (next
);
2334 x_draw_glyph_string_background (next
, true);
2335 next
->num_clips
= 0;
2339 /* Set up S->gc, set clipping and draw S. */
2340 x_set_glyph_string_gc (s
);
2342 /* Draw relief (if any) in advance for char/composition so that the
2343 glyph string can be drawn over it. */
2344 if (!s
->for_overlaps
2345 && s
->face
->box
!= FACE_NO_BOX
2346 && (s
->first_glyph
->type
== CHAR_GLYPH
2347 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2350 x_set_glyph_string_clipping (s
);
2351 x_draw_glyph_string_background (s
, true);
2352 x_draw_glyph_string_box (s
);
2353 x_set_glyph_string_clipping (s
);
2356 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2358 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2359 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2360 /* We must clip just this glyph. left_overhang part has already
2361 drawn when s->prev was drawn, and right_overhang part will be
2362 drawn later when s->next is drawn. */
2363 x_set_glyph_string_clipping_exactly (s
, s
);
2365 x_set_glyph_string_clipping (s
);
2367 switch (s
->first_glyph
->type
)
2370 x_draw_image_glyph_string (s
);
2374 x_draw_stretch_glyph_string (s
);
2378 if (s
->for_overlaps
)
2379 s
->background_filled_p
= true;
2381 x_draw_glyph_string_background (s
, false);
2382 x_draw_glyph_string_foreground (s
);
2385 case COMPOSITE_GLYPH
:
2386 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2387 && ! s
->first_glyph
->u
.cmp
.automatic
))
2388 s
->background_filled_p
= true;
2390 x_draw_glyph_string_background (s
, true);
2391 x_draw_composite_glyph_string_foreground (s
);
2394 case GLYPHLESS_GLYPH
:
2395 if (s
->for_overlaps
)
2396 s
->background_filled_p
= true;
2398 x_draw_glyph_string_background (s
, false);
2399 x_draw_glyphless_glyph_string_foreground (s
);
2406 if (!s
->for_overlaps
)
2408 /* Draw underline. */
2409 if (s
->face
->underline_p
)
2411 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2415 if (s
->face
->underline_defaulted_p
)
2416 color
= s
->gc
->foreground
;
2418 color
= s
->face
->underline_color
;
2420 w32_draw_underwave (s
, color
);
2422 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2424 unsigned long thickness
, position
;
2427 if (s
->prev
&& s
->prev
->face
->underline_p
2428 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2430 /* We use the same underline style as the previous one. */
2431 thickness
= s
->prev
->underline_thickness
;
2432 position
= s
->prev
->underline_position
;
2436 struct font
*font
= font_for_underline_metrics (s
);
2438 /* Get the underline thickness. Default is 1 pixel. */
2439 if (font
&& font
->underline_thickness
> 0)
2440 thickness
= font
->underline_thickness
;
2443 if (x_underline_at_descent_line
)
2444 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2447 /* Get the underline position. This is the recommended
2448 vertical offset in pixels from the baseline to the top of
2449 the underline. This is a signed value according to the
2450 specs, and its default is
2452 ROUND ((maximum_descent) / 2), with
2453 ROUND (x) = floor (x + 0.5) */
2455 if (x_use_underline_position_properties
2456 && font
&& font
->underline_position
>= 0)
2457 position
= font
->underline_position
;
2459 position
= (font
->descent
+ 1) / 2;
2461 position
= max (position
, underline_minimum_offset
);
2463 /* Check the sanity of thickness and position. We should
2464 avoid drawing underline out of the current line area. */
2465 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2466 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2467 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2468 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2469 s
->underline_thickness
= thickness
;
2470 s
->underline_position
= position
;
2471 y
= s
->ybase
+ position
;
2472 if (s
->face
->underline_defaulted_p
)
2474 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2479 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2484 /* Draw overline. */
2485 if (s
->face
->overline_p
)
2487 unsigned long dy
= 0, h
= 1;
2489 if (s
->face
->overline_color_defaulted_p
)
2491 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2492 s
->y
+ dy
, s
->width
, h
);
2496 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2497 s
->y
+ dy
, s
->width
, h
);
2501 /* Draw strike-through. */
2502 if (s
->face
->strike_through_p
2503 && !FONT_TEXTMETRIC (s
->font
).tmStruckOut
)
2505 /* Y-coordinate and height of the glyph string's first
2506 glyph. We cannot use s->y and s->height because those
2507 could be larger if there are taller display elements
2508 (e.g., characters displayed with a larger font) in the
2510 int glyph_y
= s
->ybase
- s
->first_glyph
->ascent
;
2511 int glyph_height
= s
->first_glyph
->ascent
+ s
->first_glyph
->descent
;
2512 /* Strike-through width and offset from the glyph string's
2514 unsigned long h
= 1;
2515 unsigned long dy
= (glyph_height
- h
) / 2;
2517 if (s
->face
->strike_through_color_defaulted_p
)
2519 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2520 glyph_y
+ dy
, s
->width
, h
);
2524 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2525 glyph_y
+ dy
, s
->width
, h
);
2529 /* Draw relief if not yet drawn. */
2530 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2531 x_draw_glyph_string_box (s
);
2535 struct glyph_string
*prev
;
2537 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2538 if (prev
->hl
!= s
->hl
2539 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2541 /* As prev was drawn while clipped to its own area, we
2542 must draw the right_overhang part using s->hl now. */
2543 enum draw_glyphs_face save
= prev
->hl
;
2546 x_set_glyph_string_gc (prev
);
2547 x_set_glyph_string_clipping_exactly (s
, prev
);
2548 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2549 x_draw_glyph_string_foreground (prev
);
2551 x_draw_composite_glyph_string_foreground (prev
);
2552 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2554 prev
->num_clips
= 0;
2560 struct glyph_string
*next
;
2562 for (next
= s
->next
; next
; next
= next
->next
)
2563 if (next
->hl
!= s
->hl
2564 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2566 /* As next will be drawn while clipped to its own area,
2567 we must draw the left_overhang part using s->hl now. */
2568 enum draw_glyphs_face save
= next
->hl
;
2571 x_set_glyph_string_gc (next
);
2572 x_set_glyph_string_clipping_exactly (s
, next
);
2573 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2574 x_draw_glyph_string_foreground (next
);
2576 x_draw_composite_glyph_string_foreground (next
);
2577 w32_set_clip_rectangle (next
->hdc
, NULL
);
2579 next
->num_clips
= 0;
2580 next
->clip_head
= s
->next
;
2585 /* Reset clipping. */
2586 w32_set_clip_rectangle (s
->hdc
, NULL
);
2591 /* Shift display to make room for inserted glyphs. */
2594 w32_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
,
2595 int width
, int height
, int shift_by
)
2599 hdc
= get_frame_dc (f
);
2600 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2601 hdc
, x
, y
, SRCCOPY
);
2603 release_frame_dc (f
, hdc
);
2607 /* Delete N glyphs at the nominal cursor position. Not implemented
2611 x_delete_glyphs (struct frame
*f
, register int n
)
2613 if (! FRAME_W32_P (f
))
2620 /* Clear entire frame. */
2623 x_clear_frame (struct frame
*f
)
2625 if (! FRAME_W32_P (f
))
2628 /* Clearing the frame will erase any cursor, so mark them all as no
2630 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2634 w32_clear_window (f
);
2636 /* We have to clear the scroll bars, too. If we have changed
2637 colors or something like that, then they should be notified. */
2638 x_scroll_bar_clear (f
);
2644 /* Make audible bell. */
2647 w32_ring_bell (struct frame
*f
)
2651 if (FRAME_W32_P (f
) && visible_bell
)
2654 HWND hwnd
= FRAME_W32_WINDOW (f
);
2656 for (i
= 0; i
< 5; i
++)
2658 FlashWindow (hwnd
, TRUE
);
2661 FlashWindow (hwnd
, FALSE
);
2664 w32_sys_ring_bell (f
);
2669 /***********************************************************************
2671 ***********************************************************************/
2673 /* Perform an insert-lines or delete-lines operation, inserting N
2674 lines or deleting -N lines at vertical position VPOS. */
2677 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
2679 if (! FRAME_W32_P (f
))
2686 /* Scroll part of the display as described by RUN. */
2689 x_scroll_run (struct window
*w
, struct run
*run
)
2691 struct frame
*f
= XFRAME (w
->frame
);
2692 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2693 HWND hwnd
= FRAME_W32_WINDOW (f
);
2696 /* Get frame-relative bounding box of the text display area of W,
2697 without mode lines. Include in this box the left and right
2699 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
2701 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2702 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2703 bottom_y
= y
+ height
;
2707 /* Scrolling up. Make sure we don't copy part of the mode
2708 line at the bottom. */
2709 if (from_y
+ run
->height
> bottom_y
)
2710 height
= bottom_y
- from_y
;
2712 height
= run
->height
;
2713 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2717 /* Scrolling down. Make sure we don't copy over the mode line.
2719 if (to_y
+ run
->height
> bottom_y
)
2720 height
= bottom_y
- to_y
;
2722 height
= run
->height
;
2723 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2728 /* Cursor off. Will be switched on again in x_update_window_end. */
2734 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2735 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2737 from
.left
= to
.left
= x
;
2738 from
.right
= to
.right
= x
+ width
;
2740 from
.bottom
= from_y
+ height
;
2742 to
.bottom
= bottom_y
;
2744 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2745 NULL
, SW_INVALIDATE
);
2747 /* Combine this with what we expect to be dirty. This covers the
2748 case where not all of the region we expect is actually dirty. */
2749 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2751 /* If the dirty region is not what we expected, redraw the entire frame. */
2752 if (!EqualRgn (combined
, expect_dirty
))
2753 SET_FRAME_GARBAGED (f
);
2755 DeleteObject (dirty
);
2756 DeleteObject (combined
);
2760 DeleteObject (expect_dirty
);
2765 /***********************************************************************
2767 ***********************************************************************/
2770 frame_highlight (struct frame
*f
)
2772 x_update_cursor (f
, 1);
2773 x_set_frame_alpha (f
);
2777 frame_unhighlight (struct frame
*f
)
2779 x_update_cursor (f
, 1);
2780 x_set_frame_alpha (f
);
2783 /* The focus has changed. Update the frames as necessary to reflect
2784 the new situation. Note that we can't change the selected frame
2785 here, because the Lisp code we are interrupting might become confused.
2786 Each event gets marked with the frame in which it occurred, so the
2787 Lisp code can tell when the switch took place by examining the events. */
2790 x_new_focus_frame (struct w32_display_info
*dpyinfo
, struct frame
*frame
)
2792 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2794 if (frame
!= dpyinfo
->w32_focus_frame
)
2796 /* Set this before calling other routines, so that they see
2797 the correct value of w32_focus_frame. */
2798 dpyinfo
->w32_focus_frame
= frame
;
2800 if (old_focus
&& old_focus
->auto_lower
)
2801 x_lower_frame (old_focus
);
2803 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2804 dpyinfo
->w32_pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2806 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
2809 x_frame_rehighlight (dpyinfo
);
2813 /* Handle FocusIn and FocusOut state changes for FRAME.
2814 If FRAME has focus and there exists more than one frame, puts
2815 a FOCUS_IN_EVENT into *BUFP. */
2818 x_focus_changed (int type
, int state
, struct w32_display_info
*dpyinfo
,
2819 struct frame
*frame
, struct input_event
*bufp
)
2821 if (type
== WM_SETFOCUS
)
2823 if (dpyinfo
->w32_focus_event_frame
!= frame
)
2825 x_new_focus_frame (dpyinfo
, frame
);
2826 dpyinfo
->w32_focus_event_frame
= frame
;
2828 /* Don't stop displaying the initial startup message
2829 for a switch-frame event we don't need. */
2830 if (NILP (Vterminal_frame
)
2831 && CONSP (Vframe_list
)
2832 && !NILP (XCDR (Vframe_list
)))
2841 bufp
->kind
= FOCUS_IN_EVENT
;
2842 XSETFRAME (bufp
->frame_or_window
, frame
);
2845 frame
->output_data
.x
->focus_state
|= state
;
2847 /* TODO: IME focus? */
2849 else if (type
== WM_KILLFOCUS
)
2851 frame
->output_data
.x
->focus_state
&= ~state
;
2853 if (dpyinfo
->w32_focus_event_frame
== frame
)
2855 dpyinfo
->w32_focus_event_frame
= 0;
2856 x_new_focus_frame (dpyinfo
, 0);
2858 bufp
->kind
= FOCUS_OUT_EVENT
;
2859 XSETFRAME (bufp
->frame_or_window
, frame
);
2862 /* TODO: IME focus? */
2867 /* The focus may have changed. Figure out if it is a real focus change,
2868 by checking both FocusIn/Out and Enter/LeaveNotify events.
2870 Returns FOCUS_IN_EVENT event in *BUFP. */
2873 w32_detect_focus_change (struct w32_display_info
*dpyinfo
, W32Msg
*event
,
2874 struct input_event
*bufp
)
2876 struct frame
*frame
;
2878 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
2882 /* On w32, this is only called from focus events, so no switch needed. */
2883 x_focus_changed (event
->msg
.message
,
2884 (event
->msg
.message
== WM_KILLFOCUS
?
2885 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
2886 dpyinfo
, frame
, bufp
);
2891 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2894 x_mouse_leave (struct w32_display_info
*dpyinfo
)
2896 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2900 /* The focus has changed, or we have redirected a frame's focus to
2901 another frame (this happens when a frame uses a surrogate
2902 mini-buffer frame). Shift the highlight as appropriate.
2904 The FRAME argument doesn't necessarily have anything to do with which
2905 frame is being highlighted or un-highlighted; we only use it to find
2906 the appropriate X display info. */
2909 w32_frame_rehighlight (struct frame
*frame
)
2911 if (! FRAME_W32_P (frame
))
2913 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
2917 x_frame_rehighlight (struct w32_display_info
*dpyinfo
)
2919 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2921 if (dpyinfo
->w32_focus_frame
)
2923 dpyinfo
->x_highlight_frame
2924 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2925 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2926 : dpyinfo
->w32_focus_frame
);
2927 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
2929 fset_focus_frame (dpyinfo
->w32_focus_frame
, Qnil
);
2930 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
2934 dpyinfo
->x_highlight_frame
= 0;
2936 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
2939 frame_unhighlight (old_highlight
);
2940 if (dpyinfo
->x_highlight_frame
)
2941 frame_highlight (dpyinfo
->x_highlight_frame
);
2945 /* Keyboard processing - modifier keys, etc. */
2947 /* Convert a keysym to its name. */
2950 x_get_keysym_name (int keysym
)
2952 /* Make static so we can always return it */
2953 static char value
[100];
2956 GetKeyNameText (keysym
, value
, 100);
2963 codepage_for_locale (LCID locale
)
2967 if (GetLocaleInfo (locale
, LOCALE_IDEFAULTANSICODEPAGE
, cp
, 20) > 0)
2974 /* Mouse clicks and mouse movement. Rah. */
2976 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2977 the state in PUP. XBUTTON provides extra information for extended mouse
2978 button messages. Returns FALSE if unable to parse the message. */
2980 parse_button (int message
, int xbutton
, int * pbutton
, int * pup
)
2987 case WM_LBUTTONDOWN
:
2995 case WM_MBUTTONDOWN
:
2996 if (NILP (Vw32_swap_mouse_buttons
))
3003 if (NILP (Vw32_swap_mouse_buttons
))
3009 case WM_RBUTTONDOWN
:
3010 if (NILP (Vw32_swap_mouse_buttons
))
3017 if (NILP (Vw32_swap_mouse_buttons
))
3023 case WM_XBUTTONDOWN
:
3024 button
= xbutton
+ 2;
3028 button
= xbutton
+ 2;
3036 if (pbutton
) *pbutton
= button
;
3042 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3044 If the event is a button press, then note that we have grabbed
3048 construct_mouse_click (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3053 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3056 /* Make the event type NO_EVENT; we'll change that when we decide
3058 result
->kind
= MOUSE_CLICK_EVENT
;
3059 result
->code
= button
;
3060 result
->timestamp
= msg
->msg
.time
;
3061 result
->modifiers
= (msg
->dwModifiers
3066 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3067 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3068 XSETFRAME (result
->frame_or_window
, f
);
3074 construct_mouse_wheel (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3079 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3082 result
->timestamp
= msg
->msg
.time
;
3084 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3085 forward, away from the user (up); a negative value indicates that
3086 the wheel was rotated backward, toward the user (down). */
3087 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3089 /* The up and down modifiers indicate if the wheel was rotated up or
3090 down based on WHEEL_DELTA value. */
3091 result
->modifiers
= (msg
->dwModifiers
3092 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3094 /* With multiple monitors, we can legitimately get negative
3095 coordinates, so cast to short to interpret them correctly. */
3096 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3097 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3098 ScreenToClient (msg
->msg
.hwnd
, &p
);
3099 XSETINT (result
->x
, p
.x
);
3100 XSETINT (result
->y
, p
.y
);
3101 XSETFRAME (result
->frame_or_window
, f
);
3107 construct_drag_n_drop (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3114 wchar_t name_w
[MAX_PATH
];
3115 #ifdef NTGUI_UNICODE
3116 const int use_unicode
= 1;
3118 int use_unicode
= w32_unicode_filenames
;
3119 char name_a
[MAX_PATH
];
3120 char file
[MAX_UTF8_PATH
];
3124 result
->kind
= DRAG_N_DROP_EVENT
;
3126 result
->timestamp
= msg
->msg
.time
;
3127 result
->modifiers
= msg
->dwModifiers
;
3129 hdrop
= (HDROP
) msg
->msg
.wParam
;
3130 DragQueryPoint (hdrop
, &p
);
3133 p
.x
= LOWORD (msg
->msg
.lParam
);
3134 p
.y
= HIWORD (msg
->msg
.lParam
);
3135 ScreenToClient (msg
->msg
.hwnd
, &p
);
3138 XSETINT (result
->x
, p
.x
);
3139 XSETINT (result
->y
, p
.y
);
3141 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3144 for (i
= 0; i
< num_files
; i
++)
3148 eassert (DragQueryFileW (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3149 /* If DragQueryFile returns zero, it failed to fetch a file
3151 if (DragQueryFileW (hdrop
, i
, name_w
, MAX_PATH
) == 0)
3153 #ifdef NTGUI_UNICODE
3154 files
= Fcons (from_unicode_buffer (name_w
), files
);
3156 filename_from_utf16 (name_w
, file
);
3157 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3158 #endif /* NTGUI_UNICODE */
3160 #ifndef NTGUI_UNICODE
3163 eassert (DragQueryFileA (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3164 if (DragQueryFileA (hdrop
, i
, name_a
, MAX_PATH
) == 0)
3166 filename_from_ansi (name_a
, file
);
3167 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3174 XSETFRAME (frame
, f
);
3175 result
->frame_or_window
= frame
;
3176 result
->arg
= files
;
3183 /* File event notifications (see w32notify.c). */
3186 lispy_file_action (DWORD action
)
3188 static char unknown_fmt
[] = "unknown-action(%d)";
3193 case FILE_ACTION_ADDED
:
3196 case FILE_ACTION_REMOVED
:
3199 case FILE_ACTION_MODIFIED
:
3202 case FILE_ACTION_RENAMED_OLD_NAME
:
3203 retval
= Qrenamed_from
;
3205 case FILE_ACTION_RENAMED_NEW_NAME
:
3206 retval
= Qrenamed_to
;
3210 char buf
[sizeof(unknown_fmt
) - 1 + INT_STRLEN_BOUND (DWORD
)];
3212 sprintf (buf
, unknown_fmt
, action
);
3213 retval
= intern (buf
);
3222 /* Put file notifications into the Emacs input event queue. This
3223 function runs when the WM_EMACS_FILENOTIFY message arrives from a
3226 queue_notifications (struct input_event
*event
, W32Msg
*msg
, struct frame
*f
,
3229 struct notifications_set
*ns
= NULL
;
3233 /* We cannot process notification before Emacs is fully initialized,
3234 since we need the UTF-16LE coding-system to be set up. */
3238 XSETFRAME (frame
, f
);
3244 /* Find out if there is a record available in the linked list of
3245 notifications sets. If so, unlink the set from the linked
3246 list. Use critical section. */
3248 if (notifications_set_head
->next
!= notifications_set_head
)
3250 ns
= notifications_set_head
->next
;
3251 ns
->prev
->next
= ns
->next
;
3252 ns
->next
->prev
= ns
->prev
;
3260 BYTE
*p
= ns
->notifications
;
3261 FILE_NOTIFY_INFORMATION
*fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3262 const DWORD min_size
3263 = offsetof (FILE_NOTIFY_INFORMATION
, FileName
) + sizeof(wchar_t);
3264 DWORD info_size
= ns
->size
;
3265 Lisp_Object cs
= Qutf_16le
;
3266 Lisp_Object obj
= w32_get_watch_object (ns
->desc
);
3268 /* notifications size could be zero when the buffer of
3269 notifications overflowed on the OS level, or when the
3270 directory being watched was itself deleted. Do nothing in
3273 && !NILP (obj
) && CONSP (obj
))
3275 Lisp_Object callback
= XCDR (obj
);
3277 while (info_size
>= min_size
)
3279 Lisp_Object utf_16_fn
3280 = make_unibyte_string ((char *)fni
->FileName
,
3281 fni
->FileNameLength
);
3282 /* Note: mule-conf is preloaded, so utf-16le must
3283 already be defined at this point. */
3285 = code_convert_string_norecord (utf_16_fn
, cs
, 0);
3286 Lisp_Object action
= lispy_file_action (fni
->Action
);
3288 event
->kind
= FILE_NOTIFY_EVENT
;
3289 event
->timestamp
= msg
->msg
.time
;
3290 event
->modifiers
= 0;
3291 event
->frame_or_window
= callback
;
3292 event
->arg
= list3 (make_pointer_integer (ns
->desc
),
3294 kbd_buffer_store_event (event
);
3296 if (!fni
->NextEntryOffset
)
3298 p
+= fni
->NextEntryOffset
;
3299 fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3300 info_size
-= fni
->NextEntryOffset
;
3303 /* Free this notifications set. */
3304 xfree (ns
->notifications
);
3308 /* We've stuffed all the events ourselves, so w32_read_socket shouldn't. */
3309 event
->kind
= NO_EVENT
;
3311 #endif /* WINDOWSNT */
3312 #endif /* HAVE_W32NOTIFY */
3315 /* Function to report a mouse movement to the mainstream Emacs code.
3316 The input handler calls this.
3318 We have received a mouse movement event, which is given in *event.
3319 If the mouse is over a different glyph than it was last time, tell
3320 the mainstream emacs code by setting mouse_moved. If not, ask for
3321 another motion event, so we can check again the next time it moves. */
3324 note_mouse_movement (struct frame
*frame
, MSG
*msg
)
3326 struct w32_display_info
*dpyinfo
;
3327 int mouse_x
= LOWORD (msg
->lParam
);
3328 int mouse_y
= HIWORD (msg
->lParam
);
3331 if (!FRAME_X_OUTPUT (frame
))
3334 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
3335 dpyinfo
->last_mouse_movement_time
= msg
->time
;
3336 dpyinfo
->last_mouse_motion_frame
= frame
;
3337 dpyinfo
->last_mouse_motion_x
= mouse_x
;
3338 dpyinfo
->last_mouse_motion_y
= mouse_y
;
3340 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3342 frame
->mouse_moved
= true;
3343 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3344 note_mouse_highlight (frame
, -1, -1);
3345 dpyinfo
->last_mouse_glyph_frame
= NULL
;
3349 /* Has the mouse moved off the glyph it was on at the last sighting? */
3350 r
= &dpyinfo
->last_mouse_glyph
;
3351 if (frame
!= dpyinfo
->last_mouse_glyph_frame
3352 || mouse_x
< r
->left
|| mouse_x
>= r
->right
3353 || mouse_y
< r
->top
|| mouse_y
>= r
->bottom
)
3355 frame
->mouse_moved
= true;
3356 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3357 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3358 /* Remember the mouse position here, as w32_mouse_position only
3359 gets called when mouse tracking is enabled but we also need
3360 to keep track of the mouse for help_echo and highlighting at
3362 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, r
);
3363 dpyinfo
->last_mouse_glyph_frame
= frame
;
3371 /************************************************************************
3373 ************************************************************************/
3375 static struct scroll_bar
*x_window_to_scroll_bar (Window
, int);
3376 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3377 enum scroll_bar_part
*,
3378 Lisp_Object
*, Lisp_Object
*,
3380 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3381 enum scroll_bar_part
*,
3382 Lisp_Object
*, Lisp_Object
*,
3385 w32_define_cursor (Window window
, Cursor cursor
)
3387 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3390 /* Return the current position of the mouse.
3391 *fp should be a frame which indicates which display to ask about.
3393 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3394 and *part to the frame, window, and scroll bar part that the mouse
3395 is over. Set *x and *y to the portion and whole of the mouse's
3396 position on the scroll bar.
3398 If the mouse movement started elsewhere, set *fp to the frame the
3399 mouse is on, *bar_window to nil, and *x and *y to the character cell
3402 Set *time to the server time-stamp for the time at which the mouse
3403 was at this position.
3405 Don't store anything if we don't have a valid set of values to report.
3407 This clears the mouse_moved flag, so we can wait for the next mouse
3411 w32_mouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
3412 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
3416 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
3420 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
3422 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
3424 if (bar
->horizontal
)
3425 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3427 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3433 Lisp_Object frame
, tail
;
3435 /* Clear the mouse-moved flag for every frame on this display. */
3436 FOR_EACH_FRAME (tail
, frame
)
3437 XFRAME (frame
)->mouse_moved
= false;
3439 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3443 /* Now we have a position on the root; find the innermost window
3444 containing the pointer. */
3446 /* If mouse was grabbed on a frame, give coords for that
3447 frame even if the mouse is now outside it. Otherwise
3448 check for window under mouse on one of our frames. */
3449 f1
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
3450 : x_any_window_to_frame (dpyinfo
, WindowFromPoint (pt
)));
3452 /* If not, is it one of our scroll bars? */
3455 struct scroll_bar
*bar
3456 = x_window_to_scroll_bar (WindowFromPoint (pt
), 2);
3459 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3462 if (f1
== 0 && insist
> 0)
3463 f1
= SELECTED_FRAME ();
3467 /* Ok, we found a frame. Store all the values.
3468 last_mouse_glyph is a rectangle used to reduce the
3469 generation of mouse events. To not miss any motion
3470 events, we must divide the frame into rectangles of the
3471 size of the smallest character that could be displayed
3472 on it, i.e. into the same rectangles that matrices on
3473 the frame are divided into. */
3475 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
3476 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3477 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &dpyinfo
->last_mouse_glyph
);
3478 dpyinfo
->last_mouse_glyph_frame
= f1
;
3481 *part
= scroll_bar_above_handle
;
3485 *time
= dpyinfo
->last_mouse_movement_time
;
3494 /***********************************************************************
3496 ***********************************************************************/
3498 /* Handle mouse button event on the tool-bar of frame F, at
3499 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
3500 or ButtonRelease. */
3503 w32_handle_tool_bar_click (struct frame
*f
, struct input_event
*button_event
)
3505 int x
= XFASTINT (button_event
->x
);
3506 int y
= XFASTINT (button_event
->y
);
3508 if (button_event
->modifiers
& down_modifier
)
3509 handle_tool_bar_click (f
, x
, y
, 1, 0);
3511 handle_tool_bar_click (f
, x
, y
, 0,
3512 button_event
->modifiers
& ~up_modifier
);
3517 /***********************************************************************
3519 ***********************************************************************/
3521 /* Scroll bar support. */
3523 /* Given a window ID, find the struct scroll_bar which manages it
3524 vertically. This can be called in GC, so we have to make sure to
3525 strip off mark bits. */
3527 static struct scroll_bar
*
3528 x_window_to_scroll_bar (Window window_id
, int type
)
3530 Lisp_Object tail
, frame
;
3532 FOR_EACH_FRAME (tail
, frame
)
3534 Lisp_Object bar
, condemned
;
3536 /* Scan this frame's scroll bar list for a scroll bar with the
3538 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3539 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3540 /* This trick allows us to search both the ordinary and
3541 condemned scroll bar lists with one loop. */
3542 ! NILP (bar
) || (bar
= condemned
,
3545 bar
= XSCROLL_BAR (bar
)->next
)
3546 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
3548 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
3549 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
3550 return XSCROLL_BAR (bar
);
3558 /* Set the thumb size and position of vertical scroll bar BAR. We are currently
3559 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3562 w32_set_scroll_bar_thumb (struct scroll_bar
*bar
,
3563 int portion
, int position
, int whole
)
3565 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3566 /* We use the whole scroll-bar height in the calculations below, to
3567 avoid strange effects like scrolling backwards when just clicking
3568 on the handle (without moving it). */
3569 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
)
3570 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3571 int sb_page
, sb_pos
;
3572 BOOL draggingp
= bar
->dragging
? TRUE
: FALSE
;
3575 /* We used to change the nPage setting while dragging the handle,
3576 but that had very strange effects (such as scrolling backwards
3577 while dragging downwards).
3579 Now, we don't change the nPage setting while dragging unless we
3580 get near to the end of the buffer, in which case we often have to
3581 resize the handle to "go all the way". */
3587 si
.cbSize
= sizeof (si
);
3588 si
.fMask
= SIF_POS
| SIF_PAGE
;
3589 GetScrollInfo (w
, SB_CTL
, &si
);
3590 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3598 /* Position scroll bar at rock bottom if the bottom of the
3599 buffer is visible. This avoids shrinking the thumb away
3600 to nothing if it is held at the bottom of the buffer. */
3601 if (position
+ portion
>= whole
&& !draggingp
)
3603 sb_page
= range
* (whole
- position
) / whole
;
3608 sb_pos
= position
* range
/ whole
;
3609 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3618 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3622 si
.cbSize
= sizeof (si
);
3623 si
.fMask
= SIF_PAGE
| SIF_POS
;
3627 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3632 /* Set the thumb size and position of horizontal scroll bar BAR. We are currently
3633 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3636 w32_set_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
3637 int portion
, int position
, int whole
)
3639 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3644 si
.cbSize
= sizeof (si
);
3645 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
3648 /* Allow nPage to be one larger than nPos so we don't allow the scrolling
3649 of an already fully visible buffer. */
3650 si
.nPage
= min (portion
, si
.nMax
) + 1;
3651 si
.nPos
= min (position
, si
.nMax
);
3652 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3658 /************************************************************************
3659 Scroll bars, general
3660 ************************************************************************/
3663 my_create_vscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3665 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3666 WM_EMACS_CREATEVSCROLLBAR
, (WPARAM
) f
,
3671 my_create_hscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3673 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3674 WM_EMACS_CREATEHSCROLLBAR
, (WPARAM
) f
,
3678 /*#define ATTACH_THREADS*/
3681 my_show_window (struct frame
*f
, HWND hwnd
, int how
)
3683 #ifndef ATTACH_THREADS
3684 return SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3685 (WPARAM
) hwnd
, (LPARAM
) how
, 0, 6000, NULL
);
3687 return ShowWindow (hwnd
, how
);
3692 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3693 int x
, int y
, int cx
, int cy
, UINT flags
)
3695 #ifndef ATTACH_THREADS
3697 pos
.hwndInsertAfter
= hwndAfter
;
3703 SendMessageTimeout (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0,
3706 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3712 my_set_focus (struct frame
* f
, HWND hwnd
)
3714 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3715 (WPARAM
) hwnd
, 0, 0, 6000, NULL
);
3720 my_set_foreground_window (HWND hwnd
)
3722 SendMessageTimeout (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0,
3728 my_destroy_window (struct frame
* f
, HWND hwnd
)
3730 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3731 (WPARAM
) hwnd
, 0, 0, 6000, NULL
);
3735 my_bring_window_to_top (HWND hwnd
)
3737 SendMessageTimeout (hwnd
, WM_EMACS_BRINGTOTOP
, (WPARAM
) hwnd
, 0,
3741 /* Create a scroll bar and return the scroll bar vector for it. W is
3742 the Emacs window on which to create the scroll bar. TOP, LEFT,
3743 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
3746 static struct scroll_bar
*
3747 x_scroll_bar_create (struct window
*w
, int left
, int top
, int width
, int height
, bool horizontal
)
3749 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3752 struct scroll_bar
*bar
3753 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, top
, PVEC_OTHER
);
3758 XSETWINDOW (bar
->window
, w
);
3762 bar
->height
= height
;
3766 bar
->horizontal
= horizontal
;
3768 /* Requires geometry to be set before call to create the real window */
3771 hwnd
= my_create_hscrollbar (f
, bar
);
3773 hwnd
= my_create_vscrollbar (f
, bar
);
3775 si
.cbSize
= sizeof (si
);
3779 si
.nMax
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
)
3780 + HORIZONTAL_SCROLL_BAR_MIN_HANDLE
;
3782 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3783 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3787 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3789 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3791 /* Add bar to its frame's list of scroll bars. */
3792 bar
->next
= FRAME_SCROLL_BARS (f
);
3794 XSETVECTOR (barobj
, bar
);
3795 fset_scroll_bars (f
, barobj
);
3796 if (! NILP (bar
->next
))
3797 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3805 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3809 x_scroll_bar_remove (struct scroll_bar
*bar
)
3811 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3815 /* Destroy the window. */
3816 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3818 /* Dissociate this scroll bar from its window. */
3819 if (bar
->horizontal
)
3820 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3822 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3827 /* Set the handle of the vertical scroll bar for WINDOW to indicate that
3828 we are displaying PORTION characters out of a total of WHOLE
3829 characters, starting at POSITION. If WINDOW has no vertical scroll
3832 w32_set_vertical_scroll_bar (struct window
*w
,
3833 int portion
, int whole
, int position
)
3835 struct frame
*f
= XFRAME (w
->frame
);
3837 struct scroll_bar
*bar
;
3838 int top
, height
, left
, width
;
3839 int window_y
, window_height
;
3841 /* Get window dimensions. */
3842 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
3844 height
= window_height
;
3846 /* Compute the left edge and the width of the scroll bar area. */
3847 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3848 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
3850 /* Does the scroll bar exist yet? */
3851 if (NILP (w
->vertical_scroll_bar
))
3855 if (width
> 0 && height
> 0)
3857 hdc
= get_frame_dc (f
);
3858 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3859 release_frame_dc (f
, hdc
);
3863 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, false);
3867 /* It may just need to be moved and resized. */
3870 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3871 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3873 /* If already correctly positioned, do nothing. */
3874 if (bar
->left
== left
3876 && bar
->width
== width
3877 && bar
->height
== height
)
3879 /* Redraw after clear_frame. */
3880 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3881 InvalidateRect (hwnd
, NULL
, FALSE
);
3889 if (width
&& height
)
3891 hdc
= get_frame_dc (f
);
3892 /* Since Windows scroll bars are smaller than the space reserved
3893 for them on the frame, we have to clear "under" them. */
3894 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3895 release_frame_dc (f
, hdc
);
3897 /* Make sure scroll bar is "visible" before moving, to ensure the
3898 area of the parent window now exposed will be refreshed. */
3899 my_show_window (f
, hwnd
, SW_HIDE
);
3900 MoveWindow (hwnd
, left
, top
, width
, max (height
, 1), TRUE
);
3902 si
.cbSize
= sizeof (si
);
3903 si
.fMask
= SIF_RANGE
;
3905 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3906 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3908 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3910 my_show_window (f
, hwnd
, SW_NORMAL
);
3911 /* InvalidateRect (w, NULL, FALSE); */
3913 /* Remember new settings. */
3917 bar
->height
= height
;
3922 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3923 XSETVECTOR (barobj
, bar
);
3924 wset_vertical_scroll_bar (w
, barobj
);
3927 /* Set the handle of the horizontal scroll bar for WINDOW to indicate
3928 that we are displaying PORTION characters out of a total of WHOLE
3929 characters, starting at POSITION. If WINDOW has no horizontal scroll
3932 w32_set_horizontal_scroll_bar (struct window
*w
,
3933 int portion
, int whole
, int position
)
3935 struct frame
*f
= XFRAME (w
->frame
);
3937 struct scroll_bar
*bar
;
3938 int top
, height
, left
, width
;
3939 int window_x
, window_width
;
3940 int clear_left
= WINDOW_LEFT_EDGE_X (w
);
3941 int clear_width
= WINDOW_PIXEL_WIDTH (w
) - WINDOW_RIGHT_DIVIDER_WIDTH (w
);
3943 /* Get window dimensions. */
3944 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
3946 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
3947 width
= window_width
;
3948 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
3950 /* Does the scroll bar exist yet? */
3951 if (NILP (w
->horizontal_scroll_bar
))
3955 if (width
> 0 && height
> 0)
3957 hdc
= get_frame_dc (f
);
3958 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
3959 release_frame_dc (f
, hdc
);
3963 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, true);
3967 /* It may just need to be moved and resized. */
3970 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
3971 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3973 /* If already correctly positioned, do nothing. */
3974 if (bar
->left
== left
&& bar
->top
== top
3975 && bar
->width
== width
&& bar
->height
== height
)
3977 /* Redraw after clear_frame. */
3978 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3979 InvalidateRect (hwnd
, NULL
, FALSE
);
3987 if (width
&& height
)
3989 hdc
= get_frame_dc (f
);
3990 /* Since Windows scroll bars are smaller than the space reserved
3991 for them on the frame, we have to clear "under" them. */
3992 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
3993 release_frame_dc (f
, hdc
);
3995 /* Make sure scroll bar is "visible" before moving, to ensure the
3996 area of the parent window now exposed will be refreshed. */
3997 my_show_window (f
, hwnd
, SW_HIDE
);
3998 MoveWindow (hwnd
, left
, top
, width
, max (height
, 1), TRUE
);
4000 /* +++ SetScrollInfo +++ */
4001 si
.cbSize
= sizeof (si
);
4002 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
4005 si
.nPage
= min (portion
, si
.nMax
) + 1;
4006 si
.nPos
= min (position
, si
.nMax
);
4007 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
4009 my_show_window (f
, hwnd
, SW_NORMAL
);
4010 /* InvalidateRect (w, NULL, FALSE); */
4012 /* Remember new settings. */
4016 bar
->height
= height
;
4022 w32_set_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
4023 XSETVECTOR (barobj
, bar
);
4024 wset_horizontal_scroll_bar (w
, barobj
);
4028 /* The following three hooks are used when we're doing a thorough
4029 redisplay of the frame. We don't explicitly know which scroll bars
4030 are going to be deleted, because keeping track of when windows go
4031 away is a real pain - "Can you say set-window-configuration, boys
4032 and girls?" Instead, we just assert at the beginning of redisplay
4033 that *all* scroll bars are to be removed, and then save a scroll bar
4034 from the fiery pit when we actually redisplay its window. */
4036 /* Arrange for all scroll bars on FRAME to be removed at the next call
4037 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
4038 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
4041 w32_condemn_scroll_bars (struct frame
*frame
)
4043 if (!NILP (FRAME_SCROLL_BARS (frame
)))
4045 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
4047 /* Prepend scrollbars to already condemned ones. */
4048 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
4050 while (!NILP (XSCROLL_BAR (last
)->next
))
4051 last
= XSCROLL_BAR (last
)->next
;
4053 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
4054 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
4057 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
4058 fset_scroll_bars (frame
, Qnil
);
4063 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
4064 Note that WINDOW isn't necessarily condemned at all. */
4067 w32_redeem_scroll_bar (struct window
*w
)
4069 struct scroll_bar
*bar
;
4073 /* We can't redeem this window's scroll bar if it doesn't have one. */
4074 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
4077 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4079 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4080 /* Unlink it from the condemned list. */
4081 f
= XFRAME (WINDOW_FRAME (w
));
4082 if (NILP (bar
->prev
))
4084 /* If the prev pointer is nil, it must be the first in one of
4086 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
4087 /* It's not condemned. Everything's fine. */
4089 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4090 w
->vertical_scroll_bar
))
4091 fset_condemned_scroll_bars (f
, bar
->next
);
4093 /* If its prev pointer is nil, it must be at the front of
4094 one or the other! */
4098 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4100 if (! NILP (bar
->next
))
4101 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4103 bar
->next
= FRAME_SCROLL_BARS (f
);
4105 XSETVECTOR (barobj
, bar
);
4106 fset_scroll_bars (f
, barobj
);
4107 if (! NILP (bar
->next
))
4108 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4112 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
4114 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
4115 /* Unlink it from the condemned list. */
4116 f
= XFRAME (WINDOW_FRAME (w
));
4117 if (NILP (bar
->prev
))
4119 /* If the prev pointer is nil, it must be the first in one of
4121 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
4122 /* It's not condemned. Everything's fine. */
4124 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4125 w
->horizontal_scroll_bar
))
4126 fset_condemned_scroll_bars (f
, bar
->next
);
4128 /* If its prev pointer is nil, it must be at the front of
4129 one or the other! */
4133 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4135 if (! NILP (bar
->next
))
4136 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4138 bar
->next
= FRAME_SCROLL_BARS (f
);
4140 XSETVECTOR (barobj
, bar
);
4141 fset_scroll_bars (f
, barobj
);
4142 if (! NILP (bar
->next
))
4143 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4147 /* Remove all scroll bars on FRAME that haven't been saved since the
4148 last call to `*condemn_scroll_bars_hook'. */
4151 w32_judge_scroll_bars (struct frame
*f
)
4153 Lisp_Object bar
, next
;
4155 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
4157 /* Clear out the condemned list now so we won't try to process any
4158 more events on the hapless scroll bars. */
4159 fset_condemned_scroll_bars (f
, Qnil
);
4161 for (; ! NILP (bar
); bar
= next
)
4163 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
4165 x_scroll_bar_remove (b
);
4168 b
->next
= b
->prev
= Qnil
;
4171 /* Now there should be no references to the condemned scroll bars,
4172 and they should get garbage-collected. */
4175 /* Handle a mouse click on the vertical scroll bar BAR. If
4176 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4179 This may be called from a signal handler, so we have to ignore GC
4183 w32_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4184 struct input_event
*emacs_event
)
4186 if (! WINDOWP (bar
->window
))
4189 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
4190 emacs_event
->code
= 0;
4191 /* not really meaningful to distinguish up/down */
4192 emacs_event
->modifiers
= msg
->dwModifiers
;
4193 emacs_event
->frame_or_window
= bar
->window
;
4194 emacs_event
->arg
= Qnil
;
4195 emacs_event
->timestamp
= msg
->msg
.time
;
4198 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4200 int dragging
= bar
->dragging
;
4202 int sb_event
= LOWORD (msg
->msg
.wParam
);
4204 si
.cbSize
= sizeof (si
);
4205 if (sb_event
== SB_THUMBTRACK
)
4206 si
.fMask
= SIF_TRACKPOS
;
4210 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4211 if (sb_event
== SB_THUMBTRACK
)
4217 struct frame
*f
; /* Value is not used. */
4218 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4223 emacs_event
->part
= scroll_bar_down_arrow
;
4226 emacs_event
->part
= scroll_bar_up_arrow
;
4229 emacs_event
->part
= scroll_bar_above_handle
;
4232 emacs_event
->part
= scroll_bar_below_handle
;
4235 emacs_event
->part
= scroll_bar_handle
;
4239 emacs_event
->part
= scroll_bar_handle
;
4243 case SB_THUMBPOSITION
:
4244 bar
->dragging
= 1; /* ??????? */
4245 emacs_event
->part
= scroll_bar_handle
;
4247 /* "Silently" update current position. */
4251 si
.cbSize
= sizeof (si
);
4254 /* Remember apparent position (we actually lag behind the real
4255 position, so don't set that directly). */
4256 last_scroll_bar_drag_pos
= y
;
4258 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4262 /* If this is the end of a drag sequence, then reset the scroll
4263 handle size to normal and do a final redraw. Otherwise do
4268 int start
= bar
->start
;
4271 si
.cbSize
= sizeof (si
);
4272 si
.fMask
= SIF_PAGE
| SIF_POS
;
4273 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4274 si
.nPos
= last_scroll_bar_drag_pos
;
4275 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4279 emacs_event
->kind
= NO_EVENT
;
4283 XSETINT (emacs_event
->x
, y
);
4284 XSETINT (emacs_event
->y
, top_range
);
4290 /* Handle a mouse click on the horizontal scroll bar BAR. If
4291 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4294 This may be called from a signal handler, so we have to ignore GC
4298 w32_horizontal_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4299 struct input_event
*emacs_event
)
4301 if (! WINDOWP (bar
->window
))
4304 emacs_event
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
4305 emacs_event
->code
= 0;
4306 /* not really meaningful to distinguish left/right */
4307 emacs_event
->modifiers
= msg
->dwModifiers
;
4308 emacs_event
->frame_or_window
= bar
->window
;
4309 emacs_event
->arg
= Qnil
;
4310 emacs_event
->timestamp
= msg
->msg
.time
;
4313 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4315 int dragging
= bar
->dragging
;
4317 int sb_event
= LOWORD (msg
->msg
.wParam
);
4319 si
.cbSize
= sizeof (si
);
4320 if (sb_event
== SB_THUMBTRACK
)
4321 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4323 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4325 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4326 if (sb_event
== SB_THUMBTRACK
)
4330 y
= si
.nMax
- si
.nPage
;
4333 struct frame
*f
; /* Value is not used. */
4334 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4339 emacs_event
->part
= scroll_bar_left_arrow
;
4342 emacs_event
->part
= scroll_bar_right_arrow
;
4345 emacs_event
->part
= scroll_bar_before_handle
;
4348 emacs_event
->part
= scroll_bar_after_handle
;
4351 emacs_event
->part
= scroll_bar_horizontal_handle
;
4355 emacs_event
->part
= scroll_bar_horizontal_handle
;
4359 case SB_THUMBPOSITION
:
4361 emacs_event
->part
= scroll_bar_horizontal_handle
;
4363 /* "Silently" update current position. */
4367 si
.cbSize
= sizeof (si
);
4369 si
.nPos
= min (x
, XWINDOW (bar
->window
)->hscroll_whole
- 1);
4370 /* Remember apparent position (we actually lag behind the real
4371 position, so don't set that directly). */
4372 last_scroll_bar_drag_pos
= x
;
4374 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4378 /* If this is the end of a drag sequence, then reset the scroll
4379 handle size to normal and do a final redraw. Otherwise do
4385 si
.cbSize
= sizeof (si
);
4387 si
.nPos
= min (last_scroll_bar_drag_pos
,
4388 XWINDOW (bar
->window
)->hscroll_whole
- 1);
4389 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4393 emacs_event
->kind
= NO_EVENT
;
4397 XSETINT (emacs_event
->x
, x
);
4398 XSETINT (emacs_event
->y
, y
);
4404 /* Return information to the user about the current position of the mouse
4405 on the vertical scroll bar. */
4407 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4408 enum scroll_bar_part
*part
,
4409 Lisp_Object
*x
, Lisp_Object
*y
,
4412 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4413 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4414 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4415 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4417 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4419 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4424 *bar_window
= bar
->window
;
4426 si
.cbSize
= sizeof (si
);
4427 if (sb_event
== SB_THUMBTRACK
)
4428 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4430 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4432 GetScrollInfo (w
, SB_CTL
, &si
);
4433 if (sb_event
== SB_THUMBTRACK
)
4437 top_range
= si
.nMax
- si
.nPage
+ 1;
4439 *part
= scroll_bar_handle
;
4440 if (sb_event
== SB_LINEDOWN
)
4444 XSETINT (*y
, top_range
);
4446 f
->mouse_moved
= false;
4447 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4449 *time
= dpyinfo
->last_mouse_movement_time
;
4454 /* Return information to the user about the current position of the mouse
4455 on the horizontal scroll bar. */
4457 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4458 enum scroll_bar_part
*part
,
4459 Lisp_Object
*x
, Lisp_Object
*y
,
4462 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4463 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4464 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4465 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4467 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4469 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4474 *bar_window
= bar
->window
;
4476 si
.cbSize
= sizeof (si
);
4477 if (sb_event
== SB_THUMBTRACK
)
4478 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4480 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4482 GetScrollInfo (w
, SB_CTL
, &si
);
4483 if (sb_event
== SB_THUMBTRACK
)
4487 left_range
= si
.nMax
- si
.nPage
+ 1;
4489 *part
= scroll_bar_handle
;
4490 if (sb_event
== SB_LINERIGHT
)
4495 XSETINT (*x
, left_range
);
4497 f
->mouse_moved
= false;
4498 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4500 *time
= dpyinfo
->last_mouse_movement_time
;
4506 /* The screen has been cleared so we may have changed foreground or
4507 background colors, and the scroll bars may need to be redrawn.
4508 Clear out the scroll bars, and ask for expose events, so we can
4512 x_scroll_bar_clear (struct frame
*f
)
4516 /* We can have scroll bars even if this is 0,
4517 if we just turned off scroll bar mode.
4518 But in that case we should not clear them. */
4519 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4520 || FRAME_HAS_HORIZONTAL_SCROLL_BARS (f
))
4521 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4522 bar
= XSCROLL_BAR (bar
)->next
)
4524 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4525 HDC hdc
= GetDC (window
);
4528 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4529 arranges to refresh the scroll bar if hidden. */
4530 my_show_window (f
, window
, SW_HIDE
);
4532 GetClientRect (window
, &rect
);
4533 select_palette (f
, hdc
);
4534 w32_clear_rect (f
, hdc
, &rect
);
4535 deselect_palette (f
, hdc
);
4537 ReleaseDC (window
, hdc
);
4541 /* The main W32 event-reading loop - w32_read_socket. */
4543 /* Record the last 100 characters stored
4544 to help debug the loss-of-chars-during-GC problem. */
4546 static int temp_index
;
4547 static short temp_buffer
[100];
4549 /* Temporarily store lead byte of DBCS input sequences. */
4550 static char dbcs_lead
= 0;
4552 /* Read events coming from the W32 shell.
4553 This routine is called by the SIGIO handler.
4554 We return as soon as there are no more events to be read.
4556 For an overview of how Emacs input works on MS-Windows, see the
4557 commentary before w32_msg_pump in w32fns.c.
4559 We return the number of characters stored into the buffer,
4560 thus pretending to be `read'.
4562 Some of these messages are reposted back to the message queue since the
4563 system calls the windows proc directly in a context where we cannot return
4564 the data nor can we guarantee the state we are in. So if we dispatch them
4565 we will get into an infinite loop. To prevent this from ever happening we
4566 will set a variable to indicate we are in the read_socket call and indicate
4567 which message we are processing since the windows proc gets called
4568 recursively with different messages by the system.
4571 extern void menubar_selection_callback (struct frame
*, void *);
4574 w32_read_socket (struct terminal
*terminal
,
4575 struct input_event
*hold_quit
)
4578 int check_visibility
= 0;
4581 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4582 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
4586 /* So people can tell when we have read the available input. */
4587 input_signal_count
++;
4589 /* Process any incoming thread messages. */
4590 drain_message_queue ();
4592 /* TODO: ghostscript integration. */
4593 while (get_next_msg (&msg
, FALSE
))
4595 struct input_event inev
;
4598 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4599 /* w32_name_of_message (msg.msg.message), */
4600 /* msg.msg.time)); */
4603 inev
.kind
= NO_EVENT
;
4606 switch (msg
.msg
.message
)
4608 case WM_EMACS_PAINT
:
4609 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4613 if (msg
.rect
.right
== msg
.rect
.left
||
4614 msg
.rect
.bottom
== msg
.rect
.top
)
4616 /* We may get paint messages even though the client
4617 area is clipped - these are not expose events. */
4618 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4621 else if (FRAME_VISIBLE_P (f
) != 1)
4623 bool iconified
= FRAME_ICONIFIED_P (f
);
4625 /* Definitely not obscured, so mark as visible. */
4626 SET_FRAME_VISIBLE (f
, 1);
4627 SET_FRAME_ICONIFIED (f
, false);
4628 SET_FRAME_GARBAGED (f
);
4629 if (!f
->output_data
.w32
->asked_for_visible
)
4630 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4633 /* WM_PAINT serves as MapNotify as well, so report
4634 visibility changes properly. */
4637 inev
.kind
= DEICONIFY_EVENT
;
4638 XSETFRAME (inev
.frame_or_window
, f
);
4640 else if (!NILP (Vframe_list
) && !NILP (XCDR (Vframe_list
)))
4641 /* Force a redisplay sooner or later to update the
4642 frame titles in case this is the second frame. */
4643 record_asynch_buffer_change ();
4647 /* Erase background again for safety. But don't do
4648 that if the frame's 'garbaged' flag is set, since
4649 in that case expose_frame will do nothing, and if
4650 the various redisplay flags happen to be unset,
4651 we are left with a blank frame. */
4652 if (!FRAME_GARBAGED_P (f
))
4654 HDC hdc
= get_frame_dc (f
);
4656 w32_clear_rect (f
, hdc
, &msg
.rect
);
4657 release_frame_dc (f
, hdc
);
4662 msg
.rect
.right
- msg
.rect
.left
,
4663 msg
.rect
.bottom
- msg
.rect
.top
);
4668 case WM_INPUTLANGCHANGE
:
4669 /* Generate a language change event. */
4670 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4672 /* lParam contains the input language ID in its low 16 bits.
4673 Use it to update our record of the keyboard codepage. */
4674 w32_keyboard_codepage
= codepage_for_locale ((LCID
)(msg
.msg
.lParam
4679 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4680 XSETFRAME (inev
.frame_or_window
, f
);
4681 inev
.code
= w32_keyboard_codepage
;
4682 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4688 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4690 if (f
&& !FRAME_ICONIFIED_P (f
))
4692 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4693 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4695 clear_mouse_face (hlinfo
);
4696 hlinfo
->mouse_face_hidden
= true;
4699 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4701 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4702 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4703 inev
.code
= msg
.msg
.wParam
;
4704 inev
.modifiers
= msg
.dwModifiers
;
4705 XSETFRAME (inev
.frame_or_window
, f
);
4706 inev
.timestamp
= msg
.msg
.time
;
4713 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4715 if (f
&& !FRAME_ICONIFIED_P (f
))
4717 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4718 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4720 clear_mouse_face (hlinfo
);
4721 hlinfo
->mouse_face_hidden
= true;
4724 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4726 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4728 inev
.modifiers
= msg
.dwModifiers
;
4729 XSETFRAME (inev
.frame_or_window
, f
);
4730 inev
.timestamp
= msg
.msg
.time
;
4732 if (msg
.msg
.message
== WM_UNICHAR
)
4734 inev
.code
= msg
.msg
.wParam
;
4736 else if (msg
.msg
.wParam
< 256)
4741 dbcs
[1] = (char) msg
.msg
.wParam
;
4745 dbcs
[0] = dbcs_lead
;
4747 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4751 DebPrint (("Invalid DBCS sequence: %d %d\n",
4753 inev
.kind
= NO_EVENT
;
4757 else if (IsDBCSLeadByteEx (w32_keyboard_codepage
,
4758 (BYTE
) msg
.msg
.wParam
))
4760 dbcs_lead
= (char) msg
.msg
.wParam
;
4761 inev
.kind
= NO_EVENT
;
4766 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4767 &dbcs
[1], 1, &code
, 1))
4769 /* What to do with garbage? */
4770 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4771 inev
.kind
= NO_EVENT
;
4779 /* Windows shouldn't generate WM_CHAR events above 0xFF
4780 in non-Unicode message handlers. */
4781 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4782 inev
.kind
= NO_EVENT
;
4785 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4786 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4791 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4793 if (f
&& !FRAME_ICONIFIED_P (f
))
4795 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4796 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4798 clear_mouse_face (hlinfo
);
4799 hlinfo
->mouse_face_hidden
= true;
4802 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4804 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4805 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4806 inev
.code
= GET_APPCOMMAND_LPARAM (msg
.msg
.lParam
);
4807 inev
.modifiers
= msg
.dwModifiers
;
4808 XSETFRAME (inev
.frame_or_window
, f
);
4809 inev
.timestamp
= msg
.msg
.time
;
4814 /* Ignore non-movement. */
4816 int x
= LOWORD (msg
.msg
.lParam
);
4817 int y
= HIWORD (msg
.msg
.lParam
);
4818 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4820 last_mousemove_x
= x
;
4821 last_mousemove_y
= y
;
4824 previous_help_echo_string
= help_echo_string
;
4825 help_echo_string
= Qnil
;
4827 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4828 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4830 if (hlinfo
->mouse_face_hidden
)
4832 hlinfo
->mouse_face_hidden
= false;
4833 clear_mouse_face (hlinfo
);
4838 /* Generate SELECT_WINDOW_EVENTs when needed. */
4839 if (!NILP (Vmouse_autoselect_window
))
4841 static Lisp_Object last_mouse_window
;
4842 Lisp_Object window
= window_from_coordinates
4843 (f
, LOWORD (msg
.msg
.lParam
), HIWORD (msg
.msg
.lParam
), 0, 0);
4845 /* Window will be selected only when it is not
4846 selected now and last mouse movement event was
4847 not in it. Minibuffer window will be selected
4848 only when it is active. */
4849 if (WINDOWP (window
)
4850 && !EQ (window
, last_mouse_window
)
4851 && !EQ (window
, selected_window
)
4852 /* For click-to-focus window managers
4853 create event iff we don't leave the
4855 && (focus_follows_mouse
4856 || (EQ (XWINDOW (window
)->frame
,
4857 XWINDOW (selected_window
)->frame
))))
4859 inev
.kind
= SELECT_WINDOW_EVENT
;
4860 inev
.frame_or_window
= window
;
4862 /* Remember the last window where we saw the mouse. */
4863 last_mouse_window
= window
;
4865 if (!note_mouse_movement (f
, &msg
.msg
))
4866 help_echo_string
= previous_help_echo_string
;
4870 /* If we move outside the frame, then we're
4871 certainly no longer on any text in the frame. */
4872 clear_mouse_face (hlinfo
);
4875 /* If the contents of the global variable help_echo_string
4876 has changed, generate a HELP_EVENT. */
4877 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4878 But it was originally changed to this to fix a bug, so I have
4879 not removed it completely in case the bug is still there. */
4880 if (help_echo_string
!= previous_help_echo_string
||
4881 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4882 #else /* This is what xterm.c does. */
4883 if (!NILP (help_echo_string
)
4884 || !NILP (previous_help_echo_string
))
4889 case WM_LBUTTONDOWN
:
4891 case WM_MBUTTONDOWN
:
4893 case WM_RBUTTONDOWN
:
4895 case WM_XBUTTONDOWN
:
4898 /* If we decide we want to generate an event to be seen
4899 by the rest of Emacs, we put it here. */
4900 bool tool_bar_p
= 0;
4904 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4905 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4909 construct_mouse_click (&inev
, &msg
, f
);
4911 /* Is this in the tool-bar? */
4912 if (WINDOWP (f
->tool_bar_window
)
4913 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4916 int x
= XFASTINT (inev
.x
);
4917 int y
= XFASTINT (inev
.y
);
4919 window
= window_from_coordinates (f
, x
, y
, 0, 1);
4921 if (EQ (window
, f
->tool_bar_window
))
4923 w32_handle_tool_bar_click (f
, &inev
);
4929 || (dpyinfo
->w32_focus_frame
4930 && f
!= dpyinfo
->w32_focus_frame
))
4931 inev
.kind
= NO_EVENT
;
4934 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4939 dpyinfo
->grabbed
&= ~ (1 << button
);
4943 dpyinfo
->grabbed
|= (1 << button
);
4944 dpyinfo
->last_mouse_frame
= f
;
4945 /* Ignore any mouse motion that happened
4946 before this event; any subsequent mouse-movement
4947 Emacs events should reflect only motion after
4951 f
->mouse_moved
= false;
4953 f
->last_tool_bar_item
= -1;
4960 case WM_MOUSEHWHEEL
:
4962 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4963 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4968 if (!dpyinfo
->w32_focus_frame
4969 || f
== dpyinfo
->w32_focus_frame
)
4971 /* Emit an Emacs wheel-up/down event. */
4972 construct_mouse_wheel (&inev
, &msg
, f
);
4974 /* Ignore any mouse motion that happened before this
4975 event; any subsequent mouse-movement Emacs events
4976 should reflect only motion after the
4978 f
->mouse_moved
= false;
4979 f
->last_tool_bar_item
= -1;
4981 dpyinfo
->last_mouse_frame
= f
;
4986 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4989 construct_drag_n_drop (&inev
, &msg
, f
);
4994 struct scroll_bar
*bar
=
4995 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 1);
4998 w32_horizontal_scroll_bar_handle_click (bar
, &msg
, &inev
);
5004 struct scroll_bar
*bar
=
5005 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 0);
5008 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
5012 case WM_WINDOWPOSCHANGED
:
5014 case WM_ACTIVATEAPP
:
5015 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5018 /* Run the full-screen hook function also when we are
5019 being activated, to actually install the required
5020 size in effect, if the WAIT flag is set. This is
5021 because when the hook is run from x_set_fullscreen,
5022 the frame might not yet be visible, if that call is a
5023 result of make-frame, and in that case the hook just
5024 sets the WAIT flag. */
5025 if ((msg
.msg
.message
== WM_WINDOWPOSCHANGED
|| msg
.msg
.wParam
)
5026 && (f
->want_fullscreen
& FULLSCREEN_WAIT
))
5028 /* Must set visibility right here since otherwise
5029 w32fullscreen_hook returns immediately. */
5030 SET_FRAME_VISIBLE (f
, 1);
5031 w32fullscreen_hook (f
);
5034 check_visibility
= 1;
5038 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5040 if (f
&& !FRAME_ICONIFIED_P (f
))
5041 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5043 check_visibility
= 1;
5047 /* wParam non-zero means Window is about to be shown, 0 means
5048 about to be hidden. */
5049 /* Redo the mouse-highlight after the tooltip has gone. */
5050 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
5053 x_redo_mouse_highlight (dpyinfo
);
5056 /* If window has been obscured or exposed by another window
5057 being maximized or minimized/restored, then recheck
5058 visibility of all frames. Direct changes to our own
5059 windows get handled by WM_SIZE. */
5061 if (msg
.msg
.lParam
!= 0)
5062 check_visibility
= 1;
5065 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5066 f
->async_visible
= msg
.msg
.wParam
;
5070 check_visibility
= 1;
5074 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5076 /* Inform lisp of whether frame has been iconified etc. */
5079 switch (msg
.msg
.wParam
)
5081 case SIZE_MINIMIZED
:
5082 SET_FRAME_VISIBLE (f
, 0);
5083 SET_FRAME_ICONIFIED (f
, true);
5085 inev
.kind
= ICONIFY_EVENT
;
5086 XSETFRAME (inev
.frame_or_window
, f
);
5089 case SIZE_MAXIMIZED
:
5091 bool iconified
= FRAME_ICONIFIED_P (f
);
5092 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5094 SET_FRAME_VISIBLE (f
, 1);
5095 SET_FRAME_ICONIFIED (f
, false);
5097 /* wait_reading_process_output will notice this
5098 and update the frame's display structures. */
5099 SET_FRAME_GARBAGED (f
);
5105 /* Reset top and left positions of the Window
5106 here since Windows sends a WM_MOVE message
5107 BEFORE telling us the Window is minimized
5108 when the Window is iconified, with 3000,3000
5110 x_real_positions (f
, &x
, &y
);
5114 inev
.kind
= DEICONIFY_EVENT
;
5115 XSETFRAME (inev
.frame_or_window
, f
);
5117 else if (! NILP (Vframe_list
)
5118 && ! NILP (XCDR (Vframe_list
)))
5119 /* Force a redisplay sooner or later
5120 to update the frame titles
5121 in case this is the second frame. */
5122 record_asynch_buffer_change ();
5124 /* Windows can send us a SIZE_MAXIMIZED message even
5125 when fullscreen is fullboth. The following is a
5126 simple hack to check that based on the fact that
5127 only a maximized fullscreen frame should have both
5128 top/left outside the screen. */
5129 if (EQ (fullscreen
, Qfullwidth
) || EQ (fullscreen
, Qfullheight
)
5130 || NILP (fullscreen
))
5134 x_real_positions (f
, &x
, &y
);
5136 store_frame_param (f
, Qfullscreen
, Qmaximized
);
5144 bool iconified
= FRAME_ICONIFIED_P (f
);
5146 /* The following was made unconditional in a
5147 pathetic attempt to fix bug#16967 in revision
5148 116716 but, considered counterproductive was made
5149 conditional again in revision 116727. martin */
5151 SET_FRAME_VISIBLE (f
, 1);
5152 SET_FRAME_ICONIFIED (f
, false);
5154 /* wait_reading_process_output will notice this
5155 and update the frame's display structures. */
5156 SET_FRAME_GARBAGED (f
);
5160 /* Reset top and left positions of the Window
5161 here since Windows sends a WM_MOVE message
5162 BEFORE telling us the Window is minimized
5163 when the Window is iconified, with 3000,3000
5165 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5167 inev
.kind
= DEICONIFY_EVENT
;
5168 XSETFRAME (inev
.frame_or_window
, f
);
5170 else if (! NILP (Vframe_list
)
5171 && ! NILP (XCDR (Vframe_list
)))
5172 /* Force a redisplay sooner or later
5173 to update the frame titles
5174 in case this is the second frame. */
5175 record_asynch_buffer_change ();
5178 if (EQ (get_frame_param (f
, Qfullscreen
), Qmaximized
))
5179 store_frame_param (f
, Qfullscreen
, Qnil
);
5185 if (f
&& !FRAME_ICONIFIED_P (f
) && msg
.msg
.wParam
!= SIZE_MINIMIZED
)
5188 int /* rows, columns, */ width
, height
, text_width
, text_height
;
5190 if (GetClientRect (msg
.msg
.hwnd
, &rect
)
5191 /* GetClientRect evidently returns (0, 0, 0, 0) if
5192 called on a minimized frame. Such "dimensions"
5193 aren't useful anyway. */
5194 && !(rect
.bottom
== 0
5197 && rect
.right
== 0))
5199 height
= rect
.bottom
- rect
.top
;
5200 width
= rect
.right
- rect
.left
;
5201 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, width
);
5202 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, height
);
5203 /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
5204 /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
5206 /* TODO: Clip size to the screen dimensions. */
5208 /* Even if the number of character rows and columns
5209 has not changed, the font size may have changed,
5210 so we need to check the pixel dimensions as well. */
5212 if (width
!= FRAME_PIXEL_WIDTH (f
)
5213 || height
!= FRAME_PIXEL_HEIGHT (f
)
5214 || text_width
!= FRAME_TEXT_WIDTH (f
)
5215 || text_height
!= FRAME_TEXT_HEIGHT (f
))
5217 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
5218 SET_FRAME_GARBAGED (f
);
5219 cancel_mouse_face (f
);
5220 f
->win_gravity
= NorthWestGravity
;
5225 check_visibility
= 1;
5229 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5232 if (f
== hlinfo
->mouse_face_mouse_frame
)
5234 /* If we move outside the frame, then we're
5235 certainly no longer on any text in the frame. */
5236 clear_mouse_face (hlinfo
);
5237 hlinfo
->mouse_face_mouse_frame
= 0;
5240 /* Generate a nil HELP_EVENT to cancel a help-echo.
5241 Do it only if there's something to cancel.
5242 Otherwise, the startup message is cleared when
5243 the mouse leaves the frame. */
5244 if (any_help_event_p
)
5250 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5252 dpyinfo
->grabbed
= 0;
5253 check_visibility
= 1;
5257 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5258 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5262 if (f
== hlinfo
->mouse_face_mouse_frame
)
5264 /* If we move outside the frame, then we're
5265 certainly no longer on any text in the frame. */
5266 clear_mouse_face (hlinfo
);
5267 hlinfo
->mouse_face_mouse_frame
= 0;
5270 /* Generate a nil HELP_EVENT to cancel a help-echo.
5271 Do it only if there's something to cancel.
5272 Otherwise, the startup message is cleared when
5273 the mouse leaves the frame. */
5274 if (any_help_event_p
)
5278 dpyinfo
->grabbed
= 0;
5279 check_visibility
= 1;
5283 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5287 inev
.kind
= DELETE_WINDOW_EVENT
;
5288 XSETFRAME (inev
.frame_or_window
, f
);
5293 inev
.kind
= END_SESSION_EVENT
;
5297 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5301 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
5302 XSETFRAME (inev
.frame_or_window
, f
);
5307 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5311 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
5314 check_visibility
= 1;
5317 case WM_DISPLAYCHANGE
:
5318 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5322 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5324 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
5325 /* The new display could have a different resolution, in
5326 which case we must reconsider what fullscreen means.
5327 The following code is untested yet. */
5328 if (!NILP (fullscreen
))
5330 x_set_fullscreen (f
, fullscreen
, fullscreen
);
5331 w32fullscreen_hook (f
);
5334 DebPrint (("display change: %d %d\n",
5335 (short) LOWORD (msg
.msg
.lParam
),
5336 (short) HIWORD (msg
.msg
.lParam
)));
5339 check_visibility
= 1;
5343 case WM_EMACS_FILENOTIFY
:
5344 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5346 queue_notifications (&inev
, &msg
, f
, &count
);
5351 /* Check for messages registered at runtime. */
5352 if (msg
.msg
.message
== msh_mousewheel
)
5354 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5355 msg
.msg
.message
= WM_MOUSEWHEEL
;
5361 if (inev
.kind
!= NO_EVENT
)
5363 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5368 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5373 XSETFRAME (frame
, f
);
5379 if (NILP (help_echo_string
))
5381 help_echo_object
= help_echo_window
= Qnil
;
5385 any_help_event_p
= 1;
5386 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5387 help_echo_object
, help_echo_pos
);
5391 help_echo_string
= Qnil
;
5392 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5398 /* If the focus was just given to an autoraising frame,
5399 raise it now. FIXME: handle more than one such frame. */
5400 if (dpyinfo
->w32_pending_autoraise_frame
)
5402 x_raise_frame (dpyinfo
->w32_pending_autoraise_frame
);
5403 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
5406 /* Check which frames are still visible, if we have enqueued any user
5407 events or been notified of events that may affect visibility. We
5408 do this here because there doesn't seem to be any direct
5409 notification from Windows that the visibility of a window has
5410 changed (at least, not in all cases). */
5411 if (count
> 0 || check_visibility
)
5413 Lisp_Object tail
, frame
;
5415 FOR_EACH_FRAME (tail
, frame
)
5417 struct frame
*f
= XFRAME (frame
);
5418 /* The tooltip has been drawn already. Avoid the
5419 SET_FRAME_GARBAGED below. */
5420 if (EQ (frame
, tip_frame
))
5423 /* Check "visible" frames and mark each as obscured or not.
5424 Note that visible is nonzero for unobscured and obscured
5425 frames, but zero for hidden and iconified frames. */
5426 if (FRAME_W32_P (f
) && FRAME_VISIBLE_P (f
))
5433 /* Query clipping rectangle for the entire window area
5434 (GetWindowDC), not just the client portion (GetDC).
5435 Otherwise, the scrollbars and menubar aren't counted as
5436 part of the visible area of the frame, and we may think
5437 the frame is obscured when really a scrollbar is still
5438 visible and gets WM_PAINT messages above. */
5439 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5440 GetClipBox (hdc
, &clipbox
);
5441 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5444 obscured
= FRAME_OBSCURED_P (f
);
5446 if (clipbox
.right
== clipbox
.left
|| clipbox
.bottom
== clipbox
.top
)
5448 /* Frame has become completely obscured so mark as such (we
5449 do this by setting visible to 2 so that FRAME_VISIBLE_P
5450 is still true, but redisplay will skip it). */
5451 SET_FRAME_VISIBLE (f
, 2);
5454 DebPrint (("frame %p (%s) obscured\n", f
, SDATA (f
->name
)));
5458 /* Frame is not obscured, so mark it as such. */
5459 SET_FRAME_VISIBLE (f
, 1);
5463 SET_FRAME_GARBAGED (f
);
5464 DebPrint (("obscured frame %p (%s) found to be visible\n",
5465 f
, SDATA (f
->name
)));
5467 /* Force a redisplay sooner or later. */
5468 record_asynch_buffer_change ();
5481 /***********************************************************************
5483 ***********************************************************************/
5485 /* Set clipping for output in glyph row ROW. W is the window in which
5486 we operate. GC is the graphics context to set clipping in.
5488 ROW may be a text row or, e.g., a mode line. Text rows must be
5489 clipped to the interior of the window dedicated to text display,
5490 mode lines must be clipped to the whole window. */
5493 w32_clip_to_row (struct window
*w
, struct glyph_row
*row
,
5494 enum glyph_row_area area
, HDC hdc
)
5497 int window_x
, window_y
, window_width
;
5499 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5501 clip_rect
.left
= window_x
;
5502 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5503 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5504 clip_rect
.right
= clip_rect
.left
+ window_width
;
5505 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5507 w32_set_clip_rectangle (hdc
, &clip_rect
);
5511 /* Draw a hollow box cursor on window W in glyph row ROW. */
5514 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
5516 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5520 struct glyph
*cursor_glyph
;
5521 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5523 /* Get the glyph the cursor is on. If we can't tell because
5524 the current matrix is invalid or such, give up. */
5525 cursor_glyph
= get_phys_cursor_glyph (w
);
5526 if (cursor_glyph
== NULL
)
5532 /* Compute frame-relative coordinates for phys cursor. */
5533 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5535 /* When on R2L character, show cursor at the right edge of the
5536 glyph, unless the cursor box is as wide as the glyph or wider
5537 (the latter happens when x-stretch-cursor is non-nil). */
5538 if ((cursor_glyph
->resolved_level
& 1) != 0
5539 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5540 rect
.left
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5542 rect
.bottom
= rect
.top
+ h
;
5543 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5545 hdc
= get_frame_dc (f
);
5546 /* Set clipping, draw the rectangle, and reset clipping again. */
5547 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5548 FrameRect (hdc
, &rect
, hb
);
5550 w32_set_clip_rectangle (hdc
, NULL
);
5551 release_frame_dc (f
, hdc
);
5555 /* Draw a bar cursor on window W in glyph row ROW.
5557 Implementation note: One would like to draw a bar cursor with an
5558 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5559 Unfortunately, I didn't find a font yet that has this property set.
5563 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
,
5564 int width
, enum text_cursor_kinds kind
)
5566 struct frame
*f
= XFRAME (w
->frame
);
5567 struct glyph
*cursor_glyph
;
5569 /* If cursor is out of bounds, don't draw garbage. This can happen
5570 in mini-buffer windows when switching between echo area glyphs
5572 cursor_glyph
= get_phys_cursor_glyph (w
);
5573 if (cursor_glyph
== NULL
)
5576 /* If on an image, draw like a normal cursor. That's usually better
5577 visible than drawing a bar, esp. if the image is large so that
5578 the bar might not be in the window. */
5579 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5581 struct glyph_row
*row
;
5582 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5583 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5587 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5588 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5592 /* If the glyph's background equals the color we normally draw
5593 the bar cursor in, the bar cursor in its normal color is
5594 invisible. Use the glyph's foreground color instead in this
5595 case, on the assumption that the glyph's colors are chosen so
5596 that the glyph is legible. */
5597 if (face
->background
== cursor_color
)
5598 cursor_color
= face
->foreground
;
5600 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5602 hdc
= get_frame_dc (f
);
5603 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5605 if (kind
== BAR_CURSOR
)
5608 width
= FRAME_CURSOR_WIDTH (f
);
5609 width
= min (cursor_glyph
->pixel_width
, width
);
5611 w
->phys_cursor_width
= width
;
5613 /* If the character under cursor is R2L, draw the bar cursor
5614 on the right of its glyph, rather than on the left. */
5615 if ((cursor_glyph
->resolved_level
& 1) != 0)
5616 x
+= cursor_glyph
->pixel_width
- width
;
5618 w32_fill_area (f
, hdc
, cursor_color
, x
,
5619 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5620 width
, row
->height
);
5622 else /* HBAR_CURSOR */
5624 int dummy_x
, dummy_y
, dummy_h
;
5627 width
= row
->height
;
5629 width
= min (row
->height
, width
);
5631 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
5632 &dummy_y
, &dummy_h
);
5633 if ((cursor_glyph
->resolved_level
& 1) != 0
5634 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5635 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5636 w32_fill_area (f
, hdc
, cursor_color
, x
,
5637 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5638 row
->height
- width
),
5639 w
->phys_cursor_width
, width
);
5642 w32_set_clip_rectangle (hdc
, NULL
);
5643 release_frame_dc (f
, hdc
);
5648 /* RIF: Define cursor CURSOR on frame F. */
5651 w32_define_frame_cursor (struct frame
*f
, Cursor cursor
)
5653 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5657 /* RIF: Clear area on frame F. */
5660 w32_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
5664 hdc
= get_frame_dc (f
);
5665 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5666 release_frame_dc (f
, hdc
);
5669 /* RIF: Draw or clear cursor on window W. */
5672 w32_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
,
5673 int x
, int y
, enum text_cursor_kinds cursor_type
,
5674 int cursor_width
, bool on_p
, bool active_p
)
5678 /* If the user wants to use the system caret, make sure our own
5679 cursor remains invisible. */
5680 if (w32_use_visible_system_caret
)
5682 /* Call to erase_phys_cursor here seems to use the
5683 wrong values of w->phys_cursor, as they have been
5684 overwritten before this function was called. */
5685 if (w
->phys_cursor_type
!= NO_CURSOR
)
5686 erase_phys_cursor (w
);
5688 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5689 w
->phys_cursor_width
= -1;
5693 w
->phys_cursor_type
= cursor_type
;
5696 w
->phys_cursor_on_p
= true;
5698 /* If this is the active cursor, we need to track it with the
5699 system caret, so third party software like screen magnifiers
5700 and speech synthesizers can follow the cursor. */
5703 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5704 HWND hwnd
= FRAME_W32_WINDOW (f
);
5707 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5709 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5710 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5711 w32_system_caret_window
= w
;
5712 w32_system_caret_hdr_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
5713 w32_system_caret_mode_height
= WINDOW_MODE_LINE_HEIGHT (w
);
5715 PostMessage (hwnd
, WM_IME_STARTCOMPOSITION
, 0, 0);
5717 /* If the size of the active cursor changed, destroy the old
5719 if (w32_system_caret_hwnd
5720 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5721 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5723 w32_system_caret_height
= w
->phys_cursor_height
;
5725 /* Move the system caret. */
5726 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5729 if (glyph_row
->exact_window_width_line_p
5730 && (glyph_row
->reversed_p
5731 ? (w
->phys_cursor
.hpos
< 0)
5732 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
5734 glyph_row
->cursor_in_fringe_p
= true;
5735 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
5739 switch (cursor_type
)
5741 case HOLLOW_BOX_CURSOR
:
5742 x_draw_hollow_cursor (w
, glyph_row
);
5745 case FILLED_BOX_CURSOR
:
5746 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5750 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5754 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5758 w
->phys_cursor_width
= 0;
5772 x_bitmap_icon (struct frame
*f
, Lisp_Object icon
)
5775 HANDLE small_icon
= NULL
;
5777 if (FRAME_W32_WINDOW (f
) == 0)
5781 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5782 else if (STRINGP (icon
))
5784 /* Load the main icon from the named file. */
5785 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5786 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5787 /* Try to load a small icon to go with it. */
5788 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5789 GetSystemMetrics (SM_CXSMICON
),
5790 GetSystemMetrics (SM_CYSMICON
),
5793 else if (SYMBOLP (icon
))
5797 if (EQ (icon
, intern ("application")))
5798 name
= (LPCTSTR
) IDI_APPLICATION
;
5799 else if (EQ (icon
, intern ("hand")))
5800 name
= (LPCTSTR
) IDI_HAND
;
5801 else if (EQ (icon
, intern ("question")))
5802 name
= (LPCTSTR
) IDI_QUESTION
;
5803 else if (EQ (icon
, intern ("exclamation")))
5804 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5805 else if (EQ (icon
, intern ("asterisk")))
5806 name
= (LPCTSTR
) IDI_ASTERISK
;
5807 else if (EQ (icon
, intern ("winlogo")))
5808 name
= (LPCTSTR
) IDI_WINLOGO
;
5812 main_icon
= LoadIcon (NULL
, name
);
5817 if (main_icon
== NULL
)
5820 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5821 (LPARAM
) main_icon
);
5823 /* If there is a small icon that goes with it, set that too. */
5825 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5826 (LPARAM
) small_icon
);
5832 /************************************************************************
5834 ************************************************************************/
5836 /* Display Error Handling functions not used on W32. Listing them here
5837 helps diff stay in step when comparing w32term.c with xterm.c.
5839 x_error_catcher (display, error)
5840 x_catch_errors (dpy)
5841 x_catch_errors_unwind (old_val)
5842 x_check_errors (dpy, format)
5843 x_fully_uncatch_errors ()
5844 x_had_errors_p (dpy)
5845 x_clear_errors (dpy)
5846 x_uncatch_errors (dpy, count)
5848 x_connection_signal (signalnum)
5849 x_connection_closed (dpy, error_message)
5850 x_error_quitter (display, error)
5851 x_error_handler (display, error)
5852 x_io_error_quitter (display)
5857 /* Changing the font of the frame. */
5860 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
5862 struct font
*font
= XFONT_OBJECT (font_object
);
5863 int unit
, font_ascent
, font_descent
;
5866 fontset
= fontset_from_font (font_object
);
5867 FRAME_FONTSET (f
) = fontset
;
5868 if (FRAME_FONT (f
) == font
)
5869 /* This font is already set in frame F. There's nothing more to
5873 FRAME_FONT (f
) = font
;
5874 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5875 FRAME_COLUMN_WIDTH (f
) = unit
= font
->average_width
;
5876 get_font_ascent_descent (font
, &font_ascent
, &font_descent
);
5877 FRAME_LINE_HEIGHT (f
) = font_ascent
+ font_descent
;
5879 /* Compute number of scrollbar columns. */
5880 unit
= FRAME_COLUMN_WIDTH (f
);
5881 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5882 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5883 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
5886 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
5887 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) =
5888 FRAME_CONFIG_SCROLL_BAR_COLS (f
) * unit
;
5891 /* Now make the frame display the given font. */
5892 if (FRAME_X_WINDOW (f
) != 0)
5894 /* Don't change the size of a tip frame; there's no point in
5895 doing it because it's done in Fx_show_tip, and it leads to
5896 problems because the tip frame has no widget. */
5897 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5898 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
5899 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
5903 /* X version sets font of input methods here also. */
5909 /***********************************************************************
5910 TODO: W32 Input Methods
5911 ***********************************************************************/
5912 /* Listing missing functions from xterm.c helps diff stay in step.
5914 xim_destroy_callback (xim, client_data, call_data)
5915 xim_open_dpy (dpyinfo, resource_name)
5917 xim_instantiate_callback (display, client_data, call_data)
5918 xim_initialize (dpyinfo, resource_name)
5919 xim_close_dpy (dpyinfo)
5924 /* Calculate the absolute position in frame F
5925 from its current recorded position values and gravity. */
5928 x_calc_absolute_position (struct frame
*f
)
5930 int flags
= f
->size_hint_flags
;
5932 /* The sum of the widths of the frame's left and right borders, and
5933 the sum of the heights of the frame's top and bottom borders (in
5934 pixels) drawn by Windows. */
5935 unsigned int left_right_borders_width
, top_bottom_borders_height
;
5937 /* Try to get the actual values of these two variables. We compute
5938 the border width (height) by subtracting the width (height) of
5939 the frame's client area from the width (height) of the frame's
5941 WINDOWPLACEMENT wp
= { 0 };
5942 RECT client_rect
= { 0 };
5944 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
5945 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
5947 left_right_borders_width
=
5948 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
5949 (client_rect
.right
- client_rect
.left
);
5951 top_bottom_borders_height
=
5952 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
5953 (client_rect
.bottom
- client_rect
.top
);
5957 /* Use sensible default values. */
5958 left_right_borders_width
= 8;
5959 top_bottom_borders_height
= 32;
5962 /* With multiple monitors, we can legitimately get negative
5963 coordinates (for monitors above or to the left of the primary
5964 monitor). Find the display origin to ensure negative positions
5965 are computed correctly (Bug#21173). */
5966 int display_left
= 0;
5967 int display_top
= 0;
5968 if (flags
& (XNegative
| YNegative
))
5972 list
= Fw32_display_monitor_attributes_list (Qnil
);
5973 while (CONSP (list
))
5975 Lisp_Object attributes
= CAR(list
);
5976 Lisp_Object geometry
;
5977 Lisp_Object monitor_left
, monitor_top
;
5981 geometry
= Fassoc (Qgeometry
, attributes
);
5982 if (!NILP (geometry
))
5984 monitor_left
= Fnth (make_number (1), geometry
);
5985 monitor_top
= Fnth (make_number (2), geometry
);
5987 display_left
= min (display_left
, XINT (monitor_left
));
5988 display_top
= min (display_top
, XINT (monitor_top
));
5993 /* Treat negative positions as relative to the rightmost bottommost
5994 position that fits on the screen. */
5995 if (flags
& XNegative
)
5996 f
->left_pos
= (x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
5998 - FRAME_PIXEL_WIDTH (f
)
6000 - (left_right_borders_width
- 1));
6002 if (flags
& YNegative
)
6003 f
->top_pos
= (x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
6005 - FRAME_PIXEL_HEIGHT (f
)
6007 - (top_bottom_borders_height
- 1));
6009 /* The left_pos and top_pos are now relative to the top and left
6010 screen edges, so the flags should correspond. */
6011 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6014 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
6015 to really change the position, and 0 when calling from
6016 x_make_frame_visible (in that case, XOFF and YOFF are the current
6017 position values). It is -1 when calling from x_set_frame_parameters,
6018 which means, do adjust for borders but don't change the gravity. */
6021 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
,
6024 int modified_top
, modified_left
;
6026 if (change_gravity
> 0)
6030 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6032 f
->size_hint_flags
|= XNegative
;
6034 f
->size_hint_flags
|= YNegative
;
6035 f
->win_gravity
= NorthWestGravity
;
6037 x_calc_absolute_position (f
);
6040 x_wm_set_size_hint (f
, (long) 0, false);
6042 modified_left
= f
->left_pos
;
6043 modified_top
= f
->top_pos
;
6045 my_set_window_pos (FRAME_W32_WINDOW (f
),
6047 modified_left
, modified_top
,
6049 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6054 w32fullscreen_hook (struct frame
*f
)
6056 if (FRAME_VISIBLE_P (f
))
6058 HWND hwnd
= FRAME_W32_WINDOW(f
);
6059 DWORD dwStyle
= GetWindowLong (hwnd
, GWL_STYLE
);
6061 enum fullscreen_type prev_fsmode
= FRAME_PREV_FSMODE (f
);
6064 f
->want_fullscreen
&= ~FULLSCREEN_WAIT
;
6066 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_NONE
)
6067 GetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6069 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_BOTH
)
6071 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
| WS_OVERLAPPEDWINDOW
);
6072 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6074 else if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_HEIGHT
6075 || FRAME_PREV_FSMODE (f
) == FULLSCREEN_WIDTH
)
6076 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6078 FRAME_PREV_FSMODE (f
) = f
->want_fullscreen
;
6080 if (f
->want_fullscreen
== FULLSCREEN_NONE
)
6081 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6082 else if (f
->want_fullscreen
== FULLSCREEN_MAXIMIZED
)
6084 if (prev_fsmode
== FULLSCREEN_BOTH
|| prev_fsmode
== FULLSCREEN_WIDTH
6085 || prev_fsmode
== FULLSCREEN_HEIGHT
)
6086 /* Make window normal since otherwise the subsequent
6087 maximization might fail in some cases. */
6088 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6089 ShowWindow (hwnd
, SW_MAXIMIZE
);
6091 else if (f
->want_fullscreen
== FULLSCREEN_BOTH
)
6093 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6095 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6096 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6097 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
& ~WS_OVERLAPPEDWINDOW
);
6098 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6099 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
,
6100 SWP_NOOWNERZORDER
| SWP_FRAMECHANGED
);
6102 (f
, FRAME_PIXEL_TO_TEXT_WIDTH (f
, rect
.right
- rect
.left
),
6103 FRAME_PIXEL_TO_TEXT_HEIGHT (f
, (rect
.bottom
- rect
.top
6104 - menu_bar_height
)),
6109 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6110 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6111 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6112 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6113 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, 0);
6115 if (f
->want_fullscreen
== FULLSCREEN_WIDTH
)
6117 int border_width
= GetSystemMetrics (SM_CXFRAME
);
6120 (f
, (FRAME_PIXEL_TO_TEXT_WIDTH
6121 (f
, rect
.right
- rect
.left
- 2 * border_width
)),
6126 int border_height
= GetSystemMetrics (SM_CYFRAME
);
6127 /* Won't work for wrapped menu bar. */
6128 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6129 int title_height
= GetSystemMetrics (SM_CYCAPTION
);
6132 (f
, 0, (FRAME_PIXEL_TO_TEXT_HEIGHT
6133 (f
, rect
.bottom
- rect
.top
- 2 * border_height
6134 - title_height
- menu_bar_height
)),
6139 f
->want_fullscreen
= FULLSCREEN_NONE
;
6142 if (f
->want_fullscreen
== FULLSCREEN_BOTH
6143 || f
->want_fullscreen
== FULLSCREEN_WIDTH
6144 || f
->want_fullscreen
== FULLSCREEN_HEIGHT
)
6145 do_pending_window_change (0);
6149 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
6152 /* Call this to change the size of frame F's x-window.
6153 If CHANGE_GRAVITY, change to top-left-corner window gravity
6154 for this size change and subsequent size changes.
6155 Otherwise we leave the window gravity unchanged. */
6158 x_set_window_size (struct frame
*f
, bool change_gravity
,
6159 int width
, int height
, bool pixelwise
)
6161 int pixelwidth
, pixelheight
;
6162 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
6165 int menu_bar_height
;
6169 /* Get the height of the menu bar here. It's used below to detect
6170 whether the menu bar is wrapped. It's also used to specify the
6171 third argument for AdjustWindowRect. FRAME_EXTERNAL_MENU_BAR which
6172 has been used before for that reason is unreliable because it only
6173 specifies whether we _want_ a menu bar for this frame and not
6174 whether this frame _has_ a menu bar. See bug#22105. */
6175 info
.cbSize
= sizeof (info
);
6176 info
.rcBar
.top
= info
.rcBar
.bottom
= 0;
6177 GetMenuBarInfo (FRAME_W32_WINDOW (f
), 0xFFFFFFFD, 0, &info
);
6178 menu_bar_height
= info
.rcBar
.bottom
- info
.rcBar
.top
;
6182 pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
6183 pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
6187 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
);
6188 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
);
6191 if (w32_add_wrapped_menu_bar_lines
)
6193 /* When the menu bar wraps sending a SetWindowPos shrinks the
6194 height of the frame then the wrapped menu bar lines are not
6195 accounted for (Bug#15174 and Bug#18720). Here we add these
6196 extra lines to the frame height. */
6197 int default_menu_bar_height
;
6199 /* Why is (apparently) SM_CYMENUSIZE needed here instead of
6201 default_menu_bar_height
= GetSystemMetrics (SM_CYMENUSIZE
);
6203 if ((default_menu_bar_height
> 0)
6204 && (menu_bar_height
> default_menu_bar_height
)
6205 && ((menu_bar_height
% default_menu_bar_height
) == 0))
6206 pixelheight
= pixelheight
+ menu_bar_height
- default_menu_bar_height
;
6209 f
->win_gravity
= NorthWestGravity
;
6210 x_wm_set_size_hint (f
, (long) 0, false);
6212 rect
.left
= rect
.top
= 0;
6213 rect
.right
= pixelwidth
;
6214 rect
.bottom
= pixelheight
;
6216 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
, menu_bar_height
> 0);
6218 if (!(f
->after_make_frame
)
6219 && !(f
->want_fullscreen
& FULLSCREEN_WAIT
)
6220 && FRAME_VISIBLE_P (f
))
6224 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6226 if (EQ (fullscreen
, Qmaximized
)
6227 || EQ (fullscreen
, Qfullboth
)
6228 || EQ (fullscreen
, Qfullwidth
))
6230 rect
.left
= window_rect
.left
;
6231 rect
.right
= window_rect
.right
;
6234 if (EQ (fullscreen
, Qmaximized
)
6235 || EQ (fullscreen
, Qfullboth
)
6236 || EQ (fullscreen
, Qfullheight
))
6238 rect
.top
= window_rect
.top
;
6239 rect
.bottom
= window_rect
.bottom
;
6244 if (pixelwidth
> 0 || pixelheight
> 0)
6246 frame_size_history_add
6247 (f
, Qx_set_window_size_1
, width
, height
,
6248 list2 (Fcons (make_number (pixelwidth
),
6249 make_number (pixelheight
)),
6250 Fcons (make_number (rect
.right
- rect
.left
),
6251 make_number (rect
.bottom
- rect
.top
))));
6253 my_set_window_pos (FRAME_W32_WINDOW (f
), NULL
,
6255 rect
.right
- rect
.left
,
6256 rect
.bottom
- rect
.top
,
6257 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6259 change_frame_size (f
,
6261 ? 0 : FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
)),
6263 ? 0 : FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
)),
6265 SET_FRAME_GARBAGED (f
);
6267 /* If cursor was outside the new size, mark it as off. */
6268 mark_window_cursors_off (XWINDOW (f
->root_window
));
6270 /* Clear out any recollection of where the mouse highlighting was,
6271 since it might be in a place that's outside the new frame size.
6272 Actually checking whether it is outside is a pain in the neck,
6273 so don't try--just let the highlighting be done afresh with new
6275 cancel_mouse_face (f
);
6280 do_pending_window_change (false);
6283 /* Mouse warping. */
6286 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
6295 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
6296 pt
.x
= rect
.left
+ pix_x
;
6297 pt
.y
= rect
.top
+ pix_y
;
6298 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
6300 /* When "mouse trails" are in effect, moving the mouse cursor
6301 sometimes leaves behind an annoying "ghost" of the pointer.
6302 Avoid that by momentarily switching off mouse trails. */
6303 if (os_subtype
== OS_NT
6304 && w32_major_version
+ w32_minor_version
>= 6)
6305 ret
= SystemParametersInfo (SPI_GETMOUSETRAILS
, 0, &trail_num
, 0);
6306 SetCursorPos (pt
.x
, pt
.y
);
6308 SystemParametersInfo (SPI_SETMOUSETRAILS
, trail_num
, NULL
, 0);
6314 /* focus shifting, raising and lowering. */
6317 x_focus_frame (struct frame
*f
)
6320 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6323 /* Give input focus to frame. */
6326 /* Try not to change its Z-order if possible. */
6327 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
6328 my_set_focus (f
, FRAME_W32_WINDOW (f
));
6331 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6335 /* Raise frame F. */
6337 x_raise_frame (struct frame
*f
)
6341 /* Strictly speaking, raise-frame should only change the frame's Z
6342 order, leaving input focus unchanged. This is reasonable behavior
6343 on X where the usual policy is point-to-focus. However, this
6344 behavior would be very odd on Windows where the usual policy is
6347 On X, if the mouse happens to be over the raised frame, it gets
6348 input focus anyway (so the window with focus will never be
6349 completely obscured) - if not, then just moving the mouse over it
6350 is sufficient to give it focus. On Windows, the user must actually
6351 click on the frame (preferably the title bar so as not to move
6352 point), which is more awkward. Also, no other Windows program
6353 raises a window to the top but leaves another window (possibly now
6354 completely obscured) with input focus.
6356 Because there is a system setting on Windows that allows the user
6357 to choose the point to focus policy, we make the strict semantics
6358 optional, but by default we grab focus when raising. */
6360 if (NILP (Vw32_grab_focus_on_raise
))
6362 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6363 not already the foreground application: the frame is raised
6364 above all other frames belonging to us, but not above the
6365 current top window. To achieve that, we have to resort to this
6366 more cumbersome method. */
6368 HDWP handle
= BeginDeferWindowPos (2);
6371 handle
= DeferWindowPos (handle
,
6372 FRAME_W32_WINDOW (f
),
6375 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6378 handle
= DeferWindowPos (handle
,
6379 GetForegroundWindow (),
6380 FRAME_W32_WINDOW (f
),
6382 SWP_NOSIZE
| SWP_NOMOVE
|
6385 EndDeferWindowPos (handle
);
6391 my_bring_window_to_top (FRAME_W32_WINDOW (f
));
6397 /* Lower frame F. */
6399 x_lower_frame (struct frame
*f
)
6402 my_set_window_pos (FRAME_W32_WINDOW (f
),
6405 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6410 w32_frame_raise_lower (struct frame
*f
, bool raise_flag
)
6412 if (! FRAME_W32_P (f
))
6421 /* Change of visibility. */
6423 /* This tries to wait until the frame is really visible.
6424 However, if the window manager asks the user where to position
6425 the frame, this will return before the user finishes doing that.
6426 The frame will not actually be visible at that time,
6427 but it will become visible later when the window manager
6428 finishes with it. */
6431 x_make_frame_visible (struct frame
*f
)
6435 x_set_bitmap_icon (f
);
6437 if (! FRAME_VISIBLE_P (f
))
6439 /* We test FRAME_GARBAGED_P here to make sure we don't
6440 call x_set_offset a second time
6441 if we get to x_make_frame_visible a second time
6442 before the window gets really visible. */
6443 if (! FRAME_ICONIFIED_P (f
)
6444 && ! f
->output_data
.w32
->asked_for_visible
)
6449 /* Adjust vertical window position in order to avoid being
6450 covered by a taskbar placed at the bottom of the desktop. */
6451 SystemParametersInfo (SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6452 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6453 if (window_rect
.bottom
> workarea_rect
.bottom
6454 && window_rect
.top
> workarea_rect
.top
)
6455 f
->top_pos
= max (window_rect
.top
6456 - window_rect
.bottom
+ workarea_rect
.bottom
,
6459 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6462 f
->output_data
.w32
->asked_for_visible
= 1;
6464 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
6465 causes unexpected behavior when unminimizing frames that were
6466 previously maximized. But only SW_SHOWNORMAL works properly for
6467 frames that were truely hidden (using make-frame-invisible), so
6468 we need it to avoid Bug#5482. It seems that iconified is only
6469 set for minimized windows that are still visible, so use that to
6470 determine the appropriate flag to pass ShowWindow. */
6471 my_show_window (f
, FRAME_W32_WINDOW (f
),
6472 FRAME_ICONIFIED_P (f
) ? SW_RESTORE
: SW_SHOWNORMAL
);
6475 /* Synchronize to ensure Emacs knows the frame is visible
6476 before we do anything else. We do this loop with input not blocked
6477 so that incoming events are handled. */
6482 /* This must come after we set COUNT. */
6485 XSETFRAME (frame
, f
);
6487 /* Wait until the frame is visible. Process X events until a
6488 MapNotify event has been seen, or until we think we won't get a
6489 MapNotify at all.. */
6490 for (count
= input_signal_count
+ 10;
6491 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6493 /* Force processing of queued events. */
6494 /* TODO: x_sync equivalent? */
6496 /* Machines that do polling rather than SIGIO have been observed
6497 to go into a busy-wait here. So we'll fake an alarm signal
6498 to let the handler know that there's something to be read.
6499 We used to raise a real alarm, but it seems that the handler
6500 isn't always enabled here. This is probably a bug. */
6501 if (input_polling_used ())
6503 /* It could be confusing if a real alarm arrives while processing
6504 the fake one. Turn it off and let the handler reset it. */
6505 int old_poll_suppress_count
= poll_suppress_count
;
6506 poll_suppress_count
= 1;
6507 poll_for_input_1 ();
6508 poll_suppress_count
= old_poll_suppress_count
;
6514 /* Change from mapped state to withdrawn state. */
6516 /* Make the frame visible (mapped and not iconified). */
6519 x_make_frame_invisible (struct frame
*f
)
6521 /* Don't keep the highlight on an invisible frame. */
6522 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6523 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6527 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6529 /* We can't distinguish this from iconification
6530 just by the event that we get from the server.
6531 So we can't win using the usual strategy of letting
6532 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6533 and synchronize with the server to make sure we agree. */
6534 SET_FRAME_VISIBLE (f
, 0);
6535 SET_FRAME_ICONIFIED (f
, false);
6540 /* Change window state from mapped to iconified. */
6543 x_iconify_frame (struct frame
*f
)
6545 /* Don't keep the highlight on an invisible frame. */
6546 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6547 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6549 if (FRAME_ICONIFIED_P (f
))
6554 x_set_bitmap_icon (f
);
6556 /* Simulate the user minimizing the frame. */
6557 SendMessageTimeout (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0,
6560 SET_FRAME_VISIBLE (f
, 0);
6561 SET_FRAME_ICONIFIED (f
, true);
6567 /* Free X resources of frame F. */
6570 x_free_frame_resources (struct frame
*f
)
6572 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6573 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
6577 /* We must free faces before destroying windows because some
6578 font-driver (e.g. xft) access a window while finishing a
6580 free_frame_faces (f
);
6582 if (FRAME_W32_WINDOW (f
))
6583 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6585 free_frame_menubar (f
);
6587 xfree (f
->output_data
.w32
);
6588 f
->output_data
.w32
= NULL
;
6590 if (f
== dpyinfo
->w32_focus_frame
)
6591 dpyinfo
->w32_focus_frame
= 0;
6592 if (f
== dpyinfo
->w32_focus_event_frame
)
6593 dpyinfo
->w32_focus_event_frame
= 0;
6594 if (f
== dpyinfo
->x_highlight_frame
)
6595 dpyinfo
->x_highlight_frame
= 0;
6596 if (f
== hlinfo
->mouse_face_mouse_frame
)
6597 reset_mouse_highlight (hlinfo
);
6603 /* Destroy the window of frame F. */
6605 x_destroy_window (struct frame
*f
)
6607 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6609 x_free_frame_resources (f
);
6610 dpyinfo
->reference_count
--;
6614 /* Setting window manager hints. */
6616 /* Set the normal size hints for the window manager, for frame F.
6617 FLAGS is the flags word to use--or 0 meaning preserve the flags
6618 that the window now has.
6619 If USER_POSITION, set the USPosition
6620 flag (this is useful when FLAGS is 0). */
6622 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
6624 Window window
= FRAME_W32_WINDOW (f
);
6628 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6629 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6630 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6631 SetWindowLong (window
, WND_VSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_WIDTH (f
));
6632 SetWindowLong (window
, WND_HSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_HEIGHT (f
));
6637 /***********************************************************************
6639 ***********************************************************************/
6643 /* Check that FONT is valid on frame F. It is if it can be found in F's
6647 x_check_font (struct frame
*f
, struct font
*font
)
6649 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
6650 if (font
->driver
->check
)
6651 eassert (font
->driver
->check (f
, font
) == 0);
6654 #endif /* GLYPH_DEBUG */
6656 /* Show hourglass cursor on frame F. */
6659 w32_show_hourglass (struct frame
*f
)
6661 if (!menubar_in_use
&& !current_popup_menu
)
6663 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6665 w32
->hourglass_p
= 1;
6666 SetCursor (w32
->hourglass_cursor
);
6670 /* Hide hourglass cursor on frame F. */
6673 w32_hide_hourglass (struct frame
*f
)
6675 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6677 w32
->hourglass_p
= 0;
6678 if (f
->pointer_invisible
)
6681 SetCursor (w32
->current_cursor
);
6684 /* FIXME: old code did that, but I don't know why. Anyway,
6685 this is used for non-GUI frames (see cancel_hourglass). */
6688 w32_arrow_cursor (void)
6690 SetCursor (w32_load_cursor (IDC_ARROW
));
6694 w32_toggle_invisible_pointer (struct frame
*f
, bool invisible
)
6698 if (f
->pointer_invisible
!= invisible
)
6700 f
->pointer_invisible
= invisible
;
6701 w32_define_cursor (FRAME_W32_WINDOW (f
),
6702 f
->output_data
.w32
->current_cursor
);
6708 /***********************************************************************
6710 ***********************************************************************/
6712 static int w32_initialized
= 0;
6715 w32_initialize_display_info (Lisp_Object display_name
)
6717 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6719 memset (dpyinfo
, 0, sizeof (*dpyinfo
));
6721 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
6722 dpyinfo
->w32_id_name
= xmalloc (SCHARS (Vinvocation_name
)
6723 + SCHARS (Vsystem_name
) + 2);
6724 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6725 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6727 /* Default Console mode values - overridden when running in GUI mode
6728 with values obtained from system metrics. */
6731 dpyinfo
->n_planes
= 1;
6732 dpyinfo
->n_cbits
= 4;
6733 dpyinfo
->n_fonts
= 0;
6734 dpyinfo
->smallest_font_height
= 1;
6735 dpyinfo
->smallest_char_width
= 1;
6736 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6737 dpyinfo
->horizontal_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6738 /* TODO: dpyinfo->gray */
6740 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
6743 /* Create an xrdb-style database of resources to supersede registry settings.
6744 The database is just a concatenation of C strings, finished by an additional
6745 \0. The strings are submitted to some basic normalization, so
6747 [ *]option[ *]:[ *]value...
6753 but any whitespace following value is not removed. */
6756 w32_make_rdb (char *xrm_option
)
6758 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6759 char *current
= buffer
;
6762 int before_value
= 0;
6776 if (in_option
&& (ch
== ':'))
6781 else if (before_value
)
6786 else if (!(in_option
|| before_value
))
6797 extern frame_parm_handler w32_frame_parm_handlers
[];
6799 static struct redisplay_interface w32_redisplay_interface
=
6801 w32_frame_parm_handlers
,
6805 x_clear_end_of_line
,
6807 x_after_update_window_line
,
6808 x_update_window_begin
,
6809 x_update_window_end
,
6810 0, /* flush_display */
6811 x_clear_window_mouse_face
,
6812 x_get_glyph_overhangs
,
6813 x_fix_overlapping_area
,
6814 w32_draw_fringe_bitmap
,
6815 w32_define_fringe_bitmap
,
6816 w32_destroy_fringe_bitmap
,
6817 w32_compute_glyph_string_overhangs
,
6818 x_draw_glyph_string
,
6819 w32_define_frame_cursor
,
6820 w32_clear_frame_area
,
6821 w32_draw_window_cursor
,
6822 w32_draw_vertical_window_border
,
6823 w32_draw_window_divider
,
6824 w32_shift_glyphs_for_insert
,
6829 static void x_delete_terminal (struct terminal
*term
);
6831 static struct terminal
*
6832 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6834 struct terminal
*terminal
;
6836 terminal
= create_terminal (output_w32
, &w32_redisplay_interface
);
6838 terminal
->display_info
.w32
= dpyinfo
;
6839 dpyinfo
->terminal
= terminal
;
6841 /* MSVC does not type K&R functions with no arguments correctly, and
6842 so we must explicitly cast them. */
6843 terminal
->clear_frame_hook
= x_clear_frame
;
6844 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6845 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6846 terminal
->ring_bell_hook
= w32_ring_bell
;
6847 terminal
->toggle_invisible_pointer_hook
= w32_toggle_invisible_pointer
;
6848 terminal
->update_begin_hook
= x_update_begin
;
6849 terminal
->update_end_hook
= x_update_end
;
6850 terminal
->read_socket_hook
= w32_read_socket
;
6851 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6852 terminal
->mouse_position_hook
= w32_mouse_position
;
6853 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6854 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6855 terminal
->fullscreen_hook
= w32fullscreen_hook
;
6856 terminal
->menu_show_hook
= w32_menu_show
;
6857 terminal
->popup_dialog_hook
= w32_popup_dialog
;
6858 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6859 terminal
->set_horizontal_scroll_bar_hook
= w32_set_horizontal_scroll_bar
;
6860 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6861 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6862 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6863 terminal
->delete_frame_hook
= x_destroy_window
;
6864 terminal
->delete_terminal_hook
= x_delete_terminal
;
6865 /* Other hooks are NULL by default. */
6867 /* We don't yet support separate terminals on W32, so don't try to share
6868 keyboards between virtual terminals that are on the same physical
6869 terminal like X does. */
6870 terminal
->kboard
= allocate_kboard (Qw32
);
6871 /* Don't let the initial kboard remain current longer than necessary.
6872 That would cause problems if a file loaded on startup tries to
6873 prompt in the mini-buffer. */
6874 if (current_kboard
== initial_kboard
)
6875 current_kboard
= terminal
->kboard
;
6876 terminal
->kboard
->reference_count
++;
6882 x_delete_terminal (struct terminal
*terminal
)
6884 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
6886 /* Protect against recursive calls. delete_frame in
6887 delete_terminal calls us back when it deletes our last frame. */
6888 if (!terminal
->name
)
6893 x_delete_display (dpyinfo
);
6897 struct w32_display_info
*
6898 w32_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
6900 struct w32_display_info
*dpyinfo
;
6901 struct terminal
*terminal
;
6906 if (!w32_initialized
)
6909 w32_initialized
= 1;
6912 w32_initialize_display_info (display_name
);
6914 dpyinfo
= &one_w32_display_info
;
6915 terminal
= w32_create_terminal (dpyinfo
);
6917 /* Set the name of the terminal. */
6918 terminal
->name
= xlispstrdup (display_name
);
6920 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6922 /* Put this display on the chain. */
6923 dpyinfo
->next
= x_display_list
;
6924 x_display_list
= dpyinfo
;
6928 dpyinfo
->root_window
= GetDesktopWindow ();
6929 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6930 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6931 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6932 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6933 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6934 ReleaseDC (NULL
, hdc
);
6936 /* initialize palette with white and black */
6939 w32_defined_color (0, "white", &color
, 1);
6940 w32_defined_color (0, "black", &color
, 1);
6944 /* Add the default keyboard. When !WINDOWSNT, we're using the
6945 standard Emacs console handling machinery and don't need an
6946 explicit FD here. */
6947 add_keyboard_wait_descriptor (0);
6949 /* /dev/windows wakes us up when we have a thread message pending. */
6950 add_keyboard_wait_descriptor (w32_message_fd
);
6953 /* Create Fringe Bitmaps and store them for later use.
6955 On W32, bitmaps are all unsigned short, as Windows requires
6956 bitmap data to be Word aligned. For some reason they are
6957 horizontally reflected compared to how they appear on X, so we
6958 need to bitswap and convert to unsigned shorts before creating
6960 w32_init_fringe (terminal
->rif
);
6967 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6969 x_delete_display (struct w32_display_info
*dpyinfo
)
6971 /* FIXME: the only display info apparently can't be deleted. */
6972 /* free palette table */
6974 struct w32_palette_entry
* plist
;
6976 plist
= dpyinfo
->color_list
;
6979 struct w32_palette_entry
* pentry
= plist
;
6980 plist
= plist
->next
;
6983 dpyinfo
->color_list
= NULL
;
6984 if (dpyinfo
->palette
)
6985 DeleteObject (dpyinfo
->palette
);
6987 w32_reset_fringes ();
6991 /* Set up use of W32. */
6994 w32_init_main_thread (void)
6996 dwMainThreadId
= GetCurrentThreadId ();
6997 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6998 GetCurrentProcess (), &hMainThread
, 0, TRUE
,
6999 DUPLICATE_SAME_ACCESS
);
7004 DWORD WINAPI
w32_msg_worker (void * arg
);
7007 w32_initialize (void)
7010 HRESULT (WINAPI
* set_user_model
) (const wchar_t * id
);
7014 w32_system_caret_hwnd
= NULL
;
7015 w32_system_caret_height
= 0;
7016 w32_system_caret_x
= 0;
7017 w32_system_caret_y
= 0;
7019 /* On Windows 7 and later, we need to set the user model ID
7020 to associate emacsclient launched files with Emacs frames
7022 shell
= GetModuleHandle ("shell32.dll");
7026 = (void *) GetProcAddress (shell
,
7027 "SetCurrentProcessExplicitAppUserModelID");
7029 /* If the function is defined, then we are running on Windows 7
7030 or newer, and the UI uses this to group related windows
7031 together. Since emacs, runemacs, emacsclient are related, we
7032 want them grouped even though the executables are different,
7033 so we need to set a consistent ID between them. */
7035 set_user_model (L
"GNU.Emacs");
7039 if ((w32_message_fd
= emacs_open ("/dev/windows", O_RDWR
, 0)) == -1)
7040 fatal ("opening /dev/windows: %s", strerror (errno
));
7043 /* Initialize w32_use_visible_system_caret based on whether a screen
7044 reader is in use. */
7045 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
7046 &w32_use_visible_system_caret
, 0))
7047 w32_use_visible_system_caret
= 0;
7049 any_help_event_p
= 0;
7051 /* Initialize input mode: interrupt_input off, no flow control, allow
7052 8 bit character input, standard quit char. */
7053 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
7056 LCID input_locale_id
= LOWORD (GetKeyboardLayout (0));
7057 w32_keyboard_codepage
= codepage_for_locale (input_locale_id
);
7060 /* Create the window thread - it will terminate itself when the app
7064 /* Wait for thread to start */
7068 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
7070 hWindowsThread
= CreateThread (NULL
, 0,
7072 0, 0, &dwWindowsThreadId
);
7074 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
7077 /* It is desirable that mainThread should have the same notion of
7078 focus window and active window as windowsThread. Unfortunately, the
7079 following call to AttachThreadInput, which should do precisely what
7080 we need, causes major problems when Emacs is linked as a console
7081 program. Unfortunately, we have good reasons for doing that, so
7082 instead we need to send messages to windowsThread to make some API
7083 calls for us (ones that affect, or depend on, the active/focus
7085 #ifdef ATTACH_THREADS
7086 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
7089 /* Dynamically link to optional system components. */
7091 HMODULE user_lib
= GetModuleHandle ("user32.dll");
7093 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7095 LOAD_PROC (user_lib
, SetLayeredWindowAttributes
);
7099 /* Ensure scrollbar handles are at least 5 pixels. */
7100 vertical_scroll_bar_min_handle
= 5;
7101 horizontal_scroll_bar_min_handle
= 5;
7103 /* For either kind of scroll bar, take account of the arrows; these
7104 effectively form the border of the main scroll bar range. */
7105 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
7106 = GetSystemMetrics (SM_CYVSCROLL
);
7107 horizontal_scroll_bar_left_border
= horizontal_scroll_bar_right_border
7108 = GetSystemMetrics (SM_CYHSCROLL
);
7113 syms_of_w32term (void)
7115 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
7117 DEFSYM (Qadded
, "added");
7118 DEFSYM (Qremoved
, "removed");
7119 DEFSYM (Qmodified
, "modified");
7120 DEFSYM (Qrenamed_from
, "renamed-from");
7121 DEFSYM (Qrenamed_to
, "renamed-to");
7123 DEFVAR_INT ("w32-num-mouse-buttons",
7124 w32_num_mouse_buttons
,
7125 doc
: /* Number of physical mouse buttons. */);
7126 w32_num_mouse_buttons
= 2;
7128 DEFVAR_LISP ("w32-swap-mouse-buttons",
7129 Vw32_swap_mouse_buttons
,
7130 doc
: /* Swap the mapping of middle and right mouse buttons.
7131 When nil, middle button is mouse-2 and right button is mouse-3. */);
7132 Vw32_swap_mouse_buttons
= Qnil
;
7134 DEFVAR_LISP ("w32-grab-focus-on-raise",
7135 Vw32_grab_focus_on_raise
,
7136 doc
: /* Raised frame grabs input focus.
7137 When t, `raise-frame' grabs input focus as well. This fits well
7138 with the normal Windows click-to-focus policy, but might not be
7139 desirable when using a point-to-focus policy. */);
7140 Vw32_grab_focus_on_raise
= Qt
;
7142 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7143 Vw32_capslock_is_shiftlock
,
7144 doc
: /* Apply CapsLock state to non character input keys.
7145 When nil, CapsLock only affects normal character input keys. */);
7146 Vw32_capslock_is_shiftlock
= Qnil
;
7148 DEFVAR_LISP ("w32-recognize-altgr",
7149 Vw32_recognize_altgr
,
7150 doc
: /* Recognize right-alt and left-ctrl as AltGr.
7151 When nil, the right-alt and left-ctrl key combination is
7152 interpreted normally. */);
7153 Vw32_recognize_altgr
= Qt
;
7155 DEFVAR_BOOL ("w32-use-visible-system-caret",
7156 w32_use_visible_system_caret
,
7157 doc
: /* Flag to make the system caret visible.
7158 When this is non-nil, Emacs will indicate the position of point by
7159 using the system caret instead of drawing its own cursor. Some screen
7160 reader software does not track the system cursor properly when it is
7161 invisible, and gets confused by Emacs drawing its own cursor, so this
7162 variable is initialized to t when Emacs detects that screen reader
7163 software is running as it starts up.
7165 When this variable is set, other variables affecting the appearance of
7166 the cursor have no effect. */);
7168 w32_use_visible_system_caret
= 0;
7170 /* We don't yet support this, but defining this here avoids whining
7171 from cus-start.el and other places, like "M-x set-variable". */
7172 DEFVAR_BOOL ("x-use-underline-position-properties",
7173 x_use_underline_position_properties
,
7174 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
7175 A value of nil means ignore them. If you encounter fonts with bogus
7176 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7177 to 4.1, set this to nil. You can also use `underline-minimum-offset'
7178 to override the font's UNDERLINE_POSITION for small font display
7180 x_use_underline_position_properties
= 0;
7182 DEFVAR_BOOL ("x-underline-at-descent-line",
7183 x_underline_at_descent_line
,
7184 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
7185 A value of nil means to draw the underline according to the value of the
7186 variable `x-use-underline-position-properties', which is usually at the
7187 baseline level. The default value is nil. */);
7188 x_underline_at_descent_line
= 0;
7190 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
7191 doc
: /* Which toolkit scroll bars Emacs uses, if any.
7192 A value of nil means Emacs doesn't use toolkit scroll bars.
7193 With the X Window system, the value is a symbol describing the
7194 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
7195 With MS Windows or Nextstep, the value is t. */);
7196 Vx_toolkit_scroll_bars
= Qt
;
7198 DEFVAR_BOOL ("w32-unicode-filenames",
7199 w32_unicode_filenames
,
7200 doc
: /* Non-nil means use Unicode APIs when passing file names to the OS.
7201 A value of nil means file names passed to the OS APIs and returned
7202 from those APIs are encoded/decoded using the ANSI codepage
7203 specified by `file-name-coding-system'.
7205 This variable is set to non-nil by default when Emacs runs on Windows
7206 systems of the NT family, including W2K, XP, Vista, Windows 7 and
7207 Windows 8. It is set to nil on Windows 9X. */);
7208 if (os_subtype
== OS_9X
)
7209 w32_unicode_filenames
= 0;
7211 w32_unicode_filenames
= 1;
7214 /* FIXME: The following variable will be (hopefully) removed
7215 before Emacs 25.1 gets released. */
7217 DEFVAR_BOOL ("w32-add-wrapped-menu-bar-lines",
7218 w32_add_wrapped_menu_bar_lines
,
7219 doc
: /* Non-nil means frame resizing accounts for wrapped menu bar lines.
7220 A value of nil means frame resizing does not add the height of wrapped
7221 menu bar lines when sending a frame resize request to the Windows API.
7222 This usually means that the resulting frame height is off by the number
7223 of wrapped menu bar lines. If this is non-nil, Emacs adds the height of
7224 wrapped menu bar lines when sending frame resize requests to the Windows
7226 w32_add_wrapped_menu_bar_lines
= 1;
7228 /* Tell Emacs about this window system. */
7229 Fprovide (Qw32
, Qnil
);