1 /* Implementation of GUI terminal on the Microsoft Windows API.
3 Copyright (C) 1989, 1993-2013 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
10 (at 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"
36 #include "character.h"
40 #include "dispextern.h"
42 #include "termhooks.h"
49 #include "intervals.h"
59 #include <io.h> /* for get_osfhandle */
69 static int max_fringe_bmp
= 0;
70 static HBITMAP
*fringe_bmp
= 0;
72 /* Temporary variables for w32_read_socket. */
74 static int last_mousemove_x
= 0;
75 static int last_mousemove_y
= 0;
77 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
78 #ifndef GET_WHEEL_DELTA_WPARAM
79 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
82 /* Non-zero means that a HELP_EVENT has been generated since Emacs
85 static int any_help_event_p
;
87 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
88 static Lisp_Object last_window
;
90 extern unsigned int msh_mousewheel
;
92 extern void free_frame_menubar (struct frame
*);
94 extern int w32_codepage_for_font (char *fontname
);
95 extern Cursor
w32_load_cursor (LPCTSTR name
);
97 #define x_any_window_to_frame x_window_to_frame
98 #define x_top_window_to_frame x_window_to_frame
101 /* This is display since w32 does not support multiple ones. */
102 struct w32_display_info one_w32_display_info
;
103 struct w32_display_info
*x_display_list
;
105 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
106 one for each element of w32_display_list and in the same order.
107 NAME is the name of the frame.
108 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
109 Lisp_Object w32_display_name_list
;
112 #if _WIN32_WINNT < 0x0500 && !defined(_W64)
113 /* Pre Windows 2000, this was not available, but define it here so
114 that Emacs compiled on such a platform will run on newer versions.
115 MinGW64 (_W64) defines these unconditionally, so avoid redefining. */
117 typedef struct tagWCRANGE
123 typedef struct tagGLYPHSET
127 DWORD cGlyphsSupported
;
132 #endif /* compiling for pre-Win2k */
134 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
135 BOOL (WINAPI
*pfnSetLayeredWindowAttributes
) (HWND
, COLORREF
, BYTE
, DWORD
);
138 #define LWA_ALPHA 0x02
140 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
141 later targets by MSVC headers. */
142 #ifndef WS_EX_LAYERED
143 #define WS_EX_LAYERED 0x80000
146 /* SM_CXVIRTUALSCREEN and SM_CYVIRTUALSCREEN are not defined on 95 and
148 #ifndef SM_CXVIRTUALSCREEN
149 #define SM_CXVIRTUALSCREEN 78
151 #ifndef SM_CYVIRTUALSCREEN
152 #define SM_CYVIRTUALSCREEN 79
155 /* This is a frame waiting to be autoraised, within w32_read_socket. */
156 struct frame
*pending_autoraise_frame
;
158 /* The handle of the frame that currently owns the system caret. */
159 HWND w32_system_caret_hwnd
;
160 int w32_system_caret_height
;
161 int w32_system_caret_x
;
162 int w32_system_caret_y
;
163 struct window
*w32_system_caret_window
;
164 int w32_system_caret_hdr_height
;
165 int w32_system_caret_mode_height
;
166 DWORD dwWindowsThreadId
= 0;
167 HANDLE hWindowsThread
= NULL
;
168 DWORD dwMainThreadId
= 0;
169 HANDLE hMainThread
= NULL
;
171 int vertical_scroll_bar_min_handle
;
172 int vertical_scroll_bar_top_border
;
173 int vertical_scroll_bar_bottom_border
;
175 int last_scroll_bar_drag_pos
;
177 /* Keyboard code page - may be changed by language-change events. */
178 int w32_keyboard_codepage
;
180 /* Mouse movement. */
182 /* Where the mouse was last time we reported a mouse event. */
183 static RECT last_mouse_glyph
;
184 static struct frame
*last_mouse_glyph_frame
;
186 /* The scroll bar in which the last motion event occurred.
188 If the last motion event occurred in a scroll bar, we set this
189 so w32_mouse_position can know whether to report a scroll bar motion or
192 If the last motion event didn't occur in a scroll bar, we set this
193 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
194 static Lisp_Object last_mouse_scroll_bar
;
195 static int last_mouse_scroll_bar_pos
;
197 /* This is a hack. We would really prefer that w32_mouse_position would
198 return the time associated with the position it returns, but there
199 doesn't seem to be any way to wrest the time-stamp from the server
200 along with the position query. So, we just keep track of the time
201 of the last movement we received, and return that in hopes that
202 it's somewhat accurate. */
203 static Time last_mouse_movement_time
;
205 /* Incremented by w32_read_socket whenever it really tries to read
207 static int volatile input_signal_count
;
210 int w32_message_fd
= -1;
213 static void x_update_window_end (struct window
*, int, int);
214 static void w32_handle_tool_bar_click (struct frame
*,
215 struct input_event
*);
216 static void w32_define_cursor (Window
, Cursor
);
218 void x_lower_frame (struct frame
*);
219 void x_scroll_bar_clear (struct frame
*);
220 void x_wm_set_size_hint (struct frame
*, long, bool);
221 void x_raise_frame (struct frame
*);
222 void x_set_window_size (struct frame
*, int, int, int);
223 void x_wm_set_window_state (struct frame
*, int);
224 void x_wm_set_icon_pixmap (struct frame
*, int);
225 static void w32_initialize (void);
226 static void x_update_end (struct frame
*);
227 static void w32_frame_up_to_date (struct frame
*);
228 static void w32_set_terminal_modes (struct terminal
*);
229 static void w32_reset_terminal_modes (struct terminal
*);
230 static void x_clear_frame (struct frame
*);
231 static void frame_highlight (struct frame
*);
232 static void frame_unhighlight (struct frame
*);
233 static void x_new_focus_frame (struct w32_display_info
*,
235 static void x_focus_changed (int, int, struct w32_display_info
*,
236 struct frame
*, struct input_event
*);
237 static void w32_detect_focus_change (struct w32_display_info
*,
238 W32Msg
*, struct input_event
*);
239 static void w32_frame_rehighlight (struct frame
*);
240 static void x_frame_rehighlight (struct w32_display_info
*);
241 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
242 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
243 enum text_cursor_kinds
);
244 static void w32_clip_to_row (struct window
*, struct glyph_row
*, int, HDC
);
245 static BOOL
my_show_window (struct frame
*, HWND
, int);
246 static void my_set_window_pos (HWND
, HWND
, int, int, int, int, UINT
);
248 static void my_set_focus (struct frame
*, HWND
);
250 static void my_set_foreground_window (HWND
);
251 static void my_destroy_window (struct frame
*, HWND
);
252 static void w32fullscreen_hook (struct frame
*);
255 static void x_check_font (struct frame
*, struct font
*);
258 static Lisp_Object Qvendor_specific_keysyms
;
259 static Lisp_Object Qadded
, Qremoved
, Qmodified
;
260 static Lisp_Object Qrenamed_from
, Qrenamed_to
;
263 /***********************************************************************
265 ***********************************************************************/
269 /* This is a function useful for recording debugging information about
270 the sequence of occurrences in this file. */
278 struct record event_record
[100];
280 int event_record_index
;
282 record_event (char *locus
, int type
)
284 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
285 event_record_index
= 0;
287 event_record
[event_record_index
].locus
= locus
;
288 event_record
[event_record_index
].type
= type
;
289 event_record_index
++;
296 XChangeGC (void *ignore
, XGCValues
*gc
, unsigned long mask
,
299 if (mask
& GCForeground
)
300 gc
->foreground
= xgcv
->foreground
;
301 if (mask
& GCBackground
)
302 gc
->background
= xgcv
->background
;
304 gc
->font
= xgcv
->font
;
308 XCreateGC (void *ignore
, Window window
, unsigned long mask
, XGCValues
*xgcv
)
310 XGCValues
*gc
= xzalloc (sizeof (XGCValues
));
312 XChangeGC (ignore
, gc
, mask
, xgcv
);
318 XGetGCValues (void *ignore
, XGCValues
*gc
,
319 unsigned long mask
, XGCValues
*xgcv
)
321 XChangeGC (ignore
, xgcv
, mask
, gc
);
325 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
329 HRGN clip_region
= CreateRectRgnIndirect (rect
);
330 SelectClipRgn (hdc
, clip_region
);
331 DeleteObject (clip_region
);
334 SelectClipRgn (hdc
, NULL
);
337 /* Restore clipping rectangle in S */
339 w32_restore_glyph_string_clip (struct glyph_string
*s
)
342 int n
= s
->num_clips
;
345 w32_set_clip_rectangle (s
->hdc
, r
);
348 HRGN clip1
= CreateRectRgnIndirect (r
);
349 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
350 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
351 SelectClipRgn (s
->hdc
, clip1
);
352 DeleteObject (clip1
);
353 DeleteObject (clip2
);
358 Draw a wavy line under S. The wave fills wave_height pixels from y0.
364 wave_height = 3 | * * * *
369 w32_draw_underwave (struct glyph_string
*s
, COLORREF color
)
371 int wave_height
= 3, wave_length
= 2;
372 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, odd
, xmax
;
373 XRectangle wave_clip
, string_clip
, final_clip
;
374 RECT w32_final_clip
, w32_string_clip
;
378 dy
= wave_height
- 1;
380 y0
= s
->ybase
- wave_height
+ 3;
384 /* Find and set clipping rectangle */
388 wave_clip
.width
= width
;
389 wave_clip
.height
= wave_height
;
391 get_glyph_string_clip_rect (s
, &w32_string_clip
);
392 CONVERT_TO_XRECT (string_clip
, w32_string_clip
);
394 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
397 hp
= CreatePen (PS_SOLID
, 0, color
);
398 oldhp
= SelectObject (s
->hdc
, hp
);
399 CONVERT_FROM_XRECT (final_clip
, w32_final_clip
);
400 w32_set_clip_rectangle (s
->hdc
, &w32_final_clip
);
414 MoveToEx (s
->hdc
, x1
, y1
, NULL
);
418 LineTo (s
->hdc
, x2
, y2
);
420 x2
+= dx
, y2
= y0
+ odd
*dy
;
424 /* Restore previous pen and clipping rectangle(s) */
425 w32_restore_glyph_string_clip (s
);
426 SelectObject (s
->hdc
, oldhp
);
430 /* Draw a hollow rectangle at the specified position. */
432 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
433 int width
, int height
)
438 hb
= CreateSolidBrush (gc
->background
);
439 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
440 oldhb
= SelectObject (hdc
, hb
);
441 oldhp
= SelectObject (hdc
, hp
);
443 Rectangle (hdc
, x
, y
, x
+ width
, y
+ height
);
445 SelectObject (hdc
, oldhb
);
446 SelectObject (hdc
, oldhp
);
451 /* Draw a filled rectangle at the specified position. */
453 w32_fill_rect (struct frame
*f
, HDC hdc
, COLORREF pix
, RECT
*lprect
)
457 hb
= CreateSolidBrush (pix
);
458 FillRect (hdc
, lprect
, hb
);
463 w32_clear_window (struct frame
*f
)
466 HDC hdc
= get_frame_dc (f
);
468 /* Under certain conditions, this can be called at startup with
469 a console frame pointer before the GUI frame is created. An HDC
470 of 0 indicates this. */
473 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
474 w32_clear_rect (f
, hdc
, &rect
);
477 release_frame_dc (f
, hdc
);
480 #define OPAQUE_FRAME 255
483 x_set_frame_alpha (struct frame
*f
)
485 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
487 double alpha_min
= 1.0;
490 HWND window
= FRAME_W32_WINDOW (f
);
492 /* Older versions of Windows do not support transparency. */
493 if (!pfnSetLayeredWindowAttributes
)
496 if (dpyinfo
->x_highlight_frame
== f
)
501 if (FLOATP (Vframe_alpha_lower_limit
))
502 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
503 else if (INTEGERP (Vframe_alpha_lower_limit
))
504 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
508 else if (alpha
> 1.0)
510 else if (alpha
< alpha_min
&& alpha_min
<= 1.0)
513 opac
= alpha
* OPAQUE_FRAME
;
515 ex_style
= GetWindowLong (window
, GWL_EXSTYLE
);
517 if (opac
== OPAQUE_FRAME
)
518 ex_style
&= ~WS_EX_LAYERED
;
520 ex_style
|= WS_EX_LAYERED
;
522 SetWindowLong (window
, GWL_EXSTYLE
, ex_style
);
524 if (opac
!= OPAQUE_FRAME
)
525 pfnSetLayeredWindowAttributes (window
, 0, opac
, LWA_ALPHA
);
529 x_display_pixel_height (struct w32_display_info
*dpyinfo
)
531 int pixels
= GetSystemMetrics (SM_CYVIRTUALSCREEN
);
534 /* Fallback for Windows 95 or NT 4.0. */
535 pixels
= GetSystemMetrics (SM_CYSCREEN
);
541 x_display_pixel_width (struct w32_display_info
*dpyinfo
)
543 int pixels
= GetSystemMetrics (SM_CXVIRTUALSCREEN
);
546 /* Fallback for Windows 95 or NT 4.0. */
547 pixels
= GetSystemMetrics (SM_CXSCREEN
);
553 /***********************************************************************
554 Starting and ending an update
555 ***********************************************************************/
557 /* Start an update of frame F. This function is installed as a hook
558 for update_begin, i.e. it is called when update_begin is called.
559 This function is called prior to calls to x_update_window_begin for
560 each window being updated. */
563 x_update_begin (struct frame
*f
)
565 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
567 if (! FRAME_W32_P (f
))
570 /* Regenerate display palette before drawing if list of requested
571 colors has changed. */
572 if (display_info
->regen_palette
)
574 w32_regenerate_palette (f
);
575 display_info
->regen_palette
= FALSE
;
580 /* Start update of window W. Set output_cursor to the cursor
584 x_update_window_begin (struct window
*w
)
586 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
587 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
589 /* Hide the system caret during an update. */
590 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
592 SendMessage (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0);
595 set_output_cursor (&w
->cursor
);
599 if (f
== hlinfo
->mouse_face_mouse_frame
)
601 /* Don't do highlighting for mouse motion during the update. */
602 hlinfo
->mouse_face_defer
= 1;
604 /* If F needs to be redrawn, simply forget about any prior mouse
606 if (FRAME_GARBAGED_P (f
))
607 hlinfo
->mouse_face_window
= Qnil
;
609 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
610 their mouse_face_p flag set, which means that they are always
611 unequal to rows in a desired matrix which never have that
612 flag set. So, rows containing mouse-face glyphs are never
613 scrolled, and we don't have to switch the mouse highlight off
614 here to prevent it from being scrolled. */
616 /* Can we tell that this update does not affect the window
617 where the mouse highlight is? If so, no need to turn off.
618 Likewise, don't do anything if the frame is garbaged;
619 in that case, the frame's current matrix that we would use
620 is all wrong, and we will redisplay that line anyway. */
621 if (!NILP (hlinfo
->mouse_face_window
)
622 && w
== XWINDOW (hlinfo
->mouse_face_window
))
626 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
627 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
630 if (i
< w
->desired_matrix
->nrows
)
631 clear_mouse_face (hlinfo
);
639 /* Draw a vertical window border from (x,y0) to (x,y1) */
642 w32_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
644 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
654 hdc
= get_frame_dc (f
);
655 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
657 w32_fill_rect (f
, hdc
, face
->foreground
, &r
);
659 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
661 release_frame_dc (f
, hdc
);
665 /* End update of window W.
667 Draw vertical borders between horizontally adjacent windows, and
668 display W's cursor if CURSOR_ON_P is non-zero.
670 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
671 glyphs in mouse-face were overwritten. In that case we have to
672 make sure that the mouse-highlight is properly redrawn.
674 W may be a menu bar pseudo-window in case we don't have X toolkit
675 support. Such windows don't have a cursor, so don't display it
679 x_update_window_end (struct window
*w
, int cursor_on_p
,
680 int mouse_face_overwritten_p
)
682 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
684 if (!w
->pseudo_window_p
)
689 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
691 output_cursor
.x
, output_cursor
.y
);
693 if (draw_window_fringes (w
, 1))
694 x_draw_vertical_border (w
);
699 /* If a row with mouse-face was overwritten, arrange for
700 XTframe_up_to_date to redisplay the mouse highlight. */
701 if (mouse_face_overwritten_p
)
703 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
704 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
705 hlinfo
->mouse_face_window
= Qnil
;
708 /* Unhide the caret. This won't actually show the cursor, unless it
709 was visible before the corresponding call to HideCaret in
710 x_update_window_begin. */
711 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
713 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
718 /* End update of frame F. This function is installed as a hook in
722 x_update_end (struct frame
*f
)
724 if (! FRAME_W32_P (f
))
727 /* Mouse highlight may be displayed again. */
728 MOUSE_HL_INFO (f
)->mouse_face_defer
= 0;
732 /* This function is called from various places in xdisp.c
733 whenever a complete update has been performed. */
736 w32_frame_up_to_date (struct frame
*f
)
739 FRAME_MOUSE_UPDATE (f
);
743 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
744 arrow bitmaps, or clear the fringes if no bitmaps are required
745 before DESIRED_ROW is made current. This function is called from
746 update_window_line only if it is known that there are differences
747 between bitmaps to be drawn between current row and DESIRED_ROW. */
750 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
757 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
758 desired_row
->redraw_fringe_bitmaps_p
= 1;
760 /* When a window has disappeared, make sure that no rest of
761 full-width rows stays visible in the internal border. Could
762 check here if updated window is the leftmost/rightmost window,
763 but I guess it's not worth doing since vertically split windows
764 are almost never used, internal border is rarely set, and the
765 overhead is very small. */
766 if (windows_or_buffers_changed
767 && desired_row
->full_width_p
768 && (f
= XFRAME (w
->frame
),
769 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
771 && (height
= desired_row
->visible_height
,
774 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
778 HDC hdc
= get_frame_dc (f
);
779 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
780 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
782 release_frame_dc (f
, hdc
);
789 /* Draw the bitmap WHICH in one of the left or right fringes of
790 window W. ROW is the glyph row for which to display the bitmap; it
791 determines the vertical position at which the bitmap has to be
795 w32_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
,
796 struct draw_fringe_bitmap_params
*p
)
798 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
800 struct face
*face
= p
->face
;
802 hdc
= get_frame_dc (f
);
806 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
808 /* If the fringe is adjacent to the left (right) scroll bar of a
809 leftmost (rightmost, respectively) window, then extend its
810 background to the gap between the fringe and the bar. */
811 if ((WINDOW_LEFTMOST_P (w
)
812 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
813 || (WINDOW_RIGHTMOST_P (w
)
814 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
816 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
820 int bar_area_x
= WINDOW_SCROLL_BAR_AREA_X (w
);
821 int bar_area_width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
822 * FRAME_COLUMN_WIDTH (f
));
826 /* Bitmap fills the fringe. */
827 if (bar_area_x
+ bar_area_width
== p
->x
)
828 bx
= bar_area_x
+ sb_width
;
829 else if (p
->x
+ p
->wd
== bar_area_x
)
833 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
835 nx
= bar_area_width
- sb_width
;
836 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
838 ny
= row
->visible_height
;
843 if (bar_area_x
+ bar_area_width
== bx
)
845 bx
= bar_area_x
+ sb_width
;
846 nx
+= bar_area_width
- sb_width
;
848 else if (bx
+ nx
== bar_area_x
)
849 nx
+= bar_area_width
- sb_width
;
854 if (bx
>= 0 && nx
> 0)
855 w32_fill_area (f
, hdc
, face
->background
, bx
, by
, nx
, ny
);
858 /* Must clip because of partially visible lines. */
859 w32_clip_to_row (w
, row
, -1, hdc
);
861 if (p
->which
&& p
->which
< max_fringe_bmp
)
863 HBITMAP pixmap
= fringe_bmp
[p
->which
];
867 compat_hdc
= CreateCompatibleDC (hdc
);
871 horig_obj
= SelectObject (compat_hdc
, pixmap
);
873 /* Paint overlays transparently. */
876 HBRUSH h_brush
, h_orig_brush
;
878 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
879 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
880 h_brush
= CreateSolidBrush (face
->foreground
);
881 h_orig_brush
= SelectObject (hdc
, h_brush
);
883 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
884 compat_hdc
, 0, p
->dh
,
886 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
887 compat_hdc
, 0, p
->dh
,
889 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
890 compat_hdc
, 0, p
->dh
,
893 SelectObject (hdc
, h_orig_brush
);
894 DeleteObject (h_brush
);
898 SetTextColor (hdc
, face
->background
);
899 SetBkColor (hdc
, (p
->cursor_p
900 ? f
->output_data
.w32
->cursor_pixel
901 : face
->foreground
));
903 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
904 compat_hdc
, 0, p
->dh
,
908 SelectObject (compat_hdc
, horig_obj
);
909 DeleteDC (compat_hdc
);
913 w32_set_clip_rectangle (hdc
, NULL
);
915 release_frame_dc (f
, hdc
);
919 w32_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
921 if (which
>= max_fringe_bmp
)
923 int i
= max_fringe_bmp
;
924 max_fringe_bmp
= which
+ 20;
925 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
926 while (i
< max_fringe_bmp
)
930 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
934 w32_destroy_fringe_bitmap (int which
)
936 if (which
>= max_fringe_bmp
)
939 if (fringe_bmp
[which
])
940 DeleteObject (fringe_bmp
[which
]);
941 fringe_bmp
[which
] = 0;
946 /* This is called when starting Emacs and when restarting after
947 suspend. When starting Emacs, no window is mapped. And nothing
948 must be done to Emacs's own window if it is suspended (though that
952 w32_set_terminal_modes (struct terminal
*term
)
956 /* This is called when exiting or suspending Emacs. Exiting will make
957 the W32 windows go away, and suspending requires no action. */
960 w32_reset_terminal_modes (struct terminal
*term
)
966 /***********************************************************************
968 ***********************************************************************/
970 /* Function prototypes of this page. */
972 static void x_set_glyph_string_clipping (struct glyph_string
*);
973 static void x_set_glyph_string_gc (struct glyph_string
*);
974 static void x_draw_glyph_string_background (struct glyph_string
*,
976 static void x_draw_glyph_string_foreground (struct glyph_string
*);
977 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
978 static void x_draw_glyph_string_box (struct glyph_string
*);
979 static void x_draw_glyph_string (struct glyph_string
*);
980 static void x_set_cursor_gc (struct glyph_string
*);
981 static void x_set_mode_line_face_gc (struct glyph_string
*);
982 static void x_set_mouse_face_gc (struct glyph_string
*);
983 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
984 static void w32_setup_relief_color (struct frame
*, struct relief
*,
985 double, int, COLORREF
);
986 static void x_setup_relief_colors (struct glyph_string
*);
987 static void x_draw_image_glyph_string (struct glyph_string
*);
988 static void x_draw_image_relief (struct glyph_string
*);
989 static void x_draw_image_foreground (struct glyph_string
*);
990 static void w32_draw_image_foreground_1 (struct glyph_string
*, HBITMAP
);
991 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
993 static void w32_draw_relief_rect (struct frame
*, int, int, int, int,
994 int, int, int, int, int, int,
996 static void w32_draw_box_rect (struct glyph_string
*, int, int, int, int,
997 int, int, int, RECT
*);
1000 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1004 x_set_cursor_gc (struct glyph_string
*s
)
1006 if (s
->font
== FRAME_FONT (s
->f
)
1007 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1008 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1010 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
1013 /* Cursor on non-default face: must merge. */
1017 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
1018 xgcv
.foreground
= s
->face
->background
;
1020 /* If the glyph would be invisible, try a different foreground. */
1021 if (xgcv
.foreground
== xgcv
.background
)
1022 xgcv
.foreground
= s
->face
->foreground
;
1023 if (xgcv
.foreground
== xgcv
.background
)
1024 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
1025 if (xgcv
.foreground
== xgcv
.background
)
1026 xgcv
.foreground
= s
->face
->foreground
;
1028 /* Make sure the cursor is distinct from text in this face. */
1029 if (xgcv
.background
== s
->face
->background
1030 && xgcv
.foreground
== s
->face
->foreground
)
1032 xgcv
.background
= s
->face
->foreground
;
1033 xgcv
.foreground
= s
->face
->background
;
1036 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1037 xgcv
.font
= s
->font
;
1038 mask
= GCForeground
| GCBackground
| GCFont
;
1040 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1041 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1044 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1045 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1047 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1052 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1055 x_set_mouse_face_gc (struct glyph_string
*s
)
1060 /* What face has to be used last for the mouse face? */
1061 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
1062 face
= FACE_FROM_ID (s
->f
, face_id
);
1064 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1066 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1067 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1069 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1070 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1071 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1073 /* If font in this face is same as S->font, use it. */
1074 if (s
->font
== s
->face
->font
)
1075 s
->gc
= s
->face
->gc
;
1078 /* Otherwise construct scratch_cursor_gc with values from FACE
1083 xgcv
.background
= s
->face
->background
;
1084 xgcv
.foreground
= s
->face
->foreground
;
1085 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1086 xgcv
.font
= s
->font
;
1087 mask
= GCForeground
| GCBackground
| GCFont
;
1089 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1090 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1093 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1094 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1096 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1099 eassert (s
->gc
!= 0);
1103 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1104 Faces to use in the mode line have already been computed when the
1105 matrix was built, so there isn't much to do, here. */
1108 x_set_mode_line_face_gc (struct glyph_string
*s
)
1110 s
->gc
= s
->face
->gc
;
1114 /* Set S->gc of glyph string S for drawing that glyph string. Set
1115 S->stippled_p to a non-zero value if the face of S has a stipple
1119 x_set_glyph_string_gc (struct glyph_string
*s
)
1121 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1123 if (s
->hl
== DRAW_NORMAL_TEXT
)
1125 s
->gc
= s
->face
->gc
;
1126 s
->stippled_p
= s
->face
->stipple
!= 0;
1128 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1130 x_set_mode_line_face_gc (s
);
1131 s
->stippled_p
= s
->face
->stipple
!= 0;
1133 else if (s
->hl
== DRAW_CURSOR
)
1135 x_set_cursor_gc (s
);
1138 else if (s
->hl
== DRAW_MOUSE_FACE
)
1140 x_set_mouse_face_gc (s
);
1141 s
->stippled_p
= s
->face
->stipple
!= 0;
1143 else if (s
->hl
== DRAW_IMAGE_RAISED
1144 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1146 s
->gc
= s
->face
->gc
;
1147 s
->stippled_p
= s
->face
->stipple
!= 0;
1151 s
->gc
= s
->face
->gc
;
1152 s
->stippled_p
= s
->face
->stipple
!= 0;
1155 /* GC must have been set. */
1156 eassert (s
->gc
!= 0);
1160 /* Set clipping for output of glyph string S. S may be part of a mode
1161 line or menu if we don't have X toolkit support. */
1164 x_set_glyph_string_clipping (struct glyph_string
*s
)
1167 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1170 w32_set_clip_rectangle (s
->hdc
, r
);
1173 HRGN clip1
= CreateRectRgnIndirect (r
);
1174 HRGN clip2
= CreateRectRgnIndirect (r
+ 1);
1175 if (CombineRgn (clip1
, clip1
, clip2
, RGN_OR
) != ERROR
)
1176 SelectClipRgn (s
->hdc
, clip1
);
1177 DeleteObject (clip1
);
1178 DeleteObject (clip2
);
1183 /* Set SRC's clipping for output of glyph string DST. This is called
1184 when we are drawing DST's left_overhang or right_overhang only in
1188 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
,
1189 struct glyph_string
*dst
)
1194 r
.right
= r
.left
+ src
->width
;
1196 r
.bottom
= r
.top
+ src
->height
;
1199 w32_set_clip_rectangle (dst
->hdc
, &r
);
1203 Compute left and right overhang of glyph string S. */
1206 w32_compute_glyph_string_overhangs (struct glyph_string
*s
)
1209 && s
->first_glyph
->type
== CHAR_GLYPH
1210 && !s
->font_not_found_p
)
1212 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1213 struct font
*font
= s
->font
;
1214 struct font_metrics metrics
;
1217 for (i
= 0; i
< s
->nchars
; i
++)
1218 code
[i
] = s
->char2b
[i
];
1219 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1220 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1221 ? metrics
.rbearing
- metrics
.width
: 0);
1222 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1226 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1227 s
->left_overhang
= -s
->cmp
->lbearing
;
1231 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1234 x_clear_glyph_string_rect (struct glyph_string
*s
,
1235 int x
, int y
, int w
, int h
)
1242 /* Take clipping into account. */
1243 if (s
->gc
->clip_mask
== Rect
)
1245 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1246 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1247 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1248 - s
->gc
->clip_rectangle
.left
);
1249 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1250 - s
->gc
->clip_rectangle
.top
);
1253 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1258 /* Draw the background of glyph_string S. If S->background_filled_p
1259 is non-zero don't draw it. FORCE_P non-zero means draw the
1260 background even if it wouldn't be drawn normally. This is used
1261 when a string preceding S draws into the background of S, or S
1262 contains the first component of a composition. */
1265 x_draw_glyph_string_background (struct glyph_string
*s
, int force_p
)
1267 /* Nothing to do if background has already been drawn or if it
1268 shouldn't be drawn in the first place. */
1269 if (!s
->background_filled_p
)
1271 int box_line_width
= max (s
->face
->box_line_width
, 0);
1273 #if 0 /* TODO: stipple */
1276 /* Fill background with a stipple pattern. */
1277 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1278 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1279 s
->y
+ box_line_width
,
1280 s
->background_width
,
1281 s
->height
- 2 * box_line_width
);
1282 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1283 s
->background_filled_p
= 1;
1287 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1288 || s
->font_not_found_p
1289 || s
->extends_to_end_of_line_p
1292 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1293 s
->background_width
,
1294 s
->height
- 2 * box_line_width
);
1295 s
->background_filled_p
= 1;
1301 /* Draw the foreground of glyph string S. */
1304 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1308 /* If first glyph of S has a left box line, start drawing the text
1309 of S to the right of that box line. */
1310 if (s
->face
->box
!= FACE_NO_BOX
1311 && s
->first_glyph
->left_box_line_p
)
1312 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1316 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1317 SetBkColor (s
->hdc
, s
->gc
->background
);
1318 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1320 /* Draw characters of S as rectangles if S's font could not be
1322 if (s
->font_not_found_p
)
1324 for (i
= 0; i
< s
->nchars
; ++i
)
1326 struct glyph
*g
= s
->first_glyph
+ i
;
1328 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1330 x
+= g
->pixel_width
;
1335 struct font
*font
= s
->font
;
1336 int boff
= font
->baseline_offset
;
1340 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1342 if (font
->vertical_centering
)
1343 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1345 y
= s
->ybase
- boff
;
1347 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1348 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1350 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1351 if (s
->face
->overstrike
)
1352 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1354 SelectObject (s
->hdc
, old_font
);
1358 /* Draw the foreground of composite glyph string S. */
1361 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1364 struct font
*font
= s
->font
;
1366 /* If first glyph of S has a left box line, start drawing the text
1367 of S to the right of that box line. */
1368 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1369 && s
->first_glyph
->left_box_line_p
)
1370 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1374 /* S is a glyph string for a composition. S->cmp_from is the index
1375 of the first character drawn for glyphs of this composition.
1376 S->cmp_from == 0 means we are drawing the very first character of
1377 this composition. */
1379 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1380 SetBkColor (s
->hdc
, s
->gc
->background
);
1381 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1383 /* Draw a rectangle for the composition if the font for the very
1384 first character of the composition could not be loaded. */
1385 if (s
->font_not_found_p
)
1387 if (s
->cmp_from
== 0)
1388 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1391 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1396 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1398 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1399 /* TAB in a composition means display glyphs with padding
1400 space on the left or right. */
1401 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1403 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1404 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1406 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1407 if (s
->face
->overstrike
)
1408 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1410 SelectObject (s
->hdc
, old_font
);
1414 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1420 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1422 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1424 glyph
= LGSTRING_GLYPH (gstring
, i
);
1425 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1426 width
+= LGLYPH_WIDTH (glyph
);
1429 int xoff
, yoff
, wadjust
;
1433 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1436 xoff
= LGLYPH_XOFF (glyph
);
1437 yoff
= LGLYPH_YOFF (glyph
);
1438 wadjust
= LGLYPH_WADJUST (glyph
);
1439 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1446 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1448 SelectObject (s
->hdc
, old_font
);
1453 /* Draw the foreground of glyph string S for glyphless characters. */
1456 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1458 struct glyph
*glyph
= s
->first_glyph
;
1461 int with_background
;
1463 /* If first glyph of S has a left box line, start drawing the text
1464 of S to the right of that box line. */
1465 if (s
->face
->box
!= FACE_NO_BOX
1466 && s
->first_glyph
->left_box_line_p
)
1467 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1471 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1472 SetBkColor (s
->hdc
, s
->gc
->background
);
1473 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1476 with_background
= ! (s
->for_overlaps
1477 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
));
1478 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1480 char buf
[7], *str
= NULL
;
1481 int len
= glyph
->u
.glyphless
.len
;
1483 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1486 && CHAR_TABLE_P (Vglyphless_char_display
)
1487 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1491 = (! glyph
->u
.glyphless
.for_no_font
1492 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1493 glyph
->u
.glyphless
.ch
)
1494 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1495 if (STRINGP (acronym
))
1496 str
= SSDATA (acronym
);
1499 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1501 sprintf ((char *) buf
, "%0*X",
1502 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1503 glyph
->u
.glyphless
.ch
);
1507 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1508 w32_draw_rectangle (s
->hdc
, s
->gc
,
1509 x
, s
->ybase
- glyph
->ascent
,
1510 glyph
->pixel_width
- 1,
1511 glyph
->ascent
+ glyph
->descent
- 1);
1514 struct font
*font
= s
->font
;
1515 int upper_len
= (len
+ 1) / 2;
1519 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1520 /* It is certain that all LEN characters in STR are ASCII. */
1521 for (j
= 0; j
< len
; j
++)
1523 code
= font
->driver
->encode_char (font
, str
[j
]);
1524 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1526 font
->driver
->draw (s
, 0, upper_len
,
1527 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1528 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1530 font
->driver
->draw (s
, upper_len
, len
,
1531 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1532 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1534 SelectObject (s
->hdc
, old_font
);
1536 x
+= glyph
->pixel_width
;
1541 /* Brightness beyond which a color won't have its highlight brightness
1544 Nominally, highlight colors for `3d' faces are calculated by
1545 brightening an object's color by a constant scale factor, but this
1546 doesn't yield good results for dark colors, so for colors whose
1547 brightness is less than this value (on a scale of 0-255) have to
1548 use an additional additive factor.
1550 The value here is set so that the default menu-bar/mode-line color
1551 (grey75) will not have its highlights changed at all. */
1552 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1555 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1556 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1557 If this produces the same color as COLOR, try a color where all RGB
1558 values have DELTA added. Return the allocated color in *COLOR.
1559 DISPLAY is the X display, CMAP is the colormap to operate on.
1560 Value is non-zero if successful. */
1563 w32_alloc_lighter_color (struct frame
*f
, COLORREF
*color
,
1564 double factor
, int delta
)
1569 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1572 /* Change RGB values by specified FACTOR. Avoid overflow! */
1573 eassert (factor
>= 0);
1574 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1575 min (0xff, factor
* GetGValue (*color
)),
1576 min (0xff, factor
* GetBValue (*color
)));
1578 /* Calculate brightness of COLOR. */
1579 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1580 + GetBValue (*color
)) / 6;
1582 /* We only boost colors that are darker than
1583 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1584 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1585 /* Make an additive adjustment to NEW, because it's dark enough so
1586 that scaling by FACTOR alone isn't enough. */
1588 /* How far below the limit this color is (0 - 1, 1 being darker). */
1589 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1590 /* The additive adjustment. */
1591 int min_delta
= delta
* dimness
* factor
/ 2;
1594 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1595 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1596 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1598 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1599 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1600 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1604 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1605 max (0, min (0xff, delta
+ GetGValue (*color
))),
1606 max (0, min (0xff, delta
+ GetBValue (*color
))));
1608 /* TODO: Map to palette and retry with delta if same? */
1609 /* TODO: Free colors (if using palette)? */
1619 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1620 colors in COLORS. On W32, we no longer try to map colors to
1623 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1627 for (i
= 0; i
< ncolors
; i
++)
1629 DWORD pixel
= colors
[i
].pixel
;
1630 /* Convert to a 16 bit value in range 0 - 0xffff. */
1631 colors
[i
].red
= GetRValue (pixel
) * 257;
1632 colors
[i
].green
= GetGValue (pixel
) * 257;
1633 colors
[i
].blue
= GetBValue (pixel
) * 257;
1638 x_query_color (struct frame
*f
, XColor
*color
)
1640 x_query_colors (f
, color
, 1);
1644 /* Set up the foreground color for drawing relief lines of glyph
1645 string S. RELIEF is a pointer to a struct relief containing the GC
1646 with which lines will be drawn. Use a color that is FACTOR or
1647 DELTA lighter or darker than the relief's background which is found
1648 in S->f->output_data.x->relief_background. If such a color cannot
1649 be allocated, use DEFAULT_PIXEL, instead. */
1652 w32_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
1653 int delta
, COLORREF default_pixel
)
1656 struct w32_output
*di
= f
->output_data
.w32
;
1657 unsigned long mask
= GCForeground
;
1659 COLORREF background
= di
->relief_background
;
1660 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
1662 /* TODO: Free colors (if using palette)? */
1664 /* Allocate new color. */
1665 xgcv
.foreground
= default_pixel
;
1667 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1669 relief
->allocated_p
= 1;
1670 xgcv
.foreground
= relief
->pixel
= pixel
;
1673 if (relief
->gc
== 0)
1675 #if 0 /* TODO: stipple */
1676 xgcv
.stipple
= dpyinfo
->gray
;
1679 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1682 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1686 /* Set up colors for the relief lines around glyph string S. */
1689 x_setup_relief_colors (struct glyph_string
*s
)
1691 struct w32_output
*di
= s
->f
->output_data
.w32
;
1694 if (s
->face
->use_box_color_for_shadows_p
)
1695 color
= s
->face
->box_color
;
1696 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1698 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1699 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1701 color
= s
->gc
->background
;
1703 if (di
->white_relief
.gc
== 0
1704 || color
!= di
->relief_background
)
1706 di
->relief_background
= color
;
1707 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1708 WHITE_PIX_DEFAULT (s
->f
));
1709 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1710 BLACK_PIX_DEFAULT (s
->f
));
1715 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1716 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1717 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1718 relief. LEFT_P non-zero means draw a relief on the left side of
1719 the rectangle. RIGHT_P non-zero means draw a relief on the right
1720 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1724 w32_draw_relief_rect (struct frame
*f
,
1725 int left_x
, int top_y
, int right_x
, int bottom_y
,
1726 int width
, int raised_p
,
1727 int top_p
, int bot_p
, int left_p
, int right_p
,
1732 HDC hdc
= get_frame_dc (f
);
1735 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1737 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1739 w32_set_clip_rectangle (hdc
, clip_rect
);
1743 for (i
= 0; i
< width
; ++i
)
1744 w32_fill_area (f
, hdc
, gc
.foreground
,
1745 left_x
+ i
* left_p
, top_y
+ i
,
1746 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1750 for (i
= 0; i
< width
; ++i
)
1751 w32_fill_area (f
, hdc
, gc
.foreground
,
1752 left_x
+ i
, top_y
+ (i
+ 1) * top_p
, 1,
1753 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1756 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1758 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1762 for (i
= 0; i
< width
; ++i
)
1763 w32_fill_area (f
, hdc
, gc
.foreground
,
1764 left_x
+ i
* left_p
, bottom_y
- i
,
1765 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1769 for (i
= 0; i
< width
; ++i
)
1770 w32_fill_area (f
, hdc
, gc
.foreground
,
1771 right_x
- i
, top_y
+ (i
+ 1) * top_p
, 1,
1772 bottom_y
- top_y
- (i
+ 1) * (bot_p
+ top_p
) + 1);
1774 w32_set_clip_rectangle (hdc
, NULL
);
1776 release_frame_dc (f
, hdc
);
1780 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1781 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1782 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1783 left side of the rectangle. RIGHT_P non-zero means draw a line
1784 on the right side of the rectangle. CLIP_RECT is the clipping
1785 rectangle to use when drawing. */
1788 w32_draw_box_rect (struct glyph_string
*s
,
1789 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1790 int left_p
, int right_p
, RECT
*clip_rect
)
1792 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1795 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1796 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1801 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1802 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1806 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1807 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1812 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1813 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1816 w32_set_clip_rectangle (s
->hdc
, NULL
);
1820 /* Draw a box around glyph string S. */
1823 x_draw_glyph_string_box (struct glyph_string
*s
)
1825 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
1826 int left_p
, right_p
;
1827 struct glyph
*last_glyph
;
1830 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1831 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1832 : window_box_right (s
->w
, s
->area
));
1834 /* The glyph that may have a right box line. */
1835 last_glyph
= (s
->cmp
|| s
->img
1837 : s
->first_glyph
+ s
->nchars
- 1);
1839 width
= eabs (s
->face
->box_line_width
);
1840 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1842 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1844 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1846 bottom_y
= top_y
+ s
->height
- 1;
1848 left_p
= (s
->first_glyph
->left_box_line_p
1849 || (s
->hl
== DRAW_MOUSE_FACE
1851 || s
->prev
->hl
!= s
->hl
)));
1852 right_p
= (last_glyph
->right_box_line_p
1853 || (s
->hl
== DRAW_MOUSE_FACE
1855 || s
->next
->hl
!= s
->hl
)));
1857 get_glyph_string_clip_rect (s
, &clip_rect
);
1859 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1860 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1861 left_p
, right_p
, &clip_rect
);
1864 x_setup_relief_colors (s
);
1865 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1866 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1871 /* Draw foreground of image glyph string S. */
1874 x_draw_image_foreground (struct glyph_string
*s
)
1877 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1879 /* If first glyph of S has a left box line, start drawing it to the
1880 right of that line. */
1881 if (s
->face
->box
!= FACE_NO_BOX
1882 && s
->first_glyph
->left_box_line_p
1884 x
+= eabs (s
->face
->box_line_width
);
1886 /* If there is a margin around the image, adjust x- and y-position
1888 if (s
->slice
.x
== 0)
1889 x
+= s
->img
->hmargin
;
1890 if (s
->slice
.y
== 0)
1891 y
+= s
->img
->vmargin
;
1897 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
1898 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1899 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
1900 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1901 SetBkColor (compat_hdc
, RGB (255, 255, 255));
1902 SetTextColor (s
->hdc
, RGB (0, 0, 0));
1903 x_set_glyph_string_clipping (s
);
1907 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
1908 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1910 SetTextColor (s
->hdc
, RGB (255, 255, 255));
1911 SetBkColor (s
->hdc
, RGB (0, 0, 0));
1913 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1914 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1915 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1916 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1917 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1918 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1920 SelectObject (mask_dc
, mask_orig_obj
);
1925 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1926 SetBkColor (s
->hdc
, s
->gc
->background
);
1928 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1929 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1931 /* When the image has a mask, we can expect that at
1932 least part of a mouse highlight or a block cursor will
1933 be visible. If the image doesn't have a mask, make
1934 a block cursor visible by drawing a rectangle around
1935 the image. I believe it's looking better if we do
1936 nothing here for mouse-face. */
1937 if (s
->hl
== DRAW_CURSOR
)
1939 int r
= s
->img
->relief
;
1941 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
1942 s
->slice
.width
+ r
*2 - 1,
1943 s
->slice
.height
+ r
*2 - 1);
1947 w32_set_clip_rectangle (s
->hdc
, NULL
);
1948 SelectObject (s
->hdc
, orig_brush
);
1949 DeleteObject (fg_brush
);
1950 SelectObject (compat_hdc
, orig_obj
);
1951 DeleteDC (compat_hdc
);
1954 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
1955 s
->slice
.width
- 1, s
->slice
.height
- 1);
1957 RestoreDC (s
->hdc
,-1);
1961 /* Draw a relief around the image glyph string S. */
1964 x_draw_image_relief (struct glyph_string
*s
)
1966 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
1969 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1971 /* If first glyph of S has a left box line, start drawing it to the
1972 right of that line. */
1973 if (s
->face
->box
!= FACE_NO_BOX
1974 && s
->first_glyph
->left_box_line_p
1976 x
+= eabs (s
->face
->box_line_width
);
1978 /* If there is a margin around the image, adjust x- and y-position
1980 if (s
->slice
.x
== 0)
1981 x
+= s
->img
->hmargin
;
1982 if (s
->slice
.y
== 0)
1983 y
+= s
->img
->vmargin
;
1985 if (s
->hl
== DRAW_IMAGE_SUNKEN
1986 || s
->hl
== DRAW_IMAGE_RAISED
)
1988 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
1989 : DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
1990 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
1994 thick
= eabs (s
->img
->relief
);
1995 raised_p
= s
->img
->relief
> 0;
1998 x1
= x
+ s
->slice
.width
- 1;
1999 y1
= y
+ s
->slice
.height
- 1;
2000 top_p
= bot_p
= left_p
= right_p
= 0;
2002 if (s
->slice
.x
== 0)
2003 x
-= thick
, left_p
= 1;
2004 if (s
->slice
.y
== 0)
2005 y
-= thick
, top_p
= 1;
2006 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
2007 x1
+= thick
, right_p
= 1;
2008 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
2009 y1
+= thick
, bot_p
= 1;
2011 x_setup_relief_colors (s
);
2012 get_glyph_string_clip_rect (s
, &r
);
2013 w32_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
2014 top_p
, bot_p
, left_p
, right_p
, &r
);
2018 /* Draw the foreground of image glyph string S to PIXMAP. */
2021 w32_draw_image_foreground_1 (struct glyph_string
*s
, HBITMAP pixmap
)
2023 HDC hdc
= CreateCompatibleDC (s
->hdc
);
2024 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
2026 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2028 /* If first glyph of S has a left box line, start drawing it to the
2029 right of that line. */
2030 if (s
->face
->box
!= FACE_NO_BOX
2031 && s
->first_glyph
->left_box_line_p
2033 x
+= eabs (s
->face
->box_line_width
);
2035 /* If there is a margin around the image, adjust x- and y-position
2037 if (s
->slice
.x
== 0)
2038 x
+= s
->img
->hmargin
;
2039 if (s
->slice
.y
== 0)
2040 y
+= s
->img
->vmargin
;
2044 HDC compat_hdc
= CreateCompatibleDC (hdc
);
2045 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2046 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
2047 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2051 HDC mask_dc
= CreateCompatibleDC (hdc
);
2052 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2054 SetTextColor (hdc
, RGB (0, 0, 0));
2055 SetBkColor (hdc
, RGB (255, 255, 255));
2056 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2057 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2058 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2059 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2060 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2061 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2063 SelectObject (mask_dc
, mask_orig_obj
);
2068 SetTextColor (hdc
, s
->gc
->foreground
);
2069 SetBkColor (hdc
, s
->gc
->background
);
2071 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2072 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2074 /* When the image has a mask, we can expect that at
2075 least part of a mouse highlight or a block cursor will
2076 be visible. If the image doesn't have a mask, make
2077 a block cursor visible by drawing a rectangle around
2078 the image. I believe it's looking better if we do
2079 nothing here for mouse-face. */
2080 if (s
->hl
== DRAW_CURSOR
)
2082 int r
= s
->img
->relief
;
2084 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2085 s
->slice
.width
+ r
*2 - 1,
2086 s
->slice
.height
+ r
*2 - 1);
2090 SelectObject (hdc
, orig_brush
);
2091 DeleteObject (fg_brush
);
2092 SelectObject (compat_hdc
, orig_obj
);
2093 DeleteDC (compat_hdc
);
2096 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2097 s
->slice
.width
- 1, s
->slice
.height
- 1);
2099 SelectObject (hdc
, orig_hdc_obj
);
2104 /* Draw part of the background of glyph string S. X, Y, W, and H
2105 give the rectangle to draw. */
2108 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2110 #if 0 /* TODO: stipple */
2113 /* Fill background with a stipple pattern. */
2114 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2115 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2116 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2120 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2124 /* Draw image glyph string S.
2127 s->x +-------------------------
2130 | +-------------------------
2133 | | +-------------------
2139 x_draw_image_glyph_string (struct glyph_string
*s
)
2142 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2143 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2147 height
= s
->height
- 2 * box_line_vwidth
;
2149 /* Fill background with face under the image. Do it only if row is
2150 taller than image or if image has a clip mask to reduce
2152 s
->stippled_p
= s
->face
->stipple
!= 0;
2153 if (height
> s
->slice
.height
2157 || s
->img
->pixmap
== 0
2158 || s
->width
!= s
->background_width
)
2161 if (s
->first_glyph
->left_box_line_p
2163 x
+= box_line_hwidth
;
2166 if (s
->slice
.y
== 0)
2167 y
+= box_line_vwidth
;
2169 #if 0 /* TODO: figure out if we need to do this on Windows. */
2172 /* Create a pixmap as large as the glyph string. Fill it
2173 with the background color. Copy the image to it, using
2174 its mask. Copy the temporary pixmap to the display. */
2175 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2176 int depth
= DefaultDepthOfScreen (screen
);
2178 /* Create a pixmap as large as the glyph string. */
2179 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2180 s
->background_width
,
2183 /* Don't clip in the following because we're working on the
2185 XSetClipMask (s
->display
, s
->gc
, None
);
2187 /* Fill the pixmap with the background color/stipple. */
2190 /* Fill background with a stipple pattern. */
2191 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2192 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2193 0, 0, s
->background_width
, s
->height
);
2194 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2199 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2201 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2202 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2203 0, 0, s
->background_width
, s
->height
);
2204 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2209 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2211 s
->background_filled_p
= 1;
2214 /* Draw the foreground. */
2217 w32_draw_image_foreground_1 (s
, pixmap
);
2218 x_set_glyph_string_clipping (s
);
2220 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2221 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2222 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2223 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2225 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2226 SetBkColor (s
->hdc
, s
->gc
->background
);
2227 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2228 compat_hdc
, 0, 0, SRCCOPY
);
2230 SelectObject (s
->hdc
, orig_brush
);
2231 DeleteObject (fg_brush
);
2232 SelectObject (compat_hdc
, orig_obj
);
2233 DeleteDC (compat_hdc
);
2235 DeleteObject (pixmap
);
2239 x_draw_image_foreground (s
);
2241 /* If we must draw a relief around the image, do it. */
2243 || s
->hl
== DRAW_IMAGE_RAISED
2244 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2245 x_draw_image_relief (s
);
2249 /* Draw stretch glyph string S. */
2252 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2254 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2256 if (s
->hl
== DRAW_CURSOR
2257 && !x_stretch_cursor_p
)
2259 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2260 wide as the stretch glyph. */
2261 int width
, background_width
= s
->background_width
;
2264 if (!s
->row
->reversed_p
)
2266 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2270 background_width
-= left_x
- x
;
2276 /* In R2L rows, draw the cursor on the right edge of the
2278 int right_x
= window_box_right_offset (s
->w
, TEXT_AREA
);
2280 if (x
+ background_width
> right_x
)
2281 background_width
-= x
- right_x
;
2282 x
+= background_width
;
2284 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2285 if (s
->row
->reversed_p
)
2289 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2291 /* Clear rest using the GC of the original non-cursor face. */
2292 if (width
< background_width
)
2294 XGCValues
*gc
= s
->face
->gc
;
2296 int w
= background_width
- width
, h
= s
->height
;
2300 if (!s
->row
->reversed_p
)
2304 if (s
->row
->mouse_face_p
2305 && cursor_in_mouse_face_p (s
->w
))
2307 x_set_mouse_face_gc (s
);
2313 get_glyph_string_clip_rect (s
, &r
);
2314 w32_set_clip_rectangle (hdc
, &r
);
2316 #if 0 /* TODO: stipple */
2317 if (s
->face
->stipple
)
2319 /* Fill background with a stipple pattern. */
2320 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2321 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2322 XSetFillStyle (s
->display
, gc
, FillSolid
);
2327 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2331 else if (!s
->background_filled_p
)
2333 int background_width
= s
->background_width
;
2334 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2336 /* Don't draw into left margin, fringe or scrollbar area
2337 except for header line and mode line. */
2338 if (x
< left_x
&& !s
->row
->mode_line_p
)
2340 background_width
-= left_x
- x
;
2343 if (background_width
> 0)
2344 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2347 s
->background_filled_p
= 1;
2351 /* Draw glyph string S. */
2354 x_draw_glyph_string (struct glyph_string
*s
)
2356 bool relief_drawn_p
= 0;
2358 /* If S draws into the background of its successor, draw the
2359 background of the successor first so that S can draw into it.
2360 This makes S->next use XDrawString instead of XDrawImageString. */
2361 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2364 struct glyph_string
*next
;
2365 for (width
= 0, next
= s
->next
;
2366 next
&& width
< s
->right_overhang
;
2367 width
+= next
->width
, next
= next
->next
)
2368 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2370 x_set_glyph_string_gc (next
);
2371 x_set_glyph_string_clipping (next
);
2372 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2373 x_draw_stretch_glyph_string (next
);
2375 x_draw_glyph_string_background (next
, 1);
2376 next
->num_clips
= 0;
2380 /* Set up S->gc, set clipping and draw S. */
2381 x_set_glyph_string_gc (s
);
2383 /* Draw relief (if any) in advance for char/composition so that the
2384 glyph string can be drawn over it. */
2385 if (!s
->for_overlaps
2386 && s
->face
->box
!= FACE_NO_BOX
2387 && (s
->first_glyph
->type
== CHAR_GLYPH
2388 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2391 x_set_glyph_string_clipping (s
);
2392 x_draw_glyph_string_background (s
, 1);
2393 x_draw_glyph_string_box (s
);
2394 x_set_glyph_string_clipping (s
);
2397 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2399 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2400 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2401 /* We must clip just this glyph. left_overhang part has already
2402 drawn when s->prev was drawn, and right_overhang part will be
2403 drawn later when s->next is drawn. */
2404 x_set_glyph_string_clipping_exactly (s
, s
);
2406 x_set_glyph_string_clipping (s
);
2408 switch (s
->first_glyph
->type
)
2411 x_draw_image_glyph_string (s
);
2415 x_draw_stretch_glyph_string (s
);
2419 if (s
->for_overlaps
)
2420 s
->background_filled_p
= 1;
2422 x_draw_glyph_string_background (s
, 0);
2423 x_draw_glyph_string_foreground (s
);
2426 case COMPOSITE_GLYPH
:
2427 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2428 && ! s
->first_glyph
->u
.cmp
.automatic
))
2429 s
->background_filled_p
= 1;
2431 x_draw_glyph_string_background (s
, 1);
2432 x_draw_composite_glyph_string_foreground (s
);
2435 case GLYPHLESS_GLYPH
:
2436 if (s
->for_overlaps
)
2437 s
->background_filled_p
= 1;
2439 x_draw_glyph_string_background (s
, 0);
2440 x_draw_glyphless_glyph_string_foreground (s
);
2447 if (!s
->for_overlaps
)
2449 /* Draw underline. */
2450 if (s
->face
->underline_p
)
2452 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2456 if (s
->face
->underline_defaulted_p
)
2457 color
= s
->gc
->foreground
;
2459 color
= s
->face
->underline_color
;
2461 w32_draw_underwave (s
, color
);
2463 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2465 unsigned long thickness
, position
;
2468 if (s
->prev
&& s
->prev
->face
->underline_p
2469 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2471 /* We use the same underline style as the previous one. */
2472 thickness
= s
->prev
->underline_thickness
;
2473 position
= s
->prev
->underline_position
;
2477 /* Get the underline thickness. Default is 1 pixel. */
2478 if (s
->font
&& s
->font
->underline_thickness
> 0)
2479 thickness
= s
->font
->underline_thickness
;
2482 if (x_underline_at_descent_line
)
2483 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2486 /* Get the underline position. This is the recommended
2487 vertical offset in pixels from the baseline to the top of
2488 the underline. This is a signed value according to the
2489 specs, and its default is
2491 ROUND ((maximum_descent) / 2), with
2492 ROUND (x) = floor (x + 0.5) */
2494 if (x_use_underline_position_properties
2495 && s
->font
&& s
->font
->underline_position
>= 0)
2496 position
= s
->font
->underline_position
;
2498 position
= (s
->font
->descent
+ 1) / 2;
2500 position
= max (position
, underline_minimum_offset
);
2502 /* Check the sanity of thickness and position. We should
2503 avoid drawing underline out of the current line area. */
2504 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2505 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2506 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2507 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2508 s
->underline_thickness
= thickness
;
2509 s
->underline_position
=position
;
2510 y
= s
->ybase
+ position
;
2511 if (s
->face
->underline_defaulted_p
)
2513 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2518 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2523 /* Draw overline. */
2524 if (s
->face
->overline_p
)
2526 unsigned long dy
= 0, h
= 1;
2528 if (s
->face
->overline_color_defaulted_p
)
2530 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2531 s
->y
+ dy
, s
->width
, h
);
2535 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2536 s
->y
+ dy
, s
->width
, h
);
2540 /* Draw strike-through. */
2541 if (s
->face
->strike_through_p
2542 && !FONT_TEXTMETRIC (s
->font
).tmStruckOut
)
2544 unsigned long h
= 1;
2545 unsigned long dy
= (s
->height
- h
) / 2;
2547 if (s
->face
->strike_through_color_defaulted_p
)
2549 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2554 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2555 s
->y
+ dy
, s
->width
, h
);
2559 /* Draw relief if not yet drawn. */
2560 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2561 x_draw_glyph_string_box (s
);
2565 struct glyph_string
*prev
;
2567 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2568 if (prev
->hl
!= s
->hl
2569 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2571 /* As prev was drawn while clipped to its own area, we
2572 must draw the right_overhang part using s->hl now. */
2573 enum draw_glyphs_face save
= prev
->hl
;
2576 x_set_glyph_string_gc (prev
);
2577 x_set_glyph_string_clipping_exactly (s
, prev
);
2578 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2579 x_draw_glyph_string_foreground (prev
);
2581 x_draw_composite_glyph_string_foreground (prev
);
2582 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2584 prev
->num_clips
= 0;
2590 struct glyph_string
*next
;
2592 for (next
= s
->next
; next
; next
= next
->next
)
2593 if (next
->hl
!= s
->hl
2594 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2596 /* As next will be drawn while clipped to its own area,
2597 we must draw the left_overhang part using s->hl now. */
2598 enum draw_glyphs_face save
= next
->hl
;
2601 x_set_glyph_string_gc (next
);
2602 x_set_glyph_string_clipping_exactly (s
, next
);
2603 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2604 x_draw_glyph_string_foreground (next
);
2606 x_draw_composite_glyph_string_foreground (next
);
2607 w32_set_clip_rectangle (next
->hdc
, NULL
);
2609 next
->num_clips
= 0;
2610 next
->clip_head
= s
->next
;
2615 /* Reset clipping. */
2616 w32_set_clip_rectangle (s
->hdc
, NULL
);
2621 /* Shift display to make room for inserted glyphs. */
2624 w32_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
,
2625 int width
, int height
, int shift_by
)
2629 hdc
= get_frame_dc (f
);
2630 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2631 hdc
, x
, y
, SRCCOPY
);
2633 release_frame_dc (f
, hdc
);
2637 /* Delete N glyphs at the nominal cursor position. Not implemented
2641 x_delete_glyphs (struct frame
*f
, register int n
)
2643 if (! FRAME_W32_P (f
))
2650 /* Clear entire frame. */
2653 x_clear_frame (struct frame
*f
)
2655 if (! FRAME_W32_P (f
))
2658 /* Clearing the frame will erase any cursor, so mark them all as no
2660 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2661 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2662 output_cursor
.x
= -1;
2664 /* We don't set the output cursor here because there will always
2665 follow an explicit cursor_to. */
2668 w32_clear_window (f
);
2670 /* We have to clear the scroll bars, too. If we have changed
2671 colors or something like that, then they should be notified. */
2672 x_scroll_bar_clear (f
);
2678 /* Make audible bell. */
2681 w32_ring_bell (struct frame
*f
)
2685 if (FRAME_W32_P (f
) && visible_bell
)
2688 HWND hwnd
= FRAME_W32_WINDOW (f
);
2690 for (i
= 0; i
< 5; i
++)
2692 FlashWindow (hwnd
, TRUE
);
2695 FlashWindow (hwnd
, FALSE
);
2698 w32_sys_ring_bell (f
);
2704 /* Specify how many text lines, from the top of the window,
2705 should be affected by insert-lines and delete-lines operations.
2706 This, and those operations, are used only within an update
2707 that is bounded by calls to x_update_begin and x_update_end. */
2710 w32_set_terminal_window (struct frame
*f
, int n
)
2712 /* This function intentionally left blank. */
2716 /***********************************************************************
2718 ***********************************************************************/
2720 /* Perform an insert-lines or delete-lines operation, inserting N
2721 lines or deleting -N lines at vertical position VPOS. */
2724 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
2726 if (! FRAME_W32_P (f
))
2733 /* Scroll part of the display as described by RUN. */
2736 x_scroll_run (struct window
*w
, struct run
*run
)
2738 struct frame
*f
= XFRAME (w
->frame
);
2739 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2740 HWND hwnd
= FRAME_W32_WINDOW (f
);
2743 /* Get frame-relative bounding box of the text display area of W,
2744 without mode lines. Include in this box the left and right
2746 window_box (w
, -1, &x
, &y
, &width
, &height
);
2748 /* If the fringe is adjacent to the left (right) scroll bar of a
2749 leftmost (rightmost, respectively) window, then extend its
2750 background to the gap between the fringe and the bar. */
2751 if ((WINDOW_LEFTMOST_P (w
)
2752 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
2753 || (WINDOW_RIGHTMOST_P (w
)
2754 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
2756 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
2760 int bar_area_x
= WINDOW_SCROLL_BAR_AREA_X (w
);
2761 int bar_area_width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
2762 * FRAME_COLUMN_WIDTH (f
));
2764 if (bar_area_x
+ bar_area_width
== x
)
2766 x
= bar_area_x
+ sb_width
;
2767 width
+= bar_area_width
- sb_width
;
2769 else if (x
+ width
== bar_area_x
)
2770 width
+= bar_area_width
- sb_width
;
2774 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2775 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2776 bottom_y
= y
+ height
;
2780 /* Scrolling up. Make sure we don't copy part of the mode
2781 line at the bottom. */
2782 if (from_y
+ run
->height
> bottom_y
)
2783 height
= bottom_y
- from_y
;
2785 height
= run
->height
;
2786 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2790 /* Scrolling down. Make sure we don't copy over the mode line.
2792 if (to_y
+ run
->height
> bottom_y
)
2793 height
= bottom_y
- to_y
;
2795 height
= run
->height
;
2796 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2801 /* Cursor off. Will be switched on again in x_update_window_end. */
2807 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2808 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2810 from
.left
= to
.left
= x
;
2811 from
.right
= to
.right
= x
+ width
;
2813 from
.bottom
= from_y
+ height
;
2815 to
.bottom
= bottom_y
;
2817 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2818 NULL
, SW_INVALIDATE
);
2820 /* Combine this with what we expect to be dirty. This covers the
2821 case where not all of the region we expect is actually dirty. */
2822 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2824 /* If the dirty region is not what we expected, redraw the entire frame. */
2825 if (!EqualRgn (combined
, expect_dirty
))
2826 SET_FRAME_GARBAGED (f
);
2828 DeleteObject (dirty
);
2829 DeleteObject (combined
);
2833 DeleteObject (expect_dirty
);
2838 /***********************************************************************
2840 ***********************************************************************/
2843 frame_highlight (struct frame
*f
)
2845 x_update_cursor (f
, 1);
2846 x_set_frame_alpha (f
);
2850 frame_unhighlight (struct frame
*f
)
2852 x_update_cursor (f
, 1);
2853 x_set_frame_alpha (f
);
2856 /* The focus has changed. Update the frames as necessary to reflect
2857 the new situation. Note that we can't change the selected frame
2858 here, because the Lisp code we are interrupting might become confused.
2859 Each event gets marked with the frame in which it occurred, so the
2860 Lisp code can tell when the switch took place by examining the events. */
2863 x_new_focus_frame (struct w32_display_info
*dpyinfo
, struct frame
*frame
)
2865 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2867 if (frame
!= dpyinfo
->w32_focus_frame
)
2869 /* Set this before calling other routines, so that they see
2870 the correct value of w32_focus_frame. */
2871 dpyinfo
->w32_focus_frame
= frame
;
2873 if (old_focus
&& old_focus
->auto_lower
)
2874 x_lower_frame (old_focus
);
2876 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2877 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2879 pending_autoraise_frame
= 0;
2882 x_frame_rehighlight (dpyinfo
);
2886 /* Handle FocusIn and FocusOut state changes for FRAME.
2887 If FRAME has focus and there exists more than one frame, puts
2888 a FOCUS_IN_EVENT into *BUFP. */
2891 x_focus_changed (int type
, int state
, struct w32_display_info
*dpyinfo
,
2892 struct frame
*frame
, struct input_event
*bufp
)
2894 if (type
== WM_SETFOCUS
)
2896 if (dpyinfo
->w32_focus_event_frame
!= frame
)
2898 x_new_focus_frame (dpyinfo
, frame
);
2899 dpyinfo
->w32_focus_event_frame
= frame
;
2901 /* Don't stop displaying the initial startup message
2902 for a switch-frame event we don't need. */
2903 if (NILP (Vterminal_frame
)
2904 && CONSP (Vframe_list
)
2905 && !NILP (XCDR (Vframe_list
)))
2914 bufp
->kind
= FOCUS_IN_EVENT
;
2915 XSETFRAME (bufp
->frame_or_window
, frame
);
2918 frame
->output_data
.x
->focus_state
|= state
;
2920 /* TODO: IME focus? */
2922 else if (type
== WM_KILLFOCUS
)
2924 frame
->output_data
.x
->focus_state
&= ~state
;
2926 if (dpyinfo
->w32_focus_event_frame
== frame
)
2928 dpyinfo
->w32_focus_event_frame
= 0;
2929 x_new_focus_frame (dpyinfo
, 0);
2931 bufp
->kind
= FOCUS_OUT_EVENT
;
2932 XSETFRAME (bufp
->frame_or_window
, frame
);
2935 /* TODO: IME focus? */
2940 /* The focus may have changed. Figure out if it is a real focus change,
2941 by checking both FocusIn/Out and Enter/LeaveNotify events.
2943 Returns FOCUS_IN_EVENT event in *BUFP. */
2946 w32_detect_focus_change (struct w32_display_info
*dpyinfo
, W32Msg
*event
,
2947 struct input_event
*bufp
)
2949 struct frame
*frame
;
2951 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
2955 /* On w32, this is only called from focus events, so no switch needed. */
2956 x_focus_changed (event
->msg
.message
,
2957 (event
->msg
.message
== WM_KILLFOCUS
?
2958 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
2959 dpyinfo
, frame
, bufp
);
2963 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2966 x_mouse_leave (struct w32_display_info
*dpyinfo
)
2968 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2971 /* The focus has changed, or we have redirected a frame's focus to
2972 another frame (this happens when a frame uses a surrogate
2973 mini-buffer frame). Shift the highlight as appropriate.
2975 The FRAME argument doesn't necessarily have anything to do with which
2976 frame is being highlighted or un-highlighted; we only use it to find
2977 the appropriate X display info. */
2980 w32_frame_rehighlight (struct frame
*frame
)
2982 if (! FRAME_W32_P (frame
))
2984 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
2988 x_frame_rehighlight (struct w32_display_info
*dpyinfo
)
2990 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2992 if (dpyinfo
->w32_focus_frame
)
2994 dpyinfo
->x_highlight_frame
2995 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2996 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2997 : dpyinfo
->w32_focus_frame
);
2998 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3000 fset_focus_frame (dpyinfo
->w32_focus_frame
, Qnil
);
3001 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
3005 dpyinfo
->x_highlight_frame
= 0;
3007 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3010 frame_unhighlight (old_highlight
);
3011 if (dpyinfo
->x_highlight_frame
)
3012 frame_highlight (dpyinfo
->x_highlight_frame
);
3016 /* Keyboard processing - modifier keys, etc. */
3018 /* Convert a keysym to its name. */
3021 x_get_keysym_name (int keysym
)
3023 /* Make static so we can always return it */
3024 static char value
[100];
3027 GetKeyNameText (keysym
, value
, 100);
3034 codepage_for_locale (LCID locale
)
3038 if (GetLocaleInfo (locale
, LOCALE_IDEFAULTANSICODEPAGE
, cp
, 20) > 0)
3045 /* Mouse clicks and mouse movement. Rah. */
3047 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
3048 the state in PUP. XBUTTON provides extra information for extended mouse
3049 button messages. Returns FALSE if unable to parse the message. */
3051 parse_button (int message
, int xbutton
, int * pbutton
, int * pup
)
3058 case WM_LBUTTONDOWN
:
3066 case WM_MBUTTONDOWN
:
3067 if (NILP (Vw32_swap_mouse_buttons
))
3074 if (NILP (Vw32_swap_mouse_buttons
))
3080 case WM_RBUTTONDOWN
:
3081 if (NILP (Vw32_swap_mouse_buttons
))
3088 if (NILP (Vw32_swap_mouse_buttons
))
3094 case WM_XBUTTONDOWN
:
3095 button
= xbutton
+ 2;
3099 button
= xbutton
+ 2;
3107 if (pbutton
) *pbutton
= button
;
3113 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3115 If the event is a button press, then note that we have grabbed
3119 construct_mouse_click (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3124 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3127 /* Make the event type NO_EVENT; we'll change that when we decide
3129 result
->kind
= MOUSE_CLICK_EVENT
;
3130 result
->code
= button
;
3131 result
->timestamp
= msg
->msg
.time
;
3132 result
->modifiers
= (msg
->dwModifiers
3137 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3138 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3139 XSETFRAME (result
->frame_or_window
, f
);
3145 construct_mouse_wheel (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3150 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3153 result
->timestamp
= msg
->msg
.time
;
3155 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3156 forward, away from the user (up); a negative value indicates that
3157 the wheel was rotated backward, toward the user (down). */
3158 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3160 /* The up and down modifiers indicate if the wheel was rotated up or
3161 down based on WHEEL_DELTA value. */
3162 result
->modifiers
= (msg
->dwModifiers
3163 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3165 /* With multiple monitors, we can legitimately get negative
3166 coordinates, so cast to short to interpret them correctly. */
3167 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3168 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3169 ScreenToClient (msg
->msg
.hwnd
, &p
);
3170 XSETINT (result
->x
, p
.x
);
3171 XSETINT (result
->y
, p
.y
);
3172 XSETFRAME (result
->frame_or_window
, f
);
3178 construct_drag_n_drop (struct input_event
*result
, W32Msg
*msg
, struct frame
*f
)
3188 result
->kind
= DRAG_N_DROP_EVENT
;
3190 result
->timestamp
= msg
->msg
.time
;
3191 result
->modifiers
= msg
->dwModifiers
;
3193 hdrop
= (HDROP
) msg
->msg
.wParam
;
3194 DragQueryPoint (hdrop
, &p
);
3197 p
.x
= LOWORD (msg
->msg
.lParam
);
3198 p
.y
= HIWORD (msg
->msg
.lParam
);
3199 ScreenToClient (msg
->msg
.hwnd
, &p
);
3202 XSETINT (result
->x
, p
.x
);
3203 XSETINT (result
->y
, p
.y
);
3205 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3208 for (i
= 0; i
< num_files
; i
++)
3210 len
= GUI_FN (DragQueryFile
) (hdrop
, i
, NULL
, 0);
3214 name
= alloca ((len
+ 1) * sizeof (*name
));
3215 GUI_FN (DragQueryFile
) (hdrop
, i
, name
, len
+ 1);
3216 #ifdef NTGUI_UNICODE
3217 files
= Fcons (from_unicode_buffer (name
), files
);
3219 files
= Fcons (DECODE_FILE (build_string (name
)), files
);
3220 #endif /* NTGUI_UNICODE */
3225 XSETFRAME (frame
, f
);
3226 result
->frame_or_window
= frame
;
3227 result
->arg
= files
;
3234 /* File event notifications (see w32notify.c). */
3237 lispy_file_action (DWORD action
)
3239 static char unknown_fmt
[] = "unknown-action(%d)";
3244 case FILE_ACTION_ADDED
:
3247 case FILE_ACTION_REMOVED
:
3250 case FILE_ACTION_MODIFIED
:
3253 case FILE_ACTION_RENAMED_OLD_NAME
:
3254 retval
= Qrenamed_from
;
3256 case FILE_ACTION_RENAMED_NEW_NAME
:
3257 retval
= Qrenamed_to
;
3261 char buf
[sizeof(unknown_fmt
) - 1 + INT_STRLEN_BOUND (DWORD
)];
3263 sprintf (buf
, unknown_fmt
, action
);
3264 retval
= intern (buf
);
3273 /* Put file notifications into the Emacs input event queue. This
3274 function runs when the WM_EMACS_FILENOTIFY message arrives from a
3277 queue_notifications (struct input_event
*event
, W32Msg
*msg
, struct frame
*f
,
3280 BYTE
*p
= file_notifications
;
3281 FILE_NOTIFY_INFORMATION
*fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3282 const DWORD min_size
3283 = offsetof (FILE_NOTIFY_INFORMATION
, FileName
) + sizeof(wchar_t);
3286 /* We cannot process notification before Emacs is fully initialized,
3287 since we need the UTF-16LE coding-system to be set up. */
3290 notification_buffer_in_use
= 0;
3294 XSETFRAME (frame
, f
);
3297 if (notification_buffer_in_use
)
3299 DWORD info_size
= notifications_size
;
3300 Lisp_Object cs
= intern ("utf-16le");
3301 Lisp_Object obj
= w32_get_watch_object (notifications_desc
);
3303 /* notifications_size could be zero when the buffer of
3304 notifications overflowed on the OS level, or when the
3305 directory being watched was itself deleted. Do nothing in
3308 && !NILP (obj
) && CONSP (obj
))
3310 Lisp_Object callback
= XCDR (obj
);
3312 while (info_size
>= min_size
)
3314 Lisp_Object utf_16_fn
3315 = make_unibyte_string ((char *)fni
->FileName
,
3316 fni
->FileNameLength
);
3317 /* Note: mule-conf is preloaded, so utf-16le must
3318 already be defined at this point. */
3320 = code_convert_string_norecord (utf_16_fn
, cs
, 0);
3321 Lisp_Object action
= lispy_file_action (fni
->Action
);
3323 event
->kind
= FILE_NOTIFY_EVENT
;
3325 = (ptrdiff_t)XINT (XIL ((EMACS_INT
)notifications_desc
));
3326 event
->timestamp
= msg
->msg
.time
;
3327 event
->modifiers
= 0;
3328 event
->frame_or_window
= callback
;
3329 event
->arg
= Fcons (action
, fname
);
3330 kbd_buffer_store_event (event
);
3333 if (!fni
->NextEntryOffset
)
3335 p
+= fni
->NextEntryOffset
;
3336 fni
= (PFILE_NOTIFY_INFORMATION
)p
;
3337 info_size
-= fni
->NextEntryOffset
;
3340 notification_buffer_in_use
= 0;
3343 DebPrint (("We were promised notifications, but in-use flag is zero!\n"));
3346 /* We've stuffed all the events ourselves, so w32_read_socket shouldn't. */
3347 event
->kind
= NO_EVENT
;
3349 #endif /* WINDOWSNT */
3350 #endif /* HAVE_W32NOTIFY */
3353 /* Function to report a mouse movement to the mainstream Emacs code.
3354 The input handler calls this.
3356 We have received a mouse movement event, which is given in *event.
3357 If the mouse is over a different glyph than it was last time, tell
3358 the mainstream emacs code by setting mouse_moved. If not, ask for
3359 another motion event, so we can check again the next time it moves. */
3361 static MSG last_mouse_motion_event
;
3362 static Lisp_Object last_mouse_motion_frame
;
3365 note_mouse_movement (struct frame
*frame
, MSG
*msg
)
3367 int mouse_x
= LOWORD (msg
->lParam
);
3368 int mouse_y
= HIWORD (msg
->lParam
);
3370 last_mouse_movement_time
= msg
->time
;
3371 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
3372 XSETFRAME (last_mouse_motion_frame
, frame
);
3374 if (!FRAME_X_OUTPUT (frame
))
3377 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3379 frame
->mouse_moved
= 1;
3380 last_mouse_scroll_bar
= Qnil
;
3381 note_mouse_highlight (frame
, -1, -1);
3382 last_mouse_glyph_frame
= 0;
3386 /* Has the mouse moved off the glyph it was on at the last sighting? */
3387 if (frame
!= last_mouse_glyph_frame
3388 || mouse_x
< last_mouse_glyph
.left
3389 || mouse_x
>= last_mouse_glyph
.right
3390 || mouse_y
< last_mouse_glyph
.top
3391 || mouse_y
>= last_mouse_glyph
.bottom
)
3393 frame
->mouse_moved
= 1;
3394 last_mouse_scroll_bar
= Qnil
;
3395 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3396 /* Remember the mouse position here, as w32_mouse_position only
3397 gets called when mouse tracking is enabled but we also need
3398 to keep track of the mouse for help_echo and highlighting at
3400 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, &last_mouse_glyph
);
3401 last_mouse_glyph_frame
= frame
;
3409 /************************************************************************
3411 ************************************************************************/
3413 static struct scroll_bar
*x_window_to_scroll_bar (Window
);
3414 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
3415 enum scroll_bar_part
*,
3416 Lisp_Object
*, Lisp_Object
*,
3418 static void x_check_fullscreen (struct frame
*);
3421 redo_mouse_highlight (void)
3423 if (!NILP (last_mouse_motion_frame
)
3424 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3425 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3426 LOWORD (last_mouse_motion_event
.lParam
),
3427 HIWORD (last_mouse_motion_event
.lParam
));
3431 w32_define_cursor (Window window
, Cursor cursor
)
3433 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3435 /* Return the current position of the mouse.
3436 *fp should be a frame which indicates which display to ask about.
3438 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3439 and *part to the frame, window, and scroll bar part that the mouse
3440 is over. Set *x and *y to the portion and whole of the mouse's
3441 position on the scroll bar.
3443 If the mouse movement started elsewhere, set *fp to the frame the
3444 mouse is on, *bar_window to nil, and *x and *y to the character cell
3447 Set *time to the server time-stamp for the time at which the mouse
3448 was at this position.
3450 Don't store anything if we don't have a valid set of values to report.
3452 This clears the mouse_moved flag, so we can wait for the next mouse
3456 w32_mouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
3457 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
3458 unsigned long *time
)
3464 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3465 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3470 Lisp_Object frame
, tail
;
3472 /* Clear the mouse-moved flag for every frame on this display. */
3473 FOR_EACH_FRAME (tail
, frame
)
3474 XFRAME (frame
)->mouse_moved
= 0;
3476 last_mouse_scroll_bar
= Qnil
;
3480 /* Now we have a position on the root; find the innermost window
3481 containing the pointer. */
3483 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3484 && FRAME_LIVE_P (last_mouse_frame
))
3486 /* If mouse was grabbed on a frame, give coords for that frame
3487 even if the mouse is now outside it. */
3488 f1
= last_mouse_frame
;
3492 /* Is window under mouse one of our frames? */
3493 f1
= x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
3494 WindowFromPoint (pt
));
3497 /* If not, is it one of our scroll bars? */
3500 struct scroll_bar
*bar
3501 = x_window_to_scroll_bar (WindowFromPoint (pt
));
3505 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3509 if (f1
== 0 && insist
> 0)
3510 f1
= SELECTED_FRAME ();
3514 /* Ok, we found a frame. Store all the values.
3515 last_mouse_glyph is a rectangle used to reduce the
3516 generation of mouse events. To not miss any motion
3517 events, we must divide the frame into rectangles of the
3518 size of the smallest character that could be displayed
3519 on it, i.e. into the same rectangles that matrices on
3520 the frame are divided into. */
3522 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3523 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &last_mouse_glyph
);
3524 last_mouse_glyph_frame
= f1
;
3531 *time
= last_mouse_movement_time
;
3540 /***********************************************************************
3542 ***********************************************************************/
3544 /* Handle mouse button event on the tool-bar of frame F, at
3545 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
3546 or ButtonRelease. */
3549 w32_handle_tool_bar_click (struct frame
*f
, struct input_event
*button_event
)
3551 int x
= XFASTINT (button_event
->x
);
3552 int y
= XFASTINT (button_event
->y
);
3554 if (button_event
->modifiers
& down_modifier
)
3555 handle_tool_bar_click (f
, x
, y
, 1, 0);
3557 handle_tool_bar_click (f
, x
, y
, 0,
3558 button_event
->modifiers
& ~up_modifier
);
3563 /***********************************************************************
3565 ***********************************************************************/
3567 /* Scroll bar support. */
3569 /* Given a window ID, find the struct scroll_bar which manages it.
3570 This can be called in GC, so we have to make sure to strip off mark
3573 static struct scroll_bar
*
3574 x_window_to_scroll_bar (Window window_id
)
3576 Lisp_Object tail
, frame
;
3578 FOR_EACH_FRAME (tail
, frame
)
3580 Lisp_Object bar
, condemned
;
3582 /* Scan this frame's scroll bar list for a scroll bar with the
3584 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3585 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3586 /* This trick allows us to search both the ordinary and
3587 condemned scroll bar lists with one loop. */
3588 ! NILP (bar
) || (bar
= condemned
,
3591 bar
= XSCROLL_BAR (bar
)->next
)
3592 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
3593 return XSCROLL_BAR (bar
);
3601 /* Set the thumb size and position of scroll bar BAR. We are currently
3602 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3605 w32_set_scroll_bar_thumb (struct scroll_bar
*bar
,
3606 int portion
, int position
, int whole
)
3608 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3609 /* We use the whole scroll-bar height in the calculations below, to
3610 avoid strange effects like scrolling backwards when just clicking
3611 on the handle (without moving it). */
3612 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
))
3613 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3614 int sb_page
, sb_pos
;
3615 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
3618 /* We used to change the nPage setting while dragging the handle,
3619 but that had very strange effects (such as scrolling backwards
3620 while dragging downwards).
3622 Now, we don't change the nPage setting while dragging unless we
3623 get near to the end of the buffer, in which case we often have to
3624 resize the handle to "go all the way". */
3630 si
.cbSize
= sizeof (si
);
3631 si
.fMask
= SIF_POS
| SIF_PAGE
;
3632 GetScrollInfo (w
, SB_CTL
, &si
);
3633 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3641 /* Position scroll bar at rock bottom if the bottom of the
3642 buffer is visible. This avoids shrinking the thumb away
3643 to nothing if it is held at the bottom of the buffer. */
3644 if (position
+ portion
>= whole
&& !draggingp
)
3646 sb_page
= range
* (whole
- position
) / whole
;
3651 sb_pos
= position
* range
/ whole
;
3652 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3661 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3665 si
.cbSize
= sizeof (si
);
3666 si
.fMask
= SIF_PAGE
| SIF_POS
;
3670 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3676 /************************************************************************
3677 Scroll bars, general
3678 ************************************************************************/
3681 my_create_scrollbar (struct frame
* f
, struct scroll_bar
* bar
)
3683 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3684 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
3688 /*#define ATTACH_THREADS*/
3691 my_show_window (struct frame
*f
, HWND hwnd
, int how
)
3693 #ifndef ATTACH_THREADS
3694 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3695 (WPARAM
) hwnd
, (LPARAM
) how
);
3697 return ShowWindow (hwnd
, how
);
3702 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3703 int x
, int y
, int cx
, int cy
, UINT flags
)
3705 #ifndef ATTACH_THREADS
3707 pos
.hwndInsertAfter
= hwndAfter
;
3713 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
3715 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3721 my_set_focus (struct frame
* f
, HWND hwnd
)
3723 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3729 my_set_foreground_window (HWND hwnd
)
3731 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
3736 my_destroy_window (struct frame
* f
, HWND hwnd
)
3738 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3743 my_bring_window_to_top (HWND hwnd
)
3745 SendMessage (hwnd
, WM_EMACS_BRINGTOTOP
, (WPARAM
) hwnd
, 0);
3748 /* Create a scroll bar and return the scroll bar vector for it. W is
3749 the Emacs window on which to create the scroll bar. TOP, LEFT,
3750 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
3753 static struct scroll_bar
*
3754 x_scroll_bar_create (struct window
*w
, int top
, int left
, int width
, int height
)
3756 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3759 struct scroll_bar
*bar
3760 = XSCROLL_BAR (Fmake_vector (make_number (VECSIZE (struct scroll_bar
)), Qnil
));
3765 XSETWINDOW (bar
->window
, w
);
3766 XSETINT (bar
->top
, top
);
3767 XSETINT (bar
->left
, left
);
3768 XSETINT (bar
->width
, width
);
3769 XSETINT (bar
->height
, height
);
3770 XSETINT (bar
->start
, 0);
3771 XSETINT (bar
->end
, 0);
3772 bar
->dragging
= Qnil
;
3773 bar
->fringe_extended_p
= Qnil
;
3775 /* Requires geometry to be set before call to create the real window */
3777 hwnd
= my_create_scrollbar (f
, bar
);
3779 si
.cbSize
= sizeof (si
);
3782 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3783 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3787 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3789 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3791 /* Add bar to its frame's list of scroll bars. */
3792 bar
->next
= FRAME_SCROLL_BARS (f
);
3794 XSETVECTOR (barobj
, bar
);
3795 fset_scroll_bars (f
, barobj
);
3796 if (! NILP (bar
->next
))
3797 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3805 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3809 x_scroll_bar_remove (struct scroll_bar
*bar
)
3811 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3815 /* Destroy the window. */
3816 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3818 /* Dissociate this scroll bar from its window. */
3819 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
3824 /* Set the handle of the vertical scroll bar for WINDOW to indicate
3825 that we are displaying PORTION characters out of a total of WHOLE
3826 characters, starting at POSITION. If WINDOW has no scroll bar,
3829 w32_set_vertical_scroll_bar (struct window
*w
,
3830 int portion
, int whole
, int position
)
3832 struct frame
*f
= XFRAME (w
->frame
);
3834 struct scroll_bar
*bar
;
3835 int top
, height
, left
, sb_left
, width
, sb_width
;
3836 int window_y
, window_height
;
3837 int fringe_extended_p
;
3839 /* Get window dimensions. */
3840 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
3842 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
3843 height
= window_height
;
3845 /* Compute the left edge of the scroll bar area. */
3846 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3848 /* Compute the width of the scroll bar which might be less than
3849 the width of the area reserved for the scroll bar. */
3850 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
3851 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
3855 /* Compute the left edge of the scroll bar. */
3856 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
3857 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
3859 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
3861 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
3862 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
3863 && WINDOW_LEFT_FRINGE_WIDTH (w
)
3864 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
3865 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
3867 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
3868 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
3869 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
3870 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
3872 /* Does the scroll bar exist yet? */
3873 if (NILP (w
->vertical_scroll_bar
))
3877 if (width
> 0 && height
> 0)
3879 hdc
= get_frame_dc (f
);
3880 if (fringe_extended_p
)
3881 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
3883 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3884 release_frame_dc (f
, hdc
);
3888 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
3892 /* It may just need to be moved and resized. */
3895 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3896 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3898 /* If already correctly positioned, do nothing. */
3899 if ( XINT (bar
->left
) == sb_left
3900 && XINT (bar
->top
) == top
3901 && XINT (bar
->width
) == sb_width
3902 && XINT (bar
->height
) == height
3903 && !NILP (bar
->fringe_extended_p
) == fringe_extended_p
)
3905 /* Redraw after clear_frame. */
3906 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3907 InvalidateRect (hwnd
, NULL
, FALSE
);
3915 if (width
&& height
)
3917 hdc
= get_frame_dc (f
);
3918 /* Since Windows scroll bars are smaller than the space reserved
3919 for them on the frame, we have to clear "under" them. */
3920 if (fringe_extended_p
)
3921 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
3923 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3924 release_frame_dc (f
, hdc
);
3926 /* Make sure scroll bar is "visible" before moving, to ensure the
3927 area of the parent window now exposed will be refreshed. */
3928 my_show_window (f
, hwnd
, SW_HIDE
);
3929 MoveWindow (hwnd
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
3930 top
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
3931 max (height
, 1), TRUE
);
3933 si
.cbSize
= sizeof (si
);
3934 si
.fMask
= SIF_RANGE
;
3936 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3937 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3939 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3941 my_show_window (f
, hwnd
, SW_NORMAL
);
3942 /* InvalidateRect (w, NULL, FALSE); */
3944 /* Remember new settings. */
3945 XSETINT (bar
->left
, sb_left
);
3946 XSETINT (bar
->top
, top
);
3947 XSETINT (bar
->width
, sb_width
);
3948 XSETINT (bar
->height
, height
);
3953 bar
->fringe_extended_p
= fringe_extended_p
? Qt
: Qnil
;
3955 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3956 XSETVECTOR (barobj
, bar
);
3957 wset_vertical_scroll_bar (w
, barobj
);
3961 /* The following three hooks are used when we're doing a thorough
3962 redisplay of the frame. We don't explicitly know which scroll bars
3963 are going to be deleted, because keeping track of when windows go
3964 away is a real pain - "Can you say set-window-configuration, boys
3965 and girls?" Instead, we just assert at the beginning of redisplay
3966 that *all* scroll bars are to be removed, and then save a scroll bar
3967 from the fiery pit when we actually redisplay its window. */
3969 /* Arrange for all scroll bars on FRAME to be removed at the next call
3970 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
3971 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
3974 w32_condemn_scroll_bars (struct frame
*frame
)
3976 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
3977 while (! NILP (FRAME_SCROLL_BARS (frame
)))
3980 bar
= FRAME_SCROLL_BARS (frame
);
3981 fset_scroll_bars (frame
, XSCROLL_BAR (bar
)->next
);
3982 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
3983 XSCROLL_BAR (bar
)->prev
= Qnil
;
3984 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
3985 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
3986 fset_condemned_scroll_bars (frame
, bar
);
3991 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
3992 Note that WINDOW isn't necessarily condemned at all. */
3995 w32_redeem_scroll_bar (struct window
*window
)
3997 struct scroll_bar
*bar
;
4001 /* We can't redeem this window's scroll bar if it doesn't have one. */
4002 if (NILP (window
->vertical_scroll_bar
))
4005 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
4007 /* Unlink it from the condemned list. */
4008 f
= XFRAME (WINDOW_FRAME (window
));
4009 if (NILP (bar
->prev
))
4011 /* If the prev pointer is nil, it must be the first in one of
4013 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
4014 /* It's not condemned. Everything's fine. */
4016 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4017 window
->vertical_scroll_bar
))
4018 fset_condemned_scroll_bars (f
, bar
->next
);
4020 /* If its prev pointer is nil, it must be at the front of
4021 one or the other! */
4025 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4027 if (! NILP (bar
->next
))
4028 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4030 bar
->next
= FRAME_SCROLL_BARS (f
);
4032 XSETVECTOR (barobj
, bar
);
4033 fset_scroll_bars (f
, barobj
);
4034 if (! NILP (bar
->next
))
4035 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4038 /* Remove all scroll bars on FRAME that haven't been saved since the
4039 last call to `*condemn_scroll_bars_hook'. */
4042 w32_judge_scroll_bars (struct frame
*f
)
4044 Lisp_Object bar
, next
;
4046 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
4048 /* Clear out the condemned list now so we won't try to process any
4049 more events on the hapless scroll bars. */
4050 fset_condemned_scroll_bars (f
, Qnil
);
4052 for (; ! NILP (bar
); bar
= next
)
4054 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
4056 x_scroll_bar_remove (b
);
4059 b
->next
= b
->prev
= Qnil
;
4062 /* Now there should be no references to the condemned scroll bars,
4063 and they should get garbage-collected. */
4066 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
4067 is set to something other than NO_EVENT, it is enqueued.
4069 This may be called from a signal handler, so we have to ignore GC
4073 w32_scroll_bar_handle_click (struct scroll_bar
*bar
, W32Msg
*msg
,
4074 struct input_event
*emacs_event
)
4076 if (! WINDOWP (bar
->window
))
4079 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
4080 emacs_event
->code
= 0;
4081 /* not really meaningful to distinguish up/down */
4082 emacs_event
->modifiers
= msg
->dwModifiers
;
4083 emacs_event
->frame_or_window
= bar
->window
;
4084 emacs_event
->arg
= Qnil
;
4085 emacs_event
->timestamp
= msg
->msg
.time
;
4088 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4090 int dragging
= !NILP (bar
->dragging
);
4093 si
.cbSize
= sizeof (si
);
4096 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4099 bar
->dragging
= Qnil
;
4102 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4104 switch (LOWORD (msg
->msg
.wParam
))
4107 emacs_event
->part
= scroll_bar_down_arrow
;
4110 emacs_event
->part
= scroll_bar_up_arrow
;
4113 emacs_event
->part
= scroll_bar_above_handle
;
4116 emacs_event
->part
= scroll_bar_below_handle
;
4119 emacs_event
->part
= scroll_bar_handle
;
4123 emacs_event
->part
= scroll_bar_handle
;
4127 case SB_THUMBPOSITION
:
4128 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
4129 y
= HIWORD (msg
->msg
.wParam
);
4131 emacs_event
->part
= scroll_bar_handle
;
4133 /* "Silently" update current position. */
4137 si
.cbSize
= sizeof (si
);
4140 /* Remember apparent position (we actually lag behind the real
4141 position, so don't set that directly). */
4142 last_scroll_bar_drag_pos
= y
;
4144 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4148 /* If this is the end of a drag sequence, then reset the scroll
4149 handle size to normal and do a final redraw. Otherwise do
4154 int start
= XINT (bar
->start
);
4155 int end
= XINT (bar
->end
);
4157 si
.cbSize
= sizeof (si
);
4158 si
.fMask
= SIF_PAGE
| SIF_POS
;
4159 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4160 si
.nPos
= last_scroll_bar_drag_pos
;
4161 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4165 emacs_event
->kind
= NO_EVENT
;
4169 XSETINT (emacs_event
->x
, y
);
4170 XSETINT (emacs_event
->y
, top_range
);
4176 /* Return information to the user about the current position of the mouse
4177 on the scroll bar. */
4180 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
4181 enum scroll_bar_part
*part
,
4182 Lisp_Object
*x
, Lisp_Object
*y
,
4183 unsigned long *time
)
4185 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
4186 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4187 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4189 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4195 *bar_window
= bar
->window
;
4197 si
.cbSize
= sizeof (si
);
4198 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4200 GetScrollInfo (w
, SB_CTL
, &si
);
4202 top_range
= si
.nMax
- si
.nPage
+ 1;
4204 switch (LOWORD (last_mouse_scroll_bar_pos
))
4206 case SB_THUMBPOSITION
:
4208 *part
= scroll_bar_handle
;
4209 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
4210 pos
= HIWORD (last_mouse_scroll_bar_pos
);
4213 *part
= scroll_bar_handle
;
4217 *part
= scroll_bar_handle
;
4222 XSETINT (*y
, top_range
);
4225 last_mouse_scroll_bar
= Qnil
;
4227 *time
= last_mouse_movement_time
;
4233 /* The screen has been cleared so we may have changed foreground or
4234 background colors, and the scroll bars may need to be redrawn.
4235 Clear out the scroll bars, and ask for expose events, so we can
4239 x_scroll_bar_clear (struct frame
*f
)
4243 /* We can have scroll bars even if this is 0,
4244 if we just turned off scroll bar mode.
4245 But in that case we should not clear them. */
4246 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4247 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4248 bar
= XSCROLL_BAR (bar
)->next
)
4250 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4251 HDC hdc
= GetDC (window
);
4254 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4255 arranges to refresh the scroll bar if hidden. */
4256 my_show_window (f
, window
, SW_HIDE
);
4258 GetClientRect (window
, &rect
);
4259 select_palette (f
, hdc
);
4260 w32_clear_rect (f
, hdc
, &rect
);
4261 deselect_palette (f
, hdc
);
4263 ReleaseDC (window
, hdc
);
4268 /* The main W32 event-reading loop - w32_read_socket. */
4270 /* Record the last 100 characters stored
4271 to help debug the loss-of-chars-during-GC problem. */
4273 static int temp_index
;
4274 static short temp_buffer
[100];
4276 /* Temporarily store lead byte of DBCS input sequences. */
4277 static char dbcs_lead
= 0;
4279 /* Read events coming from the W32 shell.
4280 This routine is called by the SIGIO handler.
4281 We return as soon as there are no more events to be read.
4283 For an overview of how Emacs input works on MS-Windows, see the
4284 commentary before w32_msg_pump in w32fns.c.
4286 We return the number of characters stored into the buffer,
4287 thus pretending to be `read'.
4289 Some of these messages are reposted back to the message queue since the
4290 system calls the windows proc directly in a context where we cannot return
4291 the data nor can we guarantee the state we are in. So if we dispatch them
4292 we will get into an infinite loop. To prevent this from ever happening we
4293 will set a variable to indicate we are in the read_socket call and indicate
4294 which message we are processing since the windows proc gets called
4295 recursively with different messages by the system.
4299 w32_read_socket (struct terminal
*terminal
,
4300 struct input_event
*hold_quit
)
4303 int check_visibility
= 0;
4306 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4307 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
4312 /* So people can tell when we have read the available input. */
4313 input_signal_count
++;
4315 /* Process any incoming thread messages. */
4316 drain_message_queue ();
4318 /* TODO: ghostscript integration. */
4319 while (get_next_msg (&msg
, FALSE
))
4321 struct input_event inev
;
4324 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4325 /* w32_name_of_message (msg.msg.message), */
4326 /* msg.msg.time)); */
4329 inev
.kind
= NO_EVENT
;
4332 switch (msg
.msg
.message
)
4334 case WM_EMACS_PAINT
:
4335 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4339 if (msg
.rect
.right
== msg
.rect
.left
||
4340 msg
.rect
.bottom
== msg
.rect
.top
)
4342 /* We may get paint messages even though the client
4343 area is clipped - these are not expose events. */
4344 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4347 else if (FRAME_VISIBLE_P (f
) != 1)
4349 bool iconified
= FRAME_ICONIFIED_P (f
);
4351 /* Definitely not obscured, so mark as visible. */
4352 SET_FRAME_VISIBLE (f
, 1);
4353 SET_FRAME_ICONIFIED (f
, 0);
4354 SET_FRAME_GARBAGED (f
);
4355 if (!f
->output_data
.w32
->asked_for_visible
)
4356 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4359 /* WM_PAINT serves as MapNotify as well, so report
4360 visibility changes properly. */
4363 inev
.kind
= DEICONIFY_EVENT
;
4364 XSETFRAME (inev
.frame_or_window
, f
);
4366 else if (!NILP (Vframe_list
) && !NILP (XCDR (Vframe_list
)))
4367 /* Force a redisplay sooner or later to update the
4368 frame titles in case this is the second frame. */
4369 record_asynch_buffer_change ();
4373 HDC hdc
= get_frame_dc (f
);
4375 /* Erase background again for safety. */
4376 w32_clear_rect (f
, hdc
, &msg
.rect
);
4377 release_frame_dc (f
, hdc
);
4381 msg
.rect
.right
- msg
.rect
.left
,
4382 msg
.rect
.bottom
- msg
.rect
.top
);
4387 case WM_INPUTLANGCHANGE
:
4388 /* Generate a language change event. */
4389 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4391 /* lParam contains the input language ID in its low 16 bits.
4392 Use it to update our record of the keyboard codepage. */
4393 w32_keyboard_codepage
= codepage_for_locale ((LCID
)(msg
.msg
.lParam
4398 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4399 XSETFRAME (inev
.frame_or_window
, f
);
4400 inev
.code
= w32_keyboard_codepage
;
4401 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4407 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4409 if (f
&& !FRAME_ICONIFIED_P (f
))
4411 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4412 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4414 clear_mouse_face (hlinfo
);
4415 hlinfo
->mouse_face_hidden
= 1;
4418 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4420 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4421 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4422 inev
.code
= msg
.msg
.wParam
;
4423 inev
.modifiers
= msg
.dwModifiers
;
4424 XSETFRAME (inev
.frame_or_window
, f
);
4425 inev
.timestamp
= msg
.msg
.time
;
4432 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4434 if (f
&& !FRAME_ICONIFIED_P (f
))
4436 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4437 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4439 clear_mouse_face (hlinfo
);
4440 hlinfo
->mouse_face_hidden
= 1;
4443 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4445 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4447 inev
.modifiers
= msg
.dwModifiers
;
4448 XSETFRAME (inev
.frame_or_window
, f
);
4449 inev
.timestamp
= msg
.msg
.time
;
4451 if (msg
.msg
.message
== WM_UNICHAR
)
4453 inev
.code
= msg
.msg
.wParam
;
4455 else if (msg
.msg
.wParam
< 256)
4460 dbcs
[1] = (char) msg
.msg
.wParam
;
4464 dbcs
[0] = dbcs_lead
;
4466 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4470 DebPrint (("Invalid DBCS sequence: %d %d\n",
4472 inev
.kind
= NO_EVENT
;
4476 else if (IsDBCSLeadByteEx (w32_keyboard_codepage
,
4477 (BYTE
) msg
.msg
.wParam
))
4479 dbcs_lead
= (char) msg
.msg
.wParam
;
4480 inev
.kind
= NO_EVENT
;
4485 if (!MultiByteToWideChar (w32_keyboard_codepage
, 0,
4486 &dbcs
[1], 1, &code
, 1))
4488 /* What to do with garbage? */
4489 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4490 inev
.kind
= NO_EVENT
;
4498 /* Windows shouldn't generate WM_CHAR events above 0xFF
4499 in non-Unicode message handlers. */
4500 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4501 inev
.kind
= NO_EVENT
;
4504 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4505 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4510 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4512 if (f
&& !FRAME_ICONIFIED_P (f
))
4514 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4515 && !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
4517 clear_mouse_face (hlinfo
);
4518 hlinfo
->mouse_face_hidden
= 1;
4521 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4523 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4524 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4525 inev
.code
= GET_APPCOMMAND_LPARAM (msg
.msg
.lParam
);
4526 inev
.modifiers
= msg
.dwModifiers
;
4527 XSETFRAME (inev
.frame_or_window
, f
);
4528 inev
.timestamp
= msg
.msg
.time
;
4533 /* Ignore non-movement. */
4535 int x
= LOWORD (msg
.msg
.lParam
);
4536 int y
= HIWORD (msg
.msg
.lParam
);
4537 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4539 last_mousemove_x
= x
;
4540 last_mousemove_y
= y
;
4543 previous_help_echo_string
= help_echo_string
;
4544 help_echo_string
= Qnil
;
4546 if (dpyinfo
->grabbed
&& last_mouse_frame
4547 && FRAME_LIVE_P (last_mouse_frame
))
4548 f
= last_mouse_frame
;
4550 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4552 if (hlinfo
->mouse_face_hidden
)
4554 hlinfo
->mouse_face_hidden
= 0;
4555 clear_mouse_face (hlinfo
);
4560 /* Generate SELECT_WINDOW_EVENTs when needed. */
4561 if (!NILP (Vmouse_autoselect_window
))
4564 int x
= LOWORD (msg
.msg
.lParam
);
4565 int y
= HIWORD (msg
.msg
.lParam
);
4567 window
= window_from_coordinates (f
, x
, y
, 0, 0);
4569 /* Window will be selected only when it is not
4570 selected now and last mouse movement event was
4571 not in it. Minibuffer window will be selected
4572 only when it is active. */
4573 if (WINDOWP (window
)
4574 && !EQ (window
, last_window
)
4575 && !EQ (window
, selected_window
)
4576 /* For click-to-focus window managers
4577 create event iff we don't leave the
4579 && (focus_follows_mouse
4580 || (EQ (XWINDOW (window
)->frame
,
4581 XWINDOW (selected_window
)->frame
))))
4583 inev
.kind
= SELECT_WINDOW_EVENT
;
4584 inev
.frame_or_window
= window
;
4587 last_window
= window
;
4589 if (!note_mouse_movement (f
, &msg
.msg
))
4590 help_echo_string
= previous_help_echo_string
;
4594 /* If we move outside the frame, then we're
4595 certainly no longer on any text in the frame. */
4596 clear_mouse_face (hlinfo
);
4599 /* If the contents of the global variable help_echo_string
4600 has changed, generate a HELP_EVENT. */
4601 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4602 But it was originally changed to this to fix a bug, so I have
4603 not removed it completely in case the bug is still there. */
4604 if (help_echo_string
!= previous_help_echo_string
||
4605 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4606 #else /* This is what xterm.c does. */
4607 if (!NILP (help_echo_string
)
4608 || !NILP (previous_help_echo_string
))
4613 case WM_LBUTTONDOWN
:
4615 case WM_MBUTTONDOWN
:
4617 case WM_RBUTTONDOWN
:
4619 case WM_XBUTTONDOWN
:
4622 /* If we decide we want to generate an event to be seen
4623 by the rest of Emacs, we put it here. */
4624 bool tool_bar_p
= 0;
4628 if (dpyinfo
->grabbed
&& last_mouse_frame
4629 && FRAME_LIVE_P (last_mouse_frame
))
4630 f
= last_mouse_frame
;
4632 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4636 construct_mouse_click (&inev
, &msg
, f
);
4638 /* Is this in the tool-bar? */
4639 if (WINDOWP (f
->tool_bar_window
)
4640 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4643 int x
= XFASTINT (inev
.x
);
4644 int y
= XFASTINT (inev
.y
);
4646 window
= window_from_coordinates (f
, x
, y
, 0, 1);
4648 if (EQ (window
, f
->tool_bar_window
))
4650 w32_handle_tool_bar_click (f
, &inev
);
4656 || (dpyinfo
->w32_focus_frame
4657 && f
!= dpyinfo
->w32_focus_frame
))
4658 inev
.kind
= NO_EVENT
;
4661 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4666 dpyinfo
->grabbed
&= ~ (1 << button
);
4670 dpyinfo
->grabbed
|= (1 << button
);
4671 last_mouse_frame
= f
;
4672 /* Ignore any mouse motion that happened
4673 before this event; any subsequent mouse-movement
4674 Emacs events should reflect only motion after
4680 last_tool_bar_item
= -1;
4686 case WM_MOUSEHWHEEL
:
4688 if (dpyinfo
->grabbed
&& last_mouse_frame
4689 && FRAME_LIVE_P (last_mouse_frame
))
4690 f
= last_mouse_frame
;
4692 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4697 if (!dpyinfo
->w32_focus_frame
4698 || f
== dpyinfo
->w32_focus_frame
)
4700 /* Emit an Emacs wheel-up/down event. */
4701 construct_mouse_wheel (&inev
, &msg
, f
);
4703 /* Ignore any mouse motion that happened before this
4704 event; any subsequent mouse-movement Emacs events
4705 should reflect only motion after the
4709 last_mouse_frame
= f
;
4710 last_tool_bar_item
= -1;
4715 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4718 construct_drag_n_drop (&inev
, &msg
, f
);
4723 struct scroll_bar
*bar
=
4724 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
4727 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
4731 case WM_WINDOWPOSCHANGED
:
4733 case WM_ACTIVATEAPP
:
4734 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4737 /* Run the full-screen hook function also when we are
4738 being activated, to actually install the required
4739 size in effect, if the WAIT flag is set. This is
4740 because when the hook is run from x_set_fullscreen,
4741 the frame might not yet be visible, if that call is a
4742 result of make-frame, and in that case the hook just
4743 sets the WAIT flag. */
4744 if ((msg
.msg
.message
== WM_WINDOWPOSCHANGED
|| msg
.msg
.wParam
)
4745 && (f
->want_fullscreen
& FULLSCREEN_WAIT
))
4746 w32fullscreen_hook (f
);
4747 x_check_fullscreen (f
);
4749 check_visibility
= 1;
4753 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4755 if (f
&& !FRAME_ICONIFIED_P (f
))
4759 x_real_positions (f
, &x
, &y
);
4764 check_visibility
= 1;
4768 /* wParam non-zero means Window is about to be shown, 0 means
4769 about to be hidden. */
4770 /* Redo the mouse-highlight after the tooltip has gone. */
4771 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
4774 redo_mouse_highlight ();
4777 /* If window has been obscured or exposed by another window
4778 being maximized or minimized/restored, then recheck
4779 visibility of all frames. Direct changes to our own
4780 windows get handled by WM_SIZE. */
4782 if (msg
.msg
.lParam
!= 0)
4783 check_visibility
= 1;
4786 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4787 f
->async_visible
= msg
.msg
.wParam
;
4791 check_visibility
= 1;
4795 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4797 /* Inform lisp of whether frame has been iconified etc. */
4800 switch (msg
.msg
.wParam
)
4802 case SIZE_MINIMIZED
:
4803 SET_FRAME_VISIBLE (f
, 0);
4804 SET_FRAME_ICONIFIED (f
, 1);
4806 inev
.kind
= ICONIFY_EVENT
;
4807 XSETFRAME (inev
.frame_or_window
, f
);
4810 case SIZE_MAXIMIZED
:
4813 bool iconified
= FRAME_ICONIFIED_P (f
);
4816 SET_FRAME_VISIBLE (f
, 1);
4817 SET_FRAME_ICONIFIED (f
, 0);
4819 /* wait_reading_process_output will notice this
4820 and update the frame's display structures. */
4821 SET_FRAME_GARBAGED (f
);
4827 /* Reset top and left positions of the Window
4828 here since Windows sends a WM_MOVE message
4829 BEFORE telling us the Window is minimized
4830 when the Window is iconified, with 3000,3000
4832 x_real_positions (f
, &x
, &y
);
4836 inev
.kind
= DEICONIFY_EVENT
;
4837 XSETFRAME (inev
.frame_or_window
, f
);
4839 else if (! NILP (Vframe_list
)
4840 && ! NILP (XCDR (Vframe_list
)))
4841 /* Force a redisplay sooner or later
4842 to update the frame titles
4843 in case this is the second frame. */
4844 record_asynch_buffer_change ();
4850 if (f
&& !FRAME_ICONIFIED_P (f
) && msg
.msg
.wParam
!= SIZE_MINIMIZED
)
4858 GetClientRect (msg
.msg
.hwnd
, &rect
);
4860 height
= rect
.bottom
- rect
.top
;
4861 width
= rect
.right
- rect
.left
;
4863 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
4864 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
4866 /* TODO: Clip size to the screen dimensions. */
4868 /* Even if the number of character rows and columns has
4869 not changed, the font size may have changed, so we need
4870 to check the pixel dimensions as well. */
4872 if (columns
!= FRAME_COLS (f
)
4873 || rows
!= FRAME_LINES (f
)
4874 || width
!= FRAME_PIXEL_WIDTH (f
)
4875 || height
!= FRAME_PIXEL_HEIGHT (f
))
4877 change_frame_size (f
, rows
, columns
, 0, 1, 0);
4878 SET_FRAME_GARBAGED (f
);
4879 cancel_mouse_face (f
);
4880 FRAME_PIXEL_WIDTH (f
) = width
;
4881 FRAME_PIXEL_HEIGHT (f
) = height
;
4882 f
->win_gravity
= NorthWestGravity
;
4886 check_visibility
= 1;
4890 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4893 if (f
== hlinfo
->mouse_face_mouse_frame
)
4895 /* If we move outside the frame, then we're
4896 certainly no longer on any text in the frame. */
4897 clear_mouse_face (hlinfo
);
4898 hlinfo
->mouse_face_mouse_frame
= 0;
4901 /* Generate a nil HELP_EVENT to cancel a help-echo.
4902 Do it only if there's something to cancel.
4903 Otherwise, the startup message is cleared when
4904 the mouse leaves the frame. */
4905 if (any_help_event_p
)
4911 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
4913 dpyinfo
->grabbed
= 0;
4914 check_visibility
= 1;
4918 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
4919 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4923 if (f
== hlinfo
->mouse_face_mouse_frame
)
4925 /* If we move outside the frame, then we're
4926 certainly no longer on any text in the frame. */
4927 clear_mouse_face (hlinfo
);
4928 hlinfo
->mouse_face_mouse_frame
= 0;
4931 /* Generate a nil HELP_EVENT to cancel a help-echo.
4932 Do it only if there's something to cancel.
4933 Otherwise, the startup message is cleared when
4934 the mouse leaves the frame. */
4935 if (any_help_event_p
)
4939 dpyinfo
->grabbed
= 0;
4940 check_visibility
= 1;
4944 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4948 inev
.kind
= DELETE_WINDOW_EVENT
;
4949 XSETFRAME (inev
.frame_or_window
, f
);
4954 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4958 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
4959 XSETFRAME (inev
.frame_or_window
, f
);
4964 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4968 extern void menubar_selection_callback
4969 (struct frame
*f
, void * client_data
);
4970 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
4973 check_visibility
= 1;
4976 case WM_DISPLAYCHANGE
:
4977 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4981 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
4982 DebPrint (("display change: %d %d\n",
4983 (short) LOWORD (msg
.msg
.lParam
),
4984 (short) HIWORD (msg
.msg
.lParam
)));
4987 check_visibility
= 1;
4991 case WM_EMACS_FILENOTIFY
:
4992 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4994 queue_notifications (&inev
, &msg
, f
, &count
);
4999 /* Check for messages registered at runtime. */
5000 if (msg
.msg
.message
== msh_mousewheel
)
5002 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5003 msg
.msg
.message
= WM_MOUSEWHEEL
;
5009 if (inev
.kind
!= NO_EVENT
)
5011 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5016 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5021 XSETFRAME (frame
, f
);
5027 if (NILP (help_echo_string
))
5029 help_echo_object
= help_echo_window
= Qnil
;
5033 any_help_event_p
= 1;
5034 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5035 help_echo_object
, help_echo_pos
);
5039 help_echo_string
= Qnil
;
5040 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5046 /* If the focus was just given to an autoraising frame,
5048 /* ??? This ought to be able to handle more than one such frame. */
5049 if (pending_autoraise_frame
)
5051 x_raise_frame (pending_autoraise_frame
);
5052 pending_autoraise_frame
= 0;
5055 /* Check which frames are still visible, if we have enqueued any user
5056 events or been notified of events that may affect visibility. We
5057 do this here because there doesn't seem to be any direct
5058 notification from Windows that the visibility of a window has
5059 changed (at least, not in all cases). */
5060 if (count
> 0 || check_visibility
)
5062 Lisp_Object tail
, frame
;
5064 FOR_EACH_FRAME (tail
, frame
)
5066 struct frame
*f
= XFRAME (frame
);
5067 /* The tooltip has been drawn already. Avoid the
5068 SET_FRAME_GARBAGED below. */
5069 if (EQ (frame
, tip_frame
))
5072 /* Check "visible" frames and mark each as obscured or not.
5073 Note that visible is nonzero for unobscured and obscured
5074 frames, but zero for hidden and iconified frames. */
5075 if (FRAME_W32_P (f
) && FRAME_VISIBLE_P (f
))
5082 /* Query clipping rectangle for the entire window area
5083 (GetWindowDC), not just the client portion (GetDC).
5084 Otherwise, the scrollbars and menubar aren't counted as
5085 part of the visible area of the frame, and we may think
5086 the frame is obscured when really a scrollbar is still
5087 visible and gets WM_PAINT messages above. */
5088 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5089 GetClipBox (hdc
, &clipbox
);
5090 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5093 obscured
= FRAME_OBSCURED_P (f
);
5095 if (clipbox
.right
== clipbox
.left
|| clipbox
.bottom
== clipbox
.top
)
5097 /* Frame has become completely obscured so mark as such (we
5098 do this by setting visible to 2 so that FRAME_VISIBLE_P
5099 is still true, but redisplay will skip it). */
5100 SET_FRAME_VISIBLE (f
, 2);
5103 DebPrint (("frame %p (%s) obscured\n", f
, SDATA (f
->name
)));
5107 /* Frame is not obscured, so mark it as such. */
5108 SET_FRAME_VISIBLE (f
, 1);
5112 SET_FRAME_GARBAGED (f
);
5113 DebPrint (("obscured frame %p (%s) found to be visible\n",
5114 f
, SDATA (f
->name
)));
5116 /* Force a redisplay sooner or later. */
5117 record_asynch_buffer_change ();
5130 /***********************************************************************
5132 ***********************************************************************/
5134 /* Set clipping for output in glyph row ROW. W is the window in which
5135 we operate. GC is the graphics context to set clipping in.
5137 ROW may be a text row or, e.g., a mode line. Text rows must be
5138 clipped to the interior of the window dedicated to text display,
5139 mode lines must be clipped to the whole window. */
5142 w32_clip_to_row (struct window
*w
, struct glyph_row
*row
, int area
, HDC hdc
)
5145 int window_x
, window_y
, window_width
;
5147 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5149 clip_rect
.left
= window_x
;
5150 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5151 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5152 clip_rect
.right
= clip_rect
.left
+ window_width
;
5153 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5155 w32_set_clip_rectangle (hdc
, &clip_rect
);
5159 /* Draw a hollow box cursor on window W in glyph row ROW. */
5162 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
5164 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5168 struct glyph
*cursor_glyph
;
5169 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5171 /* Get the glyph the cursor is on. If we can't tell because
5172 the current matrix is invalid or such, give up. */
5173 cursor_glyph
= get_phys_cursor_glyph (w
);
5174 if (cursor_glyph
== NULL
)
5180 /* Compute frame-relative coordinates for phys cursor. */
5181 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5184 rect
.bottom
= rect
.top
+ h
;
5185 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5187 hdc
= get_frame_dc (f
);
5188 /* Set clipping, draw the rectangle, and reset clipping again. */
5189 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5190 FrameRect (hdc
, &rect
, hb
);
5192 w32_set_clip_rectangle (hdc
, NULL
);
5193 release_frame_dc (f
, hdc
);
5197 /* Draw a bar cursor on window W in glyph row ROW.
5199 Implementation note: One would like to draw a bar cursor with an
5200 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5201 Unfortunately, I didn't find a font yet that has this property set.
5205 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
,
5206 int width
, enum text_cursor_kinds kind
)
5208 struct frame
*f
= XFRAME (w
->frame
);
5209 struct glyph
*cursor_glyph
;
5211 /* If cursor is out of bounds, don't draw garbage. This can happen
5212 in mini-buffer windows when switching between echo area glyphs
5214 cursor_glyph
= get_phys_cursor_glyph (w
);
5215 if (cursor_glyph
== NULL
)
5218 /* If on an image, draw like a normal cursor. That's usually better
5219 visible than drawing a bar, esp. if the image is large so that
5220 the bar might not be in the window. */
5221 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5223 struct glyph_row
*row
;
5224 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5225 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5229 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5230 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5234 /* If the glyph's background equals the color we normally draw
5235 the bar cursor in, the bar cursor in its normal color is
5236 invisible. Use the glyph's foreground color instead in this
5237 case, on the assumption that the glyph's colors are chosen so
5238 that the glyph is legible. */
5239 if (face
->background
== cursor_color
)
5240 cursor_color
= face
->foreground
;
5242 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5244 hdc
= get_frame_dc (f
);
5245 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5247 if (kind
== BAR_CURSOR
)
5250 width
= FRAME_CURSOR_WIDTH (f
);
5251 width
= min (cursor_glyph
->pixel_width
, width
);
5253 w
->phys_cursor_width
= width
;
5255 /* If the character under cursor is R2L, draw the bar cursor
5256 on the right of its glyph, rather than on the left. */
5257 if ((cursor_glyph
->resolved_level
& 1) != 0)
5258 x
+= cursor_glyph
->pixel_width
- width
;
5260 w32_fill_area (f
, hdc
, cursor_color
, x
,
5261 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5262 width
, row
->height
);
5266 int dummy_x
, dummy_y
, dummy_h
;
5269 width
= row
->height
;
5271 width
= min (row
->height
, width
);
5273 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
5274 &dummy_y
, &dummy_h
);
5275 w32_fill_area (f
, hdc
, cursor_color
, x
,
5276 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5277 row
->height
- width
),
5278 w
->phys_cursor_width
, width
);
5281 w32_set_clip_rectangle (hdc
, NULL
);
5282 release_frame_dc (f
, hdc
);
5287 /* RIF: Define cursor CURSOR on frame F. */
5290 w32_define_frame_cursor (struct frame
*f
, Cursor cursor
)
5292 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5296 /* RIF: Clear area on frame F. */
5299 w32_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
5303 hdc
= get_frame_dc (f
);
5304 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5305 release_frame_dc (f
, hdc
);
5308 /* RIF: Draw or clear cursor on window W. */
5311 w32_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
,
5312 int x
, int y
, int cursor_type
, int cursor_width
,
5313 int on_p
, int active_p
)
5317 /* If the user wants to use the system caret, make sure our own
5318 cursor remains invisible. */
5319 if (w32_use_visible_system_caret
)
5321 /* Call to erase_phys_cursor here seems to use the
5322 wrong values of w->phys_cursor, as they have been
5323 overwritten before this function was called. */
5324 if (w
->phys_cursor_type
!= NO_CURSOR
)
5325 erase_phys_cursor (w
);
5327 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5328 w
->phys_cursor_width
= -1;
5332 w
->phys_cursor_type
= cursor_type
;
5335 w
->phys_cursor_on_p
= 1;
5337 /* If this is the active cursor, we need to track it with the
5338 system caret, so third party software like screen magnifiers
5339 and speech synthesizers can follow the cursor. */
5342 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5343 HWND hwnd
= FRAME_W32_WINDOW (f
);
5346 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5348 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5349 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5350 w32_system_caret_window
= w
;
5351 w32_system_caret_hdr_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
5352 w32_system_caret_mode_height
= WINDOW_MODE_LINE_HEIGHT (w
);
5354 PostMessage (hwnd
, WM_IME_STARTCOMPOSITION
, 0, 0);
5356 /* If the size of the active cursor changed, destroy the old
5358 if (w32_system_caret_hwnd
5359 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5360 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5362 w32_system_caret_height
= w
->phys_cursor_height
;
5364 /* Move the system caret. */
5365 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5368 if (glyph_row
->exact_window_width_line_p
5369 && (glyph_row
->reversed_p
5370 ? (w
->phys_cursor
.hpos
< 0)
5371 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
5373 glyph_row
->cursor_in_fringe_p
= 1;
5374 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
5378 switch (cursor_type
)
5380 case HOLLOW_BOX_CURSOR
:
5381 x_draw_hollow_cursor (w
, glyph_row
);
5384 case FILLED_BOX_CURSOR
:
5385 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5389 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5393 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5397 w
->phys_cursor_width
= 0;
5411 x_bitmap_icon (struct frame
*f
, Lisp_Object icon
)
5414 HANDLE small_icon
= NULL
;
5416 if (FRAME_W32_WINDOW (f
) == 0)
5420 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5421 else if (STRINGP (icon
))
5423 /* Load the main icon from the named file. */
5424 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5425 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5426 /* Try to load a small icon to go with it. */
5427 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5428 GetSystemMetrics (SM_CXSMICON
),
5429 GetSystemMetrics (SM_CYSMICON
),
5432 else if (SYMBOLP (icon
))
5436 if (EQ (icon
, intern ("application")))
5437 name
= (LPCTSTR
) IDI_APPLICATION
;
5438 else if (EQ (icon
, intern ("hand")))
5439 name
= (LPCTSTR
) IDI_HAND
;
5440 else if (EQ (icon
, intern ("question")))
5441 name
= (LPCTSTR
) IDI_QUESTION
;
5442 else if (EQ (icon
, intern ("exclamation")))
5443 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5444 else if (EQ (icon
, intern ("asterisk")))
5445 name
= (LPCTSTR
) IDI_ASTERISK
;
5446 else if (EQ (icon
, intern ("winlogo")))
5447 name
= (LPCTSTR
) IDI_WINLOGO
;
5451 main_icon
= LoadIcon (NULL
, name
);
5456 if (main_icon
== NULL
)
5459 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5460 (LPARAM
) main_icon
);
5462 /* If there is a small icon that goes with it, set that too. */
5464 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5465 (LPARAM
) small_icon
);
5471 /************************************************************************
5473 ************************************************************************/
5475 /* Display Error Handling functions not used on W32. Listing them here
5476 helps diff stay in step when comparing w32term.c with xterm.c.
5478 x_error_catcher (display, error)
5479 x_catch_errors (dpy)
5480 x_catch_errors_unwind (old_val)
5481 x_check_errors (dpy, format)
5482 x_fully_uncatch_errors ()
5483 x_had_errors_p (dpy)
5484 x_clear_errors (dpy)
5485 x_uncatch_errors (dpy, count)
5487 x_connection_signal (signalnum)
5488 x_connection_closed (dpy, error_message)
5489 x_error_quitter (display, error)
5490 x_error_handler (display, error)
5491 x_io_error_quitter (display)
5496 /* Changing the font of the frame. */
5499 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
5501 struct font
*font
= XFONT_OBJECT (font_object
);
5504 fontset
= fontset_from_font (font_object
);
5505 FRAME_FONTSET (f
) = fontset
;
5506 if (FRAME_FONT (f
) == font
)
5507 /* This font is already set in frame F. There's nothing more to
5511 FRAME_FONT (f
) = font
;
5512 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5513 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
5514 FRAME_LINE_HEIGHT (f
) = font
->height
;
5516 compute_fringe_widths (f
, 1);
5518 /* Compute the scroll bar width in character columns. */
5519 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5521 int wid
= FRAME_COLUMN_WIDTH (f
);
5522 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5523 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
- 1) / wid
;
5527 int wid
= FRAME_COLUMN_WIDTH (f
);
5528 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5531 /* Now make the frame display the given font. */
5532 if (FRAME_X_WINDOW (f
) != 0)
5534 /* Don't change the size of a tip frame; there's no point in
5535 doing it because it's done in Fx_show_tip, and it leads to
5536 problems because the tip frame has no widget. */
5537 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5538 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5541 /* X version sets font of input methods here also. */
5547 /***********************************************************************
5548 TODO: W32 Input Methods
5549 ***********************************************************************/
5550 /* Listing missing functions from xterm.c helps diff stay in step.
5552 xim_destroy_callback (xim, client_data, call_data)
5553 xim_open_dpy (dpyinfo, resource_name)
5555 xim_instantiate_callback (display, client_data, call_data)
5556 xim_initialize (dpyinfo, resource_name)
5557 xim_close_dpy (dpyinfo)
5562 /* Calculate the absolute position in frame F
5563 from its current recorded position values and gravity. */
5566 x_calc_absolute_position (struct frame
*f
)
5568 int flags
= f
->size_hint_flags
;
5570 /* The sum of the widths of the frame's left and right borders, and
5571 the sum of the heights of the frame's top and bottom borders (in
5572 pixels) drawn by Windows. */
5573 unsigned int left_right_borders_width
, top_bottom_borders_height
;
5575 /* Try to get the actual values of these two variables. We compute
5576 the border width (height) by subtracting the width (height) of
5577 the frame's client area from the width (height) of the frame's
5579 WINDOWPLACEMENT wp
= { 0 };
5580 RECT client_rect
= { 0 };
5582 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
5583 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
5585 left_right_borders_width
=
5586 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
5587 (client_rect
.right
- client_rect
.left
);
5589 top_bottom_borders_height
=
5590 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
5591 (client_rect
.bottom
- client_rect
.top
);
5595 /* Use sensible default values. */
5596 left_right_borders_width
= 8;
5597 top_bottom_borders_height
= 32;
5600 /* Treat negative positions as relative to the rightmost bottommost
5601 position that fits on the screen. */
5602 if (flags
& XNegative
)
5603 f
->left_pos
= (x_display_pixel_width (FRAME_W32_DISPLAY_INFO (f
))
5604 - FRAME_PIXEL_WIDTH (f
)
5606 - (left_right_borders_width
- 1));
5608 if (flags
& YNegative
)
5609 f
->top_pos
= (x_display_pixel_height (FRAME_W32_DISPLAY_INFO (f
))
5610 - FRAME_PIXEL_HEIGHT (f
)
5612 - (top_bottom_borders_height
- 1));
5614 /* The left_pos and top_pos are now relative to the top and left
5615 screen edges, so the flags should correspond. */
5616 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5619 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5620 to really change the position, and 0 when calling from
5621 x_make_frame_visible (in that case, XOFF and YOFF are the current
5622 position values). It is -1 when calling from x_set_frame_parameters,
5623 which means, do adjust for borders but don't change the gravity. */
5626 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
,
5629 int modified_top
, modified_left
;
5631 if (change_gravity
> 0)
5635 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5637 f
->size_hint_flags
|= XNegative
;
5639 f
->size_hint_flags
|= YNegative
;
5640 f
->win_gravity
= NorthWestGravity
;
5642 x_calc_absolute_position (f
);
5645 x_wm_set_size_hint (f
, (long) 0, 0);
5647 modified_left
= f
->left_pos
;
5648 modified_top
= f
->top_pos
;
5650 my_set_window_pos (FRAME_W32_WINDOW (f
),
5652 modified_left
, modified_top
,
5654 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5659 /* Check if we need to resize the frame due to a fullscreen request.
5660 If so needed, resize the frame. */
5662 x_check_fullscreen (struct frame
*f
)
5664 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
5666 int width
, height
, ign
;
5668 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5670 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
5672 /* We do not need to move the window, it shall be taken care of
5673 when setting WM manager hints. */
5674 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
5676 change_frame_size (f
, height
, width
, 0, 1, 0);
5677 SET_FRAME_GARBAGED (f
);
5678 cancel_mouse_face (f
);
5680 /* Wait for the change of frame size to occur. */
5681 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
5687 w32fullscreen_hook (struct frame
*f
)
5689 if (FRAME_VISIBLE_P (f
))
5691 HWND hwnd
= FRAME_W32_WINDOW(f
);
5692 DWORD dwStyle
= GetWindowLong (hwnd
, GWL_STYLE
);
5696 f
->want_fullscreen
&= ~FULLSCREEN_WAIT
;
5698 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_NONE
)
5699 GetWindowPlacement (hwnd
, &FRAME_NORMAL_PLACEMENT (f
));
5701 if (FRAME_PREV_FSMODE (f
) == FULLSCREEN_BOTH
)
5703 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
| WS_OVERLAPPEDWINDOW
);
5704 SetWindowPos (hwnd
, NULL
, 0, 0, 0, 0,
5705 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOZORDER
|
5706 SWP_NOOWNERZORDER
| SWP_FRAMECHANGED
);
5709 w32_fullscreen_rect (hwnd
, f
->want_fullscreen
,
5710 FRAME_NORMAL_PLACEMENT (f
).rcNormalPosition
, &rect
);
5711 FRAME_PREV_FSMODE (f
) = f
->want_fullscreen
;
5712 if (f
->want_fullscreen
== FULLSCREEN_MAXIMIZED
)
5713 PostMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, 0xf030, 0);
5714 else if (f
->want_fullscreen
== FULLSCREEN_BOTH
)
5716 SetWindowLong (hwnd
, GWL_STYLE
, dwStyle
& ~WS_OVERLAPPEDWINDOW
);
5717 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
5718 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
,
5719 SWP_NOOWNERZORDER
| SWP_FRAMECHANGED
);
5723 SetWindowPos (hwnd
, HWND_TOP
, rect
.left
, rect
.top
,
5724 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, 0);
5727 f
->want_fullscreen
= FULLSCREEN_NONE
;
5731 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
5734 /* Call this to change the size of frame F's x-window.
5735 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5736 for this size change and subsequent size changes.
5737 Otherwise we leave the window gravity unchanged. */
5740 x_set_window_size (struct frame
*f
, int change_gravity
, int cols
, int rows
)
5742 int pixelwidth
, pixelheight
;
5746 check_frame_size (f
, &rows
, &cols
);
5747 f
->scroll_bar_actual_width
5748 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
5750 compute_fringe_widths (f
, 0);
5752 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
5753 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
5755 f
->win_gravity
= NorthWestGravity
;
5756 x_wm_set_size_hint (f
, (long) 0, 0);
5761 rect
.left
= rect
.top
= 0;
5762 rect
.right
= pixelwidth
;
5763 rect
.bottom
= pixelheight
;
5765 AdjustWindowRect (&rect
, f
->output_data
.w32
->dwStyle
,
5766 FRAME_EXTERNAL_MENU_BAR (f
));
5768 my_set_window_pos (FRAME_W32_WINDOW (f
),
5771 rect
.right
- rect
.left
,
5772 rect
.bottom
- rect
.top
,
5773 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5777 /* The following mirrors what is done in xterm.c. It appears to be
5778 for informing lisp of the new size immediately, while the actual
5779 resize will happen asynchronously. But on Windows, the menu bar
5780 automatically wraps when the frame is too narrow to contain it,
5781 and that causes any calculations made here to come out wrong. The
5782 end is some nasty buggy behavior, including the potential loss
5785 Disabling this code is either not sufficient to fix the problems
5786 completely, or it causes fresh problems, but at least it removes
5787 the most problematic symptom of the minibuffer becoming unusable.
5789 -----------------------------------------------------------------
5791 Now, strictly speaking, we can't be sure that this is accurate,
5792 but the window manager will get around to dealing with the size
5793 change request eventually, and we'll hear how it went when the
5794 ConfigureNotify event gets here.
5796 We could just not bother storing any of this information here,
5797 and let the ConfigureNotify event set everything up, but that
5798 might be kind of confusing to the Lisp code, since size changes
5799 wouldn't be reported in the frame parameters until some random
5800 point in the future when the ConfigureNotify event arrives.
5802 We pass 1 for DELAY since we can't run Lisp code inside of
5804 change_frame_size (f
, rows
, cols
, 0, 1, 0);
5805 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
5806 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
5808 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5809 receive in the ConfigureNotify event; if we get what we asked
5810 for, then the event won't cause the screen to become garbaged, so
5811 we have to make sure to do it here. */
5812 SET_FRAME_GARBAGED (f
);
5814 /* If cursor was outside the new size, mark it as off. */
5815 mark_window_cursors_off (XWINDOW (f
->root_window
));
5817 /* Clear out any recollection of where the mouse highlighting was,
5818 since it might be in a place that's outside the new frame size.
5819 Actually checking whether it is outside is a pain in the neck,
5820 so don't try--just let the highlighting be done afresh with new size. */
5821 cancel_mouse_face (f
);
5827 /* Mouse warping. */
5829 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
5832 x_set_mouse_position (struct frame
*f
, int x
, int y
)
5836 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
5837 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
5839 if (pix_x
< 0) pix_x
= 0;
5840 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
5842 if (pix_y
< 0) pix_y
= 0;
5843 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
5845 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
5849 x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
5856 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
5857 pt
.x
= rect
.left
+ pix_x
;
5858 pt
.y
= rect
.top
+ pix_y
;
5859 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
5861 SetCursorPos (pt
.x
, pt
.y
);
5867 /* focus shifting, raising and lowering. */
5870 x_focus_on_frame (struct frame
*f
)
5872 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
5874 /* Give input focus to frame. */
5877 /* Try not to change its Z-order if possible. */
5878 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
5879 my_set_focus (f
, FRAME_W32_WINDOW (f
));
5882 my_set_foreground_window (FRAME_W32_WINDOW (f
));
5886 /* Raise frame F. */
5888 x_raise_frame (struct frame
*f
)
5892 /* Strictly speaking, raise-frame should only change the frame's Z
5893 order, leaving input focus unchanged. This is reasonable behavior
5894 on X where the usual policy is point-to-focus. However, this
5895 behavior would be very odd on Windows where the usual policy is
5898 On X, if the mouse happens to be over the raised frame, it gets
5899 input focus anyway (so the window with focus will never be
5900 completely obscured) - if not, then just moving the mouse over it
5901 is sufficient to give it focus. On Windows, the user must actually
5902 click on the frame (preferably the title bar so as not to move
5903 point), which is more awkward. Also, no other Windows program
5904 raises a window to the top but leaves another window (possibly now
5905 completely obscured) with input focus.
5907 Because there is a system setting on Windows that allows the user
5908 to choose the point to focus policy, we make the strict semantics
5909 optional, but by default we grab focus when raising. */
5911 if (NILP (Vw32_grab_focus_on_raise
))
5913 /* The obvious call to my_set_window_pos doesn't work if Emacs is
5914 not already the foreground application: the frame is raised
5915 above all other frames belonging to us, but not above the
5916 current top window. To achieve that, we have to resort to this
5917 more cumbersome method. */
5919 HDWP handle
= BeginDeferWindowPos (2);
5922 handle
= DeferWindowPos (handle
,
5923 FRAME_W32_WINDOW (f
),
5926 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5929 handle
= DeferWindowPos (handle
,
5930 GetForegroundWindow (),
5931 FRAME_W32_WINDOW (f
),
5933 SWP_NOSIZE
| SWP_NOMOVE
|
5936 EndDeferWindowPos (handle
);
5942 my_bring_window_to_top (FRAME_W32_WINDOW (f
));
5948 /* Lower frame F. */
5950 x_lower_frame (struct frame
*f
)
5953 my_set_window_pos (FRAME_W32_WINDOW (f
),
5956 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5961 w32_frame_raise_lower (struct frame
*f
, int raise_flag
)
5963 if (! FRAME_W32_P (f
))
5972 /* Change of visibility. */
5974 /* This tries to wait until the frame is really visible.
5975 However, if the window manager asks the user where to position
5976 the frame, this will return before the user finishes doing that.
5977 The frame will not actually be visible at that time,
5978 but it will become visible later when the window manager
5979 finishes with it. */
5982 x_make_frame_visible (struct frame
*f
)
5988 type
= x_icon_type (f
);
5990 x_bitmap_icon (f
, type
);
5992 if (! FRAME_VISIBLE_P (f
))
5994 /* We test FRAME_GARBAGED_P here to make sure we don't
5995 call x_set_offset a second time
5996 if we get to x_make_frame_visible a second time
5997 before the window gets really visible. */
5998 if (! FRAME_ICONIFIED_P (f
)
5999 && ! f
->output_data
.w32
->asked_for_visible
)
6004 /* Adjust vertical window position in order to avoid being
6005 covered by a task bar placed at the bottom of the desktop. */
6006 SystemParametersInfo (SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6007 GetWindowRect (FRAME_W32_WINDOW (f
), &window_rect
);
6008 if (window_rect
.bottom
> workarea_rect
.bottom
6009 && window_rect
.top
> workarea_rect
.top
)
6010 f
->top_pos
= max (window_rect
.top
6011 - window_rect
.bottom
+ workarea_rect
.bottom
,
6014 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6017 f
->output_data
.w32
->asked_for_visible
= 1;
6019 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
6020 causes unexpected behavior when unminimizing frames that were
6021 previously maximized. But only SW_SHOWNORMAL works properly for
6022 frames that were truely hidden (using make-frame-invisible), so
6023 we need it to avoid Bug#5482. It seems that iconified is only
6024 set for minimized windows that are still visible, so use that to
6025 determine the appropriate flag to pass ShowWindow. */
6026 my_show_window (f
, FRAME_W32_WINDOW (f
),
6027 FRAME_ICONIFIED_P (f
) ? SW_RESTORE
: SW_SHOWNORMAL
);
6030 /* Synchronize to ensure Emacs knows the frame is visible
6031 before we do anything else. We do this loop with input not blocked
6032 so that incoming events are handled. */
6037 /* This must come after we set COUNT. */
6040 XSETFRAME (frame
, f
);
6042 /* Wait until the frame is visible. Process X events until a
6043 MapNotify event has been seen, or until we think we won't get a
6044 MapNotify at all.. */
6045 for (count
= input_signal_count
+ 10;
6046 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6048 /* Force processing of queued events. */
6049 /* TODO: x_sync equivalent? */
6051 /* Machines that do polling rather than SIGIO have been observed
6052 to go into a busy-wait here. So we'll fake an alarm signal
6053 to let the handler know that there's something to be read.
6054 We used to raise a real alarm, but it seems that the handler
6055 isn't always enabled here. This is probably a bug. */
6056 if (input_polling_used ())
6058 /* It could be confusing if a real alarm arrives while processing
6059 the fake one. Turn it off and let the handler reset it. */
6060 int old_poll_suppress_count
= poll_suppress_count
;
6061 poll_suppress_count
= 1;
6062 poll_for_input_1 ();
6063 poll_suppress_count
= old_poll_suppress_count
;
6069 /* Change from mapped state to withdrawn state. */
6071 /* Make the frame visible (mapped and not iconified). */
6074 x_make_frame_invisible (struct frame
*f
)
6076 /* Don't keep the highlight on an invisible frame. */
6077 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6078 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6082 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6084 /* We can't distinguish this from iconification
6085 just by the event that we get from the server.
6086 So we can't win using the usual strategy of letting
6087 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6088 and synchronize with the server to make sure we agree. */
6089 SET_FRAME_VISIBLE (f
, 0);
6090 SET_FRAME_ICONIFIED (f
, 0);
6095 /* Change window state from mapped to iconified. */
6098 x_iconify_frame (struct frame
*f
)
6102 /* Don't keep the highlight on an invisible frame. */
6103 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6104 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6106 if (FRAME_ICONIFIED_P (f
))
6111 type
= x_icon_type (f
);
6113 x_bitmap_icon (f
, type
);
6115 /* Simulate the user minimizing the frame. */
6116 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
6118 SET_FRAME_VISIBLE (f
, 0);
6119 SET_FRAME_ICONIFIED (f
, 1);
6125 /* Free X resources of frame F. */
6128 x_free_frame_resources (struct frame
*f
)
6130 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6131 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
6135 /* We must free faces before destroying windows because some
6136 font-driver (e.g. xft) access a window while finishing a
6138 if (FRAME_FACE_CACHE (f
))
6139 free_frame_faces (f
);
6141 if (FRAME_W32_WINDOW (f
))
6142 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6144 free_frame_menubar (f
);
6146 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
6147 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
6148 unload_color (f
, f
->output_data
.w32
->cursor_pixel
);
6149 unload_color (f
, f
->output_data
.w32
->cursor_foreground_pixel
);
6150 unload_color (f
, f
->output_data
.w32
->border_pixel
);
6151 unload_color (f
, f
->output_data
.w32
->mouse_pixel
);
6152 if (f
->output_data
.w32
->white_relief
.allocated_p
)
6153 unload_color (f
, f
->output_data
.w32
->white_relief
.pixel
);
6154 if (f
->output_data
.w32
->black_relief
.allocated_p
)
6155 unload_color (f
, f
->output_data
.w32
->black_relief
.pixel
);
6157 if (FRAME_FACE_CACHE (f
))
6158 free_frame_faces (f
);
6160 xfree (f
->output_data
.w32
);
6161 f
->output_data
.w32
= NULL
;
6163 if (f
== dpyinfo
->w32_focus_frame
)
6164 dpyinfo
->w32_focus_frame
= 0;
6165 if (f
== dpyinfo
->w32_focus_event_frame
)
6166 dpyinfo
->w32_focus_event_frame
= 0;
6167 if (f
== dpyinfo
->x_highlight_frame
)
6168 dpyinfo
->x_highlight_frame
= 0;
6170 if (f
== hlinfo
->mouse_face_mouse_frame
)
6172 hlinfo
->mouse_face_beg_row
6173 = hlinfo
->mouse_face_beg_col
= -1;
6174 hlinfo
->mouse_face_end_row
6175 = hlinfo
->mouse_face_end_col
= -1;
6176 hlinfo
->mouse_face_window
= Qnil
;
6177 hlinfo
->mouse_face_mouse_frame
= 0;
6184 /* Destroy the window of frame F. */
6186 x_destroy_window (struct frame
*f
)
6188 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6190 x_free_frame_resources (f
);
6191 dpyinfo
->reference_count
--;
6195 /* Setting window manager hints. */
6197 /* Set the normal size hints for the window manager, for frame F.
6198 FLAGS is the flags word to use--or 0 meaning preserve the flags
6199 that the window now has.
6200 If USER_POSITION, set the USPosition
6201 flag (this is useful when FLAGS is 0). */
6203 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
6205 Window window
= FRAME_W32_WINDOW (f
);
6209 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6210 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6211 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6212 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
6217 /***********************************************************************
6219 ***********************************************************************/
6223 /* Check that FONT is valid on frame F. It is if it can be found in F's
6227 x_check_font (struct frame
*f
, struct font
*font
)
6229 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
6230 if (font
->driver
->check
)
6231 eassert (font
->driver
->check (f
, font
) == 0);
6234 #endif /* GLYPH_DEBUG */
6238 /***********************************************************************
6240 ***********************************************************************/
6242 static int w32_initialized
= 0;
6245 w32_initialize_display_info (Lisp_Object display_name
)
6247 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6248 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
6250 memset (dpyinfo
, 0, sizeof (*dpyinfo
));
6252 /* Put it on w32_display_name_list. */
6253 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
6254 w32_display_name_list
);
6255 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
6257 dpyinfo
->w32_id_name
= xmalloc (SCHARS (Vinvocation_name
)
6258 + SCHARS (Vsystem_name
) + 2);
6259 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6260 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6262 /* Default Console mode values - overridden when running in GUI mode
6263 with values obtained from system metrics. */
6266 dpyinfo
->n_planes
= 1;
6267 dpyinfo
->n_cbits
= 4;
6268 dpyinfo
->n_fonts
= 0;
6269 dpyinfo
->smallest_font_height
= 1;
6270 dpyinfo
->smallest_char_width
= 1;
6272 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
6273 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
6274 hlinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
6275 hlinfo
->mouse_face_window
= Qnil
;
6276 hlinfo
->mouse_face_overlay
= Qnil
;
6277 hlinfo
->mouse_face_hidden
= 0;
6279 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6280 /* TODO: dpyinfo->gray */
6284 /* Create an xrdb-style database of resources to supersede registry settings.
6285 The database is just a concatenation of C strings, finished by an additional
6286 \0. The strings are submitted to some basic normalization, so
6288 [ *]option[ *]:[ *]value...
6294 but any whitespace following value is not removed. */
6297 w32_make_rdb (char *xrm_option
)
6299 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6300 char *current
= buffer
;
6303 int before_value
= 0;
6317 if (in_option
&& (ch
== ':'))
6322 else if (before_value
)
6327 else if (!(in_option
|| before_value
))
6339 x_flush (struct frame
* f
)
6340 { /* Nothing to do */ }
6343 extern frame_parm_handler w32_frame_parm_handlers
[];
6345 static struct redisplay_interface w32_redisplay_interface
=
6347 w32_frame_parm_handlers
,
6351 x_clear_end_of_line
,
6353 x_after_update_window_line
,
6354 x_update_window_begin
,
6355 x_update_window_end
,
6358 0, /* flush_display_optional */
6359 x_clear_window_mouse_face
,
6360 x_get_glyph_overhangs
,
6361 x_fix_overlapping_area
,
6362 w32_draw_fringe_bitmap
,
6363 w32_define_fringe_bitmap
,
6364 w32_destroy_fringe_bitmap
,
6365 w32_compute_glyph_string_overhangs
,
6366 x_draw_glyph_string
,
6367 w32_define_frame_cursor
,
6368 w32_clear_frame_area
,
6369 w32_draw_window_cursor
,
6370 w32_draw_vertical_window_border
,
6371 w32_shift_glyphs_for_insert
6374 static void x_delete_terminal (struct terminal
*term
);
6376 static struct terminal
*
6377 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6379 struct terminal
*terminal
;
6381 terminal
= create_terminal ();
6383 terminal
->type
= output_w32
;
6384 terminal
->display_info
.w32
= dpyinfo
;
6385 dpyinfo
->terminal
= terminal
;
6387 /* MSVC does not type K&R functions with no arguments correctly, and
6388 so we must explicitly cast them. */
6389 terminal
->clear_frame_hook
= x_clear_frame
;
6390 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6391 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6392 terminal
->ring_bell_hook
= w32_ring_bell
;
6393 terminal
->reset_terminal_modes_hook
= w32_reset_terminal_modes
;
6394 terminal
->set_terminal_modes_hook
= w32_set_terminal_modes
;
6395 terminal
->update_begin_hook
= x_update_begin
;
6396 terminal
->update_end_hook
= x_update_end
;
6397 terminal
->set_terminal_window_hook
= w32_set_terminal_window
;
6398 terminal
->read_socket_hook
= w32_read_socket
;
6399 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6400 terminal
->mouse_position_hook
= w32_mouse_position
;
6401 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6402 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6403 terminal
->fullscreen_hook
= w32fullscreen_hook
;
6404 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6405 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6406 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6407 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6409 terminal
->delete_frame_hook
= x_destroy_window
;
6410 terminal
->delete_terminal_hook
= x_delete_terminal
;
6412 terminal
->rif
= &w32_redisplay_interface
;
6413 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
6414 terminal
->char_ins_del_ok
= 1;
6415 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
6416 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
6417 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
6420 /* We don't yet support separate terminals on W32, so don't try to share
6421 keyboards between virtual terminals that are on the same physical
6422 terminal like X does. */
6423 terminal
->kboard
= xmalloc (sizeof (KBOARD
));
6424 init_kboard (terminal
->kboard
);
6425 kset_window_system (terminal
->kboard
, intern ("w32"));
6426 terminal
->kboard
->next_kboard
= all_kboards
;
6427 all_kboards
= terminal
->kboard
;
6428 /* Don't let the initial kboard remain current longer than necessary.
6429 That would cause problems if a file loaded on startup tries to
6430 prompt in the mini-buffer. */
6431 if (current_kboard
== initial_kboard
)
6432 current_kboard
= terminal
->kboard
;
6433 terminal
->kboard
->reference_count
++;
6439 x_delete_terminal (struct terminal
*terminal
)
6441 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
6443 /* Protect against recursive calls. delete_frame in
6444 delete_terminal calls us back when it deletes our last frame. */
6445 if (!terminal
->name
)
6450 x_delete_display (dpyinfo
);
6454 struct w32_display_info
*
6455 w32_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
6457 struct w32_display_info
*dpyinfo
;
6458 struct terminal
*terminal
;
6463 if (!w32_initialized
)
6466 w32_initialized
= 1;
6469 w32_initialize_display_info (display_name
);
6471 dpyinfo
= &one_w32_display_info
;
6472 terminal
= w32_create_terminal (dpyinfo
);
6474 /* Set the name of the terminal. */
6475 terminal
->name
= xmalloc (SBYTES (display_name
) + 1);
6476 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
6477 terminal
->name
[SBYTES (display_name
)] = 0;
6479 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6481 /* Put this display on the chain. */
6482 dpyinfo
->next
= x_display_list
;
6483 x_display_list
= dpyinfo
;
6487 dpyinfo
->root_window
= GetDesktopWindow ();
6488 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6489 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6490 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6491 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6492 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6493 ReleaseDC (NULL
, hdc
);
6495 /* initialize palette with white and black */
6498 w32_defined_color (0, "white", &color
, 1);
6499 w32_defined_color (0, "black", &color
, 1);
6503 /* Add the default keyboard. When !WINDOWSNT, we're using the
6504 standard Emacs console handling machinery and don't need an
6505 explicit FD here. */
6506 add_keyboard_wait_descriptor (0);
6508 /* /dev/windows wakes us up when we have a thread message pending. */
6509 add_keyboard_wait_descriptor (w32_message_fd
);
6512 /* Create Fringe Bitmaps and store them for later use.
6514 On W32, bitmaps are all unsigned short, as Windows requires
6515 bitmap data to be Word aligned. For some reason they are
6516 horizontally reflected compared to how they appear on X, so we
6517 need to bitswap and convert to unsigned shorts before creating
6519 w32_init_fringe (terminal
->rif
);
6526 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6528 x_delete_display (struct w32_display_info
*dpyinfo
)
6530 /* Discard this display from w32_display_name_list and w32_display_list.
6531 We can't use Fdelq because that can quit. */
6532 if (! NILP (w32_display_name_list
)
6533 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
6534 w32_display_name_list
= XCDR (w32_display_name_list
);
6539 tail
= w32_display_name_list
;
6540 while (CONSP (tail
) && CONSP (XCDR (tail
)))
6542 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
6544 XSETCDR (tail
, XCDR (XCDR (tail
)));
6551 /* free palette table */
6553 struct w32_palette_entry
* plist
;
6555 plist
= dpyinfo
->color_list
;
6558 struct w32_palette_entry
* pentry
= plist
;
6559 plist
= plist
->next
;
6562 dpyinfo
->color_list
= NULL
;
6563 if (dpyinfo
->palette
)
6564 DeleteObject (dpyinfo
->palette
);
6566 xfree (dpyinfo
->w32_id_name
);
6568 w32_reset_fringes ();
6572 /* Set up use of W32. */
6574 DWORD WINAPI
w32_msg_worker (void * arg
);
6577 w32_initialize (void)
6580 HRESULT (WINAPI
* set_user_model
) (wchar_t * id
);
6584 w32_system_caret_hwnd
= NULL
;
6585 w32_system_caret_height
= 0;
6586 w32_system_caret_x
= 0;
6587 w32_system_caret_y
= 0;
6589 /* On Windows 7 and later, we need to set the user model ID
6590 to associate emacsclient launched files with Emacs frames
6592 shell
= GetModuleHandle ("shell32.dll");
6596 = (void *) GetProcAddress (shell
,
6597 "SetCurrentProcessExplicitAppUserModelID");
6599 /* If the function is defined, then we are running on Windows 7
6600 or newer, and the UI uses this to group related windows
6601 together. Since emacs, runemacs, emacsclient are related, we
6602 want them grouped even though the executables are different,
6603 so we need to set a consistent ID between them. */
6605 set_user_model (L
"GNU.Emacs");
6609 if ((w32_message_fd
= emacs_open ("/dev/windows", O_RDWR
, 0)) == -1)
6610 fatal ("opening /dev/windows: %s", strerror (errno
));
6613 /* Initialize w32_use_visible_system_caret based on whether a screen
6614 reader is in use. */
6615 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
6616 &w32_use_visible_system_caret
, 0))
6617 w32_use_visible_system_caret
= 0;
6619 last_tool_bar_item
= -1;
6620 any_help_event_p
= 0;
6622 /* Initialize input mode: interrupt_input off, no flow control, allow
6623 8 bit character input, standard quit char. */
6624 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
6627 DWORD input_locale_id
= ((DWORD_PTR
) GetKeyboardLayout (0) & 0xffffffff);
6628 w32_keyboard_codepage
=
6629 codepage_for_locale ((LCID
) (input_locale_id
& 0xffff));
6632 /* Create the window thread - it will terminate itself when the app
6636 dwMainThreadId
= GetCurrentThreadId ();
6637 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6638 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
6640 /* Wait for thread to start */
6644 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
6646 hWindowsThread
= CreateThread (NULL
, 0,
6648 0, 0, &dwWindowsThreadId
);
6650 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6653 /* It is desirable that mainThread should have the same notion of
6654 focus window and active window as windowsThread. Unfortunately, the
6655 following call to AttachThreadInput, which should do precisely what
6656 we need, causes major problems when Emacs is linked as a console
6657 program. Unfortunately, we have good reasons for doing that, so
6658 instead we need to send messages to windowsThread to make some API
6659 calls for us (ones that affect, or depend on, the active/focus
6661 #ifdef ATTACH_THREADS
6662 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
6665 /* Dynamically link to optional system components. */
6667 HMODULE user_lib
= GetModuleHandle ("user32.dll");
6669 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
6671 LOAD_PROC (user_lib
, SetLayeredWindowAttributes
);
6675 /* Ensure scrollbar handle is at least 5 pixels. */
6676 vertical_scroll_bar_min_handle
= 5;
6678 /* For either kind of scroll bar, take account of the arrows; these
6679 effectively form the border of the main scroll bar range. */
6680 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
6681 = GetSystemMetrics (SM_CYVSCROLL
);
6686 syms_of_w32term (void)
6688 staticpro (&w32_display_name_list
);
6689 w32_display_name_list
= Qnil
;
6691 staticpro (&last_mouse_scroll_bar
);
6692 last_mouse_scroll_bar
= Qnil
;
6694 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
6696 DEFSYM (Qadded
, "added");
6697 DEFSYM (Qremoved
, "removed");
6698 DEFSYM (Qmodified
, "modified");
6699 DEFSYM (Qrenamed_from
, "renamed-from");
6700 DEFSYM (Qrenamed_to
, "renamed-to");
6702 DEFVAR_INT ("w32-num-mouse-buttons",
6703 w32_num_mouse_buttons
,
6704 doc
: /* Number of physical mouse buttons. */);
6705 w32_num_mouse_buttons
= 2;
6707 DEFVAR_LISP ("w32-swap-mouse-buttons",
6708 Vw32_swap_mouse_buttons
,
6709 doc
: /* Swap the mapping of middle and right mouse buttons.
6710 When nil, middle button is mouse-2 and right button is mouse-3. */);
6711 Vw32_swap_mouse_buttons
= Qnil
;
6713 DEFVAR_LISP ("w32-grab-focus-on-raise",
6714 Vw32_grab_focus_on_raise
,
6715 doc
: /* Raised frame grabs input focus.
6716 When t, `raise-frame' grabs input focus as well. This fits well
6717 with the normal Windows click-to-focus policy, but might not be
6718 desirable when using a point-to-focus policy. */);
6719 Vw32_grab_focus_on_raise
= Qt
;
6721 DEFVAR_LISP ("w32-capslock-is-shiftlock",
6722 Vw32_capslock_is_shiftlock
,
6723 doc
: /* Apply CapsLock state to non character input keys.
6724 When nil, CapsLock only affects normal character input keys. */);
6725 Vw32_capslock_is_shiftlock
= Qnil
;
6727 DEFVAR_LISP ("w32-recognize-altgr",
6728 Vw32_recognize_altgr
,
6729 doc
: /* Recognize right-alt and left-ctrl as AltGr.
6730 When nil, the right-alt and left-ctrl key combination is
6731 interpreted normally. */);
6732 Vw32_recognize_altgr
= Qt
;
6734 DEFVAR_BOOL ("w32-use-visible-system-caret",
6735 w32_use_visible_system_caret
,
6736 doc
: /* Flag to make the system caret visible.
6737 When this is non-nil, Emacs will indicate the position of point by
6738 using the system caret instead of drawing its own cursor. Some screen
6739 reader software does not track the system cursor properly when it is
6740 invisible, and gets confused by Emacs drawing its own cursor, so this
6741 variable is initialized to t when Emacs detects that screen reader
6742 software is running as it starts up.
6744 When this variable is set, other variables affecting the appearance of
6745 the cursor have no effect. */);
6747 w32_use_visible_system_caret
= 0;
6749 /* We don't yet support this, but defining this here avoids whining
6750 from cus-start.el and other places, like "M-x set-variable". */
6751 DEFVAR_BOOL ("x-use-underline-position-properties",
6752 x_use_underline_position_properties
,
6753 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
6754 A value of nil means ignore them. If you encounter fonts with bogus
6755 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
6756 to 4.1, set this to nil. You can also use `underline-minimum-offset'
6757 to override the font's UNDERLINE_POSITION for small font display
6759 x_use_underline_position_properties
= 0;
6761 DEFVAR_BOOL ("x-underline-at-descent-line",
6762 x_underline_at_descent_line
,
6763 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
6764 A value of nil means to draw the underline according to the value of the
6765 variable `x-use-underline-position-properties', which is usually at the
6766 baseline level. The default value is nil. */);
6767 x_underline_at_descent_line
= 0;
6769 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
6770 doc
: /* Which toolkit scroll bars Emacs uses, if any.
6771 A value of nil means Emacs doesn't use toolkit scroll bars.
6772 With the X Window system, the value is a symbol describing the
6773 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
6774 With MS Windows or Nextstep, the value is t. */);
6775 Vx_toolkit_scroll_bars
= Qt
;
6777 staticpro (&last_mouse_motion_frame
);
6778 last_mouse_motion_frame
= Qnil
;
6780 Fprovide (intern_c_string ("w32"), Qnil
);