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_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_FROM_ID (f
, WINDOW_DIVIDER_FACE_ID
);
634 struct face
*face_first
= FACE_FROM_ID (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
635 struct face
*face_last
= FACE_FROM_ID (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
636 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
637 unsigned long color_first
= (face_first
638 ? face_first
->foreground
639 : FRAME_FOREGROUND_PIXEL (f
));
640 unsigned long color_last
= (face_last
641 ? face_last
->foreground
642 : FRAME_FOREGROUND_PIXEL (f
));
644 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
647 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x0
+ 1, y1
);
648 w32_fill_area_abs (f
, hdc
, color
, x0
+ 1, y0
, x1
- 1, y1
);
649 w32_fill_area_abs (f
, hdc
, color_last
, x1
- 1, y0
, x1
, y1
);
651 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
654 w32_fill_area_abs (f
, hdc
, color_first
, x0
, y0
, x1
, y0
+ 1);
655 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
+ 1, x1
, y1
- 1);
656 w32_fill_area_abs (f
, hdc
, color_last
, x0
, y1
- 1, x1
, y1
);
659 w32_fill_area_abs (f
, hdc
, color
, x0
, y0
, x1
, y1
);
661 release_frame_dc (f
, hdc
);
664 /* End update of window W.
666 Draw vertical borders between horizontally adjacent windows, and
667 display W's cursor if CURSOR_ON_P is non-zero.
669 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
670 glyphs in mouse-face were overwritten. In that case we have to
671 make sure that the mouse-highlight is properly redrawn.
673 W may be a menu bar pseudo-window in case we don't have X toolkit
674 support. Such windows don't have a cursor, so don't display it
678 x_update_window_end (struct window
*w
, bool cursor_on_p
,
679 bool mouse_face_overwritten_p
)
681 if (!w
->pseudo_window_p
)
686 display_and_set_cursor (w
, true,
687 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
688 w
->output_cursor
.x
, w
->output_cursor
.y
);
690 if (draw_window_fringes (w
, true))
692 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
693 x_draw_right_divider (w
);
695 x_draw_vertical_border (w
);
701 /* If a row with mouse-face was overwritten, arrange for
702 XTframe_up_to_date to redisplay the mouse highlight. */
703 if (mouse_face_overwritten_p
)
705 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
707 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
708 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
709 hlinfo
->mouse_face_window
= Qnil
;
712 /* Unhide the caret. This won't actually show the cursor, unless it
713 was visible before the corresponding call to HideCaret in
714 x_update_window_begin. */
715 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
717 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
722 /* End update of frame F. This function is installed as a hook in
726 x_update_end (struct frame
*f
)
728 if (! FRAME_W32_P (f
))
731 /* Mouse highlight may be displayed again. */
732 MOUSE_HL_INFO (f
)->mouse_face_defer
= false;
736 /* This function is called from various places in xdisp.c
737 whenever a complete update has been performed. */
740 w32_frame_up_to_date (struct frame
*f
)
743 FRAME_MOUSE_UPDATE (f
);
747 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
748 arrow bitmaps, or clear the fringes if no bitmaps are required
749 before DESIRED_ROW is made current. This function is called from
750 update_window_line only if it is known that there are differences
751 between bitmaps to be drawn between current row and DESIRED_ROW. */
754 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
761 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
762 desired_row
->redraw_fringe_bitmaps_p
= true;
764 /* When a window has disappeared, make sure that no rest of
765 full-width rows stays visible in the internal border. Could
766 check here if updated window is the leftmost/rightmost window,
767 but I guess it's not worth doing since vertically split windows
768 are almost never used, internal border is rarely set, and the
769 overhead is very small. */
770 if (windows_or_buffers_changed
771 && desired_row
->full_width_p
772 && (f
= XFRAME (w
->frame
),
773 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
775 && (height
= desired_row
->visible_height
,
778 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
782 HDC hdc
= get_frame_dc (f
);
783 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
784 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
786 release_frame_dc (f
, hdc
);
793 /* Draw the bitmap WHICH in one of the left or right fringes of
794 window W. ROW is the glyph row for which to display the bitmap; it
795 determines the vertical position at which the bitmap has to be
799 w32_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
,
800 struct draw_fringe_bitmap_params
*p
)
802 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
804 struct face
*face
= p
->face
;
806 hdc
= get_frame_dc (f
);
808 /* Must clip because of partially visible lines. */
809 w32_clip_to_row (w
, row
, ANY_AREA
, hdc
);
811 if (p
->bx
>= 0 && !p
->overlay_p
)
812 w32_fill_area (f
, hdc
, face
->background
,
813 p
->bx
, p
->by
, p
->nx
, p
->ny
);
815 if (p
->which
&& p
->which
< max_fringe_bmp
)
817 HBITMAP pixmap
= fringe_bmp
[p
->which
];
821 compat_hdc
= CreateCompatibleDC (hdc
);
825 horig_obj
= SelectObject (compat_hdc
, pixmap
);
827 /* Paint overlays transparently. */
830 HBRUSH h_brush
, h_orig_brush
;
832 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
833 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
834 h_brush
= CreateSolidBrush (face
->foreground
);
835 h_orig_brush
= SelectObject (hdc
, h_brush
);
837 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
838 compat_hdc
, 0, p
->dh
,
840 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
841 compat_hdc
, 0, p
->dh
,
843 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
844 compat_hdc
, 0, p
->dh
,
847 SelectObject (hdc
, h_orig_brush
);
848 DeleteObject (h_brush
);
852 SetTextColor (hdc
, face
->background
);
853 SetBkColor (hdc
, (p
->cursor_p
854 ? f
->output_data
.w32
->cursor_pixel
855 : face
->foreground
));
857 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
858 compat_hdc
, 0, p
->dh
,
862 SelectObject (compat_hdc
, horig_obj
);
863 DeleteDC (compat_hdc
);
867 w32_set_clip_rectangle (hdc
, NULL
);
869 release_frame_dc (f
, hdc
);
873 w32_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
875 if (which
>= max_fringe_bmp
)
877 int i
= max_fringe_bmp
;
878 max_fringe_bmp
= which
+ 20;
879 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
880 while (i
< max_fringe_bmp
)
884 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
888 w32_destroy_fringe_bitmap (int which
)
890 if (which
>= max_fringe_bmp
)
893 if (fringe_bmp
[which
])
894 DeleteObject (fringe_bmp
[which
]);
895 fringe_bmp
[which
] = 0;
898 /***********************************************************************
900 ***********************************************************************/
902 /* Function prototypes of this page. */
904 static void x_set_glyph_string_clipping (struct glyph_string
*);
905 static void x_set_glyph_string_gc (struct glyph_string
*);
906 static void x_draw_glyph_string_background (struct glyph_string
*,
908 static void x_draw_glyph_string_foreground (struct glyph_string
*);
909 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
910 static void x_draw_glyph_string_box (struct glyph_string
*);
911 static void x_draw_glyph_string (struct glyph_string
*);
912 static void x_set_cursor_gc (struct glyph_string
*);
913 static void x_set_mode_line_face_gc (struct glyph_string
*);
914 static void x_set_mouse_face_gc (struct glyph_string
*);
915 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
916 static void w32_setup_relief_color (struct frame
*, struct relief
*,
917 double, int, COLORREF
);
918 static void x_setup_relief_colors (struct glyph_string
*);
919 static void x_draw_image_glyph_string (struct glyph_string
*);
920 static void x_draw_image_relief (struct glyph_string
*);
921 static void x_draw_image_foreground (struct glyph_string
*);
922 static void w32_draw_image_foreground_1 (struct glyph_string
*, HBITMAP
);
923 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
925 static void w32_draw_relief_rect (struct frame
*, int, int, int, int,
926 int, int, int, int, int, int,
928 static void w32_draw_box_rect (struct glyph_string
*, int, int, int, int,
929 int, bool, bool, RECT
*);
932 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
936 x_set_cursor_gc (struct glyph_string
*s
)
938 if (s
->font
== FRAME_FONT (s
->f
)
939 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
940 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
942 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
945 /* Cursor on non-default face: must merge. */
949 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
950 xgcv
.foreground
= s
->face
->background
;
952 /* If the glyph would be invisible, try a different foreground. */
953 if (xgcv
.foreground
== xgcv
.background
)
954 xgcv
.foreground
= s
->face
->foreground
;
955 if (xgcv
.foreground
== xgcv
.background
)
956 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
957 if (xgcv
.foreground
== xgcv
.background
)
958 xgcv
.foreground
= s
->face
->foreground
;
960 /* Make sure the cursor is distinct from text in this face. */
961 if (xgcv
.background
== s
->face
->background
962 && xgcv
.foreground
== s
->face
->foreground
)
964 xgcv
.background
= s
->face
->foreground
;
965 xgcv
.foreground
= s
->face
->background
;
968 IF_DEBUG (x_check_font (s
->f
, s
->font
));
970 mask
= GCForeground
| GCBackground
| GCFont
;
972 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
973 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
976 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
977 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
979 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
984 /* Set up S->gc of glyph string S for drawing text in mouse face. */
987 x_set_mouse_face_gc (struct glyph_string
*s
)
992 /* What face has to be used last for the mouse face? */
993 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
994 face
= FACE_FROM_ID (s
->f
, face_id
);
996 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
998 if (s
->first_glyph
->type
== CHAR_GLYPH
)
999 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1001 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1002 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1003 prepare_face_for_display (s
->f
, s
->face
);
1005 /* If font in this face is same as S->font, use it. */
1006 if (s
->font
== s
->face
->font
)
1007 s
->gc
= s
->face
->gc
;
1010 /* Otherwise construct scratch_cursor_gc with values from FACE
1015 xgcv
.background
= s
->face
->background
;
1016 xgcv
.foreground
= s
->face
->foreground
;
1017 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1018 xgcv
.font
= s
->font
;
1019 mask
= GCForeground
| GCBackground
| GCFont
;
1021 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1022 XChangeGC (NULL
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1025 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1026 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1028 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1031 eassert (s
->gc
!= 0);
1035 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1036 Faces to use in the mode line have already been computed when the
1037 matrix was built, so there isn't much to do, here. */
1040 x_set_mode_line_face_gc (struct glyph_string
*s
)
1042 s
->gc
= s
->face
->gc
;
1046 /* Set S->gc of glyph string S for drawing that glyph string. Set
1047 S->stippled_p to a non-zero value if the face of S has a stipple
1051 x_set_glyph_string_gc (struct glyph_string
*s
)
1053 prepare_face_for_display (s
->f
, s
->face
);
1055 if (s
->hl
== DRAW_NORMAL_TEXT
)
1057 s
->gc
= s
->face
->gc
;
1058 s
->stippled_p
= s
->face
->stipple
!= 0;
1060 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1062 x_set_mode_line_face_gc (s
);
1063 s
->stippled_p
= s
->face
->stipple
!= 0;
1065 else if (s
->hl
== DRAW_CURSOR
)
1067 x_set_cursor_gc (s
);
1068 s
->stippled_p
= false;
1070 else if (s
->hl
== DRAW_MOUSE_FACE
)
1072 x_set_mouse_face_gc (s
);
1073 s
->stippled_p
= s
->face
->stipple
!= 0;
1075 else if (s
->hl
== DRAW_IMAGE_RAISED
1076 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1078 s
->gc
= s
->face
->gc
;
1079 s
->stippled_p
= s
->face
->stipple
!= 0;
1084 /* GC must have been set. */
1085 eassert (s
->gc
!= 0);
1089 /* Set clipping for output of glyph string S. S may be part of a mode
1090 line or menu if we don't have X toolkit support. */
1093 x_set_glyph_string_clipping (struct glyph_string
*s
)
1096 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1099 w32_set_clip_rectangle (s
->hdc
, r
);
1102 HRGN clip1
= CreateRectRgnIndirect (r
);
1103 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
1104 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
1105 SelectClipRgn (s
->hdc
, clip1
);
1106 DeleteObject (clip1
);
1107 DeleteObject (clip2
);
1112 /* Set SRC's clipping for output of glyph string DST. This is called
1113 when we are drawing DST's left_overhang or right_overhang only in
1117 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
,
1118 struct glyph_string
*dst
)
1123 r
.right
= r
.left
+ src
->width
;
1125 r
.bottom
= r
.top
+ src
->height
;
1128 w32_set_clip_rectangle (dst
->hdc
, &r
);
1132 Compute left and right overhang of glyph string S. */
1135 w32_compute_glyph_string_overhangs (struct glyph_string
*s
)
1138 && s
->first_glyph
->type
== CHAR_GLYPH
1139 && !s
->font_not_found_p
)
1141 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1142 struct font
*font
= s
->font
;
1143 struct font_metrics metrics
;
1146 for (i
= 0; i
< s
->nchars
; i
++)
1147 code
[i
] = s
->char2b
[i
];
1148 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1149 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1150 ? metrics
.rbearing
- metrics
.width
: 0);
1151 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1155 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1156 s
->left_overhang
= -s
->cmp
->lbearing
;
1160 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1163 x_clear_glyph_string_rect (struct glyph_string
*s
,
1164 int x
, int y
, int w
, int h
)
1171 /* Take clipping into account. */
1172 if (s
->gc
->clip_mask
== Rect
)
1174 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1175 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1176 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1177 - s
->gc
->clip_rectangle
.left
);
1178 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1179 - s
->gc
->clip_rectangle
.top
);
1182 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1187 /* Draw the background of glyph_string S. If S->background_filled_p
1188 is non-zero don't draw it. FORCE_P non-zero means draw the
1189 background even if it wouldn't be drawn normally. This is used
1190 when a string preceding S draws into the background of S, or S
1191 contains the first component of a composition. */
1194 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1196 /* Nothing to do if background has already been drawn or if it
1197 shouldn't be drawn in the first place. */
1198 if (!s
->background_filled_p
)
1200 int box_line_width
= max (s
->face
->box_line_width
, 0);
1202 #if 0 /* TODO: stipple */
1205 /* Fill background with a stipple pattern. */
1206 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1207 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1208 s
->y
+ box_line_width
,
1209 s
->background_width
,
1210 s
->height
- 2 * box_line_width
);
1211 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1212 s
->background_filled_p
= true;
1216 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1217 /* When xdisp.c ignores FONT_HEIGHT, we cannot trust
1218 font dimensions, since the actual glyphs might be
1219 much smaller. So in that case we always clear the
1220 rectangle with background color. */
1221 || FONT_TOO_HIGH (s
->font
)
1222 || s
->font_not_found_p
1223 || s
->extends_to_end_of_line_p
1226 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1227 s
->background_width
,
1228 s
->height
- 2 * box_line_width
);
1229 s
->background_filled_p
= true;
1235 /* Draw the foreground of glyph string S. */
1238 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1242 /* If first glyph of S has a left box line, start drawing the text
1243 of S to the right of that box line. */
1244 if (s
->face
->box
!= FACE_NO_BOX
1245 && s
->first_glyph
->left_box_line_p
)
1246 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1250 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1251 SetBkColor (s
->hdc
, s
->gc
->background
);
1252 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1254 /* Draw characters of S as rectangles if S's font could not be
1256 if (s
->font_not_found_p
)
1258 for (i
= 0; i
< s
->nchars
; ++i
)
1260 struct glyph
*g
= s
->first_glyph
+ i
;
1262 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1264 x
+= g
->pixel_width
;
1269 struct font
*font
= s
->font
;
1270 int boff
= font
->baseline_offset
;
1274 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1276 if (font
->vertical_centering
)
1277 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1279 y
= s
->ybase
- boff
;
1281 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1282 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, false);
1284 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, true);
1285 if (s
->face
->overstrike
)
1286 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, false);
1288 SelectObject (s
->hdc
, old_font
);
1292 /* Draw the foreground of composite glyph string S. */
1295 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1298 struct font
*font
= s
->font
;
1300 /* If first glyph of S has a left box line, start drawing the text
1301 of S to the right of that box line. */
1302 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1303 && s
->first_glyph
->left_box_line_p
)
1304 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1308 /* S is a glyph string for a composition. S->cmp_from is the index
1309 of the first character drawn for glyphs of this composition.
1310 S->cmp_from == 0 means we are drawing the very first character of
1311 this composition. */
1313 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1314 SetBkColor (s
->hdc
, s
->gc
->background
);
1315 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1317 /* Draw a rectangle for the composition if the font for the very
1318 first character of the composition could not be loaded. */
1319 if (s
->font_not_found_p
)
1321 if (s
->cmp_from
== 0)
1322 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1325 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1330 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1332 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1333 /* TAB in a composition means display glyphs with padding
1334 space on the left or right. */
1335 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1337 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1338 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1340 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, false);
1341 if (s
->face
->overstrike
)
1342 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, false);
1344 SelectObject (s
->hdc
, old_font
);
1348 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1354 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1356 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1358 glyph
= LGSTRING_GLYPH (gstring
, i
);
1359 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1360 width
+= LGLYPH_WIDTH (glyph
);
1363 int xoff
, yoff
, wadjust
;
1367 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1370 xoff
= LGLYPH_XOFF (glyph
);
1371 yoff
= LGLYPH_YOFF (glyph
);
1372 wadjust
= LGLYPH_WADJUST (glyph
);
1373 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, false);
1380 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1382 SelectObject (s
->hdc
, old_font
);
1387 /* Draw the foreground of glyph string S for glyphless characters. */
1390 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1392 struct glyph
*glyph
= s
->first_glyph
;
1395 bool with_background
;
1397 /* If first glyph of S has a left box line, start drawing the text
1398 of S to the right of that box line. */
1399 if (s
->face
->box
!= FACE_NO_BOX
1400 && s
->first_glyph
->left_box_line_p
)
1401 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1405 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1406 SetBkColor (s
->hdc
, s
->gc
->background
);
1407 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1410 with_background
= ((s
->for_overlaps
1411 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))) == 0;
1412 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1414 char buf
[7], *str
= NULL
;
1415 int len
= glyph
->u
.glyphless
.len
;
1417 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1420 && CHAR_TABLE_P (Vglyphless_char_display
)
1421 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1425 = (! glyph
->u
.glyphless
.for_no_font
1426 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1427 glyph
->u
.glyphless
.ch
)
1428 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1429 if (STRINGP (acronym
))
1430 str
= SSDATA (acronym
);
1433 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1435 sprintf ((char *) buf
, "%0*X",
1436 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1437 glyph
->u
.glyphless
.ch
);
1441 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1442 w32_draw_rectangle (s
->hdc
, s
->gc
,
1443 x
, s
->ybase
- glyph
->ascent
,
1444 glyph
->pixel_width
- 1,
1445 glyph
->ascent
+ glyph
->descent
- 1);
1448 struct font
*font
= s
->font
;
1449 int upper_len
= (len
+ 1) / 2;
1453 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1454 /* It is certain that all LEN characters in STR are ASCII. */
1455 for (j
= 0; j
< len
; j
++)
1457 code
= font
->driver
->encode_char (font
, str
[j
]);
1458 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1460 font
->driver
->draw (s
, 0, upper_len
,
1461 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1462 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1464 font
->driver
->draw (s
, upper_len
, len
,
1465 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1466 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1468 SelectObject (s
->hdc
, old_font
);
1470 x
+= glyph
->pixel_width
;
1475 /* Brightness beyond which a color won't have its highlight brightness
1478 Nominally, highlight colors for `3d' faces are calculated by
1479 brightening an object's color by a constant scale factor, but this
1480 doesn't yield good results for dark colors, so for colors whose
1481 brightness is less than this value (on a scale of 0-255) have to
1482 use an additional additive factor.
1484 The value here is set so that the default menu-bar/mode-line color
1485 (grey75) will not have its highlights changed at all. */
1486 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1489 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1490 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1491 If this produces the same color as COLOR, try a color where all RGB
1492 values have DELTA added. Return the allocated color in *COLOR.
1493 DISPLAY is the X display, CMAP is the colormap to operate on.
1494 Value is non-zero if successful. */
1497 w32_alloc_lighter_color (struct frame
*f
, COLORREF
*color
,
1498 double factor
, int delta
)
1503 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1506 /* Change RGB values by specified FACTOR. Avoid overflow! */
1507 eassert (factor
>= 0);
1508 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1509 min (0xff, factor
* GetGValue (*color
)),
1510 min (0xff, factor
* GetBValue (*color
)));
1512 /* Calculate brightness of COLOR. */
1513 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1514 + GetBValue (*color
)) / 6;
1516 /* We only boost colors that are darker than
1517 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1518 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1519 /* Make an additive adjustment to NEW, because it's dark enough so
1520 that scaling by FACTOR alone isn't enough. */
1522 /* How far below the limit this color is (0 - 1, 1 being darker). */
1523 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1524 /* The additive adjustment. */
1525 int min_delta
= delta
* dimness
* factor
/ 2;
1528 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1529 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1530 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1532 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1533 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1534 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1538 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1539 max (0, min (0xff, delta
+ GetGValue (*color
))),
1540 max (0, min (0xff, delta
+ GetBValue (*color
))));
1542 /* TODO: Map to palette and retry with delta if same? */
1543 /* TODO: Free colors (if using palette)? */
1553 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1554 colors in COLORS. On W32, we no longer try to map colors to
1557 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1561 for (i
= 0; i
< ncolors
; i
++)
1563 DWORD pixel
= colors
[i
].pixel
;
1564 /* Convert to a 16 bit value in range 0 - 0xffff. */
1565 colors
[i
].red
= GetRValue (pixel
) * 257;
1566 colors
[i
].green
= GetGValue (pixel
) * 257;
1567 colors
[i
].blue
= GetBValue (pixel
) * 257;
1572 x_query_color (struct frame
*f
, XColor
*color
)
1574 x_query_colors (f
, color
, 1);
1578 /* Set up the foreground color for drawing relief lines of glyph
1579 string S. RELIEF is a pointer to a struct relief containing the GC
1580 with which lines will be drawn. Use a color that is FACTOR or
1581 DELTA lighter or darker than the relief's background which is found
1582 in S->f->output_data.x->relief_background. If such a color cannot
1583 be allocated, use DEFAULT_PIXEL, instead. */
1586 w32_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
1587 int delta
, COLORREF default_pixel
)
1590 struct w32_output
*di
= f
->output_data
.w32
;
1591 unsigned long mask
= GCForeground
;
1593 COLORREF background
= di
->relief_background
;
1595 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1598 /* TODO: Free colors (if using palette)? */
1600 /* Allocate new color. */
1601 xgcv
.foreground
= default_pixel
;
1603 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1604 xgcv
.foreground
= relief
->pixel
= pixel
;
1606 if (relief
->gc
== 0)
1608 #if 0 /* TODO: stipple */
1609 xgcv
.stipple
= dpyinfo
->gray
;
1612 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1615 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1619 /* Set up colors for the relief lines around glyph string S. */
1622 x_setup_relief_colors (struct glyph_string
*s
)
1624 struct w32_output
*di
= s
->f
->output_data
.w32
;
1627 if (s
->face
->use_box_color_for_shadows_p
)
1628 color
= s
->face
->box_color
;
1629 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1631 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1632 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1634 color
= s
->gc
->background
;
1636 if (di
->white_relief
.gc
== 0
1637 || color
!= di
->relief_background
)
1639 di
->relief_background
= color
;
1640 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1641 WHITE_PIX_DEFAULT (s
->f
));
1642 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1643 BLACK_PIX_DEFAULT (s
->f
));
1648 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1649 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1650 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1651 relief. LEFT_P non-zero means draw a relief on the left side of
1652 the rectangle. RIGHT_P non-zero means draw a relief on the right
1653 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1657 w32_draw_relief_rect (struct frame
*f
,
1658 int left_x
, int top_y
, int right_x
, int bottom_y
,
1659 int width
, int raised_p
,
1660 int top_p
, int bot_p
, int left_p
, int right_p
,
1665 HDC hdc
= get_frame_dc (f
);
1668 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1670 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1672 w32_set_clip_rectangle (hdc
, clip_rect
);
1676 for (i
= 0; i
< width
; ++i
)
1677 w32_fill_area (f
, hdc
, gc
.foreground
,
1678 left_x
+ i
* left_p
, top_y
+ i
,
1679 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1683 for (i
= 0; i
< width
; ++i
)
1684 w32_fill_area (f
, hdc
, gc
.foreground
,
1685 left_x
+ i
, top_y
+ (i
+ 1) * top_p
, 1,
1686 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1689 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1691 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1695 for (i
= 0; i
< width
; ++i
)
1696 w32_fill_area (f
, hdc
, gc
.foreground
,
1697 left_x
+ i
* left_p
, bottom_y
- i
,
1698 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1702 for (i
= 0; i
< width
; ++i
)
1703 w32_fill_area (f
, hdc
, gc
.foreground
,
1704 right_x
- i
, top_y
+ (i
+ 1) * top_p
, 1,
1705 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1707 w32_set_clip_rectangle (hdc
, NULL
);
1709 release_frame_dc (f
, hdc
);
1713 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1714 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1715 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1716 left side of the rectangle. RIGHT_P non-zero means draw a line
1717 on the right side of the rectangle. CLIP_RECT is the clipping
1718 rectangle to use when drawing. */
1721 w32_draw_box_rect (struct glyph_string
*s
,
1722 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1723 bool left_p
, bool right_p
, RECT
*clip_rect
)
1725 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1728 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1729 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1734 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1735 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1739 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1740 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1745 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1746 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1749 w32_set_clip_rectangle (s
->hdc
, NULL
);
1753 /* Draw a box around glyph string S. */
1756 x_draw_glyph_string_box (struct glyph_string
*s
)
1758 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
;
1759 bool left_p
, right_p
, raised_p
;
1760 struct glyph
*last_glyph
;
1763 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1764 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1765 : window_box_right (s
->w
, s
->area
));
1767 /* The glyph that may have a right box line. */
1768 last_glyph
= (s
->cmp
|| s
->img
1770 : s
->first_glyph
+ s
->nchars
- 1);
1772 width
= eabs (s
->face
->box_line_width
);
1773 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1775 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1777 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1779 bottom_y
= top_y
+ s
->height
- 1;
1781 left_p
= (s
->first_glyph
->left_box_line_p
1782 || (s
->hl
== DRAW_MOUSE_FACE
1784 || s
->prev
->hl
!= s
->hl
)));
1785 right_p
= (last_glyph
->right_box_line_p
1786 || (s
->hl
== DRAW_MOUSE_FACE
1788 || s
->next
->hl
!= s
->hl
)));
1790 get_glyph_string_clip_rect (s
, &clip_rect
);
1792 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1793 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1794 left_p
, right_p
, &clip_rect
);
1797 x_setup_relief_colors (s
);
1798 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1799 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1804 /* Draw foreground of image glyph string S. */
1807 x_draw_image_foreground (struct glyph_string
*s
)
1810 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1812 /* If first glyph of S has a left box line, start drawing it to the
1813 right of that line. */
1814 if (s
->face
->box
!= FACE_NO_BOX
1815 && s
->first_glyph
->left_box_line_p
1817 x
+= eabs (s
->face
->box_line_width
);
1819 /* If there is a margin around the image, adjust x- and y-position
1821 if (s
->slice
.x
== 0)
1822 x
+= s
->img
->hmargin
;
1823 if (s
->slice
.y
== 0)
1824 y
+= s
->img
->vmargin
;
1830 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
1831 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1832 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
1833 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1834 SetBkColor (compat_hdc
, RGB (255, 255, 255));
1835 SetTextColor (s
->hdc
, RGB (0, 0, 0));
1836 x_set_glyph_string_clipping (s
);
1840 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
1841 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1843 SetTextColor (s
->hdc
, RGB (255, 255, 255));
1844 SetBkColor (s
->hdc
, RGB (0, 0, 0));
1846 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1847 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1848 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1849 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1850 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1851 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1853 SelectObject (mask_dc
, mask_orig_obj
);
1858 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1859 SetBkColor (s
->hdc
, s
->gc
->background
);
1861 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1862 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1864 /* When the image has a mask, we can expect that at
1865 least part of a mouse highlight or a block cursor will
1866 be visible. If the image doesn't have a mask, make
1867 a block cursor visible by drawing a rectangle around
1868 the image. I believe it's looking better if we do
1869 nothing here for mouse-face. */
1870 if (s
->hl
== DRAW_CURSOR
)
1872 int r
= s
->img
->relief
;
1874 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
1875 s
->slice
.width
+ r
*2 - 1,
1876 s
->slice
.height
+ r
*2 - 1);
1880 w32_set_clip_rectangle (s
->hdc
, NULL
);
1881 SelectObject (s
->hdc
, orig_brush
);
1882 DeleteObject (fg_brush
);
1883 SelectObject (compat_hdc
, orig_obj
);
1884 DeleteDC (compat_hdc
);
1887 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
1888 s
->slice
.width
- 1, s
->slice
.height
- 1);
1890 RestoreDC (s
->hdc
,-1);
1894 /* Draw a relief around the image glyph string S. */
1897 x_draw_image_relief (struct glyph_string
*s
)
1899 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
1900 int extra_x
, extra_y
;
1903 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1905 /* If first glyph of S has a left box line, start drawing it to the
1906 right of that line. */
1907 if (s
->face
->box
!= FACE_NO_BOX
1908 && s
->first_glyph
->left_box_line_p
1910 x
+= eabs (s
->face
->box_line_width
);
1912 /* If there is a margin around the image, adjust x- and y-position
1914 if (s
->slice
.x
== 0)
1915 x
+= s
->img
->hmargin
;
1916 if (s
->slice
.y
== 0)
1917 y
+= s
->img
->vmargin
;
1919 if (s
->hl
== DRAW_IMAGE_SUNKEN
1920 || s
->hl
== DRAW_IMAGE_RAISED
)
1922 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
1923 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
1924 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
1928 thick
= eabs (s
->img
->relief
);
1929 raised_p
= s
->img
->relief
> 0;
1932 x1
= x
+ s
->slice
.width
- 1;
1933 y1
= y
+ s
->slice
.height
- 1;
1935 extra_x
= extra_y
= 0;
1936 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
1938 if (CONSP (Vtool_bar_button_margin
)
1939 && INTEGERP (XCAR (Vtool_bar_button_margin
))
1940 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
1942 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
1943 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
1945 else if (INTEGERP (Vtool_bar_button_margin
))
1946 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
1949 top_p
= bot_p
= left_p
= right_p
= 0;
1951 if (s
->slice
.x
== 0)
1952 x
-= thick
+ extra_x
, left_p
= 1;
1953 if (s
->slice
.y
== 0)
1954 y
-= thick
+ extra_y
, top_p
= 1;
1955 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
1956 x1
+= thick
+ extra_x
, right_p
= 1;
1957 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
1958 y1
+= thick
+ extra_y
, bot_p
= 1;
1960 x_setup_relief_colors (s
);
1961 get_glyph_string_clip_rect (s
, &r
);
1962 w32_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
1963 top_p
, bot_p
, left_p
, right_p
, &r
);
1967 /* Draw the foreground of image glyph string S to PIXMAP. */
1970 w32_draw_image_foreground_1 (struct glyph_string
*s
, HBITMAP pixmap
)
1972 HDC hdc
= CreateCompatibleDC (s
->hdc
);
1973 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
1975 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1977 /* If first glyph of S has a left box line, start drawing it to the
1978 right of that line. */
1979 if (s
->face
->box
!= FACE_NO_BOX
1980 && s
->first_glyph
->left_box_line_p
1982 x
+= eabs (s
->face
->box_line_width
);
1984 /* If there is a margin around the image, adjust x- and y-position
1986 if (s
->slice
.x
== 0)
1987 x
+= s
->img
->hmargin
;
1988 if (s
->slice
.y
== 0)
1989 y
+= s
->img
->vmargin
;
1993 HDC compat_hdc
= CreateCompatibleDC (hdc
);
1994 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1995 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
1996 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2000 HDC mask_dc
= CreateCompatibleDC (hdc
);
2001 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2003 SetTextColor (hdc
, RGB (0, 0, 0));
2004 SetBkColor (hdc
, RGB (255, 255, 255));
2005 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2006 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2007 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2008 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2009 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2010 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2012 SelectObject (mask_dc
, mask_orig_obj
);
2017 SetTextColor (hdc
, s
->gc
->foreground
);
2018 SetBkColor (hdc
, s
->gc
->background
);
2020 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2021 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2023 /* When the image has a mask, we can expect that at
2024 least part of a mouse highlight or a block cursor will
2025 be visible. If the image doesn't have a mask, make
2026 a block cursor visible by drawing a rectangle around
2027 the image. I believe it's looking better if we do
2028 nothing here for mouse-face. */
2029 if (s
->hl
== DRAW_CURSOR
)
2031 int r
= s
->img
->relief
;
2033 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2034 s
->slice
.width
+ r
*2 - 1,
2035 s
->slice
.height
+ r
*2 - 1);
2039 SelectObject (hdc
, orig_brush
);
2040 DeleteObject (fg_brush
);
2041 SelectObject (compat_hdc
, orig_obj
);
2042 DeleteDC (compat_hdc
);
2045 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2046 s
->slice
.width
- 1, s
->slice
.height
- 1);
2048 SelectObject (hdc
, orig_hdc_obj
);
2053 /* Draw part of the background of glyph string S. X, Y, W, and H
2054 give the rectangle to draw. */
2057 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2059 #if 0 /* TODO: stipple */
2062 /* Fill background with a stipple pattern. */
2063 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2064 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2065 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2069 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2073 /* Draw image glyph string S.
2076 s->x +-------------------------
2079 | +-------------------------
2082 | | +-------------------
2088 x_draw_image_glyph_string (struct glyph_string
*s
)
2091 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2092 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2097 if (s
->slice
.y
== 0)
2098 height
-= box_line_vwidth
;
2099 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2100 height
-= box_line_vwidth
;
2102 /* Fill background with face under the image. Do it only if row is
2103 taller than image or if image has a clip mask to reduce
2105 s
->stippled_p
= s
->face
->stipple
!= 0;
2106 if (height
> s
->slice
.height
2110 || s
->img
->pixmap
== 0
2111 || s
->width
!= s
->background_width
)
2113 width
= s
->background_width
;
2115 if (s
->first_glyph
->left_box_line_p
2118 x
+= box_line_hwidth
;
2119 width
-= box_line_hwidth
;
2123 if (s
->slice
.y
== 0)
2124 y
+= box_line_vwidth
;
2126 #if 0 /* TODO: figure out if we need to do this on Windows. */
2129 /* Create a pixmap as large as the glyph string. Fill it
2130 with the background color. Copy the image to it, using
2131 its mask. Copy the temporary pixmap to the display. */
2132 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2133 int depth
= DefaultDepthOfScreen (screen
);
2135 /* Create a pixmap as large as the glyph string. */
2136 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2137 s
->background_width
,
2140 /* Don't clip in the following because we're working on the
2142 XSetClipMask (s
->display
, s
->gc
, None
);
2144 /* Fill the pixmap with the background color/stipple. */
2147 /* Fill background with a stipple pattern. */
2148 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2149 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2150 0, 0, s
->background_width
, s
->height
);
2151 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2156 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2158 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2159 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2160 0, 0, s
->background_width
, s
->height
);
2161 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2166 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
2168 s
->background_filled_p
= true;
2171 /* Draw the foreground. */
2174 w32_draw_image_foreground_1 (s
, pixmap
);
2175 x_set_glyph_string_clipping (s
);
2177 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2178 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2179 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2180 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2182 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2183 SetBkColor (s
->hdc
, s
->gc
->background
);
2184 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2185 compat_hdc
, 0, 0, SRCCOPY
);
2187 SelectObject (s
->hdc
, orig_brush
);
2188 DeleteObject (fg_brush
);
2189 SelectObject (compat_hdc
, orig_obj
);
2190 DeleteDC (compat_hdc
);
2192 DeleteObject (pixmap
);
2196 x_draw_image_foreground (s
);
2198 /* If we must draw a relief around the image, do it. */
2200 || s
->hl
== DRAW_IMAGE_RAISED
2201 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2202 x_draw_image_relief (s
);
2206 /* Draw stretch glyph string S. */
2209 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2211 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2213 if (s
->hl
== DRAW_CURSOR
2214 && !x_stretch_cursor_p
)
2216 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2217 wide as the stretch glyph. */
2218 int width
, background_width
= s
->background_width
;
2221 if (!s
->row
->reversed_p
)
2223 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2227 background_width
-= left_x
- x
;
2233 /* In R2L rows, draw the cursor on the right edge of the
2235 int right_x
= window_box_right (s
->w
, TEXT_AREA
);
2237 if (x
+ background_width
> right_x
)
2238 background_width
-= x
- right_x
;
2239 x
+= background_width
;
2241 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2242 if (s
->row
->reversed_p
)
2246 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2248 /* Clear rest using the GC of the original non-cursor face. */
2249 if (width
< background_width
)
2251 XGCValues
*gc
= s
->face
->gc
;
2253 int w
= background_width
- width
, h
= s
->height
;
2257 if (!s
->row
->reversed_p
)
2261 if (s
->row
->mouse_face_p
2262 && cursor_in_mouse_face_p (s
->w
))
2264 x_set_mouse_face_gc (s
);
2270 get_glyph_string_clip_rect (s
, &r
);
2271 w32_set_clip_rectangle (hdc
, &r
);
2273 #if 0 /* TODO: stipple */
2274 if (s
->face
->stipple
)
2276 /* Fill background with a stipple pattern. */
2277 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2278 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2279 XSetFillStyle (s
->display
, gc
, FillSolid
);
2284 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2288 else if (!s
->background_filled_p
)
2290 int background_width
= s
->background_width
;
2291 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2293 /* Don't draw into left margin, fringe or scrollbar area
2294 except for header line and mode line. */
2295 if (x
< left_x
&& !s
->row
->mode_line_p
)
2297 background_width
-= left_x
- x
;
2300 if (background_width
> 0)
2301 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2304 s
->background_filled_p
= true;
2308 /* Draw glyph string S. */
2311 x_draw_glyph_string (struct glyph_string
*s
)
2313 bool relief_drawn_p
= 0;
2315 /* If S draws into the background of its successor, draw the
2316 background of the successor first so that S can draw into it.
2317 This makes S->next use XDrawString instead of XDrawImageString. */
2318 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2321 struct glyph_string
*next
;
2322 for (width
= 0, next
= s
->next
;
2323 next
&& width
< s
->right_overhang
;
2324 width
+= next
->width
, next
= next
->next
)
2325 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2327 x_set_glyph_string_gc (next
);
2328 x_set_glyph_string_clipping (next
);
2329 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2330 x_draw_stretch_glyph_string (next
);
2332 x_draw_glyph_string_background (next
, true);
2333 next
->num_clips
= 0;
2337 /* Set up S->gc, set clipping and draw S. */
2338 x_set_glyph_string_gc (s
);
2340 /* Draw relief (if any) in advance for char/composition so that the
2341 glyph string can be drawn over it. */
2342 if (!s
->for_overlaps
2343 && s
->face
->box
!= FACE_NO_BOX
2344 && (s
->first_glyph
->type
== CHAR_GLYPH
2345 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2348 x_set_glyph_string_clipping (s
);
2349 x_draw_glyph_string_background (s
, true);
2350 x_draw_glyph_string_box (s
);
2351 x_set_glyph_string_clipping (s
);
2354 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2356 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2357 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2358 /* We must clip just this glyph. left_overhang part has already
2359 drawn when s->prev was drawn, and right_overhang part will be
2360 drawn later when s->next is drawn. */
2361 x_set_glyph_string_clipping_exactly (s
, s
);
2363 x_set_glyph_string_clipping (s
);
2365 switch (s
->first_glyph
->type
)
2368 x_draw_image_glyph_string (s
);
2372 x_draw_stretch_glyph_string (s
);
2376 if (s
->for_overlaps
)
2377 s
->background_filled_p
= true;
2379 x_draw_glyph_string_background (s
, false);
2380 x_draw_glyph_string_foreground (s
);
2383 case COMPOSITE_GLYPH
:
2384 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2385 && ! s
->first_glyph
->u
.cmp
.automatic
))
2386 s
->background_filled_p
= true;
2388 x_draw_glyph_string_background (s
, true);
2389 x_draw_composite_glyph_string_foreground (s
);
2392 case GLYPHLESS_GLYPH
:
2393 if (s
->for_overlaps
)
2394 s
->background_filled_p
= true;
2396 x_draw_glyph_string_background (s
, false);
2397 x_draw_glyphless_glyph_string_foreground (s
);
2404 if (!s
->for_overlaps
)
2406 /* Draw underline. */
2407 if (s
->face
->underline_p
)
2409 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2413 if (s
->face
->underline_defaulted_p
)
2414 color
= s
->gc
->foreground
;
2416 color
= s
->face
->underline_color
;
2418 w32_draw_underwave (s
, color
);
2420 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2422 unsigned long thickness
, position
;
2425 if (s
->prev
&& s
->prev
->face
->underline_p
2426 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2428 /* We use the same underline style as the previous one. */
2429 thickness
= s
->prev
->underline_thickness
;
2430 position
= s
->prev
->underline_position
;
2434 /* Get the underline thickness. Default is 1 pixel. */
2435 if (s
->font
&& s
->font
->underline_thickness
> 0)
2436 thickness
= s
->font
->underline_thickness
;
2439 if (x_underline_at_descent_line
)
2440 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2443 /* Get the underline position. This is the recommended
2444 vertical offset in pixels from the baseline to the top of
2445 the underline. This is a signed value according to the
2446 specs, and its default is
2448 ROUND ((maximum_descent) / 2), with
2449 ROUND (x) = floor (x + 0.5) */
2451 if (x_use_underline_position_properties
2452 && s
->font
&& s
->font
->underline_position
>= 0)
2453 position
= s
->font
->underline_position
;
2455 position
= (s
->font
->descent
+ 1) / 2;
2457 position
= max (position
, underline_minimum_offset
);
2459 /* Check the sanity of thickness and position. We should
2460 avoid drawing underline out of the current line area. */
2461 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2462 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2463 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2464 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2465 s
->underline_thickness
= thickness
;
2466 s
->underline_position
=position
;
2467 y
= s
->ybase
+ position
;
2468 if (s
->face
->underline_defaulted_p
)
2470 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2475 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2480 /* Draw overline. */
2481 if (s
->face
->overline_p
)
2483 unsigned long dy
= 0, h
= 1;
2485 if (s
->face
->overline_color_defaulted_p
)
2487 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2488 s
->y
+ dy
, s
->width
, h
);
2492 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2493 s
->y
+ dy
, s
->width
, h
);
2497 /* Draw strike-through. */
2498 if (s
->face
->strike_through_p
2499 && !FONT_TEXTMETRIC (s
->font
).tmStruckOut
)
2501 unsigned long h
= 1;
2502 unsigned long dy
= (s
->height
- h
) / 2;
2504 if (s
->face
->strike_through_color_defaulted_p
)
2506 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2511 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2512 s
->y
+ dy
, s
->width
, h
);
2516 /* Draw relief if not yet drawn. */
2517 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2518 x_draw_glyph_string_box (s
);
2522 struct glyph_string
*prev
;
2524 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2525 if (prev
->hl
!= s
->hl
2526 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2528 /* As prev was drawn while clipped to its own area, we
2529 must draw the right_overhang part using s->hl now. */
2530 enum draw_glyphs_face save
= prev
->hl
;
2533 x_set_glyph_string_gc (prev
);
2534 x_set_glyph_string_clipping_exactly (s
, prev
);
2535 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2536 x_draw_glyph_string_foreground (prev
);
2538 x_draw_composite_glyph_string_foreground (prev
);
2539 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2541 prev
->num_clips
= 0;
2547 struct glyph_string
*next
;
2549 for (next
= s
->next
; next
; next
= next
->next
)
2550 if (next
->hl
!= s
->hl
2551 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2553 /* As next will be drawn while clipped to its own area,
2554 we must draw the left_overhang part using s->hl now. */
2555 enum draw_glyphs_face save
= next
->hl
;
2558 x_set_glyph_string_gc (next
);
2559 x_set_glyph_string_clipping_exactly (s
, next
);
2560 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2561 x_draw_glyph_string_foreground (next
);
2563 x_draw_composite_glyph_string_foreground (next
);
2564 w32_set_clip_rectangle (next
->hdc
, NULL
);
2566 next
->num_clips
= 0;
2567 next
->clip_head
= s
->next
;
2572 /* Reset clipping. */
2573 w32_set_clip_rectangle (s
->hdc
, NULL
);
2578 /* Shift display to make room for inserted glyphs. */
2581 w32_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
,
2582 int width
, int height
, int shift_by
)
2586 hdc
= get_frame_dc (f
);
2587 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2588 hdc
, x
, y
, SRCCOPY
);
2590 release_frame_dc (f
, hdc
);
2594 /* Delete N glyphs at the nominal cursor position. Not implemented
2598 x_delete_glyphs (struct frame
*f
, register int n
)
2600 if (! FRAME_W32_P (f
))
2607 /* Clear entire frame. */
2610 x_clear_frame (struct frame
*f
)
2612 if (! FRAME_W32_P (f
))
2615 /* Clearing the frame will erase any cursor, so mark them all as no
2617 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2621 w32_clear_window (f
);
2623 /* We have to clear the scroll bars, too. If we have changed
2624 colors or something like that, then they should be notified. */
2625 x_scroll_bar_clear (f
);
2631 /* Make audible bell. */
2634 w32_ring_bell (struct frame
*f
)
2638 if (FRAME_W32_P (f
) && visible_bell
)
2641 HWND hwnd
= FRAME_W32_WINDOW (f
);
2643 for (i
= 0; i
< 5; i
++)
2645 FlashWindow (hwnd
, TRUE
);
2648 FlashWindow (hwnd
, FALSE
);
2651 w32_sys_ring_bell (f
);
2656 /***********************************************************************
2658 ***********************************************************************/
2660 /* Perform an insert-lines or delete-lines operation, inserting N
2661 lines or deleting -N lines at vertical position VPOS. */
2664 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
2666 if (! FRAME_W32_P (f
))
2673 /* Scroll part of the display as described by RUN. */
2676 x_scroll_run (struct window
*w
, struct run
*run
)
2678 struct frame
*f
= XFRAME (w
->frame
);
2679 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2680 HWND hwnd
= FRAME_W32_WINDOW (f
);
2683 /* Get frame-relative bounding box of the text display area of W,
2684 without mode lines. Include in this box the left and right
2686 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
2688 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2689 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2690 bottom_y
= y
+ height
;
2694 /* Scrolling up. Make sure we don't copy part of the mode
2695 line at the bottom. */
2696 if (from_y
+ run
->height
> bottom_y
)
2697 height
= bottom_y
- from_y
;
2699 height
= run
->height
;
2700 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2704 /* Scrolling down. Make sure we don't copy over the mode line.
2706 if (to_y
+ run
->height
> bottom_y
)
2707 height
= bottom_y
- to_y
;
2709 height
= run
->height
;
2710 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2715 /* Cursor off. Will be switched on again in x_update_window_end. */
2721 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2722 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2724 from
.left
= to
.left
= x
;
2725 from
.right
= to
.right
= x
+ width
;
2727 from
.bottom
= from_y
+ height
;
2729 to
.bottom
= bottom_y
;
2731 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2732 NULL
, SW_INVALIDATE
);
2734 /* Combine this with what we expect to be dirty. This covers the
2735 case where not all of the region we expect is actually dirty. */
2736 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2738 /* If the dirty region is not what we expected, redraw the entire frame. */
2739 if (!EqualRgn (combined
, expect_dirty
))
2740 SET_FRAME_GARBAGED (f
);
2742 DeleteObject (dirty
);
2743 DeleteObject (combined
);
2747 DeleteObject (expect_dirty
);
2752 /***********************************************************************
2754 ***********************************************************************/
2757 frame_highlight (struct frame
*f
)
2759 x_update_cursor (f
, 1);
2760 x_set_frame_alpha (f
);
2764 frame_unhighlight (struct frame
*f
)
2766 x_update_cursor (f
, 1);
2767 x_set_frame_alpha (f
);
2770 /* The focus has changed. Update the frames as necessary to reflect
2771 the new situation. Note that we can't change the selected frame
2772 here, because the Lisp code we are interrupting might become confused.
2773 Each event gets marked with the frame in which it occurred, so the
2774 Lisp code can tell when the switch took place by examining the events. */
2777 x_new_focus_frame (struct w32_display_info
*dpyinfo
, struct frame
*frame
)
2779 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2781 if (frame
!= dpyinfo
->w32_focus_frame
)
2783 /* Set this before calling other routines, so that they see
2784 the correct value of w32_focus_frame. */
2785 dpyinfo
->w32_focus_frame
= frame
;
2787 if (old_focus
&& old_focus
->auto_lower
)
2788 x_lower_frame (old_focus
);
2790 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2791 dpyinfo
->w32_pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2793 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
2796 x_frame_rehighlight (dpyinfo
);
2800 /* Handle FocusIn and FocusOut state changes for FRAME.
2801 If FRAME has focus and there exists more than one frame, puts
2802 a FOCUS_IN_EVENT into *BUFP. */
2805 x_focus_changed (int type
, int state
, struct w32_display_info
*dpyinfo
,
2806 struct frame
*frame
, struct input_event
*bufp
)
2808 if (type
== WM_SETFOCUS
)
2810 if (dpyinfo
->w32_focus_event_frame
!= frame
)
2812 x_new_focus_frame (dpyinfo
, frame
);
2813 dpyinfo
->w32_focus_event_frame
= frame
;
2815 /* Don't stop displaying the initial startup message
2816 for a switch-frame event we don't need. */
2817 if (NILP (Vterminal_frame
)
2818 && CONSP (Vframe_list
)
2819 && !NILP (XCDR (Vframe_list
)))
2828 bufp
->kind
= FOCUS_IN_EVENT
;
2829 XSETFRAME (bufp
->frame_or_window
, frame
);
2832 frame
->output_data
.x
->focus_state
|= state
;
2834 /* TODO: IME focus? */
2836 else if (type
== WM_KILLFOCUS
)
2838 frame
->output_data
.x
->focus_state
&= ~state
;
2840 if (dpyinfo
->w32_focus_event_frame
== frame
)
2842 dpyinfo
->w32_focus_event_frame
= 0;
2843 x_new_focus_frame (dpyinfo
, 0);
2845 bufp
->kind
= FOCUS_OUT_EVENT
;
2846 XSETFRAME (bufp
->frame_or_window
, frame
);
2849 /* TODO: IME focus? */
2854 /* The focus may have changed. Figure out if it is a real focus change,
2855 by checking both FocusIn/Out and Enter/LeaveNotify events.
2857 Returns FOCUS_IN_EVENT event in *BUFP. */
2860 w32_detect_focus_change (struct w32_display_info
*dpyinfo
, W32Msg
*event
,
2861 struct input_event
*bufp
)
2863 struct frame
*frame
;
2865 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
2869 /* On w32, this is only called from focus events, so no switch needed. */
2870 x_focus_changed (event
->msg
.message
,
2871 (event
->msg
.message
== WM_KILLFOCUS
?
2872 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
2873 dpyinfo
, frame
, bufp
);
2877 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2880 x_mouse_leave (struct w32_display_info
*dpyinfo
)
2882 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2885 /* The focus has changed, or we have redirected a frame's focus to
2886 another frame (this happens when a frame uses a surrogate
2887 mini-buffer frame). Shift the highlight as appropriate.
2889 The FRAME argument doesn't necessarily have anything to do with which
2890 frame is being highlighted or un-highlighted; we only use it to find
2891 the appropriate X display info. */
2894 w32_frame_rehighlight (struct frame
*frame
)
2896 if (! FRAME_W32_P (frame
))
2898 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
2902 x_frame_rehighlight (struct w32_display_info
*dpyinfo
)
2904 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2906 if (dpyinfo
->w32_focus_frame
)
2908 dpyinfo
->x_highlight_frame
2909 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2910 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2911 : dpyinfo
->w32_focus_frame
);
2912 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
2914 fset_focus_frame (dpyinfo
->w32_focus_frame
, Qnil
);
2915 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
2919 dpyinfo
->x_highlight_frame
= 0;
2921 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
2924 frame_unhighlight (old_highlight
);
2925 if (dpyinfo
->x_highlight_frame
)
2926 frame_highlight (dpyinfo
->x_highlight_frame
);
2930 /* Keyboard processing - modifier keys, etc. */
2932 /* Convert a keysym to its name. */
2935 x_get_keysym_name (int keysym
)
2937 /* Make static so we can always return it */
2938 static char value
[100];
2941 GetKeyNameText (keysym
, value
, 100);
2948 codepage_for_locale (LCID locale
)
2952 if (GetLocaleInfo (locale
, LOCALE_IDEFAULTANSICODEPAGE
, cp
, 20) > 0)
2959 /* Mouse clicks and mouse movement. Rah. */
2961 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2962 the state in PUP. XBUTTON provides extra information for extended mouse
2963 button messages. Returns FALSE if unable to parse the message. */
2965 parse_button (int message
, int xbutton
, int * pbutton
, int * pup
)
2972 case WM_LBUTTONDOWN
:
2980 case WM_MBUTTONDOWN
:
2981 if (NILP (Vw32_swap_mouse_buttons
))
2988 if (NILP (Vw32_swap_mouse_buttons
))
2994 case WM_RBUTTONDOWN
:
2995 if (NILP (Vw32_swap_mouse_buttons
))
3002 if (NILP (Vw32_swap_mouse_buttons
))
3008 case WM_XBUTTONDOWN
:
3009 button
= xbutton
+ 2;
3013 button
= xbutton
+ 2;
3021 if (pbutton
) *pbutton
= button
;
3027 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3029 If the event is a button press, then note that we have grabbed
3033 construct_mouse_click (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3038 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3041 /* Make the event type NO_EVENT; we'll change that when we decide
3043 result
->kind
= MOUSE_CLICK_EVENT
;
3044 result
->code
= button
;
3045 result
->timestamp
= msg
->msg
.time
;
3046 result
->modifiers
= (msg
->dwModifiers
3051 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3052 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3053 XSETFRAME (result
->frame_or_window
, f
);
3059 construct_mouse_wheel (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3064 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3067 result
->timestamp
= msg
->msg
.time
;
3069 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3070 forward, away from the user (up); a negative value indicates that
3071 the wheel was rotated backward, toward the user (down). */
3072 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3074 /* The up and down modifiers indicate if the wheel was rotated up or
3075 down based on WHEEL_DELTA value. */
3076 result
->modifiers
= (msg
->dwModifiers
3077 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3079 /* With multiple monitors, we can legitimately get negative
3080 coordinates, so cast to short to interpret them correctly. */
3081 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3082 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3083 ScreenToClient (msg
->msg
.hwnd
, &p
);
3084 XSETINT (result
->x
, p
.x
);
3085 XSETINT (result
->y
, p
.y
);
3086 XSETFRAME (result
->frame_or_window
, f
);
3092 construct_drag_n_drop (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3099 wchar_t name_w
[MAX_PATH
];
3100 #ifdef NTGUI_UNICODE
3101 const int use_unicode
= 1;
3103 int use_unicode
= w32_unicode_filenames
;
3104 char name_a
[MAX_PATH
];
3105 char file
[MAX_UTF8_PATH
];
3109 result
->kind
= DRAG_N_DROP_EVENT
;
3111 result
->timestamp
= msg
->msg
.time
;
3112 result
->modifiers
= msg
->dwModifiers
;
3114 hdrop
= (HDROP
) msg
->msg
.wParam
;
3115 DragQueryPoint (hdrop
, &p
);
3118 p
.x
= LOWORD (msg
->msg
.lParam
);
3119 p
.y
= HIWORD (msg
->msg
.lParam
);
3120 ScreenToClient (msg
->msg
.hwnd
, &p
);
3123 XSETINT (result
->x
, p
.x
);
3124 XSETINT (result
->y
, p
.y
);
3126 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3129 for (i
= 0; i
< num_files
; i
++)
3133 eassert (DragQueryFileW (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3134 /* If DragQueryFile returns zero, it failed to fetch a file
3136 if (DragQueryFileW (hdrop
, i
, name_w
, MAX_PATH
) == 0)
3138 #ifdef NTGUI_UNICODE
3139 files
= Fcons (from_unicode_buffer (name_w
), files
);
3141 filename_from_utf16 (name_w
, file
);
3142 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3143 #endif /* NTGUI_UNICODE */
3145 #ifndef NTGUI_UNICODE
3148 eassert (DragQueryFileA (hdrop
, i
, NULL
, 0) < MAX_PATH
);
3149 if (DragQueryFileA (hdrop
, i
, name_a
, MAX_PATH
) == 0)
3151 filename_from_ansi (name_a
, file
);
3152 files
= Fcons (DECODE_FILE (build_unibyte_string (file
)), files
);
3159 XSETFRAME (frame
, f
);
3160 result
->frame_or_window
= frame
;
3161 result
->arg
= files
;
3168 /* File event notifications (see w32notify.c). */
3171 lispy_file_action (DWORD action
)
3173 static char unknown_fmt
[] = "unknown-action(%d)";
3178 case FILE_ACTION_ADDED
:
3181 case FILE_ACTION_REMOVED
:
3184 case FILE_ACTION_MODIFIED
:
3187 case FILE_ACTION_RENAMED_OLD_NAME
:
3188 retval
= Qrenamed_from
;
3190 case FILE_ACTION_RENAMED_NEW_NAME
:
3191 retval
= Qrenamed_to
;
3195 char buf
[sizeof(unknown_fmt
) - 1 + INT_STRLEN_BOUND (DWORD
)];
3197 sprintf (buf
, unknown_fmt
, action
);
3198 retval
= intern (buf
);
3207 /* Put file notifications into the Emacs input event queue. This
3208 function runs when the WM_EMACS_FILENOTIFY message arrives from a
3211 queue_notifications (struct input_event
*event
, W32Msg
*msg
, struct frame
*f
,
3214 struct notifications_set
*ns
= NULL
;
3218 /* We cannot process notification before Emacs is fully initialized,
3219 since we need the UTF-16LE coding-system to be set up. */
3223 XSETFRAME (frame
, f
);
3229 /* Find out if there is a record available in the linked list of
3230 notifications sets. If so, unlink the set from the linked
3231 list. Use critical section. */
3233 if (notifications_set_head
->next
!= notifications_set_head
)
3235 ns
= notifications_set_head
->next
;
3236 ns
->prev
->next
= ns
->next
;
3237 ns
->next
->prev
= ns
->prev
;
3245 BYTE
*p
= ns
->notifications
;
3246 FILE_NOTIFY_INFORMATION
*fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3247 const DWORD min_size
3248 = offsetof (FILE_NOTIFY_INFORMATION
, FileName
) + sizeof(wchar_t);
3249 DWORD info_size
= ns
->size
;
3250 Lisp_Object cs
= Qutf_16le
;
3251 Lisp_Object obj
= w32_get_watch_object (ns
->desc
);
3253 /* notifications size could be zero when the buffer of
3254 notifications overflowed on the OS level, or when the
3255 directory being watched was itself deleted. Do nothing in
3258 && !NILP (obj
) && CONSP (obj
))
3260 Lisp_Object callback
= XCDR (obj
);
3262 while (info_size
>= min_size
)
3264 Lisp_Object utf_16_fn
3265 = make_unibyte_string ((char *)fni
->FileName
,
3266 fni
->FileNameLength
);
3267 /* Note: mule-conf is preloaded, so utf-16le must
3268 already be defined at this point. */
3270 = code_convert_string_norecord (utf_16_fn
, cs
, 0);
3271 Lisp_Object action
= lispy_file_action (fni
->Action
);
3273 event
->kind
= FILE_NOTIFY_EVENT
;
3274 event
->timestamp
= msg
->msg
.time
;
3275 event
->modifiers
= 0;
3276 event
->frame_or_window
= callback
;
3277 event
->arg
= list3 (make_pointer_integer (ns
->desc
),
3279 kbd_buffer_store_event (event
);
3281 if (!fni
->NextEntryOffset
)
3283 p
+= fni
->NextEntryOffset
;
3284 fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3285 info_size
-= fni
->NextEntryOffset
;
3288 /* Free this notifications set. */
3289 xfree (ns
->notifications
);
3293 /* We've stuffed all the events ourselves, so w32_read_socket shouldn't. */
3294 event
->kind
= NO_EVENT
;
3296 #endif /* WINDOWSNT */
3297 #endif /* HAVE_W32NOTIFY */
3300 /* Function to report a mouse movement to the mainstream Emacs code.
3301 The input handler calls this.
3303 We have received a mouse movement event, which is given in *event.
3304 If the mouse is over a different glyph than it was last time, tell
3305 the mainstream emacs code by setting mouse_moved. If not, ask for
3306 another motion event, so we can check again the next time it moves. */
3309 note_mouse_movement (struct frame
*frame
, MSG
*msg
)
3311 struct w32_display_info
*dpyinfo
;
3312 int mouse_x
= LOWORD (msg
->lParam
);
3313 int mouse_y
= HIWORD (msg
->lParam
);
3316 if (!FRAME_X_OUTPUT (frame
))
3319 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
3320 dpyinfo
->last_mouse_movement_time
= msg
->time
;
3321 dpyinfo
->last_mouse_motion_frame
= frame
;
3322 dpyinfo
->last_mouse_motion_x
= mouse_x
;
3323 dpyinfo
->last_mouse_motion_y
= mouse_y
;
3325 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3327 frame
->mouse_moved
= true;
3328 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3329 note_mouse_highlight (frame
, -1, -1);
3330 dpyinfo
->last_mouse_glyph_frame
= NULL
;
3334 /* Has the mouse moved off the glyph it was on at the last sighting? */
3335 r
= &dpyinfo
->last_mouse_glyph
;
3336 if (frame
!= dpyinfo
->last_mouse_glyph_frame
3337 || mouse_x
< r
->left
|| mouse_x
>= r
->right
3338 || mouse_y
< r
->top
|| mouse_y
>= r
->bottom
)
3340 frame
->mouse_moved
= true;
3341 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3342 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3343 /* Remember the mouse position here, as w32_mouse_position only
3344 gets called when mouse tracking is enabled but we also need
3345 to keep track of the mouse for help_echo and highlighting at
3347 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, r
);
3348 dpyinfo
->last_mouse_glyph_frame
= frame
;
3356 /************************************************************************
3358 ************************************************************************/
3360 static struct scroll_bar
*x_window_to_scroll_bar (Window
, int);
3361 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3362 enum scroll_bar_part
*,
3363 Lisp_Object
*, Lisp_Object
*,
3365 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3366 enum scroll_bar_part
*,
3367 Lisp_Object
*, Lisp_Object
*,
3370 w32_define_cursor (Window window
, Cursor cursor
)
3372 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3375 /* Return the current position of the mouse.
3376 *fp should be a frame which indicates which display to ask about.
3378 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3379 and *part to the frame, window, and scroll bar part that the mouse
3380 is over. Set *x and *y to the portion and whole of the mouse's
3381 position on the scroll bar.
3383 If the mouse movement started elsewhere, set *fp to the frame the
3384 mouse is on, *bar_window to nil, and *x and *y to the character cell
3387 Set *time to the server time-stamp for the time at which the mouse
3388 was at this position.
3390 Don't store anything if we don't have a valid set of values to report.
3392 This clears the mouse_moved flag, so we can wait for the next mouse
3396 w32_mouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
3397 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
3401 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
3405 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
3407 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
3409 if (bar
->horizontal
)
3410 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3412 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3418 Lisp_Object frame
, tail
;
3420 /* Clear the mouse-moved flag for every frame on this display. */
3421 FOR_EACH_FRAME (tail
, frame
)
3422 XFRAME (frame
)->mouse_moved
= false;
3424 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3428 /* Now we have a position on the root; find the innermost window
3429 containing the pointer. */
3431 /* If mouse was grabbed on a frame, give coords for that
3432 frame even if the mouse is now outside it. Otherwise
3433 check for window under mouse on one of our frames. */
3434 f1
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
3435 : x_any_window_to_frame (dpyinfo
, WindowFromPoint (pt
)));
3437 /* If not, is it one of our scroll bars? */
3440 struct scroll_bar
*bar
3441 = x_window_to_scroll_bar (WindowFromPoint (pt
), 2);
3444 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3447 if (f1
== 0 && insist
> 0)
3448 f1
= SELECTED_FRAME ();
3452 /* Ok, we found a frame. Store all the values.
3453 last_mouse_glyph is a rectangle used to reduce the
3454 generation of mouse events. To not miss any motion
3455 events, we must divide the frame into rectangles of the
3456 size of the smallest character that could be displayed
3457 on it, i.e. into the same rectangles that matrices on
3458 the frame are divided into. */
3460 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
3461 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3462 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &dpyinfo
->last_mouse_glyph
);
3463 dpyinfo
->last_mouse_glyph_frame
= f1
;
3466 *part
= scroll_bar_above_handle
;
3470 *time
= dpyinfo
->last_mouse_movement_time
;
3479 /***********************************************************************
3481 ***********************************************************************/
3483 /* Handle mouse button event on the tool-bar of frame F, at
3484 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
3485 or ButtonRelease. */
3488 w32_handle_tool_bar_click (struct frame
*f
, struct input_event
*button_event
)
3490 int x
= XFASTINT (button_event
->x
);
3491 int y
= XFASTINT (button_event
->y
);
3493 if (button_event
->modifiers
& down_modifier
)
3494 handle_tool_bar_click (f
, x
, y
, 1, 0);
3496 handle_tool_bar_click (f
, x
, y
, 0,
3497 button_event
->modifiers
& ~up_modifier
);
3502 /***********************************************************************
3504 ***********************************************************************/
3506 /* Scroll bar support. */
3508 /* Given a window ID, find the struct scroll_bar which manages it
3509 vertically. This can be called in GC, so we have to make sure to
3510 strip off mark bits. */
3512 static struct scroll_bar
*
3513 x_window_to_scroll_bar (Window window_id
, int type
)
3515 Lisp_Object tail
, frame
;
3517 FOR_EACH_FRAME (tail
, frame
)
3519 Lisp_Object bar
, condemned
;
3521 /* Scan this frame's scroll bar list for a scroll bar with the
3523 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3524 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3525 /* This trick allows us to search both the ordinary and
3526 condemned scroll bar lists with one loop. */
3527 ! NILP (bar
) || (bar
= condemned
,
3530 bar
= XSCROLL_BAR (bar
)->next
)
3531 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
3533 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
3534 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
3535 return XSCROLL_BAR (bar
);
3543 /* Set the thumb size and position of vertical scroll bar BAR. We are currently
3544 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3547 w32_set_scroll_bar_thumb (struct scroll_bar
*bar
,
3548 int portion
, int position
, int whole
)
3550 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3551 /* We use the whole scroll-bar height in the calculations below, to
3552 avoid strange effects like scrolling backwards when just clicking
3553 on the handle (without moving it). */
3554 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
)
3555 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3556 int sb_page
, sb_pos
;
3557 BOOL draggingp
= bar
->dragging
? TRUE
: FALSE
;
3560 /* We used to change the nPage setting while dragging the handle,
3561 but that had very strange effects (such as scrolling backwards
3562 while dragging downwards).
3564 Now, we don't change the nPage setting while dragging unless we
3565 get near to the end of the buffer, in which case we often have to
3566 resize the handle to "go all the way". */
3572 si
.cbSize
= sizeof (si
);
3573 si
.fMask
= SIF_POS
| SIF_PAGE
;
3574 GetScrollInfo (w
, SB_CTL
, &si
);
3575 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3583 /* Position scroll bar at rock bottom if the bottom of the
3584 buffer is visible. This avoids shrinking the thumb away
3585 to nothing if it is held at the bottom of the buffer. */
3586 if (position
+ portion
>= whole
&& !draggingp
)
3588 sb_page
= range
* (whole
- position
) / whole
;
3593 sb_pos
= position
* range
/ whole
;
3594 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3603 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3607 si
.cbSize
= sizeof (si
);
3608 si
.fMask
= SIF_PAGE
| SIF_POS
;
3612 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3617 /* Set the thumb size and position of horizontal scroll bar BAR. We are currently
3618 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3621 w32_set_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
3622 int portion
, int position
, int whole
)
3624 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3629 si
.cbSize
= sizeof (si
);
3630 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
3633 /* Allow nPage to be one larger than nPos so we don't allow the scrolling
3634 of an already fully visible buffer. */
3635 si
.nPage
= min (portion
, si
.nMax
) + 1;
3636 si
.nPos
= min (position
, si
.nMax
);
3637 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3643 /************************************************************************
3644 Scroll bars, general
3645 ************************************************************************/
3648 my_create_vscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3650 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3651 WM_EMACS_CREATEVSCROLLBAR
, (WPARAM
) f
,
3656 my_create_hscrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3658 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3659 WM_EMACS_CREATEHSCROLLBAR
, (WPARAM
) f
,
3663 /*#define ATTACH_THREADS*/
3666 my_show_window (struct frame
*f
, HWND hwnd
, int how
)
3668 #ifndef ATTACH_THREADS
3669 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3670 (WPARAM
) hwnd
, (LPARAM
) how
);
3672 return ShowWindow (hwnd
, how
);
3677 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3678 int x
, int y
, int cx
, int cy
, UINT flags
)
3680 #ifndef ATTACH_THREADS
3682 pos
.hwndInsertAfter
= hwndAfter
;
3688 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
3690 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3696 my_set_focus (struct frame
* f
, HWND hwnd
)
3698 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3704 my_set_foreground_window (HWND hwnd
)
3706 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
3711 my_destroy_window (struct frame
* f
, HWND hwnd
)
3713 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3718 my_bring_window_to_top (HWND hwnd
)
3720 SendMessage (hwnd
, WM_EMACS_BRINGTOTOP
, (WPARAM
) hwnd
, 0);
3723 /* Create a scroll bar and return the scroll bar vector for it. W is
3724 the Emacs window on which to create the scroll bar. TOP, LEFT,
3725 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
3728 static struct scroll_bar
*
3729 x_scroll_bar_create (struct window
*w
, int left
, int top
, int width
, int height
, bool horizontal
)
3731 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3734 struct scroll_bar
*bar
3735 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, top
, PVEC_OTHER
);
3740 XSETWINDOW (bar
->window
, w
);
3744 bar
->height
= height
;
3748 bar
->horizontal
= horizontal
;
3750 /* Requires geometry to be set before call to create the real window */
3753 hwnd
= my_create_hscrollbar (f
, bar
);
3755 hwnd
= my_create_vscrollbar (f
, bar
);
3757 si
.cbSize
= sizeof (si
);
3761 si
.nMax
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
)
3762 + HORIZONTAL_SCROLL_BAR_MIN_HANDLE
;
3764 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3765 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3769 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3771 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3773 /* Add bar to its frame's list of scroll bars. */
3774 bar
->next
= FRAME_SCROLL_BARS (f
);
3776 XSETVECTOR (barobj
, bar
);
3777 fset_scroll_bars (f
, barobj
);
3778 if (! NILP (bar
->next
))
3779 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3787 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3791 x_scroll_bar_remove (struct scroll_bar
*bar
)
3793 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3797 /* Destroy the window. */
3798 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3800 /* Dissociate this scroll bar from its window. */
3801 if (bar
->horizontal
)
3802 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3804 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3809 /* Set the handle of the vertical scroll bar for WINDOW to indicate that
3810 we are displaying PORTION characters out of a total of WHOLE
3811 characters, starting at POSITION. If WINDOW has no vertical scroll
3814 w32_set_vertical_scroll_bar (struct window
*w
,
3815 int portion
, int whole
, int position
)
3817 struct frame
*f
= XFRAME (w
->frame
);
3819 struct scroll_bar
*bar
;
3820 int top
, height
, left
, width
;
3821 int window_y
, window_height
;
3823 /* Get window dimensions. */
3824 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
3826 height
= window_height
;
3828 /* Compute the left edge and the width of the scroll bar area. */
3829 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3830 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
3832 /* Does the scroll bar exist yet? */
3833 if (NILP (w
->vertical_scroll_bar
))
3837 if (width
> 0 && height
> 0)
3839 hdc
= get_frame_dc (f
);
3840 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3841 release_frame_dc (f
, hdc
);
3845 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, false);
3849 /* It may just need to be moved and resized. */
3852 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3853 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3855 /* If already correctly positioned, do nothing. */
3856 if (bar
->left
== left
3858 && bar
->width
== width
3859 && bar
->height
== height
)
3861 /* Redraw after clear_frame. */
3862 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3863 InvalidateRect (hwnd
, NULL
, FALSE
);
3871 if (width
&& height
)
3873 hdc
= get_frame_dc (f
);
3874 /* Since Windows scroll bars are smaller than the space reserved
3875 for them on the frame, we have to clear "under" them. */
3876 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3877 release_frame_dc (f
, hdc
);
3879 /* Make sure scroll bar is "visible" before moving, to ensure the
3880 area of the parent window now exposed will be refreshed. */
3881 my_show_window (f
, hwnd
, SW_HIDE
);
3882 MoveWindow (hwnd
, left
, top
, width
, max (height
, 1), TRUE
);
3884 si
.cbSize
= sizeof (si
);
3885 si
.fMask
= SIF_RANGE
;
3887 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3888 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3890 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3892 my_show_window (f
, hwnd
, SW_NORMAL
);
3893 /* InvalidateRect (w, NULL, FALSE); */
3895 /* Remember new settings. */
3899 bar
->height
= height
;
3904 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3905 XSETVECTOR (barobj
, bar
);
3906 wset_vertical_scroll_bar (w
, barobj
);
3909 /* Set the handle of the horizontal scroll bar for WINDOW to indicate
3910 that we are displaying PORTION characters out of a total of WHOLE
3911 characters, starting at POSITION. If WINDOW has no horizontal scroll
3914 w32_set_horizontal_scroll_bar (struct window
*w
,
3915 int portion
, int whole
, int position
)
3917 struct frame
*f
= XFRAME (w
->frame
);
3919 struct scroll_bar
*bar
;
3920 int top
, height
, left
, width
;
3921 int window_x
, window_width
;
3922 int clear_left
= WINDOW_LEFT_EDGE_X (w
);
3923 int clear_width
= WINDOW_PIXEL_WIDTH (w
) - WINDOW_RIGHT_DIVIDER_WIDTH (w
);
3925 /* Get window dimensions. */
3926 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
3928 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
3929 width
= window_width
;
3930 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
3932 /* Does the scroll bar exist yet? */
3933 if (NILP (w
->horizontal_scroll_bar
))
3937 if (width
> 0 && height
> 0)
3939 hdc
= get_frame_dc (f
);
3940 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
3941 release_frame_dc (f
, hdc
);
3945 bar
= x_scroll_bar_create (w
, left
, top
, width
, height
, true);
3949 /* It may just need to be moved and resized. */
3952 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
3953 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3955 /* If already correctly positioned, do nothing. */
3956 if (bar
->left
== left
&& bar
->top
== top
3957 && bar
->width
== width
&& bar
->height
== height
)
3959 /* Redraw after clear_frame. */
3960 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3961 InvalidateRect (hwnd
, NULL
, FALSE
);
3969 if (width
&& height
)
3971 hdc
= get_frame_dc (f
);
3972 /* Since Windows scroll bars are smaller than the space reserved
3973 for them on the frame, we have to clear "under" them. */
3974 w32_clear_area (f
, hdc
, clear_left
, top
, clear_width
, height
);
3975 release_frame_dc (f
, hdc
);
3977 /* Make sure scroll bar is "visible" before moving, to ensure the
3978 area of the parent window now exposed will be refreshed. */
3979 my_show_window (f
, hwnd
, SW_HIDE
);
3980 MoveWindow (hwnd
, left
, top
, width
, max (height
, 1), TRUE
);
3982 /* +++ SetScrollInfo +++ */
3983 si
.cbSize
= sizeof (si
);
3984 si
.fMask
= SIF_PAGE
| SIF_POS
| SIF_RANGE
;
3987 si
.nPage
= min (portion
, si
.nMax
) + 1;
3988 si
.nPos
= min (position
, si
.nMax
);
3989 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3991 my_show_window (f
, hwnd
, SW_NORMAL
);
3992 /* InvalidateRect (w, NULL, FALSE); */
3994 /* Remember new settings. */
3998 bar
->height
= height
;
4004 w32_set_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
4005 XSETVECTOR (barobj
, bar
);
4006 wset_horizontal_scroll_bar (w
, barobj
);
4010 /* The following three hooks are used when we're doing a thorough
4011 redisplay of the frame. We don't explicitly know which scroll bars
4012 are going to be deleted, because keeping track of when windows go
4013 away is a real pain - "Can you say set-window-configuration, boys
4014 and girls?" Instead, we just assert at the beginning of redisplay
4015 that *all* scroll bars are to be removed, and then save a scroll bar
4016 from the fiery pit when we actually redisplay its window. */
4018 /* Arrange for all scroll bars on FRAME to be removed at the next call
4019 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
4020 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
4023 w32_condemn_scroll_bars (struct frame
*frame
)
4025 if (!NILP (FRAME_SCROLL_BARS (frame
)))
4027 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
4029 /* Prepend scrollbars to already condemned ones. */
4030 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
4032 while (!NILP (XSCROLL_BAR (last
)->next
))
4033 last
= XSCROLL_BAR (last
)->next
;
4035 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
4036 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
4039 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
4040 fset_scroll_bars (frame
, Qnil
);
4045 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
4046 Note that WINDOW isn't necessarily condemned at all. */
4049 w32_redeem_scroll_bar (struct window
*w
)
4051 struct scroll_bar
*bar
;
4055 /* We can't redeem this window's scroll bar if it doesn't have one. */
4056 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
4059 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
4061 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4062 /* Unlink it from the condemned list. */
4063 f
= XFRAME (WINDOW_FRAME (w
));
4064 if (NILP (bar
->prev
))
4066 /* If the prev pointer is nil, it must be the first in one of
4068 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
4069 /* It's not condemned. Everything's fine. */
4071 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4072 w
->vertical_scroll_bar
))
4073 fset_condemned_scroll_bars (f
, bar
->next
);
4075 /* If its prev pointer is nil, it must be at the front of
4076 one or the other! */
4080 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4082 if (! NILP (bar
->next
))
4083 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4085 bar
->next
= FRAME_SCROLL_BARS (f
);
4087 XSETVECTOR (barobj
, bar
);
4088 fset_scroll_bars (f
, barobj
);
4089 if (! NILP (bar
->next
))
4090 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4094 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
4096 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
4097 /* Unlink it from the condemned list. */
4098 f
= XFRAME (WINDOW_FRAME (w
));
4099 if (NILP (bar
->prev
))
4101 /* If the prev pointer is nil, it must be the first in one of
4103 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
4104 /* It's not condemned. Everything's fine. */
4106 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4107 w
->horizontal_scroll_bar
))
4108 fset_condemned_scroll_bars (f
, bar
->next
);
4110 /* If its prev pointer is nil, it must be at the front of
4111 one or the other! */
4115 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4117 if (! NILP (bar
->next
))
4118 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4120 bar
->next
= FRAME_SCROLL_BARS (f
);
4122 XSETVECTOR (barobj
, bar
);
4123 fset_scroll_bars (f
, barobj
);
4124 if (! NILP (bar
->next
))
4125 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4129 /* Remove all scroll bars on FRAME that haven't been saved since the
4130 last call to `*condemn_scroll_bars_hook'. */
4133 w32_judge_scroll_bars (struct frame
*f
)
4135 Lisp_Object bar
, next
;
4137 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
4139 /* Clear out the condemned list now so we won't try to process any
4140 more events on the hapless scroll bars. */
4141 fset_condemned_scroll_bars (f
, Qnil
);
4143 for (; ! NILP (bar
); bar
= next
)
4145 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
4147 x_scroll_bar_remove (b
);
4150 b
->next
= b
->prev
= Qnil
;
4153 /* Now there should be no references to the condemned scroll bars,
4154 and they should get garbage-collected. */
4157 /* Handle a mouse click on the vertical scroll bar BAR. If
4158 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4161 This may be called from a signal handler, so we have to ignore GC
4165 w32_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4166 struct input_event
*emacs_event
)
4168 if (! WINDOWP (bar
->window
))
4171 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
4172 emacs_event
->code
= 0;
4173 /* not really meaningful to distinguish up/down */
4174 emacs_event
->modifiers
= msg
->dwModifiers
;
4175 emacs_event
->frame_or_window
= bar
->window
;
4176 emacs_event
->arg
= Qnil
;
4177 emacs_event
->timestamp
= msg
->msg
.time
;
4180 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4182 int dragging
= bar
->dragging
;
4184 int sb_event
= LOWORD (msg
->msg
.wParam
);
4186 si
.cbSize
= sizeof (si
);
4187 if (sb_event
== SB_THUMBTRACK
)
4188 si
.fMask
= SIF_TRACKPOS
;
4192 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4193 if (sb_event
== SB_THUMBTRACK
)
4199 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4204 emacs_event
->part
= scroll_bar_down_arrow
;
4207 emacs_event
->part
= scroll_bar_up_arrow
;
4210 emacs_event
->part
= scroll_bar_above_handle
;
4213 emacs_event
->part
= scroll_bar_below_handle
;
4216 emacs_event
->part
= scroll_bar_handle
;
4220 emacs_event
->part
= scroll_bar_handle
;
4224 case SB_THUMBPOSITION
:
4225 bar
->dragging
= 1; /* ??????? */
4226 emacs_event
->part
= scroll_bar_handle
;
4228 /* "Silently" update current position. */
4232 si
.cbSize
= sizeof (si
);
4235 /* Remember apparent position (we actually lag behind the real
4236 position, so don't set that directly). */
4237 last_scroll_bar_drag_pos
= y
;
4239 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4243 /* If this is the end of a drag sequence, then reset the scroll
4244 handle size to normal and do a final redraw. Otherwise do
4249 int start
= bar
->start
;
4252 si
.cbSize
= sizeof (si
);
4253 si
.fMask
= SIF_PAGE
| SIF_POS
;
4254 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4255 si
.nPos
= last_scroll_bar_drag_pos
;
4256 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4260 emacs_event
->kind
= NO_EVENT
;
4264 XSETINT (emacs_event
->x
, y
);
4265 XSETINT (emacs_event
->y
, top_range
);
4271 /* Handle a mouse click on the horizontal scroll bar BAR. If
4272 *EMACS_EVENT's kind is set to something other than NO_EVENT, it is
4275 This may be called from a signal handler, so we have to ignore GC
4279 w32_horizontal_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4280 struct input_event
*emacs_event
)
4282 if (! WINDOWP (bar
->window
))
4285 emacs_event
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
4286 emacs_event
->code
= 0;
4287 /* not really meaningful to distinguish left/right */
4288 emacs_event
->modifiers
= msg
->dwModifiers
;
4289 emacs_event
->frame_or_window
= bar
->window
;
4290 emacs_event
->arg
= Qnil
;
4291 emacs_event
->timestamp
= msg
->msg
.time
;
4294 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4296 int dragging
= bar
->dragging
;
4298 int sb_event
= LOWORD (msg
->msg
.wParam
);
4300 si
.cbSize
= sizeof (si
);
4301 if (sb_event
== SB_THUMBTRACK
)
4302 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4304 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4306 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4307 if (sb_event
== SB_THUMBTRACK
)
4311 y
= si
.nMax
- si
.nPage
;
4314 FRAME_DISPLAY_INFO (f
)->last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4319 emacs_event
->part
= scroll_bar_left_arrow
;
4322 emacs_event
->part
= scroll_bar_right_arrow
;
4325 emacs_event
->part
= scroll_bar_before_handle
;
4328 emacs_event
->part
= scroll_bar_after_handle
;
4331 emacs_event
->part
= scroll_bar_horizontal_handle
;
4335 emacs_event
->part
= scroll_bar_horizontal_handle
;
4339 case SB_THUMBPOSITION
:
4341 emacs_event
->part
= scroll_bar_horizontal_handle
;
4343 /* "Silently" update current position. */
4347 si
.cbSize
= sizeof (si
);
4349 si
.nPos
= min (x
, XWINDOW (bar
->window
)->hscroll_whole
- 1);
4350 /* Remember apparent position (we actually lag behind the real
4351 position, so don't set that directly). */
4352 last_scroll_bar_drag_pos
= x
;
4354 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4358 /* If this is the end of a drag sequence, then reset the scroll
4359 handle size to normal and do a final redraw. Otherwise do
4365 si
.cbSize
= sizeof (si
);
4367 si
.nPos
= min (last_scroll_bar_drag_pos
,
4368 XWINDOW (bar
->window
)->hscroll_whole
- 1);
4369 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4373 emacs_event
->kind
= NO_EVENT
;
4377 XSETINT (emacs_event
->x
, x
);
4378 XSETINT (emacs_event
->y
, y
);
4384 /* Return information to the user about the current position of the mouse
4385 on the vertical scroll bar. */
4387 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4388 enum scroll_bar_part
*part
,
4389 Lisp_Object
*x
, Lisp_Object
*y
,
4392 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4393 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4394 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4395 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4397 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4399 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4404 *bar_window
= bar
->window
;
4406 si
.cbSize
= sizeof (si
);
4407 if (sb_event
== SB_THUMBTRACK
)
4408 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4410 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4412 GetScrollInfo (w
, SB_CTL
, &si
);
4413 if (sb_event
== SB_THUMBTRACK
)
4417 top_range
= si
.nMax
- si
.nPage
+ 1;
4419 *part
= scroll_bar_handle
;
4420 if (sb_event
== SB_LINEDOWN
)
4424 XSETINT (*y
, top_range
);
4426 f
->mouse_moved
= false;
4427 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4429 *time
= dpyinfo
->last_mouse_movement_time
;
4434 /* Return information to the user about the current position of the mouse
4435 on the horizontal scroll bar. */
4437 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4438 enum scroll_bar_part
*part
,
4439 Lisp_Object
*x
, Lisp_Object
*y
,
4442 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4443 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4444 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4445 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4447 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
4449 int sb_event
= LOWORD (dpyinfo
->last_mouse_scroll_bar_pos
);
4454 *bar_window
= bar
->window
;
4456 si
.cbSize
= sizeof (si
);
4457 if (sb_event
== SB_THUMBTRACK
)
4458 si
.fMask
= SIF_TRACKPOS
| SIF_PAGE
| SIF_RANGE
;
4460 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4462 GetScrollInfo (w
, SB_CTL
, &si
);
4463 if (sb_event
== SB_THUMBTRACK
)
4467 left_range
= si
.nMax
- si
.nPage
+ 1;
4469 *part
= scroll_bar_handle
;
4470 if (sb_event
== SB_LINERIGHT
)
4475 XSETINT (*x
, left_range
);
4477 f
->mouse_moved
= false;
4478 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4480 *time
= dpyinfo
->last_mouse_movement_time
;
4486 /* The screen has been cleared so we may have changed foreground or
4487 background colors, and the scroll bars may need to be redrawn.
4488 Clear out the scroll bars, and ask for expose events, so we can
4492 x_scroll_bar_clear (struct frame
*f
)
4496 /* We can have scroll bars even if this is 0,
4497 if we just turned off scroll bar mode.
4498 But in that case we should not clear them. */
4499 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
4500 || FRAME_HAS_HORIZONTAL_SCROLL_BARS (f
))
4501 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4502 bar
= XSCROLL_BAR (bar
)->next
)
4504 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4505 HDC hdc
= GetDC (window
);
4508 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4509 arranges to refresh the scroll bar if hidden. */
4510 my_show_window (f
, window
, SW_HIDE
);
4512 GetClientRect (window
, &rect
);
4513 select_palette (f
, hdc
);
4514 w32_clear_rect (f
, hdc
, &rect
);
4515 deselect_palette (f
, hdc
);
4517 ReleaseDC (window
, hdc
);
4521 /* The main W32 event-reading loop - w32_read_socket. */
4523 /* Record the last 100 characters stored
4524 to help debug the loss-of-chars-during-GC problem. */
4526 static int temp_index
;
4527 static short temp_buffer
[100];
4529 /* Temporarily store lead byte of DBCS input sequences. */
4530 static char dbcs_lead
= 0;
4532 /* Read events coming from the W32 shell.
4533 This routine is called by the SIGIO handler.
4534 We return as soon as there are no more events to be read.
4536 For an overview of how Emacs input works on MS-Windows, see the
4537 commentary before w32_msg_pump in w32fns.c.
4539 We return the number of characters stored into the buffer,
4540 thus pretending to be `read'.
4542 Some of these messages are reposted back to the message queue since the
4543 system calls the windows proc directly in a context where we cannot return
4544 the data nor can we guarantee the state we are in. So if we dispatch them
4545 we will get into an infinite loop. To prevent this from ever happening we
4546 will set a variable to indicate we are in the read_socket call and indicate
4547 which message we are processing since the windows proc gets called
4548 recursively with different messages by the system.
4552 w32_read_socket (struct terminal
*terminal
,
4553 struct input_event
*hold_quit
)
4556 int check_visibility
= 0;
4559 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4560 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
4564 /* So people can tell when we have read the available input. */
4565 input_signal_count
++;
4567 /* Process any incoming thread messages. */
4568 drain_message_queue ();
4570 /* TODO: ghostscript integration. */
4571 while (get_next_msg (&msg
, FALSE
))
4573 struct input_event inev
;
4576 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4577 /* w32_name_of_message (msg.msg.message), */
4578 /* msg.msg.time)); */
4581 inev
.kind
= NO_EVENT
;
4584 switch (msg
.msg
.message
)
4586 case WM_EMACS_PAINT
:
4587 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4591 if (msg
.rect
.right
== msg
.rect
.left
||
4592 msg
.rect
.bottom
== msg
.rect
.top
)
4594 /* We may get paint messages even though the client
4595 area is clipped - these are not expose events. */
4596 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4599 else if (FRAME_VISIBLE_P (f
) != 1)
4601 bool iconified
= FRAME_ICONIFIED_P (f
);
4603 /* Definitely not obscured, so mark as visible. */
4604 SET_FRAME_VISIBLE (f
, 1);
4605 SET_FRAME_ICONIFIED (f
, false);
4606 SET_FRAME_GARBAGED (f
);
4607 if (!f
->output_data
.w32
->asked_for_visible
)
4608 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4611 /* WM_PAINT serves as MapNotify as well, so report
4612 visibility changes properly. */
4615 inev
.kind
= DEICONIFY_EVENT
;
4616 XSETFRAME (inev
.frame_or_window
, f
);
4618 else if (!NILP (Vframe_list
) && !NILP (XCDR (Vframe_list
)))
4619 /* Force a redisplay sooner or later to update the
4620 frame titles in case this is the second frame. */
4621 record_asynch_buffer_change ();
4625 HDC hdc
= get_frame_dc (f
);
4627 /* Erase background again for safety. */
4628 w32_clear_rect (f
, hdc
, &msg
.rect
);
4629 release_frame_dc (f
, hdc
);
4633 msg
.rect
.right
- msg
.rect
.left
,
4634 msg
.rect
.bottom
- msg
.rect
.top
);
4639 case WM_INPUTLANGCHANGE
:
4640 /* Generate a language change event. */
4641 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4643 /* lParam contains the input language ID in its low 16 bits.
4644 Use it to update our record of the keyboard codepage. */
4645 w32_keyboard_codepage
= codepage_for_locale ((LCID
)(msg
.msg
.lParam
4650 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4651 XSETFRAME (inev
.frame_or_window
, f
);
4652 inev
.code
= w32_keyboard_codepage
;
4653 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4659 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4661 if (f
&& !FRAME_ICONIFIED_P (f
))
4663 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4664 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4666 clear_mouse_face (hlinfo
);
4667 hlinfo
->mouse_face_hidden
= true;
4670 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4672 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4673 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4674 inev
.code
= msg
.msg
.wParam
;
4675 inev
.modifiers
= msg
.dwModifiers
;
4676 XSETFRAME (inev
.frame_or_window
, f
);
4677 inev
.timestamp
= msg
.msg
.time
;
4684 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4686 if (f
&& !FRAME_ICONIFIED_P (f
))
4688 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4689 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4691 clear_mouse_face (hlinfo
);
4692 hlinfo
->mouse_face_hidden
= true;
4695 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4697 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4699 inev
.modifiers
= msg
.dwModifiers
;
4700 XSETFRAME (inev
.frame_or_window
, f
);
4701 inev
.timestamp
= msg
.msg
.time
;
4703 if (msg
.msg
.message
== WM_UNICHAR
)
4705 inev
.code
= msg
.msg
.wParam
;
4707 else if (msg
.msg
.wParam
< 256)
4712 dbcs
[1] = (char) msg
.msg
.wParam
;
4716 dbcs
[0] = dbcs_lead
;
4718 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4722 DebPrint (("Invalid DBCS sequence: %d %d\n",
4724 inev
.kind
= NO_EVENT
;
4728 else if (IsDBCSLeadByteEx (w32_keyboard_codepage
,
4729 (BYTE
) msg
.msg
.wParam
))
4731 dbcs_lead
= (char) msg
.msg
.wParam
;
4732 inev
.kind
= NO_EVENT
;
4737 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4738 &dbcs
[1], 1, &code
, 1))
4740 /* What to do with garbage? */
4741 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4742 inev
.kind
= NO_EVENT
;
4750 /* Windows shouldn't generate WM_CHAR events above 0xFF
4751 in non-Unicode message handlers. */
4752 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4753 inev
.kind
= NO_EVENT
;
4756 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4757 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4762 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4764 if (f
&& !FRAME_ICONIFIED_P (f
))
4766 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4767 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4769 clear_mouse_face (hlinfo
);
4770 hlinfo
->mouse_face_hidden
= true;
4773 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4775 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4776 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4777 inev
.code
= GET_APPCOMMAND_LPARAM (msg
.msg
.lParam
);
4778 inev
.modifiers
= msg
.dwModifiers
;
4779 XSETFRAME (inev
.frame_or_window
, f
);
4780 inev
.timestamp
= msg
.msg
.time
;
4785 /* Ignore non-movement. */
4787 int x
= LOWORD (msg
.msg
.lParam
);
4788 int y
= HIWORD (msg
.msg
.lParam
);
4789 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4791 last_mousemove_x
= x
;
4792 last_mousemove_y
= y
;
4795 previous_help_echo_string
= help_echo_string
;
4796 help_echo_string
= Qnil
;
4798 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4799 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4801 if (hlinfo
->mouse_face_hidden
)
4803 hlinfo
->mouse_face_hidden
= false;
4804 clear_mouse_face (hlinfo
);
4809 /* Generate SELECT_WINDOW_EVENTs when needed. */
4810 if (!NILP (Vmouse_autoselect_window
))
4812 static Lisp_Object last_mouse_window
;
4813 Lisp_Object window
= window_from_coordinates
4814 (f
, LOWORD (msg
.msg
.lParam
), HIWORD (msg
.msg
.lParam
), 0, 0);
4816 /* Window will be selected only when it is not
4817 selected now and last mouse movement event was
4818 not in it. Minibuffer window will be selected
4819 only when it is active. */
4820 if (WINDOWP (window
)
4821 && !EQ (window
, last_mouse_window
)
4822 && !EQ (window
, selected_window
)
4823 /* For click-to-focus window managers
4824 create event iff we don't leave the
4826 && (focus_follows_mouse
4827 || (EQ (XWINDOW (window
)->frame
,
4828 XWINDOW (selected_window
)->frame
))))
4830 inev
.kind
= SELECT_WINDOW_EVENT
;
4831 inev
.frame_or_window
= window
;
4833 /* Remember the last window where we saw the mouse. */
4834 last_mouse_window
= window
;
4836 if (!note_mouse_movement (f
, &msg
.msg
))
4837 help_echo_string
= previous_help_echo_string
;
4841 /* If we move outside the frame, then we're
4842 certainly no longer on any text in the frame. */
4843 clear_mouse_face (hlinfo
);
4846 /* If the contents of the global variable help_echo_string
4847 has changed, generate a HELP_EVENT. */
4848 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4849 But it was originally changed to this to fix a bug, so I have
4850 not removed it completely in case the bug is still there. */
4851 if (help_echo_string
!= previous_help_echo_string
||
4852 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4853 #else /* This is what xterm.c does. */
4854 if (!NILP (help_echo_string
)
4855 || !NILP (previous_help_echo_string
))
4860 case WM_LBUTTONDOWN
:
4862 case WM_MBUTTONDOWN
:
4864 case WM_RBUTTONDOWN
:
4866 case WM_XBUTTONDOWN
:
4869 /* If we decide we want to generate an event to be seen
4870 by the rest of Emacs, we put it here. */
4871 bool tool_bar_p
= 0;
4875 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4876 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4880 construct_mouse_click (&inev
, &msg
, f
);
4882 /* Is this in the tool-bar? */
4883 if (WINDOWP (f
->tool_bar_window
)
4884 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4887 int x
= XFASTINT (inev
.x
);
4888 int y
= XFASTINT (inev
.y
);
4890 window
= window_from_coordinates (f
, x
, y
, 0, 1);
4892 if (EQ (window
, f
->tool_bar_window
))
4894 w32_handle_tool_bar_click (f
, &inev
);
4900 || (dpyinfo
->w32_focus_frame
4901 && f
!= dpyinfo
->w32_focus_frame
))
4902 inev
.kind
= NO_EVENT
;
4905 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4910 dpyinfo
->grabbed
&= ~ (1 << button
);
4914 dpyinfo
->grabbed
|= (1 << button
);
4915 dpyinfo
->last_mouse_frame
= f
;
4916 /* Ignore any mouse motion that happened
4917 before this event; any subsequent mouse-movement
4918 Emacs events should reflect only motion after
4922 f
->mouse_moved
= false;
4924 f
->last_tool_bar_item
= -1;
4931 case WM_MOUSEHWHEEL
:
4933 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
4934 : x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
));
4939 if (!dpyinfo
->w32_focus_frame
4940 || f
== dpyinfo
->w32_focus_frame
)
4942 /* Emit an Emacs wheel-up/down event. */
4943 construct_mouse_wheel (&inev
, &msg
, f
);
4945 /* Ignore any mouse motion that happened before this
4946 event; any subsequent mouse-movement Emacs events
4947 should reflect only motion after the
4949 f
->mouse_moved
= false;
4950 f
->last_tool_bar_item
= -1;
4952 dpyinfo
->last_mouse_frame
= f
;
4957 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4960 construct_drag_n_drop (&inev
, &msg
, f
);
4965 struct scroll_bar
*bar
=
4966 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 1);
4969 w32_horizontal_scroll_bar_handle_click (bar
, &msg
, &inev
);
4975 struct scroll_bar
*bar
=
4976 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
, 0);
4979 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
4983 case WM_WINDOWPOSCHANGED
:
4985 case WM_ACTIVATEAPP
:
4986 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4989 /* Run the full-screen hook function also when we are
4990 being activated, to actually install the required
4991 size in effect, if the WAIT flag is set. This is
4992 because when the hook is run from x_set_fullscreen,
4993 the frame might not yet be visible, if that call is a
4994 result of make-frame, and in that case the hook just
4995 sets the WAIT flag. */
4996 if ((msg
.msg
.message
== WM_WINDOWPOSCHANGED
|| msg
.msg
.wParam
)
4997 && (f
->want_fullscreen
& FULLSCREEN_WAIT
))
4999 /* Must set visibility right here since otherwise
5000 w32fullscreen_hook returns immediately. */
5001 SET_FRAME_VISIBLE (f
, 1);
5002 w32fullscreen_hook (f
);
5005 check_visibility
= 1;
5009 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5011 if (f
&& !FRAME_ICONIFIED_P (f
))
5012 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5014 check_visibility
= 1;
5018 /* wParam non-zero means Window is about to be shown, 0 means
5019 about to be hidden. */
5020 /* Redo the mouse-highlight after the tooltip has gone. */
5021 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
5024 x_redo_mouse_highlight (dpyinfo
);
5027 /* If window has been obscured or exposed by another window
5028 being maximized or minimized/restored, then recheck
5029 visibility of all frames. Direct changes to our own
5030 windows get handled by WM_SIZE. */
5032 if (msg
.msg
.lParam
!= 0)
5033 check_visibility
= 1;
5036 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5037 f
->async_visible
= msg
.msg
.wParam
;
5041 check_visibility
= 1;
5045 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5047 /* Inform lisp of whether frame has been iconified etc. */
5050 switch (msg
.msg
.wParam
)
5052 case SIZE_MINIMIZED
:
5053 SET_FRAME_VISIBLE (f
, 0);
5054 SET_FRAME_ICONIFIED (f
, true);
5056 inev
.kind
= ICONIFY_EVENT
;
5057 XSETFRAME (inev
.frame_or_window
, f
);
5060 case SIZE_MAXIMIZED
:
5062 bool iconified
= FRAME_ICONIFIED_P (f
);
5063 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5065 SET_FRAME_VISIBLE (f
, 1);
5066 SET_FRAME_ICONIFIED (f
, false);
5068 /* wait_reading_process_output will notice this
5069 and update the frame's display structures. */
5070 SET_FRAME_GARBAGED (f
);
5076 /* Reset top and left positions of the Window
5077 here since Windows sends a WM_MOVE message
5078 BEFORE telling us the Window is minimized
5079 when the Window is iconified, with 3000,3000
5081 x_real_positions (f
, &x
, &y
);
5085 inev
.kind
= DEICONIFY_EVENT
;
5086 XSETFRAME (inev
.frame_or_window
, f
);
5088 else if (! NILP (Vframe_list
)
5089 && ! NILP (XCDR (Vframe_list
)))
5090 /* Force a redisplay sooner or later
5091 to update the frame titles
5092 in case this is the second frame. */
5093 record_asynch_buffer_change ();
5095 /* Windows can send us a SIZE_MAXIMIZED message even
5096 when fullscreen is fullboth. The following is a
5097 simple hack to check that based on the fact that
5098 only a maximized fullscreen frame should have both
5099 top/left outside the screen. */
5100 if (EQ (fullscreen
, Qfullwidth
) || EQ (fullscreen
, Qfullheight
)
5101 || NILP (fullscreen
))
5105 x_real_positions (f
, &x
, &y
);
5107 store_frame_param (f
, Qfullscreen
, Qmaximized
);
5115 bool iconified
= FRAME_ICONIFIED_P (f
);
5117 /* The following was made unconditional in a
5118 pathetic attempt to fix bug#16967 in revision
5119 116716 but, considered counterproductive was made
5120 conditional again in revision 116727. martin */
5122 SET_FRAME_VISIBLE (f
, 1);
5123 SET_FRAME_ICONIFIED (f
, false);
5125 /* wait_reading_process_output will notice this
5126 and update the frame's display structures. */
5127 SET_FRAME_GARBAGED (f
);
5131 /* Reset top and left positions of the Window
5132 here since Windows sends a WM_MOVE message
5133 BEFORE telling us the Window is minimized
5134 when the Window is iconified, with 3000,3000
5136 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5138 inev
.kind
= DEICONIFY_EVENT
;
5139 XSETFRAME (inev
.frame_or_window
, f
);
5141 else if (! NILP (Vframe_list
)
5142 && ! NILP (XCDR (Vframe_list
)))
5143 /* Force a redisplay sooner or later
5144 to update the frame titles
5145 in case this is the second frame. */
5146 record_asynch_buffer_change ();
5149 if (EQ (get_frame_param (f
, Qfullscreen
), Qmaximized
))
5150 store_frame_param (f
, Qfullscreen
, Qnil
);
5156 if (f
&& !FRAME_ICONIFIED_P (f
) && msg
.msg
.wParam
!= SIZE_MINIMIZED
)
5159 int /* rows, columns, */ width
, height
, text_width
, text_height
;
5161 if (GetClientRect (msg
.msg
.hwnd
, &rect
)
5162 /* GetClientRect evidently returns (0, 0, 0, 0) if
5163 called on a minimized frame. Such "dimensions"
5164 aren't useful anyway. */
5165 && !(rect
.bottom
== 0
5168 && rect
.right
== 0))
5170 height
= rect
.bottom
- rect
.top
;
5171 width
= rect
.right
- rect
.left
;
5172 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, width
);
5173 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, height
);
5174 /* rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height); */
5175 /* columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width); */
5177 /* TODO: Clip size to the screen dimensions. */
5179 /* Even if the number of character rows and columns
5180 has not changed, the font size may have changed,
5181 so we need to check the pixel dimensions as well. */
5183 if (width
!= FRAME_PIXEL_WIDTH (f
)
5184 || height
!= FRAME_PIXEL_HEIGHT (f
)
5185 || text_width
!= FRAME_TEXT_WIDTH (f
)
5186 || text_height
!= FRAME_TEXT_HEIGHT (f
))
5188 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
5189 SET_FRAME_GARBAGED (f
);
5190 cancel_mouse_face (f
);
5191 f
->win_gravity
= NorthWestGravity
;
5196 check_visibility
= 1;
5200 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5203 if (f
== hlinfo
->mouse_face_mouse_frame
)
5205 /* If we move outside the frame, then we're
5206 certainly no longer on any text in the frame. */
5207 clear_mouse_face (hlinfo
);
5208 hlinfo
->mouse_face_mouse_frame
= 0;
5211 /* Generate a nil HELP_EVENT to cancel a help-echo.
5212 Do it only if there's something to cancel.
5213 Otherwise, the startup message is cleared when
5214 the mouse leaves the frame. */
5215 if (any_help_event_p
)
5221 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5223 dpyinfo
->grabbed
= 0;
5224 check_visibility
= 1;
5228 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5229 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5233 if (f
== hlinfo
->mouse_face_mouse_frame
)
5235 /* If we move outside the frame, then we're
5236 certainly no longer on any text in the frame. */
5237 clear_mouse_face (hlinfo
);
5238 hlinfo
->mouse_face_mouse_frame
= 0;
5241 /* Generate a nil HELP_EVENT to cancel a help-echo.
5242 Do it only if there's something to cancel.
5243 Otherwise, the startup message is cleared when
5244 the mouse leaves the frame. */
5245 if (any_help_event_p
)
5249 dpyinfo
->grabbed
= 0;
5250 check_visibility
= 1;
5254 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5258 inev
.kind
= DELETE_WINDOW_EVENT
;
5259 XSETFRAME (inev
.frame_or_window
, f
);
5264 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5268 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
5269 XSETFRAME (inev
.frame_or_window
, f
);
5274 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5278 extern void menubar_selection_callback
5279 (struct frame
*f
, void * client_data
);
5280 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
5283 check_visibility
= 1;
5286 case WM_DISPLAYCHANGE
:
5287 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5291 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
5293 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
5294 /* The new display could have a different resolution, in
5295 which case we must reconsider what fullscreen means.
5296 The following code is untested yet. */
5297 if (!NILP (fullscreen
))
5299 x_set_fullscreen (f
, fullscreen
, fullscreen
);
5300 w32fullscreen_hook (f
);
5303 DebPrint (("display change: %d %d\n",
5304 (short) LOWORD (msg
.msg
.lParam
),
5305 (short) HIWORD (msg
.msg
.lParam
)));
5308 check_visibility
= 1;
5312 case WM_EMACS_FILENOTIFY
:
5313 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5315 queue_notifications (&inev
, &msg
, f
, &count
);
5320 /* Check for messages registered at runtime. */
5321 if (msg
.msg
.message
== msh_mousewheel
)
5323 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5324 msg
.msg
.message
= WM_MOUSEWHEEL
;
5330 if (inev
.kind
!= NO_EVENT
)
5332 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5337 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5342 XSETFRAME (frame
, f
);
5348 if (NILP (help_echo_string
))
5350 help_echo_object
= help_echo_window
= Qnil
;
5354 any_help_event_p
= 1;
5355 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5356 help_echo_object
, help_echo_pos
);
5360 help_echo_string
= Qnil
;
5361 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5367 /* If the focus was just given to an autoraising frame,
5368 raise it now. FIXME: handle more than one such frame. */
5369 if (dpyinfo
->w32_pending_autoraise_frame
)
5371 x_raise_frame (dpyinfo
->w32_pending_autoraise_frame
);
5372 dpyinfo
->w32_pending_autoraise_frame
= NULL
;
5375 /* Check which frames are still visible, if we have enqueued any user
5376 events or been notified of events that may affect visibility. We
5377 do this here because there doesn't seem to be any direct
5378 notification from Windows that the visibility of a window has
5379 changed (at least, not in all cases). */
5380 if (count
> 0 || check_visibility
)
5382 Lisp_Object tail
, frame
;
5384 FOR_EACH_FRAME (tail
, frame
)
5386 struct frame
*f
= XFRAME (frame
);
5387 /* The tooltip has been drawn already. Avoid the
5388 SET_FRAME_GARBAGED below. */
5389 if (EQ (frame
, tip_frame
))
5392 /* Check "visible" frames and mark each as obscured or not.
5393 Note that visible is nonzero for unobscured and obscured
5394 frames, but zero for hidden and iconified frames. */
5395 if (FRAME_W32_P (f
) && FRAME_VISIBLE_P (f
))
5402 /* Query clipping rectangle for the entire window area
5403 (GetWindowDC), not just the client portion (GetDC).
5404 Otherwise, the scrollbars and menubar aren't counted as
5405 part of the visible area of the frame, and we may think
5406 the frame is obscured when really a scrollbar is still
5407 visible and gets WM_PAINT messages above. */
5408 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5409 GetClipBox (hdc
, &clipbox
);
5410 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5413 obscured
= FRAME_OBSCURED_P (f
);
5415 if (clipbox
.right
== clipbox
.left
|| clipbox
.bottom
== clipbox
.top
)
5417 /* Frame has become completely obscured so mark as such (we
5418 do this by setting visible to 2 so that FRAME_VISIBLE_P
5419 is still true, but redisplay will skip it). */
5420 SET_FRAME_VISIBLE (f
, 2);
5423 DebPrint (("frame %p (%s) obscured\n", f
, SDATA (f
->name
)));
5427 /* Frame is not obscured, so mark it as such. */
5428 SET_FRAME_VISIBLE (f
, 1);
5432 SET_FRAME_GARBAGED (f
);
5433 DebPrint (("obscured frame %p (%s) found to be visible\n",
5434 f
, SDATA (f
->name
)));
5436 /* Force a redisplay sooner or later. */
5437 record_asynch_buffer_change ();
5450 /***********************************************************************
5452 ***********************************************************************/
5454 /* Set clipping for output in glyph row ROW. W is the window in which
5455 we operate. GC is the graphics context to set clipping in.
5457 ROW may be a text row or, e.g., a mode line. Text rows must be
5458 clipped to the interior of the window dedicated to text display,
5459 mode lines must be clipped to the whole window. */
5462 w32_clip_to_row (struct window
*w
, struct glyph_row
*row
,
5463 enum glyph_row_area area
, HDC hdc
)
5466 int window_x
, window_y
, window_width
;
5468 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5470 clip_rect
.left
= window_x
;
5471 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5472 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5473 clip_rect
.right
= clip_rect
.left
+ window_width
;
5474 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5476 w32_set_clip_rectangle (hdc
, &clip_rect
);
5480 /* Draw a hollow box cursor on window W in glyph row ROW. */
5483 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
5485 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5489 struct glyph
*cursor_glyph
;
5490 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5492 /* Get the glyph the cursor is on. If we can't tell because
5493 the current matrix is invalid or such, give up. */
5494 cursor_glyph
= get_phys_cursor_glyph (w
);
5495 if (cursor_glyph
== NULL
)
5501 /* Compute frame-relative coordinates for phys cursor. */
5502 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5504 /* When on R2L character, show cursor at the right edge of the
5505 glyph, unless the cursor box is as wide as the glyph or wider
5506 (the latter happens when x-stretch-cursor is non-nil). */
5507 if ((cursor_glyph
->resolved_level
& 1) != 0
5508 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5509 rect
.left
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5511 rect
.bottom
= rect
.top
+ h
;
5512 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5514 hdc
= get_frame_dc (f
);
5515 /* Set clipping, draw the rectangle, and reset clipping again. */
5516 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5517 FrameRect (hdc
, &rect
, hb
);
5519 w32_set_clip_rectangle (hdc
, NULL
);
5520 release_frame_dc (f
, hdc
);
5524 /* Draw a bar cursor on window W in glyph row ROW.
5526 Implementation note: One would like to draw a bar cursor with an
5527 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5528 Unfortunately, I didn't find a font yet that has this property set.
5532 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
,
5533 int width
, enum text_cursor_kinds kind
)
5535 struct frame
*f
= XFRAME (w
->frame
);
5536 struct glyph
*cursor_glyph
;
5538 /* If cursor is out of bounds, don't draw garbage. This can happen
5539 in mini-buffer windows when switching between echo area glyphs
5541 cursor_glyph
= get_phys_cursor_glyph (w
);
5542 if (cursor_glyph
== NULL
)
5545 /* If on an image, draw like a normal cursor. That's usually better
5546 visible than drawing a bar, esp. if the image is large so that
5547 the bar might not be in the window. */
5548 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5550 struct glyph_row
*row
;
5551 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5552 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5556 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5557 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5561 /* If the glyph's background equals the color we normally draw
5562 the bar cursor in, the bar cursor in its normal color is
5563 invisible. Use the glyph's foreground color instead in this
5564 case, on the assumption that the glyph's colors are chosen so
5565 that the glyph is legible. */
5566 if (face
->background
== cursor_color
)
5567 cursor_color
= face
->foreground
;
5569 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5571 hdc
= get_frame_dc (f
);
5572 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5574 if (kind
== BAR_CURSOR
)
5577 width
= FRAME_CURSOR_WIDTH (f
);
5578 width
= min (cursor_glyph
->pixel_width
, width
);
5580 w
->phys_cursor_width
= width
;
5582 /* If the character under cursor is R2L, draw the bar cursor
5583 on the right of its glyph, rather than on the left. */
5584 if ((cursor_glyph
->resolved_level
& 1) != 0)
5585 x
+= cursor_glyph
->pixel_width
- width
;
5587 w32_fill_area (f
, hdc
, cursor_color
, x
,
5588 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5589 width
, row
->height
);
5591 else /* HBAR_CURSOR */
5593 int dummy_x
, dummy_y
, dummy_h
;
5596 width
= row
->height
;
5598 width
= min (row
->height
, width
);
5600 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
5601 &dummy_y
, &dummy_h
);
5602 if ((cursor_glyph
->resolved_level
& 1) != 0
5603 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
)
5604 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
;
5605 w32_fill_area (f
, hdc
, cursor_color
, x
,
5606 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5607 row
->height
- width
),
5608 w
->phys_cursor_width
, width
);
5611 w32_set_clip_rectangle (hdc
, NULL
);
5612 release_frame_dc (f
, hdc
);
5617 /* RIF: Define cursor CURSOR on frame F. */
5620 w32_define_frame_cursor (struct frame
*f
, Cursor cursor
)
5622 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5626 /* RIF: Clear area on frame F. */
5629 w32_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
5633 hdc
= get_frame_dc (f
);
5634 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5635 release_frame_dc (f
, hdc
);
5638 /* RIF: Draw or clear cursor on window W. */
5641 w32_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
,
5642 int x
, int y
, enum text_cursor_kinds cursor_type
,
5643 int cursor_width
, bool on_p
, bool active_p
)
5647 /* If the user wants to use the system caret, make sure our own
5648 cursor remains invisible. */
5649 if (w32_use_visible_system_caret
)
5651 /* Call to erase_phys_cursor here seems to use the
5652 wrong values of w->phys_cursor, as they have been
5653 overwritten before this function was called. */
5654 if (w
->phys_cursor_type
!= NO_CURSOR
)
5655 erase_phys_cursor (w
);
5657 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5658 w
->phys_cursor_width
= -1;
5662 w
->phys_cursor_type
= cursor_type
;
5665 w
->phys_cursor_on_p
= true;
5667 /* If this is the active cursor, we need to track it with the
5668 system caret, so third party software like screen magnifiers
5669 and speech synthesizers can follow the cursor. */
5672 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5673 HWND hwnd
= FRAME_W32_WINDOW (f
);
5676 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5678 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5679 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5680 w32_system_caret_window
= w
;
5681 w32_system_caret_hdr_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
5682 w32_system_caret_mode_height
= WINDOW_MODE_LINE_HEIGHT (w
);
5684 PostMessage (hwnd
, WM_IME_STARTCOMPOSITION
, 0, 0);
5686 /* If the size of the active cursor changed, destroy the old
5688 if (w32_system_caret_hwnd
5689 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5690 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5692 w32_system_caret_height
= w
->phys_cursor_height
;
5694 /* Move the system caret. */
5695 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5698 if (glyph_row
->exact_window_width_line_p
5699 && (glyph_row
->reversed_p
5700 ? (w
->phys_cursor
.hpos
< 0)
5701 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
5703 glyph_row
->cursor_in_fringe_p
= true;
5704 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
5708 switch (cursor_type
)
5710 case HOLLOW_BOX_CURSOR
:
5711 x_draw_hollow_cursor (w
, glyph_row
);
5714 case FILLED_BOX_CURSOR
:
5715 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5719 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5723 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5727 w
->phys_cursor_width
= 0;
5741 x_bitmap_icon (struct frame
*f
, Lisp_Object icon
)
5744 HANDLE small_icon
= NULL
;
5746 if (FRAME_W32_WINDOW (f
) == 0)
5750 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5751 else if (STRINGP (icon
))
5753 /* Load the main icon from the named file. */
5754 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5755 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5756 /* Try to load a small icon to go with it. */
5757 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5758 GetSystemMetrics (SM_CXSMICON
),
5759 GetSystemMetrics (SM_CYSMICON
),
5762 else if (SYMBOLP (icon
))
5766 if (EQ (icon
, intern ("application")))
5767 name
= (LPCTSTR
) IDI_APPLICATION
;
5768 else if (EQ (icon
, intern ("hand")))
5769 name
= (LPCTSTR
) IDI_HAND
;
5770 else if (EQ (icon
, intern ("question")))
5771 name
= (LPCTSTR
) IDI_QUESTION
;
5772 else if (EQ (icon
, intern ("exclamation")))
5773 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5774 else if (EQ (icon
, intern ("asterisk")))
5775 name
= (LPCTSTR
) IDI_ASTERISK
;
5776 else if (EQ (icon
, intern ("winlogo")))
5777 name
= (LPCTSTR
) IDI_WINLOGO
;
5781 main_icon
= LoadIcon (NULL
, name
);
5786 if (main_icon
== NULL
)
5789 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5790 (LPARAM
) main_icon
);
5792 /* If there is a small icon that goes with it, set that too. */
5794 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5795 (LPARAM
) small_icon
);
5801 /************************************************************************
5803 ************************************************************************/
5805 /* Display Error Handling functions not used on W32. Listing them here
5806 helps diff stay in step when comparing w32term.c with xterm.c.
5808 x_error_catcher (display, error)
5809 x_catch_errors (dpy)
5810 x_catch_errors_unwind (old_val)
5811 x_check_errors (dpy, format)
5812 x_fully_uncatch_errors ()
5813 x_had_errors_p (dpy)
5814 x_clear_errors (dpy)
5815 x_uncatch_errors (dpy, count)
5817 x_connection_signal (signalnum)
5818 x_connection_closed (dpy, error_message)
5819 x_error_quitter (display, error)
5820 x_error_handler (display, error)
5821 x_io_error_quitter (display)
5826 /* Changing the font of the frame. */
5829 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
5831 struct font
*font
= XFONT_OBJECT (font_object
);
5832 int unit
, font_ascent
, font_descent
;
5835 fontset
= fontset_from_font (font_object
);
5836 FRAME_FONTSET (f
) = fontset
;
5837 if (FRAME_FONT (f
) == font
)
5838 /* This font is already set in frame F. There's nothing more to
5842 FRAME_FONT (f
) = font
;
5843 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5844 FRAME_COLUMN_WIDTH (f
) = unit
= font
->average_width
;
5845 get_font_ascent_descent (font
, &font_ascent
, &font_descent
);
5846 FRAME_LINE_HEIGHT (f
) = font_ascent
+ font_descent
;
5848 /* Compute number of scrollbar columns. */
5849 unit
= FRAME_COLUMN_WIDTH (f
);
5850 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5851 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5852 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
5855 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
5856 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) =
5857 FRAME_CONFIG_SCROLL_BAR_COLS (f
) * unit
;
5860 /* Now make the frame display the given font. */
5861 if (FRAME_X_WINDOW (f
) != 0)
5863 /* Don't change the size of a tip frame; there's no point in
5864 doing it because it's done in Fx_show_tip, and it leads to
5865 problems because the tip frame has no widget. */
5866 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5867 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
5868 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
5872 /* X version sets font of input methods here also. */
5878 /***********************************************************************
5879 TODO: W32 Input Methods
5880 ***********************************************************************/
5881 /* Listing missing functions from xterm.c helps diff stay in step.
5883 xim_destroy_callback (xim, client_data, call_data)
5884 xim_open_dpy (dpyinfo, resource_name)
5886 xim_instantiate_callback (display, client_data, call_data)
5887 xim_initialize (dpyinfo, resource_name)
5888 xim_close_dpy (dpyinfo)
5893 /* Calculate the absolute position in frame F
5894 from its current recorded position values and gravity. */
5897 x_calc_absolute_position (struct frame
*f
)
5899 int flags
= f
->size_hint_flags
;
5901 /* The sum of the widths of the frame's left and right borders, and
5902 the sum of the heights of the frame's top and bottom borders (in
5903 pixels) drawn by Windows. */
5904 unsigned int left_right_borders_width
, top_bottom_borders_height
;
5906 /* Try to get the actual values of these two variables. We compute
5907 the border width (height) by subtracting the width (height) of
5908 the frame's client area from the width (height) of the frame's
5910 WINDOWPLACEMENT wp
= { 0 };
5911 RECT client_rect
= { 0 };
5913 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
5914 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
5916 left_right_borders_width
=
5917 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
5918 (client_rect
.right
- client_rect
.left
);
5920 top_bottom_borders_height
=
5921 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
5922 (client_rect
.bottom
- client_rect
.top
);
5926 /* Use sensible default values. */
5927 left_right_borders_width
= 8;
5928 top_bottom_borders_height
= 32;
5931 /* With multiple monitors, we can legitimately get negative
5932 coordinates (for monitors above or to the left of the primary
5933 monitor). Find the display origin to ensure negative positions
5934 are computed correctly (Bug#21173). */
5935 int display_left
= 0;
5936 int display_top
= 0;
5937 if (flags
& (XNegative
| YNegative
))
5941 list
= Fw32_display_monitor_attributes_list (Qnil
);
5942 while (CONSP (list
))
5944 Lisp_Object attributes
= CAR(list
);
5945 Lisp_Object geometry
;
5946 Lisp_Object monitor_left
, monitor_top
;
5950 geometry
= Fassoc (Qgeometry
, attributes
);
5951 if (!NILP (geometry
))
5953 monitor_left
= Fnth (make_number (1), geometry
);
5954 monitor_top
= Fnth (make_number (2), geometry
);
5956 display_left
= min (display_left
, XINT (monitor_left
));
5957 display_top
= min (display_top
, XINT (monitor_top
));
5962 /* Treat negative positions as relative to the rightmost bottommost
5963 position that fits on the screen. */
5964 if (flags
& XNegative
)
5965 f
->left_pos
= (x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
5967 - FRAME_PIXEL_WIDTH (f
)
5969 - (left_right_borders_width
- 1));
5971 if (flags
& YNegative
)
5972 f
->top_pos
= (x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
5974 - FRAME_PIXEL_HEIGHT (f
)
5976 - (top_bottom_borders_height
- 1));
5978 /* The left_pos and top_pos are now relative to the top and left
5979 screen edges, so the flags should correspond. */
5980 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5983 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5984 to really change the position, and 0 when calling from
5985 x_make_frame_visible (in that case, XOFF and YOFF are the current
5986 position values). It is -1 when calling from x_set_frame_parameters,
5987 which means, do adjust for borders but don't change the gravity. */
5990 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
,
5993 int modified_top
, modified_left
;
5995 if (change_gravity
> 0)
5999 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6001 f
->size_hint_flags
|= XNegative
;
6003 f
->size_hint_flags
|= YNegative
;
6004 f
->win_gravity
= NorthWestGravity
;
6006 x_calc_absolute_position (f
);
6009 x_wm_set_size_hint (f
, (long) 0, false);
6011 modified_left
= f
->left_pos
;
6012 modified_top
= f
->top_pos
;
6014 my_set_window_pos (FRAME_W32_WINDOW (f
),
6016 modified_left
, modified_top
,
6018 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6023 w32fullscreen_hook (struct frame
*f
)
6025 if (FRAME_VISIBLE_P (f
))
6027 HWND hwnd
= FRAME_W32_WINDOW(f
);
6028 DWORD dwStyle
= GetWindowLong (hwnd
, GWL_STYLE
);
6030 enum fullscreen_type prev_fsmode
= FRAME_PREV_FSMODE (f
);
6033 f
->want_fullscreen
&= ~FULLSCREEN_WAIT
;
6035 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_NONE
)
6036 GetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6038 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_BOTH
)
6040 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
| WS_OVERLAPPEDWINDOW
);
6041 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6043 else if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_HEIGHT
6044 || FRAME_PREV_FSMODE (f
) == FULLSCREEN_WIDTH
)
6045 SetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
6047 FRAME_PREV_FSMODE (f
) = f
->want_fullscreen
;
6049 if (f
->want_fullscreen
== FULLSCREEN_NONE
)
6050 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6051 else if (f
->want_fullscreen
== FULLSCREEN_MAXIMIZED
)
6053 if (prev_fsmode
== FULLSCREEN_BOTH
|| prev_fsmode
== FULLSCREEN_WIDTH
6054 || prev_fsmode
== FULLSCREEN_HEIGHT
)
6055 /* Make window normal since otherwise the subsequent
6056 maximization might fail in some cases. */
6057 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6058 ShowWindow (hwnd
, SW_MAXIMIZE
);
6060 else if (f
->want_fullscreen
== FULLSCREEN_BOTH
)
6062 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6064 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6065 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6066 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
& ~WS_OVERLAPPEDWINDOW
);
6067 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6068 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
,
6069 SWP_NOOWNERZORDER
| SWP_FRAMECHANGED
);
6071 (f
, FRAME_PIXEL_TO_TEXT_WIDTH (f
, rect
.right
- rect
.left
),
6072 FRAME_PIXEL_TO_TEXT_HEIGHT (f
, (rect
.bottom
- rect
.top
6073 - menu_bar_height
)),
6078 ShowWindow (hwnd
, SW_SHOWNORMAL
);
6079 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
6080 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
6081 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
6082 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, 0);
6084 if (f
->want_fullscreen
== FULLSCREEN_WIDTH
)
6086 int border_width
= GetSystemMetrics (SM_CXFRAME
);
6089 (f
, (FRAME_PIXEL_TO_TEXT_WIDTH
6090 (f
, rect
.right
- rect
.left
- 2 * border_width
)),
6095 int border_height
= GetSystemMetrics (SM_CYFRAME
);
6096 /* Won't work for wrapped menu bar. */
6097 int menu_bar_height
= GetSystemMetrics (SM_CYMENU
);
6098 int title_height
= GetSystemMetrics (SM_CYCAPTION
);
6101 (f
, 0, (FRAME_PIXEL_TO_TEXT_HEIGHT
6102 (f
, rect
.bottom
- rect
.top
- 2 * border_height
6103 - title_height
- menu_bar_height
)),
6108 f
->want_fullscreen
= FULLSCREEN_NONE
;
6111 if (f
->want_fullscreen
== FULLSCREEN_BOTH
6112 || f
->want_fullscreen
== FULLSCREEN_WIDTH
6113 || f
->want_fullscreen
== FULLSCREEN_HEIGHT
)
6114 do_pending_window_change (0);
6118 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
6121 /* Call this to change the size of frame F's x-window.
6122 If CHANGE_GRAVITY, change to top-left-corner window gravity
6123 for this size change and subsequent size changes.
6124 Otherwise we leave the window gravity unchanged. */
6127 x_set_window_size (struct frame
*f
, bool change_gravity
,
6128 int width
, int height
, bool pixelwise
)
6130 int pixelwidth
, pixelheight
;
6131 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
6134 int menu_bar_height
;
6138 /* Get the height of the menu bar here. It's used below to detect
6139 whether the menu bar is wrapped. It's also used to specify the
6140 third argument for AdjustWindowRect. FRAME_EXTERNAL_MENU_BAR which
6141 has been used before for that reason is unreliable because it only
6142 specifies whether we _want_ a menu bar for this frame and not
6143 whether this frame _has_ a menu bar. See bug#22105. */
6144 info
.cbSize
= sizeof (info
);
6145 info
.rcBar
.top
= info
.rcBar
.bottom
= 0;
6146 GetMenuBarInfo (FRAME_W32_WINDOW (f
), 0xFFFFFFFD, 0, &info
);
6147 menu_bar_height
= info
.rcBar
.bottom
- info
.rcBar
.top
;
6151 pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
6152 pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
6156 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
);
6157 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
);
6160 if (w32_add_wrapped_menu_bar_lines
)
6162 /* When the menu bar wraps sending a SetWindowPos shrinks the
6163 height of the frame then the wrapped menu bar lines are not
6164 accounted for (Bug#15174 and Bug#18720). Here we add these
6165 extra lines to the frame height. */
6166 int default_menu_bar_height
;
6168 /* Why is (apparently) SM_CYMENUSIZE needed here instead of
6170 default_menu_bar_height
= GetSystemMetrics (SM_CYMENUSIZE
);
6172 if ((default_menu_bar_height
> 0)
6173 && (menu_bar_height
> default_menu_bar_height
)
6174 && ((menu_bar_height
% default_menu_bar_height
) == 0))
6175 pixelheight
= pixelheight
+ menu_bar_height
- default_menu_bar_height
;
6178 f
->win_gravity
= NorthWestGravity
;
6179 x_wm_set_size_hint (f
, (long) 0, false);
6181 rect
.left
= rect
.top
= 0;
6182 rect
.right
= pixelwidth
;
6183 rect
.bottom
= pixelheight
;
6185 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
, menu_bar_height
> 0);
6187 if (!(f
->after_make_frame
)
6188 && !(f
->want_fullscreen
& FULLSCREEN_WAIT
)
6189 && FRAME_VISIBLE_P (f
))
6193 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6195 if (EQ (fullscreen
, Qmaximized
)
6196 || EQ (fullscreen
, Qfullboth
)
6197 || EQ (fullscreen
, Qfullwidth
))
6199 rect
.left
= window_rect
.left
;
6200 rect
.right
= window_rect
.right
;
6203 if (EQ (fullscreen
, Qmaximized
)
6204 || EQ (fullscreen
, Qfullboth
)
6205 || EQ (fullscreen
, Qfullheight
))
6207 rect
.top
= window_rect
.top
;
6208 rect
.bottom
= window_rect
.bottom
;
6213 if (pixelwidth
> 0 || pixelheight
> 0)
6215 frame_size_history_add
6216 (f
, Qx_set_window_size_1
, width
, height
,
6217 list2 (Fcons (make_number (pixelwidth
),
6218 make_number (pixelheight
)),
6219 Fcons (make_number (rect
.right
- rect
.left
),
6220 make_number (rect
.bottom
- rect
.top
))));
6222 my_set_window_pos (FRAME_W32_WINDOW (f
), NULL
,
6224 rect
.right
- rect
.left
,
6225 rect
.bottom
- rect
.top
,
6226 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6228 change_frame_size (f
,
6230 ? 0 : FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
)),
6232 ? 0 : FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
)),
6234 SET_FRAME_GARBAGED (f
);
6236 /* If cursor was outside the new size, mark it as off. */
6237 mark_window_cursors_off (XWINDOW (f
->root_window
));
6239 /* Clear out any recollection of where the mouse highlighting was,
6240 since it might be in a place that's outside the new frame size.
6241 Actually checking whether it is outside is a pain in the neck,
6242 so don't try--just let the highlighting be done afresh with new
6244 cancel_mouse_face (f
);
6249 do_pending_window_change (false);
6252 /* Mouse warping. */
6255 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
6264 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
6265 pt
.x
= rect
.left
+ pix_x
;
6266 pt
.y
= rect
.top
+ pix_y
;
6267 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
6269 /* When "mouse trails" are in effect, moving the mouse cursor
6270 sometimes leaves behind an annoying "ghost" of the pointer.
6271 Avoid that by momentarily switching off mouse trails. */
6272 if (os_subtype
== OS_NT
6273 && w32_major_version
+ w32_minor_version
>= 6)
6274 ret
= SystemParametersInfo (SPI_GETMOUSETRAILS
, 0, &trail_num
, 0);
6275 SetCursorPos (pt
.x
, pt
.y
);
6277 SystemParametersInfo (SPI_SETMOUSETRAILS
, trail_num
, NULL
, 0);
6283 /* focus shifting, raising and lowering. */
6286 x_focus_frame (struct frame
*f
)
6289 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6292 /* Give input focus to frame. */
6295 /* Try not to change its Z-order if possible. */
6296 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
6297 my_set_focus (f
, FRAME_W32_WINDOW (f
));
6300 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6304 /* Raise frame F. */
6306 x_raise_frame (struct frame
*f
)
6310 /* Strictly speaking, raise-frame should only change the frame's Z
6311 order, leaving input focus unchanged. This is reasonable behavior
6312 on X where the usual policy is point-to-focus. However, this
6313 behavior would be very odd on Windows where the usual policy is
6316 On X, if the mouse happens to be over the raised frame, it gets
6317 input focus anyway (so the window with focus will never be
6318 completely obscured) - if not, then just moving the mouse over it
6319 is sufficient to give it focus. On Windows, the user must actually
6320 click on the frame (preferably the title bar so as not to move
6321 point), which is more awkward. Also, no other Windows program
6322 raises a window to the top but leaves another window (possibly now
6323 completely obscured) with input focus.
6325 Because there is a system setting on Windows that allows the user
6326 to choose the point to focus policy, we make the strict semantics
6327 optional, but by default we grab focus when raising. */
6329 if (NILP (Vw32_grab_focus_on_raise
))
6331 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6332 not already the foreground application: the frame is raised
6333 above all other frames belonging to us, but not above the
6334 current top window. To achieve that, we have to resort to this
6335 more cumbersome method. */
6337 HDWP handle
= BeginDeferWindowPos (2);
6340 handle
= DeferWindowPos (handle
,
6341 FRAME_W32_WINDOW (f
),
6344 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6347 handle
= DeferWindowPos (handle
,
6348 GetForegroundWindow (),
6349 FRAME_W32_WINDOW (f
),
6351 SWP_NOSIZE
| SWP_NOMOVE
|
6354 EndDeferWindowPos (handle
);
6360 my_bring_window_to_top (FRAME_W32_WINDOW (f
));
6366 /* Lower frame F. */
6368 x_lower_frame (struct frame
*f
)
6371 my_set_window_pos (FRAME_W32_WINDOW (f
),
6374 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6379 w32_frame_raise_lower (struct frame
*f
, bool raise_flag
)
6381 if (! FRAME_W32_P (f
))
6390 /* Change of visibility. */
6392 /* This tries to wait until the frame is really visible.
6393 However, if the window manager asks the user where to position
6394 the frame, this will return before the user finishes doing that.
6395 The frame will not actually be visible at that time,
6396 but it will become visible later when the window manager
6397 finishes with it. */
6400 x_make_frame_visible (struct frame
*f
)
6404 x_set_bitmap_icon (f
);
6406 if (! FRAME_VISIBLE_P (f
))
6408 /* We test FRAME_GARBAGED_P here to make sure we don't
6409 call x_set_offset a second time
6410 if we get to x_make_frame_visible a second time
6411 before the window gets really visible. */
6412 if (! FRAME_ICONIFIED_P (f
)
6413 && ! f
->output_data
.w32
->asked_for_visible
)
6418 /* Adjust vertical window position in order to avoid being
6419 covered by a taskbar placed at the bottom of the desktop. */
6420 SystemParametersInfo (SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6421 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6422 if (window_rect
.bottom
> workarea_rect
.bottom
6423 && window_rect
.top
> workarea_rect
.top
)
6424 f
->top_pos
= max (window_rect
.top
6425 - window_rect
.bottom
+ workarea_rect
.bottom
,
6428 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6431 f
->output_data
.w32
->asked_for_visible
= 1;
6433 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
6434 causes unexpected behavior when unminimizing frames that were
6435 previously maximized. But only SW_SHOWNORMAL works properly for
6436 frames that were truely hidden (using make-frame-invisible), so
6437 we need it to avoid Bug#5482. It seems that iconified is only
6438 set for minimized windows that are still visible, so use that to
6439 determine the appropriate flag to pass ShowWindow. */
6440 my_show_window (f
, FRAME_W32_WINDOW (f
),
6441 FRAME_ICONIFIED_P (f
) ? SW_RESTORE
: SW_SHOWNORMAL
);
6444 /* Synchronize to ensure Emacs knows the frame is visible
6445 before we do anything else. We do this loop with input not blocked
6446 so that incoming events are handled. */
6451 /* This must come after we set COUNT. */
6454 XSETFRAME (frame
, f
);
6456 /* Wait until the frame is visible. Process X events until a
6457 MapNotify event has been seen, or until we think we won't get a
6458 MapNotify at all.. */
6459 for (count
= input_signal_count
+ 10;
6460 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6462 /* Force processing of queued events. */
6463 /* TODO: x_sync equivalent? */
6465 /* Machines that do polling rather than SIGIO have been observed
6466 to go into a busy-wait here. So we'll fake an alarm signal
6467 to let the handler know that there's something to be read.
6468 We used to raise a real alarm, but it seems that the handler
6469 isn't always enabled here. This is probably a bug. */
6470 if (input_polling_used ())
6472 /* It could be confusing if a real alarm arrives while processing
6473 the fake one. Turn it off and let the handler reset it. */
6474 int old_poll_suppress_count
= poll_suppress_count
;
6475 poll_suppress_count
= 1;
6476 poll_for_input_1 ();
6477 poll_suppress_count
= old_poll_suppress_count
;
6483 /* Change from mapped state to withdrawn state. */
6485 /* Make the frame visible (mapped and not iconified). */
6488 x_make_frame_invisible (struct frame
*f
)
6490 /* Don't keep the highlight on an invisible frame. */
6491 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6492 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6496 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6498 /* We can't distinguish this from iconification
6499 just by the event that we get from the server.
6500 So we can't win using the usual strategy of letting
6501 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6502 and synchronize with the server to make sure we agree. */
6503 SET_FRAME_VISIBLE (f
, 0);
6504 SET_FRAME_ICONIFIED (f
, false);
6509 /* Change window state from mapped to iconified. */
6512 x_iconify_frame (struct frame
*f
)
6514 /* Don't keep the highlight on an invisible frame. */
6515 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6516 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6518 if (FRAME_ICONIFIED_P (f
))
6523 x_set_bitmap_icon (f
);
6525 /* Simulate the user minimizing the frame. */
6526 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
6528 SET_FRAME_VISIBLE (f
, 0);
6529 SET_FRAME_ICONIFIED (f
, true);
6535 /* Free X resources of frame F. */
6538 x_free_frame_resources (struct frame
*f
)
6540 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6541 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
6545 /* We must free faces before destroying windows because some
6546 font-driver (e.g. xft) access a window while finishing a
6548 free_frame_faces (f
);
6550 if (FRAME_W32_WINDOW (f
))
6551 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6553 free_frame_menubar (f
);
6555 xfree (f
->output_data
.w32
);
6556 f
->output_data
.w32
= NULL
;
6558 if (f
== dpyinfo
->w32_focus_frame
)
6559 dpyinfo
->w32_focus_frame
= 0;
6560 if (f
== dpyinfo
->w32_focus_event_frame
)
6561 dpyinfo
->w32_focus_event_frame
= 0;
6562 if (f
== dpyinfo
->x_highlight_frame
)
6563 dpyinfo
->x_highlight_frame
= 0;
6564 if (f
== hlinfo
->mouse_face_mouse_frame
)
6565 reset_mouse_highlight (hlinfo
);
6571 /* Destroy the window of frame F. */
6573 x_destroy_window (struct frame
*f
)
6575 struct w32_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6577 x_free_frame_resources (f
);
6578 dpyinfo
->reference_count
--;
6582 /* Setting window manager hints. */
6584 /* Set the normal size hints for the window manager, for frame F.
6585 FLAGS is the flags word to use--or 0 meaning preserve the flags
6586 that the window now has.
6587 If USER_POSITION, set the USPosition
6588 flag (this is useful when FLAGS is 0). */
6590 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
6592 Window window
= FRAME_W32_WINDOW (f
);
6596 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6597 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6598 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6599 SetWindowLong (window
, WND_VSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_WIDTH (f
));
6600 SetWindowLong (window
, WND_HSCROLLBAR_INDEX
, FRAME_SCROLL_BAR_AREA_HEIGHT (f
));
6605 /***********************************************************************
6607 ***********************************************************************/
6611 /* Check that FONT is valid on frame F. It is if it can be found in F's
6615 x_check_font (struct frame
*f
, struct font
*font
)
6617 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
6618 if (font
->driver
->check
)
6619 eassert (font
->driver
->check (f
, font
) == 0);
6622 #endif /* GLYPH_DEBUG */
6624 /* Show hourglass cursor on frame F. */
6627 w32_show_hourglass (struct frame
*f
)
6629 if (!menubar_in_use
&& !current_popup_menu
)
6631 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6633 w32
->hourglass_p
= 1;
6634 SetCursor (w32
->hourglass_cursor
);
6638 /* Hide hourglass cursor on frame F. */
6641 w32_hide_hourglass (struct frame
*f
)
6643 struct w32_output
*w32
= FRAME_X_OUTPUT (f
);
6645 w32
->hourglass_p
= 0;
6646 if (f
->pointer_invisible
)
6649 SetCursor (w32
->current_cursor
);
6652 /* FIXME: old code did that, but I don't know why. Anyway,
6653 this is used for non-GUI frames (see cancel_hourglass). */
6656 w32_arrow_cursor (void)
6658 SetCursor (w32_load_cursor (IDC_ARROW
));
6662 w32_toggle_invisible_pointer (struct frame
*f
, bool invisible
)
6666 if (f
->pointer_invisible
!= invisible
)
6668 f
->pointer_invisible
= invisible
;
6669 w32_define_cursor (FRAME_W32_WINDOW (f
),
6670 f
->output_data
.w32
->current_cursor
);
6676 /***********************************************************************
6678 ***********************************************************************/
6680 static int w32_initialized
= 0;
6683 w32_initialize_display_info (Lisp_Object display_name
)
6685 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6687 memset (dpyinfo
, 0, sizeof (*dpyinfo
));
6689 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
6690 dpyinfo
->w32_id_name
= xmalloc (SCHARS (Vinvocation_name
)
6691 + SCHARS (Vsystem_name
) + 2);
6692 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6693 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6695 /* Default Console mode values - overridden when running in GUI mode
6696 with values obtained from system metrics. */
6699 dpyinfo
->n_planes
= 1;
6700 dpyinfo
->n_cbits
= 4;
6701 dpyinfo
->n_fonts
= 0;
6702 dpyinfo
->smallest_font_height
= 1;
6703 dpyinfo
->smallest_char_width
= 1;
6704 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6705 dpyinfo
->horizontal_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6706 /* TODO: dpyinfo->gray */
6708 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
6711 /* Create an xrdb-style database of resources to supersede registry settings.
6712 The database is just a concatenation of C strings, finished by an additional
6713 \0. The strings are submitted to some basic normalization, so
6715 [ *]option[ *]:[ *]value...
6721 but any whitespace following value is not removed. */
6724 w32_make_rdb (char *xrm_option
)
6726 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6727 char *current
= buffer
;
6730 int before_value
= 0;
6744 if (in_option
&& (ch
== ':'))
6749 else if (before_value
)
6754 else if (!(in_option
|| before_value
))
6765 extern frame_parm_handler w32_frame_parm_handlers
[];
6767 static struct redisplay_interface w32_redisplay_interface
=
6769 w32_frame_parm_handlers
,
6773 x_clear_end_of_line
,
6775 x_after_update_window_line
,
6776 x_update_window_begin
,
6777 x_update_window_end
,
6778 0, /* flush_display */
6779 x_clear_window_mouse_face
,
6780 x_get_glyph_overhangs
,
6781 x_fix_overlapping_area
,
6782 w32_draw_fringe_bitmap
,
6783 w32_define_fringe_bitmap
,
6784 w32_destroy_fringe_bitmap
,
6785 w32_compute_glyph_string_overhangs
,
6786 x_draw_glyph_string
,
6787 w32_define_frame_cursor
,
6788 w32_clear_frame_area
,
6789 w32_draw_window_cursor
,
6790 w32_draw_vertical_window_border
,
6791 w32_draw_window_divider
,
6792 w32_shift_glyphs_for_insert
,
6797 static void x_delete_terminal (struct terminal
*term
);
6799 static struct terminal
*
6800 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6802 struct terminal
*terminal
;
6804 terminal
= create_terminal (output_w32
, &w32_redisplay_interface
);
6806 terminal
->display_info
.w32
= dpyinfo
;
6807 dpyinfo
->terminal
= terminal
;
6809 /* MSVC does not type K&R functions with no arguments correctly, and
6810 so we must explicitly cast them. */
6811 terminal
->clear_frame_hook
= x_clear_frame
;
6812 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6813 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6814 terminal
->ring_bell_hook
= w32_ring_bell
;
6815 terminal
->toggle_invisible_pointer_hook
= w32_toggle_invisible_pointer
;
6816 terminal
->update_begin_hook
= x_update_begin
;
6817 terminal
->update_end_hook
= x_update_end
;
6818 terminal
->read_socket_hook
= w32_read_socket
;
6819 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6820 terminal
->mouse_position_hook
= w32_mouse_position
;
6821 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6822 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6823 terminal
->fullscreen_hook
= w32fullscreen_hook
;
6824 terminal
->menu_show_hook
= w32_menu_show
;
6825 terminal
->popup_dialog_hook
= w32_popup_dialog
;
6826 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6827 terminal
->set_horizontal_scroll_bar_hook
= w32_set_horizontal_scroll_bar
;
6828 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6829 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6830 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6831 terminal
->delete_frame_hook
= x_destroy_window
;
6832 terminal
->delete_terminal_hook
= x_delete_terminal
;
6833 /* Other hooks are NULL by default. */
6835 /* We don't yet support separate terminals on W32, so don't try to share
6836 keyboards between virtual terminals that are on the same physical
6837 terminal like X does. */
6838 terminal
->kboard
= allocate_kboard (Qw32
);
6839 /* Don't let the initial kboard remain current longer than necessary.
6840 That would cause problems if a file loaded on startup tries to
6841 prompt in the mini-buffer. */
6842 if (current_kboard
== initial_kboard
)
6843 current_kboard
= terminal
->kboard
;
6844 terminal
->kboard
->reference_count
++;
6850 x_delete_terminal (struct terminal
*terminal
)
6852 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
6854 /* Protect against recursive calls. delete_frame in
6855 delete_terminal calls us back when it deletes our last frame. */
6856 if (!terminal
->name
)
6861 x_delete_display (dpyinfo
);
6865 struct w32_display_info
*
6866 w32_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
6868 struct w32_display_info
*dpyinfo
;
6869 struct terminal
*terminal
;
6874 if (!w32_initialized
)
6877 w32_initialized
= 1;
6880 w32_initialize_display_info (display_name
);
6882 dpyinfo
= &one_w32_display_info
;
6883 terminal
= w32_create_terminal (dpyinfo
);
6885 /* Set the name of the terminal. */
6886 terminal
->name
= xlispstrdup (display_name
);
6888 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6890 /* Put this display on the chain. */
6891 dpyinfo
->next
= x_display_list
;
6892 x_display_list
= dpyinfo
;
6896 dpyinfo
->root_window
= GetDesktopWindow ();
6897 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6898 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6899 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6900 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6901 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6902 ReleaseDC (NULL
, hdc
);
6904 /* initialize palette with white and black */
6907 w32_defined_color (0, "white", &color
, 1);
6908 w32_defined_color (0, "black", &color
, 1);
6912 /* Add the default keyboard. When !WINDOWSNT, we're using the
6913 standard Emacs console handling machinery and don't need an
6914 explicit FD here. */
6915 add_keyboard_wait_descriptor (0);
6917 /* /dev/windows wakes us up when we have a thread message pending. */
6918 add_keyboard_wait_descriptor (w32_message_fd
);
6921 /* Create Fringe Bitmaps and store them for later use.
6923 On W32, bitmaps are all unsigned short, as Windows requires
6924 bitmap data to be Word aligned. For some reason they are
6925 horizontally reflected compared to how they appear on X, so we
6926 need to bitswap and convert to unsigned shorts before creating
6928 w32_init_fringe (terminal
->rif
);
6935 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6937 x_delete_display (struct w32_display_info
*dpyinfo
)
6939 /* FIXME: the only display info apparently can't be deleted. */
6940 /* free palette table */
6942 struct w32_palette_entry
* plist
;
6944 plist
= dpyinfo
->color_list
;
6947 struct w32_palette_entry
* pentry
= plist
;
6948 plist
= plist
->next
;
6951 dpyinfo
->color_list
= NULL
;
6952 if (dpyinfo
->palette
)
6953 DeleteObject (dpyinfo
->palette
);
6955 w32_reset_fringes ();
6959 /* Set up use of W32. */
6962 w32_init_main_thread (void)
6964 dwMainThreadId
= GetCurrentThreadId ();
6965 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6966 GetCurrentProcess (), &hMainThread
, 0, TRUE
,
6967 DUPLICATE_SAME_ACCESS
);
6972 DWORD WINAPI
w32_msg_worker (void * arg
);
6975 w32_initialize (void)
6978 HRESULT (WINAPI
* set_user_model
) (const wchar_t * id
);
6982 w32_system_caret_hwnd
= NULL
;
6983 w32_system_caret_height
= 0;
6984 w32_system_caret_x
= 0;
6985 w32_system_caret_y
= 0;
6987 /* On Windows 7 and later, we need to set the user model ID
6988 to associate emacsclient launched files with Emacs frames
6990 shell
= GetModuleHandle ("shell32.dll");
6994 = (void *) GetProcAddress (shell
,
6995 "SetCurrentProcessExplicitAppUserModelID");
6997 /* If the function is defined, then we are running on Windows 7
6998 or newer, and the UI uses this to group related windows
6999 together. Since emacs, runemacs, emacsclient are related, we
7000 want them grouped even though the executables are different,
7001 so we need to set a consistent ID between them. */
7003 set_user_model (L
"GNU.Emacs");
7007 if ((w32_message_fd
= emacs_open ("/dev/windows", O_RDWR
, 0)) == -1)
7008 fatal ("opening /dev/windows: %s", strerror (errno
));
7011 /* Initialize w32_use_visible_system_caret based on whether a screen
7012 reader is in use. */
7013 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
7014 &w32_use_visible_system_caret
, 0))
7015 w32_use_visible_system_caret
= 0;
7017 any_help_event_p
= 0;
7019 /* Initialize input mode: interrupt_input off, no flow control, allow
7020 8 bit character input, standard quit char. */
7021 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
7024 LCID input_locale_id
= LOWORD (GetKeyboardLayout (0));
7025 w32_keyboard_codepage
= codepage_for_locale (input_locale_id
);
7028 /* Create the window thread - it will terminate itself when the app
7032 /* Wait for thread to start */
7036 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
7038 hWindowsThread
= CreateThread (NULL
, 0,
7040 0, 0, &dwWindowsThreadId
);
7042 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
7045 /* It is desirable that mainThread should have the same notion of
7046 focus window and active window as windowsThread. Unfortunately, the
7047 following call to AttachThreadInput, which should do precisely what
7048 we need, causes major problems when Emacs is linked as a console
7049 program. Unfortunately, we have good reasons for doing that, so
7050 instead we need to send messages to windowsThread to make some API
7051 calls for us (ones that affect, or depend on, the active/focus
7053 #ifdef ATTACH_THREADS
7054 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
7057 /* Dynamically link to optional system components. */
7059 HMODULE user_lib
= GetModuleHandle ("user32.dll");
7061 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7063 LOAD_PROC (user_lib
, SetLayeredWindowAttributes
);
7067 /* Ensure scrollbar handles are at least 5 pixels. */
7068 vertical_scroll_bar_min_handle
= 5;
7069 horizontal_scroll_bar_min_handle
= 5;
7071 /* For either kind of scroll bar, take account of the arrows; these
7072 effectively form the border of the main scroll bar range. */
7073 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
7074 = GetSystemMetrics (SM_CYVSCROLL
);
7075 horizontal_scroll_bar_left_border
= horizontal_scroll_bar_right_border
7076 = GetSystemMetrics (SM_CYHSCROLL
);
7081 syms_of_w32term (void)
7083 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
7085 DEFSYM (Qadded
, "added");
7086 DEFSYM (Qremoved
, "removed");
7087 DEFSYM (Qmodified
, "modified");
7088 DEFSYM (Qrenamed_from
, "renamed-from");
7089 DEFSYM (Qrenamed_to
, "renamed-to");
7091 DEFVAR_INT ("w32-num-mouse-buttons",
7092 w32_num_mouse_buttons
,
7093 doc
: /* Number of physical mouse buttons. */);
7094 w32_num_mouse_buttons
= 2;
7096 DEFVAR_LISP ("w32-swap-mouse-buttons",
7097 Vw32_swap_mouse_buttons
,
7098 doc
: /* Swap the mapping of middle and right mouse buttons.
7099 When nil, middle button is mouse-2 and right button is mouse-3. */);
7100 Vw32_swap_mouse_buttons
= Qnil
;
7102 DEFVAR_LISP ("w32-grab-focus-on-raise",
7103 Vw32_grab_focus_on_raise
,
7104 doc
: /* Raised frame grabs input focus.
7105 When t, `raise-frame' grabs input focus as well. This fits well
7106 with the normal Windows click-to-focus policy, but might not be
7107 desirable when using a point-to-focus policy. */);
7108 Vw32_grab_focus_on_raise
= Qt
;
7110 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7111 Vw32_capslock_is_shiftlock
,
7112 doc
: /* Apply CapsLock state to non character input keys.
7113 When nil, CapsLock only affects normal character input keys. */);
7114 Vw32_capslock_is_shiftlock
= Qnil
;
7116 DEFVAR_LISP ("w32-recognize-altgr",
7117 Vw32_recognize_altgr
,
7118 doc
: /* Recognize right-alt and left-ctrl as AltGr.
7119 When nil, the right-alt and left-ctrl key combination is
7120 interpreted normally. */);
7121 Vw32_recognize_altgr
= Qt
;
7123 DEFVAR_BOOL ("w32-use-visible-system-caret",
7124 w32_use_visible_system_caret
,
7125 doc
: /* Flag to make the system caret visible.
7126 When this is non-nil, Emacs will indicate the position of point by
7127 using the system caret instead of drawing its own cursor. Some screen
7128 reader software does not track the system cursor properly when it is
7129 invisible, and gets confused by Emacs drawing its own cursor, so this
7130 variable is initialized to t when Emacs detects that screen reader
7131 software is running as it starts up.
7133 When this variable is set, other variables affecting the appearance of
7134 the cursor have no effect. */);
7136 w32_use_visible_system_caret
= 0;
7138 /* We don't yet support this, but defining this here avoids whining
7139 from cus-start.el and other places, like "M-x set-variable". */
7140 DEFVAR_BOOL ("x-use-underline-position-properties",
7141 x_use_underline_position_properties
,
7142 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
7143 A value of nil means ignore them. If you encounter fonts with bogus
7144 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7145 to 4.1, set this to nil. You can also use `underline-minimum-offset'
7146 to override the font's UNDERLINE_POSITION for small font display
7148 x_use_underline_position_properties
= 0;
7150 DEFVAR_BOOL ("x-underline-at-descent-line",
7151 x_underline_at_descent_line
,
7152 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
7153 A value of nil means to draw the underline according to the value of the
7154 variable `x-use-underline-position-properties', which is usually at the
7155 baseline level. The default value is nil. */);
7156 x_underline_at_descent_line
= 0;
7158 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
7159 doc
: /* Which toolkit scroll bars Emacs uses, if any.
7160 A value of nil means Emacs doesn't use toolkit scroll bars.
7161 With the X Window system, the value is a symbol describing the
7162 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
7163 With MS Windows or Nextstep, the value is t. */);
7164 Vx_toolkit_scroll_bars
= Qt
;
7166 DEFVAR_BOOL ("w32-unicode-filenames",
7167 w32_unicode_filenames
,
7168 doc
: /* Non-nil means use Unicode APIs when passing file names to the OS.
7169 A value of nil means file names passed to the OS APIs and returned
7170 from those APIs are encoded/decoded using the ANSI codepage
7171 specified by `file-name-coding-system'.
7173 This variable is set to non-nil by default when Emacs runs on Windows
7174 systems of the NT family, including W2K, XP, Vista, Windows 7 and
7175 Windows 8. It is set to nil on Windows 9X. */);
7176 w32_unicode_filenames
= 0;
7179 /* FIXME: The following variable will be (hopefully) removed
7180 before Emacs 25.1 gets released. */
7182 DEFVAR_BOOL ("w32-add-wrapped-menu-bar-lines",
7183 w32_add_wrapped_menu_bar_lines
,
7184 doc
: /* Non-nil means frame resizing accounts for wrapped menu bar lines.
7185 A value of nil means frame resizing does not add the height of wrapped
7186 menu bar lines when sending a frame resize request to the Windows API.
7187 This usually means that the resulting frame height is off by the number
7188 of wrapped menu bar lines. If this is non-nil, Emacs adds the height of
7189 wrapped menu bar lines when sending frame resize requests to the Windows
7191 w32_add_wrapped_menu_bar_lines
= 1;
7193 /* Tell Emacs about this window system. */
7194 Fprovide (Qw32
, Qnil
);