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 void free_frame_menubar (struct frame
*);
88 extern int w32_codepage_for_font (char *fontname
);
89 extern Cursor
w32_load_cursor (LPCTSTR name
);
91 #define x_any_window_to_frame x_window_to_frame
92 #define x_top_window_to_frame x_window_to_frame
95 /* This is display since w32 does not support multiple ones. */
96 struct w32_display_info one_w32_display_info
;
97 struct w32_display_info
*x_display_list
;
99 #if _WIN32_WINNT < 0x0500 && !defined(MINGW_W64)
100 /* Pre Windows 2000, this was not available, but define it here so
101 that Emacs compiled on such a platform will run on newer versions.
102 MinGW64 defines these unconditionally, so avoid redefining. */
104 typedef struct tagWCRANGE
110 typedef struct tagGLYPHSET
114 DWORD cGlyphsSupported
;
119 #endif /* compiling for pre-Win2k */
121 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
122 BOOL (WINAPI
*pfnSetLayeredWindowAttributes
) (HWND
, COLORREF
, BYTE
, DWORD
);
125 #define LWA_ALPHA 0x02
127 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
128 later targets by MSVC headers. */
129 #ifndef WS_EX_LAYERED
130 #define WS_EX_LAYERED 0x80000
133 /* SM_CXVIRTUALSCREEN and SM_CYVIRTUALSCREEN are not defined on 95 and
135 #ifndef SM_CXVIRTUALSCREEN
136 #define SM_CXVIRTUALSCREEN 78
138 #ifndef SM_CYVIRTUALSCREEN
139 #define SM_CYVIRTUALSCREEN 79
142 /* The handle of the frame that currently owns the system caret. */
143 HWND w32_system_caret_hwnd
;
144 int w32_system_caret_height
;
145 int w32_system_caret_x
;
146 int w32_system_caret_y
;
147 struct window
*w32_system_caret_window
;
148 int w32_system_caret_hdr_height
;
149 int w32_system_caret_mode_height
;
150 DWORD dwWindowsThreadId
= 0;
151 HANDLE hWindowsThread
= NULL
;
152 DWORD dwMainThreadId
= 0;
153 HANDLE hMainThread
= NULL
;
155 int vertical_scroll_bar_min_handle
;
156 int horizontal_scroll_bar_min_handle
;
157 int vertical_scroll_bar_top_border
;
158 int vertical_scroll_bar_bottom_border
;
159 int horizontal_scroll_bar_left_border
;
160 int horizontal_scroll_bar_right_border
;
162 int last_scroll_bar_drag_pos
;
164 /* Keyboard code page - may be changed by language-change events. */
165 int w32_keyboard_codepage
;
167 /* Incremented by w32_read_socket whenever it really tries to read
169 static int volatile input_signal_count
;
172 int w32_message_fd
= -1;
175 static void w32_handle_tool_bar_click (struct frame
*,
176 struct input_event
*);
177 static void w32_define_cursor (Window
, Cursor
);
179 void x_lower_frame (struct frame
*);
180 void x_scroll_bar_clear (struct frame
*);
181 void x_wm_set_size_hint (struct frame
*, long, bool);
182 void x_raise_frame (struct frame
*);
183 void x_set_window_size (struct frame
*, bool, int, int, bool);
184 void x_wm_set_window_state (struct frame
*, int);
185 void x_wm_set_icon_pixmap (struct frame
*, int);
186 static void w32_initialize (void);
187 static void x_update_end (struct frame
*);
188 static void w32_frame_up_to_date (struct frame
*);
189 static void x_clear_frame (struct frame
*);
190 static void frame_highlight (struct frame
*);
191 static void frame_unhighlight (struct frame
*);
192 static void x_new_focus_frame (struct w32_display_info
*,
194 static void x_focus_changed (int, int, struct w32_display_info
*,
195 struct frame
*, struct input_event
*);
196 static void w32_detect_focus_change (struct w32_display_info
*,
197 W32Msg
*, struct input_event
*);
198 static void w32_frame_rehighlight (struct frame
*);
199 static void x_frame_rehighlight (struct w32_display_info
*);
200 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
201 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
202 enum text_cursor_kinds
);
203 static void w32_clip_to_row (struct window
*, struct glyph_row
*,
204 enum glyph_row_area
, HDC
);
205 static BOOL
my_show_window (struct frame
*, HWND
, int);
206 static void my_set_window_pos (HWND
, HWND
, int, int, int, int, UINT
);
208 static void my_set_focus (struct frame
*, HWND
);
210 static void my_set_foreground_window (HWND
);
211 static void my_destroy_window (struct frame
*, HWND
);
212 static void w32fullscreen_hook (struct frame
*);
215 static void x_check_font (struct frame
*, struct font
*);
219 /***********************************************************************
221 ***********************************************************************/
225 /* This is a function useful for recording debugging information about
226 the sequence of occurrences in this file. */
234 struct record event_record
[100];
236 int event_record_index
;
238 record_event (char *locus
, int type
)
240 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
241 event_record_index
= 0;
243 event_record
[event_record_index
].locus
= locus
;
244 event_record
[event_record_index
].type
= type
;
245 event_record_index
++;
252 XChangeGC (void *ignore
, XGCValues
*gc
, unsigned long mask
,
255 if (mask
& GCForeground
)
256 gc
->foreground
= xgcv
->foreground
;
257 if (mask
& GCBackground
)
258 gc
->background
= xgcv
->background
;
260 gc
->font
= xgcv
->font
;
264 XCreateGC (void *ignore
, Window window
, unsigned long mask
, XGCValues
*xgcv
)
266 XGCValues
*gc
= xzalloc (sizeof (XGCValues
));
268 XChangeGC (ignore
, gc
, mask
, xgcv
);
274 XGetGCValues (void *ignore
, XGCValues
*gc
,
275 unsigned long mask
, XGCValues
*xgcv
)
277 XChangeGC (ignore
, xgcv
, mask
, gc
);
281 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
285 HRGN clip_region
= CreateRectRgnIndirect (rect
);
286 SelectClipRgn (hdc
, clip_region
);
287 DeleteObject (clip_region
);
290 SelectClipRgn (hdc
, NULL
);
293 /* Restore clipping rectangle in S */
295 w32_restore_glyph_string_clip (struct glyph_string
*s
)
298 int n
= s
->num_clips
;
301 w32_set_clip_rectangle (s
->hdc
, r
);
304 HRGN clip1
= CreateRectRgnIndirect (r
);
305 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
306 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
307 SelectClipRgn (s
->hdc
, clip1
);
308 DeleteObject (clip1
);
309 DeleteObject (clip2
);
314 Draw a wavy line under S. The wave fills wave_height pixels from y0.
320 wave_height = 3 | * * * *
325 w32_draw_underwave (struct glyph_string
*s
, COLORREF color
)
327 int wave_height
= 3, wave_length
= 2;
328 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, odd
, xmax
;
329 XRectangle wave_clip
, string_clip
, final_clip
;
330 RECT w32_final_clip
, w32_string_clip
;
334 dy
= wave_height
- 1;
336 y0
= s
->ybase
- wave_height
+ 3;
340 /* Find and set clipping rectangle */
344 wave_clip
.width
= width
;
345 wave_clip
.height
= wave_height
;
347 get_glyph_string_clip_rect (s
, &w32_string_clip
);
348 CONVERT_TO_XRECT (string_clip
, w32_string_clip
);
350 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
353 hp
= CreatePen (PS_SOLID
, 0, color
);
354 oldhp
= SelectObject (s
->hdc
, hp
);
355 CONVERT_FROM_XRECT (final_clip
, w32_final_clip
);
356 w32_set_clip_rectangle (s
->hdc
, &w32_final_clip
);
370 MoveToEx (s
->hdc
, x1
, y1
, NULL
);
374 LineTo (s
->hdc
, x2
, y2
);
376 x2
+= dx
, y2
= y0
+ odd
*dy
;
380 /* Restore previous pen and clipping rectangle(s) */
381 w32_restore_glyph_string_clip (s
);
382 SelectObject (s
->hdc
, oldhp
);
386 /* Draw a hollow rectangle at the specified position. */
388 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
389 int width
, int height
)
394 hb
= CreateSolidBrush (gc
->background
);
395 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
396 oldhb
= SelectObject (hdc
, hb
);
397 oldhp
= SelectObject (hdc
, hp
);
399 /* We enlarge WIDTH and HEIGHT by 1 to be bug-compatible to the
400 brain-dead design of XDrawRectangle, which draws a rectangle that
401 is 1 pixel wider and higher than its arguments WIDTH and HEIGHT.
402 This allows us to keep the code that calls this function similar
403 to the corresponding code in xterm.c. For the details, see
404 http://lists.gnu.org/archives/html/emacs-devel/2014-10/msg00546.html. */
405 Rectangle (hdc
, x
, y
, x
+ width
+ 1, y
+ height
+ 1);
407 SelectObject (hdc
, oldhb
);
408 SelectObject (hdc
, oldhp
);
413 /* Draw a filled rectangle at the specified position. */
415 w32_fill_rect (struct frame
*f
, HDC hdc
, COLORREF pix
, RECT
*lprect
)
419 hb
= CreateSolidBrush (pix
);
420 FillRect (hdc
, lprect
, hb
);
425 w32_clear_window (struct frame
*f
)
428 HDC hdc
= get_frame_dc (f
);
430 /* Under certain conditions, this can be called at startup with
431 a console frame pointer before the GUI frame is created. An HDC
432 of 0 indicates this. */
435 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
436 w32_clear_rect (f
, hdc
, &rect
);
439 release_frame_dc (f
, hdc
);
442 #define OPAQUE_FRAME 255
445 x_set_frame_alpha (struct frame
*f
)
447 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
449 double alpha_min
= 1.0;
452 HWND window
= FRAME_W32_WINDOW (f
);
454 /* Older versions of Windows do not support transparency. */
455 if (!pfnSetLayeredWindowAttributes
)
458 if (dpyinfo
->w32_focus_frame
== f
)
463 if (FLOATP (Vframe_alpha_lower_limit
))
464 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
465 else if (INTEGERP (Vframe_alpha_lower_limit
))
466 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
470 else if (alpha
> 1.0)
472 else if (alpha
< alpha_min
&& alpha_min
<= 1.0)
475 opac
= alpha
* OPAQUE_FRAME
;
477 ex_style
= GetWindowLong (window
, GWL_EXSTYLE
);
479 if (opac
== OPAQUE_FRAME
)
480 ex_style
&= ~WS_EX_LAYERED
;
482 ex_style
|= WS_EX_LAYERED
;
484 SetWindowLong (window
, GWL_EXSTYLE
, ex_style
);
486 if (opac
!= OPAQUE_FRAME
)
487 pfnSetLayeredWindowAttributes (window
, 0, opac
, LWA_ALPHA
);
491 x_display_pixel_height (struct w32_display_info
*dpyinfo
)
493 int pixels
= GetSystemMetrics (SM_CYVIRTUALSCREEN
);
496 /* Fallback for Windows 95 or NT 4.0. */
497 pixels
= GetSystemMetrics (SM_CYSCREEN
);
503 x_display_pixel_width (struct w32_display_info
*dpyinfo
)
505 int pixels
= GetSystemMetrics (SM_CXVIRTUALSCREEN
);
508 /* Fallback for Windows 95 or NT 4.0. */
509 pixels
= GetSystemMetrics (SM_CXSCREEN
);
515 /***********************************************************************
516 Starting and ending an update
517 ***********************************************************************/
519 /* Start an update of frame F. This function is installed as a hook
520 for update_begin, i.e. it is called when update_begin is called.
521 This function is called prior to calls to x_update_window_begin for
522 each window being updated. */
525 x_update_begin (struct frame
*f
)
527 struct w32_display_info
*display_info
= FRAME_DISPLAY_INFO (f
);
529 if (! FRAME_W32_P (f
))
532 /* Regenerate display palette before drawing if list of requested
533 colors has changed. */
534 if (display_info
->regen_palette
)
536 w32_regenerate_palette (f
);
537 display_info
->regen_palette
= FALSE
;
542 /* Start update of window W. */
545 x_update_window_begin (struct window
*w
)
547 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
548 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
550 /* Hide the system caret during an update. */
551 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
553 SendMessage (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0);
556 w
->output_cursor
= w
->cursor
;
560 if (f
== hlinfo
->mouse_face_mouse_frame
)
562 /* Don't do highlighting for mouse motion during the update. */
563 hlinfo
->mouse_face_defer
= true;
565 /* If F needs to be redrawn, simply forget about any prior mouse
567 if (FRAME_GARBAGED_P (f
))
568 hlinfo
->mouse_face_window
= Qnil
;
570 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
571 their mouse_face_p flag set, which means that they are always
572 unequal to rows in a desired matrix which never have that
573 flag set. So, rows containing mouse-face glyphs are never
574 scrolled, and we don't have to switch the mouse highlight off
575 here to prevent it from being scrolled. */
577 /* Can we tell that this update does not affect the window
578 where the mouse highlight is? If so, no need to turn off.
579 Likewise, don't do anything if the frame is garbaged;
580 in that case, the frame's current matrix that we would use
581 is all wrong, and we will redisplay that line anyway. */
582 if (!NILP (hlinfo
->mouse_face_window
)
583 && w
== XWINDOW (hlinfo
->mouse_face_window
))
587 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
588 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
591 if (i
< w
->desired_matrix
->nrows
)
592 clear_mouse_face (hlinfo
);
600 /* Draw a vertical window border from (x,y0) to (x,y1) */
603 w32_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
605 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
615 hdc
= get_frame_dc (f
);
616 face
= FACE_OPT_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
618 w32_fill_rect (f
, hdc
, face
->foreground
, &r
);
620 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
622 release_frame_dc (f
, hdc
);
626 /* Draw a window divider from (x0, y0) to (x1, y1) */
629 w32_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
631 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
632 HDC hdc
= get_frame_dc (f
);
633 struct face
*face
= FACE_OPT_FROM_ID (f
, WINDOW_DIVIDER_FACE_ID
);
634 struct face
*face_first
635 = FACE_OPT_FROM_ID (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
636 struct face
*face_last
637 = FACE_OPT_FROM_ID (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
638 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
639 unsigned long color_first
= (face_first
640 ? face_first
->foreground
641 : FRAME_FOREGROUND_PIXEL (f
));
642 unsigned long color_last
= (face_last
643 ? face_last
->foreground
644 : FRAME_FOREGROUND_PIXEL (f
));
646 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
649 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x0
+ 1, y1
);
650 w32_fill_area_abs (f
, hdc
, color
, x0
+ 1, y0
, x1
- 1, y1
);
651 w32_fill_area_abs (f
, hdc
, color_last
, x1
- 1, y0
, x1
, y1
);
653 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
656 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x1
, y0
+ 1);
657 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
+ 1, x1
, y1
- 1);
658 w32_fill_area_abs (f
, hdc
, color_last
, x0
, y1
- 1, x1
, y1
);
661 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
, x1
, y1
);
663 release_frame_dc (f
, hdc
);
666 /* End update of window W.
668 Draw vertical borders between horizontally adjacent windows, and
669 display W's cursor if CURSOR_ON_P is non-zero.
671 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
672 glyphs in mouse-face were overwritten. In that case we have to
673 make sure that the mouse-highlight is properly redrawn.
675 W may be a menu bar pseudo-window in case we don't have X toolkit
676 support. Such windows don't have a cursor, so don't display it
680 x_update_window_end (struct window
*w
, bool cursor_on_p
,
681 bool mouse_face_overwritten_p
)
683 if (!w
->pseudo_window_p
)
688 display_and_set_cursor (w
, true,
689 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
690 w
->output_cursor
.x
, w
->output_cursor
.y
);
692 if (draw_window_fringes (w
, true))
694 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
695 x_draw_right_divider (w
);
697 x_draw_vertical_border (w
);
703 /* If a row with mouse-face was overwritten, arrange for
704 XTframe_up_to_date to redisplay the mouse highlight. */
705 if (mouse_face_overwritten_p
)
707 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
709 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
710 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
711 hlinfo
->mouse_face_window
= Qnil
;
714 /* Unhide the caret. This won't actually show the cursor, unless it
715 was visible before the corresponding call to HideCaret in
716 x_update_window_begin. */
717 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
719 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
724 /* End update of frame F. This function is installed as a hook in
728 x_update_end (struct frame
*f
)
730 if (! FRAME_W32_P (f
))
733 /* Mouse highlight may be displayed again. */
734 MOUSE_HL_INFO (f
)->mouse_face_defer
= false;
738 /* This function is called from various places in xdisp.c
739 whenever a complete update has been performed. */
742 w32_frame_up_to_date (struct frame
*f
)
745 FRAME_MOUSE_UPDATE (f
);
749 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
750 arrow bitmaps, or clear the fringes if no bitmaps are required
751 before DESIRED_ROW is made current. This function is called from
752 update_window_line only if it is known that there are differences
753 between bitmaps to be drawn between current row and DESIRED_ROW. */
756 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
763 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
764 desired_row
->redraw_fringe_bitmaps_p
= true;
766 /* When a window has disappeared, make sure that no rest of
767 full-width rows stays visible in the internal border. Could
768 check here if updated window is the leftmost/rightmost window,
769 but I guess it's not worth doing since vertically split windows
770 are almost never used, internal border is rarely set, and the
771 overhead is very small. */
772 if (windows_or_buffers_changed
773 && desired_row
->full_width_p
774 && (f
= XFRAME (w
->frame
),
775 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
777 && (height
= desired_row
->visible_height
,
780 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
784 HDC hdc
= get_frame_dc (f
);
785 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
786 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
788 release_frame_dc (f
, hdc
);
795 /* Draw the bitmap WHICH in one of the left or right fringes of
796 window W. ROW is the glyph row for which to display the bitmap; it
797 determines the vertical position at which the bitmap has to be
801 w32_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
,
802 struct draw_fringe_bitmap_params
*p
)
804 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
806 struct face
*face
= p
->face
;
808 hdc
= get_frame_dc (f
);
810 /* Must clip because of partially visible lines. */
811 w32_clip_to_row (w
, row
, ANY_AREA
, hdc
);
813 if (p
->bx
>= 0 && !p
->overlay_p
)
814 w32_fill_area (f
, hdc
, face
->background
,
815 p
->bx
, p
->by
, p
->nx
, p
->ny
);
817 if (p
->which
&& p
->which
< max_fringe_bmp
)
819 HBITMAP pixmap
= fringe_bmp
[p
->which
];
823 compat_hdc
= CreateCompatibleDC (hdc
);
827 horig_obj
= SelectObject (compat_hdc
, pixmap
);
829 /* Paint overlays transparently. */
832 HBRUSH h_brush
, h_orig_brush
;
834 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
835 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
836 h_brush
= CreateSolidBrush (face
->foreground
);
837 h_orig_brush
= SelectObject (hdc
, h_brush
);
839 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
840 compat_hdc
, 0, p
->dh
,
842 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
843 compat_hdc
, 0, p
->dh
,
845 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
846 compat_hdc
, 0, p
->dh
,
849 SelectObject (hdc
, h_orig_brush
);
850 DeleteObject (h_brush
);
854 SetTextColor (hdc
, face
->background
);
855 SetBkColor (hdc
, (p
->cursor_p
856 ? f
->output_data
.w32
->cursor_pixel
857 : face
->foreground
));
859 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
860 compat_hdc
, 0, p
->dh
,
864 SelectObject (compat_hdc
, horig_obj
);
865 DeleteDC (compat_hdc
);
869 w32_set_clip_rectangle (hdc
, NULL
);
871 release_frame_dc (f
, hdc
);
875 w32_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
877 if (which
>= max_fringe_bmp
)
879 int i
= max_fringe_bmp
;
880 max_fringe_bmp
= which
+ 20;
881 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
882 while (i
< max_fringe_bmp
)
886 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
890 w32_destroy_fringe_bitmap (int which
)
892 if (which
>= max_fringe_bmp
)
895 if (fringe_bmp
[which
])
896 DeleteObject (fringe_bmp
[which
]);
897 fringe_bmp
[which
] = 0;
900 /***********************************************************************
902 ***********************************************************************/
904 /* Function prototypes of this page. */
906 static void x_set_glyph_string_clipping (struct glyph_string
*);
907 static void x_set_glyph_string_gc (struct glyph_string
*);
908 static void x_draw_glyph_string_background (struct glyph_string
*,
910 static void x_draw_glyph_string_foreground (struct glyph_string
*);
911 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
912 static void x_draw_glyph_string_box (struct glyph_string
*);
913 static void x_draw_glyph_string (struct glyph_string
*);
914 static void x_set_cursor_gc (struct glyph_string
*);
915 static void x_set_mode_line_face_gc (struct glyph_string
*);
916 static void x_set_mouse_face_gc (struct glyph_string
*);
917 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
918 static void w32_setup_relief_color (struct frame
*, struct relief
*,
919 double, int, COLORREF
);
920 static void x_setup_relief_colors (struct glyph_string
*);
921 static void x_draw_image_glyph_string (struct glyph_string
*);
922 static void x_draw_image_relief (struct glyph_string
*);
923 static void x_draw_image_foreground (struct glyph_string
*);
924 static void w32_draw_image_foreground_1 (struct glyph_string
*, HBITMAP
);
925 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
927 static void w32_draw_relief_rect (struct frame
*, int, int, int, int,
928 int, int, int, int, int, int,
930 static void w32_draw_box_rect (struct glyph_string
*, int, int, int, int,
931 int, bool, bool, RECT
*);
934 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
938 x_set_cursor_gc (struct glyph_string
*s
)
940 if (s
->font
== FRAME_FONT (s
->f
)
941 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
942 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
944 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
947 /* Cursor on non-default face: must merge. */
951 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
952 xgcv
.foreground
= s
->face
->background
;
954 /* If the glyph would be invisible, try a different foreground. */
955 if (xgcv
.foreground
== xgcv
.background
)
956 xgcv
.foreground
= s
->face
->foreground
;
957 if (xgcv
.foreground
== xgcv
.background
)
958 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
959 if (xgcv
.foreground
== xgcv
.background
)
960 xgcv
.foreground
= s
->face
->foreground
;
962 /* Make sure the cursor is distinct from text in this face. */
963 if (xgcv
.background
== s
->face
->background
964 && xgcv
.foreground
== s
->face
->foreground
)
966 xgcv
.background
= s
->face
->foreground
;
967 xgcv
.foreground
= s
->face
->background
;
970 IF_DEBUG (x_check_font (s
->f
, s
->font
));
972 mask
= GCForeground
| GCBackground
| GCFont
;
974 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
975 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
978 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
979 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
981 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
986 /* Set up S->gc of glyph string S for drawing text in mouse face. */
989 x_set_mouse_face_gc (struct glyph_string
*s
)
994 /* What face has to be used last for the mouse face? */
995 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
996 face
= FACE_OPT_FROM_ID (s
->f
, face_id
);
998 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1000 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1001 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1003 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1004 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1005 prepare_face_for_display (s
->f
, s
->face
);
1007 /* If font in this face is same as S->font, use it. */
1008 if (s
->font
== s
->face
->font
)
1009 s
->gc
= s
->face
->gc
;
1012 /* Otherwise construct scratch_cursor_gc with values from FACE
1017 xgcv
.background
= s
->face
->background
;
1018 xgcv
.foreground
= s
->face
->foreground
;
1019 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1020 xgcv
.font
= s
->font
;
1021 mask
= GCForeground
| GCBackground
| GCFont
;
1023 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1024 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1027 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1028 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1030 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1033 eassert (s
->gc
!= 0);
1037 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1038 Faces to use in the mode line have already been computed when the
1039 matrix was built, so there isn't much to do, here. */
1042 x_set_mode_line_face_gc (struct glyph_string
*s
)
1044 s
->gc
= s
->face
->gc
;
1048 /* Set S->gc of glyph string S for drawing that glyph string. Set
1049 S->stippled_p to a non-zero value if the face of S has a stipple
1053 x_set_glyph_string_gc (struct glyph_string
*s
)
1055 prepare_face_for_display (s
->f
, s
->face
);
1057 if (s
->hl
== DRAW_NORMAL_TEXT
)
1059 s
->gc
= s
->face
->gc
;
1060 s
->stippled_p
= s
->face
->stipple
!= 0;
1062 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1064 x_set_mode_line_face_gc (s
);
1065 s
->stippled_p
= s
->face
->stipple
!= 0;
1067 else if (s
->hl
== DRAW_CURSOR
)
1069 x_set_cursor_gc (s
);
1070 s
->stippled_p
= false;
1072 else if (s
->hl
== DRAW_MOUSE_FACE
)
1074 x_set_mouse_face_gc (s
);
1075 s
->stippled_p
= s
->face
->stipple
!= 0;
1077 else if (s
->hl
== DRAW_IMAGE_RAISED
1078 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1080 s
->gc
= s
->face
->gc
;
1081 s
->stippled_p
= s
->face
->stipple
!= 0;
1086 /* GC must have been set. */
1087 eassert (s
->gc
!= 0);
1091 /* Set clipping for output of glyph string S. S may be part of a mode
1092 line or menu if we don't have X toolkit support. */
1095 x_set_glyph_string_clipping (struct glyph_string
*s
)
1098 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1101 w32_set_clip_rectangle (s
->hdc
, r
);
1104 HRGN clip1
= CreateRectRgnIndirect (r
);
1105 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
1106 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
1107 SelectClipRgn (s
->hdc
, clip1
);
1108 DeleteObject (clip1
);
1109 DeleteObject (clip2
);
1114 /* Set SRC's clipping for output of glyph string DST. This is called
1115 when we are drawing DST's left_overhang or right_overhang only in
1119 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
,
1120 struct glyph_string
*dst
)
1125 r
.right
= r
.left
+ src
->width
;
1127 r
.bottom
= r
.top
+ src
->height
;
1130 w32_set_clip_rectangle (dst
->hdc
, &r
);
1134 Compute left and right overhang of glyph string S. */
1137 w32_compute_glyph_string_overhangs (struct glyph_string
*s
)
1140 && s
->first_glyph
->type
== CHAR_GLYPH
1141 && !s
->font_not_found_p
)
1143 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1144 struct font
*font
= s
->font
;
1145 struct font_metrics metrics
;
1148 for (i
= 0; i
< s
->nchars
; i
++)
1149 code
[i
] = s
->char2b
[i
];
1150 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1151 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1152 ? metrics
.rbearing
- metrics
.width
: 0);
1153 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1157 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1158 s
->left_overhang
= -s
->cmp
->lbearing
;
1162 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1165 x_clear_glyph_string_rect (struct glyph_string
*s
,
1166 int x
, int y
, int w
, int h
)
1173 /* Take clipping into account. */
1174 if (s
->gc
->clip_mask
== Rect
)
1176 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1177 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1178 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1179 - s
->gc
->clip_rectangle
.left
);
1180 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1181 - s
->gc
->clip_rectangle
.top
);
1184 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1189 /* Draw the background of glyph_string S. If S->background_filled_p
1190 is non-zero don't draw it. FORCE_P non-zero means draw the
1191 background even if it wouldn't be drawn normally. This is used
1192 when a string preceding S draws into the background of S, or S
1193 contains the first component of a composition. */
1196 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1198 /* Nothing to do if background has already been drawn or if it
1199 shouldn't be drawn in the first place. */
1200 if (!s
->background_filled_p
)
1202 int box_line_width
= max (s
->face
->box_line_width
, 0);
1204 #if 0 /* TODO: stipple */
1207 /* Fill background with a stipple pattern. */
1208 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1209 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1210 s
->y
+ box_line_width
,
1211 s
->background_width
,
1212 s
->height
- 2 * box_line_width
);
1213 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1214 s
->background_filled_p
= true;
1218 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1219 /* When xdisp.c ignores FONT_HEIGHT, we cannot trust
1220 font dimensions, since the actual glyphs might be
1221 much smaller. So in that case we always clear the
1222 rectangle with background color. */
1223 || FONT_TOO_HIGH (s
->font
)
1224 || s
->font_not_found_p
1225 || s
->extends_to_end_of_line_p
1228 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1229 s
->background_width
,
1230 s
->height
- 2 * box_line_width
);
1231 s
->background_filled_p
= true;
1237 /* Draw the foreground of glyph string S. */
1240 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1244 /* If first glyph of S has a left box line, start drawing the text
1245 of S to the right of that box line. */
1246 if (s
->face
->box
!= FACE_NO_BOX
1247 && s
->first_glyph
->left_box_line_p
)
1248 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1252 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1253 SetBkColor (s
->hdc
, s
->gc
->background
);
1254 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1256 /* Draw characters of S as rectangles if S's font could not be
1258 if (s
->font_not_found_p
)
1260 for (i
= 0; i
< s
->nchars
; ++i
)
1262 struct glyph
*g
= s
->first_glyph
+ i
;
1264 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1266 x
+= g
->pixel_width
;
1271 struct font
*font
= s
->font
;
1272 int boff
= font
->baseline_offset
;
1276 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1278 if (font
->vertical_centering
)
1279 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1281 y
= s
->ybase
- boff
;
1283 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1284 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, false);
1286 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, true);
1287 if (s
->face
->overstrike
)
1288 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, false);
1290 SelectObject (s
->hdc
, old_font
);
1294 /* Draw the foreground of composite glyph string S. */
1297 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1300 struct font
*font
= s
->font
;
1302 /* If first glyph of S has a left box line, start drawing the text
1303 of S to the right of that box line. */
1304 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1305 && s
->first_glyph
->left_box_line_p
)
1306 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1310 /* S is a glyph string for a composition. S->cmp_from is the index
1311 of the first character drawn for glyphs of this composition.
1312 S->cmp_from == 0 means we are drawing the very first character of
1313 this composition. */
1315 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1316 SetBkColor (s
->hdc
, s
->gc
->background
);
1317 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1319 /* Draw a rectangle for the composition if the font for the very
1320 first character of the composition could not be loaded. */
1321 if (s
->font_not_found_p
)
1323 if (s
->cmp_from
== 0)
1324 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1327 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1332 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1334 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1335 /* TAB in a composition means display glyphs with padding
1336 space on the left or right. */
1337 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1339 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1340 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1342 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, false);
1343 if (s
->face
->overstrike
)
1344 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, false);
1346 SelectObject (s
->hdc
, old_font
);
1350 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1356 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1358 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1360 glyph
= LGSTRING_GLYPH (gstring
, i
);
1361 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1362 width
+= LGLYPH_WIDTH (glyph
);
1365 int xoff
, yoff
, wadjust
;
1369 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1372 xoff
= LGLYPH_XOFF (glyph
);
1373 yoff
= LGLYPH_YOFF (glyph
);
1374 wadjust
= LGLYPH_WADJUST (glyph
);
1375 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, false);
1382 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1384 SelectObject (s
->hdc
, old_font
);
1389 /* Draw the foreground of glyph string S for glyphless characters. */
1392 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1394 struct glyph
*glyph
= s
->first_glyph
;
1397 bool with_background
;
1399 /* If first glyph of S has a left box line, start drawing the text
1400 of S to the right of that box line. */
1401 if (s
->face
->box
!= FACE_NO_BOX
1402 && s
->first_glyph
->left_box_line_p
)
1403 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1407 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1408 SetBkColor (s
->hdc
, s
->gc
->background
);
1409 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1412 with_background
= ((s
->for_overlaps
1413 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))) == 0;
1414 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1416 char buf
[7], *str
= NULL
;
1417 int len
= glyph
->u
.glyphless
.len
;
1419 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1422 && CHAR_TABLE_P (Vglyphless_char_display
)
1423 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1427 = (! glyph
->u
.glyphless
.for_no_font
1428 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1429 glyph
->u
.glyphless
.ch
)
1430 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1431 if (STRINGP (acronym
))
1432 str
= SSDATA (acronym
);
1435 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1437 sprintf ((char *) buf
, "%0*X",
1438 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1439 glyph
->u
.glyphless
.ch
);
1443 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1444 w32_draw_rectangle (s
->hdc
, s
->gc
,
1445 x
, s
->ybase
- glyph
->ascent
,
1446 glyph
->pixel_width
- 1,
1447 glyph
->ascent
+ glyph
->descent
- 1);
1450 struct font
*font
= s
->font
;
1451 int upper_len
= (len
+ 1) / 2;
1455 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1456 /* It is certain that all LEN characters in STR are ASCII. */
1457 for (j
= 0; j
< len
; j
++)
1459 code
= font
->driver
->encode_char (font
, str
[j
]);
1460 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1462 font
->driver
->draw (s
, 0, upper_len
,
1463 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1464 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1466 font
->driver
->draw (s
, upper_len
, len
,
1467 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1468 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1470 SelectObject (s
->hdc
, old_font
);
1472 x
+= glyph
->pixel_width
;
1477 /* Brightness beyond which a color won't have its highlight brightness
1480 Nominally, highlight colors for `3d' faces are calculated by
1481 brightening an object's color by a constant scale factor, but this
1482 doesn't yield good results for dark colors, so for colors whose
1483 brightness is less than this value (on a scale of 0-255) have to
1484 use an additional additive factor.
1486 The value here is set so that the default menu-bar/mode-line color
1487 (grey75) will not have its highlights changed at all. */
1488 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1491 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1492 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1493 If this produces the same color as COLOR, try a color where all RGB
1494 values have DELTA added. Return the allocated color in *COLOR.
1495 DISPLAY is the X display, CMAP is the colormap to operate on.
1496 Value is non-zero if successful. */
1499 w32_alloc_lighter_color (struct frame
*f
, COLORREF
*color
,
1500 double factor
, int delta
)
1505 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1508 /* Change RGB values by specified FACTOR. Avoid overflow! */
1509 eassert (factor
>= 0);
1510 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1511 min (0xff, factor
* GetGValue (*color
)),
1512 min (0xff, factor
* GetBValue (*color
)));
1514 /* Calculate brightness of COLOR. */
1515 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1516 + GetBValue (*color
)) / 6;
1518 /* We only boost colors that are darker than
1519 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1520 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1521 /* Make an additive adjustment to NEW, because it's dark enough so
1522 that scaling by FACTOR alone isn't enough. */
1524 /* How far below the limit this color is (0 - 1, 1 being darker). */
1525 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1526 /* The additive adjustment. */
1527 int min_delta
= delta
* dimness
* factor
/ 2;
1530 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1531 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1532 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1534 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1535 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1536 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1540 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1541 max (0, min (0xff, delta
+ GetGValue (*color
))),
1542 max (0, min (0xff, delta
+ GetBValue (*color
))));
1544 /* TODO: Map to palette and retry with delta if same? */
1545 /* TODO: Free colors (if using palette)? */
1555 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1556 colors in COLORS. On W32, we no longer try to map colors to
1559 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1563 for (i
= 0; i
< ncolors
; i
++)
1565 DWORD pixel
= colors
[i
].pixel
;
1566 /* Convert to a 16 bit value in range 0 - 0xffff. */
1567 colors
[i
].red
= GetRValue (pixel
) * 257;
1568 colors
[i
].green
= GetGValue (pixel
) * 257;
1569 colors
[i
].blue
= GetBValue (pixel
) * 257;
1574 x_query_color (struct frame
*f
, XColor
*color
)
1576 x_query_colors (f
, color
, 1);
1580 /* Set up the foreground color for drawing relief lines of glyph
1581 string S. RELIEF is a pointer to a struct relief containing the GC
1582 with which lines will be drawn. Use a color that is FACTOR or
1583 DELTA lighter or darker than the relief's background which is found
1584 in S->f->output_data.x->relief_background. If such a color cannot
1585 be allocated, use DEFAULT_PIXEL, instead. */
1588 w32_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
1589 int delta
, COLORREF default_pixel
)
1592 struct w32_output
*di
= f
->output_data
.w32
;
1593 unsigned long mask
= GCForeground
;
1595 COLORREF background
= di
->relief_background
;
1597 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1600 /* TODO: Free colors (if using palette)? */
1602 /* Allocate new color. */
1603 xgcv
.foreground
= default_pixel
;
1605 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1606 xgcv
.foreground
= relief
->pixel
= pixel
;
1608 if (relief
->gc
== 0)
1610 #if 0 /* TODO: stipple */
1611 xgcv
.stipple
= dpyinfo
->gray
;
1614 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1617 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1621 /* Set up colors for the relief lines around glyph string S. */
1624 x_setup_relief_colors (struct glyph_string
*s
)
1626 struct w32_output
*di
= s
->f
->output_data
.w32
;
1629 if (s
->face
->use_box_color_for_shadows_p
)
1630 color
= s
->face
->box_color
;
1631 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1633 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1634 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1636 color
= s
->gc
->background
;
1638 if (di
->white_relief
.gc
== 0
1639 || color
!= di
->relief_background
)
1641 di
->relief_background
= color
;
1642 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1643 WHITE_PIX_DEFAULT (s
->f
));
1644 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1645 BLACK_PIX_DEFAULT (s
->f
));
1650 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1651 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1652 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1653 relief. LEFT_P non-zero means draw a relief on the left side of
1654 the rectangle. RIGHT_P non-zero means draw a relief on the right
1655 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1659 w32_draw_relief_rect (struct frame
*f
,
1660 int left_x
, int top_y
, int right_x
, int bottom_y
,
1661 int width
, int raised_p
,
1662 int top_p
, int bot_p
, int left_p
, int right_p
,
1667 HDC hdc
= get_frame_dc (f
);
1670 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1672 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1674 w32_set_clip_rectangle (hdc
, clip_rect
);
1678 for (i
= 0; i
< width
; ++i
)
1679 w32_fill_area (f
, hdc
, gc
.foreground
,
1680 left_x
+ i
* left_p
, top_y
+ i
,
1681 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1685 for (i
= 0; i
< width
; ++i
)
1686 w32_fill_area (f
, hdc
, gc
.foreground
,
1687 left_x
+ i
, top_y
+ (i
+ 1) * top_p
, 1,
1688 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1691 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1693 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1697 for (i
= 0; i
< width
; ++i
)
1698 w32_fill_area (f
, hdc
, gc
.foreground
,
1699 left_x
+ i
* left_p
, bottom_y
- i
,
1700 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1704 for (i
= 0; i
< width
; ++i
)
1705 w32_fill_area (f
, hdc
, gc
.foreground
,
1706 right_x
- i
, top_y
+ (i
+ 1) * top_p
, 1,
1707 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1709 w32_set_clip_rectangle (hdc
, NULL
);
1711 release_frame_dc (f
, hdc
);
1715 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1716 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1717 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1718 left side of the rectangle. RIGHT_P non-zero means draw a line
1719 on the right side of the rectangle. CLIP_RECT is the clipping
1720 rectangle to use when drawing. */
1723 w32_draw_box_rect (struct glyph_string
*s
,
1724 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1725 bool left_p
, bool right_p
, RECT
*clip_rect
)
1727 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1730 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1731 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1736 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1737 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1741 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1742 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1747 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1748 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1751 w32_set_clip_rectangle (s
->hdc
, NULL
);
1755 /* Draw a box around glyph string S. */
1758 x_draw_glyph_string_box (struct glyph_string
*s
)
1760 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
;
1761 bool left_p
, right_p
, raised_p
;
1762 struct glyph
*last_glyph
;
1765 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1766 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1767 : window_box_right (s
->w
, s
->area
));
1769 /* The glyph that may have a right box line. */
1770 last_glyph
= (s
->cmp
|| s
->img
1772 : s
->first_glyph
+ s
->nchars
- 1);
1774 width
= eabs (s
->face
->box_line_width
);
1775 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1777 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1779 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1781 bottom_y
= top_y
+ s
->height
- 1;
1783 left_p
= (s
->first_glyph
->left_box_line_p
1784 || (s
->hl
== DRAW_MOUSE_FACE
1786 || s
->prev
->hl
!= s
->hl
)));
1787 right_p
= (last_glyph
->right_box_line_p
1788 || (s
->hl
== DRAW_MOUSE_FACE
1790 || s
->next
->hl
!= s
->hl
)));
1792 get_glyph_string_clip_rect (s
, &clip_rect
);
1794 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1795 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1796 left_p
, right_p
, &clip_rect
);
1799 x_setup_relief_colors (s
);
1800 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1801 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1806 /* Draw foreground of image glyph string S. */
1809 x_draw_image_foreground (struct glyph_string
*s
)
1812 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1814 /* If first glyph of S has a left box line, start drawing it to the
1815 right of that line. */
1816 if (s
->face
->box
!= FACE_NO_BOX
1817 && s
->first_glyph
->left_box_line_p
1819 x
+= eabs (s
->face
->box_line_width
);
1821 /* If there is a margin around the image, adjust x- and y-position
1823 if (s
->slice
.x
== 0)
1824 x
+= s
->img
->hmargin
;
1825 if (s
->slice
.y
== 0)
1826 y
+= s
->img
->vmargin
;
1832 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
1833 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1834 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
1835 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1836 SetBkColor (compat_hdc
, RGB (255, 255, 255));
1837 SetTextColor (s
->hdc
, RGB (0, 0, 0));
1838 x_set_glyph_string_clipping (s
);
1842 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
1843 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1845 SetTextColor (s
->hdc
, RGB (255, 255, 255));
1846 SetBkColor (s
->hdc
, RGB (0, 0, 0));
1848 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1849 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1850 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1851 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1852 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1853 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1855 SelectObject (mask_dc
, mask_orig_obj
);
1860 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1861 SetBkColor (s
->hdc
, s
->gc
->background
);
1863 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1864 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1866 /* When the image has a mask, we can expect that at
1867 least part of a mouse highlight or a block cursor will
1868 be visible. If the image doesn't have a mask, make
1869 a block cursor visible by drawing a rectangle around
1870 the image. I believe it's looking better if we do
1871 nothing here for mouse-face. */
1872 if (s
->hl
== DRAW_CURSOR
)
1874 int r
= s
->img
->relief
;
1876 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
1877 s
->slice
.width
+ r
*2 - 1,
1878 s
->slice
.height
+ r
*2 - 1);
1882 w32_set_clip_rectangle (s
->hdc
, NULL
);
1883 SelectObject (s
->hdc
, orig_brush
);
1884 DeleteObject (fg_brush
);
1885 SelectObject (compat_hdc
, orig_obj
);
1886 DeleteDC (compat_hdc
);
1889 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
1890 s
->slice
.width
- 1, s
->slice
.height
- 1);
1892 RestoreDC (s
->hdc
,-1);
1896 /* Draw a relief around the image glyph string S. */
1899 x_draw_image_relief (struct glyph_string
*s
)
1901 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
1902 int extra_x
, extra_y
;
1905 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1907 /* If first glyph of S has a left box line, start drawing it to the
1908 right of that line. */
1909 if (s
->face
->box
!= FACE_NO_BOX
1910 && s
->first_glyph
->left_box_line_p
1912 x
+= eabs (s
->face
->box_line_width
);
1914 /* If there is a margin around the image, adjust x- and y-position
1916 if (s
->slice
.x
== 0)
1917 x
+= s
->img
->hmargin
;
1918 if (s
->slice
.y
== 0)
1919 y
+= s
->img
->vmargin
;
1921 if (s
->hl
== DRAW_IMAGE_SUNKEN
1922 || s
->hl
== DRAW_IMAGE_RAISED
)
1924 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
1925 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
1926 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
1930 thick
= eabs (s
->img
->relief
);
1931 raised_p
= s
->img
->relief
> 0;
1934 x1
= x
+ s
->slice
.width
- 1;
1935 y1
= y
+ s
->slice
.height
- 1;
1937 extra_x
= extra_y
= 0;
1938 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
1940 if (CONSP (Vtool_bar_button_margin
)
1941 && INTEGERP (XCAR (Vtool_bar_button_margin
))
1942 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
1944 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
1945 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
1947 else if (INTEGERP (Vtool_bar_button_margin
))
1948 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
1951 top_p
= bot_p
= left_p
= right_p
= 0;
1953 if (s
->slice
.x
== 0)
1954 x
-= thick
+ extra_x
, left_p
= 1;
1955 if (s
->slice
.y
== 0)
1956 y
-= thick
+ extra_y
, top_p
= 1;
1957 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
1958 x1
+= thick
+ extra_x
, right_p
= 1;
1959 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
1960 y1
+= thick
+ extra_y
, bot_p
= 1;
1962 x_setup_relief_colors (s
);
1963 get_glyph_string_clip_rect (s
, &r
);
1964 w32_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
1965 top_p
, bot_p
, left_p
, right_p
, &r
);
1969 /* Draw the foreground of image glyph string S to PIXMAP. */
1972 w32_draw_image_foreground_1 (struct glyph_string
*s
, HBITMAP pixmap
)
1974 HDC hdc
= CreateCompatibleDC (s
->hdc
);
1975 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
1977 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1979 /* If first glyph of S has a left box line, start drawing it to the
1980 right of that line. */
1981 if (s
->face
->box
!= FACE_NO_BOX
1982 && s
->first_glyph
->left_box_line_p
1984 x
+= eabs (s
->face
->box_line_width
);
1986 /* If there is a margin around the image, adjust x- and y-position
1988 if (s
->slice
.x
== 0)
1989 x
+= s
->img
->hmargin
;
1990 if (s
->slice
.y
== 0)
1991 y
+= s
->img
->vmargin
;
1995 HDC compat_hdc
= CreateCompatibleDC (hdc
);
1996 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1997 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
1998 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2002 HDC mask_dc
= CreateCompatibleDC (hdc
);
2003 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2005 SetTextColor (hdc
, RGB (0, 0, 0));
2006 SetBkColor (hdc
, RGB (255, 255, 255));
2007 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2008 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2009 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2010 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2011 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2012 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2014 SelectObject (mask_dc
, mask_orig_obj
);
2019 SetTextColor (hdc
, s
->gc
->foreground
);
2020 SetBkColor (hdc
, s
->gc
->background
);
2022 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2023 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2025 /* When the image has a mask, we can expect that at
2026 least part of a mouse highlight or a block cursor will
2027 be visible. If the image doesn't have a mask, make
2028 a block cursor visible by drawing a rectangle around
2029 the image. I believe it's looking better if we do
2030 nothing here for mouse-face. */
2031 if (s
->hl
== DRAW_CURSOR
)
2033 int r
= s
->img
->relief
;
2035 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2036 s
->slice
.width
+ r
*2 - 1,
2037 s
->slice
.height
+ r
*2 - 1);
2041 SelectObject (hdc
, orig_brush
);
2042 DeleteObject (fg_brush
);
2043 SelectObject (compat_hdc
, orig_obj
);
2044 DeleteDC (compat_hdc
);
2047 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2048 s
->slice
.width
- 1, s
->slice
.height
- 1);
2050 SelectObject (hdc
, orig_hdc_obj
);
2055 /* Draw part of the background of glyph string S. X, Y, W, and H
2056 give the rectangle to draw. */
2059 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2061 #if 0 /* TODO: stipple */
2064 /* Fill background with a stipple pattern. */
2065 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2066 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2067 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2071 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2075 /* Draw image glyph string S.
2078 s->x +-------------------------
2081 | +-------------------------
2084 | | +-------------------
2090 x_draw_image_glyph_string (struct glyph_string
*s
)
2093 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2094 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2099 if (s
->slice
.y
== 0)
2100 height
-= box_line_vwidth
;
2101 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2102 height
-= box_line_vwidth
;
2104 /* Fill background with face under the image. Do it only if row is
2105 taller than image or if image has a clip mask to reduce
2107 s
->stippled_p
= s
->face
->stipple
!= 0;
2108 if (height
> s
->slice
.height
2112 || s
->img
->pixmap
== 0
2113 || s
->width
!= s
->background_width
)
2115 width
= s
->background_width
;
2117 if (s
->first_glyph
->left_box_line_p
2120 x
+= box_line_hwidth
;
2121 width
-= box_line_hwidth
;
2125 if (s
->slice
.y
== 0)
2126 y
+= box_line_vwidth
;
2128 #if 0 /* TODO: figure out if we need to do this on Windows. */
2131 /* Create a pixmap as large as the glyph string. Fill it
2132 with the background color. Copy the image to it, using
2133 its mask. Copy the temporary pixmap to the display. */
2134 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2135 int depth
= DefaultDepthOfScreen (screen
);
2137 /* Create a pixmap as large as the glyph string. */
2138 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2139 s
->background_width
,
2142 /* Don't clip in the following because we're working on the
2144 XSetClipMask (s
->display
, s
->gc
, None
);
2146 /* Fill the pixmap with the background color/stipple. */
2149 /* Fill background with a stipple pattern. */
2150 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2151 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2152 0, 0, s
->background_width
, s
->height
);
2153 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2158 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2160 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2161 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2162 0, 0, s
->background_width
, s
->height
);
2163 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2168 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
2170 s
->background_filled_p
= true;
2173 /* Draw the foreground. */
2176 w32_draw_image_foreground_1 (s
, pixmap
);
2177 x_set_glyph_string_clipping (s
);
2179 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2180 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2181 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2182 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2184 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2185 SetBkColor (s
->hdc
, s
->gc
->background
);
2186 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2187 compat_hdc
, 0, 0, SRCCOPY
);
2189 SelectObject (s
->hdc
, orig_brush
);
2190 DeleteObject (fg_brush
);
2191 SelectObject (compat_hdc
, orig_obj
);
2192 DeleteDC (compat_hdc
);
2194 DeleteObject (pixmap
);
2198 x_draw_image_foreground (s
);
2200 /* If we must draw a relief around the image, do it. */
2202 || s
->hl
== DRAW_IMAGE_RAISED
2203 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2204 x_draw_image_relief (s
);
2208 /* Draw stretch glyph string S. */
2211 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2213 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2215 if (s
->hl
== DRAW_CURSOR
2216 && !x_stretch_cursor_p
)
2218 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2219 wide as the stretch glyph. */
2220 int width
, background_width
= s
->background_width
;
2223 if (!s
->row
->reversed_p
)
2225 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2229 background_width
-= left_x
- x
;
2235 /* In R2L rows, draw the cursor on the right edge of the
2237 int right_x
= window_box_right (s
->w
, TEXT_AREA
);
2239 if (x
+ background_width
> right_x
)
2240 background_width
-= x
- right_x
;
2241 x
+= background_width
;
2243 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2244 if (s
->row
->reversed_p
)
2248 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2250 /* Clear rest using the GC of the original non-cursor face. */
2251 if (width
< background_width
)
2253 XGCValues
*gc
= s
->face
->gc
;
2255 int w
= background_width
- width
, h
= s
->height
;
2259 if (!s
->row
->reversed_p
)
2263 if (s
->row
->mouse_face_p
2264 && cursor_in_mouse_face_p (s
->w
))
2266 x_set_mouse_face_gc (s
);
2272 get_glyph_string_clip_rect (s
, &r
);
2273 w32_set_clip_rectangle (hdc
, &r
);
2275 #if 0 /* TODO: stipple */
2276 if (s
->face
->stipple
)
2278 /* Fill background with a stipple pattern. */
2279 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2280 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2281 XSetFillStyle (s
->display
, gc
, FillSolid
);
2286 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2290 else if (!s
->background_filled_p
)
2292 int background_width
= s
->background_width
;
2293 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2295 /* Don't draw into left margin, fringe or scrollbar area
2296 except for header line and mode line. */
2297 if (x
< left_x
&& !s
->row
->mode_line_p
)
2299 background_width
-= left_x
- x
;
2302 if (background_width
> 0)
2303 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2306 s
->background_filled_p
= true;
2310 /* Draw glyph string S. */
2313 x_draw_glyph_string (struct glyph_string
*s
)
2315 bool relief_drawn_p
= 0;
2317 /* If S draws into the background of its successor, draw the
2318 background of the successor first so that S can draw into it.
2319 This makes S->next use XDrawString instead of XDrawImageString. */
2320 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2323 struct glyph_string
*next
;
2324 for (width
= 0, next
= s
->next
;
2325 next
&& width
< s
->right_overhang
;
2326 width
+= next
->width
, next
= next
->next
)
2327 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2329 x_set_glyph_string_gc (next
);
2330 x_set_glyph_string_clipping (next
);
2331 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2332 x_draw_stretch_glyph_string (next
);
2334 x_draw_glyph_string_background (next
, true);
2335 next
->num_clips
= 0;
2339 /* Set up S->gc, set clipping and draw S. */
2340 x_set_glyph_string_gc (s
);
2342 /* Draw relief (if any) in advance for char/composition so that the
2343 glyph string can be drawn over it. */
2344 if (!s
->for_overlaps
2345 && s
->face
->box
!= FACE_NO_BOX
2346 && (s
->first_glyph
->type
== CHAR_GLYPH
2347 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2350 x_set_glyph_string_clipping (s
);
2351 x_draw_glyph_string_background (s
, true);
2352 x_draw_glyph_string_box (s
);
2353 x_set_glyph_string_clipping (s
);
2356 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2358 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2359 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2360 /* We must clip just this glyph. left_overhang part has already
2361 drawn when s->prev was drawn, and right_overhang part will be
2362 drawn later when s->next is drawn. */
2363 x_set_glyph_string_clipping_exactly (s
, s
);
2365 x_set_glyph_string_clipping (s
);
2367 switch (s
->first_glyph
->type
)
2370 x_draw_image_glyph_string (s
);
2374 x_draw_stretch_glyph_string (s
);
2378 if (s
->for_overlaps
)
2379 s
->background_filled_p
= true;
2381 x_draw_glyph_string_background (s
, false);
2382 x_draw_glyph_string_foreground (s
);
2385 case COMPOSITE_GLYPH
:
2386 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2387 && ! s
->first_glyph
->u
.cmp
.automatic
))
2388 s
->background_filled_p
= true;
2390 x_draw_glyph_string_background (s
, true);
2391 x_draw_composite_glyph_string_foreground (s
);
2394 case GLYPHLESS_GLYPH
:
2395 if (s
->for_overlaps
)
2396 s
->background_filled_p
= true;
2398 x_draw_glyph_string_background (s
, false);
2399 x_draw_glyphless_glyph_string_foreground (s
);
2406 if (!s
->for_overlaps
)
2408 /* Draw underline. */
2409 if (s
->face
->underline_p
)
2411 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2415 if (s
->face
->underline_defaulted_p
)
2416 color
= s
->gc
->foreground
;
2418 color
= s
->face
->underline_color
;
2420 w32_draw_underwave (s
, color
);
2422 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2424 unsigned long thickness
, position
;
2427 if (s
->prev
&& s
->prev
->face
->underline_p
2428 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2430 /* We use the same underline style as the previous one. */
2431 thickness
= s
->prev
->underline_thickness
;
2432 position
= s
->prev
->underline_position
;
2436 /* Get the underline thickness. Default is 1 pixel. */
2437 if (s
->font
&& s
->font
->underline_thickness
> 0)
2438 thickness
= s
->font
->underline_thickness
;
2441 if (x_underline_at_descent_line
)
2442 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2445 /* Get the underline position. This is the recommended
2446 vertical offset in pixels from the baseline to the top of
2447 the underline. This is a signed value according to the
2448 specs, and its default is
2450 ROUND ((maximum_descent) / 2), with
2451 ROUND (x) = floor (x + 0.5) */
2453 if (x_use_underline_position_properties
2454 && s
->font
&& s
->font
->underline_position
>= 0)
2455 position
= s
->font
->underline_position
;
2457 position
= (s
->font
->descent
+ 1) / 2;
2459 position
= max (position
, underline_minimum_offset
);
2461 /* Check the sanity of thickness and position. We should
2462 avoid drawing underline out of the current line area. */
2463 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2464 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2465 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2466 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2467 s
->underline_thickness
= thickness
;
2468 s
->underline_position
=position
;
2469 y
= s
->ybase
+ position
;
2470 if (s
->face
->underline_defaulted_p
)
2472 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2477 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2482 /* Draw overline. */
2483 if (s
->face
->overline_p
)
2485 unsigned long dy
= 0, h
= 1;
2487 if (s
->face
->overline_color_defaulted_p
)
2489 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2490 s
->y
+ dy
, s
->width
, h
);
2494 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2495 s
->y
+ dy
, s
->width
, h
);
2499 /* Draw strike-through. */
2500 if (s
->face
->strike_through_p
2501 && !FONT_TEXTMETRIC (s
->font
).tmStruckOut
)
2503 unsigned long h
= 1;
2504 unsigned long dy
= (s
->height
- h
) / 2;
2506 if (s
->face
->strike_through_color_defaulted_p
)
2508 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2513 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2514 s
->y
+ dy
, s
->width
, h
);
2518 /* Draw relief if not yet drawn. */
2519 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2520 x_draw_glyph_string_box (s
);
2524 struct glyph_string
*prev
;
2526 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2527 if (prev
->hl
!= s
->hl
2528 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2530 /* As prev was drawn while clipped to its own area, we
2531 must draw the right_overhang part using s->hl now. */
2532 enum draw_glyphs_face save
= prev
->hl
;
2535 x_set_glyph_string_gc (prev
);
2536 x_set_glyph_string_clipping_exactly (s
, prev
);
2537 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2538 x_draw_glyph_string_foreground (prev
);
2540 x_draw_composite_glyph_string_foreground (prev
);
2541 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2543 prev
->num_clips
= 0;
2549 struct glyph_string
*next
;
2551 for (next
= s
->next
; next
; next
= next
->next
)
2552 if (next
->hl
!= s
->hl
2553 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2555 /* As next will be drawn while clipped to its own area,
2556 we must draw the left_overhang part using s->hl now. */
2557 enum draw_glyphs_face save
= next
->hl
;
2560 x_set_glyph_string_gc (next
);
2561 x_set_glyph_string_clipping_exactly (s
, next
);
2562 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2563 x_draw_glyph_string_foreground (next
);
2565 x_draw_composite_glyph_string_foreground (next
);
2566 w32_set_clip_rectangle (next
->hdc
, NULL
);
2568 next
->num_clips
= 0;
2569 next
->clip_head
= s
->next
;
2574 /* Reset clipping. */
2575 w32_set_clip_rectangle (s
->hdc
, NULL
);
2580 /* Shift display to make room for inserted glyphs. */
2583 w32_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
,
2584 int width
, int height
, int shift_by
)
2588 hdc
= get_frame_dc (f
);
2589 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2590 hdc
, x
, y
, SRCCOPY
);
2592 release_frame_dc (f
, hdc
);
2596 /* Delete N glyphs at the nominal cursor position. Not implemented
2600 x_delete_glyphs (struct frame
*f
, register int n
)
2602 if (! FRAME_W32_P (f
))
2609 /* Clear entire frame. */
2612 x_clear_frame (struct frame
*f
)
2614 if (! FRAME_W32_P (f
))
2617 /* Clearing the frame will erase any cursor, so mark them all as no
2619 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2623 w32_clear_window (f
);
2625 /* We have to clear the scroll bars, too. If we have changed
2626 colors or something like that, then they should be notified. */
2627 x_scroll_bar_clear (f
);
2633 /* Make audible bell. */
2636 w32_ring_bell (struct frame
*f
)
2640 if (FRAME_W32_P (f
) && visible_bell
)
2643 HWND hwnd
= FRAME_W32_WINDOW (f
);
2645 for (i
= 0; i
< 5; i
++)
2647 FlashWindow (hwnd
, TRUE
);
2650 FlashWindow (hwnd
, FALSE
);
2653 w32_sys_ring_bell (f
);
2658 /***********************************************************************
2660 ***********************************************************************/
2662 /* Perform an insert-lines or delete-lines operation, inserting N
2663 lines or deleting -N lines at vertical position VPOS. */
2666 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
2668 if (! FRAME_W32_P (f
))
2675 /* Scroll part of the display as described by RUN. */
2678 x_scroll_run (struct window
*w
, struct run
*run
)
2680 struct frame
*f
= XFRAME (w
->frame
);
2681 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2682 HWND hwnd
= FRAME_W32_WINDOW (f
);
2685 /* Get frame-relative bounding box of the text display area of W,
2686 without mode lines. Include in this box the left and right
2688 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
2690 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2691 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2692 bottom_y
= y
+ height
;
2696 /* Scrolling up. Make sure we don't copy part of the mode
2697 line at the bottom. */
2698 if (from_y
+ run
->height
> bottom_y
)
2699 height
= bottom_y
- from_y
;
2701 height
= run
->height
;
2702 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2706 /* Scrolling down. Make sure we don't copy over the mode line.
2708 if (to_y
+ run
->height
> bottom_y
)
2709 height
= bottom_y
- to_y
;
2711 height
= run
->height
;
2712 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2717 /* Cursor off. Will be switched on again in x_update_window_end. */
2723 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2724 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2726 from
.left
= to
.left
= x
;
2727 from
.right
= to
.right
= x
+ width
;
2729 from
.bottom
= from_y
+ height
;
2731 to
.bottom
= bottom_y
;
2733 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2734 NULL
, SW_INVALIDATE
);
2736 /* Combine this with what we expect to be dirty. This covers the
2737 case where not all of the region we expect is actually dirty. */
2738 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2740 /* If the dirty region is not what we expected, redraw the entire frame. */
2741 if (!EqualRgn (combined
, expect_dirty
))
2742 SET_FRAME_GARBAGED (f
);
2744 DeleteObject (dirty
);
2745 DeleteObject (combined
);
2749 DeleteObject (expect_dirty
);
2754 /***********************************************************************
2756 ***********************************************************************/
2759 frame_highlight (struct frame
*f
)
2761 x_update_cursor (f
, 1);
2762 x_set_frame_alpha (f
);
2766 frame_unhighlight (struct frame
*f
)
2768 x_update_cursor (f
, 1);
2769 x_set_frame_alpha (f
);
2772 /* The focus has changed. Update the frames as necessary to reflect
2773 the new situation. Note that we can't change the selected frame
2774 here, because the Lisp code we are interrupting might become confused.
2775 Each event gets marked with the frame in which it occurred, so the
2776 Lisp code can tell when the switch took place by examining the events. */
2779 x_new_focus_frame (struct w32_display_info
*dpyinfo
, struct frame
*frame
)
2781 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2783 if (frame
!= dpyinfo
->w32_focus_frame
)
2785 /* Set this before calling other routines, so that they see
2786 the correct value of w32_focus_frame. */
2787 dpyinfo
->w32_focus_frame
= frame
;
2789 if (old_focus
&& old_focus
->auto_lower
)
2790 x_lower_frame (old_focus
);
2792 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2793 dpyinfo
->w32_pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2795 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
2798 x_frame_rehighlight (dpyinfo
);
2802 /* Handle FocusIn and FocusOut state changes for FRAME.
2803 If FRAME has focus and there exists more than one frame, puts
2804 a FOCUS_IN_EVENT into *BUFP. */
2807 x_focus_changed (int type
, int state
, struct w32_display_info
*dpyinfo
,
2808 struct frame
*frame
, struct input_event
*bufp
)
2810 if (type
== WM_SETFOCUS
)
2812 if (dpyinfo
->w32_focus_event_frame
!= frame
)
2814 x_new_focus_frame (dpyinfo
, frame
);
2815 dpyinfo
->w32_focus_event_frame
= frame
;
2817 /* Don't stop displaying the initial startup message
2818 for a switch-frame event we don't need. */
2819 if (NILP (Vterminal_frame
)
2820 && CONSP (Vframe_list
)
2821 && !NILP (XCDR (Vframe_list
)))
2830 bufp
->kind
= FOCUS_IN_EVENT
;
2831 XSETFRAME (bufp
->frame_or_window
, frame
);
2834 frame
->output_data
.x
->focus_state
|= state
;
2836 /* TODO: IME focus? */
2838 else if (type
== WM_KILLFOCUS
)
2840 frame
->output_data
.x
->focus_state
&= ~state
;
2842 if (dpyinfo
->w32_focus_event_frame
== frame
)
2844 dpyinfo
->w32_focus_event_frame
= 0;
2845 x_new_focus_frame (dpyinfo
, 0);
2847 bufp
->kind
= FOCUS_OUT_EVENT
;
2848 XSETFRAME (bufp
->frame_or_window
, frame
);
2851 /* TODO: IME focus? */
2856 /* The focus may have changed. Figure out if it is a real focus change,
2857 by checking both FocusIn/Out and Enter/LeaveNotify events.
2859 Returns FOCUS_IN_EVENT event in *BUFP. */
2862 w32_detect_focus_change (struct w32_display_info
*dpyinfo
, W32Msg
*event
,
2863 struct input_event
*bufp
)
2865 struct frame
*frame
;
2867 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
2871 /* On w32, this is only called from focus events, so no switch needed. */
2872 x_focus_changed (event
->msg
.message
,
2873 (event
->msg
.message
== WM_KILLFOCUS
?
2874 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
2875 dpyinfo
, frame
, bufp
);
2879 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2882 x_mouse_leave (struct w32_display_info
*dpyinfo
)
2884 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 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4206 emacs_event
->part
= scroll_bar_down_arrow
;
4209 emacs_event
->part
= scroll_bar_up_arrow
;
4212 emacs_event
->part
= scroll_bar_above_handle
;
4215 emacs_event
->part
= scroll_bar_below_handle
;
4218 emacs_event
->part
= scroll_bar_handle
;
4222 emacs_event
->part
= scroll_bar_handle
;
4226 case SB_THUMBPOSITION
:
4227 bar
->dragging
= 1; /* ??????? */
4228 emacs_event
->part
= scroll_bar_handle
;
4230 /* "Silently" update current position. */
4234 si
.cbSize
= sizeof (si
);
4237 /* Remember apparent position (we actually lag behind the real
4238 position, so don't set that directly). */
4239 last_scroll_bar_drag_pos
= y
;
4241 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4245 /* If this is the end of a drag sequence, then reset the scroll
4246 handle size to normal and do a final redraw. Otherwise do
4251 int start
= bar
->start
;
4254 si
.cbSize
= sizeof (si
);
4255 si
.fMask
= SIF_PAGE
| SIF_POS
;
4256 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4257 si
.nPos
= last_scroll_bar_drag_pos
;
4258 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4262 emacs_event
->kind
= NO_EVENT
;
4266 XSETINT (emacs_event
->x
, y
);
4267 XSETINT (emacs_event
->y
, top_range
);
4273 /* Handle a mouse click on the horizontal scroll bar BAR. If
4274 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4277 This may be called from a signal handler, so we have to ignore GC
4281 w32_horizontal_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4282 struct input_event
*emacs_event
)
4284 if (! WINDOWP (bar
->window
))
4287 emacs_event
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
4288 emacs_event
->code
= 0;
4289 /* not really meaningful to distinguish left/right */
4290 emacs_event
->modifiers
= msg
->dwModifiers
;
4291 emacs_event
->frame_or_window
= bar
->window
;
4292 emacs_event
->arg
= Qnil
;
4293 emacs_event
->timestamp
= msg
->msg
.time
;
4296 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4298 int dragging
= bar
->dragging
;
4300 int sb_event
= LOWORD (msg
->msg
.wParam
);
4302 si
.cbSize
= sizeof (si
);
4303 if (sb_event
== SB_THUMBTRACK
)
4304 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4306 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4308 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4309 if (sb_event
== SB_THUMBTRACK
)
4313 y
= si
.nMax
- si
.nPage
;
4316 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4321 emacs_event
->part
= scroll_bar_left_arrow
;
4324 emacs_event
->part
= scroll_bar_right_arrow
;
4327 emacs_event
->part
= scroll_bar_before_handle
;
4330 emacs_event
->part
= scroll_bar_after_handle
;
4333 emacs_event
->part
= scroll_bar_horizontal_handle
;
4337 emacs_event
->part
= scroll_bar_horizontal_handle
;
4341 case SB_THUMBPOSITION
:
4343 emacs_event
->part
= scroll_bar_horizontal_handle
;
4345 /* "Silently" update current position. */
4349 si
.cbSize
= sizeof (si
);
4351 si
.nPos
= min (x
, XWINDOW (bar
->window
)->hscroll_whole
- 1);
4352 /* Remember apparent position (we actually lag behind the real
4353 position, so don't set that directly). */
4354 last_scroll_bar_drag_pos
= x
;
4356 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4360 /* If this is the end of a drag sequence, then reset the scroll
4361 handle size to normal and do a final redraw. Otherwise do
4367 si
.cbSize
= sizeof (si
);
4369 si
.nPos
= min (last_scroll_bar_drag_pos
,
4370 XWINDOW (bar
->window
)->hscroll_whole
- 1);
4371 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4375 emacs_event
->kind
= NO_EVENT
;
4379 XSETINT (emacs_event
->x
, x
);
4380 XSETINT (emacs_event
->y
, y
);
4386 /* Return information to the user about the current position of the mouse
4387 on the vertical scroll bar. */
4389 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4390 enum scroll_bar_part
*part
,
4391 Lisp_Object
*x
, Lisp_Object
*y
,
4394 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4395 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4396 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4397 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4399 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4401 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4406 *bar_window
= bar
->window
;
4408 si
.cbSize
= sizeof (si
);
4409 if (sb_event
== SB_THUMBTRACK
)
4410 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4412 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4414 GetScrollInfo (w
, SB_CTL
, &si
);
4415 if (sb_event
== SB_THUMBTRACK
)
4419 top_range
= si
.nMax
- si
.nPage
+ 1;
4421 *part
= scroll_bar_handle
;
4422 if (sb_event
== SB_LINEDOWN
)
4426 XSETINT (*y
, top_range
);
4428 f
->mouse_moved
= false;
4429 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4431 *time
= dpyinfo
->last_mouse_movement_time
;
4436 /* Return information to the user about the current position of the mouse
4437 on the horizontal scroll bar. */
4439 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4440 enum scroll_bar_part
*part
,
4441 Lisp_Object
*x
, Lisp_Object
*y
,
4444 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4445 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4446 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4447 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4449 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4451 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4456 *bar_window
= bar
->window
;
4458 si
.cbSize
= sizeof (si
);
4459 if (sb_event
== SB_THUMBTRACK
)
4460 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4462 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4464 GetScrollInfo (w
, SB_CTL
, &si
);
4465 if (sb_event
== SB_THUMBTRACK
)
4469 left_range
= si
.nMax
- si
.nPage
+ 1;
4471 *part
= scroll_bar_handle
;
4472 if (sb_event
== SB_LINERIGHT
)
4477 XSETINT (*x
, left_range
);
4479 f
->mouse_moved
= false;
4480 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4482 *time
= dpyinfo
->last_mouse_movement_time
;
4488 /* The screen has been cleared so we may have changed foreground or
4489 background colors, and the scroll bars may need to be redrawn.
4490 Clear out the scroll bars, and ask for expose events, so we can
4494 x_scroll_bar_clear (struct frame
*f
)
4498 /* We can have scroll bars even if this is 0,
4499 if we just turned off scroll bar mode.
4500 But in that case we should not clear them. */
4501 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4502 || FRAME_HAS_HORIZONTAL_SCROLL_BARS (f
))
4503 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4504 bar
= XSCROLL_BAR (bar
)->next
)
4506 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4507 HDC hdc
= GetDC (window
);
4510 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4511 arranges to refresh the scroll bar if hidden. */
4512 my_show_window (f
, window
, SW_HIDE
);
4514 GetClientRect (window
, &rect
);
4515 select_palette (f
, hdc
);
4516 w32_clear_rect (f
, hdc
, &rect
);
4517 deselect_palette (f
, hdc
);
4519 ReleaseDC (window
, hdc
);
4523 /* The main W32 event-reading loop - w32_read_socket. */
4525 /* Record the last 100 characters stored
4526 to help debug the loss-of-chars-during-GC problem. */
4528 static int temp_index
;
4529 static short temp_buffer
[100];
4531 /* Temporarily store lead byte of DBCS input sequences. */
4532 static char dbcs_lead
= 0;
4534 /* Read events coming from the W32 shell.
4535 This routine is called by the SIGIO handler.
4536 We return as soon as there are no more events to be read.
4538 For an overview of how Emacs input works on MS-Windows, see the
4539 commentary before w32_msg_pump in w32fns.c.
4541 We return the number of characters stored into the buffer,
4542 thus pretending to be `read'.
4544 Some of these messages are reposted back to the message queue since the
4545 system calls the windows proc directly in a context where we cannot return
4546 the data nor can we guarantee the state we are in. So if we dispatch them
4547 we will get into an infinite loop. To prevent this from ever happening we
4548 will set a variable to indicate we are in the read_socket call and indicate
4549 which message we are processing since the windows proc gets called
4550 recursively with different messages by the system.
4554 w32_read_socket (struct terminal
*terminal
,
4555 struct input_event
*hold_quit
)
4558 int check_visibility
= 0;
4561 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4562 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
4566 /* So people can tell when we have read the available input. */
4567 input_signal_count
++;
4569 /* Process any incoming thread messages. */
4570 drain_message_queue ();
4572 /* TODO: ghostscript integration. */
4573 while (get_next_msg (&msg
, FALSE
))
4575 struct input_event inev
;
4578 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4579 /* w32_name_of_message (msg.msg.message), */
4580 /* msg.msg.time)); */
4583 inev
.kind
= NO_EVENT
;
4586 switch (msg
.msg
.message
)
4588 case WM_EMACS_PAINT
:
4589 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4593 if (msg
.rect
.right
== msg
.rect
.left
||
4594 msg
.rect
.bottom
== msg
.rect
.top
)
4596 /* We may get paint messages even though the client
4597 area is clipped - these are not expose events. */
4598 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4601 else if (FRAME_VISIBLE_P (f
) != 1)
4603 bool iconified
= FRAME_ICONIFIED_P (f
);
4605 /* Definitely not obscured, so mark as visible. */
4606 SET_FRAME_VISIBLE (f
, 1);
4607 SET_FRAME_ICONIFIED (f
, false);
4608 SET_FRAME_GARBAGED (f
);
4609 if (!f
->output_data
.w32
->asked_for_visible
)
4610 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4613 /* WM_PAINT serves as MapNotify as well, so report
4614 visibility changes properly. */
4617 inev
.kind
= DEICONIFY_EVENT
;
4618 XSETFRAME (inev
.frame_or_window
, f
);
4620 else if (!NILP (Vframe_list
) && !NILP (XCDR (Vframe_list
)))
4621 /* Force a redisplay sooner or later to update the
4622 frame titles in case this is the second frame. */
4623 record_asynch_buffer_change ();
4627 HDC hdc
= get_frame_dc (f
);
4629 /* Erase background again for safety. */
4630 w32_clear_rect (f
, hdc
, &msg
.rect
);
4631 release_frame_dc (f
, hdc
);
4635 msg
.rect
.right
- msg
.rect
.left
,
4636 msg
.rect
.bottom
- msg
.rect
.top
);
4641 case WM_INPUTLANGCHANGE
:
4642 /* Generate a language change event. */
4643 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4645 /* lParam contains the input language ID in its low 16 bits.
4646 Use it to update our record of the keyboard codepage. */
4647 w32_keyboard_codepage
= codepage_for_locale ((LCID
)(msg
.msg
.lParam
4652 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4653 XSETFRAME (inev
.frame_or_window
, f
);
4654 inev
.code
= w32_keyboard_codepage
;
4655 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4661 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4663 if (f
&& !FRAME_ICONIFIED_P (f
))
4665 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4666 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4668 clear_mouse_face (hlinfo
);
4669 hlinfo
->mouse_face_hidden
= true;
4672 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4674 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4675 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4676 inev
.code
= msg
.msg
.wParam
;
4677 inev
.modifiers
= msg
.dwModifiers
;
4678 XSETFRAME (inev
.frame_or_window
, f
);
4679 inev
.timestamp
= msg
.msg
.time
;
4686 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4688 if (f
&& !FRAME_ICONIFIED_P (f
))
4690 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4691 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4693 clear_mouse_face (hlinfo
);
4694 hlinfo
->mouse_face_hidden
= true;
4697 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4699 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4701 inev
.modifiers
= msg
.dwModifiers
;
4702 XSETFRAME (inev
.frame_or_window
, f
);
4703 inev
.timestamp
= msg
.msg
.time
;
4705 if (msg
.msg
.message
== WM_UNICHAR
)
4707 inev
.code
= msg
.msg
.wParam
;
4709 else if (msg
.msg
.wParam
< 256)
4714 dbcs
[1] = (char) msg
.msg
.wParam
;
4718 dbcs
[0] = dbcs_lead
;
4720 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4724 DebPrint (("Invalid DBCS sequence: %d %d\n",
4726 inev
.kind
= NO_EVENT
;
4730 else if (IsDBCSLeadByteEx (w32_keyboard_codepage
,
4731 (BYTE
) msg
.msg
.wParam
))
4733 dbcs_lead
= (char) msg
.msg
.wParam
;
4734 inev
.kind
= NO_EVENT
;
4739 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4740 &dbcs
[1], 1, &code
, 1))
4742 /* What to do with garbage? */
4743 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4744 inev
.kind
= NO_EVENT
;
4752 /* Windows shouldn't generate WM_CHAR events above 0xFF
4753 in non-Unicode message handlers. */
4754 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4755 inev
.kind
= NO_EVENT
;
4758 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4759 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4764 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4766 if (f
&& !FRAME_ICONIFIED_P (f
))
4768 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4769 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4771 clear_mouse_face (hlinfo
);
4772 hlinfo
->mouse_face_hidden
= true;
4775 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4777 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4778 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4779 inev
.code
= GET_APPCOMMAND_LPARAM (msg
.msg
.lParam
);
4780 inev
.modifiers
= msg
.dwModifiers
;
4781 XSETFRAME (inev
.frame_or_window
, f
);
4782 inev
.timestamp
= msg
.msg
.time
;
4787 /* Ignore non-movement. */
4789 int x
= LOWORD (msg
.msg
.lParam
);
4790 int y
= HIWORD (msg
.msg
.lParam
);
4791 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4793 last_mousemove_x
= x
;
4794 last_mousemove_y
= y
;
4797 previous_help_echo_string
= help_echo_string
;
4798 help_echo_string
= Qnil
;
4800 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4801 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4803 if (hlinfo
->mouse_face_hidden
)
4805 hlinfo
->mouse_face_hidden
= false;
4806 clear_mouse_face (hlinfo
);
4811 /* Generate SELECT_WINDOW_EVENTs when needed. */
4812 if (!NILP (Vmouse_autoselect_window
))
4814 static Lisp_Object last_mouse_window
;
4815 Lisp_Object window
= window_from_coordinates
4816 (f
, LOWORD (msg
.msg
.lParam
), HIWORD (msg
.msg
.lParam
), 0, 0);
4818 /* Window will be selected only when it is not
4819 selected now and last mouse movement event was
4820 not in it. Minibuffer window will be selected
4821 only when it is active. */
4822 if (WINDOWP (window
)
4823 && !EQ (window
, last_mouse_window
)
4824 && !EQ (window
, selected_window
)
4825 /* For click-to-focus window managers
4826 create event iff we don't leave the
4828 && (focus_follows_mouse
4829 || (EQ (XWINDOW (window
)->frame
,
4830 XWINDOW (selected_window
)->frame
))))
4832 inev
.kind
= SELECT_WINDOW_EVENT
;
4833 inev
.frame_or_window
= window
;
4835 /* Remember the last window where we saw the mouse. */
4836 last_mouse_window
= window
;
4838 if (!note_mouse_movement (f
, &msg
.msg
))
4839 help_echo_string
= previous_help_echo_string
;
4843 /* If we move outside the frame, then we're
4844 certainly no longer on any text in the frame. */
4845 clear_mouse_face (hlinfo
);
4848 /* If the contents of the global variable help_echo_string
4849 has changed, generate a HELP_EVENT. */
4850 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4851 But it was originally changed to this to fix a bug, so I have
4852 not removed it completely in case the bug is still there. */
4853 if (help_echo_string
!= previous_help_echo_string
||
4854 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4855 #else /* This is what xterm.c does. */
4856 if (!NILP (help_echo_string
)
4857 || !NILP (previous_help_echo_string
))
4862 case WM_LBUTTONDOWN
:
4864 case WM_MBUTTONDOWN
:
4866 case WM_RBUTTONDOWN
:
4868 case WM_XBUTTONDOWN
:
4871 /* If we decide we want to generate an event to be seen
4872 by the rest of Emacs, we put it here. */
4873 bool tool_bar_p
= 0;
4877 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4878 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4882 construct_mouse_click (&inev
, &msg
, f
);
4884 /* Is this in the tool-bar? */
4885 if (WINDOWP (f
->tool_bar_window
)
4886 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4889 int x
= XFASTINT (inev
.x
);
4890 int y
= XFASTINT (inev
.y
);
4892 window
= window_from_coordinates (f
, x
, y
, 0, 1);
4894 if (EQ (window
, f
->tool_bar_window
))
4896 w32_handle_tool_bar_click (f
, &inev
);
4902 || (dpyinfo
->w32_focus_frame
4903 && f
!= dpyinfo
->w32_focus_frame
))
4904 inev
.kind
= NO_EVENT
;
4907 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4912 dpyinfo
->grabbed
&= ~ (1 << button
);
4916 dpyinfo
->grabbed
|= (1 << button
);
4917 dpyinfo
->last_mouse_frame
= f
;
4918 /* Ignore any mouse motion that happened
4919 before this event; any subsequent mouse-movement
4920 Emacs events should reflect only motion after
4924 f
->mouse_moved
= false;
4926 f
->last_tool_bar_item
= -1;
4933 case WM_MOUSEHWHEEL
:
4935 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4936 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4941 if (!dpyinfo
->w32_focus_frame
4942 || f
== dpyinfo
->w32_focus_frame
)
4944 /* Emit an Emacs wheel-up/down event. */
4945 construct_mouse_wheel (&inev
, &msg
, f
);
4947 /* Ignore any mouse motion that happened before this
4948 event; any subsequent mouse-movement Emacs events
4949 should reflect only motion after the
4951 f
->mouse_moved
= false;
4952 f
->last_tool_bar_item
= -1;
4954 dpyinfo
->last_mouse_frame
= f
;
4959 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4962 construct_drag_n_drop (&inev
, &msg
, f
);
4967 struct scroll_bar
*bar
=
4968 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 1);
4971 w32_horizontal_scroll_bar_handle_click (bar
, &msg
, &inev
);
4977 struct scroll_bar
*bar
=
4978 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 0);
4981 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
4985 case WM_WINDOWPOSCHANGED
:
4987 case WM_ACTIVATEAPP
:
4988 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4991 /* Run the full-screen hook function also when we are
4992 being activated, to actually install the required
4993 size in effect, if the WAIT flag is set. This is
4994 because when the hook is run from x_set_fullscreen,
4995 the frame might not yet be visible, if that call is a
4996 result of make-frame, and in that case the hook just
4997 sets the WAIT flag. */
4998 if ((msg
.msg
.message
== WM_WINDOWPOSCHANGED
|| msg
.msg
.wParam
)
4999 && (f
->want_fullscreen
& FULLSCREEN_WAIT
))
5001 /* Must set visibility right here since otherwise
5002 w32fullscreen_hook returns immediately. */
5003 SET_FRAME_VISIBLE (f
, 1);
5004 w32fullscreen_hook (f
);
5007 check_visibility
= 1;
5011 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5013 if (f
&& !FRAME_ICONIFIED_P (f
))
5014 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5016 check_visibility
= 1;
5020 /* wParam non-zero means Window is about to be shown, 0 means
5021 about to be hidden. */
5022 /* Redo the mouse-highlight after the tooltip has gone. */
5023 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
5026 x_redo_mouse_highlight (dpyinfo
);
5029 /* If window has been obscured or exposed by another window
5030 being maximized or minimized/restored, then recheck
5031 visibility of all frames. Direct changes to our own
5032 windows get handled by WM_SIZE. */
5034 if (msg
.msg
.lParam
!= 0)
5035 check_visibility
= 1;
5038 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5039 f
->async_visible
= msg
.msg
.wParam
;
5043 check_visibility
= 1;
5047 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5049 /* Inform lisp of whether frame has been iconified etc. */
5052 switch (msg
.msg
.wParam
)
5054 case SIZE_MINIMIZED
:
5055 SET_FRAME_VISIBLE (f
, 0);
5056 SET_FRAME_ICONIFIED (f
, true);
5058 inev
.kind
= ICONIFY_EVENT
;
5059 XSETFRAME (inev
.frame_or_window
, f
);
5062 case SIZE_MAXIMIZED
:
5064 bool iconified
= FRAME_ICONIFIED_P (f
);
5065 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5067 SET_FRAME_VISIBLE (f
, 1);
5068 SET_FRAME_ICONIFIED (f
, false);
5070 /* wait_reading_process_output will notice this
5071 and update the frame's display structures. */
5072 SET_FRAME_GARBAGED (f
);
5078 /* Reset top and left positions of the Window
5079 here since Windows sends a WM_MOVE message
5080 BEFORE telling us the Window is minimized
5081 when the Window is iconified, with 3000,3000
5083 x_real_positions (f
, &x
, &y
);
5087 inev
.kind
= DEICONIFY_EVENT
;
5088 XSETFRAME (inev
.frame_or_window
, f
);
5090 else if (! NILP (Vframe_list
)
5091 && ! NILP (XCDR (Vframe_list
)))
5092 /* Force a redisplay sooner or later
5093 to update the frame titles
5094 in case this is the second frame. */
5095 record_asynch_buffer_change ();
5097 /* Windows can send us a SIZE_MAXIMIZED message even
5098 when fullscreen is fullboth. The following is a
5099 simple hack to check that based on the fact that
5100 only a maximized fullscreen frame should have both
5101 top/left outside the screen. */
5102 if (EQ (fullscreen
, Qfullwidth
) || EQ (fullscreen
, Qfullheight
)
5103 || NILP (fullscreen
))
5107 x_real_positions (f
, &x
, &y
);
5109 store_frame_param (f
, Qfullscreen
, Qmaximized
);
5117 bool iconified
= FRAME_ICONIFIED_P (f
);
5119 /* The following was made unconditional in a
5120 pathetic attempt to fix bug#16967 in revision
5121 116716 but, considered counterproductive was made
5122 conditional again in revision 116727. martin */
5124 SET_FRAME_VISIBLE (f
, 1);
5125 SET_FRAME_ICONIFIED (f
, false);
5127 /* wait_reading_process_output will notice this
5128 and update the frame's display structures. */
5129 SET_FRAME_GARBAGED (f
);
5133 /* Reset top and left positions of the Window
5134 here since Windows sends a WM_MOVE message
5135 BEFORE telling us the Window is minimized
5136 when the Window is iconified, with 3000,3000
5138 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5140 inev
.kind
= DEICONIFY_EVENT
;
5141 XSETFRAME (inev
.frame_or_window
, f
);
5143 else if (! NILP (Vframe_list
)
5144 && ! NILP (XCDR (Vframe_list
)))
5145 /* Force a redisplay sooner or later
5146 to update the frame titles
5147 in case this is the second frame. */
5148 record_asynch_buffer_change ();
5151 if (EQ (get_frame_param (f
, Qfullscreen
), Qmaximized
))
5152 store_frame_param (f
, Qfullscreen
, Qnil
);
5158 if (f
&& !FRAME_ICONIFIED_P (f
) && msg
.msg
.wParam
!= SIZE_MINIMIZED
)
5161 int /* rows, columns, */ width
, height
, text_width
, text_height
;
5163 if (GetClientRect (msg
.msg
.hwnd
, &rect
)
5164 /* GetClientRect evidently returns (0, 0, 0, 0) if
5165 called on a minimized frame. Such "dimensions"
5166 aren't useful anyway. */
5167 && !(rect
.bottom
== 0
5170 && rect
.right
== 0))
5172 height
= rect
.bottom
- rect
.top
;
5173 width
= rect
.right
- rect
.left
;
5174 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, width
);
5175 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, height
);
5176 /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
5177 /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
5179 /* TODO: Clip size to the screen dimensions. */
5181 /* Even if the number of character rows and columns
5182 has not changed, the font size may have changed,
5183 so we need to check the pixel dimensions as well. */
5185 if (width
!= FRAME_PIXEL_WIDTH (f
)
5186 || height
!= FRAME_PIXEL_HEIGHT (f
)
5187 || text_width
!= FRAME_TEXT_WIDTH (f
)
5188 || text_height
!= FRAME_TEXT_HEIGHT (f
))
5190 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
5191 SET_FRAME_GARBAGED (f
);
5192 cancel_mouse_face (f
);
5193 f
->win_gravity
= NorthWestGravity
;
5198 check_visibility
= 1;
5202 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5205 if (f
== hlinfo
->mouse_face_mouse_frame
)
5207 /* If we move outside the frame, then we're
5208 certainly no longer on any text in the frame. */
5209 clear_mouse_face (hlinfo
);
5210 hlinfo
->mouse_face_mouse_frame
= 0;
5213 /* Generate a nil HELP_EVENT to cancel a help-echo.
5214 Do it only if there's something to cancel.
5215 Otherwise, the startup message is cleared when
5216 the mouse leaves the frame. */
5217 if (any_help_event_p
)
5223 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5225 dpyinfo
->grabbed
= 0;
5226 check_visibility
= 1;
5230 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5231 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5235 if (f
== hlinfo
->mouse_face_mouse_frame
)
5237 /* If we move outside the frame, then we're
5238 certainly no longer on any text in the frame. */
5239 clear_mouse_face (hlinfo
);
5240 hlinfo
->mouse_face_mouse_frame
= 0;
5243 /* Generate a nil HELP_EVENT to cancel a help-echo.
5244 Do it only if there's something to cancel.
5245 Otherwise, the startup message is cleared when
5246 the mouse leaves the frame. */
5247 if (any_help_event_p
)
5251 dpyinfo
->grabbed
= 0;
5252 check_visibility
= 1;
5256 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5260 inev
.kind
= DELETE_WINDOW_EVENT
;
5261 XSETFRAME (inev
.frame_or_window
, f
);
5266 inev
.kind
= END_SESSION_EVENT
;
5270 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5274 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
5275 XSETFRAME (inev
.frame_or_window
, f
);
5280 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5284 extern void menubar_selection_callback
5285 (struct frame
*f
, void * client_data
);
5286 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
5289 check_visibility
= 1;
5292 case WM_DISPLAYCHANGE
:
5293 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5297 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5299 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
5300 /* The new display could have a different resolution, in
5301 which case we must reconsider what fullscreen means.
5302 The following code is untested yet. */
5303 if (!NILP (fullscreen
))
5305 x_set_fullscreen (f
, fullscreen
, fullscreen
);
5306 w32fullscreen_hook (f
);
5309 DebPrint (("display change: %d %d\n",
5310 (short) LOWORD (msg
.msg
.lParam
),
5311 (short) HIWORD (msg
.msg
.lParam
)));
5314 check_visibility
= 1;
5318 case WM_EMACS_FILENOTIFY
:
5319 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5321 queue_notifications (&inev
, &msg
, f
, &count
);
5326 /* Check for messages registered at runtime. */
5327 if (msg
.msg
.message
== msh_mousewheel
)
5329 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5330 msg
.msg
.message
= WM_MOUSEWHEEL
;
5336 if (inev
.kind
!= NO_EVENT
)
5338 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5343 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5348 XSETFRAME (frame
, f
);
5354 if (NILP (help_echo_string
))
5356 help_echo_object
= help_echo_window
= Qnil
;
5360 any_help_event_p
= 1;
5361 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5362 help_echo_object
, help_echo_pos
);
5366 help_echo_string
= Qnil
;
5367 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5373 /* If the focus was just given to an autoraising frame,
5374 raise it now. FIXME: handle more than one such frame. */
5375 if (dpyinfo
->w32_pending_autoraise_frame
)
5377 x_raise_frame (dpyinfo
->w32_pending_autoraise_frame
);
5378 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
5381 /* Check which frames are still visible, if we have enqueued any user
5382 events or been notified of events that may affect visibility. We
5383 do this here because there doesn't seem to be any direct
5384 notification from Windows that the visibility of a window has
5385 changed (at least, not in all cases). */
5386 if (count
> 0 || check_visibility
)
5388 Lisp_Object tail
, frame
;
5390 FOR_EACH_FRAME (tail
, frame
)
5392 struct frame
*f
= XFRAME (frame
);
5393 /* The tooltip has been drawn already. Avoid the
5394 SET_FRAME_GARBAGED below. */
5395 if (EQ (frame
, tip_frame
))
5398 /* Check "visible" frames and mark each as obscured or not.
5399 Note that visible is nonzero for unobscured and obscured
5400 frames, but zero for hidden and iconified frames. */
5401 if (FRAME_W32_P (f
) && FRAME_VISIBLE_P (f
))
5408 /* Query clipping rectangle for the entire window area
5409 (GetWindowDC), not just the client portion (GetDC).
5410 Otherwise, the scrollbars and menubar aren't counted as
5411 part of the visible area of the frame, and we may think
5412 the frame is obscured when really a scrollbar is still
5413 visible and gets WM_PAINT messages above. */
5414 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5415 GetClipBox (hdc
, &clipbox
);
5416 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5419 obscured
= FRAME_OBSCURED_P (f
);
5421 if (clipbox
.right
== clipbox
.left
|| clipbox
.bottom
== clipbox
.top
)
5423 /* Frame has become completely obscured so mark as such (we
5424 do this by setting visible to 2 so that FRAME_VISIBLE_P
5425 is still true, but redisplay will skip it). */
5426 SET_FRAME_VISIBLE (f
, 2);
5429 DebPrint (("frame %p (%s) obscured\n", f
, SDATA (f
->name
)));
5433 /* Frame is not obscured, so mark it as such. */
5434 SET_FRAME_VISIBLE (f
, 1);
5438 SET_FRAME_GARBAGED (f
);
5439 DebPrint (("obscured frame %p (%s) found to be visible\n",
5440 f
, SDATA (f
->name
)));
5442 /* Force a redisplay sooner or later. */
5443 record_asynch_buffer_change ();
5456 /***********************************************************************
5458 ***********************************************************************/
5460 /* Set clipping for output in glyph row ROW. W is the window in which
5461 we operate. GC is the graphics context to set clipping in.
5463 ROW may be a text row or, e.g., a mode line. Text rows must be
5464 clipped to the interior of the window dedicated to text display,
5465 mode lines must be clipped to the whole window. */
5468 w32_clip_to_row (struct window
*w
, struct glyph_row
*row
,
5469 enum glyph_row_area area
, HDC hdc
)
5472 int window_x
, window_y
, window_width
;
5474 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5476 clip_rect
.left
= window_x
;
5477 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5478 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5479 clip_rect
.right
= clip_rect
.left
+ window_width
;
5480 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5482 w32_set_clip_rectangle (hdc
, &clip_rect
);
5486 /* Draw a hollow box cursor on window W in glyph row ROW. */
5489 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
5491 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5495 struct glyph
*cursor_glyph
;
5496 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5498 /* Get the glyph the cursor is on. If we can't tell because
5499 the current matrix is invalid or such, give up. */
5500 cursor_glyph
= get_phys_cursor_glyph (w
);
5501 if (cursor_glyph
== NULL
)
5507 /* Compute frame-relative coordinates for phys cursor. */
5508 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5510 /* When on R2L character, show cursor at the right edge of the
5511 glyph, unless the cursor box is as wide as the glyph or wider
5512 (the latter happens when x-stretch-cursor is non-nil). */
5513 if ((cursor_glyph
->resolved_level
& 1) != 0
5514 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5515 rect
.left
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5517 rect
.bottom
= rect
.top
+ h
;
5518 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5520 hdc
= get_frame_dc (f
);
5521 /* Set clipping, draw the rectangle, and reset clipping again. */
5522 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5523 FrameRect (hdc
, &rect
, hb
);
5525 w32_set_clip_rectangle (hdc
, NULL
);
5526 release_frame_dc (f
, hdc
);
5530 /* Draw a bar cursor on window W in glyph row ROW.
5532 Implementation note: One would like to draw a bar cursor with an
5533 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5534 Unfortunately, I didn't find a font yet that has this property set.
5538 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
,
5539 int width
, enum text_cursor_kinds kind
)
5541 struct frame
*f
= XFRAME (w
->frame
);
5542 struct glyph
*cursor_glyph
;
5544 /* If cursor is out of bounds, don't draw garbage. This can happen
5545 in mini-buffer windows when switching between echo area glyphs
5547 cursor_glyph
= get_phys_cursor_glyph (w
);
5548 if (cursor_glyph
== NULL
)
5551 /* If on an image, draw like a normal cursor. That's usually better
5552 visible than drawing a bar, esp. if the image is large so that
5553 the bar might not be in the window. */
5554 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5556 struct glyph_row
*row
;
5557 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5558 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5562 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5563 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5567 /* If the glyph's background equals the color we normally draw
5568 the bar cursor in, the bar cursor in its normal color is
5569 invisible. Use the glyph's foreground color instead in this
5570 case, on the assumption that the glyph's colors are chosen so
5571 that the glyph is legible. */
5572 if (face
->background
== cursor_color
)
5573 cursor_color
= face
->foreground
;
5575 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5577 hdc
= get_frame_dc (f
);
5578 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5580 if (kind
== BAR_CURSOR
)
5583 width
= FRAME_CURSOR_WIDTH (f
);
5584 width
= min (cursor_glyph
->pixel_width
, width
);
5586 w
->phys_cursor_width
= width
;
5588 /* If the character under cursor is R2L, draw the bar cursor
5589 on the right of its glyph, rather than on the left. */
5590 if ((cursor_glyph
->resolved_level
& 1) != 0)
5591 x
+= cursor_glyph
->pixel_width
- width
;
5593 w32_fill_area (f
, hdc
, cursor_color
, x
,
5594 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5595 width
, row
->height
);
5597 else /* HBAR_CURSOR */
5599 int dummy_x
, dummy_y
, dummy_h
;
5602 width
= row
->height
;
5604 width
= min (row
->height
, width
);
5606 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
5607 &dummy_y
, &dummy_h
);
5608 if ((cursor_glyph
->resolved_level
& 1) != 0
5609 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5610 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5611 w32_fill_area (f
, hdc
, cursor_color
, x
,
5612 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5613 row
->height
- width
),
5614 w
->phys_cursor_width
, width
);
5617 w32_set_clip_rectangle (hdc
, NULL
);
5618 release_frame_dc (f
, hdc
);
5623 /* RIF: Define cursor CURSOR on frame F. */
5626 w32_define_frame_cursor (struct frame
*f
, Cursor cursor
)
5628 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5632 /* RIF: Clear area on frame F. */
5635 w32_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
5639 hdc
= get_frame_dc (f
);
5640 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5641 release_frame_dc (f
, hdc
);
5644 /* RIF: Draw or clear cursor on window W. */
5647 w32_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
,
5648 int x
, int y
, enum text_cursor_kinds cursor_type
,
5649 int cursor_width
, bool on_p
, bool active_p
)
5653 /* If the user wants to use the system caret, make sure our own
5654 cursor remains invisible. */
5655 if (w32_use_visible_system_caret
)
5657 /* Call to erase_phys_cursor here seems to use the
5658 wrong values of w->phys_cursor, as they have been
5659 overwritten before this function was called. */
5660 if (w
->phys_cursor_type
!= NO_CURSOR
)
5661 erase_phys_cursor (w
);
5663 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5664 w
->phys_cursor_width
= -1;
5668 w
->phys_cursor_type
= cursor_type
;
5671 w
->phys_cursor_on_p
= true;
5673 /* If this is the active cursor, we need to track it with the
5674 system caret, so third party software like screen magnifiers
5675 and speech synthesizers can follow the cursor. */
5678 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5679 HWND hwnd
= FRAME_W32_WINDOW (f
);
5682 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5684 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5685 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5686 w32_system_caret_window
= w
;
5687 w32_system_caret_hdr_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
5688 w32_system_caret_mode_height
= WINDOW_MODE_LINE_HEIGHT (w
);
5690 PostMessage (hwnd
, WM_IME_STARTCOMPOSITION
, 0, 0);
5692 /* If the size of the active cursor changed, destroy the old
5694 if (w32_system_caret_hwnd
5695 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5696 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5698 w32_system_caret_height
= w
->phys_cursor_height
;
5700 /* Move the system caret. */
5701 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5704 if (glyph_row
->exact_window_width_line_p
5705 && (glyph_row
->reversed_p
5706 ? (w
->phys_cursor
.hpos
< 0)
5707 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
5709 glyph_row
->cursor_in_fringe_p
= true;
5710 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
5714 switch (cursor_type
)
5716 case HOLLOW_BOX_CURSOR
:
5717 x_draw_hollow_cursor (w
, glyph_row
);
5720 case FILLED_BOX_CURSOR
:
5721 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5725 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5729 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5733 w
->phys_cursor_width
= 0;
5747 x_bitmap_icon (struct frame
*f
, Lisp_Object icon
)
5750 HANDLE small_icon
= NULL
;
5752 if (FRAME_W32_WINDOW (f
) == 0)
5756 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5757 else if (STRINGP (icon
))
5759 /* Load the main icon from the named file. */
5760 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5761 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5762 /* Try to load a small icon to go with it. */
5763 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5764 GetSystemMetrics (SM_CXSMICON
),
5765 GetSystemMetrics (SM_CYSMICON
),
5768 else if (SYMBOLP (icon
))
5772 if (EQ (icon
, intern ("application")))
5773 name
= (LPCTSTR
) IDI_APPLICATION
;
5774 else if (EQ (icon
, intern ("hand")))
5775 name
= (LPCTSTR
) IDI_HAND
;
5776 else if (EQ (icon
, intern ("question")))
5777 name
= (LPCTSTR
) IDI_QUESTION
;
5778 else if (EQ (icon
, intern ("exclamation")))
5779 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5780 else if (EQ (icon
, intern ("asterisk")))
5781 name
= (LPCTSTR
) IDI_ASTERISK
;
5782 else if (EQ (icon
, intern ("winlogo")))
5783 name
= (LPCTSTR
) IDI_WINLOGO
;
5787 main_icon
= LoadIcon (NULL
, name
);
5792 if (main_icon
== NULL
)
5795 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5796 (LPARAM
) main_icon
);
5798 /* If there is a small icon that goes with it, set that too. */
5800 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5801 (LPARAM
) small_icon
);
5807 /************************************************************************
5809 ************************************************************************/
5811 /* Display Error Handling functions not used on W32. Listing them here
5812 helps diff stay in step when comparing w32term.c with xterm.c.
5814 x_error_catcher (display, error)
5815 x_catch_errors (dpy)
5816 x_catch_errors_unwind (old_val)
5817 x_check_errors (dpy, format)
5818 x_fully_uncatch_errors ()
5819 x_had_errors_p (dpy)
5820 x_clear_errors (dpy)
5821 x_uncatch_errors (dpy, count)
5823 x_connection_signal (signalnum)
5824 x_connection_closed (dpy, error_message)
5825 x_error_quitter (display, error)
5826 x_error_handler (display, error)
5827 x_io_error_quitter (display)
5832 /* Changing the font of the frame. */
5835 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
5837 struct font
*font
= XFONT_OBJECT (font_object
);
5838 int unit
, font_ascent
, font_descent
;
5841 fontset
= fontset_from_font (font_object
);
5842 FRAME_FONTSET (f
) = fontset
;
5843 if (FRAME_FONT (f
) == font
)
5844 /* This font is already set in frame F. There's nothing more to
5848 FRAME_FONT (f
) = font
;
5849 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5850 FRAME_COLUMN_WIDTH (f
) = unit
= font
->average_width
;
5851 get_font_ascent_descent (font
, &font_ascent
, &font_descent
);
5852 FRAME_LINE_HEIGHT (f
) = font_ascent
+ font_descent
;
5854 /* Compute number of scrollbar columns. */
5855 unit
= FRAME_COLUMN_WIDTH (f
);
5856 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5857 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5858 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
5861 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
5862 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) =
5863 FRAME_CONFIG_SCROLL_BAR_COLS (f
) * unit
;
5866 /* Now make the frame display the given font. */
5867 if (FRAME_X_WINDOW (f
) != 0)
5869 /* Don't change the size of a tip frame; there's no point in
5870 doing it because it's done in Fx_show_tip, and it leads to
5871 problems because the tip frame has no widget. */
5872 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5873 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
5874 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
5878 /* X version sets font of input methods here also. */
5884 /***********************************************************************
5885 TODO: W32 Input Methods
5886 ***********************************************************************/
5887 /* Listing missing functions from xterm.c helps diff stay in step.
5889 xim_destroy_callback (xim, client_data, call_data)
5890 xim_open_dpy (dpyinfo, resource_name)
5892 xim_instantiate_callback (display, client_data, call_data)
5893 xim_initialize (dpyinfo, resource_name)
5894 xim_close_dpy (dpyinfo)
5899 /* Calculate the absolute position in frame F
5900 from its current recorded position values and gravity. */
5903 x_calc_absolute_position (struct frame
*f
)
5905 int flags
= f
->size_hint_flags
;
5907 /* The sum of the widths of the frame's left and right borders, and
5908 the sum of the heights of the frame's top and bottom borders (in
5909 pixels) drawn by Windows. */
5910 unsigned int left_right_borders_width
, top_bottom_borders_height
;
5912 /* Try to get the actual values of these two variables. We compute
5913 the border width (height) by subtracting the width (height) of
5914 the frame's client area from the width (height) of the frame's
5916 WINDOWPLACEMENT wp
= { 0 };
5917 RECT client_rect
= { 0 };
5919 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
5920 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
5922 left_right_borders_width
=
5923 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
5924 (client_rect
.right
- client_rect
.left
);
5926 top_bottom_borders_height
=
5927 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
5928 (client_rect
.bottom
- client_rect
.top
);
5932 /* Use sensible default values. */
5933 left_right_borders_width
= 8;
5934 top_bottom_borders_height
= 32;
5937 /* With multiple monitors, we can legitimately get negative
5938 coordinates (for monitors above or to the left of the primary
5939 monitor). Find the display origin to ensure negative positions
5940 are computed correctly (Bug#21173). */
5941 int display_left
= 0;
5942 int display_top
= 0;
5943 if (flags
& (XNegative
| YNegative
))
5947 list
= Fw32_display_monitor_attributes_list (Qnil
);
5948 while (CONSP (list
))
5950 Lisp_Object attributes
= CAR(list
);
5951 Lisp_Object geometry
;
5952 Lisp_Object monitor_left
, monitor_top
;
5956 geometry
= Fassoc (Qgeometry
, attributes
);
5957 if (!NILP (geometry
))
5959 monitor_left
= Fnth (make_number (1), geometry
);
5960 monitor_top
= Fnth (make_number (2), geometry
);
5962 display_left
= min (display_left
, XINT (monitor_left
));
5963 display_top
= min (display_top
, XINT (monitor_top
));
5968 /* Treat negative positions as relative to the rightmost bottommost
5969 position that fits on the screen. */
5970 if (flags
& XNegative
)
5971 f
->left_pos
= (x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
5973 - FRAME_PIXEL_WIDTH (f
)
5975 - (left_right_borders_width
- 1));
5977 if (flags
& YNegative
)
5978 f
->top_pos
= (x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
5980 - FRAME_PIXEL_HEIGHT (f
)
5982 - (top_bottom_borders_height
- 1));
5984 /* The left_pos and top_pos are now relative to the top and left
5985 screen edges, so the flags should correspond. */
5986 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5989 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5990 to really change the position, and 0 when calling from
5991 x_make_frame_visible (in that case, XOFF and YOFF are the current
5992 position values). It is -1 when calling from x_set_frame_parameters,
5993 which means, do adjust for borders but don't change the gravity. */
5996 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
,
5999 int modified_top
, modified_left
;
6001 if (change_gravity
> 0)
6005 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6007 f
->size_hint_flags
|= XNegative
;
6009 f
->size_hint_flags
|= YNegative
;
6010 f
->win_gravity
= NorthWestGravity
;
6012 x_calc_absolute_position (f
);
6015 x_wm_set_size_hint (f
, (long) 0, false);
6017 modified_left
= f
->left_pos
;
6018 modified_top
= f
->top_pos
;
6020 my_set_window_pos (FRAME_W32_WINDOW (f
),
6022 modified_left
, modified_top
,
6024 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6029 w32fullscreen_hook (struct frame
*f
)
6031 if (FRAME_VISIBLE_P (f
))
6033 HWND hwnd
= FRAME_W32_WINDOW(f
);
6034 DWORD dwStyle
= GetWindowLong (hwnd
, GWL_STYLE
);
6036 enum fullscreen_type prev_fsmode
= FRAME_PREV_FSMODE (f
);
6039 f
->want_fullscreen
&= ~FULLSCREEN_WAIT
;
6041 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_NONE
)
6042 GetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6044 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_BOTH
)
6046 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
| WS_OVERLAPPEDWINDOW
);
6047 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6049 else if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_HEIGHT
6050 || FRAME_PREV_FSMODE (f
) == FULLSCREEN_WIDTH
)
6051 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6053 FRAME_PREV_FSMODE (f
) = f
->want_fullscreen
;
6055 if (f
->want_fullscreen
== FULLSCREEN_NONE
)
6056 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6057 else if (f
->want_fullscreen
== FULLSCREEN_MAXIMIZED
)
6059 if (prev_fsmode
== FULLSCREEN_BOTH
|| prev_fsmode
== FULLSCREEN_WIDTH
6060 || prev_fsmode
== FULLSCREEN_HEIGHT
)
6061 /* Make window normal since otherwise the subsequent
6062 maximization might fail in some cases. */
6063 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6064 ShowWindow (hwnd
, SW_MAXIMIZE
);
6066 else if (f
->want_fullscreen
== FULLSCREEN_BOTH
)
6068 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6070 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6071 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6072 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
& ~WS_OVERLAPPEDWINDOW
);
6073 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6074 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
,
6075 SWP_NOOWNERZORDER
| SWP_FRAMECHANGED
);
6077 (f
, FRAME_PIXEL_TO_TEXT_WIDTH (f
, rect
.right
- rect
.left
),
6078 FRAME_PIXEL_TO_TEXT_HEIGHT (f
, (rect
.bottom
- rect
.top
6079 - menu_bar_height
)),
6084 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6085 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6086 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6087 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6088 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, 0);
6090 if (f
->want_fullscreen
== FULLSCREEN_WIDTH
)
6092 int border_width
= GetSystemMetrics (SM_CXFRAME
);
6095 (f
, (FRAME_PIXEL_TO_TEXT_WIDTH
6096 (f
, rect
.right
- rect
.left
- 2 * border_width
)),
6101 int border_height
= GetSystemMetrics (SM_CYFRAME
);
6102 /* Won't work for wrapped menu bar. */
6103 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6104 int title_height
= GetSystemMetrics (SM_CYCAPTION
);
6107 (f
, 0, (FRAME_PIXEL_TO_TEXT_HEIGHT
6108 (f
, rect
.bottom
- rect
.top
- 2 * border_height
6109 - title_height
- menu_bar_height
)),
6114 f
->want_fullscreen
= FULLSCREEN_NONE
;
6117 if (f
->want_fullscreen
== FULLSCREEN_BOTH
6118 || f
->want_fullscreen
== FULLSCREEN_WIDTH
6119 || f
->want_fullscreen
== FULLSCREEN_HEIGHT
)
6120 do_pending_window_change (0);
6124 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
6127 /* Call this to change the size of frame F's x-window.
6128 If CHANGE_GRAVITY, change to top-left-corner window gravity
6129 for this size change and subsequent size changes.
6130 Otherwise we leave the window gravity unchanged. */
6133 x_set_window_size (struct frame
*f
, bool change_gravity
,
6134 int width
, int height
, bool pixelwise
)
6136 int pixelwidth
, pixelheight
;
6137 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
6140 int menu_bar_height
;
6144 /* Get the height of the menu bar here. It's used below to detect
6145 whether the menu bar is wrapped. It's also used to specify the
6146 third argument for AdjustWindowRect. FRAME_EXTERNAL_MENU_BAR which
6147 has been used before for that reason is unreliable because it only
6148 specifies whether we _want_ a menu bar for this frame and not
6149 whether this frame _has_ a menu bar. See bug#22105. */
6150 info
.cbSize
= sizeof (info
);
6151 info
.rcBar
.top
= info
.rcBar
.bottom
= 0;
6152 GetMenuBarInfo (FRAME_W32_WINDOW (f
), 0xFFFFFFFD, 0, &info
);
6153 menu_bar_height
= info
.rcBar
.bottom
- info
.rcBar
.top
;
6157 pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
6158 pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
6162 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
);
6163 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
);
6166 if (w32_add_wrapped_menu_bar_lines
)
6168 /* When the menu bar wraps sending a SetWindowPos shrinks the
6169 height of the frame then the wrapped menu bar lines are not
6170 accounted for (Bug#15174 and Bug#18720). Here we add these
6171 extra lines to the frame height. */
6172 int default_menu_bar_height
;
6174 /* Why is (apparently) SM_CYMENUSIZE needed here instead of
6176 default_menu_bar_height
= GetSystemMetrics (SM_CYMENUSIZE
);
6178 if ((default_menu_bar_height
> 0)
6179 && (menu_bar_height
> default_menu_bar_height
)
6180 && ((menu_bar_height
% default_menu_bar_height
) == 0))
6181 pixelheight
= pixelheight
+ menu_bar_height
- default_menu_bar_height
;
6184 f
->win_gravity
= NorthWestGravity
;
6185 x_wm_set_size_hint (f
, (long) 0, false);
6187 rect
.left
= rect
.top
= 0;
6188 rect
.right
= pixelwidth
;
6189 rect
.bottom
= pixelheight
;
6191 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
, menu_bar_height
> 0);
6193 if (!(f
->after_make_frame
)
6194 && !(f
->want_fullscreen
& FULLSCREEN_WAIT
)
6195 && FRAME_VISIBLE_P (f
))
6199 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6201 if (EQ (fullscreen
, Qmaximized
)
6202 || EQ (fullscreen
, Qfullboth
)
6203 || EQ (fullscreen
, Qfullwidth
))
6205 rect
.left
= window_rect
.left
;
6206 rect
.right
= window_rect
.right
;
6209 if (EQ (fullscreen
, Qmaximized
)
6210 || EQ (fullscreen
, Qfullboth
)
6211 || EQ (fullscreen
, Qfullheight
))
6213 rect
.top
= window_rect
.top
;
6214 rect
.bottom
= window_rect
.bottom
;
6219 if (pixelwidth
> 0 || pixelheight
> 0)
6221 frame_size_history_add
6222 (f
, Qx_set_window_size_1
, width
, height
,
6223 list2 (Fcons (make_number (pixelwidth
),
6224 make_number (pixelheight
)),
6225 Fcons (make_number (rect
.right
- rect
.left
),
6226 make_number (rect
.bottom
- rect
.top
))));
6228 my_set_window_pos (FRAME_W32_WINDOW (f
), NULL
,
6230 rect
.right
- rect
.left
,
6231 rect
.bottom
- rect
.top
,
6232 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6234 change_frame_size (f
,
6236 ? 0 : FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
)),
6238 ? 0 : FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
)),
6240 SET_FRAME_GARBAGED (f
);
6242 /* If cursor was outside the new size, mark it as off. */
6243 mark_window_cursors_off (XWINDOW (f
->root_window
));
6245 /* Clear out any recollection of where the mouse highlighting was,
6246 since it might be in a place that's outside the new frame size.
6247 Actually checking whether it is outside is a pain in the neck,
6248 so don't try--just let the highlighting be done afresh with new
6250 cancel_mouse_face (f
);
6255 do_pending_window_change (false);
6258 /* Mouse warping. */
6261 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
6270 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
6271 pt
.x
= rect
.left
+ pix_x
;
6272 pt
.y
= rect
.top
+ pix_y
;
6273 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
6275 /* When "mouse trails" are in effect, moving the mouse cursor
6276 sometimes leaves behind an annoying "ghost" of the pointer.
6277 Avoid that by momentarily switching off mouse trails. */
6278 if (os_subtype
== OS_NT
6279 && w32_major_version
+ w32_minor_version
>= 6)
6280 ret
= SystemParametersInfo (SPI_GETMOUSETRAILS
, 0, &trail_num
, 0);
6281 SetCursorPos (pt
.x
, pt
.y
);
6283 SystemParametersInfo (SPI_SETMOUSETRAILS
, trail_num
, NULL
, 0);
6289 /* focus shifting, raising and lowering. */
6292 x_focus_frame (struct frame
*f
)
6295 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6298 /* Give input focus to frame. */
6301 /* Try not to change its Z-order if possible. */
6302 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
6303 my_set_focus (f
, FRAME_W32_WINDOW (f
));
6306 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6310 /* Raise frame F. */
6312 x_raise_frame (struct frame
*f
)
6316 /* Strictly speaking, raise-frame should only change the frame's Z
6317 order, leaving input focus unchanged. This is reasonable behavior
6318 on X where the usual policy is point-to-focus. However, this
6319 behavior would be very odd on Windows where the usual policy is
6322 On X, if the mouse happens to be over the raised frame, it gets
6323 input focus anyway (so the window with focus will never be
6324 completely obscured) - if not, then just moving the mouse over it
6325 is sufficient to give it focus. On Windows, the user must actually
6326 click on the frame (preferably the title bar so as not to move
6327 point), which is more awkward. Also, no other Windows program
6328 raises a window to the top but leaves another window (possibly now
6329 completely obscured) with input focus.
6331 Because there is a system setting on Windows that allows the user
6332 to choose the point to focus policy, we make the strict semantics
6333 optional, but by default we grab focus when raising. */
6335 if (NILP (Vw32_grab_focus_on_raise
))
6337 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6338 not already the foreground application: the frame is raised
6339 above all other frames belonging to us, but not above the
6340 current top window. To achieve that, we have to resort to this
6341 more cumbersome method. */
6343 HDWP handle
= BeginDeferWindowPos (2);
6346 handle
= DeferWindowPos (handle
,
6347 FRAME_W32_WINDOW (f
),
6350 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6353 handle
= DeferWindowPos (handle
,
6354 GetForegroundWindow (),
6355 FRAME_W32_WINDOW (f
),
6357 SWP_NOSIZE
| SWP_NOMOVE
|
6360 EndDeferWindowPos (handle
);
6366 my_bring_window_to_top (FRAME_W32_WINDOW (f
));
6372 /* Lower frame F. */
6374 x_lower_frame (struct frame
*f
)
6377 my_set_window_pos (FRAME_W32_WINDOW (f
),
6380 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6385 w32_frame_raise_lower (struct frame
*f
, bool raise_flag
)
6387 if (! FRAME_W32_P (f
))
6396 /* Change of visibility. */
6398 /* This tries to wait until the frame is really visible.
6399 However, if the window manager asks the user where to position
6400 the frame, this will return before the user finishes doing that.
6401 The frame will not actually be visible at that time,
6402 but it will become visible later when the window manager
6403 finishes with it. */
6406 x_make_frame_visible (struct frame
*f
)
6410 x_set_bitmap_icon (f
);
6412 if (! FRAME_VISIBLE_P (f
))
6414 /* We test FRAME_GARBAGED_P here to make sure we don't
6415 call x_set_offset a second time
6416 if we get to x_make_frame_visible a second time
6417 before the window gets really visible. */
6418 if (! FRAME_ICONIFIED_P (f
)
6419 && ! f
->output_data
.w32
->asked_for_visible
)
6424 /* Adjust vertical window position in order to avoid being
6425 covered by a taskbar placed at the bottom of the desktop. */
6426 SystemParametersInfo (SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6427 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6428 if (window_rect
.bottom
> workarea_rect
.bottom
6429 && window_rect
.top
> workarea_rect
.top
)
6430 f
->top_pos
= max (window_rect
.top
6431 - window_rect
.bottom
+ workarea_rect
.bottom
,
6434 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6437 f
->output_data
.w32
->asked_for_visible
= 1;
6439 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
6440 causes unexpected behavior when unminimizing frames that were
6441 previously maximized. But only SW_SHOWNORMAL works properly for
6442 frames that were truely hidden (using make-frame-invisible), so
6443 we need it to avoid Bug#5482. It seems that iconified is only
6444 set for minimized windows that are still visible, so use that to
6445 determine the appropriate flag to pass ShowWindow. */
6446 my_show_window (f
, FRAME_W32_WINDOW (f
),
6447 FRAME_ICONIFIED_P (f
) ? SW_RESTORE
: SW_SHOWNORMAL
);
6450 /* Synchronize to ensure Emacs knows the frame is visible
6451 before we do anything else. We do this loop with input not blocked
6452 so that incoming events are handled. */
6457 /* This must come after we set COUNT. */
6460 XSETFRAME (frame
, f
);
6462 /* Wait until the frame is visible. Process X events until a
6463 MapNotify event has been seen, or until we think we won't get a
6464 MapNotify at all.. */
6465 for (count
= input_signal_count
+ 10;
6466 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6468 /* Force processing of queued events. */
6469 /* TODO: x_sync equivalent? */
6471 /* Machines that do polling rather than SIGIO have been observed
6472 to go into a busy-wait here. So we'll fake an alarm signal
6473 to let the handler know that there's something to be read.
6474 We used to raise a real alarm, but it seems that the handler
6475 isn't always enabled here. This is probably a bug. */
6476 if (input_polling_used ())
6478 /* It could be confusing if a real alarm arrives while processing
6479 the fake one. Turn it off and let the handler reset it. */
6480 int old_poll_suppress_count
= poll_suppress_count
;
6481 poll_suppress_count
= 1;
6482 poll_for_input_1 ();
6483 poll_suppress_count
= old_poll_suppress_count
;
6489 /* Change from mapped state to withdrawn state. */
6491 /* Make the frame visible (mapped and not iconified). */
6494 x_make_frame_invisible (struct frame
*f
)
6496 /* Don't keep the highlight on an invisible frame. */
6497 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6498 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6502 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6504 /* We can't distinguish this from iconification
6505 just by the event that we get from the server.
6506 So we can't win using the usual strategy of letting
6507 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6508 and synchronize with the server to make sure we agree. */
6509 SET_FRAME_VISIBLE (f
, 0);
6510 SET_FRAME_ICONIFIED (f
, false);
6515 /* Change window state from mapped to iconified. */
6518 x_iconify_frame (struct frame
*f
)
6520 /* Don't keep the highlight on an invisible frame. */
6521 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6522 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6524 if (FRAME_ICONIFIED_P (f
))
6529 x_set_bitmap_icon (f
);
6531 /* Simulate the user minimizing the frame. */
6532 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
6534 SET_FRAME_VISIBLE (f
, 0);
6535 SET_FRAME_ICONIFIED (f
, true);
6541 /* Free X resources of frame F. */
6544 x_free_frame_resources (struct frame
*f
)
6546 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6547 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
6551 /* We must free faces before destroying windows because some
6552 font-driver (e.g. xft) access a window while finishing a
6554 free_frame_faces (f
);
6556 if (FRAME_W32_WINDOW (f
))
6557 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6559 free_frame_menubar (f
);
6561 xfree (f
->output_data
.w32
);
6562 f
->output_data
.w32
= NULL
;
6564 if (f
== dpyinfo
->w32_focus_frame
)
6565 dpyinfo
->w32_focus_frame
= 0;
6566 if (f
== dpyinfo
->w32_focus_event_frame
)
6567 dpyinfo
->w32_focus_event_frame
= 0;
6568 if (f
== dpyinfo
->x_highlight_frame
)
6569 dpyinfo
->x_highlight_frame
= 0;
6570 if (f
== hlinfo
->mouse_face_mouse_frame
)
6571 reset_mouse_highlight (hlinfo
);
6577 /* Destroy the window of frame F. */
6579 x_destroy_window (struct frame
*f
)
6581 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6583 x_free_frame_resources (f
);
6584 dpyinfo
->reference_count
--;
6588 /* Setting window manager hints. */
6590 /* Set the normal size hints for the window manager, for frame F.
6591 FLAGS is the flags word to use--or 0 meaning preserve the flags
6592 that the window now has.
6593 If USER_POSITION, set the USPosition
6594 flag (this is useful when FLAGS is 0). */
6596 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
6598 Window window
= FRAME_W32_WINDOW (f
);
6602 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6603 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6604 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6605 SetWindowLong (window
, WND_VSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_WIDTH (f
));
6606 SetWindowLong (window
, WND_HSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_HEIGHT (f
));
6611 /***********************************************************************
6613 ***********************************************************************/
6617 /* Check that FONT is valid on frame F. It is if it can be found in F's
6621 x_check_font (struct frame
*f
, struct font
*font
)
6623 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
6624 if (font
->driver
->check
)
6625 eassert (font
->driver
->check (f
, font
) == 0);
6628 #endif /* GLYPH_DEBUG */
6630 /* Show hourglass cursor on frame F. */
6633 w32_show_hourglass (struct frame
*f
)
6635 if (!menubar_in_use
&& !current_popup_menu
)
6637 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6639 w32
->hourglass_p
= 1;
6640 SetCursor (w32
->hourglass_cursor
);
6644 /* Hide hourglass cursor on frame F. */
6647 w32_hide_hourglass (struct frame
*f
)
6649 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6651 w32
->hourglass_p
= 0;
6652 if (f
->pointer_invisible
)
6655 SetCursor (w32
->current_cursor
);
6658 /* FIXME: old code did that, but I don't know why. Anyway,
6659 this is used for non-GUI frames (see cancel_hourglass). */
6662 w32_arrow_cursor (void)
6664 SetCursor (w32_load_cursor (IDC_ARROW
));
6668 w32_toggle_invisible_pointer (struct frame
*f
, bool invisible
)
6672 if (f
->pointer_invisible
!= invisible
)
6674 f
->pointer_invisible
= invisible
;
6675 w32_define_cursor (FRAME_W32_WINDOW (f
),
6676 f
->output_data
.w32
->current_cursor
);
6682 /***********************************************************************
6684 ***********************************************************************/
6686 static int w32_initialized
= 0;
6689 w32_initialize_display_info (Lisp_Object display_name
)
6691 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6693 memset (dpyinfo
, 0, sizeof (*dpyinfo
));
6695 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
6696 dpyinfo
->w32_id_name
= xmalloc (SCHARS (Vinvocation_name
)
6697 + SCHARS (Vsystem_name
) + 2);
6698 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6699 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6701 /* Default Console mode values - overridden when running in GUI mode
6702 with values obtained from system metrics. */
6705 dpyinfo
->n_planes
= 1;
6706 dpyinfo
->n_cbits
= 4;
6707 dpyinfo
->n_fonts
= 0;
6708 dpyinfo
->smallest_font_height
= 1;
6709 dpyinfo
->smallest_char_width
= 1;
6710 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6711 dpyinfo
->horizontal_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6712 /* TODO: dpyinfo->gray */
6714 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
6717 /* Create an xrdb-style database of resources to supersede registry settings.
6718 The database is just a concatenation of C strings, finished by an additional
6719 \0. The strings are submitted to some basic normalization, so
6721 [ *]option[ *]:[ *]value...
6727 but any whitespace following value is not removed. */
6730 w32_make_rdb (char *xrm_option
)
6732 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6733 char *current
= buffer
;
6736 int before_value
= 0;
6750 if (in_option
&& (ch
== ':'))
6755 else if (before_value
)
6760 else if (!(in_option
|| before_value
))
6771 extern frame_parm_handler w32_frame_parm_handlers
[];
6773 static struct redisplay_interface w32_redisplay_interface
=
6775 w32_frame_parm_handlers
,
6779 x_clear_end_of_line
,
6781 x_after_update_window_line
,
6782 x_update_window_begin
,
6783 x_update_window_end
,
6784 0, /* flush_display */
6785 x_clear_window_mouse_face
,
6786 x_get_glyph_overhangs
,
6787 x_fix_overlapping_area
,
6788 w32_draw_fringe_bitmap
,
6789 w32_define_fringe_bitmap
,
6790 w32_destroy_fringe_bitmap
,
6791 w32_compute_glyph_string_overhangs
,
6792 x_draw_glyph_string
,
6793 w32_define_frame_cursor
,
6794 w32_clear_frame_area
,
6795 w32_draw_window_cursor
,
6796 w32_draw_vertical_window_border
,
6797 w32_draw_window_divider
,
6798 w32_shift_glyphs_for_insert
,
6803 static void x_delete_terminal (struct terminal
*term
);
6805 static struct terminal
*
6806 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6808 struct terminal
*terminal
;
6810 terminal
= create_terminal (output_w32
, &w32_redisplay_interface
);
6812 terminal
->display_info
.w32
= dpyinfo
;
6813 dpyinfo
->terminal
= terminal
;
6815 /* MSVC does not type K&R functions with no arguments correctly, and
6816 so we must explicitly cast them. */
6817 terminal
->clear_frame_hook
= x_clear_frame
;
6818 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6819 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6820 terminal
->ring_bell_hook
= w32_ring_bell
;
6821 terminal
->toggle_invisible_pointer_hook
= w32_toggle_invisible_pointer
;
6822 terminal
->update_begin_hook
= x_update_begin
;
6823 terminal
->update_end_hook
= x_update_end
;
6824 terminal
->read_socket_hook
= w32_read_socket
;
6825 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6826 terminal
->mouse_position_hook
= w32_mouse_position
;
6827 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6828 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6829 terminal
->fullscreen_hook
= w32fullscreen_hook
;
6830 terminal
->menu_show_hook
= w32_menu_show
;
6831 terminal
->popup_dialog_hook
= w32_popup_dialog
;
6832 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6833 terminal
->set_horizontal_scroll_bar_hook
= w32_set_horizontal_scroll_bar
;
6834 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6835 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6836 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6837 terminal
->delete_frame_hook
= x_destroy_window
;
6838 terminal
->delete_terminal_hook
= x_delete_terminal
;
6839 /* Other hooks are NULL by default. */
6841 /* We don't yet support separate terminals on W32, so don't try to share
6842 keyboards between virtual terminals that are on the same physical
6843 terminal like X does. */
6844 terminal
->kboard
= allocate_kboard (Qw32
);
6845 /* Don't let the initial kboard remain current longer than necessary.
6846 That would cause problems if a file loaded on startup tries to
6847 prompt in the mini-buffer. */
6848 if (current_kboard
== initial_kboard
)
6849 current_kboard
= terminal
->kboard
;
6850 terminal
->kboard
->reference_count
++;
6856 x_delete_terminal (struct terminal
*terminal
)
6858 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
6860 /* Protect against recursive calls. delete_frame in
6861 delete_terminal calls us back when it deletes our last frame. */
6862 if (!terminal
->name
)
6867 x_delete_display (dpyinfo
);
6871 struct w32_display_info
*
6872 w32_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
6874 struct w32_display_info
*dpyinfo
;
6875 struct terminal
*terminal
;
6880 if (!w32_initialized
)
6883 w32_initialized
= 1;
6886 w32_initialize_display_info (display_name
);
6888 dpyinfo
= &one_w32_display_info
;
6889 terminal
= w32_create_terminal (dpyinfo
);
6891 /* Set the name of the terminal. */
6892 terminal
->name
= xlispstrdup (display_name
);
6894 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6896 /* Put this display on the chain. */
6897 dpyinfo
->next
= x_display_list
;
6898 x_display_list
= dpyinfo
;
6902 dpyinfo
->root_window
= GetDesktopWindow ();
6903 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6904 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6905 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6906 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6907 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6908 ReleaseDC (NULL
, hdc
);
6910 /* initialize palette with white and black */
6913 w32_defined_color (0, "white", &color
, 1);
6914 w32_defined_color (0, "black", &color
, 1);
6918 /* Add the default keyboard. When !WINDOWSNT, we're using the
6919 standard Emacs console handling machinery and don't need an
6920 explicit FD here. */
6921 add_keyboard_wait_descriptor (0);
6923 /* /dev/windows wakes us up when we have a thread message pending. */
6924 add_keyboard_wait_descriptor (w32_message_fd
);
6927 /* Create Fringe Bitmaps and store them for later use.
6929 On W32, bitmaps are all unsigned short, as Windows requires
6930 bitmap data to be Word aligned. For some reason they are
6931 horizontally reflected compared to how they appear on X, so we
6932 need to bitswap and convert to unsigned shorts before creating
6934 w32_init_fringe (terminal
->rif
);
6941 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6943 x_delete_display (struct w32_display_info
*dpyinfo
)
6945 /* FIXME: the only display info apparently can't be deleted. */
6946 /* free palette table */
6948 struct w32_palette_entry
* plist
;
6950 plist
= dpyinfo
->color_list
;
6953 struct w32_palette_entry
* pentry
= plist
;
6954 plist
= plist
->next
;
6957 dpyinfo
->color_list
= NULL
;
6958 if (dpyinfo
->palette
)
6959 DeleteObject (dpyinfo
->palette
);
6961 w32_reset_fringes ();
6965 /* Set up use of W32. */
6968 w32_init_main_thread (void)
6970 dwMainThreadId
= GetCurrentThreadId ();
6971 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6972 GetCurrentProcess (), &hMainThread
, 0, TRUE
,
6973 DUPLICATE_SAME_ACCESS
);
6978 DWORD WINAPI
w32_msg_worker (void * arg
);
6981 w32_initialize (void)
6984 HRESULT (WINAPI
* set_user_model
) (const wchar_t * id
);
6988 w32_system_caret_hwnd
= NULL
;
6989 w32_system_caret_height
= 0;
6990 w32_system_caret_x
= 0;
6991 w32_system_caret_y
= 0;
6993 /* On Windows 7 and later, we need to set the user model ID
6994 to associate emacsclient launched files with Emacs frames
6996 shell
= GetModuleHandle ("shell32.dll");
7000 = (void *) GetProcAddress (shell
,
7001 "SetCurrentProcessExplicitAppUserModelID");
7003 /* If the function is defined, then we are running on Windows 7
7004 or newer, and the UI uses this to group related windows
7005 together. Since emacs, runemacs, emacsclient are related, we
7006 want them grouped even though the executables are different,
7007 so we need to set a consistent ID between them. */
7009 set_user_model (L
"GNU.Emacs");
7013 if ((w32_message_fd
= emacs_open ("/dev/windows", O_RDWR
, 0)) == -1)
7014 fatal ("opening /dev/windows: %s", strerror (errno
));
7017 /* Initialize w32_use_visible_system_caret based on whether a screen
7018 reader is in use. */
7019 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
7020 &w32_use_visible_system_caret
, 0))
7021 w32_use_visible_system_caret
= 0;
7023 any_help_event_p
= 0;
7025 /* Initialize input mode: interrupt_input off, no flow control, allow
7026 8 bit character input, standard quit char. */
7027 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
7030 LCID input_locale_id
= LOWORD (GetKeyboardLayout (0));
7031 w32_keyboard_codepage
= codepage_for_locale (input_locale_id
);
7034 /* Create the window thread - it will terminate itself when the app
7038 /* Wait for thread to start */
7042 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
7044 hWindowsThread
= CreateThread (NULL
, 0,
7046 0, 0, &dwWindowsThreadId
);
7048 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
7051 /* It is desirable that mainThread should have the same notion of
7052 focus window and active window as windowsThread. Unfortunately, the
7053 following call to AttachThreadInput, which should do precisely what
7054 we need, causes major problems when Emacs is linked as a console
7055 program. Unfortunately, we have good reasons for doing that, so
7056 instead we need to send messages to windowsThread to make some API
7057 calls for us (ones that affect, or depend on, the active/focus
7059 #ifdef ATTACH_THREADS
7060 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
7063 /* Dynamically link to optional system components. */
7065 HMODULE user_lib
= GetModuleHandle ("user32.dll");
7067 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7069 LOAD_PROC (user_lib
, SetLayeredWindowAttributes
);
7073 /* Ensure scrollbar handles are at least 5 pixels. */
7074 vertical_scroll_bar_min_handle
= 5;
7075 horizontal_scroll_bar_min_handle
= 5;
7077 /* For either kind of scroll bar, take account of the arrows; these
7078 effectively form the border of the main scroll bar range. */
7079 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
7080 = GetSystemMetrics (SM_CYVSCROLL
);
7081 horizontal_scroll_bar_left_border
= horizontal_scroll_bar_right_border
7082 = GetSystemMetrics (SM_CYHSCROLL
);
7087 syms_of_w32term (void)
7089 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
7091 DEFSYM (Qadded
, "added");
7092 DEFSYM (Qremoved
, "removed");
7093 DEFSYM (Qmodified
, "modified");
7094 DEFSYM (Qrenamed_from
, "renamed-from");
7095 DEFSYM (Qrenamed_to
, "renamed-to");
7097 DEFVAR_INT ("w32-num-mouse-buttons",
7098 w32_num_mouse_buttons
,
7099 doc
: /* Number of physical mouse buttons. */);
7100 w32_num_mouse_buttons
= 2;
7102 DEFVAR_LISP ("w32-swap-mouse-buttons",
7103 Vw32_swap_mouse_buttons
,
7104 doc
: /* Swap the mapping of middle and right mouse buttons.
7105 When nil, middle button is mouse-2 and right button is mouse-3. */);
7106 Vw32_swap_mouse_buttons
= Qnil
;
7108 DEFVAR_LISP ("w32-grab-focus-on-raise",
7109 Vw32_grab_focus_on_raise
,
7110 doc
: /* Raised frame grabs input focus.
7111 When t, `raise-frame' grabs input focus as well. This fits well
7112 with the normal Windows click-to-focus policy, but might not be
7113 desirable when using a point-to-focus policy. */);
7114 Vw32_grab_focus_on_raise
= Qt
;
7116 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7117 Vw32_capslock_is_shiftlock
,
7118 doc
: /* Apply CapsLock state to non character input keys.
7119 When nil, CapsLock only affects normal character input keys. */);
7120 Vw32_capslock_is_shiftlock
= Qnil
;
7122 DEFVAR_LISP ("w32-recognize-altgr",
7123 Vw32_recognize_altgr
,
7124 doc
: /* Recognize right-alt and left-ctrl as AltGr.
7125 When nil, the right-alt and left-ctrl key combination is
7126 interpreted normally. */);
7127 Vw32_recognize_altgr
= Qt
;
7129 DEFVAR_BOOL ("w32-use-visible-system-caret",
7130 w32_use_visible_system_caret
,
7131 doc
: /* Flag to make the system caret visible.
7132 When this is non-nil, Emacs will indicate the position of point by
7133 using the system caret instead of drawing its own cursor. Some screen
7134 reader software does not track the system cursor properly when it is
7135 invisible, and gets confused by Emacs drawing its own cursor, so this
7136 variable is initialized to t when Emacs detects that screen reader
7137 software is running as it starts up.
7139 When this variable is set, other variables affecting the appearance of
7140 the cursor have no effect. */);
7142 w32_use_visible_system_caret
= 0;
7144 /* We don't yet support this, but defining this here avoids whining
7145 from cus-start.el and other places, like "M-x set-variable". */
7146 DEFVAR_BOOL ("x-use-underline-position-properties",
7147 x_use_underline_position_properties
,
7148 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
7149 A value of nil means ignore them. If you encounter fonts with bogus
7150 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7151 to 4.1, set this to nil. You can also use `underline-minimum-offset'
7152 to override the font's UNDERLINE_POSITION for small font display
7154 x_use_underline_position_properties
= 0;
7156 DEFVAR_BOOL ("x-underline-at-descent-line",
7157 x_underline_at_descent_line
,
7158 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
7159 A value of nil means to draw the underline according to the value of the
7160 variable `x-use-underline-position-properties', which is usually at the
7161 baseline level. The default value is nil. */);
7162 x_underline_at_descent_line
= 0;
7164 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
7165 doc
: /* Which toolkit scroll bars Emacs uses, if any.
7166 A value of nil means Emacs doesn't use toolkit scroll bars.
7167 With the X Window system, the value is a symbol describing the
7168 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
7169 With MS Windows or Nextstep, the value is t. */);
7170 Vx_toolkit_scroll_bars
= Qt
;
7172 DEFVAR_BOOL ("w32-unicode-filenames",
7173 w32_unicode_filenames
,
7174 doc
: /* Non-nil means use Unicode APIs when passing file names to the OS.
7175 A value of nil means file names passed to the OS APIs and returned
7176 from those APIs are encoded/decoded using the ANSI codepage
7177 specified by `file-name-coding-system'.
7179 This variable is set to non-nil by default when Emacs runs on Windows
7180 systems of the NT family, including W2K, XP, Vista, Windows 7 and
7181 Windows 8. It is set to nil on Windows 9X. */);
7182 w32_unicode_filenames
= 0;
7185 /* FIXME: The following variable will be (hopefully) removed
7186 before Emacs 25.1 gets released. */
7188 DEFVAR_BOOL ("w32-add-wrapped-menu-bar-lines",
7189 w32_add_wrapped_menu_bar_lines
,
7190 doc
: /* Non-nil means frame resizing accounts for wrapped menu bar lines.
7191 A value of nil means frame resizing does not add the height of wrapped
7192 menu bar lines when sending a frame resize request to the Windows API.
7193 This usually means that the resulting frame height is off by the number
7194 of wrapped menu bar lines. If this is non-nil, Emacs adds the height of
7195 wrapped menu bar lines when sending frame resize requests to the Windows
7197 w32_add_wrapped_menu_bar_lines
= 1;
7199 /* Tell Emacs about this window system. */
7200 Fprovide (Qw32
, Qnil
);