1 /* Implementation of GUI terminal on the Microsoft Windows API.
3 Copyright (C) 1989, 1993-2016 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or (at
10 your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
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
, Window window
, 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 SendMessage (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0);
554 w
->output_cursor
= w
->cursor
;
558 if (f
== hlinfo
->mouse_face_mouse_frame
)
560 /* Don't do highlighting for mouse motion during the update. */
561 hlinfo
->mouse_face_defer
= true;
563 /* If F needs to be redrawn, simply forget about any prior mouse
565 if (FRAME_GARBAGED_P (f
))
566 hlinfo
->mouse_face_window
= Qnil
;
568 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
569 their mouse_face_p flag set, which means that they are always
570 unequal to rows in a desired matrix which never have that
571 flag set. So, rows containing mouse-face glyphs are never
572 scrolled, and we don't have to switch the mouse highlight off
573 here to prevent it from being scrolled. */
575 /* Can we tell that this update does not affect the window
576 where the mouse highlight is? If so, no need to turn off.
577 Likewise, don't do anything if the frame is garbaged;
578 in that case, the frame's current matrix that we would use
579 is all wrong, and we will redisplay that line anyway. */
580 if (!NILP (hlinfo
->mouse_face_window
)
581 && w
== XWINDOW (hlinfo
->mouse_face_window
))
585 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
586 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
589 if (i
< w
->desired_matrix
->nrows
)
590 clear_mouse_face (hlinfo
);
598 /* Draw a vertical window border from (x,y0) to (x,y1) */
601 w32_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
603 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
613 hdc
= get_frame_dc (f
);
614 face
= FACE_FROM_ID_OR_NULL (f
, VERTICAL_BORDER_FACE_ID
);
616 w32_fill_rect (f
, hdc
, face
->foreground
, &r
);
618 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
620 release_frame_dc (f
, hdc
);
624 /* Draw a window divider from (x0, y0) to (x1, y1) */
627 w32_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
629 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
630 HDC hdc
= get_frame_dc (f
);
631 struct face
*face
= FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_FACE_ID
);
632 struct face
*face_first
633 = FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
634 struct face
*face_last
635 = FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
636 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
637 unsigned long color_first
= (face_first
638 ? face_first
->foreground
639 : FRAME_FOREGROUND_PIXEL (f
));
640 unsigned long color_last
= (face_last
641 ? face_last
->foreground
642 : FRAME_FOREGROUND_PIXEL (f
));
644 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
647 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x0
+ 1, y1
);
648 w32_fill_area_abs (f
, hdc
, color
, x0
+ 1, y0
, x1
- 1, y1
);
649 w32_fill_area_abs (f
, hdc
, color_last
, x1
- 1, y0
, x1
, y1
);
651 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
654 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x1
, y0
+ 1);
655 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
+ 1, x1
, y1
- 1);
656 w32_fill_area_abs (f
, hdc
, color_last
, x0
, y1
- 1, x1
, y1
);
659 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
, x1
, y1
);
661 release_frame_dc (f
, hdc
);
664 /* End update of window W.
666 Draw vertical borders between horizontally adjacent windows, and
667 display W's cursor if CURSOR_ON_P is non-zero.
669 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
670 glyphs in mouse-face were overwritten. In that case we have to
671 make sure that the mouse-highlight is properly redrawn.
673 W may be a menu bar pseudo-window in case we don't have X toolkit
674 support. Such windows don't have a cursor, so don't display it
678 x_update_window_end (struct window
*w
, bool cursor_on_p
,
679 bool mouse_face_overwritten_p
)
681 if (!w
->pseudo_window_p
)
686 display_and_set_cursor (w
, true,
687 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
688 w
->output_cursor
.x
, w
->output_cursor
.y
);
690 if (draw_window_fringes (w
, true))
692 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
693 x_draw_right_divider (w
);
695 x_draw_vertical_border (w
);
701 /* If a row with mouse-face was overwritten, arrange for
702 XTframe_up_to_date to redisplay the mouse highlight. */
703 if (mouse_face_overwritten_p
)
705 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
707 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
708 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
709 hlinfo
->mouse_face_window
= Qnil
;
712 /* Unhide the caret. This won't actually show the cursor, unless it
713 was visible before the corresponding call to HideCaret in
714 x_update_window_begin. */
715 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
717 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
722 /* End update of frame F. This function is installed as a hook in
726 x_update_end (struct frame
*f
)
728 if (! FRAME_W32_P (f
))
731 /* Mouse highlight may be displayed again. */
732 MOUSE_HL_INFO (f
)->mouse_face_defer
= false;
736 /* This function is called from various places in xdisp.c
737 whenever a complete update has been performed. */
740 w32_frame_up_to_date (struct frame
*f
)
743 FRAME_MOUSE_UPDATE (f
);
747 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
748 arrow bitmaps, or clear the fringes if no bitmaps are required
749 before DESIRED_ROW is made current. This function is called from
750 update_window_line only if it is known that there are differences
751 between bitmaps to be drawn between current row and DESIRED_ROW. */
754 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
761 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
762 desired_row
->redraw_fringe_bitmaps_p
= true;
764 /* When a window has disappeared, make sure that no rest of
765 full-width rows stays visible in the internal border. Could
766 check here if updated window is the leftmost/rightmost window,
767 but I guess it's not worth doing since vertically split windows
768 are almost never used, internal border is rarely set, and the
769 overhead is very small. */
770 if (windows_or_buffers_changed
771 && desired_row
->full_width_p
772 && (f
= XFRAME (w
->frame
),
773 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
775 && (height
= desired_row
->visible_height
,
778 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
782 HDC hdc
= get_frame_dc (f
);
783 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
784 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
786 release_frame_dc (f
, hdc
);
793 /* Draw the bitmap WHICH in one of the left or right fringes of
794 window W. ROW is the glyph row for which to display the bitmap; it
795 determines the vertical position at which the bitmap has to be
799 w32_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
,
800 struct draw_fringe_bitmap_params
*p
)
802 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
804 struct face
*face
= p
->face
;
806 hdc
= get_frame_dc (f
);
808 /* Must clip because of partially visible lines. */
809 w32_clip_to_row (w
, row
, ANY_AREA
, hdc
);
811 if (p
->bx
>= 0 && !p
->overlay_p
)
812 w32_fill_area (f
, hdc
, face
->background
,
813 p
->bx
, p
->by
, p
->nx
, p
->ny
);
815 if (p
->which
&& p
->which
< max_fringe_bmp
)
817 HBITMAP pixmap
= fringe_bmp
[p
->which
];
821 compat_hdc
= CreateCompatibleDC (hdc
);
825 horig_obj
= SelectObject (compat_hdc
, pixmap
);
827 /* Paint overlays transparently. */
830 HBRUSH h_brush
, h_orig_brush
;
832 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
833 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
834 h_brush
= CreateSolidBrush (face
->foreground
);
835 h_orig_brush
= SelectObject (hdc
, h_brush
);
837 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
838 compat_hdc
, 0, p
->dh
,
840 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
841 compat_hdc
, 0, p
->dh
,
843 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
844 compat_hdc
, 0, p
->dh
,
847 SelectObject (hdc
, h_orig_brush
);
848 DeleteObject (h_brush
);
852 SetTextColor (hdc
, face
->background
);
853 SetBkColor (hdc
, (p
->cursor_p
854 ? f
->output_data
.w32
->cursor_pixel
855 : face
->foreground
));
857 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
858 compat_hdc
, 0, p
->dh
,
862 SelectObject (compat_hdc
, horig_obj
);
863 DeleteDC (compat_hdc
);
867 w32_set_clip_rectangle (hdc
, NULL
);
869 release_frame_dc (f
, hdc
);
873 w32_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
875 if (which
>= max_fringe_bmp
)
877 int i
= max_fringe_bmp
;
878 max_fringe_bmp
= which
+ 20;
879 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
880 while (i
< max_fringe_bmp
)
884 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
888 w32_destroy_fringe_bitmap (int which
)
890 if (which
>= max_fringe_bmp
)
893 if (fringe_bmp
[which
])
894 DeleteObject (fringe_bmp
[which
]);
895 fringe_bmp
[which
] = 0;
898 /***********************************************************************
900 ***********************************************************************/
902 /* Function prototypes of this page. */
904 static void x_set_glyph_string_clipping (struct glyph_string
*);
905 static void x_set_glyph_string_gc (struct glyph_string
*);
906 static void x_draw_glyph_string_background (struct glyph_string
*,
908 static void x_draw_glyph_string_foreground (struct glyph_string
*);
909 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
910 static void x_draw_glyph_string_box (struct glyph_string
*);
911 static void x_draw_glyph_string (struct glyph_string
*);
912 static void x_set_cursor_gc (struct glyph_string
*);
913 static void x_set_mode_line_face_gc (struct glyph_string
*);
914 static void x_set_mouse_face_gc (struct glyph_string
*);
915 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
916 static void w32_setup_relief_color (struct frame
*, struct relief
*,
917 double, int, COLORREF
);
918 static void x_setup_relief_colors (struct glyph_string
*);
919 static void x_draw_image_glyph_string (struct glyph_string
*);
920 static void x_draw_image_relief (struct glyph_string
*);
921 static void x_draw_image_foreground (struct glyph_string
*);
922 static void w32_draw_image_foreground_1 (struct glyph_string
*, HBITMAP
);
923 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
925 static void w32_draw_relief_rect (struct frame
*, int, int, int, int,
926 int, int, int, int, int, int,
928 static void w32_draw_box_rect (struct glyph_string
*, int, int, int, int,
929 int, bool, bool, RECT
*);
932 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
936 x_set_cursor_gc (struct glyph_string
*s
)
938 if (s
->font
== FRAME_FONT (s
->f
)
939 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
940 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
942 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
945 /* Cursor on non-default face: must merge. */
949 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
950 xgcv
.foreground
= s
->face
->background
;
952 /* If the glyph would be invisible, try a different foreground. */
953 if (xgcv
.foreground
== xgcv
.background
)
954 xgcv
.foreground
= s
->face
->foreground
;
955 if (xgcv
.foreground
== xgcv
.background
)
956 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
957 if (xgcv
.foreground
== xgcv
.background
)
958 xgcv
.foreground
= s
->face
->foreground
;
960 /* Make sure the cursor is distinct from text in this face. */
961 if (xgcv
.background
== s
->face
->background
962 && xgcv
.foreground
== s
->face
->foreground
)
964 xgcv
.background
= s
->face
->foreground
;
965 xgcv
.foreground
= s
->face
->background
;
968 IF_DEBUG (x_check_font (s
->f
, s
->font
));
970 mask
= GCForeground
| GCBackground
| GCFont
;
972 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
973 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
976 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
977 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
979 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
984 /* Set up S->gc of glyph string S for drawing text in mouse face. */
987 x_set_mouse_face_gc (struct glyph_string
*s
)
992 /* What face has to be used last for the mouse face? */
993 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
994 face
= FACE_FROM_ID_OR_NULL (s
->f
, face_id
);
996 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
998 if (s
->first_glyph
->type
== CHAR_GLYPH
)
999 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1001 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1002 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1003 prepare_face_for_display (s
->f
, s
->face
);
1005 /* If font in this face is same as S->font, use it. */
1006 if (s
->font
== s
->face
->font
)
1007 s
->gc
= s
->face
->gc
;
1010 /* Otherwise construct scratch_cursor_gc with values from FACE
1015 xgcv
.background
= s
->face
->background
;
1016 xgcv
.foreground
= s
->face
->foreground
;
1017 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1018 xgcv
.font
= s
->font
;
1019 mask
= GCForeground
| GCBackground
| GCFont
;
1021 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1022 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1025 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1026 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1028 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1031 eassert (s
->gc
!= 0);
1035 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1036 Faces to use in the mode line have already been computed when the
1037 matrix was built, so there isn't much to do, here. */
1040 x_set_mode_line_face_gc (struct glyph_string
*s
)
1042 s
->gc
= s
->face
->gc
;
1046 /* Set S->gc of glyph string S for drawing that glyph string. Set
1047 S->stippled_p to a non-zero value if the face of S has a stipple
1051 x_set_glyph_string_gc (struct glyph_string
*s
)
1053 prepare_face_for_display (s
->f
, s
->face
);
1055 if (s
->hl
== DRAW_NORMAL_TEXT
)
1057 s
->gc
= s
->face
->gc
;
1058 s
->stippled_p
= s
->face
->stipple
!= 0;
1060 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1062 x_set_mode_line_face_gc (s
);
1063 s
->stippled_p
= s
->face
->stipple
!= 0;
1065 else if (s
->hl
== DRAW_CURSOR
)
1067 x_set_cursor_gc (s
);
1068 s
->stippled_p
= false;
1070 else if (s
->hl
== DRAW_MOUSE_FACE
)
1072 x_set_mouse_face_gc (s
);
1073 s
->stippled_p
= s
->face
->stipple
!= 0;
1075 else if (s
->hl
== DRAW_IMAGE_RAISED
1076 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1078 s
->gc
= s
->face
->gc
;
1079 s
->stippled_p
= s
->face
->stipple
!= 0;
1084 /* GC must have been set. */
1085 eassert (s
->gc
!= 0);
1089 /* Set clipping for output of glyph string S. S may be part of a mode
1090 line or menu if we don't have X toolkit support. */
1093 x_set_glyph_string_clipping (struct glyph_string
*s
)
1096 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1099 w32_set_clip_rectangle (s
->hdc
, r
);
1102 HRGN clip1
= CreateRectRgnIndirect (r
);
1103 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
1104 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
1105 SelectClipRgn (s
->hdc
, clip1
);
1106 DeleteObject (clip1
);
1107 DeleteObject (clip2
);
1112 /* Set SRC's clipping for output of glyph string DST. This is called
1113 when we are drawing DST's left_overhang or right_overhang only in
1117 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
,
1118 struct glyph_string
*dst
)
1123 r
.right
= r
.left
+ src
->width
;
1125 r
.bottom
= r
.top
+ src
->height
;
1128 w32_set_clip_rectangle (dst
->hdc
, &r
);
1132 Compute left and right overhang of glyph string S. */
1135 w32_compute_glyph_string_overhangs (struct glyph_string
*s
)
1138 && s
->first_glyph
->type
== CHAR_GLYPH
1139 && !s
->font_not_found_p
)
1141 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1142 struct font
*font
= s
->font
;
1143 struct font_metrics metrics
;
1146 for (i
= 0; i
< s
->nchars
; i
++)
1147 code
[i
] = s
->char2b
[i
];
1148 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1149 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1150 ? metrics
.rbearing
- metrics
.width
: 0);
1151 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1155 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1156 s
->left_overhang
= -s
->cmp
->lbearing
;
1160 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1163 x_clear_glyph_string_rect (struct glyph_string
*s
,
1164 int x
, int y
, int w
, int h
)
1171 /* Take clipping into account. */
1172 if (s
->gc
->clip_mask
== Rect
)
1174 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1175 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1176 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1177 - s
->gc
->clip_rectangle
.left
);
1178 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1179 - s
->gc
->clip_rectangle
.top
);
1182 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1187 /* Draw the background of glyph_string S. If S->background_filled_p
1188 is non-zero don't draw it. FORCE_P non-zero means draw the
1189 background even if it wouldn't be drawn normally. This is used
1190 when a string preceding S draws into the background of S, or S
1191 contains the first component of a composition. */
1194 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1196 /* Nothing to do if background has already been drawn or if it
1197 shouldn't be drawn in the first place. */
1198 if (!s
->background_filled_p
)
1200 int box_line_width
= max (s
->face
->box_line_width
, 0);
1202 #if 0 /* TODO: stipple */
1205 /* Fill background with a stipple pattern. */
1206 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1207 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1208 s
->y
+ box_line_width
,
1209 s
->background_width
,
1210 s
->height
- 2 * box_line_width
);
1211 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1212 s
->background_filled_p
= true;
1216 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1217 /* When xdisp.c ignores FONT_HEIGHT, we cannot trust
1218 font dimensions, since the actual glyphs might be
1219 much smaller. So in that case we always clear the
1220 rectangle with background color. */
1221 || FONT_TOO_HIGH (s
->font
)
1222 || s
->font_not_found_p
1223 || s
->extends_to_end_of_line_p
1226 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1227 s
->background_width
,
1228 s
->height
- 2 * box_line_width
);
1229 s
->background_filled_p
= true;
1235 /* Draw the foreground of glyph string S. */
1238 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1242 /* If first glyph of S has a left box line, start drawing the text
1243 of S to the right of that box line. */
1244 if (s
->face
->box
!= FACE_NO_BOX
1245 && s
->first_glyph
->left_box_line_p
)
1246 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1250 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1251 SetBkColor (s
->hdc
, s
->gc
->background
);
1252 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1254 /* Draw characters of S as rectangles if S's font could not be
1256 if (s
->font_not_found_p
)
1258 for (i
= 0; i
< s
->nchars
; ++i
)
1260 struct glyph
*g
= s
->first_glyph
+ i
;
1262 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1264 x
+= g
->pixel_width
;
1269 struct font
*font
= s
->font
;
1270 int boff
= font
->baseline_offset
;
1274 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1276 if (font
->vertical_centering
)
1277 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1279 y
= s
->ybase
- boff
;
1281 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1282 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, false);
1284 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, true);
1285 if (s
->face
->overstrike
)
1286 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, false);
1288 SelectObject (s
->hdc
, old_font
);
1292 /* Draw the foreground of composite glyph string S. */
1295 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1298 struct font
*font
= s
->font
;
1300 /* If first glyph of S has a left box line, start drawing the text
1301 of S to the right of that box line. */
1302 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1303 && s
->first_glyph
->left_box_line_p
)
1304 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1308 /* S is a glyph string for a composition. S->cmp_from is the index
1309 of the first character drawn for glyphs of this composition.
1310 S->cmp_from == 0 means we are drawing the very first character of
1311 this composition. */
1313 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1314 SetBkColor (s
->hdc
, s
->gc
->background
);
1315 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1317 /* Draw a rectangle for the composition if the font for the very
1318 first character of the composition could not be loaded. */
1319 if (s
->font_not_found_p
)
1321 if (s
->cmp_from
== 0)
1322 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1325 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1330 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1332 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1333 /* TAB in a composition means display glyphs with padding
1334 space on the left or right. */
1335 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1337 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1338 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1340 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, false);
1341 if (s
->face
->overstrike
)
1342 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, false);
1344 SelectObject (s
->hdc
, old_font
);
1348 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1354 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1356 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1358 glyph
= LGSTRING_GLYPH (gstring
, i
);
1359 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1360 width
+= LGLYPH_WIDTH (glyph
);
1363 int xoff
, yoff
, wadjust
;
1367 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1370 xoff
= LGLYPH_XOFF (glyph
);
1371 yoff
= LGLYPH_YOFF (glyph
);
1372 wadjust
= LGLYPH_WADJUST (glyph
);
1373 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, false);
1380 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1382 SelectObject (s
->hdc
, old_font
);
1387 /* Draw the foreground of glyph string S for glyphless characters. */
1390 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1392 struct glyph
*glyph
= s
->first_glyph
;
1395 bool with_background
;
1397 /* If first glyph of S has a left box line, start drawing the text
1398 of S to the right of that box line. */
1399 if (s
->face
->box
!= FACE_NO_BOX
1400 && s
->first_glyph
->left_box_line_p
)
1401 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1405 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1406 SetBkColor (s
->hdc
, s
->gc
->background
);
1407 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1410 with_background
= ((s
->for_overlaps
1411 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))) == 0;
1412 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1414 char buf
[7], *str
= NULL
;
1415 int len
= glyph
->u
.glyphless
.len
;
1417 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1420 && CHAR_TABLE_P (Vglyphless_char_display
)
1421 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1425 = (! glyph
->u
.glyphless
.for_no_font
1426 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1427 glyph
->u
.glyphless
.ch
)
1428 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1429 if (STRINGP (acronym
))
1430 str
= SSDATA (acronym
);
1433 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1435 sprintf ((char *) buf
, "%0*X",
1436 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1437 (unsigned int) glyph
->u
.glyphless
.ch
);
1441 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1442 w32_draw_rectangle (s
->hdc
, s
->gc
,
1443 x
, s
->ybase
- glyph
->ascent
,
1444 glyph
->pixel_width
- 1,
1445 glyph
->ascent
+ glyph
->descent
- 1);
1448 struct font
*font
= s
->font
;
1449 int upper_len
= (len
+ 1) / 2;
1453 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1454 /* It is certain that all LEN characters in STR are ASCII. */
1455 for (j
= 0; j
< len
; j
++)
1457 code
= font
->driver
->encode_char (font
, str
[j
]);
1458 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1460 font
->driver
->draw (s
, 0, upper_len
,
1461 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1462 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1464 font
->driver
->draw (s
, upper_len
, len
,
1465 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1466 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1468 SelectObject (s
->hdc
, old_font
);
1470 x
+= glyph
->pixel_width
;
1475 /* Brightness beyond which a color won't have its highlight brightness
1478 Nominally, highlight colors for `3d' faces are calculated by
1479 brightening an object's color by a constant scale factor, but this
1480 doesn't yield good results for dark colors, so for colors whose
1481 brightness is less than this value (on a scale of 0-255) have to
1482 use an additional additive factor.
1484 The value here is set so that the default menu-bar/mode-line color
1485 (grey75) will not have its highlights changed at all. */
1486 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1489 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1490 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1491 If this produces the same color as COLOR, try a color where all RGB
1492 values have DELTA added. Return the allocated color in *COLOR.
1493 DISPLAY is the X display, CMAP is the colormap to operate on.
1494 Value is non-zero if successful. */
1497 w32_alloc_lighter_color (struct frame
*f
, COLORREF
*color
,
1498 double factor
, int delta
)
1503 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1506 /* Change RGB values by specified FACTOR. Avoid overflow! */
1507 eassert (factor
>= 0);
1508 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1509 min (0xff, factor
* GetGValue (*color
)),
1510 min (0xff, factor
* GetBValue (*color
)));
1512 /* Calculate brightness of COLOR. */
1513 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1514 + GetBValue (*color
)) / 6;
1516 /* We only boost colors that are darker than
1517 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1518 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1519 /* Make an additive adjustment to NEW, because it's dark enough so
1520 that scaling by FACTOR alone isn't enough. */
1522 /* How far below the limit this color is (0 - 1, 1 being darker). */
1523 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1524 /* The additive adjustment. */
1525 int min_delta
= delta
* dimness
* factor
/ 2;
1528 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1529 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1530 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1532 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1533 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1534 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1538 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1539 max (0, min (0xff, delta
+ GetGValue (*color
))),
1540 max (0, min (0xff, delta
+ GetBValue (*color
))));
1542 /* TODO: Map to palette and retry with delta if same? */
1543 /* TODO: Free colors (if using palette)? */
1553 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1554 colors in COLORS. On W32, we no longer try to map colors to
1557 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1561 for (i
= 0; i
< ncolors
; i
++)
1563 DWORD pixel
= colors
[i
].pixel
;
1564 /* Convert to a 16 bit value in range 0 - 0xffff. */
1565 colors
[i
].red
= GetRValue (pixel
) * 257;
1566 colors
[i
].green
= GetGValue (pixel
) * 257;
1567 colors
[i
].blue
= GetBValue (pixel
) * 257;
1572 x_query_color (struct frame
*f
, XColor
*color
)
1574 x_query_colors (f
, color
, 1);
1578 /* Set up the foreground color for drawing relief lines of glyph
1579 string S. RELIEF is a pointer to a struct relief containing the GC
1580 with which lines will be drawn. Use a color that is FACTOR or
1581 DELTA lighter or darker than the relief's background which is found
1582 in S->f->output_data.x->relief_background. If such a color cannot
1583 be allocated, use DEFAULT_PIXEL, instead. */
1586 w32_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
1587 int delta
, COLORREF default_pixel
)
1590 struct w32_output
*di
= f
->output_data
.w32
;
1591 unsigned long mask
= GCForeground
;
1593 COLORREF background
= di
->relief_background
;
1595 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1598 /* TODO: Free colors (if using palette)? */
1600 /* Allocate new color. */
1601 xgcv
.foreground
= default_pixel
;
1603 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1604 xgcv
.foreground
= relief
->pixel
= pixel
;
1606 if (relief
->gc
== 0)
1608 #if 0 /* TODO: stipple */
1609 xgcv
.stipple
= dpyinfo
->gray
;
1612 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1615 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1619 /* Set up colors for the relief lines around glyph string S. */
1622 x_setup_relief_colors (struct glyph_string
*s
)
1624 struct w32_output
*di
= s
->f
->output_data
.w32
;
1627 if (s
->face
->use_box_color_for_shadows_p
)
1628 color
= s
->face
->box_color
;
1629 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1631 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1632 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1634 color
= s
->gc
->background
;
1636 if (di
->white_relief
.gc
== 0
1637 || color
!= di
->relief_background
)
1639 di
->relief_background
= color
;
1640 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1641 WHITE_PIX_DEFAULT (s
->f
));
1642 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1643 BLACK_PIX_DEFAULT (s
->f
));
1648 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1649 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1650 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1651 relief. LEFT_P non-zero means draw a relief on the left side of
1652 the rectangle. RIGHT_P non-zero means draw a relief on the right
1653 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1657 w32_draw_relief_rect (struct frame
*f
,
1658 int left_x
, int top_y
, int right_x
, int bottom_y
,
1659 int width
, int raised_p
,
1660 int top_p
, int bot_p
, int left_p
, int right_p
,
1665 HDC hdc
= get_frame_dc (f
);
1668 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1670 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1672 w32_set_clip_rectangle (hdc
, clip_rect
);
1676 for (i
= 0; i
< width
; ++i
)
1677 w32_fill_area (f
, hdc
, gc
.foreground
,
1678 left_x
+ i
* left_p
, top_y
+ i
,
1679 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1683 for (i
= 0; i
< width
; ++i
)
1684 w32_fill_area (f
, hdc
, gc
.foreground
,
1685 left_x
+ i
, top_y
+ (i
+ 1) * top_p
, 1,
1686 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1689 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1691 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1695 for (i
= 0; i
< width
; ++i
)
1696 w32_fill_area (f
, hdc
, gc
.foreground
,
1697 left_x
+ i
* left_p
, bottom_y
- i
,
1698 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1702 for (i
= 0; i
< width
; ++i
)
1703 w32_fill_area (f
, hdc
, gc
.foreground
,
1704 right_x
- i
, top_y
+ (i
+ 1) * top_p
, 1,
1705 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1707 w32_set_clip_rectangle (hdc
, NULL
);
1709 release_frame_dc (f
, hdc
);
1713 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1714 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1715 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1716 left side of the rectangle. RIGHT_P non-zero means draw a line
1717 on the right side of the rectangle. CLIP_RECT is the clipping
1718 rectangle to use when drawing. */
1721 w32_draw_box_rect (struct glyph_string
*s
,
1722 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1723 bool left_p
, bool right_p
, RECT
*clip_rect
)
1725 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1728 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1729 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1734 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1735 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1739 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1740 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1745 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1746 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1749 w32_set_clip_rectangle (s
->hdc
, NULL
);
1753 /* Draw a box around glyph string S. */
1756 x_draw_glyph_string_box (struct glyph_string
*s
)
1758 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
;
1759 bool left_p
, right_p
, raised_p
;
1760 struct glyph
*last_glyph
;
1763 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1764 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1765 : window_box_right (s
->w
, s
->area
));
1767 /* The glyph that may have a right box line. */
1768 last_glyph
= (s
->cmp
|| s
->img
1770 : s
->first_glyph
+ s
->nchars
- 1);
1772 width
= eabs (s
->face
->box_line_width
);
1773 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1775 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1777 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1779 bottom_y
= top_y
+ s
->height
- 1;
1781 left_p
= (s
->first_glyph
->left_box_line_p
1782 || (s
->hl
== DRAW_MOUSE_FACE
1784 || s
->prev
->hl
!= s
->hl
)));
1785 right_p
= (last_glyph
->right_box_line_p
1786 || (s
->hl
== DRAW_MOUSE_FACE
1788 || s
->next
->hl
!= s
->hl
)));
1790 get_glyph_string_clip_rect (s
, &clip_rect
);
1792 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1793 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1794 left_p
, right_p
, &clip_rect
);
1797 x_setup_relief_colors (s
);
1798 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1799 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1804 /* Draw foreground of image glyph string S. */
1807 x_draw_image_foreground (struct glyph_string
*s
)
1810 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1812 /* If first glyph of S has a left box line, start drawing it to the
1813 right of that line. */
1814 if (s
->face
->box
!= FACE_NO_BOX
1815 && s
->first_glyph
->left_box_line_p
1817 x
+= eabs (s
->face
->box_line_width
);
1819 /* If there is a margin around the image, adjust x- and y-position
1821 if (s
->slice
.x
== 0)
1822 x
+= s
->img
->hmargin
;
1823 if (s
->slice
.y
== 0)
1824 y
+= s
->img
->vmargin
;
1830 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
1831 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1832 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
1833 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1834 SetBkColor (compat_hdc
, RGB (255, 255, 255));
1835 SetTextColor (s
->hdc
, RGB (0, 0, 0));
1836 x_set_glyph_string_clipping (s
);
1840 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
1841 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1843 SetTextColor (s
->hdc
, RGB (255, 255, 255));
1844 SetBkColor (s
->hdc
, RGB (0, 0, 0));
1846 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1847 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1848 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1849 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1850 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1851 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1853 SelectObject (mask_dc
, mask_orig_obj
);
1858 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1859 SetBkColor (s
->hdc
, s
->gc
->background
);
1861 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1862 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1864 /* When the image has a mask, we can expect that at
1865 least part of a mouse highlight or a block cursor will
1866 be visible. If the image doesn't have a mask, make
1867 a block cursor visible by drawing a rectangle around
1868 the image. I believe it's looking better if we do
1869 nothing here for mouse-face. */
1870 if (s
->hl
== DRAW_CURSOR
)
1872 int r
= s
->img
->relief
;
1874 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
1875 s
->slice
.width
+ r
*2 - 1,
1876 s
->slice
.height
+ r
*2 - 1);
1880 w32_set_clip_rectangle (s
->hdc
, NULL
);
1881 SelectObject (s
->hdc
, orig_brush
);
1882 DeleteObject (fg_brush
);
1883 SelectObject (compat_hdc
, orig_obj
);
1884 DeleteDC (compat_hdc
);
1887 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
1888 s
->slice
.width
- 1, s
->slice
.height
- 1);
1890 RestoreDC (s
->hdc
,-1);
1894 /* Draw a relief around the image glyph string S. */
1897 x_draw_image_relief (struct glyph_string
*s
)
1899 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
1900 int extra_x
, extra_y
;
1903 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1905 /* If first glyph of S has a left box line, start drawing it to the
1906 right of that line. */
1907 if (s
->face
->box
!= FACE_NO_BOX
1908 && s
->first_glyph
->left_box_line_p
1910 x
+= eabs (s
->face
->box_line_width
);
1912 /* If there is a margin around the image, adjust x- and y-position
1914 if (s
->slice
.x
== 0)
1915 x
+= s
->img
->hmargin
;
1916 if (s
->slice
.y
== 0)
1917 y
+= s
->img
->vmargin
;
1919 if (s
->hl
== DRAW_IMAGE_SUNKEN
1920 || s
->hl
== DRAW_IMAGE_RAISED
)
1922 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
1923 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
1924 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
1928 thick
= eabs (s
->img
->relief
);
1929 raised_p
= s
->img
->relief
> 0;
1932 x1
= x
+ s
->slice
.width
- 1;
1933 y1
= y
+ s
->slice
.height
- 1;
1935 extra_x
= extra_y
= 0;
1936 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
1938 if (CONSP (Vtool_bar_button_margin
)
1939 && INTEGERP (XCAR (Vtool_bar_button_margin
))
1940 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
1942 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
1943 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
1945 else if (INTEGERP (Vtool_bar_button_margin
))
1946 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
1949 top_p
= bot_p
= left_p
= right_p
= 0;
1951 if (s
->slice
.x
== 0)
1952 x
-= thick
+ extra_x
, left_p
= 1;
1953 if (s
->slice
.y
== 0)
1954 y
-= thick
+ extra_y
, top_p
= 1;
1955 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
1956 x1
+= thick
+ extra_x
, right_p
= 1;
1957 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
1958 y1
+= thick
+ extra_y
, bot_p
= 1;
1960 x_setup_relief_colors (s
);
1961 get_glyph_string_clip_rect (s
, &r
);
1962 w32_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
1963 top_p
, bot_p
, left_p
, right_p
, &r
);
1967 /* Draw the foreground of image glyph string S to PIXMAP. */
1970 w32_draw_image_foreground_1 (struct glyph_string
*s
, HBITMAP pixmap
)
1972 HDC hdc
= CreateCompatibleDC (s
->hdc
);
1973 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
1975 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1977 /* If first glyph of S has a left box line, start drawing it to the
1978 right of that line. */
1979 if (s
->face
->box
!= FACE_NO_BOX
1980 && s
->first_glyph
->left_box_line_p
1982 x
+= eabs (s
->face
->box_line_width
);
1984 /* If there is a margin around the image, adjust x- and y-position
1986 if (s
->slice
.x
== 0)
1987 x
+= s
->img
->hmargin
;
1988 if (s
->slice
.y
== 0)
1989 y
+= s
->img
->vmargin
;
1993 HDC compat_hdc
= CreateCompatibleDC (hdc
);
1994 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1995 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
1996 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2000 HDC mask_dc
= CreateCompatibleDC (hdc
);
2001 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2003 SetTextColor (hdc
, RGB (0, 0, 0));
2004 SetBkColor (hdc
, RGB (255, 255, 255));
2005 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2006 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2007 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2008 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2009 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2010 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2012 SelectObject (mask_dc
, mask_orig_obj
);
2017 SetTextColor (hdc
, s
->gc
->foreground
);
2018 SetBkColor (hdc
, s
->gc
->background
);
2020 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2021 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2023 /* When the image has a mask, we can expect that at
2024 least part of a mouse highlight or a block cursor will
2025 be visible. If the image doesn't have a mask, make
2026 a block cursor visible by drawing a rectangle around
2027 the image. I believe it's looking better if we do
2028 nothing here for mouse-face. */
2029 if (s
->hl
== DRAW_CURSOR
)
2031 int r
= s
->img
->relief
;
2033 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2034 s
->slice
.width
+ r
*2 - 1,
2035 s
->slice
.height
+ r
*2 - 1);
2039 SelectObject (hdc
, orig_brush
);
2040 DeleteObject (fg_brush
);
2041 SelectObject (compat_hdc
, orig_obj
);
2042 DeleteDC (compat_hdc
);
2045 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2046 s
->slice
.width
- 1, s
->slice
.height
- 1);
2048 SelectObject (hdc
, orig_hdc_obj
);
2053 /* Draw part of the background of glyph string S. X, Y, W, and H
2054 give the rectangle to draw. */
2057 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2059 #if 0 /* TODO: stipple */
2062 /* Fill background with a stipple pattern. */
2063 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2064 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2065 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2069 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2073 /* Draw image glyph string S.
2076 s->x +-------------------------
2079 | +-------------------------
2082 | | +-------------------
2088 x_draw_image_glyph_string (struct glyph_string
*s
)
2091 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2092 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2097 if (s
->slice
.y
== 0)
2098 height
-= box_line_vwidth
;
2099 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2100 height
-= box_line_vwidth
;
2102 /* Fill background with face under the image. Do it only if row is
2103 taller than image or if image has a clip mask to reduce
2105 s
->stippled_p
= s
->face
->stipple
!= 0;
2106 if (height
> s
->slice
.height
2110 || s
->img
->pixmap
== 0
2111 || s
->width
!= s
->background_width
)
2113 width
= s
->background_width
;
2115 if (s
->first_glyph
->left_box_line_p
2118 x
+= box_line_hwidth
;
2119 width
-= box_line_hwidth
;
2123 if (s
->slice
.y
== 0)
2124 y
+= box_line_vwidth
;
2126 #if 0 /* TODO: figure out if we need to do this on Windows. */
2129 /* Create a pixmap as large as the glyph string. Fill it
2130 with the background color. Copy the image to it, using
2131 its mask. Copy the temporary pixmap to the display. */
2132 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2133 int depth
= DefaultDepthOfScreen (screen
);
2135 /* Create a pixmap as large as the glyph string. */
2136 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2137 s
->background_width
,
2140 /* Don't clip in the following because we're working on the
2142 XSetClipMask (s
->display
, s
->gc
, None
);
2144 /* Fill the pixmap with the background color/stipple. */
2147 /* Fill background with a stipple pattern. */
2148 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2149 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2150 0, 0, s
->background_width
, s
->height
);
2151 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2156 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2158 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2159 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2160 0, 0, s
->background_width
, s
->height
);
2161 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2166 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
2168 s
->background_filled_p
= true;
2171 /* Draw the foreground. */
2174 w32_draw_image_foreground_1 (s
, pixmap
);
2175 x_set_glyph_string_clipping (s
);
2177 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2178 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2179 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2180 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2182 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2183 SetBkColor (s
->hdc
, s
->gc
->background
);
2184 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2185 compat_hdc
, 0, 0, SRCCOPY
);
2187 SelectObject (s
->hdc
, orig_brush
);
2188 DeleteObject (fg_brush
);
2189 SelectObject (compat_hdc
, orig_obj
);
2190 DeleteDC (compat_hdc
);
2192 DeleteObject (pixmap
);
2196 x_draw_image_foreground (s
);
2198 /* If we must draw a relief around the image, do it. */
2200 || s
->hl
== DRAW_IMAGE_RAISED
2201 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2202 x_draw_image_relief (s
);
2206 /* Draw stretch glyph string S. */
2209 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2211 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2213 if (s
->hl
== DRAW_CURSOR
2214 && !x_stretch_cursor_p
)
2216 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2217 wide as the stretch glyph. */
2218 int width
, background_width
= s
->background_width
;
2221 if (!s
->row
->reversed_p
)
2223 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2227 background_width
-= left_x
- x
;
2233 /* In R2L rows, draw the cursor on the right edge of the
2235 int right_x
= window_box_right (s
->w
, TEXT_AREA
);
2237 if (x
+ background_width
> right_x
)
2238 background_width
-= x
- right_x
;
2239 x
+= background_width
;
2241 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2242 if (s
->row
->reversed_p
)
2246 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2248 /* Clear rest using the GC of the original non-cursor face. */
2249 if (width
< background_width
)
2251 XGCValues
*gc
= s
->face
->gc
;
2253 int w
= background_width
- width
, h
= s
->height
;
2257 if (!s
->row
->reversed_p
)
2261 if (s
->row
->mouse_face_p
2262 && cursor_in_mouse_face_p (s
->w
))
2264 x_set_mouse_face_gc (s
);
2270 get_glyph_string_clip_rect (s
, &r
);
2271 w32_set_clip_rectangle (hdc
, &r
);
2273 #if 0 /* TODO: stipple */
2274 if (s
->face
->stipple
)
2276 /* Fill background with a stipple pattern. */
2277 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2278 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2279 XSetFillStyle (s
->display
, gc
, FillSolid
);
2284 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2288 else if (!s
->background_filled_p
)
2290 int background_width
= s
->background_width
;
2291 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2293 /* Don't draw into left margin, fringe or scrollbar area
2294 except for header line and mode line. */
2295 if (x
< left_x
&& !s
->row
->mode_line_p
)
2297 background_width
-= left_x
- x
;
2300 if (background_width
> 0)
2301 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2304 s
->background_filled_p
= true;
2308 /* Draw glyph string S. */
2311 x_draw_glyph_string (struct glyph_string
*s
)
2313 bool relief_drawn_p
= 0;
2315 /* If S draws into the background of its successor, draw the
2316 background of the successor first so that S can draw into it.
2317 This makes S->next use XDrawString instead of XDrawImageString. */
2318 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2321 struct glyph_string
*next
;
2322 for (width
= 0, next
= s
->next
;
2323 next
&& width
< s
->right_overhang
;
2324 width
+= next
->width
, next
= next
->next
)
2325 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2327 x_set_glyph_string_gc (next
);
2328 x_set_glyph_string_clipping (next
);
2329 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2330 x_draw_stretch_glyph_string (next
);
2332 x_draw_glyph_string_background (next
, true);
2333 next
->num_clips
= 0;
2337 /* Set up S->gc, set clipping and draw S. */
2338 x_set_glyph_string_gc (s
);
2340 /* Draw relief (if any) in advance for char/composition so that the
2341 glyph string can be drawn over it. */
2342 if (!s
->for_overlaps
2343 && s
->face
->box
!= FACE_NO_BOX
2344 && (s
->first_glyph
->type
== CHAR_GLYPH
2345 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2348 x_set_glyph_string_clipping (s
);
2349 x_draw_glyph_string_background (s
, true);
2350 x_draw_glyph_string_box (s
);
2351 x_set_glyph_string_clipping (s
);
2354 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2356 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2357 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2358 /* We must clip just this glyph. left_overhang part has already
2359 drawn when s->prev was drawn, and right_overhang part will be
2360 drawn later when s->next is drawn. */
2361 x_set_glyph_string_clipping_exactly (s
, s
);
2363 x_set_glyph_string_clipping (s
);
2365 switch (s
->first_glyph
->type
)
2368 x_draw_image_glyph_string (s
);
2372 x_draw_stretch_glyph_string (s
);
2376 if (s
->for_overlaps
)
2377 s
->background_filled_p
= true;
2379 x_draw_glyph_string_background (s
, false);
2380 x_draw_glyph_string_foreground (s
);
2383 case COMPOSITE_GLYPH
:
2384 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2385 && ! s
->first_glyph
->u
.cmp
.automatic
))
2386 s
->background_filled_p
= true;
2388 x_draw_glyph_string_background (s
, true);
2389 x_draw_composite_glyph_string_foreground (s
);
2392 case GLYPHLESS_GLYPH
:
2393 if (s
->for_overlaps
)
2394 s
->background_filled_p
= true;
2396 x_draw_glyph_string_background (s
, false);
2397 x_draw_glyphless_glyph_string_foreground (s
);
2404 if (!s
->for_overlaps
)
2406 /* Draw underline. */
2407 if (s
->face
->underline_p
)
2409 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2413 if (s
->face
->underline_defaulted_p
)
2414 color
= s
->gc
->foreground
;
2416 color
= s
->face
->underline_color
;
2418 w32_draw_underwave (s
, color
);
2420 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2422 unsigned long thickness
, position
;
2425 if (s
->prev
&& s
->prev
->face
->underline_p
2426 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2428 /* We use the same underline style as the previous one. */
2429 thickness
= s
->prev
->underline_thickness
;
2430 position
= s
->prev
->underline_position
;
2434 /* Get the underline thickness. Default is 1 pixel. */
2435 if (s
->font
&& s
->font
->underline_thickness
> 0)
2436 thickness
= s
->font
->underline_thickness
;
2439 if (x_underline_at_descent_line
)
2440 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2443 /* Get the underline position. This is the recommended
2444 vertical offset in pixels from the baseline to the top of
2445 the underline. This is a signed value according to the
2446 specs, and its default is
2448 ROUND ((maximum_descent) / 2), with
2449 ROUND (x) = floor (x + 0.5) */
2451 if (x_use_underline_position_properties
2452 && s
->font
&& s
->font
->underline_position
>= 0)
2453 position
= s
->font
->underline_position
;
2455 position
= (s
->font
->descent
+ 1) / 2;
2457 position
= max (position
, underline_minimum_offset
);
2459 /* Check the sanity of thickness and position. We should
2460 avoid drawing underline out of the current line area. */
2461 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2462 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2463 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2464 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2465 s
->underline_thickness
= thickness
;
2466 s
->underline_position
=position
;
2467 y
= s
->ybase
+ position
;
2468 if (s
->face
->underline_defaulted_p
)
2470 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2475 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2480 /* Draw overline. */
2481 if (s
->face
->overline_p
)
2483 unsigned long dy
= 0, h
= 1;
2485 if (s
->face
->overline_color_defaulted_p
)
2487 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2488 s
->y
+ dy
, s
->width
, h
);
2492 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2493 s
->y
+ dy
, s
->width
, h
);
2497 /* Draw strike-through. */
2498 if (s
->face
->strike_through_p
2499 && !FONT_TEXTMETRIC (s
->font
).tmStruckOut
)
2501 unsigned long h
= 1;
2502 unsigned long dy
= (s
->height
- h
) / 2;
2504 if (s
->face
->strike_through_color_defaulted_p
)
2506 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2511 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2512 s
->y
+ dy
, s
->width
, h
);
2516 /* Draw relief if not yet drawn. */
2517 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2518 x_draw_glyph_string_box (s
);
2522 struct glyph_string
*prev
;
2524 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2525 if (prev
->hl
!= s
->hl
2526 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2528 /* As prev was drawn while clipped to its own area, we
2529 must draw the right_overhang part using s->hl now. */
2530 enum draw_glyphs_face save
= prev
->hl
;
2533 x_set_glyph_string_gc (prev
);
2534 x_set_glyph_string_clipping_exactly (s
, prev
);
2535 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2536 x_draw_glyph_string_foreground (prev
);
2538 x_draw_composite_glyph_string_foreground (prev
);
2539 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2541 prev
->num_clips
= 0;
2547 struct glyph_string
*next
;
2549 for (next
= s
->next
; next
; next
= next
->next
)
2550 if (next
->hl
!= s
->hl
2551 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2553 /* As next will be drawn while clipped to its own area,
2554 we must draw the left_overhang part using s->hl now. */
2555 enum draw_glyphs_face save
= next
->hl
;
2558 x_set_glyph_string_gc (next
);
2559 x_set_glyph_string_clipping_exactly (s
, next
);
2560 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2561 x_draw_glyph_string_foreground (next
);
2563 x_draw_composite_glyph_string_foreground (next
);
2564 w32_set_clip_rectangle (next
->hdc
, NULL
);
2566 next
->num_clips
= 0;
2567 next
->clip_head
= s
->next
;
2572 /* Reset clipping. */
2573 w32_set_clip_rectangle (s
->hdc
, NULL
);
2578 /* Shift display to make room for inserted glyphs. */
2581 w32_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
,
2582 int width
, int height
, int shift_by
)
2586 hdc
= get_frame_dc (f
);
2587 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2588 hdc
, x
, y
, SRCCOPY
);
2590 release_frame_dc (f
, hdc
);
2594 /* Delete N glyphs at the nominal cursor position. Not implemented
2598 x_delete_glyphs (struct frame
*f
, register int n
)
2600 if (! FRAME_W32_P (f
))
2607 /* Clear entire frame. */
2610 x_clear_frame (struct frame
*f
)
2612 if (! FRAME_W32_P (f
))
2615 /* Clearing the frame will erase any cursor, so mark them all as no
2617 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2621 w32_clear_window (f
);
2623 /* We have to clear the scroll bars, too. If we have changed
2624 colors or something like that, then they should be notified. */
2625 x_scroll_bar_clear (f
);
2631 /* Make audible bell. */
2634 w32_ring_bell (struct frame
*f
)
2638 if (FRAME_W32_P (f
) && visible_bell
)
2641 HWND hwnd
= FRAME_W32_WINDOW (f
);
2643 for (i
= 0; i
< 5; i
++)
2645 FlashWindow (hwnd
, TRUE
);
2648 FlashWindow (hwnd
, FALSE
);
2651 w32_sys_ring_bell (f
);
2656 /***********************************************************************
2658 ***********************************************************************/
2660 /* Perform an insert-lines or delete-lines operation, inserting N
2661 lines or deleting -N lines at vertical position VPOS. */
2664 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
2666 if (! FRAME_W32_P (f
))
2673 /* Scroll part of the display as described by RUN. */
2676 x_scroll_run (struct window
*w
, struct run
*run
)
2678 struct frame
*f
= XFRAME (w
->frame
);
2679 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2680 HWND hwnd
= FRAME_W32_WINDOW (f
);
2683 /* Get frame-relative bounding box of the text display area of W,
2684 without mode lines. Include in this box the left and right
2686 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
2688 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2689 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2690 bottom_y
= y
+ height
;
2694 /* Scrolling up. Make sure we don't copy part of the mode
2695 line at the bottom. */
2696 if (from_y
+ run
->height
> bottom_y
)
2697 height
= bottom_y
- from_y
;
2699 height
= run
->height
;
2700 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2704 /* Scrolling down. Make sure we don't copy over the mode line.
2706 if (to_y
+ run
->height
> bottom_y
)
2707 height
= bottom_y
- to_y
;
2709 height
= run
->height
;
2710 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2715 /* Cursor off. Will be switched on again in x_update_window_end. */
2721 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2722 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2724 from
.left
= to
.left
= x
;
2725 from
.right
= to
.right
= x
+ width
;
2727 from
.bottom
= from_y
+ height
;
2729 to
.bottom
= bottom_y
;
2731 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2732 NULL
, SW_INVALIDATE
);
2734 /* Combine this with what we expect to be dirty. This covers the
2735 case where not all of the region we expect is actually dirty. */
2736 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2738 /* If the dirty region is not what we expected, redraw the entire frame. */
2739 if (!EqualRgn (combined
, expect_dirty
))
2740 SET_FRAME_GARBAGED (f
);
2742 DeleteObject (dirty
);
2743 DeleteObject (combined
);
2747 DeleteObject (expect_dirty
);
2752 /***********************************************************************
2754 ***********************************************************************/
2757 frame_highlight (struct frame
*f
)
2759 x_update_cursor (f
, 1);
2760 x_set_frame_alpha (f
);
2764 frame_unhighlight (struct frame
*f
)
2766 x_update_cursor (f
, 1);
2767 x_set_frame_alpha (f
);
2770 /* The focus has changed. Update the frames as necessary to reflect
2771 the new situation. Note that we can't change the selected frame
2772 here, because the Lisp code we are interrupting might become confused.
2773 Each event gets marked with the frame in which it occurred, so the
2774 Lisp code can tell when the switch took place by examining the events. */
2777 x_new_focus_frame (struct w32_display_info
*dpyinfo
, struct frame
*frame
)
2779 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2781 if (frame
!= dpyinfo
->w32_focus_frame
)
2783 /* Set this before calling other routines, so that they see
2784 the correct value of w32_focus_frame. */
2785 dpyinfo
->w32_focus_frame
= frame
;
2787 if (old_focus
&& old_focus
->auto_lower
)
2788 x_lower_frame (old_focus
);
2790 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2791 dpyinfo
->w32_pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2793 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
2796 x_frame_rehighlight (dpyinfo
);
2800 /* Handle FocusIn and FocusOut state changes for FRAME.
2801 If FRAME has focus and there exists more than one frame, puts
2802 a FOCUS_IN_EVENT into *BUFP. */
2805 x_focus_changed (int type
, int state
, struct w32_display_info
*dpyinfo
,
2806 struct frame
*frame
, struct input_event
*bufp
)
2808 if (type
== WM_SETFOCUS
)
2810 if (dpyinfo
->w32_focus_event_frame
!= frame
)
2812 x_new_focus_frame (dpyinfo
, frame
);
2813 dpyinfo
->w32_focus_event_frame
= frame
;
2815 /* Don't stop displaying the initial startup message
2816 for a switch-frame event we don't need. */
2817 if (NILP (Vterminal_frame
)
2818 && CONSP (Vframe_list
)
2819 && !NILP (XCDR (Vframe_list
)))
2828 bufp
->kind
= FOCUS_IN_EVENT
;
2829 XSETFRAME (bufp
->frame_or_window
, frame
);
2832 frame
->output_data
.x
->focus_state
|= state
;
2834 /* TODO: IME focus? */
2836 else if (type
== WM_KILLFOCUS
)
2838 frame
->output_data
.x
->focus_state
&= ~state
;
2840 if (dpyinfo
->w32_focus_event_frame
== frame
)
2842 dpyinfo
->w32_focus_event_frame
= 0;
2843 x_new_focus_frame (dpyinfo
, 0);
2845 bufp
->kind
= FOCUS_OUT_EVENT
;
2846 XSETFRAME (bufp
->frame_or_window
, frame
);
2849 /* TODO: IME focus? */
2854 /* The focus may have changed. Figure out if it is a real focus change,
2855 by checking both FocusIn/Out and Enter/LeaveNotify events.
2857 Returns FOCUS_IN_EVENT event in *BUFP. */
2860 w32_detect_focus_change (struct w32_display_info
*dpyinfo
, W32Msg
*event
,
2861 struct input_event
*bufp
)
2863 struct frame
*frame
;
2865 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
2869 /* On w32, this is only called from focus events, so no switch needed. */
2870 x_focus_changed (event
->msg
.message
,
2871 (event
->msg
.message
== WM_KILLFOCUS
?
2872 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
2873 dpyinfo
, frame
, bufp
);
2878 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2881 x_mouse_leave (struct w32_display_info
*dpyinfo
)
2883 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2887 /* The focus has changed, or we have redirected a frame's focus to
2888 another frame (this happens when a frame uses a surrogate
2889 mini-buffer frame). Shift the highlight as appropriate.
2891 The FRAME argument doesn't necessarily have anything to do with which
2892 frame is being highlighted or un-highlighted; we only use it to find
2893 the appropriate X display info. */
2896 w32_frame_rehighlight (struct frame
*frame
)
2898 if (! FRAME_W32_P (frame
))
2900 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
2904 x_frame_rehighlight (struct w32_display_info
*dpyinfo
)
2906 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2908 if (dpyinfo
->w32_focus_frame
)
2910 dpyinfo
->x_highlight_frame
2911 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2912 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2913 : dpyinfo
->w32_focus_frame
);
2914 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
2916 fset_focus_frame (dpyinfo
->w32_focus_frame
, Qnil
);
2917 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
2921 dpyinfo
->x_highlight_frame
= 0;
2923 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
2926 frame_unhighlight (old_highlight
);
2927 if (dpyinfo
->x_highlight_frame
)
2928 frame_highlight (dpyinfo
->x_highlight_frame
);
2932 /* Keyboard processing - modifier keys, etc. */
2934 /* Convert a keysym to its name. */
2937 x_get_keysym_name (int keysym
)
2939 /* Make static so we can always return it */
2940 static char value
[100];
2943 GetKeyNameText (keysym
, value
, 100);
2950 codepage_for_locale (LCID locale
)
2954 if (GetLocaleInfo (locale
, LOCALE_IDEFAULTANSICODEPAGE
, cp
, 20) > 0)
2961 /* Mouse clicks and mouse movement. Rah. */
2963 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2964 the state in PUP. XBUTTON provides extra information for extended mouse
2965 button messages. Returns FALSE if unable to parse the message. */
2967 parse_button (int message
, int xbutton
, int * pbutton
, int * pup
)
2974 case WM_LBUTTONDOWN
:
2982 case WM_MBUTTONDOWN
:
2983 if (NILP (Vw32_swap_mouse_buttons
))
2990 if (NILP (Vw32_swap_mouse_buttons
))
2996 case WM_RBUTTONDOWN
:
2997 if (NILP (Vw32_swap_mouse_buttons
))
3004 if (NILP (Vw32_swap_mouse_buttons
))
3010 case WM_XBUTTONDOWN
:
3011 button
= xbutton
+ 2;
3015 button
= xbutton
+ 2;
3023 if (pbutton
) *pbutton
= button
;
3029 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3031 If the event is a button press, then note that we have grabbed
3035 construct_mouse_click (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3040 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3043 /* Make the event type NO_EVENT; we'll change that when we decide
3045 result
->kind
= MOUSE_CLICK_EVENT
;
3046 result
->code
= button
;
3047 result
->timestamp
= msg
->msg
.time
;
3048 result
->modifiers
= (msg
->dwModifiers
3053 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3054 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3055 XSETFRAME (result
->frame_or_window
, f
);
3061 construct_mouse_wheel (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3066 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3069 result
->timestamp
= msg
->msg
.time
;
3071 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3072 forward, away from the user (up); a negative value indicates that
3073 the wheel was rotated backward, toward the user (down). */
3074 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3076 /* The up and down modifiers indicate if the wheel was rotated up or
3077 down based on WHEEL_DELTA value. */
3078 result
->modifiers
= (msg
->dwModifiers
3079 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3081 /* With multiple monitors, we can legitimately get negative
3082 coordinates, so cast to short to interpret them correctly. */
3083 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3084 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3085 ScreenToClient (msg
->msg
.hwnd
, &p
);
3086 XSETINT (result
->x
, p
.x
);
3087 XSETINT (result
->y
, p
.y
);
3088 XSETFRAME (result
->frame_or_window
, f
);
3094 construct_drag_n_drop (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3101 wchar_t name_w
[MAX_PATH
];
3102 #ifdef NTGUI_UNICODE
3103 const int use_unicode
= 1;
3105 int use_unicode
= w32_unicode_filenames
;
3106 char name_a
[MAX_PATH
];
3107 char file
[MAX_UTF8_PATH
];
3111 result
->kind
= DRAG_N_DROP_EVENT
;
3113 result
->timestamp
= msg
->msg
.time
;
3114 result
->modifiers
= msg
->dwModifiers
;
3116 hdrop
= (HDROP
) msg
->msg
.wParam
;
3117 DragQueryPoint (hdrop
, &p
);
3120 p
.x
= LOWORD (msg
->msg
.lParam
);
3121 p
.y
= HIWORD (msg
->msg
.lParam
);
3122 ScreenToClient (msg
->msg
.hwnd
, &p
);
3125 XSETINT (result
->x
, p
.x
);
3126 XSETINT (result
->y
, p
.y
);
3128 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3131 for (i
= 0; i
< num_files
; i
++)
3135 eassert (DragQueryFileW (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3136 /* If DragQueryFile returns zero, it failed to fetch a file
3138 if (DragQueryFileW (hdrop
, i
, name_w
, MAX_PATH
) == 0)
3140 #ifdef NTGUI_UNICODE
3141 files
= Fcons (from_unicode_buffer (name_w
), files
);
3143 filename_from_utf16 (name_w
, file
);
3144 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3145 #endif /* NTGUI_UNICODE */
3147 #ifndef NTGUI_UNICODE
3150 eassert (DragQueryFileA (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3151 if (DragQueryFileA (hdrop
, i
, name_a
, MAX_PATH
) == 0)
3153 filename_from_ansi (name_a
, file
);
3154 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3161 XSETFRAME (frame
, f
);
3162 result
->frame_or_window
= frame
;
3163 result
->arg
= files
;
3170 /* File event notifications (see w32notify.c). */
3173 lispy_file_action (DWORD action
)
3175 static char unknown_fmt
[] = "unknown-action(%d)";
3180 case FILE_ACTION_ADDED
:
3183 case FILE_ACTION_REMOVED
:
3186 case FILE_ACTION_MODIFIED
:
3189 case FILE_ACTION_RENAMED_OLD_NAME
:
3190 retval
= Qrenamed_from
;
3192 case FILE_ACTION_RENAMED_NEW_NAME
:
3193 retval
= Qrenamed_to
;
3197 char buf
[sizeof(unknown_fmt
) - 1 + INT_STRLEN_BOUND (DWORD
)];
3199 sprintf (buf
, unknown_fmt
, action
);
3200 retval
= intern (buf
);
3209 /* Put file notifications into the Emacs input event queue. This
3210 function runs when the WM_EMACS_FILENOTIFY message arrives from a
3213 queue_notifications (struct input_event
*event
, W32Msg
*msg
, struct frame
*f
,
3216 struct notifications_set
*ns
= NULL
;
3220 /* We cannot process notification before Emacs is fully initialized,
3221 since we need the UTF-16LE coding-system to be set up. */
3225 XSETFRAME (frame
, f
);
3231 /* Find out if there is a record available in the linked list of
3232 notifications sets. If so, unlink the set from the linked
3233 list. Use critical section. */
3235 if (notifications_set_head
->next
!= notifications_set_head
)
3237 ns
= notifications_set_head
->next
;
3238 ns
->prev
->next
= ns
->next
;
3239 ns
->next
->prev
= ns
->prev
;
3247 BYTE
*p
= ns
->notifications
;
3248 FILE_NOTIFY_INFORMATION
*fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3249 const DWORD min_size
3250 = offsetof (FILE_NOTIFY_INFORMATION
, FileName
) + sizeof(wchar_t);
3251 DWORD info_size
= ns
->size
;
3252 Lisp_Object cs
= Qutf_16le
;
3253 Lisp_Object obj
= w32_get_watch_object (ns
->desc
);
3255 /* notifications size could be zero when the buffer of
3256 notifications overflowed on the OS level, or when the
3257 directory being watched was itself deleted. Do nothing in
3260 && !NILP (obj
) && CONSP (obj
))
3262 Lisp_Object callback
= XCDR (obj
);
3264 while (info_size
>= min_size
)
3266 Lisp_Object utf_16_fn
3267 = make_unibyte_string ((char *)fni
->FileName
,
3268 fni
->FileNameLength
);
3269 /* Note: mule-conf is preloaded, so utf-16le must
3270 already be defined at this point. */
3272 = code_convert_string_norecord (utf_16_fn
, cs
, 0);
3273 Lisp_Object action
= lispy_file_action (fni
->Action
);
3275 event
->kind
= FILE_NOTIFY_EVENT
;
3276 event
->timestamp
= msg
->msg
.time
;
3277 event
->modifiers
= 0;
3278 event
->frame_or_window
= callback
;
3279 event
->arg
= list3 (make_pointer_integer (ns
->desc
),
3281 kbd_buffer_store_event (event
);
3283 if (!fni
->NextEntryOffset
)
3285 p
+= fni
->NextEntryOffset
;
3286 fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3287 info_size
-= fni
->NextEntryOffset
;
3290 /* Free this notifications set. */
3291 xfree (ns
->notifications
);
3295 /* We've stuffed all the events ourselves, so w32_read_socket shouldn't. */
3296 event
->kind
= NO_EVENT
;
3298 #endif /* WINDOWSNT */
3299 #endif /* HAVE_W32NOTIFY */
3302 /* Function to report a mouse movement to the mainstream Emacs code.
3303 The input handler calls this.
3305 We have received a mouse movement event, which is given in *event.
3306 If the mouse is over a different glyph than it was last time, tell
3307 the mainstream emacs code by setting mouse_moved. If not, ask for
3308 another motion event, so we can check again the next time it moves. */
3311 note_mouse_movement (struct frame
*frame
, MSG
*msg
)
3313 struct w32_display_info
*dpyinfo
;
3314 int mouse_x
= LOWORD (msg
->lParam
);
3315 int mouse_y
= HIWORD (msg
->lParam
);
3318 if (!FRAME_X_OUTPUT (frame
))
3321 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
3322 dpyinfo
->last_mouse_movement_time
= msg
->time
;
3323 dpyinfo
->last_mouse_motion_frame
= frame
;
3324 dpyinfo
->last_mouse_motion_x
= mouse_x
;
3325 dpyinfo
->last_mouse_motion_y
= mouse_y
;
3327 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3329 frame
->mouse_moved
= true;
3330 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3331 note_mouse_highlight (frame
, -1, -1);
3332 dpyinfo
->last_mouse_glyph_frame
= NULL
;
3336 /* Has the mouse moved off the glyph it was on at the last sighting? */
3337 r
= &dpyinfo
->last_mouse_glyph
;
3338 if (frame
!= dpyinfo
->last_mouse_glyph_frame
3339 || mouse_x
< r
->left
|| mouse_x
>= r
->right
3340 || mouse_y
< r
->top
|| mouse_y
>= r
->bottom
)
3342 frame
->mouse_moved
= true;
3343 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3344 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3345 /* Remember the mouse position here, as w32_mouse_position only
3346 gets called when mouse tracking is enabled but we also need
3347 to keep track of the mouse for help_echo and highlighting at
3349 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, r
);
3350 dpyinfo
->last_mouse_glyph_frame
= frame
;
3358 /************************************************************************
3360 ************************************************************************/
3362 static struct scroll_bar
*x_window_to_scroll_bar (Window
, int);
3363 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3364 enum scroll_bar_part
*,
3365 Lisp_Object
*, Lisp_Object
*,
3367 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3368 enum scroll_bar_part
*,
3369 Lisp_Object
*, Lisp_Object
*,
3372 w32_define_cursor (Window window
, Cursor cursor
)
3374 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3377 /* Return the current position of the mouse.
3378 *fp should be a frame which indicates which display to ask about.
3380 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3381 and *part to the frame, window, and scroll bar part that the mouse
3382 is over. Set *x and *y to the portion and whole of the mouse's
3383 position on the scroll bar.
3385 If the mouse movement started elsewhere, set *fp to the frame the
3386 mouse is on, *bar_window to nil, and *x and *y to the character cell
3389 Set *time to the server time-stamp for the time at which the mouse
3390 was at this position.
3392 Don't store anything if we don't have a valid set of values to report.
3394 This clears the mouse_moved flag, so we can wait for the next mouse
3398 w32_mouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
3399 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
3403 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
3407 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
3409 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
3411 if (bar
->horizontal
)
3412 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3414 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3420 Lisp_Object frame
, tail
;
3422 /* Clear the mouse-moved flag for every frame on this display. */
3423 FOR_EACH_FRAME (tail
, frame
)
3424 XFRAME (frame
)->mouse_moved
= false;
3426 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3430 /* Now we have a position on the root; find the innermost window
3431 containing the pointer. */
3433 /* If mouse was grabbed on a frame, give coords for that
3434 frame even if the mouse is now outside it. Otherwise
3435 check for window under mouse on one of our frames. */
3436 f1
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
3437 : x_any_window_to_frame (dpyinfo
, WindowFromPoint (pt
)));
3439 /* If not, is it one of our scroll bars? */
3442 struct scroll_bar
*bar
3443 = x_window_to_scroll_bar (WindowFromPoint (pt
), 2);
3446 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3449 if (f1
== 0 && insist
> 0)
3450 f1
= SELECTED_FRAME ();
3454 /* Ok, we found a frame. Store all the values.
3455 last_mouse_glyph is a rectangle used to reduce the
3456 generation of mouse events. To not miss any motion
3457 events, we must divide the frame into rectangles of the
3458 size of the smallest character that could be displayed
3459 on it, i.e. into the same rectangles that matrices on
3460 the frame are divided into. */
3462 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
3463 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3464 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &dpyinfo
->last_mouse_glyph
);
3465 dpyinfo
->last_mouse_glyph_frame
= f1
;
3468 *part
= scroll_bar_above_handle
;
3472 *time
= dpyinfo
->last_mouse_movement_time
;
3481 /***********************************************************************
3483 ***********************************************************************/
3485 /* Handle mouse button event on the tool-bar of frame F, at
3486 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
3487 or ButtonRelease. */
3490 w32_handle_tool_bar_click (struct frame
*f
, struct input_event
*button_event
)
3492 int x
= XFASTINT (button_event
->x
);
3493 int y
= XFASTINT (button_event
->y
);
3495 if (button_event
->modifiers
& down_modifier
)
3496 handle_tool_bar_click (f
, x
, y
, 1, 0);
3498 handle_tool_bar_click (f
, x
, y
, 0,
3499 button_event
->modifiers
& ~up_modifier
);
3504 /***********************************************************************
3506 ***********************************************************************/
3508 /* Scroll bar support. */
3510 /* Given a window ID, find the struct scroll_bar which manages it
3511 vertically. This can be called in GC, so we have to make sure to
3512 strip off mark bits. */
3514 static struct scroll_bar
*
3515 x_window_to_scroll_bar (Window window_id
, int type
)
3517 Lisp_Object tail
, frame
;
3519 FOR_EACH_FRAME (tail
, frame
)
3521 Lisp_Object bar
, condemned
;
3523 /* Scan this frame's scroll bar list for a scroll bar with the
3525 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3526 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3527 /* This trick allows us to search both the ordinary and
3528 condemned scroll bar lists with one loop. */
3529 ! NILP (bar
) || (bar
= condemned
,
3532 bar
= XSCROLL_BAR (bar
)->next
)
3533 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
3535 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
3536 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
3537 return XSCROLL_BAR (bar
);
3545 /* Set the thumb size and position of vertical scroll bar BAR. We are currently
3546 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3549 w32_set_scroll_bar_thumb (struct scroll_bar
*bar
,
3550 int portion
, int position
, int whole
)
3552 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3553 /* We use the whole scroll-bar height in the calculations below, to
3554 avoid strange effects like scrolling backwards when just clicking
3555 on the handle (without moving it). */
3556 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
)
3557 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3558 int sb_page
, sb_pos
;
3559 BOOL draggingp
= bar
->dragging
? TRUE
: FALSE
;
3562 /* We used to change the nPage setting while dragging the handle,
3563 but that had very strange effects (such as scrolling backwards
3564 while dragging downwards).
3566 Now, we don't change the nPage setting while dragging unless we
3567 get near to the end of the buffer, in which case we often have to
3568 resize the handle to "go all the way". */
3574 si
.cbSize
= sizeof (si
);
3575 si
.fMask
= SIF_POS
| SIF_PAGE
;
3576 GetScrollInfo (w
, SB_CTL
, &si
);
3577 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3585 /* Position scroll bar at rock bottom if the bottom of the
3586 buffer is visible. This avoids shrinking the thumb away
3587 to nothing if it is held at the bottom of the buffer. */
3588 if (position
+ portion
>= whole
&& !draggingp
)
3590 sb_page
= range
* (whole
- position
) / whole
;
3595 sb_pos
= position
* range
/ whole
;
3596 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3605 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3609 si
.cbSize
= sizeof (si
);
3610 si
.fMask
= SIF_PAGE
| SIF_POS
;
3614 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3619 /* Set the thumb size and position of horizontal scroll bar BAR. We are currently
3620 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3623 w32_set_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
3624 int portion
, int position
, int whole
)
3626 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3631 si
.cbSize
= sizeof (si
);
3632 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
3635 /* Allow nPage to be one larger than nPos so we don't allow the scrolling
3636 of an already fully visible buffer. */
3637 si
.nPage
= min (portion
, si
.nMax
) + 1;
3638 si
.nPos
= min (position
, si
.nMax
);
3639 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3645 /************************************************************************
3646 Scroll bars, general
3647 ************************************************************************/
3650 my_create_vscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3652 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3653 WM_EMACS_CREATEVSCROLLBAR
, (WPARAM
) f
,
3658 my_create_hscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3660 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3661 WM_EMACS_CREATEHSCROLLBAR
, (WPARAM
) f
,
3665 /*#define ATTACH_THREADS*/
3668 my_show_window (struct frame
*f
, HWND hwnd
, int how
)
3670 #ifndef ATTACH_THREADS
3671 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3672 (WPARAM
) hwnd
, (LPARAM
) how
);
3674 return ShowWindow (hwnd
, how
);
3679 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3680 int x
, int y
, int cx
, int cy
, UINT flags
)
3682 #ifndef ATTACH_THREADS
3684 pos
.hwndInsertAfter
= hwndAfter
;
3690 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
3692 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3698 my_set_focus (struct frame
* f
, HWND hwnd
)
3700 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3706 my_set_foreground_window (HWND hwnd
)
3708 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
3713 my_destroy_window (struct frame
* f
, HWND hwnd
)
3715 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3720 my_bring_window_to_top (HWND hwnd
)
3722 SendMessage (hwnd
, WM_EMACS_BRINGTOTOP
, (WPARAM
) hwnd
, 0);
3725 /* Create a scroll bar and return the scroll bar vector for it. W is
3726 the Emacs window on which to create the scroll bar. TOP, LEFT,
3727 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
3730 static struct scroll_bar
*
3731 x_scroll_bar_create (struct window
*w
, int left
, int top
, int width
, int height
, bool horizontal
)
3733 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3736 struct scroll_bar
*bar
3737 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, top
, PVEC_OTHER
);
3742 XSETWINDOW (bar
->window
, w
);
3746 bar
->height
= height
;
3750 bar
->horizontal
= horizontal
;
3752 /* Requires geometry to be set before call to create the real window */
3755 hwnd
= my_create_hscrollbar (f
, bar
);
3757 hwnd
= my_create_vscrollbar (f
, bar
);
3759 si
.cbSize
= sizeof (si
);
3763 si
.nMax
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
)
3764 + HORIZONTAL_SCROLL_BAR_MIN_HANDLE
;
3766 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3767 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3771 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3773 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3775 /* Add bar to its frame's list of scroll bars. */
3776 bar
->next
= FRAME_SCROLL_BARS (f
);
3778 XSETVECTOR (barobj
, bar
);
3779 fset_scroll_bars (f
, barobj
);
3780 if (! NILP (bar
->next
))
3781 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3789 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3793 x_scroll_bar_remove (struct scroll_bar
*bar
)
3795 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3799 /* Destroy the window. */
3800 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3802 /* Dissociate this scroll bar from its window. */
3803 if (bar
->horizontal
)
3804 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3806 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3811 /* Set the handle of the vertical scroll bar for WINDOW to indicate that
3812 we are displaying PORTION characters out of a total of WHOLE
3813 characters, starting at POSITION. If WINDOW has no vertical scroll
3816 w32_set_vertical_scroll_bar (struct window
*w
,
3817 int portion
, int whole
, int position
)
3819 struct frame
*f
= XFRAME (w
->frame
);
3821 struct scroll_bar
*bar
;
3822 int top
, height
, left
, width
;
3823 int window_y
, window_height
;
3825 /* Get window dimensions. */
3826 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
3828 height
= window_height
;
3830 /* Compute the left edge and the width of the scroll bar area. */
3831 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3832 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
3834 /* Does the scroll bar exist yet? */
3835 if (NILP (w
->vertical_scroll_bar
))
3839 if (width
> 0 && height
> 0)
3841 hdc
= get_frame_dc (f
);
3842 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3843 release_frame_dc (f
, hdc
);
3847 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, false);
3851 /* It may just need to be moved and resized. */
3854 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3855 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3857 /* If already correctly positioned, do nothing. */
3858 if (bar
->left
== left
3860 && bar
->width
== width
3861 && bar
->height
== height
)
3863 /* Redraw after clear_frame. */
3864 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3865 InvalidateRect (hwnd
, NULL
, FALSE
);
3873 if (width
&& height
)
3875 hdc
= get_frame_dc (f
);
3876 /* Since Windows scroll bars are smaller than the space reserved
3877 for them on the frame, we have to clear "under" them. */
3878 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3879 release_frame_dc (f
, hdc
);
3881 /* Make sure scroll bar is "visible" before moving, to ensure the
3882 area of the parent window now exposed will be refreshed. */
3883 my_show_window (f
, hwnd
, SW_HIDE
);
3884 MoveWindow (hwnd
, left
, top
, width
, max (height
, 1), TRUE
);
3886 si
.cbSize
= sizeof (si
);
3887 si
.fMask
= SIF_RANGE
;
3889 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3890 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3892 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3894 my_show_window (f
, hwnd
, SW_NORMAL
);
3895 /* InvalidateRect (w, NULL, FALSE); */
3897 /* Remember new settings. */
3901 bar
->height
= height
;
3906 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3907 XSETVECTOR (barobj
, bar
);
3908 wset_vertical_scroll_bar (w
, barobj
);
3911 /* Set the handle of the horizontal scroll bar for WINDOW to indicate
3912 that we are displaying PORTION characters out of a total of WHOLE
3913 characters, starting at POSITION. If WINDOW has no horizontal scroll
3916 w32_set_horizontal_scroll_bar (struct window
*w
,
3917 int portion
, int whole
, int position
)
3919 struct frame
*f
= XFRAME (w
->frame
);
3921 struct scroll_bar
*bar
;
3922 int top
, height
, left
, width
;
3923 int window_x
, window_width
;
3924 int clear_left
= WINDOW_LEFT_EDGE_X (w
);
3925 int clear_width
= WINDOW_PIXEL_WIDTH (w
) - WINDOW_RIGHT_DIVIDER_WIDTH (w
);
3927 /* Get window dimensions. */
3928 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
3930 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
3931 width
= window_width
;
3932 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
3934 /* Does the scroll bar exist yet? */
3935 if (NILP (w
->horizontal_scroll_bar
))
3939 if (width
> 0 && height
> 0)
3941 hdc
= get_frame_dc (f
);
3942 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
3943 release_frame_dc (f
, hdc
);
3947 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, true);
3951 /* It may just need to be moved and resized. */
3954 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
3955 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3957 /* If already correctly positioned, do nothing. */
3958 if (bar
->left
== left
&& bar
->top
== top
3959 && bar
->width
== width
&& bar
->height
== height
)
3961 /* Redraw after clear_frame. */
3962 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3963 InvalidateRect (hwnd
, NULL
, FALSE
);
3971 if (width
&& height
)
3973 hdc
= get_frame_dc (f
);
3974 /* Since Windows scroll bars are smaller than the space reserved
3975 for them on the frame, we have to clear "under" them. */
3976 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
3977 release_frame_dc (f
, hdc
);
3979 /* Make sure scroll bar is "visible" before moving, to ensure the
3980 area of the parent window now exposed will be refreshed. */
3981 my_show_window (f
, hwnd
, SW_HIDE
);
3982 MoveWindow (hwnd
, left
, top
, width
, max (height
, 1), TRUE
);
3984 /* +++ SetScrollInfo +++ */
3985 si
.cbSize
= sizeof (si
);
3986 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
3989 si
.nPage
= min (portion
, si
.nMax
) + 1;
3990 si
.nPos
= min (position
, si
.nMax
);
3991 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3993 my_show_window (f
, hwnd
, SW_NORMAL
);
3994 /* InvalidateRect (w, NULL, FALSE); */
3996 /* Remember new settings. */
4000 bar
->height
= height
;
4006 w32_set_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
4007 XSETVECTOR (barobj
, bar
);
4008 wset_horizontal_scroll_bar (w
, barobj
);
4012 /* The following three hooks are used when we're doing a thorough
4013 redisplay of the frame. We don't explicitly know which scroll bars
4014 are going to be deleted, because keeping track of when windows go
4015 away is a real pain - "Can you say set-window-configuration, boys
4016 and girls?" Instead, we just assert at the beginning of redisplay
4017 that *all* scroll bars are to be removed, and then save a scroll bar
4018 from the fiery pit when we actually redisplay its window. */
4020 /* Arrange for all scroll bars on FRAME to be removed at the next call
4021 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
4022 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
4025 w32_condemn_scroll_bars (struct frame
*frame
)
4027 if (!NILP (FRAME_SCROLL_BARS (frame
)))
4029 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
4031 /* Prepend scrollbars to already condemned ones. */
4032 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
4034 while (!NILP (XSCROLL_BAR (last
)->next
))
4035 last
= XSCROLL_BAR (last
)->next
;
4037 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
4038 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
4041 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
4042 fset_scroll_bars (frame
, Qnil
);
4047 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
4048 Note that WINDOW isn't necessarily condemned at all. */
4051 w32_redeem_scroll_bar (struct window
*w
)
4053 struct scroll_bar
*bar
;
4057 /* We can't redeem this window's scroll bar if it doesn't have one. */
4058 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
4061 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4063 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4064 /* Unlink it from the condemned list. */
4065 f
= XFRAME (WINDOW_FRAME (w
));
4066 if (NILP (bar
->prev
))
4068 /* If the prev pointer is nil, it must be the first in one of
4070 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
4071 /* It's not condemned. Everything's fine. */
4073 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4074 w
->vertical_scroll_bar
))
4075 fset_condemned_scroll_bars (f
, bar
->next
);
4077 /* If its prev pointer is nil, it must be at the front of
4078 one or the other! */
4082 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4084 if (! NILP (bar
->next
))
4085 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4087 bar
->next
= FRAME_SCROLL_BARS (f
);
4089 XSETVECTOR (barobj
, bar
);
4090 fset_scroll_bars (f
, barobj
);
4091 if (! NILP (bar
->next
))
4092 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4096 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
4098 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
4099 /* Unlink it from the condemned list. */
4100 f
= XFRAME (WINDOW_FRAME (w
));
4101 if (NILP (bar
->prev
))
4103 /* If the prev pointer is nil, it must be the first in one of
4105 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
4106 /* It's not condemned. Everything's fine. */
4108 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4109 w
->horizontal_scroll_bar
))
4110 fset_condemned_scroll_bars (f
, bar
->next
);
4112 /* If its prev pointer is nil, it must be at the front of
4113 one or the other! */
4117 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4119 if (! NILP (bar
->next
))
4120 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4122 bar
->next
= FRAME_SCROLL_BARS (f
);
4124 XSETVECTOR (barobj
, bar
);
4125 fset_scroll_bars (f
, barobj
);
4126 if (! NILP (bar
->next
))
4127 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4131 /* Remove all scroll bars on FRAME that haven't been saved since the
4132 last call to `*condemn_scroll_bars_hook'. */
4135 w32_judge_scroll_bars (struct frame
*f
)
4137 Lisp_Object bar
, next
;
4139 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
4141 /* Clear out the condemned list now so we won't try to process any
4142 more events on the hapless scroll bars. */
4143 fset_condemned_scroll_bars (f
, Qnil
);
4145 for (; ! NILP (bar
); bar
= next
)
4147 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
4149 x_scroll_bar_remove (b
);
4152 b
->next
= b
->prev
= Qnil
;
4155 /* Now there should be no references to the condemned scroll bars,
4156 and they should get garbage-collected. */
4159 /* Handle a mouse click on the vertical scroll bar BAR. If
4160 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4163 This may be called from a signal handler, so we have to ignore GC
4167 w32_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4168 struct input_event
*emacs_event
)
4170 if (! WINDOWP (bar
->window
))
4173 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
4174 emacs_event
->code
= 0;
4175 /* not really meaningful to distinguish up/down */
4176 emacs_event
->modifiers
= msg
->dwModifiers
;
4177 emacs_event
->frame_or_window
= bar
->window
;
4178 emacs_event
->arg
= Qnil
;
4179 emacs_event
->timestamp
= msg
->msg
.time
;
4182 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4184 int dragging
= bar
->dragging
;
4186 int sb_event
= LOWORD (msg
->msg
.wParam
);
4188 si
.cbSize
= sizeof (si
);
4189 if (sb_event
== SB_THUMBTRACK
)
4190 si
.fMask
= SIF_TRACKPOS
;
4194 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4195 if (sb_event
== SB_THUMBTRACK
)
4201 struct frame
*f
; /* Value is not used. */
4202 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4207 emacs_event
->part
= scroll_bar_down_arrow
;
4210 emacs_event
->part
= scroll_bar_up_arrow
;
4213 emacs_event
->part
= scroll_bar_above_handle
;
4216 emacs_event
->part
= scroll_bar_below_handle
;
4219 emacs_event
->part
= scroll_bar_handle
;
4223 emacs_event
->part
= scroll_bar_handle
;
4227 case SB_THUMBPOSITION
:
4228 bar
->dragging
= 1; /* ??????? */
4229 emacs_event
->part
= scroll_bar_handle
;
4231 /* "Silently" update current position. */
4235 si
.cbSize
= sizeof (si
);
4238 /* Remember apparent position (we actually lag behind the real
4239 position, so don't set that directly). */
4240 last_scroll_bar_drag_pos
= y
;
4242 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4246 /* If this is the end of a drag sequence, then reset the scroll
4247 handle size to normal and do a final redraw. Otherwise do
4252 int start
= bar
->start
;
4255 si
.cbSize
= sizeof (si
);
4256 si
.fMask
= SIF_PAGE
| SIF_POS
;
4257 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4258 si
.nPos
= last_scroll_bar_drag_pos
;
4259 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4263 emacs_event
->kind
= NO_EVENT
;
4267 XSETINT (emacs_event
->x
, y
);
4268 XSETINT (emacs_event
->y
, top_range
);
4274 /* Handle a mouse click on the horizontal scroll bar BAR. If
4275 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4278 This may be called from a signal handler, so we have to ignore GC
4282 w32_horizontal_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4283 struct input_event
*emacs_event
)
4285 if (! WINDOWP (bar
->window
))
4288 emacs_event
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
4289 emacs_event
->code
= 0;
4290 /* not really meaningful to distinguish left/right */
4291 emacs_event
->modifiers
= msg
->dwModifiers
;
4292 emacs_event
->frame_or_window
= bar
->window
;
4293 emacs_event
->arg
= Qnil
;
4294 emacs_event
->timestamp
= msg
->msg
.time
;
4297 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4299 int dragging
= bar
->dragging
;
4301 int sb_event
= LOWORD (msg
->msg
.wParam
);
4303 si
.cbSize
= sizeof (si
);
4304 if (sb_event
== SB_THUMBTRACK
)
4305 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4307 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4309 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4310 if (sb_event
== SB_THUMBTRACK
)
4314 y
= si
.nMax
- si
.nPage
;
4317 struct frame
*f
; /* Value is not used. */
4318 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4323 emacs_event
->part
= scroll_bar_left_arrow
;
4326 emacs_event
->part
= scroll_bar_right_arrow
;
4329 emacs_event
->part
= scroll_bar_before_handle
;
4332 emacs_event
->part
= scroll_bar_after_handle
;
4335 emacs_event
->part
= scroll_bar_horizontal_handle
;
4339 emacs_event
->part
= scroll_bar_horizontal_handle
;
4343 case SB_THUMBPOSITION
:
4345 emacs_event
->part
= scroll_bar_horizontal_handle
;
4347 /* "Silently" update current position. */
4351 si
.cbSize
= sizeof (si
);
4353 si
.nPos
= min (x
, XWINDOW (bar
->window
)->hscroll_whole
- 1);
4354 /* Remember apparent position (we actually lag behind the real
4355 position, so don't set that directly). */
4356 last_scroll_bar_drag_pos
= x
;
4358 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4362 /* If this is the end of a drag sequence, then reset the scroll
4363 handle size to normal and do a final redraw. Otherwise do
4369 si
.cbSize
= sizeof (si
);
4371 si
.nPos
= min (last_scroll_bar_drag_pos
,
4372 XWINDOW (bar
->window
)->hscroll_whole
- 1);
4373 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4377 emacs_event
->kind
= NO_EVENT
;
4381 XSETINT (emacs_event
->x
, x
);
4382 XSETINT (emacs_event
->y
, y
);
4388 /* Return information to the user about the current position of the mouse
4389 on the vertical scroll bar. */
4391 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4392 enum scroll_bar_part
*part
,
4393 Lisp_Object
*x
, Lisp_Object
*y
,
4396 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4397 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4398 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4399 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4401 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4403 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4408 *bar_window
= bar
->window
;
4410 si
.cbSize
= sizeof (si
);
4411 if (sb_event
== SB_THUMBTRACK
)
4412 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4414 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4416 GetScrollInfo (w
, SB_CTL
, &si
);
4417 if (sb_event
== SB_THUMBTRACK
)
4421 top_range
= si
.nMax
- si
.nPage
+ 1;
4423 *part
= scroll_bar_handle
;
4424 if (sb_event
== SB_LINEDOWN
)
4428 XSETINT (*y
, top_range
);
4430 f
->mouse_moved
= false;
4431 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4433 *time
= dpyinfo
->last_mouse_movement_time
;
4438 /* Return information to the user about the current position of the mouse
4439 on the horizontal scroll bar. */
4441 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4442 enum scroll_bar_part
*part
,
4443 Lisp_Object
*x
, Lisp_Object
*y
,
4446 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4447 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4448 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4449 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4451 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4453 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4458 *bar_window
= bar
->window
;
4460 si
.cbSize
= sizeof (si
);
4461 if (sb_event
== SB_THUMBTRACK
)
4462 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4464 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4466 GetScrollInfo (w
, SB_CTL
, &si
);
4467 if (sb_event
== SB_THUMBTRACK
)
4471 left_range
= si
.nMax
- si
.nPage
+ 1;
4473 *part
= scroll_bar_handle
;
4474 if (sb_event
== SB_LINERIGHT
)
4479 XSETINT (*x
, left_range
);
4481 f
->mouse_moved
= false;
4482 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4484 *time
= dpyinfo
->last_mouse_movement_time
;
4490 /* The screen has been cleared so we may have changed foreground or
4491 background colors, and the scroll bars may need to be redrawn.
4492 Clear out the scroll bars, and ask for expose events, so we can
4496 x_scroll_bar_clear (struct frame
*f
)
4500 /* We can have scroll bars even if this is 0,
4501 if we just turned off scroll bar mode.
4502 But in that case we should not clear them. */
4503 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4504 || FRAME_HAS_HORIZONTAL_SCROLL_BARS (f
))
4505 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4506 bar
= XSCROLL_BAR (bar
)->next
)
4508 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4509 HDC hdc
= GetDC (window
);
4512 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4513 arranges to refresh the scroll bar if hidden. */
4514 my_show_window (f
, window
, SW_HIDE
);
4516 GetClientRect (window
, &rect
);
4517 select_palette (f
, hdc
);
4518 w32_clear_rect (f
, hdc
, &rect
);
4519 deselect_palette (f
, hdc
);
4521 ReleaseDC (window
, hdc
);
4525 /* The main W32 event-reading loop - w32_read_socket. */
4527 /* Record the last 100 characters stored
4528 to help debug the loss-of-chars-during-GC problem. */
4530 static int temp_index
;
4531 static short temp_buffer
[100];
4533 /* Temporarily store lead byte of DBCS input sequences. */
4534 static char dbcs_lead
= 0;
4536 /* Read events coming from the W32 shell.
4537 This routine is called by the SIGIO handler.
4538 We return as soon as there are no more events to be read.
4540 For an overview of how Emacs input works on MS-Windows, see the
4541 commentary before w32_msg_pump in w32fns.c.
4543 We return the number of characters stored into the buffer,
4544 thus pretending to be `read'.
4546 Some of these messages are reposted back to the message queue since the
4547 system calls the windows proc directly in a context where we cannot return
4548 the data nor can we guarantee the state we are in. So if we dispatch them
4549 we will get into an infinite loop. To prevent this from ever happening we
4550 will set a variable to indicate we are in the read_socket call and indicate
4551 which message we are processing since the windows proc gets called
4552 recursively with different messages by the system.
4555 extern void menubar_selection_callback (struct frame
*, void *);
4558 w32_read_socket (struct terminal
*terminal
,
4559 struct input_event
*hold_quit
)
4562 int check_visibility
= 0;
4565 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4566 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
4570 /* So people can tell when we have read the available input. */
4571 input_signal_count
++;
4573 /* Process any incoming thread messages. */
4574 drain_message_queue ();
4576 /* TODO: ghostscript integration. */
4577 while (get_next_msg (&msg
, FALSE
))
4579 struct input_event inev
;
4582 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4583 /* w32_name_of_message (msg.msg.message), */
4584 /* msg.msg.time)); */
4587 inev
.kind
= NO_EVENT
;
4590 switch (msg
.msg
.message
)
4592 case WM_EMACS_PAINT
:
4593 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4597 if (msg
.rect
.right
== msg
.rect
.left
||
4598 msg
.rect
.bottom
== msg
.rect
.top
)
4600 /* We may get paint messages even though the client
4601 area is clipped - these are not expose events. */
4602 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4605 else if (FRAME_VISIBLE_P (f
) != 1)
4607 bool iconified
= FRAME_ICONIFIED_P (f
);
4609 /* Definitely not obscured, so mark as visible. */
4610 SET_FRAME_VISIBLE (f
, 1);
4611 SET_FRAME_ICONIFIED (f
, false);
4612 SET_FRAME_GARBAGED (f
);
4613 if (!f
->output_data
.w32
->asked_for_visible
)
4614 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4617 /* WM_PAINT serves as MapNotify as well, so report
4618 visibility changes properly. */
4621 inev
.kind
= DEICONIFY_EVENT
;
4622 XSETFRAME (inev
.frame_or_window
, f
);
4624 else if (!NILP (Vframe_list
) && !NILP (XCDR (Vframe_list
)))
4625 /* Force a redisplay sooner or later to update the
4626 frame titles in case this is the second frame. */
4627 record_asynch_buffer_change ();
4631 HDC hdc
= get_frame_dc (f
);
4633 /* Erase background again for safety. */
4634 w32_clear_rect (f
, hdc
, &msg
.rect
);
4635 release_frame_dc (f
, hdc
);
4639 msg
.rect
.right
- msg
.rect
.left
,
4640 msg
.rect
.bottom
- msg
.rect
.top
);
4645 case WM_INPUTLANGCHANGE
:
4646 /* Generate a language change event. */
4647 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4649 /* lParam contains the input language ID in its low 16 bits.
4650 Use it to update our record of the keyboard codepage. */
4651 w32_keyboard_codepage
= codepage_for_locale ((LCID
)(msg
.msg
.lParam
4656 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4657 XSETFRAME (inev
.frame_or_window
, f
);
4658 inev
.code
= w32_keyboard_codepage
;
4659 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4665 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4667 if (f
&& !FRAME_ICONIFIED_P (f
))
4669 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4670 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4672 clear_mouse_face (hlinfo
);
4673 hlinfo
->mouse_face_hidden
= true;
4676 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4678 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4679 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4680 inev
.code
= msg
.msg
.wParam
;
4681 inev
.modifiers
= msg
.dwModifiers
;
4682 XSETFRAME (inev
.frame_or_window
, f
);
4683 inev
.timestamp
= msg
.msg
.time
;
4690 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4692 if (f
&& !FRAME_ICONIFIED_P (f
))
4694 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4695 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4697 clear_mouse_face (hlinfo
);
4698 hlinfo
->mouse_face_hidden
= true;
4701 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4703 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4705 inev
.modifiers
= msg
.dwModifiers
;
4706 XSETFRAME (inev
.frame_or_window
, f
);
4707 inev
.timestamp
= msg
.msg
.time
;
4709 if (msg
.msg
.message
== WM_UNICHAR
)
4711 inev
.code
= msg
.msg
.wParam
;
4713 else if (msg
.msg
.wParam
< 256)
4718 dbcs
[1] = (char) msg
.msg
.wParam
;
4722 dbcs
[0] = dbcs_lead
;
4724 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4728 DebPrint (("Invalid DBCS sequence: %d %d\n",
4730 inev
.kind
= NO_EVENT
;
4734 else if (IsDBCSLeadByteEx (w32_keyboard_codepage
,
4735 (BYTE
) msg
.msg
.wParam
))
4737 dbcs_lead
= (char) msg
.msg
.wParam
;
4738 inev
.kind
= NO_EVENT
;
4743 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4744 &dbcs
[1], 1, &code
, 1))
4746 /* What to do with garbage? */
4747 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4748 inev
.kind
= NO_EVENT
;
4756 /* Windows shouldn't generate WM_CHAR events above 0xFF
4757 in non-Unicode message handlers. */
4758 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4759 inev
.kind
= NO_EVENT
;
4762 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4763 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4768 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4770 if (f
&& !FRAME_ICONIFIED_P (f
))
4772 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4773 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4775 clear_mouse_face (hlinfo
);
4776 hlinfo
->mouse_face_hidden
= true;
4779 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4781 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4782 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4783 inev
.code
= GET_APPCOMMAND_LPARAM (msg
.msg
.lParam
);
4784 inev
.modifiers
= msg
.dwModifiers
;
4785 XSETFRAME (inev
.frame_or_window
, f
);
4786 inev
.timestamp
= msg
.msg
.time
;
4791 /* Ignore non-movement. */
4793 int x
= LOWORD (msg
.msg
.lParam
);
4794 int y
= HIWORD (msg
.msg
.lParam
);
4795 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4797 last_mousemove_x
= x
;
4798 last_mousemove_y
= y
;
4801 previous_help_echo_string
= help_echo_string
;
4802 help_echo_string
= Qnil
;
4804 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4805 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4807 if (hlinfo
->mouse_face_hidden
)
4809 hlinfo
->mouse_face_hidden
= false;
4810 clear_mouse_face (hlinfo
);
4815 /* Generate SELECT_WINDOW_EVENTs when needed. */
4816 if (!NILP (Vmouse_autoselect_window
))
4818 static Lisp_Object last_mouse_window
;
4819 Lisp_Object window
= window_from_coordinates
4820 (f
, LOWORD (msg
.msg
.lParam
), HIWORD (msg
.msg
.lParam
), 0, 0);
4822 /* Window will be selected only when it is not
4823 selected now and last mouse movement event was
4824 not in it. Minibuffer window will be selected
4825 only when it is active. */
4826 if (WINDOWP (window
)
4827 && !EQ (window
, last_mouse_window
)
4828 && !EQ (window
, selected_window
)
4829 /* For click-to-focus window managers
4830 create event iff we don't leave the
4832 && (focus_follows_mouse
4833 || (EQ (XWINDOW (window
)->frame
,
4834 XWINDOW (selected_window
)->frame
))))
4836 inev
.kind
= SELECT_WINDOW_EVENT
;
4837 inev
.frame_or_window
= window
;
4839 /* Remember the last window where we saw the mouse. */
4840 last_mouse_window
= window
;
4842 if (!note_mouse_movement (f
, &msg
.msg
))
4843 help_echo_string
= previous_help_echo_string
;
4847 /* If we move outside the frame, then we're
4848 certainly no longer on any text in the frame. */
4849 clear_mouse_face (hlinfo
);
4852 /* If the contents of the global variable help_echo_string
4853 has changed, generate a HELP_EVENT. */
4854 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4855 But it was originally changed to this to fix a bug, so I have
4856 not removed it completely in case the bug is still there. */
4857 if (help_echo_string
!= previous_help_echo_string
||
4858 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4859 #else /* This is what xterm.c does. */
4860 if (!NILP (help_echo_string
)
4861 || !NILP (previous_help_echo_string
))
4866 case WM_LBUTTONDOWN
:
4868 case WM_MBUTTONDOWN
:
4870 case WM_RBUTTONDOWN
:
4872 case WM_XBUTTONDOWN
:
4875 /* If we decide we want to generate an event to be seen
4876 by the rest of Emacs, we put it here. */
4877 bool tool_bar_p
= 0;
4881 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4882 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4886 construct_mouse_click (&inev
, &msg
, f
);
4888 /* Is this in the tool-bar? */
4889 if (WINDOWP (f
->tool_bar_window
)
4890 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4893 int x
= XFASTINT (inev
.x
);
4894 int y
= XFASTINT (inev
.y
);
4896 window
= window_from_coordinates (f
, x
, y
, 0, 1);
4898 if (EQ (window
, f
->tool_bar_window
))
4900 w32_handle_tool_bar_click (f
, &inev
);
4906 || (dpyinfo
->w32_focus_frame
4907 && f
!= dpyinfo
->w32_focus_frame
))
4908 inev
.kind
= NO_EVENT
;
4911 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4916 dpyinfo
->grabbed
&= ~ (1 << button
);
4920 dpyinfo
->grabbed
|= (1 << button
);
4921 dpyinfo
->last_mouse_frame
= f
;
4922 /* Ignore any mouse motion that happened
4923 before this event; any subsequent mouse-movement
4924 Emacs events should reflect only motion after
4928 f
->mouse_moved
= false;
4930 f
->last_tool_bar_item
= -1;
4937 case WM_MOUSEHWHEEL
:
4939 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4940 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4945 if (!dpyinfo
->w32_focus_frame
4946 || f
== dpyinfo
->w32_focus_frame
)
4948 /* Emit an Emacs wheel-up/down event. */
4949 construct_mouse_wheel (&inev
, &msg
, f
);
4951 /* Ignore any mouse motion that happened before this
4952 event; any subsequent mouse-movement Emacs events
4953 should reflect only motion after the
4955 f
->mouse_moved
= false;
4956 f
->last_tool_bar_item
= -1;
4958 dpyinfo
->last_mouse_frame
= f
;
4963 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4966 construct_drag_n_drop (&inev
, &msg
, f
);
4971 struct scroll_bar
*bar
=
4972 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 1);
4975 w32_horizontal_scroll_bar_handle_click (bar
, &msg
, &inev
);
4981 struct scroll_bar
*bar
=
4982 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 0);
4985 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
4989 case WM_WINDOWPOSCHANGED
:
4991 case WM_ACTIVATEAPP
:
4992 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4995 /* Run the full-screen hook function also when we are
4996 being activated, to actually install the required
4997 size in effect, if the WAIT flag is set. This is
4998 because when the hook is run from x_set_fullscreen,
4999 the frame might not yet be visible, if that call is a
5000 result of make-frame, and in that case the hook just
5001 sets the WAIT flag. */
5002 if ((msg
.msg
.message
== WM_WINDOWPOSCHANGED
|| msg
.msg
.wParam
)
5003 && (f
->want_fullscreen
& FULLSCREEN_WAIT
))
5005 /* Must set visibility right here since otherwise
5006 w32fullscreen_hook returns immediately. */
5007 SET_FRAME_VISIBLE (f
, 1);
5008 w32fullscreen_hook (f
);
5011 check_visibility
= 1;
5015 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5017 if (f
&& !FRAME_ICONIFIED_P (f
))
5018 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5020 check_visibility
= 1;
5024 /* wParam non-zero means Window is about to be shown, 0 means
5025 about to be hidden. */
5026 /* Redo the mouse-highlight after the tooltip has gone. */
5028 && dpyinfo
->w32_tooltip_frame
5029 && FRAME_W32_WINDOW (dpyinfo
->w32_tooltip_frame
) == msg
.msg
.hwnd
)
5030 x_redo_mouse_highlight (dpyinfo
);
5032 /* If window has been obscured or exposed by another window
5033 being maximized or minimized/restored, then recheck
5034 visibility of all frames. Direct changes to our own
5035 windows get handled by WM_SIZE. */
5037 if (msg
.msg
.lParam
!= 0)
5038 check_visibility
= 1;
5041 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5042 f
->async_visible
= msg
.msg
.wParam
;
5046 check_visibility
= 1;
5050 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5052 /* Inform lisp of whether frame has been iconified etc. */
5055 switch (msg
.msg
.wParam
)
5057 case SIZE_MINIMIZED
:
5058 SET_FRAME_VISIBLE (f
, 0);
5059 SET_FRAME_ICONIFIED (f
, true);
5061 inev
.kind
= ICONIFY_EVENT
;
5062 XSETFRAME (inev
.frame_or_window
, f
);
5065 case SIZE_MAXIMIZED
:
5067 bool iconified
= FRAME_ICONIFIED_P (f
);
5068 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5070 SET_FRAME_VISIBLE (f
, 1);
5071 SET_FRAME_ICONIFIED (f
, false);
5073 /* wait_reading_process_output will notice this
5074 and update the frame's display structures. */
5075 SET_FRAME_GARBAGED (f
);
5081 /* Reset top and left positions of the Window
5082 here since Windows sends a WM_MOVE message
5083 BEFORE telling us the Window is minimized
5084 when the Window is iconified, with 3000,3000
5086 x_real_positions (f
, &x
, &y
);
5090 inev
.kind
= DEICONIFY_EVENT
;
5091 XSETFRAME (inev
.frame_or_window
, f
);
5093 else if (! NILP (Vframe_list
)
5094 && ! NILP (XCDR (Vframe_list
)))
5095 /* Force a redisplay sooner or later
5096 to update the frame titles
5097 in case this is the second frame. */
5098 record_asynch_buffer_change ();
5100 /* Windows can send us a SIZE_MAXIMIZED message even
5101 when fullscreen is fullboth. The following is a
5102 simple hack to check that based on the fact that
5103 only a maximized fullscreen frame should have both
5104 top/left outside the screen. */
5105 if (EQ (fullscreen
, Qfullwidth
) || EQ (fullscreen
, Qfullheight
)
5106 || NILP (fullscreen
))
5110 x_real_positions (f
, &x
, &y
);
5112 store_frame_param (f
, Qfullscreen
, Qmaximized
);
5120 bool iconified
= FRAME_ICONIFIED_P (f
);
5122 /* The following was made unconditional in a
5123 pathetic attempt to fix bug#16967 in revision
5124 116716 but, considered counterproductive was made
5125 conditional again in revision 116727. martin */
5127 SET_FRAME_VISIBLE (f
, 1);
5128 SET_FRAME_ICONIFIED (f
, false);
5130 /* wait_reading_process_output will notice this
5131 and update the frame's display structures. */
5132 SET_FRAME_GARBAGED (f
);
5136 /* Reset top and left positions of the Window
5137 here since Windows sends a WM_MOVE message
5138 BEFORE telling us the Window is minimized
5139 when the Window is iconified, with 3000,3000
5141 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5143 inev
.kind
= DEICONIFY_EVENT
;
5144 XSETFRAME (inev
.frame_or_window
, f
);
5146 else if (! NILP (Vframe_list
)
5147 && ! NILP (XCDR (Vframe_list
)))
5148 /* Force a redisplay sooner or later
5149 to update the frame titles
5150 in case this is the second frame. */
5151 record_asynch_buffer_change ();
5154 if (EQ (get_frame_param (f
, Qfullscreen
), Qmaximized
))
5155 store_frame_param (f
, Qfullscreen
, Qnil
);
5161 if (f
&& !FRAME_ICONIFIED_P (f
) && msg
.msg
.wParam
!= SIZE_MINIMIZED
)
5164 int /* rows, columns, */ width
, height
, text_width
, text_height
;
5166 if (GetClientRect (msg
.msg
.hwnd
, &rect
)
5167 /* GetClientRect evidently returns (0, 0, 0, 0) if
5168 called on a minimized frame. Such "dimensions"
5169 aren't useful anyway. */
5170 && !(rect
.bottom
== 0
5173 && rect
.right
== 0))
5175 height
= rect
.bottom
- rect
.top
;
5176 width
= rect
.right
- rect
.left
;
5177 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, width
);
5178 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, height
);
5179 /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
5180 /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
5182 /* TODO: Clip size to the screen dimensions. */
5184 /* Even if the number of character rows and columns
5185 has not changed, the font size may have changed,
5186 so we need to check the pixel dimensions as well. */
5188 if (width
!= FRAME_PIXEL_WIDTH (f
)
5189 || height
!= FRAME_PIXEL_HEIGHT (f
)
5190 || text_width
!= FRAME_TEXT_WIDTH (f
)
5191 || text_height
!= FRAME_TEXT_HEIGHT (f
))
5193 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
5194 SET_FRAME_GARBAGED (f
);
5195 cancel_mouse_face (f
);
5196 f
->win_gravity
= NorthWestGravity
;
5201 check_visibility
= 1;
5205 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5208 if (f
== hlinfo
->mouse_face_mouse_frame
)
5210 /* If we move outside the frame, then we're
5211 certainly no longer on any text in the frame. */
5212 clear_mouse_face (hlinfo
);
5213 hlinfo
->mouse_face_mouse_frame
= 0;
5216 /* Generate a nil HELP_EVENT to cancel a help-echo.
5217 Do it only if there's something to cancel.
5218 Otherwise, the startup message is cleared when
5219 the mouse leaves the frame. */
5220 if (any_help_event_p
)
5226 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5228 dpyinfo
->grabbed
= 0;
5229 check_visibility
= 1;
5233 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5234 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5238 if (f
== hlinfo
->mouse_face_mouse_frame
)
5240 /* If we move outside the frame, then we're
5241 certainly no longer on any text in the frame. */
5242 clear_mouse_face (hlinfo
);
5243 hlinfo
->mouse_face_mouse_frame
= 0;
5246 /* Generate a nil HELP_EVENT to cancel a help-echo.
5247 Do it only if there's something to cancel.
5248 Otherwise, the startup message is cleared when
5249 the mouse leaves the frame. */
5250 if (any_help_event_p
)
5254 dpyinfo
->grabbed
= 0;
5255 check_visibility
= 1;
5259 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5263 inev
.kind
= DELETE_WINDOW_EVENT
;
5264 XSETFRAME (inev
.frame_or_window
, f
);
5269 inev
.kind
= END_SESSION_EVENT
;
5273 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5277 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
5278 XSETFRAME (inev
.frame_or_window
, f
);
5283 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5287 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
5290 check_visibility
= 1;
5293 case WM_DISPLAYCHANGE
:
5294 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5298 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5300 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
5301 /* The new display could have a different resolution, in
5302 which case we must reconsider what fullscreen means.
5303 The following code is untested yet. */
5304 if (!NILP (fullscreen
))
5306 x_set_fullscreen (f
, fullscreen
, fullscreen
);
5307 w32fullscreen_hook (f
);
5310 DebPrint (("display change: %d %d\n",
5311 (short) LOWORD (msg
.msg
.lParam
),
5312 (short) HIWORD (msg
.msg
.lParam
)));
5315 check_visibility
= 1;
5319 case WM_EMACS_FILENOTIFY
:
5320 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5322 queue_notifications (&inev
, &msg
, f
, &count
);
5327 /* Check for messages registered at runtime. */
5328 if (msg
.msg
.message
== msh_mousewheel
)
5330 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5331 msg
.msg
.message
= WM_MOUSEWHEEL
;
5337 if (inev
.kind
!= NO_EVENT
)
5339 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5344 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5349 XSETFRAME (frame
, f
);
5355 if (NILP (help_echo_string
))
5357 help_echo_object
= help_echo_window
= Qnil
;
5361 any_help_event_p
= 1;
5362 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5363 help_echo_object
, help_echo_pos
);
5367 help_echo_string
= Qnil
;
5368 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5374 /* If the focus was just given to an autoraising frame,
5375 raise it now. FIXME: handle more than one such frame. */
5376 if (dpyinfo
->w32_pending_autoraise_frame
)
5378 x_raise_frame (dpyinfo
->w32_pending_autoraise_frame
);
5379 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
5382 /* Check which frames are still visible, if we have enqueued any user
5383 events or been notified of events that may affect visibility. We
5384 do this here because there doesn't seem to be any direct
5385 notification from Windows that the visibility of a window has
5386 changed (at least, not in all cases). */
5387 if (count
> 0 || check_visibility
)
5389 Lisp_Object tail
, frame
;
5391 FOR_EACH_FRAME (tail
, frame
)
5393 struct frame
*f
= XFRAME (frame
);
5394 /* The tooltip has been drawn already. Avoid the
5395 SET_FRAME_GARBAGED below. */
5396 if (FRAME_TOOLTIP_P (f
))
5399 /* Check "visible" frames and mark each as obscured or not.
5400 Note that visible is nonzero for unobscured and obscured
5401 frames, but zero for hidden and iconified frames. */
5402 if (FRAME_W32_P (f
) && FRAME_VISIBLE_P (f
))
5409 /* Query clipping rectangle for the entire window area
5410 (GetWindowDC), not just the client portion (GetDC).
5411 Otherwise, the scrollbars and menubar aren't counted as
5412 part of the visible area of the frame, and we may think
5413 the frame is obscured when really a scrollbar is still
5414 visible and gets WM_PAINT messages above. */
5415 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5416 GetClipBox (hdc
, &clipbox
);
5417 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5420 obscured
= FRAME_OBSCURED_P (f
);
5422 if (clipbox
.right
== clipbox
.left
|| clipbox
.bottom
== clipbox
.top
)
5424 /* Frame has become completely obscured so mark as such (we
5425 do this by setting visible to 2 so that FRAME_VISIBLE_P
5426 is still true, but redisplay will skip it). */
5427 SET_FRAME_VISIBLE (f
, 2);
5430 DebPrint (("frame %p (%s) obscured\n", f
, SDATA (f
->name
)));
5434 /* Frame is not obscured, so mark it as such. */
5435 SET_FRAME_VISIBLE (f
, 1);
5439 SET_FRAME_GARBAGED (f
);
5440 DebPrint (("obscured frame %p (%s) found to be visible\n",
5441 f
, SDATA (f
->name
)));
5443 /* Force a redisplay sooner or later. */
5444 record_asynch_buffer_change ();
5457 /***********************************************************************
5459 ***********************************************************************/
5461 /* Set clipping for output in glyph row ROW. W is the window in which
5462 we operate. GC is the graphics context to set clipping in.
5464 ROW may be a text row or, e.g., a mode line. Text rows must be
5465 clipped to the interior of the window dedicated to text display,
5466 mode lines must be clipped to the whole window. */
5469 w32_clip_to_row (struct window
*w
, struct glyph_row
*row
,
5470 enum glyph_row_area area
, HDC hdc
)
5473 int window_x
, window_y
, window_width
;
5475 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5477 clip_rect
.left
= window_x
;
5478 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5479 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5480 clip_rect
.right
= clip_rect
.left
+ window_width
;
5481 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5483 w32_set_clip_rectangle (hdc
, &clip_rect
);
5487 /* Draw a hollow box cursor on window W in glyph row ROW. */
5490 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
5492 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5496 struct glyph
*cursor_glyph
;
5497 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5499 /* Get the glyph the cursor is on. If we can't tell because
5500 the current matrix is invalid or such, give up. */
5501 cursor_glyph
= get_phys_cursor_glyph (w
);
5502 if (cursor_glyph
== NULL
)
5508 /* Compute frame-relative coordinates for phys cursor. */
5509 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5511 /* When on R2L character, show cursor at the right edge of the
5512 glyph, unless the cursor box is as wide as the glyph or wider
5513 (the latter happens when x-stretch-cursor is non-nil). */
5514 if ((cursor_glyph
->resolved_level
& 1) != 0
5515 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5516 rect
.left
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5518 rect
.bottom
= rect
.top
+ h
;
5519 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5521 hdc
= get_frame_dc (f
);
5522 /* Set clipping, draw the rectangle, and reset clipping again. */
5523 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5524 FrameRect (hdc
, &rect
, hb
);
5526 w32_set_clip_rectangle (hdc
, NULL
);
5527 release_frame_dc (f
, hdc
);
5531 /* Draw a bar cursor on window W in glyph row ROW.
5533 Implementation note: One would like to draw a bar cursor with an
5534 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5535 Unfortunately, I didn't find a font yet that has this property set.
5539 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
,
5540 int width
, enum text_cursor_kinds kind
)
5542 struct frame
*f
= XFRAME (w
->frame
);
5543 struct glyph
*cursor_glyph
;
5545 /* If cursor is out of bounds, don't draw garbage. This can happen
5546 in mini-buffer windows when switching between echo area glyphs
5548 cursor_glyph
= get_phys_cursor_glyph (w
);
5549 if (cursor_glyph
== NULL
)
5552 /* If on an image, draw like a normal cursor. That's usually better
5553 visible than drawing a bar, esp. if the image is large so that
5554 the bar might not be in the window. */
5555 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5557 struct glyph_row
*row
;
5558 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5559 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5563 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5564 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5568 /* If the glyph's background equals the color we normally draw
5569 the bar cursor in, the bar cursor in its normal color is
5570 invisible. Use the glyph's foreground color instead in this
5571 case, on the assumption that the glyph's colors are chosen so
5572 that the glyph is legible. */
5573 if (face
->background
== cursor_color
)
5574 cursor_color
= face
->foreground
;
5576 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5578 hdc
= get_frame_dc (f
);
5579 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5581 if (kind
== BAR_CURSOR
)
5584 width
= FRAME_CURSOR_WIDTH (f
);
5585 width
= min (cursor_glyph
->pixel_width
, width
);
5587 w
->phys_cursor_width
= width
;
5589 /* If the character under cursor is R2L, draw the bar cursor
5590 on the right of its glyph, rather than on the left. */
5591 if ((cursor_glyph
->resolved_level
& 1) != 0)
5592 x
+= cursor_glyph
->pixel_width
- width
;
5594 w32_fill_area (f
, hdc
, cursor_color
, x
,
5595 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5596 width
, row
->height
);
5598 else /* HBAR_CURSOR */
5600 int dummy_x
, dummy_y
, dummy_h
;
5603 width
= row
->height
;
5605 width
= min (row
->height
, width
);
5607 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
5608 &dummy_y
, &dummy_h
);
5609 if ((cursor_glyph
->resolved_level
& 1) != 0
5610 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5611 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5612 w32_fill_area (f
, hdc
, cursor_color
, x
,
5613 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5614 row
->height
- width
),
5615 w
->phys_cursor_width
, width
);
5618 w32_set_clip_rectangle (hdc
, NULL
);
5619 release_frame_dc (f
, hdc
);
5624 /* RIF: Define cursor CURSOR on frame F. */
5627 w32_define_frame_cursor (struct frame
*f
, Cursor cursor
)
5629 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5633 /* RIF: Clear area on frame F. */
5636 w32_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
5640 hdc
= get_frame_dc (f
);
5641 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5642 release_frame_dc (f
, hdc
);
5645 /* RIF: Draw or clear cursor on window W. */
5648 w32_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
,
5649 int x
, int y
, enum text_cursor_kinds cursor_type
,
5650 int cursor_width
, bool on_p
, bool active_p
)
5654 /* If the user wants to use the system caret, make sure our own
5655 cursor remains invisible. */
5656 if (w32_use_visible_system_caret
)
5658 /* Call to erase_phys_cursor here seems to use the
5659 wrong values of w->phys_cursor, as they have been
5660 overwritten before this function was called. */
5661 if (w
->phys_cursor_type
!= NO_CURSOR
)
5662 erase_phys_cursor (w
);
5664 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5665 w
->phys_cursor_width
= -1;
5669 w
->phys_cursor_type
= cursor_type
;
5672 w
->phys_cursor_on_p
= true;
5674 /* If this is the active cursor, we need to track it with the
5675 system caret, so third party software like screen magnifiers
5676 and speech synthesizers can follow the cursor. */
5679 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5680 HWND hwnd
= FRAME_W32_WINDOW (f
);
5683 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5685 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5686 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5687 w32_system_caret_window
= w
;
5688 w32_system_caret_hdr_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
5689 w32_system_caret_mode_height
= WINDOW_MODE_LINE_HEIGHT (w
);
5691 PostMessage (hwnd
, WM_IME_STARTCOMPOSITION
, 0, 0);
5693 /* If the size of the active cursor changed, destroy the old
5695 if (w32_system_caret_hwnd
5696 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5697 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5699 w32_system_caret_height
= w
->phys_cursor_height
;
5701 /* Move the system caret. */
5702 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5705 if (glyph_row
->exact_window_width_line_p
5706 && (glyph_row
->reversed_p
5707 ? (w
->phys_cursor
.hpos
< 0)
5708 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
5710 glyph_row
->cursor_in_fringe_p
= true;
5711 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
5715 switch (cursor_type
)
5717 case HOLLOW_BOX_CURSOR
:
5718 x_draw_hollow_cursor (w
, glyph_row
);
5721 case FILLED_BOX_CURSOR
:
5722 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5726 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5730 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5734 w
->phys_cursor_width
= 0;
5748 x_bitmap_icon (struct frame
*f
, Lisp_Object icon
)
5751 HANDLE small_icon
= NULL
;
5753 if (FRAME_W32_WINDOW (f
) == 0)
5757 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5758 else if (STRINGP (icon
))
5760 /* Load the main icon from the named file. */
5761 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5762 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5763 /* Try to load a small icon to go with it. */
5764 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5765 GetSystemMetrics (SM_CXSMICON
),
5766 GetSystemMetrics (SM_CYSMICON
),
5769 else if (SYMBOLP (icon
))
5773 if (EQ (icon
, intern ("application")))
5774 name
= (LPCTSTR
) IDI_APPLICATION
;
5775 else if (EQ (icon
, intern ("hand")))
5776 name
= (LPCTSTR
) IDI_HAND
;
5777 else if (EQ (icon
, intern ("question")))
5778 name
= (LPCTSTR
) IDI_QUESTION
;
5779 else if (EQ (icon
, intern ("exclamation")))
5780 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5781 else if (EQ (icon
, intern ("asterisk")))
5782 name
= (LPCTSTR
) IDI_ASTERISK
;
5783 else if (EQ (icon
, intern ("winlogo")))
5784 name
= (LPCTSTR
) IDI_WINLOGO
;
5788 main_icon
= LoadIcon (NULL
, name
);
5793 if (main_icon
== NULL
)
5796 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5797 (LPARAM
) main_icon
);
5799 /* If there is a small icon that goes with it, set that too. */
5801 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5802 (LPARAM
) small_icon
);
5808 /************************************************************************
5810 ************************************************************************/
5812 /* Display Error Handling functions not used on W32. Listing them here
5813 helps diff stay in step when comparing w32term.c with xterm.c.
5815 x_error_catcher (display, error)
5816 x_catch_errors (dpy)
5817 x_catch_errors_unwind (old_val)
5818 x_check_errors (dpy, format)
5819 x_fully_uncatch_errors ()
5820 x_had_errors_p (dpy)
5821 x_clear_errors (dpy)
5822 x_uncatch_errors (dpy, count)
5824 x_connection_signal (signalnum)
5825 x_connection_closed (dpy, error_message)
5826 x_error_quitter (display, error)
5827 x_error_handler (display, error)
5828 x_io_error_quitter (display)
5833 /* Changing the font of the frame. */
5836 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
5838 struct font
*font
= XFONT_OBJECT (font_object
);
5839 int unit
, font_ascent
, font_descent
;
5842 fontset
= fontset_from_font (font_object
);
5843 FRAME_FONTSET (f
) = fontset
;
5844 if (FRAME_FONT (f
) == font
)
5845 /* This font is already set in frame F. There's nothing more to
5849 FRAME_FONT (f
) = font
;
5850 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5851 FRAME_COLUMN_WIDTH (f
) = unit
= font
->average_width
;
5852 get_font_ascent_descent (font
, &font_ascent
, &font_descent
);
5853 FRAME_LINE_HEIGHT (f
) = font_ascent
+ font_descent
;
5855 /* Compute number of scrollbar columns. */
5856 unit
= FRAME_COLUMN_WIDTH (f
);
5857 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5858 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5859 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
5862 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
5863 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) =
5864 FRAME_CONFIG_SCROLL_BAR_COLS (f
) * unit
;
5867 /* Now make the frame display the given font. */
5868 if (FRAME_X_WINDOW (f
) != 0)
5870 /* Don't change the size of a tip frame; there's no point in
5871 doing it because it's done in Fx_show_tip, and it leads to
5872 problems because the tip frame has no widget. */
5873 if (!FRAME_TOOLTIP_P (f
))
5874 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
5875 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
5879 /* X version sets font of input methods here also. */
5885 /***********************************************************************
5886 TODO: W32 Input Methods
5887 ***********************************************************************/
5888 /* Listing missing functions from xterm.c helps diff stay in step.
5890 xim_destroy_callback (xim, client_data, call_data)
5891 xim_open_dpy (dpyinfo, resource_name)
5893 xim_instantiate_callback (display, client_data, call_data)
5894 xim_initialize (dpyinfo, resource_name)
5895 xim_close_dpy (dpyinfo)
5900 /* Calculate the absolute position in frame F
5901 from its current recorded position values and gravity. */
5904 x_calc_absolute_position (struct frame
*f
)
5906 int flags
= f
->size_hint_flags
;
5908 /* The sum of the widths of the frame's left and right borders, and
5909 the sum of the heights of the frame's top and bottom borders (in
5910 pixels) drawn by Windows. */
5911 unsigned int left_right_borders_width
, top_bottom_borders_height
;
5913 /* Try to get the actual values of these two variables. We compute
5914 the border width (height) by subtracting the width (height) of
5915 the frame's client area from the width (height) of the frame's
5917 WINDOWPLACEMENT wp
= { 0 };
5918 RECT client_rect
= { 0 };
5920 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
5921 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
5923 left_right_borders_width
=
5924 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
5925 (client_rect
.right
- client_rect
.left
);
5927 top_bottom_borders_height
=
5928 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
5929 (client_rect
.bottom
- client_rect
.top
);
5933 /* Use sensible default values. */
5934 left_right_borders_width
= 8;
5935 top_bottom_borders_height
= 32;
5938 /* With multiple monitors, we can legitimately get negative
5939 coordinates (for monitors above or to the left of the primary
5940 monitor). Find the display origin to ensure negative positions
5941 are computed correctly (Bug#21173). */
5942 int display_left
= 0;
5943 int display_top
= 0;
5944 if (flags
& (XNegative
| YNegative
))
5948 list
= Fw32_display_monitor_attributes_list (Qnil
);
5949 while (CONSP (list
))
5951 Lisp_Object attributes
= CAR(list
);
5952 Lisp_Object geometry
;
5953 Lisp_Object monitor_left
, monitor_top
;
5957 geometry
= Fassoc (Qgeometry
, attributes
);
5958 if (!NILP (geometry
))
5960 monitor_left
= Fnth (make_number (1), geometry
);
5961 monitor_top
= Fnth (make_number (2), geometry
);
5963 display_left
= min (display_left
, XINT (monitor_left
));
5964 display_top
= min (display_top
, XINT (monitor_top
));
5969 /* Treat negative positions as relative to the rightmost bottommost
5970 position that fits on the screen. */
5971 if (flags
& XNegative
)
5972 f
->left_pos
= (x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
5974 - FRAME_PIXEL_WIDTH (f
)
5976 - (left_right_borders_width
- 1));
5978 if (flags
& YNegative
)
5979 f
->top_pos
= (x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
5981 - FRAME_PIXEL_HEIGHT (f
)
5983 - (top_bottom_borders_height
- 1));
5985 /* The left_pos and top_pos are now relative to the top and left
5986 screen edges, so the flags should correspond. */
5987 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5990 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5991 to really change the position, and 0 when calling from
5992 x_make_frame_visible (in that case, XOFF and YOFF are the current
5993 position values). It is -1 when calling from x_set_frame_parameters,
5994 which means, do adjust for borders but don't change the gravity. */
5997 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
,
6000 int modified_top
, modified_left
;
6002 if (change_gravity
> 0)
6006 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6008 f
->size_hint_flags
|= XNegative
;
6010 f
->size_hint_flags
|= YNegative
;
6011 f
->win_gravity
= NorthWestGravity
;
6013 x_calc_absolute_position (f
);
6016 x_wm_set_size_hint (f
, (long) 0, false);
6018 modified_left
= f
->left_pos
;
6019 modified_top
= f
->top_pos
;
6021 my_set_window_pos (FRAME_W32_WINDOW (f
),
6023 modified_left
, modified_top
,
6025 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6030 w32fullscreen_hook (struct frame
*f
)
6032 if (FRAME_VISIBLE_P (f
))
6034 HWND hwnd
= FRAME_W32_WINDOW(f
);
6035 DWORD dwStyle
= GetWindowLong (hwnd
, GWL_STYLE
);
6037 enum fullscreen_type prev_fsmode
= FRAME_PREV_FSMODE (f
);
6040 f
->want_fullscreen
&= ~FULLSCREEN_WAIT
;
6042 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_NONE
)
6043 GetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6045 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_BOTH
)
6047 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
| WS_OVERLAPPEDWINDOW
);
6048 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6050 else if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_HEIGHT
6051 || FRAME_PREV_FSMODE (f
) == FULLSCREEN_WIDTH
)
6052 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6054 FRAME_PREV_FSMODE (f
) = f
->want_fullscreen
;
6056 if (f
->want_fullscreen
== FULLSCREEN_NONE
)
6057 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6058 else if (f
->want_fullscreen
== FULLSCREEN_MAXIMIZED
)
6060 if (prev_fsmode
== FULLSCREEN_BOTH
|| prev_fsmode
== FULLSCREEN_WIDTH
6061 || prev_fsmode
== FULLSCREEN_HEIGHT
)
6062 /* Make window normal since otherwise the subsequent
6063 maximization might fail in some cases. */
6064 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6065 ShowWindow (hwnd
, SW_MAXIMIZE
);
6067 else if (f
->want_fullscreen
== FULLSCREEN_BOTH
)
6069 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6071 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6072 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6073 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
& ~WS_OVERLAPPEDWINDOW
);
6074 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6075 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
,
6076 SWP_NOOWNERZORDER
| SWP_FRAMECHANGED
);
6078 (f
, FRAME_PIXEL_TO_TEXT_WIDTH (f
, rect
.right
- rect
.left
),
6079 FRAME_PIXEL_TO_TEXT_HEIGHT (f
, (rect
.bottom
- rect
.top
6080 - menu_bar_height
)),
6085 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6086 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6087 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6088 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6089 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, 0);
6091 if (f
->want_fullscreen
== FULLSCREEN_WIDTH
)
6093 int border_width
= GetSystemMetrics (SM_CXFRAME
);
6096 (f
, (FRAME_PIXEL_TO_TEXT_WIDTH
6097 (f
, rect
.right
- rect
.left
- 2 * border_width
)),
6102 int border_height
= GetSystemMetrics (SM_CYFRAME
);
6103 /* Won't work for wrapped menu bar. */
6104 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6105 int title_height
= GetSystemMetrics (SM_CYCAPTION
);
6108 (f
, 0, (FRAME_PIXEL_TO_TEXT_HEIGHT
6109 (f
, rect
.bottom
- rect
.top
- 2 * border_height
6110 - title_height
- menu_bar_height
)),
6115 f
->want_fullscreen
= FULLSCREEN_NONE
;
6118 if (f
->want_fullscreen
== FULLSCREEN_BOTH
6119 || f
->want_fullscreen
== FULLSCREEN_WIDTH
6120 || f
->want_fullscreen
== FULLSCREEN_HEIGHT
)
6121 do_pending_window_change (0);
6125 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
6128 /* Call this to change the size of frame F's x-window.
6129 If CHANGE_GRAVITY, change to top-left-corner window gravity
6130 for this size change and subsequent size changes.
6131 Otherwise we leave the window gravity unchanged. */
6134 x_set_window_size (struct frame
*f
, bool change_gravity
,
6135 int width
, int height
, bool pixelwise
)
6137 int pixelwidth
, pixelheight
;
6138 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
6141 int menu_bar_height
;
6145 /* Get the height of the menu bar here. It's used below to detect
6146 whether the menu bar is wrapped. It's also used to specify the
6147 third argument for AdjustWindowRect. FRAME_EXTERNAL_MENU_BAR which
6148 has been used before for that reason is unreliable because it only
6149 specifies whether we _want_ a menu bar for this frame and not
6150 whether this frame _has_ a menu bar. See bug#22105. */
6151 info
.cbSize
= sizeof (info
);
6152 info
.rcBar
.top
= info
.rcBar
.bottom
= 0;
6153 GetMenuBarInfo (FRAME_W32_WINDOW (f
), 0xFFFFFFFD, 0, &info
);
6154 menu_bar_height
= info
.rcBar
.bottom
- info
.rcBar
.top
;
6158 pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
6159 pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
6163 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
);
6164 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
);
6167 if (w32_add_wrapped_menu_bar_lines
)
6169 /* When the menu bar wraps sending a SetWindowPos shrinks the
6170 height of the frame then the wrapped menu bar lines are not
6171 accounted for (Bug#15174 and Bug#18720). Here we add these
6172 extra lines to the frame height. */
6173 int default_menu_bar_height
;
6175 /* Why is (apparently) SM_CYMENUSIZE needed here instead of
6177 default_menu_bar_height
= GetSystemMetrics (SM_CYMENUSIZE
);
6179 if ((default_menu_bar_height
> 0)
6180 && (menu_bar_height
> default_menu_bar_height
)
6181 && ((menu_bar_height
% default_menu_bar_height
) == 0))
6182 pixelheight
= pixelheight
+ menu_bar_height
- default_menu_bar_height
;
6185 f
->win_gravity
= NorthWestGravity
;
6186 x_wm_set_size_hint (f
, (long) 0, false);
6188 rect
.left
= rect
.top
= 0;
6189 rect
.right
= pixelwidth
;
6190 rect
.bottom
= pixelheight
;
6192 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
, menu_bar_height
> 0);
6194 if (!(f
->after_make_frame
)
6195 && !(f
->want_fullscreen
& FULLSCREEN_WAIT
)
6196 && FRAME_VISIBLE_P (f
))
6200 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6202 if (EQ (fullscreen
, Qmaximized
)
6203 || EQ (fullscreen
, Qfullboth
)
6204 || EQ (fullscreen
, Qfullwidth
))
6206 rect
.left
= window_rect
.left
;
6207 rect
.right
= window_rect
.right
;
6210 if (EQ (fullscreen
, Qmaximized
)
6211 || EQ (fullscreen
, Qfullboth
)
6212 || EQ (fullscreen
, Qfullheight
))
6214 rect
.top
= window_rect
.top
;
6215 rect
.bottom
= window_rect
.bottom
;
6220 if (pixelwidth
> 0 || pixelheight
> 0)
6222 frame_size_history_add
6223 (f
, Qx_set_window_size_1
, width
, height
,
6224 list2 (Fcons (make_number (pixelwidth
),
6225 make_number (pixelheight
)),
6226 Fcons (make_number (rect
.right
- rect
.left
),
6227 make_number (rect
.bottom
- rect
.top
))));
6229 my_set_window_pos (FRAME_W32_WINDOW (f
), NULL
,
6231 rect
.right
- rect
.left
,
6232 rect
.bottom
- rect
.top
,
6233 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6235 change_frame_size (f
,
6237 ? 0 : FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
)),
6239 ? 0 : FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
)),
6241 SET_FRAME_GARBAGED (f
);
6243 /* If cursor was outside the new size, mark it as off. */
6244 mark_window_cursors_off (XWINDOW (f
->root_window
));
6246 /* Clear out any recollection of where the mouse highlighting was,
6247 since it might be in a place that's outside the new frame size.
6248 Actually checking whether it is outside is a pain in the neck,
6249 so don't try--just let the highlighting be done afresh with new
6251 cancel_mouse_face (f
);
6256 do_pending_window_change (false);
6259 /* Mouse warping. */
6262 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
6271 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
6272 pt
.x
= rect
.left
+ pix_x
;
6273 pt
.y
= rect
.top
+ pix_y
;
6274 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
6276 /* When "mouse trails" are in effect, moving the mouse cursor
6277 sometimes leaves behind an annoying "ghost" of the pointer.
6278 Avoid that by momentarily switching off mouse trails. */
6279 if (os_subtype
== OS_NT
6280 && w32_major_version
+ w32_minor_version
>= 6)
6281 ret
= SystemParametersInfo (SPI_GETMOUSETRAILS
, 0, &trail_num
, 0);
6282 SetCursorPos (pt
.x
, pt
.y
);
6284 SystemParametersInfo (SPI_SETMOUSETRAILS
, trail_num
, NULL
, 0);
6290 /* focus shifting, raising and lowering. */
6293 x_focus_frame (struct frame
*f
)
6296 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6299 /* Give input focus to frame. */
6302 /* Try not to change its Z-order if possible. */
6303 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
6304 my_set_focus (f
, FRAME_W32_WINDOW (f
));
6307 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6311 /* Raise frame F. */
6313 x_raise_frame (struct frame
*f
)
6317 /* Strictly speaking, raise-frame should only change the frame's Z
6318 order, leaving input focus unchanged. This is reasonable behavior
6319 on X where the usual policy is point-to-focus. However, this
6320 behavior would be very odd on Windows where the usual policy is
6323 On X, if the mouse happens to be over the raised frame, it gets
6324 input focus anyway (so the window with focus will never be
6325 completely obscured) - if not, then just moving the mouse over it
6326 is sufficient to give it focus. On Windows, the user must actually
6327 click on the frame (preferably the title bar so as not to move
6328 point), which is more awkward. Also, no other Windows program
6329 raises a window to the top but leaves another window (possibly now
6330 completely obscured) with input focus.
6332 Because there is a system setting on Windows that allows the user
6333 to choose the point to focus policy, we make the strict semantics
6334 optional, but by default we grab focus when raising. */
6336 if (NILP (Vw32_grab_focus_on_raise
))
6338 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6339 not already the foreground application: the frame is raised
6340 above all other frames belonging to us, but not above the
6341 current top window. To achieve that, we have to resort to this
6342 more cumbersome method. */
6344 HDWP handle
= BeginDeferWindowPos (2);
6347 handle
= DeferWindowPos (handle
,
6348 FRAME_W32_WINDOW (f
),
6351 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6354 handle
= DeferWindowPos (handle
,
6355 GetForegroundWindow (),
6356 FRAME_W32_WINDOW (f
),
6358 SWP_NOSIZE
| SWP_NOMOVE
|
6361 EndDeferWindowPos (handle
);
6367 my_bring_window_to_top (FRAME_W32_WINDOW (f
));
6373 /* Lower frame F. */
6375 x_lower_frame (struct frame
*f
)
6378 my_set_window_pos (FRAME_W32_WINDOW (f
),
6381 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6386 w32_frame_raise_lower (struct frame
*f
, bool raise_flag
)
6388 if (! FRAME_W32_P (f
))
6397 /* Change of visibility. */
6399 /* This tries to wait until the frame is really visible.
6400 However, if the window manager asks the user where to position
6401 the frame, this will return before the user finishes doing that.
6402 The frame will not actually be visible at that time,
6403 but it will become visible later when the window manager
6404 finishes with it. */
6407 x_make_frame_visible (struct frame
*f
)
6411 x_set_bitmap_icon (f
);
6413 if (! FRAME_VISIBLE_P (f
))
6415 /* We test FRAME_GARBAGED_P here to make sure we don't
6416 call x_set_offset a second time
6417 if we get to x_make_frame_visible a second time
6418 before the window gets really visible. */
6419 if (! FRAME_ICONIFIED_P (f
)
6420 && ! f
->output_data
.w32
->asked_for_visible
)
6425 /* Adjust vertical window position in order to avoid being
6426 covered by a taskbar placed at the bottom of the desktop. */
6427 SystemParametersInfo (SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6428 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6429 if (window_rect
.bottom
> workarea_rect
.bottom
6430 && window_rect
.top
> workarea_rect
.top
)
6431 f
->top_pos
= max (window_rect
.top
6432 - window_rect
.bottom
+ workarea_rect
.bottom
,
6435 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6438 f
->output_data
.w32
->asked_for_visible
= 1;
6440 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
6441 causes unexpected behavior when unminimizing frames that were
6442 previously maximized. But only SW_SHOWNORMAL works properly for
6443 frames that were truely hidden (using make-frame-invisible), so
6444 we need it to avoid Bug#5482. It seems that iconified is only
6445 set for minimized windows that are still visible, so use that to
6446 determine the appropriate flag to pass ShowWindow. */
6447 my_show_window (f
, FRAME_W32_WINDOW (f
),
6448 FRAME_ICONIFIED_P (f
) ? SW_RESTORE
: SW_SHOWNORMAL
);
6451 /* Synchronize to ensure Emacs knows the frame is visible
6452 before we do anything else. We do this loop with input not blocked
6453 so that incoming events are handled. */
6458 /* This must come after we set COUNT. */
6461 XSETFRAME (frame
, f
);
6463 /* Wait until the frame is visible. Process X events until a
6464 MapNotify event has been seen, or until we think we won't get a
6465 MapNotify at all.. */
6466 for (count
= input_signal_count
+ 10;
6467 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6469 /* Force processing of queued events. */
6470 /* TODO: x_sync equivalent? */
6472 /* Machines that do polling rather than SIGIO have been observed
6473 to go into a busy-wait here. So we'll fake an alarm signal
6474 to let the handler know that there's something to be read.
6475 We used to raise a real alarm, but it seems that the handler
6476 isn't always enabled here. This is probably a bug. */
6477 if (input_polling_used ())
6479 /* It could be confusing if a real alarm arrives while processing
6480 the fake one. Turn it off and let the handler reset it. */
6481 int old_poll_suppress_count
= poll_suppress_count
;
6482 poll_suppress_count
= 1;
6483 poll_for_input_1 ();
6484 poll_suppress_count
= old_poll_suppress_count
;
6490 /* Change from mapped state to withdrawn state. */
6492 /* Make the frame visible (mapped and not iconified). */
6495 x_make_frame_invisible (struct frame
*f
)
6497 /* Don't keep the highlight on an invisible frame. */
6498 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6499 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6503 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6505 /* We can't distinguish this from iconification
6506 just by the event that we get from the server.
6507 So we can't win using the usual strategy of letting
6508 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6509 and synchronize with the server to make sure we agree. */
6510 SET_FRAME_VISIBLE (f
, 0);
6511 SET_FRAME_ICONIFIED (f
, false);
6516 /* Change window state from mapped to iconified. */
6519 x_iconify_frame (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;
6525 if (FRAME_ICONIFIED_P (f
))
6530 x_set_bitmap_icon (f
);
6532 /* Simulate the user minimizing the frame. */
6533 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
6535 SET_FRAME_VISIBLE (f
, 0);
6536 SET_FRAME_ICONIFIED (f
, true);
6542 /* Free X resources of frame F. */
6545 x_free_frame_resources (struct frame
*f
)
6547 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6548 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
6552 /* We must free faces before destroying windows because some
6553 font-driver (e.g. xft) access a window while finishing a
6555 free_frame_faces (f
);
6557 if (FRAME_W32_WINDOW (f
))
6558 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6560 free_frame_menubar (f
);
6562 xfree (f
->output_data
.w32
);
6563 f
->output_data
.w32
= NULL
;
6565 if (f
== dpyinfo
->w32_focus_frame
)
6566 dpyinfo
->w32_focus_frame
= 0;
6567 if (f
== dpyinfo
->w32_focus_event_frame
)
6568 dpyinfo
->w32_focus_event_frame
= 0;
6569 if (f
== dpyinfo
->x_highlight_frame
)
6570 dpyinfo
->x_highlight_frame
= 0;
6571 if (f
== dpyinfo
->w32_tooltip_frame
)
6572 dpyinfo
->w32_tooltip_frame
= 0;
6573 if (f
== hlinfo
->mouse_face_mouse_frame
)
6574 reset_mouse_highlight (hlinfo
);
6580 /* Destroy the window of frame F. */
6582 x_destroy_window (struct frame
*f
)
6584 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6586 x_free_frame_resources (f
);
6587 dpyinfo
->reference_count
--;
6591 /* Setting window manager hints. */
6593 /* Set the normal size hints for the window manager, for frame F.
6594 FLAGS is the flags word to use--or 0 meaning preserve the flags
6595 that the window now has.
6596 If USER_POSITION, set the USPosition
6597 flag (this is useful when FLAGS is 0). */
6599 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
6601 Window window
= FRAME_W32_WINDOW (f
);
6605 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6606 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6607 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6608 SetWindowLong (window
, WND_VSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_WIDTH (f
));
6609 SetWindowLong (window
, WND_HSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_HEIGHT (f
));
6614 /***********************************************************************
6616 ***********************************************************************/
6620 /* Check that FONT is valid on frame F. It is if it can be found in F's
6624 x_check_font (struct frame
*f
, struct font
*font
)
6626 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
6627 if (font
->driver
->check
)
6628 eassert (font
->driver
->check (f
, font
) == 0);
6631 #endif /* GLYPH_DEBUG */
6633 /* Show hourglass cursor on frame F. */
6636 w32_show_hourglass (struct frame
*f
)
6638 if (!menubar_in_use
&& !current_popup_menu
)
6640 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6642 w32
->hourglass_p
= 1;
6643 SetCursor (w32
->hourglass_cursor
);
6647 /* Hide hourglass cursor on frame F. */
6650 w32_hide_hourglass (struct frame
*f
)
6652 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6654 w32
->hourglass_p
= 0;
6655 if (f
->pointer_invisible
)
6658 SetCursor (w32
->current_cursor
);
6661 /* FIXME: old code did that, but I don't know why. Anyway,
6662 this is used for non-GUI frames (see cancel_hourglass). */
6665 w32_arrow_cursor (void)
6667 SetCursor (w32_load_cursor (IDC_ARROW
));
6671 w32_toggle_invisible_pointer (struct frame
*f
, bool invisible
)
6675 if (f
->pointer_invisible
!= invisible
)
6677 f
->pointer_invisible
= invisible
;
6678 w32_define_cursor (FRAME_W32_WINDOW (f
),
6679 f
->output_data
.w32
->current_cursor
);
6685 /***********************************************************************
6687 ***********************************************************************/
6689 static int w32_initialized
= 0;
6692 w32_initialize_display_info (Lisp_Object display_name
)
6694 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6696 memset (dpyinfo
, 0, sizeof (*dpyinfo
));
6698 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
6699 dpyinfo
->w32_id_name
= xmalloc (SCHARS (Vinvocation_name
)
6700 + SCHARS (Vsystem_name
) + 2);
6701 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6702 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6704 /* Default Console mode values - overridden when running in GUI mode
6705 with values obtained from system metrics. */
6708 dpyinfo
->n_planes
= 1;
6709 dpyinfo
->n_cbits
= 4;
6710 dpyinfo
->n_fonts
= 0;
6711 dpyinfo
->smallest_font_height
= 1;
6712 dpyinfo
->smallest_char_width
= 1;
6713 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6714 dpyinfo
->horizontal_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6715 /* TODO: dpyinfo->gray */
6717 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
6720 /* Create an xrdb-style database of resources to supersede registry settings.
6721 The database is just a concatenation of C strings, finished by an additional
6722 \0. The strings are submitted to some basic normalization, so
6724 [ *]option[ *]:[ *]value...
6730 but any whitespace following value is not removed. */
6733 w32_make_rdb (char *xrm_option
)
6735 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6736 char *current
= buffer
;
6739 int before_value
= 0;
6753 if (in_option
&& (ch
== ':'))
6758 else if (before_value
)
6763 else if (!(in_option
|| before_value
))
6774 extern frame_parm_handler w32_frame_parm_handlers
[];
6776 static struct redisplay_interface w32_redisplay_interface
=
6778 w32_frame_parm_handlers
,
6782 x_clear_end_of_line
,
6784 x_after_update_window_line
,
6785 x_update_window_begin
,
6786 x_update_window_end
,
6787 0, /* flush_display */
6788 x_clear_window_mouse_face
,
6789 x_get_glyph_overhangs
,
6790 x_fix_overlapping_area
,
6791 w32_draw_fringe_bitmap
,
6792 w32_define_fringe_bitmap
,
6793 w32_destroy_fringe_bitmap
,
6794 w32_compute_glyph_string_overhangs
,
6795 x_draw_glyph_string
,
6796 w32_define_frame_cursor
,
6797 w32_clear_frame_area
,
6798 w32_draw_window_cursor
,
6799 w32_draw_vertical_window_border
,
6800 w32_draw_window_divider
,
6801 w32_shift_glyphs_for_insert
,
6806 static void x_delete_terminal (struct terminal
*term
);
6808 static struct terminal
*
6809 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6811 struct terminal
*terminal
;
6813 terminal
= create_terminal (output_w32
, &w32_redisplay_interface
);
6815 terminal
->display_info
.w32
= dpyinfo
;
6816 dpyinfo
->terminal
= terminal
;
6818 /* MSVC does not type K&R functions with no arguments correctly, and
6819 so we must explicitly cast them. */
6820 terminal
->clear_frame_hook
= x_clear_frame
;
6821 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6822 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6823 terminal
->ring_bell_hook
= w32_ring_bell
;
6824 terminal
->toggle_invisible_pointer_hook
= w32_toggle_invisible_pointer
;
6825 terminal
->update_begin_hook
= x_update_begin
;
6826 terminal
->update_end_hook
= x_update_end
;
6827 terminal
->read_socket_hook
= w32_read_socket
;
6828 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6829 terminal
->mouse_position_hook
= w32_mouse_position
;
6830 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6831 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6832 terminal
->fullscreen_hook
= w32fullscreen_hook
;
6833 terminal
->menu_show_hook
= w32_menu_show
;
6834 terminal
->popup_dialog_hook
= w32_popup_dialog
;
6835 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6836 terminal
->set_horizontal_scroll_bar_hook
= w32_set_horizontal_scroll_bar
;
6837 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6838 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6839 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6840 terminal
->delete_frame_hook
= x_destroy_window
;
6841 terminal
->delete_terminal_hook
= x_delete_terminal
;
6842 /* Other hooks are NULL by default. */
6844 /* We don't yet support separate terminals on W32, so don't try to share
6845 keyboards between virtual terminals that are on the same physical
6846 terminal like X does. */
6847 terminal
->kboard
= allocate_kboard (Qw32
);
6848 /* Don't let the initial kboard remain current longer than necessary.
6849 That would cause problems if a file loaded on startup tries to
6850 prompt in the mini-buffer. */
6851 if (current_kboard
== initial_kboard
)
6852 current_kboard
= terminal
->kboard
;
6853 terminal
->kboard
->reference_count
++;
6859 x_delete_terminal (struct terminal
*terminal
)
6861 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
6863 /* Protect against recursive calls. delete_frame in
6864 delete_terminal calls us back when it deletes our last frame. */
6865 if (!terminal
->name
)
6870 x_delete_display (dpyinfo
);
6874 struct w32_display_info
*
6875 w32_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
6877 struct w32_display_info
*dpyinfo
;
6878 struct terminal
*terminal
;
6883 if (!w32_initialized
)
6886 w32_initialized
= 1;
6889 w32_initialize_display_info (display_name
);
6891 dpyinfo
= &one_w32_display_info
;
6892 terminal
= w32_create_terminal (dpyinfo
);
6894 /* Set the name of the terminal. */
6895 terminal
->name
= xlispstrdup (display_name
);
6897 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6899 /* Put this display on the chain. */
6900 dpyinfo
->next
= x_display_list
;
6901 x_display_list
= dpyinfo
;
6905 dpyinfo
->root_window
= GetDesktopWindow ();
6906 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6907 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6908 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6909 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6910 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6911 ReleaseDC (NULL
, hdc
);
6913 /* initialize palette with white and black */
6916 w32_defined_color (0, "white", &color
, 1);
6917 w32_defined_color (0, "black", &color
, 1);
6921 /* Add the default keyboard. When !WINDOWSNT, we're using the
6922 standard Emacs console handling machinery and don't need an
6923 explicit FD here. */
6924 add_keyboard_wait_descriptor (0);
6926 /* /dev/windows wakes us up when we have a thread message pending. */
6927 add_keyboard_wait_descriptor (w32_message_fd
);
6930 /* Create Fringe Bitmaps and store them for later use.
6932 On W32, bitmaps are all unsigned short, as Windows requires
6933 bitmap data to be Word aligned. For some reason they are
6934 horizontally reflected compared to how they appear on X, so we
6935 need to bitswap and convert to unsigned shorts before creating
6937 w32_init_fringe (terminal
->rif
);
6944 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6946 x_delete_display (struct w32_display_info
*dpyinfo
)
6948 /* FIXME: the only display info apparently can't be deleted. */
6949 /* free palette table */
6951 struct w32_palette_entry
* plist
;
6953 plist
= dpyinfo
->color_list
;
6956 struct w32_palette_entry
* pentry
= plist
;
6957 plist
= plist
->next
;
6960 dpyinfo
->color_list
= NULL
;
6961 if (dpyinfo
->palette
)
6962 DeleteObject (dpyinfo
->palette
);
6964 w32_reset_fringes ();
6968 /* Set up use of W32. */
6971 w32_init_main_thread (void)
6973 dwMainThreadId
= GetCurrentThreadId ();
6974 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6975 GetCurrentProcess (), &hMainThread
, 0, TRUE
,
6976 DUPLICATE_SAME_ACCESS
);
6981 DWORD WINAPI
w32_msg_worker (void * arg
);
6984 w32_initialize (void)
6987 HRESULT (WINAPI
* set_user_model
) (const wchar_t * id
);
6991 w32_system_caret_hwnd
= NULL
;
6992 w32_system_caret_height
= 0;
6993 w32_system_caret_x
= 0;
6994 w32_system_caret_y
= 0;
6996 /* On Windows 7 and later, we need to set the user model ID
6997 to associate emacsclient launched files with Emacs frames
6999 shell
= GetModuleHandle ("shell32.dll");
7003 = (void *) GetProcAddress (shell
,
7004 "SetCurrentProcessExplicitAppUserModelID");
7006 /* If the function is defined, then we are running on Windows 7
7007 or newer, and the UI uses this to group related windows
7008 together. Since emacs, runemacs, emacsclient are related, we
7009 want them grouped even though the executables are different,
7010 so we need to set a consistent ID between them. */
7012 set_user_model (L
"GNU.Emacs");
7016 if ((w32_message_fd
= emacs_open ("/dev/windows", O_RDWR
, 0)) == -1)
7017 fatal ("opening /dev/windows: %s", strerror (errno
));
7020 /* Initialize w32_use_visible_system_caret based on whether a screen
7021 reader is in use. */
7022 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
7023 &w32_use_visible_system_caret
, 0))
7024 w32_use_visible_system_caret
= 0;
7026 any_help_event_p
= 0;
7028 /* Initialize input mode: interrupt_input off, no flow control, allow
7029 8 bit character input, standard quit char. */
7030 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
7033 LCID input_locale_id
= LOWORD (GetKeyboardLayout (0));
7034 w32_keyboard_codepage
= codepage_for_locale (input_locale_id
);
7037 /* Create the window thread - it will terminate itself when the app
7041 /* Wait for thread to start */
7045 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
7047 hWindowsThread
= CreateThread (NULL
, 0,
7049 0, 0, &dwWindowsThreadId
);
7051 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
7054 /* It is desirable that mainThread should have the same notion of
7055 focus window and active window as windowsThread. Unfortunately, the
7056 following call to AttachThreadInput, which should do precisely what
7057 we need, causes major problems when Emacs is linked as a console
7058 program. Unfortunately, we have good reasons for doing that, so
7059 instead we need to send messages to windowsThread to make some API
7060 calls for us (ones that affect, or depend on, the active/focus
7062 #ifdef ATTACH_THREADS
7063 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
7066 /* Dynamically link to optional system components. */
7068 HMODULE user_lib
= GetModuleHandle ("user32.dll");
7070 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7072 LOAD_PROC (user_lib
, SetLayeredWindowAttributes
);
7076 /* Ensure scrollbar handles are at least 5 pixels. */
7077 vertical_scroll_bar_min_handle
= 5;
7078 horizontal_scroll_bar_min_handle
= 5;
7080 /* For either kind of scroll bar, take account of the arrows; these
7081 effectively form the border of the main scroll bar range. */
7082 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
7083 = GetSystemMetrics (SM_CYVSCROLL
);
7084 horizontal_scroll_bar_left_border
= horizontal_scroll_bar_right_border
7085 = GetSystemMetrics (SM_CYHSCROLL
);
7090 syms_of_w32term (void)
7092 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
7094 DEFSYM (Qadded
, "added");
7095 DEFSYM (Qremoved
, "removed");
7096 DEFSYM (Qmodified
, "modified");
7097 DEFSYM (Qrenamed_from
, "renamed-from");
7098 DEFSYM (Qrenamed_to
, "renamed-to");
7100 DEFVAR_INT ("w32-num-mouse-buttons",
7101 w32_num_mouse_buttons
,
7102 doc
: /* Number of physical mouse buttons. */);
7103 w32_num_mouse_buttons
= 2;
7105 DEFVAR_LISP ("w32-swap-mouse-buttons",
7106 Vw32_swap_mouse_buttons
,
7107 doc
: /* Swap the mapping of middle and right mouse buttons.
7108 When nil, middle button is mouse-2 and right button is mouse-3. */);
7109 Vw32_swap_mouse_buttons
= Qnil
;
7111 DEFVAR_LISP ("w32-grab-focus-on-raise",
7112 Vw32_grab_focus_on_raise
,
7113 doc
: /* Raised frame grabs input focus.
7114 When t, `raise-frame' grabs input focus as well. This fits well
7115 with the normal Windows click-to-focus policy, but might not be
7116 desirable when using a point-to-focus policy. */);
7117 Vw32_grab_focus_on_raise
= Qt
;
7119 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7120 Vw32_capslock_is_shiftlock
,
7121 doc
: /* Apply CapsLock state to non character input keys.
7122 When nil, CapsLock only affects normal character input keys. */);
7123 Vw32_capslock_is_shiftlock
= Qnil
;
7125 DEFVAR_LISP ("w32-recognize-altgr",
7126 Vw32_recognize_altgr
,
7127 doc
: /* Recognize right-alt and left-ctrl as AltGr.
7128 When nil, the right-alt and left-ctrl key combination is
7129 interpreted normally. */);
7130 Vw32_recognize_altgr
= Qt
;
7132 DEFVAR_BOOL ("w32-use-visible-system-caret",
7133 w32_use_visible_system_caret
,
7134 doc
: /* Flag to make the system caret visible.
7135 When this is non-nil, Emacs will indicate the position of point by
7136 using the system caret instead of drawing its own cursor. Some screen
7137 reader software does not track the system cursor properly when it is
7138 invisible, and gets confused by Emacs drawing its own cursor, so this
7139 variable is initialized to t when Emacs detects that screen reader
7140 software is running as it starts up.
7142 When this variable is set, other variables affecting the appearance of
7143 the cursor have no effect. */);
7145 w32_use_visible_system_caret
= 0;
7147 /* We don't yet support this, but defining this here avoids whining
7148 from cus-start.el and other places, like "M-x set-variable". */
7149 DEFVAR_BOOL ("x-use-underline-position-properties",
7150 x_use_underline_position_properties
,
7151 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
7152 A value of nil means ignore them. If you encounter fonts with bogus
7153 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7154 to 4.1, set this to nil. You can also use `underline-minimum-offset'
7155 to override the font's UNDERLINE_POSITION for small font display
7157 x_use_underline_position_properties
= 0;
7159 DEFVAR_BOOL ("x-underline-at-descent-line",
7160 x_underline_at_descent_line
,
7161 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
7162 A value of nil means to draw the underline according to the value of the
7163 variable `x-use-underline-position-properties', which is usually at the
7164 baseline level. The default value is nil. */);
7165 x_underline_at_descent_line
= 0;
7167 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
7168 doc
: /* Which toolkit scroll bars Emacs uses, if any.
7169 A value of nil means Emacs doesn't use toolkit scroll bars.
7170 With the X Window system, the value is a symbol describing the
7171 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
7172 With MS Windows or Nextstep, the value is t. */);
7173 Vx_toolkit_scroll_bars
= Qt
;
7175 DEFVAR_BOOL ("w32-unicode-filenames",
7176 w32_unicode_filenames
,
7177 doc
: /* Non-nil means use Unicode APIs when passing file names to the OS.
7178 A value of nil means file names passed to the OS APIs and returned
7179 from those APIs are encoded/decoded using the ANSI codepage
7180 specified by `file-name-coding-system'.
7182 This variable is set to non-nil by default when Emacs runs on Windows
7183 systems of the NT family, including W2K, XP, Vista, Windows 7 and
7184 Windows 8. It is set to nil on Windows 9X. */);
7185 w32_unicode_filenames
= 0;
7188 /* FIXME: The following variable will be (hopefully) removed
7189 before Emacs 25.1 gets released. */
7191 DEFVAR_BOOL ("w32-add-wrapped-menu-bar-lines",
7192 w32_add_wrapped_menu_bar_lines
,
7193 doc
: /* Non-nil means frame resizing accounts for wrapped menu bar lines.
7194 A value of nil means frame resizing does not add the height of wrapped
7195 menu bar lines when sending a frame resize request to the Windows API.
7196 This usually means that the resulting frame height is off by the number
7197 of wrapped menu bar lines. If this is non-nil, Emacs adds the height of
7198 wrapped menu bar lines when sending frame resize requests to the Windows
7200 w32_add_wrapped_menu_bar_lines
= 1;
7202 /* Tell Emacs about this window system. */
7203 Fprovide (Qw32
, Qnil
);