1 /* Implementation of GUI terminal on the Microsoft W32 API.
2 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 2006, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
26 #include "blockinput.h"
38 #include "character.h"
42 #include "dispextern.h"
44 #include "termhooks.h"
51 #include "intervals.h"
64 static int max_fringe_bmp
= 0;
65 static HBITMAP
*fringe_bmp
= 0;
67 /* Non-nil means Emacs uses toolkit scroll bars. */
69 Lisp_Object Vx_toolkit_scroll_bars
;
71 /* Temporary variables for w32_read_socket. */
73 static int last_mousemove_x
= 0;
74 static int last_mousemove_y
= 0;
76 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
77 #ifndef GET_WHEEL_DELTA_WPARAM
78 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
81 /* Non-zero means that a HELP_EVENT has been generated since Emacs
84 static int any_help_event_p
;
86 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
87 static Lisp_Object last_window
;
89 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
90 int x_use_underline_position_properties
;
92 /* Non-zero means to draw the underline at the same place as the descent line. */
94 int x_underline_at_descent_line
;
96 extern unsigned int msh_mousewheel
;
98 extern void free_frame_menubar ();
100 extern int w32_codepage_for_font (char *fontname
);
101 extern Cursor
w32_load_cursor (LPCTSTR name
);
103 extern Lisp_Object Vwindow_system
;
105 #define x_any_window_to_frame x_window_to_frame
106 #define x_top_window_to_frame x_window_to_frame
109 /* This is display since w32 does not support multiple ones. */
110 struct w32_display_info one_w32_display_info
;
111 struct w32_display_info
*x_display_list
;
113 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
114 one for each element of w32_display_list and in the same order.
115 NAME is the name of the frame.
116 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
117 Lisp_Object w32_display_name_list
;
121 /* Pre Windows 2000, this was not available, but define it here so
122 that Emacs compiled on such a platform will run on newer versions. */
124 typedef struct tagWCRANGE
130 typedef struct tagGLYPHSET
134 DWORD cGlyphsSupported
;
141 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
142 BOOL (PASCAL
*pfnSetLayeredWindowAttributes
) (HWND
, COLORREF
, BYTE
, DWORD
);
145 #define LWA_ALPHA 0x02
147 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
148 later targets by MSVC headers. */
149 #ifndef WS_EX_LAYERED
150 #define WS_EX_LAYERED 0x80000
153 /* Frame being updated by update_frame. This is declared in term.c.
154 This is set by update_begin and looked at by all the
155 w32 functions. It is zero while not inside an update.
156 In that case, the w32 functions assume that `SELECTED_FRAME ()'
157 is the frame to apply to. */
158 extern struct frame
*updating_frame
;
160 /* This is a frame waiting to be autoraised, within w32_read_socket. */
161 struct frame
*pending_autoraise_frame
;
163 /* The handle of the frame that currently owns the system caret. */
164 HWND w32_system_caret_hwnd
;
165 int w32_system_caret_height
;
166 int w32_system_caret_x
;
167 int w32_system_caret_y
;
168 int w32_use_visible_system_caret
;
170 DWORD dwWindowsThreadId
= 0;
171 HANDLE hWindowsThread
= NULL
;
172 DWORD dwMainThreadId
= 0;
173 HANDLE hMainThread
= NULL
;
175 int vertical_scroll_bar_min_handle
;
176 int vertical_scroll_bar_top_border
;
177 int vertical_scroll_bar_bottom_border
;
179 int last_scroll_bar_drag_pos
;
181 /* Mouse movement. */
183 /* Where the mouse was last time we reported a mouse event. */
185 static RECT last_mouse_glyph
;
186 static FRAME_PTR last_mouse_glyph_frame
;
187 static Lisp_Object last_mouse_press_frame
;
189 int w32_num_mouse_buttons
;
191 Lisp_Object Vw32_swap_mouse_buttons
;
193 /* Control whether x_raise_frame also sets input focus. */
194 Lisp_Object Vw32_grab_focus_on_raise
;
196 /* Control whether Caps Lock affects non-ascii characters. */
197 Lisp_Object Vw32_capslock_is_shiftlock
;
199 /* Control whether right-alt and left-ctrl should be recognized as AltGr. */
200 Lisp_Object Vw32_recognize_altgr
;
202 /* The scroll bar in which the last motion event occurred.
204 If the last motion event occurred in a scroll bar, we set this
205 so w32_mouse_position can know whether to report a scroll bar motion or
208 If the last motion event didn't occur in a scroll bar, we set this
209 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
210 static Lisp_Object last_mouse_scroll_bar
;
211 static int last_mouse_scroll_bar_pos
;
213 /* This is a hack. We would really prefer that w32_mouse_position would
214 return the time associated with the position it returns, but there
215 doesn't seem to be any way to wrest the time-stamp from the server
216 along with the position query. So, we just keep track of the time
217 of the last movement we received, and return that in hopes that
218 it's somewhat accurate. */
220 static Time last_mouse_movement_time
;
222 /* Incremented by w32_read_socket whenever it really tries to read
226 static int volatile input_signal_count
;
228 static int input_signal_count
;
231 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
237 /* A mask of extra modifier bits to put into every keyboard char. */
239 extern EMACS_INT extra_keyboard_modifiers
;
241 static void x_update_window_end
P_ ((struct window
*, int, int));
242 static void w32_handle_tool_bar_click
P_ ((struct frame
*,
243 struct input_event
*));
244 static void w32_define_cursor
P_ ((Window
, Cursor
));
246 void x_lower_frame
P_ ((struct frame
*));
247 void x_scroll_bar_clear
P_ ((struct frame
*));
248 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
249 void x_raise_frame
P_ ((struct frame
*));
250 void x_set_window_size
P_ ((struct frame
*, int, int, int));
251 void x_wm_set_window_state
P_ ((struct frame
*, int));
252 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
253 static void w32_initialize
P_ ((void));
254 static void x_update_end
P_ ((struct frame
*));
255 static void w32_frame_up_to_date
P_ ((struct frame
*));
256 static void w32_set_terminal_modes
P_ ((struct terminal
*));
257 static void w32_reset_terminal_modes
P_ ((struct terminal
*));
258 static void x_clear_frame
P_ ((struct frame
*));
259 static void frame_highlight
P_ ((struct frame
*));
260 static void frame_unhighlight
P_ ((struct frame
*));
261 static void x_new_focus_frame
P_ ((struct w32_display_info
*,
263 static void x_focus_changed
P_ ((int, int, struct w32_display_info
*,
264 struct frame
*, struct input_event
*));
265 static void w32_detect_focus_change
P_ ((struct w32_display_info
*,
266 W32Msg
*, struct input_event
*));
267 static void w32_frame_rehighlight
P_ ((struct frame
*));
268 static void x_frame_rehighlight
P_ ((struct w32_display_info
*));
269 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
270 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
271 enum text_cursor_kinds
));
272 static void w32_clip_to_row
P_ ((struct window
*, struct glyph_row
*, int, HDC
));
273 static BOOL my_show_window
P_ ((struct frame
*, HWND
, int));
274 static void my_set_window_pos
P_ ((HWND
, HWND
, int, int, int, int, UINT
));
275 static void my_set_focus
P_ ((struct frame
*, HWND
));
276 static void my_set_foreground_window
P_ ((HWND
));
277 static void my_destroy_window
P_ ((struct frame
*, HWND
));
279 static Lisp_Object Qvendor_specific_keysyms
;
282 /***********************************************************************
284 ***********************************************************************/
288 /* This is a function useful for recording debugging information about
289 the sequence of occurrences in this file. */
297 struct record event_record
[100];
299 int event_record_index
;
301 record_event (locus
, type
)
305 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
306 event_record_index
= 0;
308 event_record
[event_record_index
].locus
= locus
;
309 event_record
[event_record_index
].type
= type
;
310 event_record_index
++;
317 XChangeGC (void * ignore
, XGCValues
* gc
, unsigned long mask
,
320 if (mask
& GCForeground
)
321 gc
->foreground
= xgcv
->foreground
;
322 if (mask
& GCBackground
)
323 gc
->background
= xgcv
->background
;
325 gc
->font
= xgcv
->font
;
328 XGCValues
*XCreateGC (void * ignore
, Window window
, unsigned long mask
,
331 XGCValues
*gc
= (XGCValues
*) xmalloc (sizeof (XGCValues
));
332 bzero (gc
, sizeof (XGCValues
));
334 XChangeGC (ignore
, gc
, mask
, xgcv
);
340 XGetGCValues (void* ignore
, XGCValues
*gc
,
341 unsigned long mask
, XGCValues
*xgcv
)
343 XChangeGC (ignore
, xgcv
, mask
, gc
);
347 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
351 HRGN clip_region
= CreateRectRgnIndirect (rect
);
352 SelectClipRgn (hdc
, clip_region
);
353 DeleteObject (clip_region
);
356 SelectClipRgn (hdc
, NULL
);
360 /* Draw a hollow rectangle at the specified position. */
362 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
363 int width
, int height
)
368 hb
= CreateSolidBrush (gc
->background
);
369 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
370 oldhb
= SelectObject (hdc
, hb
);
371 oldhp
= SelectObject (hdc
, hp
);
373 Rectangle (hdc
, x
, y
, x
+ width
, y
+ height
);
375 SelectObject (hdc
, oldhb
);
376 SelectObject (hdc
, oldhp
);
381 /* Draw a filled rectangle at the specified position. */
383 w32_fill_rect (f
, hdc
, pix
, lprect
)
391 hb
= CreateSolidBrush (pix
);
392 FillRect (hdc
, lprect
, hb
);
401 HDC hdc
= get_frame_dc (f
);
403 /* Under certain conditions, this can be called at startup with
404 a console frame pointer before the GUI frame is created. An HDC
405 of 0 indicates this. */
408 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
409 w32_clear_rect (f
, hdc
, &rect
);
412 release_frame_dc (f
, hdc
);
415 #define OPAQUE_FRAME 255
418 x_set_frame_alpha (f
)
421 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
423 double alpha_min
= 1.0;
426 HWND window
= FRAME_W32_WINDOW (f
);
428 /* Older versions of Windows do not support transparency. */
429 if (!pfnSetLayeredWindowAttributes
)
432 if (dpyinfo
->x_highlight_frame
== f
)
437 if (FLOATP (Vframe_alpha_lower_limit
))
438 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
439 else if (INTEGERP (Vframe_alpha_lower_limit
))
440 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
442 if (alpha
< 0.0 || 1.0 < alpha
)
444 else if (alpha
< alpha_min
&& alpha_min
<= 1.0)
447 opac
= alpha
* OPAQUE_FRAME
;
449 ex_style
= GetWindowLong (window
, GWL_EXSTYLE
);
451 if (opac
== OPAQUE_FRAME
)
452 ex_style
&= ~WS_EX_LAYERED
;
454 ex_style
|= WS_EX_LAYERED
;
456 SetWindowLong (window
, GWL_EXSTYLE
, ex_style
);
458 if (opac
!= OPAQUE_FRAME
)
459 pfnSetLayeredWindowAttributes (window
, 0, opac
, LWA_ALPHA
);
463 /***********************************************************************
464 Starting and ending an update
465 ***********************************************************************/
467 /* Start an update of frame F. This function is installed as a hook
468 for update_begin, i.e. it is called when update_begin is called.
469 This function is called prior to calls to x_update_window_begin for
470 each window being updated. */
476 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
478 if (! FRAME_W32_P (f
))
481 /* Regenerate display palette before drawing if list of requested
482 colors has changed. */
483 if (display_info
->regen_palette
)
485 w32_regenerate_palette (f
);
486 display_info
->regen_palette
= FALSE
;
491 /* Start update of window W. Set the global variable updated_window
492 to the window being updated and set output_cursor to the cursor
496 x_update_window_begin (w
)
499 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
500 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
502 /* Hide the system caret during an update. */
503 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
505 SendMessage (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0);
509 set_output_cursor (&w
->cursor
);
513 if (f
== display_info
->mouse_face_mouse_frame
)
515 /* Don't do highlighting for mouse motion during the update. */
516 display_info
->mouse_face_defer
= 1;
518 /* If F needs to be redrawn, simply forget about any prior mouse
520 if (FRAME_GARBAGED_P (f
))
521 display_info
->mouse_face_window
= Qnil
;
523 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
524 their mouse_face_p flag set, which means that they are always
525 unequal to rows in a desired matrix which never have that
526 flag set. So, rows containing mouse-face glyphs are never
527 scrolled, and we don't have to switch the mouse highlight off
528 here to prevent it from being scrolled. */
530 /* Can we tell that this update does not affect the window
531 where the mouse highlight is? If so, no need to turn off.
532 Likewise, don't do anything if the frame is garbaged;
533 in that case, the frame's current matrix that we would use
534 is all wrong, and we will redisplay that line anyway. */
535 if (!NILP (display_info
->mouse_face_window
)
536 && w
== XWINDOW (display_info
->mouse_face_window
))
540 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
541 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
544 if (i
< w
->desired_matrix
->nrows
)
545 clear_mouse_face (display_info
);
553 /* Draw a vertical window border from (x,y0) to (x,y1) */
556 w32_draw_vertical_window_border (w
, x
, y0
, y1
)
560 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
570 hdc
= get_frame_dc (f
);
571 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
573 w32_fill_rect (f
, hdc
, face
->foreground
, &r
);
575 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
577 release_frame_dc (f
, hdc
);
581 /* End update of window W (which is equal to updated_window).
583 Draw vertical borders between horizontally adjacent windows, and
584 display W's cursor if CURSOR_ON_P is non-zero.
586 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
587 glyphs in mouse-face were overwritten. In that case we have to
588 make sure that the mouse-highlight is properly redrawn.
590 W may be a menu bar pseudo-window in case we don't have X toolkit
591 support. Such windows don't have a cursor, so don't display it
595 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
597 int cursor_on_p
, mouse_face_overwritten_p
;
599 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
601 if (!w
->pseudo_window_p
)
606 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
608 output_cursor
.x
, output_cursor
.y
);
610 if (draw_window_fringes (w
, 1))
611 x_draw_vertical_border (w
);
616 /* If a row with mouse-face was overwritten, arrange for
617 XTframe_up_to_date to redisplay the mouse highlight. */
618 if (mouse_face_overwritten_p
)
620 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
621 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
622 dpyinfo
->mouse_face_window
= Qnil
;
625 /* Unhide the caret. This won't actually show the cursor, unless it
626 was visible before the corresponding call to HideCaret in
627 x_update_window_begin. */
628 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
630 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
633 updated_window
= NULL
;
637 /* End update of frame F. This function is installed as a hook in
644 if (! FRAME_W32_P (f
))
647 /* Mouse highlight may be displayed again. */
648 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
652 /* This function is called from various places in xdisp.c whenever a
653 complete update has been performed. The global variable
654 updated_window is not available here. */
657 w32_frame_up_to_date (f
)
662 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
664 if (dpyinfo
->mouse_face_deferred_gc
665 || f
== dpyinfo
->mouse_face_mouse_frame
)
668 if (dpyinfo
->mouse_face_mouse_frame
)
669 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
670 dpyinfo
->mouse_face_mouse_x
,
671 dpyinfo
->mouse_face_mouse_y
);
672 dpyinfo
->mouse_face_deferred_gc
= 0;
679 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
680 arrow bitmaps, or clear the fringes if no bitmaps are required
681 before DESIRED_ROW is made current. The window being updated is
682 found in updated_window. This function is called from
683 update_window_line only if it is known that there are differences
684 between bitmaps to be drawn between current row and DESIRED_ROW. */
687 x_after_update_window_line (desired_row
)
688 struct glyph_row
*desired_row
;
690 struct window
*w
= updated_window
;
696 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
697 desired_row
->redraw_fringe_bitmaps_p
= 1;
699 /* When a window has disappeared, make sure that no rest of
700 full-width rows stays visible in the internal border. Could
701 check here if updated_window is the leftmost/rightmost window,
702 but I guess it's not worth doing since vertically split windows
703 are almost never used, internal border is rarely set, and the
704 overhead is very small. */
705 if (windows_or_buffers_changed
706 && desired_row
->full_width_p
707 && (f
= XFRAME (w
->frame
),
708 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
710 && (height
= desired_row
->visible_height
,
713 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
715 /* Internal border is drawn below the tool bar. */
716 if (WINDOWP (f
->tool_bar_window
)
717 && w
== XWINDOW (f
->tool_bar_window
))
722 HDC hdc
= get_frame_dc (f
);
723 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
724 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
726 release_frame_dc (f
, hdc
);
733 /* Draw the bitmap WHICH in one of the left or right fringes of
734 window W. ROW is the glyph row for which to display the bitmap; it
735 determines the vertical position at which the bitmap has to be
739 w32_draw_fringe_bitmap (w
, row
, p
)
741 struct glyph_row
*row
;
742 struct draw_fringe_bitmap_params
*p
;
744 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
746 struct face
*face
= p
->face
;
749 hdc
= get_frame_dc (f
);
753 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
755 /* If the fringe is adjacent to the left (right) scroll bar of a
756 leftmost (rightmost, respectively) window, then extend its
757 background to the gap between the fringe and the bar. */
758 if ((WINDOW_LEFTMOST_P (w
)
759 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
760 || (WINDOW_RIGHTMOST_P (w
)
761 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
763 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
767 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
768 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
769 * FRAME_COLUMN_WIDTH (f
));
773 /* Bitmap fills the fringe. */
774 if (left
+ width
== p
->x
)
775 bx
= left
+ sb_width
;
776 else if (p
->x
+ p
->wd
== left
)
780 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
782 nx
= width
- sb_width
;
783 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
785 ny
= row
->visible_height
;
790 if (left
+ width
== bx
)
792 bx
= left
+ sb_width
;
793 nx
+= width
- sb_width
;
795 else if (bx
+ nx
== left
)
796 nx
+= width
- sb_width
;
801 if (bx
>= 0 && nx
> 0)
802 w32_fill_area (f
, hdc
, face
->background
, bx
, by
, nx
, ny
);
805 /* Must clip because of partially visible lines. */
806 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
809 /* Adjust position of "bottom aligned" bitmap on partially
812 int oldVH
= row
->visible_height
;
813 row
->visible_height
= p
->h
;
814 row
->y
-= rowY
- p
->y
;
815 w32_clip_to_row (w
, row
, -1, hdc
);
817 row
->visible_height
= oldVH
;
820 w32_clip_to_row (w
, row
, -1, hdc
);
822 if (p
->which
&& p
->which
< max_fringe_bmp
)
824 HBITMAP pixmap
= fringe_bmp
[p
->which
];
828 compat_hdc
= CreateCompatibleDC (hdc
);
832 horig_obj
= SelectObject (compat_hdc
, pixmap
);
834 /* Paint overlays transparently. */
837 HBRUSH h_brush
, h_orig_brush
;
839 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
840 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
841 h_brush
= CreateSolidBrush (face
->foreground
);
842 h_orig_brush
= SelectObject (hdc
, h_brush
);
844 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
845 compat_hdc
, 0, p
->dh
,
847 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
848 compat_hdc
, 0, p
->dh
,
850 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
851 compat_hdc
, 0, p
->dh
,
854 SelectObject (hdc
, h_orig_brush
);
855 DeleteObject (h_brush
);
859 SetTextColor (hdc
, face
->background
);
860 SetBkColor (hdc
, (p
->cursor_p
861 ? f
->output_data
.w32
->cursor_pixel
862 : face
->foreground
));
864 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
865 compat_hdc
, 0, p
->dh
,
869 SelectObject (compat_hdc
, horig_obj
);
870 DeleteDC (compat_hdc
);
874 w32_set_clip_rectangle (hdc
, NULL
);
876 release_frame_dc (f
, hdc
);
880 w32_define_fringe_bitmap (which
, bits
, h
, wd
)
882 unsigned short *bits
;
885 if (which
>= max_fringe_bmp
)
887 int i
= max_fringe_bmp
;
888 max_fringe_bmp
= which
+ 20;
889 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
890 while (i
< max_fringe_bmp
)
894 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
898 w32_destroy_fringe_bitmap (which
)
901 if (which
>= max_fringe_bmp
)
904 if (fringe_bmp
[which
])
905 DeleteObject (fringe_bmp
[which
]);
906 fringe_bmp
[which
] = 0;
911 /* This is called when starting Emacs and when restarting after
912 suspend. When starting Emacs, no window is mapped. And nothing
913 must be done to Emacs's own window if it is suspended (though that
917 w32_set_terminal_modes (struct terminal
*term
)
921 /* This is called when exiting or suspending Emacs. Exiting will make
922 the W32 windows go away, and suspending requires no action. */
925 w32_reset_terminal_modes (struct terminal
*term
)
931 /***********************************************************************
933 ***********************************************************************/
935 /* Function prototypes of this page. */
937 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
938 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
939 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
941 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
942 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
943 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
944 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
945 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
946 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
947 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
948 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
949 static void w32_setup_relief_color
P_ ((struct frame
*, struct relief
*,
950 double, int, COLORREF
));
951 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
952 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
953 static void x_draw_image_relief
P_ ((struct glyph_string
*));
954 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
955 static void w32_draw_image_foreground_1
P_ ((struct glyph_string
*, HBITMAP
));
956 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
958 static void w32_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
959 int, int, int, int, int, int,
961 static void w32_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
962 int, int, int, RECT
*));
965 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
970 struct glyph_string
*s
;
972 if (s
->font
== FRAME_FONT (s
->f
)
973 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
974 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
976 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
979 /* Cursor on non-default face: must merge. */
983 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
984 xgcv
.foreground
= s
->face
->background
;
986 /* If the glyph would be invisible, try a different foreground. */
987 if (xgcv
.foreground
== xgcv
.background
)
988 xgcv
.foreground
= s
->face
->foreground
;
989 if (xgcv
.foreground
== xgcv
.background
)
990 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
991 if (xgcv
.foreground
== xgcv
.background
)
992 xgcv
.foreground
= s
->face
->foreground
;
994 /* Make sure the cursor is distinct from text in this face. */
995 if (xgcv
.background
== s
->face
->background
996 && xgcv
.foreground
== s
->face
->foreground
)
998 xgcv
.background
= s
->face
->foreground
;
999 xgcv
.foreground
= s
->face
->background
;
1002 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1003 xgcv
.font
= s
->font
;
1004 mask
= GCForeground
| GCBackground
| GCFont
;
1006 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1007 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1010 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1011 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1013 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1018 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1021 x_set_mouse_face_gc (s
)
1022 struct glyph_string
*s
;
1027 /* What face has to be used last for the mouse face? */
1028 face_id
= FRAME_W32_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1029 face
= FACE_FROM_ID (s
->f
, face_id
);
1031 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1033 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1034 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1036 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1037 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1038 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1040 /* If font in this face is same as S->font, use it. */
1041 if (s
->font
== s
->face
->font
)
1042 s
->gc
= s
->face
->gc
;
1045 /* Otherwise construct scratch_cursor_gc with values from FACE
1050 xgcv
.background
= s
->face
->background
;
1051 xgcv
.foreground
= s
->face
->foreground
;
1052 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1053 xgcv
.font
= s
->font
;
1054 mask
= GCForeground
| GCBackground
| GCFont
;
1056 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1057 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1060 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1061 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1063 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1066 xassert (s
->gc
!= 0);
1070 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1071 Faces to use in the mode line have already been computed when the
1072 matrix was built, so there isn't much to do, here. */
1075 x_set_mode_line_face_gc (s
)
1076 struct glyph_string
*s
;
1078 s
->gc
= s
->face
->gc
;
1082 /* Set S->gc of glyph string S for drawing that glyph string. Set
1083 S->stippled_p to a non-zero value if the face of S has a stipple
1087 x_set_glyph_string_gc (s
)
1088 struct glyph_string
*s
;
1090 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1092 if (s
->hl
== DRAW_NORMAL_TEXT
)
1094 s
->gc
= s
->face
->gc
;
1095 s
->stippled_p
= s
->face
->stipple
!= 0;
1097 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1099 x_set_mode_line_face_gc (s
);
1100 s
->stippled_p
= s
->face
->stipple
!= 0;
1102 else if (s
->hl
== DRAW_CURSOR
)
1104 x_set_cursor_gc (s
);
1107 else if (s
->hl
== DRAW_MOUSE_FACE
)
1109 x_set_mouse_face_gc (s
);
1110 s
->stippled_p
= s
->face
->stipple
!= 0;
1112 else if (s
->hl
== DRAW_IMAGE_RAISED
1113 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1115 s
->gc
= s
->face
->gc
;
1116 s
->stippled_p
= s
->face
->stipple
!= 0;
1120 s
->gc
= s
->face
->gc
;
1121 s
->stippled_p
= s
->face
->stipple
!= 0;
1124 /* GC must have been set. */
1125 xassert (s
->gc
!= 0);
1129 /* Set clipping for output of glyph string S. S may be part of a mode
1130 line or menu if we don't have X toolkit support. */
1133 x_set_glyph_string_clipping (s
)
1134 struct glyph_string
*s
;
1137 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1140 w32_set_clip_rectangle (s
->hdc
, r
);
1143 HRGN full_clip
, clip1
, clip2
;
1144 clip1
= CreateRectRgnIndirect (r
);
1145 clip2
= CreateRectRgnIndirect (r
+ 1);
1146 if (CombineRgn (full_clip
, clip1
, clip2
, RGN_OR
) != ERROR
)
1148 SelectClipRgn (s
->hdc
, full_clip
);
1150 DeleteObject (clip1
);
1151 DeleteObject (clip2
);
1152 DeleteObject (full_clip
);
1157 /* Set SRC's clipping for output of glyph string DST. This is called
1158 when we are drawing DST's left_overhang or right_overhang only in
1162 x_set_glyph_string_clipping_exactly (src
, dst
)
1163 struct glyph_string
*src
, *dst
;
1168 r
.right
= r
.left
+ src
->width
;
1170 r
.bottom
= r
.top
+ src
->height
;
1173 w32_set_clip_rectangle (dst
->hdc
, &r
);
1177 Compute left and right overhang of glyph string S. */
1180 w32_compute_glyph_string_overhangs (s
)
1181 struct glyph_string
*s
;
1184 && s
->first_glyph
->type
== CHAR_GLYPH
1185 && !s
->font_not_found_p
)
1187 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1188 struct font
*font
= s
->font
;
1189 struct font_metrics metrics
;
1192 for (i
= 0; i
< s
->nchars
; i
++)
1193 code
[i
] = s
->char2b
[i
];
1194 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1195 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1196 ? metrics
.rbearing
- metrics
.width
: 0);
1197 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1201 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1202 s
->left_overhang
= -s
->cmp
->lbearing
;
1206 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1209 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1210 struct glyph_string
*s
;
1218 /* Take clipping into account. */
1219 if (s
->gc
->clip_mask
== Rect
)
1221 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1222 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1223 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1224 - s
->gc
->clip_rectangle
.left
);
1225 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1226 - s
->gc
->clip_rectangle
.top
);
1229 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1234 /* Draw the background of glyph_string S. If S->background_filled_p
1235 is non-zero don't draw it. FORCE_P non-zero means draw the
1236 background even if it wouldn't be drawn normally. This is used
1237 when a string preceding S draws into the background of S, or S
1238 contains the first component of a composition. */
1241 x_draw_glyph_string_background (s
, force_p
)
1242 struct glyph_string
*s
;
1245 /* Nothing to do if background has already been drawn or if it
1246 shouldn't be drawn in the first place. */
1247 if (!s
->background_filled_p
)
1249 int box_line_width
= max (s
->face
->box_line_width
, 0);
1251 #if 0 /* TODO: stipple */
1254 /* Fill background with a stipple pattern. */
1255 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1256 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1257 s
->y
+ box_line_width
,
1258 s
->background_width
,
1259 s
->height
- 2 * box_line_width
);
1260 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1261 s
->background_filled_p
= 1;
1265 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1266 || s
->font_not_found_p
1267 || s
->extends_to_end_of_line_p
1270 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1271 s
->background_width
,
1272 s
->height
- 2 * box_line_width
);
1273 s
->background_filled_p
= 1;
1279 /* Draw the foreground of glyph string S. */
1282 x_draw_glyph_string_foreground (s
)
1283 struct glyph_string
*s
;
1287 /* If first glyph of S has a left box line, start drawing the text
1288 of S to the right of that box line. */
1289 if (s
->face
->box
!= FACE_NO_BOX
1290 && s
->first_glyph
->left_box_line_p
)
1291 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1295 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1296 SetBkColor (s
->hdc
, s
->gc
->background
);
1297 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1299 /* Draw characters of S as rectangles if S's font could not be
1301 if (s
->font_not_found_p
)
1303 for (i
= 0; i
< s
->nchars
; ++i
)
1305 struct glyph
*g
= s
->first_glyph
+ i
;
1307 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1309 x
+= g
->pixel_width
;
1314 struct font
*font
= s
->font
;
1315 int boff
= font
->baseline_offset
;
1319 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1321 if (font
->vertical_centering
)
1322 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1324 y
= s
->ybase
- boff
;
1326 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1327 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1329 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1330 if (s
->face
->overstrike
)
1331 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1333 SelectObject (s
->hdc
, old_font
);
1337 /* Draw the foreground of composite glyph string S. */
1340 x_draw_composite_glyph_string_foreground (s
)
1341 struct glyph_string
*s
;
1345 /* If first glyph of S has a left box line, start drawing the text
1346 of S to the right of that box line. */
1347 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1348 && s
->first_glyph
->left_box_line_p
)
1349 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1353 /* S is a glyph string for a composition. S->gidx is the index of
1354 the first character drawn for glyphs of this composition.
1355 S->gidx == 0 means we are drawing the very first character of
1356 this composition. */
1358 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1359 SetBkColor (s
->hdc
, s
->gc
->background
);
1360 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1362 /* Draw a rectangle for the composition if the font for the very
1363 first character of the composition could not be loaded. */
1364 if (s
->font_not_found_p
)
1367 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1372 struct font
*font
= s
->font
;
1377 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1379 if (s
->cmp
->method
== COMPOSITION_WITH_GLYPH_STRING
)
1381 Lisp_Object gstring
= AREF (XHASH_TABLE (composition_hash_table
)
1383 s
->cmp
->hash_index
* 2);
1386 for (i
= from
= 0; i
< s
->nchars
; i
++)
1388 Lisp_Object g
= LGSTRING_GLYPH (gstring
, i
);
1389 Lisp_Object adjustment
= LGLYPH_ADJUSTMENT (g
);
1390 int xoff
, yoff
, wadjust
;
1392 if (! VECTORP (adjustment
))
1394 width
+= LGLYPH_WIDTH (g
);
1399 font
->driver
->draw (s
, from
, i
, x
, y
, 0);
1402 xoff
= XINT (AREF (adjustment
, 0));
1403 yoff
= XINT (AREF (adjustment
, 1));
1404 wadjust
= XINT (AREF (adjustment
, 2));
1406 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1412 font
->driver
->draw (s
, from
, i
, x
, y
, 0);
1416 for (i
= 0, j
= s
->gidx
; i
< s
->nchars
; i
++, j
++)
1417 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1419 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1420 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1422 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1423 if (s
->face
->overstrike
)
1424 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1427 SelectObject (s
->hdc
, old_font
);
1432 /* Brightness beyond which a color won't have its highlight brightness
1435 Nominally, highlight colors for `3d' faces are calculated by
1436 brightening an object's color by a constant scale factor, but this
1437 doesn't yield good results for dark colors, so for colors who's
1438 brightness is less than this value (on a scale of 0-255) have to
1439 use an additional additive factor.
1441 The value here is set so that the default menu-bar/mode-line color
1442 (grey75) will not have its highlights changed at all. */
1443 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1446 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1447 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1448 If this produces the same color as COLOR, try a color where all RGB
1449 values have DELTA added. Return the allocated color in *COLOR.
1450 DISPLAY is the X display, CMAP is the colormap to operate on.
1451 Value is non-zero if successful. */
1454 w32_alloc_lighter_color (f
, color
, factor
, delta
)
1463 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1466 /* Change RGB values by specified FACTOR. Avoid overflow! */
1467 xassert (factor
>= 0);
1468 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1469 min (0xff, factor
* GetGValue (*color
)),
1470 min (0xff, factor
* GetBValue (*color
)));
1472 /* Calculate brightness of COLOR. */
1473 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1474 + GetBValue (*color
)) / 6;
1476 /* We only boost colors that are darker than
1477 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1478 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1479 /* Make an additive adjustment to NEW, because it's dark enough so
1480 that scaling by FACTOR alone isn't enough. */
1482 /* How far below the limit this color is (0 - 1, 1 being darker). */
1483 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1484 /* The additive adjustment. */
1485 int min_delta
= delta
* dimness
* factor
/ 2;
1488 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1489 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1490 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1492 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1493 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1494 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1498 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1499 max (0, min (0xff, delta
+ GetGValue (*color
))),
1500 max (0, min (0xff, delta
+ GetBValue (*color
))));
1502 /* TODO: Map to palette and retry with delta if same? */
1503 /* TODO: Free colors (if using palette)? */
1514 /* Set up the foreground color for drawing relief lines of glyph
1515 string S. RELIEF is a pointer to a struct relief containing the GC
1516 with which lines will be drawn. Use a color that is FACTOR or
1517 DELTA lighter or darker than the relief's background which is found
1518 in S->f->output_data.x->relief_background. If such a color cannot
1519 be allocated, use DEFAULT_PIXEL, instead. */
1522 w32_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
1524 struct relief
*relief
;
1527 COLORREF default_pixel
;
1530 struct w32_output
*di
= f
->output_data
.w32
;
1531 unsigned long mask
= GCForeground
;
1533 COLORREF background
= di
->relief_background
;
1534 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
1536 /* TODO: Free colors (if using palette)? */
1538 /* Allocate new color. */
1539 xgcv
.foreground
= default_pixel
;
1541 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1543 relief
->allocated_p
= 1;
1544 xgcv
.foreground
= relief
->pixel
= pixel
;
1547 if (relief
->gc
== 0)
1549 #if 0 /* TODO: stipple */
1550 xgcv
.stipple
= dpyinfo
->gray
;
1553 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1556 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1560 /* Set up colors for the relief lines around glyph string S. */
1563 x_setup_relief_colors (s
)
1564 struct glyph_string
*s
;
1566 struct w32_output
*di
= s
->f
->output_data
.w32
;
1569 if (s
->face
->use_box_color_for_shadows_p
)
1570 color
= s
->face
->box_color
;
1571 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1573 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1574 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1576 color
= s
->gc
->background
;
1578 if (di
->white_relief
.gc
== 0
1579 || color
!= di
->relief_background
)
1581 di
->relief_background
= color
;
1582 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1583 WHITE_PIX_DEFAULT (s
->f
));
1584 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1585 BLACK_PIX_DEFAULT (s
->f
));
1590 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1591 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1592 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1593 relief. LEFT_P non-zero means draw a relief on the left side of
1594 the rectangle. RIGHT_P non-zero means draw a relief on the right
1595 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1599 w32_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
1600 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
1602 int left_x
, top_y
, right_x
, bottom_y
, width
;
1603 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
1608 HDC hdc
= get_frame_dc (f
);
1611 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1613 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1615 w32_set_clip_rectangle (hdc
, clip_rect
);
1619 for (i
= 0; i
< width
; ++i
)
1620 w32_fill_area (f
, hdc
, gc
.foreground
,
1621 left_x
+ i
* left_p
, top_y
+ i
,
1622 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1626 for (i
= 0; i
< width
; ++i
)
1627 w32_fill_area (f
, hdc
, gc
.foreground
,
1628 left_x
+ i
, top_y
+ i
, 1,
1629 bottom_y
- top_y
- 2 * i
+ 1);
1632 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1634 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1638 for (i
= 0; i
< width
; ++i
)
1639 w32_fill_area (f
, hdc
, gc
.foreground
,
1640 left_x
+ i
* left_p
, bottom_y
- i
,
1641 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1645 for (i
= 0; i
< width
; ++i
)
1646 w32_fill_area (f
, hdc
, gc
.foreground
,
1647 right_x
- i
, top_y
+ i
+ 1, 1,
1648 bottom_y
- top_y
- 2 * i
- 1);
1650 w32_set_clip_rectangle (hdc
, NULL
);
1652 release_frame_dc (f
, hdc
);
1656 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1657 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1658 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1659 left side of the rectangle. RIGHT_P non-zero means draw a line
1660 on the right side of the rectangle. CLIP_RECT is the clipping
1661 rectangle to use when drawing. */
1664 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1665 left_p
, right_p
, clip_rect
)
1666 struct glyph_string
*s
;
1667 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
1670 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1673 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1674 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1679 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1680 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1684 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1685 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1690 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1691 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1694 w32_set_clip_rectangle (s
->hdc
, NULL
);
1698 /* Draw a box around glyph string S. */
1701 x_draw_glyph_string_box (s
)
1702 struct glyph_string
*s
;
1704 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
1705 int left_p
, right_p
;
1706 struct glyph
*last_glyph
;
1709 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1710 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1711 : window_box_right (s
->w
, s
->area
));
1713 /* The glyph that may have a right box line. */
1714 last_glyph
= (s
->cmp
|| s
->img
1716 : s
->first_glyph
+ s
->nchars
- 1);
1718 width
= eabs (s
->face
->box_line_width
);
1719 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1721 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1723 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1725 bottom_y
= top_y
+ s
->height
- 1;
1727 left_p
= (s
->first_glyph
->left_box_line_p
1728 || (s
->hl
== DRAW_MOUSE_FACE
1730 || s
->prev
->hl
!= s
->hl
)));
1731 right_p
= (last_glyph
->right_box_line_p
1732 || (s
->hl
== DRAW_MOUSE_FACE
1734 || s
->next
->hl
!= s
->hl
)));
1736 get_glyph_string_clip_rect (s
, &clip_rect
);
1738 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1739 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1740 left_p
, right_p
, &clip_rect
);
1743 x_setup_relief_colors (s
);
1744 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1745 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1750 /* Draw foreground of image glyph string S. */
1753 x_draw_image_foreground (s
)
1754 struct glyph_string
*s
;
1757 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1759 /* If first glyph of S has a left box line, start drawing it to the
1760 right of that line. */
1761 if (s
->face
->box
!= FACE_NO_BOX
1762 && s
->first_glyph
->left_box_line_p
1764 x
+= eabs (s
->face
->box_line_width
);
1766 /* If there is a margin around the image, adjust x- and y-position
1768 if (s
->slice
.x
== 0)
1769 x
+= s
->img
->hmargin
;
1770 if (s
->slice
.y
== 0)
1771 y
+= s
->img
->vmargin
;
1777 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
1778 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1779 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
1780 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1781 SetBkColor (compat_hdc
, RGB (255, 255, 255));
1782 SetTextColor (s
->hdc
, RGB (0, 0, 0));
1783 x_set_glyph_string_clipping (s
);
1787 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
1788 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1790 SetTextColor (s
->hdc
, RGB (255, 255, 255));
1791 SetBkColor (s
->hdc
, RGB (0, 0, 0));
1793 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1794 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1795 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1796 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1797 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1798 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1800 SelectObject (mask_dc
, mask_orig_obj
);
1805 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1806 SetBkColor (s
->hdc
, s
->gc
->background
);
1808 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1809 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1811 /* When the image has a mask, we can expect that at
1812 least part of a mouse highlight or a block cursor will
1813 be visible. If the image doesn't have a mask, make
1814 a block cursor visible by drawing a rectangle around
1815 the image. I believe it's looking better if we do
1816 nothing here for mouse-face. */
1817 if (s
->hl
== DRAW_CURSOR
)
1819 int r
= s
->img
->relief
;
1821 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
1822 s
->slice
.width
+ r
*2 - 1,
1823 s
->slice
.height
+ r
*2 - 1);
1827 w32_set_clip_rectangle (s
->hdc
, NULL
);
1828 SelectObject (s
->hdc
, orig_brush
);
1829 DeleteObject (fg_brush
);
1830 SelectObject (compat_hdc
, orig_obj
);
1831 DeleteDC (compat_hdc
);
1834 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
1835 s
->slice
.width
- 1, s
->slice
.height
- 1);
1837 RestoreDC (s
->hdc
,-1);
1841 /* Draw a relief around the image glyph string S. */
1844 x_draw_image_relief (s
)
1845 struct glyph_string
*s
;
1847 int x0
, y0
, x1
, y1
, thick
, raised_p
;
1850 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1852 /* If first glyph of S has a left box line, start drawing it to the
1853 right of that line. */
1854 if (s
->face
->box
!= FACE_NO_BOX
1855 && s
->first_glyph
->left_box_line_p
1857 x
+= eabs (s
->face
->box_line_width
);
1859 /* If there is a margin around the image, adjust x- and y-position
1861 if (s
->slice
.x
== 0)
1862 x
+= s
->img
->hmargin
;
1863 if (s
->slice
.y
== 0)
1864 y
+= s
->img
->vmargin
;
1866 if (s
->hl
== DRAW_IMAGE_SUNKEN
1867 || s
->hl
== DRAW_IMAGE_RAISED
)
1869 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
1870 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
1874 thick
= eabs (s
->img
->relief
);
1875 raised_p
= s
->img
->relief
> 0;
1880 x1
= x
+ s
->slice
.width
+ thick
- 1;
1881 y1
= y
+ s
->slice
.height
+ thick
- 1;
1883 x_setup_relief_colors (s
);
1884 get_glyph_string_clip_rect (s
, &r
);
1885 w32_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
1887 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
1889 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
1894 /* Draw the foreground of image glyph string S to PIXMAP. */
1897 w32_draw_image_foreground_1 (s
, pixmap
)
1898 struct glyph_string
*s
;
1901 HDC hdc
= CreateCompatibleDC (s
->hdc
);
1902 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
1904 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1906 /* If first glyph of S has a left box line, start drawing it to the
1907 right of that line. */
1908 if (s
->face
->box
!= FACE_NO_BOX
1909 && s
->first_glyph
->left_box_line_p
1911 x
+= eabs (s
->face
->box_line_width
);
1913 /* If there is a margin around the image, adjust x- and y-position
1915 if (s
->slice
.x
== 0)
1916 x
+= s
->img
->hmargin
;
1917 if (s
->slice
.y
== 0)
1918 y
+= s
->img
->vmargin
;
1922 HDC compat_hdc
= CreateCompatibleDC (hdc
);
1923 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1924 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
1925 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1929 HDC mask_dc
= CreateCompatibleDC (hdc
);
1930 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1932 SetTextColor (hdc
, RGB (0, 0, 0));
1933 SetBkColor (hdc
, RGB (255, 255, 255));
1934 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1935 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1936 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1937 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1938 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1939 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1941 SelectObject (mask_dc
, mask_orig_obj
);
1946 SetTextColor (hdc
, s
->gc
->foreground
);
1947 SetBkColor (hdc
, s
->gc
->background
);
1949 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1950 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1952 /* When the image has a mask, we can expect that at
1953 least part of a mouse highlight or a block cursor will
1954 be visible. If the image doesn't have a mask, make
1955 a block cursor visible by drawing a rectangle around
1956 the image. I believe it's looking better if we do
1957 nothing here for mouse-face. */
1958 if (s
->hl
== DRAW_CURSOR
)
1960 int r
= s
->img
->relief
;
1962 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
1963 s
->slice
.width
+ r
*2 - 1,
1964 s
->slice
.height
+ r
*2 - 1);
1968 SelectObject (hdc
, orig_brush
);
1969 DeleteObject (fg_brush
);
1970 SelectObject (compat_hdc
, orig_obj
);
1971 DeleteDC (compat_hdc
);
1974 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
1975 s
->slice
.width
- 1, s
->slice
.height
- 1);
1977 SelectObject (hdc
, orig_hdc_obj
);
1982 /* Draw part of the background of glyph string S. X, Y, W, and H
1983 give the rectangle to draw. */
1986 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
1987 struct glyph_string
*s
;
1990 #if 0 /* TODO: stipple */
1993 /* Fill background with a stipple pattern. */
1994 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1995 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1996 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2000 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2004 /* Draw image glyph string S.
2007 s->x +-------------------------
2010 | +-------------------------
2013 | | +-------------------
2019 x_draw_image_glyph_string (s
)
2020 struct glyph_string
*s
;
2023 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2024 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2028 height
= s
->height
- 2 * box_line_vwidth
;
2030 /* Fill background with face under the image. Do it only if row is
2031 taller than image or if image has a clip mask to reduce
2033 s
->stippled_p
= s
->face
->stipple
!= 0;
2034 if (height
> s
->slice
.height
2038 || s
->img
->pixmap
== 0
2039 || s
->width
!= s
->background_width
)
2042 if (s
->first_glyph
->left_box_line_p
2044 x
+= box_line_hwidth
;
2047 if (s
->slice
.y
== 0)
2048 y
+= box_line_vwidth
;
2050 #if 0 /* TODO: figure out if we need to do this on Windows. */
2053 /* Create a pixmap as large as the glyph string. Fill it
2054 with the background color. Copy the image to it, using
2055 its mask. Copy the temporary pixmap to the display. */
2056 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2057 int depth
= DefaultDepthOfScreen (screen
);
2059 /* Create a pixmap as large as the glyph string. */
2060 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2061 s
->background_width
,
2064 /* Don't clip in the following because we're working on the
2066 XSetClipMask (s
->display
, s
->gc
, None
);
2068 /* Fill the pixmap with the background color/stipple. */
2071 /* Fill background with a stipple pattern. */
2072 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2073 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2074 0, 0, s
->background_width
, s
->height
);
2075 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2080 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2082 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2083 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2084 0, 0, s
->background_width
, s
->height
);
2085 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2090 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2092 s
->background_filled_p
= 1;
2095 /* Draw the foreground. */
2098 w32_draw_image_foreground_1 (s
, pixmap
);
2099 x_set_glyph_string_clipping (s
);
2101 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2102 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2103 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2104 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2106 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2107 SetBkColor (s
->hdc
, s
->gc
->background
);
2108 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2109 compat_hdc
, 0, 0, SRCCOPY
);
2111 SelectObject (s
->hdc
, orig_brush
);
2112 DeleteObject (fg_brush
);
2113 SelectObject (compat_hdc
, orig_obj
);
2114 DeleteDC (compat_hdc
);
2116 DeleteObject (pixmap
);
2120 x_draw_image_foreground (s
);
2122 /* If we must draw a relief around the image, do it. */
2124 || s
->hl
== DRAW_IMAGE_RAISED
2125 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2126 x_draw_image_relief (s
);
2130 /* Draw stretch glyph string S. */
2133 x_draw_stretch_glyph_string (s
)
2134 struct glyph_string
*s
;
2136 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2138 if (s
->hl
== DRAW_CURSOR
2139 && !x_stretch_cursor_p
)
2141 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2142 as wide as the stretch glyph. */
2143 int width
, background_width
= s
->background_width
;
2144 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2148 background_width
-= left_x
- x
;
2151 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2154 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2156 /* Clear rest using the GC of the original non-cursor face. */
2157 if (width
< background_width
)
2159 XGCValues
*gc
= s
->face
->gc
;
2161 int w
= background_width
- width
, h
= s
->height
;
2166 if (s
->row
->mouse_face_p
2167 && cursor_in_mouse_face_p (s
->w
))
2169 x_set_mouse_face_gc (s
);
2175 get_glyph_string_clip_rect (s
, &r
);
2176 w32_set_clip_rectangle (hdc
, &r
);
2178 #if 0 /* TODO: stipple */
2179 if (s
->face
->stipple
)
2181 /* Fill background with a stipple pattern. */
2182 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2183 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2184 XSetFillStyle (s
->display
, gc
, FillSolid
);
2189 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2193 else if (!s
->background_filled_p
)
2195 int background_width
= s
->background_width
;
2196 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2198 /* Don't draw into left margin, fringe or scrollbar area
2199 except for header line and mode line. */
2200 if (x
< left_x
&& !s
->row
->mode_line_p
)
2202 background_width
-= left_x
- x
;
2205 if (background_width
> 0)
2206 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2209 s
->background_filled_p
= 1;
2213 /* Draw glyph string S. */
2216 x_draw_glyph_string (s
)
2217 struct glyph_string
*s
;
2219 int relief_drawn_p
= 0;
2221 /* If S draws into the background of its successor, draw the
2222 background of the successor first so that S can draw into it.
2223 This makes S->next use XDrawString instead of XDrawImageString. */
2224 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2227 struct glyph_string
*next
;
2228 for (width
= 0, next
= s
->next
; next
;
2229 width
+= next
->width
, next
= next
->next
)
2230 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2232 x_set_glyph_string_gc (next
);
2233 x_set_glyph_string_clipping (next
);
2234 x_draw_glyph_string_background (next
, 1);
2235 next
->num_clips
= 0;
2239 /* Set up S->gc, set clipping and draw S. */
2240 x_set_glyph_string_gc (s
);
2242 /* Draw relief (if any) in advance for char/composition so that the
2243 glyph string can be drawn over it. */
2244 if (!s
->for_overlaps
2245 && s
->face
->box
!= FACE_NO_BOX
2246 && (s
->first_glyph
->type
== CHAR_GLYPH
2247 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2250 x_set_glyph_string_clipping (s
);
2251 x_draw_glyph_string_background (s
, 1);
2252 x_draw_glyph_string_box (s
);
2253 x_set_glyph_string_clipping (s
);
2256 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2258 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2259 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2260 /* We must clip just this glyph. left_overhang part has already
2261 drawn when s->prev was drawn, and right_overhang part will be
2262 drawn later when s->next is drawn. */
2263 x_set_glyph_string_clipping_exactly (s
, s
);
2265 x_set_glyph_string_clipping (s
);
2267 switch (s
->first_glyph
->type
)
2270 x_draw_image_glyph_string (s
);
2274 x_draw_stretch_glyph_string (s
);
2278 if (s
->for_overlaps
)
2279 s
->background_filled_p
= 1;
2281 x_draw_glyph_string_background (s
, 0);
2282 x_draw_glyph_string_foreground (s
);
2285 case COMPOSITE_GLYPH
:
2286 if (s
->for_overlaps
|| s
->gidx
> 0)
2287 s
->background_filled_p
= 1;
2289 x_draw_glyph_string_background (s
, 1);
2290 x_draw_composite_glyph_string_foreground (s
);
2297 if (!s
->for_overlaps
)
2299 /* Draw underline. */
2300 if (s
->face
->underline_p
)
2302 unsigned long thickness
, position
;
2305 if (s
->prev
&& s
->prev
->face
->underline_p
)
2307 /* We use the same underline style as the previous one. */
2308 thickness
= s
->prev
->underline_thickness
;
2309 position
= s
->prev
->underline_position
;
2313 /* Get the underline thickness. Default is 1 pixel. */
2314 if (s
->font
&& s
->font
->underline_thickness
> 0)
2315 thickness
= s
->font
->underline_thickness
;
2318 if (x_underline_at_descent_line
)
2319 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2322 /* Get the underline position. This is the recommended
2323 vertical offset in pixels from the baseline to the top of
2324 the underline. This is a signed value according to the
2325 specs, and its default is
2327 ROUND ((maximum_descent) / 2), with
2328 ROUND (x) = floor (x + 0.5) */
2330 if (x_use_underline_position_properties
2331 && s
->font
&& s
->font
->underline_position
>= 0)
2332 position
= s
->font
->underline_position
;
2334 position
= (s
->font
->descent
+ 1) / 2;
2336 position
= max (position
, underline_minimum_offset
);
2338 /* Check the sanity of thickness and position. We should
2339 avoid drawing underline out of the current line area. */
2340 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2341 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2342 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2343 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2344 s
->underline_thickness
= thickness
;
2345 s
->underline_position
=position
;
2346 y
= s
->ybase
+ position
;
2347 if (s
->face
->underline_defaulted_p
)
2349 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2350 y
, s
->background_width
, 1);
2354 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2355 y
, s
->background_width
, 1);
2358 /* Draw overline. */
2359 if (s
->face
->overline_p
)
2361 unsigned long dy
= 0, h
= 1;
2363 if (s
->face
->overline_color_defaulted_p
)
2365 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2366 s
->y
+ dy
, s
->background_width
, h
);
2370 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2371 s
->y
+ dy
, s
->background_width
, h
);
2375 /* Draw strike-through. */
2376 if (s
->face
->strike_through_p
2377 && !FONT_TEXTMETRIC(s
->font
).tmStruckOut
)
2379 unsigned long h
= 1;
2380 unsigned long dy
= (s
->height
- h
) / 2;
2382 if (s
->face
->strike_through_color_defaulted_p
)
2384 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2389 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2390 s
->y
+ dy
, s
->width
, h
);
2394 /* Draw relief if not yet drawn. */
2395 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2396 x_draw_glyph_string_box (s
);
2400 struct glyph_string
*prev
;
2402 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2403 if (prev
->hl
!= s
->hl
2404 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2406 /* As prev was drawn while clipped to its own area, we
2407 must draw the right_overhang part using s->hl now. */
2408 enum draw_glyphs_face save
= prev
->hl
;
2411 x_set_glyph_string_gc (prev
);
2412 x_set_glyph_string_clipping_exactly (s
, prev
);
2413 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2414 x_draw_glyph_string_foreground (prev
);
2416 x_draw_composite_glyph_string_foreground (prev
);
2417 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2419 prev
->num_clips
= 0;
2425 struct glyph_string
*next
;
2427 for (next
= s
->next
; next
; next
= next
->next
)
2428 if (next
->hl
!= s
->hl
2429 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2431 /* As next will be drawn while clipped to its own area,
2432 we must draw the left_overhang part using s->hl now. */
2433 enum draw_glyphs_face save
= next
->hl
;
2436 x_set_glyph_string_gc (next
);
2437 x_set_glyph_string_clipping_exactly (s
, next
);
2438 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2439 x_draw_glyph_string_foreground (next
);
2441 x_draw_composite_glyph_string_foreground (next
);
2442 w32_set_clip_rectangle (next
->hdc
, NULL
);
2444 next
->num_clips
= 0;
2449 /* Reset clipping. */
2450 w32_set_clip_rectangle (s
->hdc
, NULL
);
2455 /* Shift display to make room for inserted glyphs. */
2458 w32_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
2460 int x
, y
, width
, height
, shift_by
;
2464 hdc
= get_frame_dc (f
);
2465 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2466 hdc
, x
, y
, SRCCOPY
);
2468 release_frame_dc (f
, hdc
);
2472 /* Delete N glyphs at the nominal cursor position. Not implemented
2476 x_delete_glyphs (f
, n
)
2480 if (! FRAME_W32_P (f
))
2487 /* Clear entire frame. If updating_frame is non-null, clear that
2488 frame. Otherwise clear the selected frame. */
2491 x_clear_frame (struct frame
*f
)
2493 if (! FRAME_W32_P (f
))
2496 /* Clearing the frame will erase any cursor, so mark them all as no
2498 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2499 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2500 output_cursor
.x
= -1;
2502 /* We don't set the output cursor here because there will always
2503 follow an explicit cursor_to. */
2506 w32_clear_window (f
);
2508 /* We have to clear the scroll bars, too. If we have changed
2509 colors or something like that, then they should be notified. */
2510 x_scroll_bar_clear (f
);
2516 /* Make audible bell. */
2519 w32_ring_bell (struct frame
*f
)
2523 if (FRAME_W32_P (f
) && visible_bell
)
2526 HWND hwnd
= FRAME_W32_WINDOW (f
);
2528 for (i
= 0; i
< 5; i
++)
2530 FlashWindow (hwnd
, TRUE
);
2533 FlashWindow (hwnd
, FALSE
);
2536 w32_sys_ring_bell (f
);
2542 /* Specify how many text lines, from the top of the window,
2543 should be affected by insert-lines and delete-lines operations.
2544 This, and those operations, are used only within an update
2545 that is bounded by calls to x_update_begin and x_update_end. */
2548 w32_set_terminal_window (n
)
2551 /* This function intentionally left blank. */
2555 /***********************************************************************
2557 ***********************************************************************/
2559 /* Perform an insert-lines or delete-lines operation, inserting N
2560 lines or deleting -N lines at vertical position VPOS. */
2563 x_ins_del_lines (f
, vpos
, n
)
2567 if (! FRAME_W32_P (f
))
2574 /* Scroll part of the display as described by RUN. */
2577 x_scroll_run (w
, run
)
2581 struct frame
*f
= XFRAME (w
->frame
);
2582 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2583 HWND hwnd
= FRAME_W32_WINDOW (f
);
2586 /* Get frame-relative bounding box of the text display area of W,
2587 without mode lines. Include in this box the left and right
2589 window_box (w
, -1, &x
, &y
, &width
, &height
);
2591 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2592 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2593 bottom_y
= y
+ height
;
2597 /* Scrolling up. Make sure we don't copy part of the mode
2598 line at the bottom. */
2599 if (from_y
+ run
->height
> bottom_y
)
2600 height
= bottom_y
- from_y
;
2602 height
= run
->height
;
2603 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2607 /* Scolling down. Make sure we don't copy over the mode line.
2609 if (to_y
+ run
->height
> bottom_y
)
2610 height
= bottom_y
- to_y
;
2612 height
= run
->height
;
2613 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2618 /* Cursor off. Will be switched on again in x_update_window_end. */
2625 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2626 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2628 from
.left
= to
.left
= x
;
2629 from
.right
= to
.right
= x
+ width
;
2631 from
.bottom
= from_y
+ height
;
2633 to
.bottom
= bottom_y
;
2635 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2636 NULL
, SW_INVALIDATE
);
2638 /* Combine this with what we expect to be dirty. This covers the
2639 case where not all of the region we expect is actually dirty. */
2640 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2642 /* If the dirty region is not what we expected, redraw the entire frame. */
2643 if (!EqualRgn (combined
, expect_dirty
))
2644 SET_FRAME_GARBAGED (f
);
2646 DeleteObject (dirty
);
2647 DeleteObject (combined
);
2651 DeleteObject (expect_dirty
);
2656 /***********************************************************************
2658 ***********************************************************************/
2664 x_update_cursor (f
, 1);
2665 x_set_frame_alpha (f
);
2669 frame_unhighlight (f
)
2672 x_update_cursor (f
, 1);
2673 x_set_frame_alpha (f
);
2676 /* The focus has changed. Update the frames as necessary to reflect
2677 the new situation. Note that we can't change the selected frame
2678 here, because the Lisp code we are interrupting might become confused.
2679 Each event gets marked with the frame in which it occurred, so the
2680 Lisp code can tell when the switch took place by examining the events. */
2683 x_new_focus_frame (dpyinfo
, frame
)
2684 struct w32_display_info
*dpyinfo
;
2685 struct frame
*frame
;
2687 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2689 if (frame
!= dpyinfo
->w32_focus_frame
)
2691 /* Set this before calling other routines, so that they see
2692 the correct value of w32_focus_frame. */
2693 dpyinfo
->w32_focus_frame
= frame
;
2695 if (old_focus
&& old_focus
->auto_lower
)
2696 x_lower_frame (old_focus
);
2698 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2699 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2701 pending_autoraise_frame
= 0;
2704 x_frame_rehighlight (dpyinfo
);
2708 /* Handle FocusIn and FocusOut state changes for FRAME.
2709 If FRAME has focus and there exists more than one frame, puts
2710 a FOCUS_IN_EVENT into *BUFP. */
2713 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
)
2716 struct w32_display_info
*dpyinfo
;
2717 struct frame
*frame
;
2718 struct input_event
*bufp
;
2720 if (type
== WM_SETFOCUS
)
2722 if (dpyinfo
->w32_focus_event_frame
!= frame
)
2724 x_new_focus_frame (dpyinfo
, frame
);
2725 dpyinfo
->w32_focus_event_frame
= frame
;
2727 /* Don't stop displaying the initial startup message
2728 for a switch-frame event we don't need. */
2729 if (NILP (Vterminal_frame
)
2730 && CONSP (Vframe_list
)
2731 && !NILP (XCDR (Vframe_list
)))
2733 bufp
->kind
= FOCUS_IN_EVENT
;
2734 XSETFRAME (bufp
->frame_or_window
, frame
);
2738 frame
->output_data
.x
->focus_state
|= state
;
2740 /* TODO: IME focus? */
2742 else if (type
== WM_KILLFOCUS
)
2744 frame
->output_data
.x
->focus_state
&= ~state
;
2746 if (dpyinfo
->w32_focus_event_frame
== frame
)
2748 dpyinfo
->w32_focus_event_frame
= 0;
2749 x_new_focus_frame (dpyinfo
, 0);
2752 /* TODO: IME focus? */
2757 /* The focus may have changed. Figure out if it is a real focus change,
2758 by checking both FocusIn/Out and Enter/LeaveNotify events.
2760 Returns FOCUS_IN_EVENT event in *BUFP. */
2763 w32_detect_focus_change (dpyinfo
, event
, bufp
)
2764 struct w32_display_info
*dpyinfo
;
2766 struct input_event
*bufp
;
2768 struct frame
*frame
;
2770 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
2774 /* On w32, this is only called from focus events, so no switch needed. */
2775 x_focus_changed (event
->msg
.message
,
2776 (event
->msg
.message
== WM_KILLFOCUS
?
2777 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
2778 dpyinfo
, frame
, bufp
);
2782 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2785 x_mouse_leave (dpyinfo
)
2786 struct w32_display_info
*dpyinfo
;
2788 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2791 /* The focus has changed, or we have redirected a frame's focus to
2792 another frame (this happens when a frame uses a surrogate
2793 mini-buffer frame). Shift the highlight as appropriate.
2795 The FRAME argument doesn't necessarily have anything to do with which
2796 frame is being highlighted or un-highlighted; we only use it to find
2797 the appropriate X display info. */
2800 w32_frame_rehighlight (frame
)
2801 struct frame
*frame
;
2803 if (! FRAME_W32_P (frame
))
2805 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
2809 x_frame_rehighlight (dpyinfo
)
2810 struct w32_display_info
*dpyinfo
;
2812 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2814 if (dpyinfo
->w32_focus_frame
)
2816 dpyinfo
->x_highlight_frame
2817 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2818 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2819 : dpyinfo
->w32_focus_frame
);
2820 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
2822 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
2823 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
2827 dpyinfo
->x_highlight_frame
= 0;
2829 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
2832 frame_unhighlight (old_highlight
);
2833 if (dpyinfo
->x_highlight_frame
)
2834 frame_highlight (dpyinfo
->x_highlight_frame
);
2838 /* Keyboard processing - modifier keys, etc. */
2840 /* Convert a keysym to its name. */
2843 x_get_keysym_name (keysym
)
2846 /* Make static so we can always return it */
2847 static char value
[100];
2850 GetKeyNameText (keysym
, value
, 100);
2858 /* Mouse clicks and mouse movement. Rah. */
2860 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2861 the state in PUP. XBUTTON provides extra information for extended mouse
2862 button messages. Returns FALSE if unable to parse the message. */
2864 parse_button (message
, xbutton
, pbutton
, pup
)
2875 case WM_LBUTTONDOWN
:
2883 case WM_MBUTTONDOWN
:
2884 if (NILP (Vw32_swap_mouse_buttons
))
2891 if (NILP (Vw32_swap_mouse_buttons
))
2897 case WM_RBUTTONDOWN
:
2898 if (NILP (Vw32_swap_mouse_buttons
))
2905 if (NILP (Vw32_swap_mouse_buttons
))
2911 case WM_XBUTTONDOWN
:
2912 button
= xbutton
+ 2;
2916 button
= xbutton
+ 2;
2924 if (pbutton
) *pbutton
= button
;
2930 /* Prepare a mouse-event in *RESULT for placement in the input queue.
2932 If the event is a button press, then note that we have grabbed
2936 construct_mouse_click (result
, msg
, f
)
2937 struct input_event
*result
;
2944 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
2947 /* Make the event type NO_EVENT; we'll change that when we decide
2949 result
->kind
= MOUSE_CLICK_EVENT
;
2950 result
->code
= button
;
2951 result
->timestamp
= msg
->msg
.time
;
2952 result
->modifiers
= (msg
->dwModifiers
2957 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
2958 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
2959 XSETFRAME (result
->frame_or_window
, f
);
2965 construct_mouse_wheel (result
, msg
, f
)
2966 struct input_event
*result
;
2973 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
2976 result
->timestamp
= msg
->msg
.time
;
2978 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
2979 forward, away from the user (up); a negative value indicates that
2980 the wheel was rotated backward, toward the user (down). */
2981 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
2983 /* The up and down modifiers indicate if the wheel was rotated up or
2984 down based on WHEEL_DELTA value. */
2985 result
->modifiers
= (msg
->dwModifiers
2986 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
2988 /* With multiple monitors, we can legitimately get negative
2989 coordinates, so cast to short to interpret them correctly. */
2990 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
2991 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
2992 ScreenToClient (msg
->msg
.hwnd
, &p
);
2993 XSETINT (result
->x
, p
.x
);
2994 XSETINT (result
->y
, p
.y
);
2995 XSETFRAME (result
->frame_or_window
, f
);
3001 construct_drag_n_drop (result
, msg
, f
)
3002 struct input_event
*result
;
3014 result
->kind
= DRAG_N_DROP_EVENT
;
3016 result
->timestamp
= msg
->msg
.time
;
3017 result
->modifiers
= msg
->dwModifiers
;
3019 hdrop
= (HDROP
) msg
->msg
.wParam
;
3020 DragQueryPoint (hdrop
, &p
);
3023 p
.x
= LOWORD (msg
->msg
.lParam
);
3024 p
.y
= HIWORD (msg
->msg
.lParam
);
3025 ScreenToClient (msg
->msg
.hwnd
, &p
);
3028 XSETINT (result
->x
, p
.x
);
3029 XSETINT (result
->y
, p
.y
);
3031 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3034 for (i
= 0; i
< num_files
; i
++)
3036 len
= DragQueryFile (hdrop
, i
, NULL
, 0);
3039 name
= alloca (len
+ 1);
3040 DragQueryFile (hdrop
, i
, name
, len
+ 1);
3041 files
= Fcons (DECODE_FILE (build_string (name
)), files
);
3046 XSETFRAME (frame
, f
);
3047 result
->frame_or_window
= frame
;
3048 result
->arg
= files
;
3053 /* Function to report a mouse movement to the mainstream Emacs code.
3054 The input handler calls this.
3056 We have received a mouse movement event, which is given in *event.
3057 If the mouse is over a different glyph than it was last time, tell
3058 the mainstream emacs code by setting mouse_moved. If not, ask for
3059 another motion event, so we can check again the next time it moves. */
3061 static MSG last_mouse_motion_event
;
3062 static Lisp_Object last_mouse_motion_frame
;
3065 note_mouse_movement (frame
, msg
)
3069 int mouse_x
= LOWORD (msg
->lParam
);
3070 int mouse_y
= HIWORD (msg
->lParam
);
3072 last_mouse_movement_time
= msg
->time
;
3073 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
3074 XSETFRAME (last_mouse_motion_frame
, frame
);
3076 if (!FRAME_X_OUTPUT (frame
))
3079 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3081 frame
->mouse_moved
= 1;
3082 last_mouse_scroll_bar
= Qnil
;
3083 note_mouse_highlight (frame
, -1, -1);
3084 last_mouse_glyph_frame
= 0;
3088 /* Has the mouse moved off the glyph it was on at the last sighting? */
3089 if (frame
!= last_mouse_glyph_frame
3090 || mouse_x
< last_mouse_glyph
.left
3091 || mouse_x
>= last_mouse_glyph
.right
3092 || mouse_y
< last_mouse_glyph
.top
3093 || mouse_y
>= last_mouse_glyph
.bottom
)
3095 frame
->mouse_moved
= 1;
3096 last_mouse_scroll_bar
= Qnil
;
3097 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3098 /* Remember the mouse position here, as w32_mouse_position only
3099 gets called when mouse tracking is enabled but we also need
3100 to keep track of the mouse for help_echo and highlighting at
3102 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, &last_mouse_glyph
);
3103 last_mouse_glyph_frame
= frame
;
3111 /************************************************************************
3113 ************************************************************************/
3115 static struct scroll_bar
*x_window_to_scroll_bar ();
3116 static void x_scroll_bar_report_motion ();
3117 static void x_check_fullscreen
P_ ((struct frame
*));
3120 redo_mouse_highlight ()
3122 if (!NILP (last_mouse_motion_frame
)
3123 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3124 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3125 LOWORD (last_mouse_motion_event
.lParam
),
3126 HIWORD (last_mouse_motion_event
.lParam
));
3130 w32_define_cursor (window
, cursor
)
3134 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3136 /* Return the current position of the mouse.
3137 *fp should be a frame which indicates which display to ask about.
3139 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3140 and *part to the frame, window, and scroll bar part that the mouse
3141 is over. Set *x and *y to the portion and whole of the mouse's
3142 position on the scroll bar.
3144 If the mouse movement started elsewhere, set *fp to the frame the
3145 mouse is on, *bar_window to nil, and *x and *y to the character cell
3148 Set *time to the server time-stamp for the time at which the mouse
3149 was at this position.
3151 Don't store anything if we don't have a valid set of values to report.
3153 This clears the mouse_moved flag, so we can wait for the next mouse
3157 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3160 Lisp_Object
*bar_window
;
3161 enum scroll_bar_part
*part
;
3163 unsigned long *time
;
3169 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3170 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3175 Lisp_Object frame
, tail
;
3177 /* Clear the mouse-moved flag for every frame on this display. */
3178 FOR_EACH_FRAME (tail
, frame
)
3179 XFRAME (frame
)->mouse_moved
= 0;
3181 last_mouse_scroll_bar
= Qnil
;
3185 /* Now we have a position on the root; find the innermost window
3186 containing the pointer. */
3188 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3189 && FRAME_LIVE_P (last_mouse_frame
))
3191 /* If mouse was grabbed on a frame, give coords for that frame
3192 even if the mouse is now outside it. */
3193 f1
= last_mouse_frame
;
3197 /* Is window under mouse one of our frames? */
3198 f1
= x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
3199 WindowFromPoint (pt
));
3202 /* If not, is it one of our scroll bars? */
3205 struct scroll_bar
*bar
3206 = x_window_to_scroll_bar (WindowFromPoint (pt
));
3210 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3214 if (f1
== 0 && insist
> 0)
3215 f1
= SELECTED_FRAME ();
3219 /* Ok, we found a frame. Store all the values.
3220 last_mouse_glyph is a rectangle used to reduce the
3221 generation of mouse events. To not miss any motion
3222 events, we must divide the frame into rectangles of the
3223 size of the smallest character that could be displayed
3224 on it, i.e. into the same rectangles that matrices on
3225 the frame are divided into. */
3227 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3228 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &last_mouse_glyph
);
3229 last_mouse_glyph_frame
= f1
;
3236 *time
= last_mouse_movement_time
;
3245 /***********************************************************************
3247 ***********************************************************************/
3249 /* Handle mouse button event on the tool-bar of frame F, at
3250 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
3254 w32_handle_tool_bar_click (f
, button_event
)
3256 struct input_event
*button_event
;
3258 int x
= XFASTINT (button_event
->x
);
3259 int y
= XFASTINT (button_event
->y
);
3261 if (button_event
->modifiers
& down_modifier
)
3262 handle_tool_bar_click (f
, x
, y
, 1, 0);
3264 handle_tool_bar_click (f
, x
, y
, 0,
3265 button_event
->modifiers
& ~up_modifier
);
3270 /***********************************************************************
3272 ***********************************************************************/
3274 /* Scroll bar support. */
3276 /* Given a window ID, find the struct scroll_bar which manages it.
3277 This can be called in GC, so we have to make sure to strip off mark
3280 static struct scroll_bar
*
3281 x_window_to_scroll_bar (window_id
)
3286 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3288 Lisp_Object frame
, bar
, condemned
;
3290 frame
= XCAR (tail
);
3291 /* All elements of Vframe_list should be frames. */
3292 if (! FRAMEP (frame
))
3295 /* Scan this frame's scroll bar list for a scroll bar with the
3297 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3298 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3299 /* This trick allows us to search both the ordinary and
3300 condemned scroll bar lists with one loop. */
3301 ! NILP (bar
) || (bar
= condemned
,
3304 bar
= XSCROLL_BAR (bar
)->next
)
3305 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
3306 return XSCROLL_BAR (bar
);
3314 /* Set the thumb size and position of scroll bar BAR. We are currently
3315 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3318 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
)
3319 struct scroll_bar
*bar
;
3320 int portion
, position
, whole
;
3322 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3323 /* We use the whole scroll-bar height in the calculations below, to
3324 avoid strange effects like scrolling backwards when just clicking
3325 on the handle (without moving it). */
3326 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
))
3327 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3328 int sb_page
, sb_pos
;
3329 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
3332 /* We used to change the nPage setting while dragging the handle,
3333 but that had very strange effects (such as scrolling backwards
3334 while dragging downwards).
3336 Now, we don't change the nPage setting while dragging unless we
3337 get near to the end of the buffer, in which case we often have to
3338 resize the handle to "go all the way". */
3344 si
.cbSize
= sizeof (si
);
3345 si
.fMask
= SIF_POS
| SIF_PAGE
;
3346 GetScrollInfo(w
, SB_CTL
, &si
);
3347 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3355 /* Position scroll bar at rock bottom if the bottom of the
3356 buffer is visible. This avoids shinking the thumb away
3357 to nothing if it is held at the bottom of the buffer. */
3358 if (position
+ portion
>= whole
&& !draggingp
)
3360 sb_page
= range
* (whole
- position
) / whole
;
3365 sb_pos
= position
* range
/ whole
;
3366 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3375 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3379 si
.cbSize
= sizeof (si
);
3380 si
.fMask
= SIF_PAGE
| SIF_POS
;
3384 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3390 /************************************************************************
3391 Scroll bars, general
3392 ************************************************************************/
3395 my_create_scrollbar (f
, bar
)
3397 struct scroll_bar
* bar
;
3399 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3400 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
3404 /*#define ATTACH_THREADS*/
3407 my_show_window (FRAME_PTR f
, HWND hwnd
, int how
)
3409 #ifndef ATTACH_THREADS
3410 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3411 (WPARAM
) hwnd
, (LPARAM
) how
);
3413 return ShowWindow (hwnd
, how
);
3418 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3419 int x
, int y
, int cx
, int cy
, UINT flags
)
3421 #ifndef ATTACH_THREADS
3423 pos
.hwndInsertAfter
= hwndAfter
;
3429 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
3431 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3436 my_set_focus (f
, hwnd
)
3440 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3445 my_set_foreground_window (hwnd
)
3448 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
3453 my_destroy_window (f
, hwnd
)
3457 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3461 /* Create a scroll bar and return the scroll bar vector for it. W is
3462 the Emacs window on which to create the scroll bar. TOP, LEFT,
3463 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
3466 static struct scroll_bar
*
3467 x_scroll_bar_create (w
, top
, left
, width
, height
)
3469 int top
, left
, width
, height
;
3471 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3474 struct scroll_bar
*bar
3475 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
3479 XSETWINDOW (bar
->window
, w
);
3480 XSETINT (bar
->top
, top
);
3481 XSETINT (bar
->left
, left
);
3482 XSETINT (bar
->width
, width
);
3483 XSETINT (bar
->height
, height
);
3484 XSETINT (bar
->start
, 0);
3485 XSETINT (bar
->end
, 0);
3486 bar
->dragging
= Qnil
;
3487 bar
->fringe_extended_p
= Qnil
;
3489 /* Requires geometry to be set before call to create the real window */
3491 hwnd
= my_create_scrollbar (f
, bar
);
3493 si
.cbSize
= sizeof (si
);
3496 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3497 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3501 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3503 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3505 /* Add bar to its frame's list of scroll bars. */
3506 bar
->next
= FRAME_SCROLL_BARS (f
);
3508 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
3509 if (! NILP (bar
->next
))
3510 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3518 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3522 x_scroll_bar_remove (bar
)
3523 struct scroll_bar
*bar
;
3525 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3529 /* Destroy the window. */
3530 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3532 /* Disassociate this scroll bar from its window. */
3533 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
3538 /* Set the handle of the vertical scroll bar for WINDOW to indicate
3539 that we are displaying PORTION characters out of a total of WHOLE
3540 characters, starting at POSITION. If WINDOW has no scroll bar,
3543 w32_set_vertical_scroll_bar (w
, portion
, whole
, position
)
3545 int portion
, whole
, position
;
3547 struct frame
*f
= XFRAME (w
->frame
);
3548 struct scroll_bar
*bar
;
3549 int top
, height
, left
, sb_left
, width
, sb_width
;
3550 int window_y
, window_height
;
3551 int fringe_extended_p
;
3553 /* Get window dimensions. */
3554 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
3556 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
3557 height
= window_height
;
3559 /* Compute the left edge of the scroll bar area. */
3560 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3562 /* Compute the width of the scroll bar which might be less than
3563 the width of the area reserved for the scroll bar. */
3564 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
3565 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
3569 /* Compute the left edge of the scroll bar. */
3570 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
3571 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
3573 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
3575 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
3576 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
3577 && WINDOW_LEFT_FRINGE_WIDTH (w
)
3578 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
3579 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
3581 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
3582 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
3583 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
3584 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
3586 /* Does the scroll bar exist yet? */
3587 if (NILP (w
->vertical_scroll_bar
))
3591 if (width
> 0 && height
> 0)
3593 hdc
= get_frame_dc (f
);
3594 if (fringe_extended_p
)
3595 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
3597 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3598 release_frame_dc (f
, hdc
);
3602 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
3606 /* It may just need to be moved and resized. */
3609 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3610 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3612 /* If already correctly positioned, do nothing. */
3613 if ( XINT (bar
->left
) == sb_left
3614 && XINT (bar
->top
) == top
3615 && XINT (bar
->width
) == sb_width
3616 && XINT (bar
->height
) == height
3617 && !NILP (bar
->fringe_extended_p
) == fringe_extended_p
)
3619 /* Redraw after clear_frame. */
3620 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3621 InvalidateRect (hwnd
, NULL
, FALSE
);
3629 if (width
&& height
)
3631 hdc
= get_frame_dc (f
);
3632 /* Since Windows scroll bars are smaller than the space reserved
3633 for them on the frame, we have to clear "under" them. */
3634 if (fringe_extended_p
)
3635 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
3637 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3638 release_frame_dc (f
, hdc
);
3640 /* Make sure scroll bar is "visible" before moving, to ensure the
3641 area of the parent window now exposed will be refreshed. */
3642 my_show_window (f
, hwnd
, SW_HIDE
);
3643 MoveWindow (hwnd
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
3644 top
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
3645 max (height
, 1), TRUE
);
3647 si
.cbSize
= sizeof (si
);
3648 si
.fMask
= SIF_RANGE
;
3650 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3651 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3653 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3655 my_show_window (f
, hwnd
, SW_NORMAL
);
3656 /* InvalidateRect (w, NULL, FALSE); */
3658 /* Remember new settings. */
3659 XSETINT (bar
->left
, sb_left
);
3660 XSETINT (bar
->top
, top
);
3661 XSETINT (bar
->width
, sb_width
);
3662 XSETINT (bar
->height
, height
);
3667 bar
->fringe_extended_p
= fringe_extended_p
? Qt
: Qnil
;
3669 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3671 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
3675 /* The following three hooks are used when we're doing a thorough
3676 redisplay of the frame. We don't explicitly know which scroll bars
3677 are going to be deleted, because keeping track of when windows go
3678 away is a real pain - "Can you say set-window-configuration, boys
3679 and girls?" Instead, we just assert at the beginning of redisplay
3680 that *all* scroll bars are to be removed, and then save a scroll bar
3681 from the fiery pit when we actually redisplay its window. */
3683 /* Arrange for all scroll bars on FRAME to be removed at the next call
3684 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
3685 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
3688 w32_condemn_scroll_bars (frame
)
3691 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
3692 while (! NILP (FRAME_SCROLL_BARS (frame
)))
3695 bar
= FRAME_SCROLL_BARS (frame
);
3696 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
3697 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
3698 XSCROLL_BAR (bar
)->prev
= Qnil
;
3699 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
3700 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
3701 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
3706 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
3707 Note that WINDOW isn't necessarily condemned at all. */
3710 w32_redeem_scroll_bar (window
)
3711 struct window
*window
;
3713 struct scroll_bar
*bar
;
3716 /* We can't redeem this window's scroll bar if it doesn't have one. */
3717 if (NILP (window
->vertical_scroll_bar
))
3720 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
3722 /* Unlink it from the condemned list. */
3723 f
= XFRAME (WINDOW_FRAME (window
));
3724 if (NILP (bar
->prev
))
3726 /* If the prev pointer is nil, it must be the first in one of
3728 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
3729 /* It's not condemned. Everything's fine. */
3731 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
3732 window
->vertical_scroll_bar
))
3733 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
3735 /* If its prev pointer is nil, it must be at the front of
3736 one or the other! */
3740 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
3742 if (! NILP (bar
->next
))
3743 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
3745 bar
->next
= FRAME_SCROLL_BARS (f
);
3747 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
3748 if (! NILP (bar
->next
))
3749 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3752 /* Remove all scroll bars on FRAME that haven't been saved since the
3753 last call to `*condemn_scroll_bars_hook'. */
3756 w32_judge_scroll_bars (f
)
3759 Lisp_Object bar
, next
;
3761 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
3763 /* Clear out the condemned list now so we won't try to process any
3764 more events on the hapless scroll bars. */
3765 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
3767 for (; ! NILP (bar
); bar
= next
)
3769 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
3771 x_scroll_bar_remove (b
);
3774 b
->next
= b
->prev
= Qnil
;
3777 /* Now there should be no references to the condemned scroll bars,
3778 and they should get garbage-collected. */
3781 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
3782 is set to something other than NO_EVENT, it is enqueued.
3784 This may be called from a signal handler, so we have to ignore GC
3788 w32_scroll_bar_handle_click (bar
, msg
, emacs_event
)
3789 struct scroll_bar
*bar
;
3791 struct input_event
*emacs_event
;
3793 if (! WINDOWP (bar
->window
))
3796 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
3797 emacs_event
->code
= 0;
3798 /* not really meaningful to distinguish up/down */
3799 emacs_event
->modifiers
= msg
->dwModifiers
;
3800 emacs_event
->frame_or_window
= bar
->window
;
3801 emacs_event
->arg
= Qnil
;
3802 emacs_event
->timestamp
= msg
->msg
.time
;
3805 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
3807 int dragging
= !NILP (bar
->dragging
);
3810 si
.cbSize
= sizeof (si
);
3813 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
3816 bar
->dragging
= Qnil
;
3819 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
3821 switch (LOWORD (msg
->msg
.wParam
))
3824 emacs_event
->part
= scroll_bar_down_arrow
;
3827 emacs_event
->part
= scroll_bar_up_arrow
;
3830 emacs_event
->part
= scroll_bar_above_handle
;
3833 emacs_event
->part
= scroll_bar_below_handle
;
3836 emacs_event
->part
= scroll_bar_handle
;
3840 emacs_event
->part
= scroll_bar_handle
;
3844 case SB_THUMBPOSITION
:
3845 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
3846 y
= HIWORD (msg
->msg
.wParam
);
3848 emacs_event
->part
= scroll_bar_handle
;
3850 /* "Silently" update current position. */
3854 si
.cbSize
= sizeof (si
);
3857 /* Remember apparent position (we actually lag behind the real
3858 position, so don't set that directly. */
3859 last_scroll_bar_drag_pos
= y
;
3861 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
3865 /* If this is the end of a drag sequence, then reset the scroll
3866 handle size to normal and do a final redraw. Otherwise do
3871 int start
= XINT (bar
->start
);
3872 int end
= XINT (bar
->end
);
3874 si
.cbSize
= sizeof (si
);
3875 si
.fMask
= SIF_PAGE
| SIF_POS
;
3876 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3877 si
.nPos
= last_scroll_bar_drag_pos
;
3878 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
3882 emacs_event
->kind
= NO_EVENT
;
3886 XSETINT (emacs_event
->x
, y
);
3887 XSETINT (emacs_event
->y
, top_range
);
3893 /* Return information to the user about the current position of the mouse
3894 on the scroll bar. */
3897 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
3899 Lisp_Object
*bar_window
;
3900 enum scroll_bar_part
*part
;
3902 unsigned long *time
;
3904 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
3905 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3906 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3908 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
3914 *bar_window
= bar
->window
;
3916 si
.cbSize
= sizeof (si
);
3917 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
3919 GetScrollInfo (w
, SB_CTL
, &si
);
3921 top_range
= si
.nMax
- si
.nPage
+ 1;
3923 switch (LOWORD (last_mouse_scroll_bar_pos
))
3925 case SB_THUMBPOSITION
:
3927 *part
= scroll_bar_handle
;
3928 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
3929 pos
= HIWORD (last_mouse_scroll_bar_pos
);
3932 *part
= scroll_bar_handle
;
3936 *part
= scroll_bar_handle
;
3941 XSETINT (*y
, top_range
);
3944 last_mouse_scroll_bar
= Qnil
;
3946 *time
= last_mouse_movement_time
;
3952 /* The screen has been cleared so we may have changed foreground or
3953 background colors, and the scroll bars may need to be redrawn.
3954 Clear out the scroll bars, and ask for expose events, so we can
3958 x_scroll_bar_clear (f
)
3963 /* We can have scroll bars even if this is 0,
3964 if we just turned off scroll bar mode.
3965 But in that case we should not clear them. */
3966 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
3967 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
3968 bar
= XSCROLL_BAR (bar
)->next
)
3970 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
3971 HDC hdc
= GetDC (window
);
3974 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
3975 arranges to refresh the scroll bar if hidden. */
3976 my_show_window (f
, window
, SW_HIDE
);
3978 GetClientRect (window
, &rect
);
3979 select_palette (f
, hdc
);
3980 w32_clear_rect (f
, hdc
, &rect
);
3981 deselect_palette (f
, hdc
);
3983 ReleaseDC (window
, hdc
);
3988 /* The main W32 event-reading loop - w32_read_socket. */
3990 /* Record the last 100 characters stored
3991 to help debug the loss-of-chars-during-GC problem. */
3993 static int temp_index
;
3994 static short temp_buffer
[100];
3996 /* Temporarily store lead byte of DBCS input sequences. */
3997 static char dbcs_lead
= 0;
3999 /* Read events coming from the W32 shell.
4000 This routine is called by the SIGIO handler.
4001 We return as soon as there are no more events to be read.
4003 We return the number of characters stored into the buffer,
4004 thus pretending to be `read'.
4006 EXPECTED is nonzero if the caller knows input is available.
4008 Some of these messages are reposted back to the message queue since the
4009 system calls the windows proc directly in a context where we cannot return
4010 the data nor can we guarantee the state we are in. So if we dispatch them
4011 we will get into an infinite loop. To prevent this from ever happening we
4012 will set a variable to indicate we are in the read_socket call and indicate
4013 which message we are processing since the windows proc gets called
4014 recursively with different messages by the system.
4018 w32_read_socket (sd
, expected
, hold_quit
)
4021 struct input_event
*hold_quit
;
4024 int check_visibility
= 0;
4027 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4029 if (interrupt_input_blocked
)
4031 interrupt_input_pending
= 1;
4035 interrupt_input_pending
= 0;
4038 /* So people can tell when we have read the available input. */
4039 input_signal_count
++;
4041 /* TODO: ghostscript integration. */
4042 while (get_next_msg (&msg
, FALSE
))
4044 struct input_event inev
;
4048 inev
.kind
= NO_EVENT
;
4051 switch (msg
.msg
.message
)
4054 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4058 if (msg
.rect
.right
== msg
.rect
.left
||
4059 msg
.rect
.bottom
== msg
.rect
.top
)
4061 /* We may get paint messages even though the client
4062 area is clipped - these are not expose events. */
4063 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4066 else if (f
->async_visible
!= 1)
4068 /* Definitely not obscured, so mark as visible. */
4069 f
->async_visible
= 1;
4070 f
->async_iconified
= 0;
4071 SET_FRAME_GARBAGED (f
);
4072 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4075 /* WM_PAINT serves as MapNotify as well, so report
4076 visibility changes properly. */
4079 inev
.kind
= DEICONIFY_EVENT
;
4080 XSETFRAME (inev
.frame_or_window
, f
);
4082 else if (! NILP (Vframe_list
)
4083 && ! NILP (XCDR (Vframe_list
)))
4084 /* Force a redisplay sooner or later to update the
4085 frame titles in case this is the second frame. */
4086 record_asynch_buffer_change ();
4090 HDC hdc
= get_frame_dc (f
);
4092 /* Erase background again for safety. */
4093 w32_clear_rect (f
, hdc
, &msg
.rect
);
4094 release_frame_dc (f
, hdc
);
4098 msg
.rect
.right
- msg
.rect
.left
,
4099 msg
.rect
.bottom
- msg
.rect
.top
);
4104 case WM_INPUTLANGCHANGE
:
4105 /* Generate a language change event. */
4106 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4110 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4111 XSETFRAME (inev
.frame_or_window
, f
);
4112 inev
.code
= msg
.msg
.wParam
;
4113 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4119 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4121 if (f
&& !f
->iconified
)
4123 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4124 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4126 clear_mouse_face (dpyinfo
);
4127 dpyinfo
->mouse_face_hidden
= 1;
4130 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4132 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4133 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4134 inev
.code
= msg
.msg
.wParam
;
4135 inev
.modifiers
= msg
.dwModifiers
;
4136 XSETFRAME (inev
.frame_or_window
, f
);
4137 inev
.timestamp
= msg
.msg
.time
;
4144 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4146 if (f
&& !f
->iconified
)
4148 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4149 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4151 clear_mouse_face (dpyinfo
);
4152 dpyinfo
->mouse_face_hidden
= 1;
4155 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4157 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4159 inev
.modifiers
= msg
.dwModifiers
;
4160 XSETFRAME (inev
.frame_or_window
, f
);
4161 inev
.timestamp
= msg
.msg
.time
;
4163 if (msg
.msg
.message
== WM_UNICHAR
)
4165 inev
.code
= msg
.msg
.wParam
;
4167 else if (msg
.msg
.wParam
< 256)
4172 dbcs
[1] = (char) msg
.msg
.wParam
;
4176 dbcs
[0] = dbcs_lead
;
4178 if (!MultiByteToWideChar (CP_ACP
, 0, dbcs
, 2, &code
, 1))
4181 DebPrint (("Invalid DBCS sequence: %d %d\n",
4183 inev
.kind
= NO_EVENT
;
4187 else if (IsDBCSLeadByteEx (CP_ACP
, (BYTE
) msg
.msg
.wParam
))
4189 dbcs_lead
= (char) msg
.msg
.wParam
;
4190 inev
.kind
= NO_EVENT
;
4195 if (!MultiByteToWideChar (CP_ACP
, 0, &dbcs
[1], 1,
4198 /* What to do with garbage? */
4199 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4200 inev
.kind
= NO_EVENT
;
4208 /* Windows shouldn't generate WM_CHAR events above 0xFF
4209 in non-Unicode message handlers. */
4210 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4211 inev
.kind
= NO_EVENT
;
4214 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4215 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4220 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4222 if (f
&& !f
->iconified
)
4224 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4225 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4227 clear_mouse_face (dpyinfo
);
4228 dpyinfo
->mouse_face_hidden
= 1;
4231 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4233 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4234 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4235 inev
.code
= GET_APPCOMMAND_LPARAM(msg
.msg
.lParam
);
4236 inev
.modifiers
= msg
.dwModifiers
;
4237 XSETFRAME (inev
.frame_or_window
, f
);
4238 inev
.timestamp
= msg
.msg
.time
;
4243 /* Ignore non-movement. */
4245 int x
= LOWORD (msg
.msg
.lParam
);
4246 int y
= HIWORD (msg
.msg
.lParam
);
4247 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4249 last_mousemove_x
= x
;
4250 last_mousemove_y
= y
;
4253 previous_help_echo_string
= help_echo_string
;
4254 help_echo_string
= Qnil
;
4256 if (dpyinfo
->grabbed
&& last_mouse_frame
4257 && FRAME_LIVE_P (last_mouse_frame
))
4258 f
= last_mouse_frame
;
4260 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4262 if (dpyinfo
->mouse_face_hidden
)
4264 dpyinfo
->mouse_face_hidden
= 0;
4265 clear_mouse_face (dpyinfo
);
4270 /* Generate SELECT_WINDOW_EVENTs when needed. */
4271 if (!NILP (Vmouse_autoselect_window
))
4274 int x
= LOWORD (msg
.msg
.lParam
);
4275 int y
= HIWORD (msg
.msg
.lParam
);
4277 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 0);
4279 /* Window will be selected only when it is not
4280 selected now and last mouse movement event was
4281 not in it. Minibuffer window will be selected
4282 only when it is active. */
4284 && !EQ (window
, last_window
)
4285 && !EQ (window
, selected_window
)
4286 /* For click-to-focus window managers
4287 create event iff we don't leave the
4289 && (focus_follows_mouse
4290 || (EQ (XWINDOW (window
)->frame
,
4291 XWINDOW (selected_window
)->frame
))))
4293 inev
.kind
= SELECT_WINDOW_EVENT
;
4294 inev
.frame_or_window
= window
;
4299 if (!note_mouse_movement (f
, &msg
.msg
))
4300 help_echo_string
= previous_help_echo_string
;
4304 /* If we move outside the frame, then we're
4305 certainly no longer on any text in the frame. */
4306 clear_mouse_face (dpyinfo
);
4309 /* If the contents of the global variable help_echo_string
4310 has changed, generate a HELP_EVENT. */
4311 #if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE.
4312 But it was originally changed to this to fix a bug, so I have
4313 not removed it completely in case the bug is still there. */
4314 if (help_echo_string
!= previous_help_echo_string
||
4315 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4316 #else /* This is what xterm.c does. */
4317 if (!NILP (help_echo_string
)
4318 || !NILP (previous_help_echo_string
))
4323 case WM_LBUTTONDOWN
:
4325 case WM_MBUTTONDOWN
:
4327 case WM_RBUTTONDOWN
:
4329 case WM_XBUTTONDOWN
:
4332 /* If we decide we want to generate an event to be seen
4333 by the rest of Emacs, we put it here. */
4338 if (dpyinfo
->grabbed
&& last_mouse_frame
4339 && FRAME_LIVE_P (last_mouse_frame
))
4340 f
= last_mouse_frame
;
4342 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4346 construct_mouse_click (&inev
, &msg
, f
);
4348 /* Is this in the tool-bar? */
4349 if (WINDOWP (f
->tool_bar_window
)
4350 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4353 int x
= XFASTINT (inev
.x
);
4354 int y
= XFASTINT (inev
.y
);
4356 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
4358 if (EQ (window
, f
->tool_bar_window
))
4360 w32_handle_tool_bar_click (f
, &inev
);
4366 || (dpyinfo
->w32_focus_frame
4367 && f
!= dpyinfo
->w32_focus_frame
))
4368 inev
.kind
= NO_EVENT
;
4371 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4376 dpyinfo
->grabbed
&= ~ (1 << button
);
4380 dpyinfo
->grabbed
|= (1 << button
);
4381 last_mouse_frame
= f
;
4382 /* Ignore any mouse motion that happened
4383 before this event; any subsequent mouse-movement
4384 Emacs events should reflect only motion after
4390 last_tool_bar_item
= -1;
4396 case WM_MOUSEHWHEEL
:
4398 if (dpyinfo
->grabbed
&& last_mouse_frame
4399 && FRAME_LIVE_P (last_mouse_frame
))
4400 f
= last_mouse_frame
;
4402 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4407 if (!dpyinfo
->w32_focus_frame
4408 || f
== dpyinfo
->w32_focus_frame
)
4410 /* Emit an Emacs wheel-up/down event. */
4411 construct_mouse_wheel (&inev
, &msg
, f
);
4413 /* Ignore any mouse motion that happened before this
4414 event; any subsequent mouse-movement Emacs events
4415 should reflect only motion after the
4419 last_mouse_frame
= f
;
4420 last_tool_bar_item
= -1;
4425 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4428 construct_drag_n_drop (&inev
, &msg
, f
);
4433 struct scroll_bar
*bar
=
4434 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
4437 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
4441 case WM_WINDOWPOSCHANGED
:
4442 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4445 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
4446 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
4448 check_visibility
= 1;
4452 case WM_ACTIVATEAPP
:
4453 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4455 x_check_fullscreen (f
);
4456 check_visibility
= 1;
4460 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4462 if (f
&& !f
->async_iconified
)
4466 x_real_positions (f
, &x
, &y
);
4471 check_visibility
= 1;
4475 /* wParam non-zero means Window is about to be shown, 0 means
4476 about to be hidden. */
4477 /* Redo the mouse-highlight after the tooltip has gone. */
4478 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
4481 redo_mouse_highlight ();
4484 /* If window has been obscured or exposed by another window
4485 being maximised or minimised/restored, then recheck
4486 visibility of all frames. Direct changes to our own
4487 windows get handled by WM_SIZE. */
4489 if (msg
.msg
.lParam
!= 0)
4490 check_visibility
= 1;
4493 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4494 f
->async_visible
= msg
.msg
.wParam
;
4498 check_visibility
= 1;
4502 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4504 /* Inform lisp of whether frame has been iconified etc. */
4507 switch (msg
.msg
.wParam
)
4509 case SIZE_MINIMIZED
:
4510 f
->async_visible
= 0;
4511 f
->async_iconified
= 1;
4513 inev
.kind
= ICONIFY_EVENT
;
4514 XSETFRAME (inev
.frame_or_window
, f
);
4517 case SIZE_MAXIMIZED
:
4519 f
->async_visible
= 1;
4520 f
->async_iconified
= 0;
4522 /* wait_reading_process_output will notice this and update
4523 the frame's display structures. */
4524 SET_FRAME_GARBAGED (f
);
4530 /* Reset top and left positions of the Window
4531 here since Windows sends a WM_MOVE message
4532 BEFORE telling us the Window is minimized
4533 when the Window is iconified, with 3000,3000
4535 x_real_positions (f
, &x
, &y
);
4539 inev
.kind
= DEICONIFY_EVENT
;
4540 XSETFRAME (inev
.frame_or_window
, f
);
4542 else if (! NILP (Vframe_list
)
4543 && ! NILP (XCDR (Vframe_list
)))
4544 /* Force a redisplay sooner or later
4545 to update the frame titles
4546 in case this is the second frame. */
4547 record_asynch_buffer_change ();
4552 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
4560 GetClientRect (msg
.msg
.hwnd
, &rect
);
4562 height
= rect
.bottom
- rect
.top
;
4563 width
= rect
.right
- rect
.left
;
4565 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
4566 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
4568 /* TODO: Clip size to the screen dimensions. */
4570 /* Even if the number of character rows and columns has
4571 not changed, the font size may have changed, so we need
4572 to check the pixel dimensions as well. */
4574 if (columns
!= FRAME_COLS (f
)
4575 || rows
!= FRAME_LINES (f
)
4576 || width
!= FRAME_PIXEL_WIDTH (f
)
4577 || height
!= FRAME_PIXEL_HEIGHT (f
))
4579 change_frame_size (f
, rows
, columns
, 0, 1, 0);
4580 SET_FRAME_GARBAGED (f
);
4581 cancel_mouse_face (f
);
4582 FRAME_PIXEL_WIDTH (f
) = width
;
4583 FRAME_PIXEL_HEIGHT (f
) = height
;
4584 f
->win_gravity
= NorthWestGravity
;
4588 check_visibility
= 1;
4592 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4595 if (f
== dpyinfo
->mouse_face_mouse_frame
)
4597 /* If we move outside the frame, then we're
4598 certainly no longer on any text in the frame. */
4599 clear_mouse_face (dpyinfo
);
4600 dpyinfo
->mouse_face_mouse_frame
= 0;
4603 /* Generate a nil HELP_EVENT to cancel a help-echo.
4604 Do it only if there's something to cancel.
4605 Otherwise, the startup message is cleared when
4606 the mouse leaves the frame. */
4607 if (any_help_event_p
)
4613 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
4615 dpyinfo
->grabbed
= 0;
4616 check_visibility
= 1;
4620 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4624 if (f
== dpyinfo
->w32_focus_event_frame
)
4625 dpyinfo
->w32_focus_event_frame
= 0;
4627 if (f
== dpyinfo
->w32_focus_frame
)
4628 x_new_focus_frame (dpyinfo
, 0);
4630 if (f
== dpyinfo
->mouse_face_mouse_frame
)
4632 /* If we move outside the frame, then we're
4633 certainly no longer on any text in the frame. */
4634 clear_mouse_face (dpyinfo
);
4635 dpyinfo
->mouse_face_mouse_frame
= 0;
4638 /* Generate a nil HELP_EVENT to cancel a help-echo.
4639 Do it only if there's something to cancel.
4640 Otherwise, the startup message is cleared when
4641 the mouse leaves the frame. */
4642 if (any_help_event_p
)
4646 dpyinfo
->grabbed
= 0;
4647 check_visibility
= 1;
4651 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4655 inev
.kind
= DELETE_WINDOW_EVENT
;
4656 XSETFRAME (inev
.frame_or_window
, f
);
4661 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4665 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
4666 XSETFRAME (inev
.frame_or_window
, f
);
4671 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4675 extern void menubar_selection_callback
4676 (FRAME_PTR f
, void * client_data
);
4677 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
4680 check_visibility
= 1;
4683 case WM_DISPLAYCHANGE
:
4684 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4688 dpyinfo
->width
= (short) LOWORD (msg
.msg
.lParam
);
4689 dpyinfo
->height
= (short) HIWORD (msg
.msg
.lParam
);
4690 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
4691 DebPrint (("display change: %d %d\n", dpyinfo
->width
,
4695 check_visibility
= 1;
4699 /* Check for messages registered at runtime. */
4700 if (msg
.msg
.message
== msh_mousewheel
)
4702 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
4703 msg
.msg
.message
= WM_MOUSEWHEEL
;
4709 if (inev
.kind
!= NO_EVENT
)
4711 kbd_buffer_store_event_hold (&inev
, hold_quit
);
4716 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
4721 XSETFRAME (frame
, f
);
4727 if (NILP (help_echo_string
))
4729 help_echo_object
= help_echo_window
= Qnil
;
4733 any_help_event_p
= 1;
4734 gen_help_event (help_echo_string
, frame
, help_echo_window
,
4735 help_echo_object
, help_echo_pos
);
4739 help_echo_string
= Qnil
;
4740 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
4746 /* If the focus was just given to an autoraising frame,
4748 /* ??? This ought to be able to handle more than one such frame. */
4749 if (pending_autoraise_frame
)
4751 x_raise_frame (pending_autoraise_frame
);
4752 pending_autoraise_frame
= 0;
4755 /* Check which frames are still visisble, if we have enqueued any user
4756 events or been notified of events that may affect visibility. We
4757 do this here because there doesn't seem to be any direct
4758 notification from Windows that the visibility of a window has
4759 changed (at least, not in all cases). */
4760 if (count
> 0 || check_visibility
)
4762 Lisp_Object tail
, frame
;
4764 FOR_EACH_FRAME (tail
, frame
)
4766 FRAME_PTR f
= XFRAME (frame
);
4767 /* The tooltip has been drawn already. Avoid the
4768 SET_FRAME_GARBAGED below. */
4769 if (EQ (frame
, tip_frame
))
4772 /* Check "visible" frames and mark each as obscured or not.
4773 Note that async_visible is nonzero for unobscured and
4774 obscured frames, but zero for hidden and iconified frames. */
4775 if (FRAME_W32_P (f
) && f
->async_visible
)
4781 /* Query clipping rectangle for the entire window area
4782 (GetWindowDC), not just the client portion (GetDC).
4783 Otherwise, the scrollbars and menubar aren't counted as
4784 part of the visible area of the frame, and we may think
4785 the frame is obscured when really a scrollbar is still
4786 visible and gets WM_PAINT messages above. */
4787 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
4788 GetClipBox (hdc
, &clipbox
);
4789 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
4792 if (clipbox
.right
== clipbox
.left
4793 || clipbox
.bottom
== clipbox
.top
)
4795 /* Frame has become completely obscured so mark as
4796 such (we do this by setting async_visible to 2 so
4797 that FRAME_VISIBLE_P is still true, but redisplay
4799 f
->async_visible
= 2;
4801 if (!FRAME_OBSCURED_P (f
))
4803 DebPrint (("frame %p (%s) obscured\n", f
,
4809 /* Frame is not obscured, so mark it as such. */
4810 f
->async_visible
= 1;
4812 if (FRAME_OBSCURED_P (f
))
4814 SET_FRAME_GARBAGED (f
);
4815 DebPrint (("obscured frame %p (%s) found to be visible\n", f
,
4818 /* Force a redisplay sooner or later. */
4819 record_asynch_buffer_change ();
4832 /***********************************************************************
4834 ***********************************************************************/
4836 /* Set clipping for output in glyph row ROW. W is the window in which
4837 we operate. GC is the graphics context to set clipping in.
4839 ROW may be a text row or, e.g., a mode line. Text rows must be
4840 clipped to the interior of the window dedicated to text display,
4841 mode lines must be clipped to the whole window. */
4844 w32_clip_to_row (w
, row
, area
, hdc
)
4846 struct glyph_row
*row
;
4850 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4852 int window_x
, window_y
, window_width
;
4854 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
4856 clip_rect
.left
= window_x
;
4857 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4858 clip_rect
.top
= max (clip_rect
.top
, window_y
);
4859 clip_rect
.right
= clip_rect
.left
+ window_width
;
4860 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
4862 w32_set_clip_rectangle (hdc
, &clip_rect
);
4866 /* Draw a hollow box cursor on window W in glyph row ROW. */
4869 x_draw_hollow_cursor (w
, row
)
4871 struct glyph_row
*row
;
4873 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4877 struct glyph
*cursor_glyph
;
4878 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
4880 /* Get the glyph the cursor is on. If we can't tell because
4881 the current matrix is invalid or such, give up. */
4882 cursor_glyph
= get_phys_cursor_glyph (w
);
4883 if (cursor_glyph
== NULL
)
4886 /* Compute frame-relative coordinates for phys cursor. */
4887 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
4890 rect
.bottom
= rect
.top
+ h
;
4891 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
4893 hdc
= get_frame_dc (f
);
4894 /* Set clipping, draw the rectangle, and reset clipping again. */
4895 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
4896 FrameRect (hdc
, &rect
, hb
);
4898 w32_set_clip_rectangle (hdc
, NULL
);
4899 release_frame_dc (f
, hdc
);
4903 /* Draw a bar cursor on window W in glyph row ROW.
4905 Implementation note: One would like to draw a bar cursor with an
4906 angle equal to the one given by the font property XA_ITALIC_ANGLE.
4907 Unfortunately, I didn't find a font yet that has this property set.
4911 x_draw_bar_cursor (w
, row
, width
, kind
)
4913 struct glyph_row
*row
;
4915 enum text_cursor_kinds kind
;
4917 struct frame
*f
= XFRAME (w
->frame
);
4918 struct glyph
*cursor_glyph
;
4922 /* If cursor is out of bounds, don't draw garbage. This can happen
4923 in mini-buffer windows when switching between echo area glyphs
4925 cursor_glyph
= get_phys_cursor_glyph (w
);
4926 if (cursor_glyph
== NULL
)
4929 /* If on an image, draw like a normal cursor. That's usually better
4930 visible than drawing a bar, esp. if the image is large so that
4931 the bar might not be in the window. */
4932 if (cursor_glyph
->type
== IMAGE_GLYPH
)
4934 struct glyph_row
*row
;
4935 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
4936 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
4940 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
4941 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
4943 /* If the glyph's background equals the color we normally draw
4944 the bar cursor in, the bar cursor in its normal color is
4945 invisible. Use the glyph's foreground color instead in this
4946 case, on the assumption that the glyph's colors are chosen so
4947 that the glyph is legible. */
4948 if (face
->background
== cursor_color
)
4949 cursor_color
= face
->foreground
;
4951 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
4954 width
= FRAME_CURSOR_WIDTH (f
);
4955 width
= min (cursor_glyph
->pixel_width
, width
);
4957 w
->phys_cursor_width
= width
;
4960 hdc
= get_frame_dc (f
);
4961 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
4963 if (kind
== BAR_CURSOR
)
4965 w32_fill_area (f
, hdc
, cursor_color
, x
,
4966 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
4967 width
, row
->height
);
4971 w32_fill_area (f
, hdc
, cursor_color
, x
,
4972 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
4973 row
->height
- width
),
4974 cursor_glyph
->pixel_width
, width
);
4977 w32_set_clip_rectangle (hdc
, NULL
);
4978 release_frame_dc (f
, hdc
);
4983 /* RIF: Define cursor CURSOR on frame F. */
4986 w32_define_frame_cursor (f
, cursor
)
4990 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
4994 /* RIF: Clear area on frame F. */
4997 w32_clear_frame_area (f
, x
, y
, width
, height
)
4999 int x
, y
, width
, height
;
5003 hdc
= get_frame_dc (f
);
5004 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5005 release_frame_dc (f
, hdc
);
5008 /* RIF: Draw or clear cursor on window W. */
5011 w32_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
5013 struct glyph_row
*glyph_row
;
5015 int cursor_type
, cursor_width
;
5020 /* If the user wants to use the system caret, make sure our own
5021 cursor remains invisible. */
5022 if (w32_use_visible_system_caret
)
5024 /* Call to erase_phys_cursor here seems to use the
5025 wrong values of w->phys_cursor, as they have been
5026 overwritten before this function was called. */
5027 if (w
->phys_cursor_type
!= NO_CURSOR
)
5028 erase_phys_cursor (w
);
5030 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5031 w
->phys_cursor_width
= -1;
5035 w
->phys_cursor_type
= cursor_type
;
5038 w
->phys_cursor_on_p
= 1;
5040 /* If this is the active cursor, we need to track it with the
5041 system caret, so third party software like screen magnifiers
5042 and speech synthesizers can follow the cursor. */
5045 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5046 HWND hwnd
= FRAME_W32_WINDOW (f
);
5049 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5051 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5052 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5054 /* If the size of the active cursor changed, destroy the old
5056 if (w32_system_caret_hwnd
5057 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5058 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5060 w32_system_caret_height
= w
->phys_cursor_height
;
5062 /* Move the system caret. */
5063 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5066 if (glyph_row
->exact_window_width_line_p
5067 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
5069 glyph_row
->cursor_in_fringe_p
= 1;
5070 draw_fringe_bitmap (w
, glyph_row
, 0);
5074 switch (cursor_type
)
5076 case HOLLOW_BOX_CURSOR
:
5077 x_draw_hollow_cursor (w
, glyph_row
);
5080 case FILLED_BOX_CURSOR
:
5081 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5085 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5089 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5093 w
->phys_cursor_width
= 0;
5107 x_bitmap_icon (f
, icon
)
5112 HANDLE small_icon
= NULL
;
5114 if (FRAME_W32_WINDOW (f
) == 0)
5118 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5119 else if (STRINGP (icon
))
5121 /* Load the main icon from the named file. */
5122 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5123 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5124 /* Try to load a small icon to go with it. */
5125 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5126 GetSystemMetrics (SM_CXSMICON
),
5127 GetSystemMetrics (SM_CYSMICON
),
5130 else if (SYMBOLP (icon
))
5134 if (EQ (icon
, intern ("application")))
5135 name
= (LPCTSTR
) IDI_APPLICATION
;
5136 else if (EQ (icon
, intern ("hand")))
5137 name
= (LPCTSTR
) IDI_HAND
;
5138 else if (EQ (icon
, intern ("question")))
5139 name
= (LPCTSTR
) IDI_QUESTION
;
5140 else if (EQ (icon
, intern ("exclamation")))
5141 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5142 else if (EQ (icon
, intern ("asterisk")))
5143 name
= (LPCTSTR
) IDI_ASTERISK
;
5144 else if (EQ (icon
, intern ("winlogo")))
5145 name
= (LPCTSTR
) IDI_WINLOGO
;
5149 main_icon
= LoadIcon (NULL
, name
);
5154 if (main_icon
== NULL
)
5157 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5158 (LPARAM
) main_icon
);
5160 /* If there is a small icon that goes with it, set that too. */
5162 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5163 (LPARAM
) small_icon
);
5169 /************************************************************************
5171 ************************************************************************/
5173 /* Display Error Handling functions not used on W32. Listing them here
5174 helps diff stay in step when comparing w32term.c with xterm.c.
5176 x_error_catcher (display, error)
5177 x_catch_errors (dpy)
5178 x_catch_errors_unwind (old_val)
5179 x_check_errors (dpy, format)
5180 x_fully_uncatch_errors ()
5181 x_catching_errors ()
5182 x_had_errors_p (dpy)
5183 x_clear_errors (dpy)
5184 x_uncatch_errors (dpy, count)
5186 x_connection_signal (signalnum)
5187 x_connection_closed (dpy, error_message)
5188 x_error_quitter (display, error)
5189 x_error_handler (display, error)
5190 x_io_error_quitter (display)
5195 /* Changing the font of the frame. */
5198 x_new_font (f
, font_object
, fontset
)
5200 Lisp_Object font_object
;
5203 struct font
*font
= XFONT_OBJECT (font_object
);
5206 fontset
= fontset_from_font (font_object
);
5207 FRAME_FONTSET (f
) = fontset
;
5208 if (FRAME_FONT (f
) == font
)
5209 /* This font is already set in frame F. There's nothing more to
5211 return fontset_name (fontset
);
5215 FRAME_FONT (f
) = font
;
5216 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5217 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
5218 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
5219 FRAME_LINE_HEIGHT (f
) = font
->height
;
5221 compute_fringe_widths (f
, 1);
5223 /* Compute the scroll bar width in character columns. */
5224 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5226 int wid
= FRAME_COLUMN_WIDTH (f
);
5227 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5228 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
- 1) / wid
;
5232 int wid
= FRAME_COLUMN_WIDTH (f
);
5233 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5236 /* Now make the frame display the given font. */
5237 if (FRAME_X_WINDOW (f
) != 0)
5239 /* Don't change the size of a tip frame; there's no point in
5240 doing it because it's done in Fx_show_tip, and it leads to
5241 problems because the tip frame has no widget. */
5242 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5243 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5248 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
5249 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
5254 return fontset_name (fontset
);
5258 /***********************************************************************
5259 TODO: W32 Input Methods
5260 ***********************************************************************/
5261 /* Listing missing functions from xterm.c helps diff stay in step.
5263 xim_destroy_callback (xim, client_data, call_data)
5264 xim_open_dpy (dpyinfo, resource_name)
5266 xim_instantiate_callback (display, client_data, call_data)
5267 xim_initialize (dpyinfo, resource_name)
5268 xim_close_dpy (dpyinfo)
5273 /* Calculate the absolute position in frame F
5274 from its current recorded position values and gravity. */
5277 x_calc_absolute_position (f
)
5280 int flags
= f
->size_hint_flags
;
5282 /* The sum of the widths of the frame's left and right borders, and
5283 the sum of the heights of the frame's top and bottom borders (in
5284 pixels) drawn by Windows. */
5285 unsigned int left_right_borders_width
, top_bottom_borders_height
;
5287 /* Try to get the actual values of these two variables. We compute
5288 the border width (height) by subtracting the width (height) of
5289 the frame's client area from the width (height) of the frame's
5291 WINDOWPLACEMENT wp
= { 0 };
5292 RECT client_rect
= { 0 };
5294 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
5295 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
5297 left_right_borders_width
=
5298 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
5299 (client_rect
.right
- client_rect
.left
);
5301 top_bottom_borders_height
=
5302 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
5303 (client_rect
.bottom
- client_rect
.top
);
5307 /* Use sensible default values. */
5308 left_right_borders_width
= 8;
5309 top_bottom_borders_height
= 32;
5312 /* Treat negative positions as relative to the rightmost bottommost
5313 position that fits on the screen. */
5314 if (flags
& XNegative
)
5315 f
->left_pos
= (FRAME_W32_DISPLAY_INFO (f
)->width
5316 - FRAME_PIXEL_WIDTH (f
)
5318 - (left_right_borders_width
- 1));
5320 if (flags
& YNegative
)
5321 f
->top_pos
= (FRAME_W32_DISPLAY_INFO (f
)->height
5322 - FRAME_PIXEL_HEIGHT (f
)
5324 - (top_bottom_borders_height
- 1));
5326 /* The left_pos and top_pos are now relative to the top and left
5327 screen edges, so the flags should correspond. */
5328 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5331 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5332 to really change the position, and 0 when calling from
5333 x_make_frame_visible (in that case, XOFF and YOFF are the current
5334 position values). It is -1 when calling from x_set_frame_parameters,
5335 which means, do adjust for borders but don't change the gravity. */
5338 x_set_offset (f
, xoff
, yoff
, change_gravity
)
5340 register int xoff
, yoff
;
5343 int modified_top
, modified_left
;
5345 if (change_gravity
> 0)
5349 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5351 f
->size_hint_flags
|= XNegative
;
5353 f
->size_hint_flags
|= YNegative
;
5354 f
->win_gravity
= NorthWestGravity
;
5356 x_calc_absolute_position (f
);
5359 x_wm_set_size_hint (f
, (long) 0, 0);
5361 modified_left
= f
->left_pos
;
5362 modified_top
= f
->top_pos
;
5364 my_set_window_pos (FRAME_W32_WINDOW (f
),
5366 modified_left
, modified_top
,
5368 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5373 /* Check if we need to resize the frame due to a fullscreen request.
5374 If so needed, resize the frame. */
5376 x_check_fullscreen (f
)
5379 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
5381 int width
, height
, ign
;
5383 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5385 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
5387 /* We do not need to move the window, it shall be taken care of
5388 when setting WM manager hints. */
5389 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
5391 change_frame_size (f
, height
, width
, 0, 1, 0);
5392 SET_FRAME_GARBAGED (f
);
5393 cancel_mouse_face (f
);
5395 /* Wait for the change of frame size to occur */
5396 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
5401 /* Call this to change the size of frame F's x-window.
5402 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5403 for this size change and subsequent size changes.
5404 Otherwise we leave the window gravity unchanged. */
5407 x_set_window_size (f
, change_gravity
, cols
, rows
)
5412 int pixelwidth
, pixelheight
;
5416 check_frame_size (f
, &rows
, &cols
);
5417 f
->scroll_bar_actual_width
5418 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
5420 compute_fringe_widths (f
, 0);
5422 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
5423 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
5425 f
->win_gravity
= NorthWestGravity
;
5426 x_wm_set_size_hint (f
, (long) 0, 0);
5431 rect
.left
= rect
.top
= 0;
5432 rect
.right
= pixelwidth
;
5433 rect
.bottom
= pixelheight
;
5435 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
5436 FRAME_EXTERNAL_MENU_BAR (f
));
5438 my_set_window_pos (FRAME_W32_WINDOW (f
),
5441 rect
.right
- rect
.left
,
5442 rect
.bottom
- rect
.top
,
5443 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5447 /* The following mirrors what is done in xterm.c. It appears to be
5448 for informing lisp of the new size immediately, while the actual
5449 resize will happen asynchronously. But on Windows, the menu bar
5450 automatically wraps when the frame is too narrow to contain it,
5451 and that causes any calculations made here to come out wrong. The
5452 end is some nasty buggy behavior, including the potential loss
5455 Disabling this code is either not sufficient to fix the problems
5456 completely, or it causes fresh problems, but at least it removes
5457 the most problematic symptom of the minibuffer becoming unusable.
5459 -----------------------------------------------------------------
5461 Now, strictly speaking, we can't be sure that this is accurate,
5462 but the window manager will get around to dealing with the size
5463 change request eventually, and we'll hear how it went when the
5464 ConfigureNotify event gets here.
5466 We could just not bother storing any of this information here,
5467 and let the ConfigureNotify event set everything up, but that
5468 might be kind of confusing to the Lisp code, since size changes
5469 wouldn't be reported in the frame parameters until some random
5470 point in the future when the ConfigureNotify event arrives.
5472 We pass 1 for DELAY since we can't run Lisp code inside of
5474 change_frame_size (f
, rows
, cols
, 0, 1, 0);
5475 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
5476 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
5478 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5479 receive in the ConfigureNotify event; if we get what we asked
5480 for, then the event won't cause the screen to become garbaged, so
5481 we have to make sure to do it here. */
5482 SET_FRAME_GARBAGED (f
);
5484 /* If cursor was outside the new size, mark it as off. */
5485 mark_window_cursors_off (XWINDOW (f
->root_window
));
5487 /* Clear out any recollection of where the mouse highlighting was,
5488 since it might be in a place that's outside the new frame size.
5489 Actually checking whether it is outside is a pain in the neck,
5490 so don't try--just let the highlighting be done afresh with new size. */
5491 cancel_mouse_face (f
);
5497 /* Mouse warping. */
5499 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
5502 x_set_mouse_position (f
, x
, y
)
5508 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
5509 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
5511 if (pix_x
< 0) pix_x
= 0;
5512 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
5514 if (pix_y
< 0) pix_y
= 0;
5515 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
5517 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
5521 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
5530 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
5531 pt
.x
= rect
.left
+ pix_x
;
5532 pt
.y
= rect
.top
+ pix_y
;
5533 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
5535 SetCursorPos (pt
.x
, pt
.y
);
5541 /* focus shifting, raising and lowering. */
5544 x_focus_on_frame (f
)
5547 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
5549 /* Give input focus to frame. */
5552 /* Try not to change its Z-order if possible. */
5553 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
5554 my_set_focus (f
, FRAME_W32_WINDOW (f
));
5557 my_set_foreground_window (FRAME_W32_WINDOW (f
));
5567 /* Raise frame F. */
5574 /* Strictly speaking, raise-frame should only change the frame's Z
5575 order, leaving input focus unchanged. This is reasonable behavior
5576 on X where the usual policy is point-to-focus. However, this
5577 behavior would be very odd on Windows where the usual policy is
5580 On X, if the mouse happens to be over the raised frame, it gets
5581 input focus anyway (so the window with focus will never be
5582 completely obscured) - if not, then just moving the mouse over it
5583 is sufficient to give it focus. On Windows, the user must actually
5584 click on the frame (preferrably the title bar so as not to move
5585 point), which is more awkward. Also, no other Windows program
5586 raises a window to the top but leaves another window (possibly now
5587 completely obscured) with input focus.
5589 Because there is a system setting on Windows that allows the user
5590 to choose the point to focus policy, we make the strict semantics
5591 optional, but by default we grab focus when raising. */
5593 if (NILP (Vw32_grab_focus_on_raise
))
5595 /* The obvious call to my_set_window_pos doesn't work if Emacs is
5596 not already the foreground application: the frame is raised
5597 above all other frames belonging to us, but not above the
5598 current top window. To achieve that, we have to resort to this
5599 more cumbersome method. */
5601 HDWP handle
= BeginDeferWindowPos (2);
5604 DeferWindowPos (handle
,
5605 FRAME_W32_WINDOW (f
),
5608 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5610 DeferWindowPos (handle
,
5611 GetForegroundWindow (),
5612 FRAME_W32_WINDOW (f
),
5614 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5616 EndDeferWindowPos (handle
);
5621 my_set_foreground_window (FRAME_W32_WINDOW (f
));
5627 /* Lower frame F. */
5633 my_set_window_pos (FRAME_W32_WINDOW (f
),
5636 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5641 w32_frame_raise_lower (f
, raise_flag
)
5645 if (! FRAME_W32_P (f
))
5654 /* Change of visibility. */
5656 /* This tries to wait until the frame is really visible.
5657 However, if the window manager asks the user where to position
5658 the frame, this will return before the user finishes doing that.
5659 The frame will not actually be visible at that time,
5660 but it will become visible later when the window manager
5661 finishes with it. */
5664 x_make_frame_visible (f
)
5671 type
= x_icon_type (f
);
5673 x_bitmap_icon (f
, type
);
5675 if (! FRAME_VISIBLE_P (f
))
5677 /* We test FRAME_GARBAGED_P here to make sure we don't
5678 call x_set_offset a second time
5679 if we get to x_make_frame_visible a second time
5680 before the window gets really visible. */
5681 if (! FRAME_ICONIFIED_P (f
)
5682 && ! f
->output_data
.w32
->asked_for_visible
)
5687 /* Adjust vertical window position in order to avoid being
5688 covered by a task bar placed at the bottom of the desktop. */
5689 SystemParametersInfo(SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
5690 GetWindowRect(FRAME_W32_WINDOW(f
), &window_rect
);
5691 if (window_rect
.bottom
> workarea_rect
.bottom
5692 && window_rect
.top
> workarea_rect
.top
)
5693 f
->top_pos
= max (window_rect
.top
5694 - window_rect
.bottom
+ workarea_rect
.bottom
,
5697 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
5700 f
->output_data
.w32
->asked_for_visible
= 1;
5702 /* The first of these seems to give more expected behavior, but
5703 was added as a commented out line in Sept 1997, with the
5704 second version remaining uncommented. There may have been
5705 some problem with it that led to it not being enabled,
5706 so the old version remains commented out below in case we
5707 decide we need to go back to it [23.0.60 2008-06-09]. */
5708 my_show_window (f
, FRAME_W32_WINDOW (f
),
5709 f
->async_iconified
? SW_RESTORE
: SW_SHOW
);
5710 /* my_show_window (f, FRAME_W32_WINDOW (f), SW_SHOWNORMAL); */
5713 /* Synchronize to ensure Emacs knows the frame is visible
5714 before we do anything else. We do this loop with input not blocked
5715 so that incoming events are handled. */
5720 /* This must come after we set COUNT. */
5723 XSETFRAME (frame
, f
);
5725 /* Wait until the frame is visible. Process X events until a
5726 MapNotify event has been seen, or until we think we won't get a
5727 MapNotify at all.. */
5728 for (count
= input_signal_count
+ 10;
5729 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
5731 /* Force processing of queued events. */
5732 /* TODO: x_sync equivalent? */
5734 /* Machines that do polling rather than SIGIO have been observed
5735 to go into a busy-wait here. So we'll fake an alarm signal
5736 to let the handler know that there's something to be read.
5737 We used to raise a real alarm, but it seems that the handler
5738 isn't always enabled here. This is probably a bug. */
5739 if (input_polling_used ())
5741 /* It could be confusing if a real alarm arrives while processing
5742 the fake one. Turn it off and let the handler reset it. */
5743 int old_poll_suppress_count
= poll_suppress_count
;
5744 poll_suppress_count
= 1;
5745 poll_for_input_1 ();
5746 poll_suppress_count
= old_poll_suppress_count
;
5749 FRAME_SAMPLE_VISIBILITY (f
);
5753 /* Change from mapped state to withdrawn state. */
5755 /* Make the frame visible (mapped and not iconified). */
5757 x_make_frame_invisible (f
)
5760 /* Don't keep the highlight on an invisible frame. */
5761 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5762 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5766 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
5768 /* We can't distinguish this from iconification
5769 just by the event that we get from the server.
5770 So we can't win using the usual strategy of letting
5771 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5772 and synchronize with the server to make sure we agree. */
5774 FRAME_ICONIFIED_P (f
) = 0;
5775 f
->async_visible
= 0;
5776 f
->async_iconified
= 0;
5781 /* Change window state from mapped to iconified. */
5789 /* Don't keep the highlight on an invisible frame. */
5790 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5791 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5793 if (f
->async_iconified
)
5798 type
= x_icon_type (f
);
5800 x_bitmap_icon (f
, type
);
5802 /* Simulate the user minimizing the frame. */
5803 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
5809 /* Free X resources of frame F. */
5812 x_free_frame_resources (f
)
5815 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5819 /* We must free faces before destroying windows because some
5820 font-driver (e.g. xft) access a window while finishing a
5822 if (FRAME_FACE_CACHE (f
))
5823 free_frame_faces (f
);
5825 if (FRAME_W32_WINDOW (f
))
5826 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
5828 free_frame_menubar (f
);
5830 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
5831 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
5832 unload_color (f
, f
->output_data
.w32
->cursor_pixel
);
5833 unload_color (f
, f
->output_data
.w32
->cursor_foreground_pixel
);
5834 unload_color (f
, f
->output_data
.w32
->border_pixel
);
5835 unload_color (f
, f
->output_data
.w32
->mouse_pixel
);
5836 if (f
->output_data
.w32
->white_relief
.allocated_p
)
5837 unload_color (f
, f
->output_data
.w32
->white_relief
.pixel
);
5838 if (f
->output_data
.w32
->black_relief
.allocated_p
)
5839 unload_color (f
, f
->output_data
.w32
->black_relief
.pixel
);
5841 if (FRAME_FACE_CACHE (f
))
5842 free_frame_faces (f
);
5844 xfree (f
->output_data
.w32
);
5845 f
->output_data
.w32
= NULL
;
5847 if (f
== dpyinfo
->w32_focus_frame
)
5848 dpyinfo
->w32_focus_frame
= 0;
5849 if (f
== dpyinfo
->w32_focus_event_frame
)
5850 dpyinfo
->w32_focus_event_frame
= 0;
5851 if (f
== dpyinfo
->x_highlight_frame
)
5852 dpyinfo
->x_highlight_frame
= 0;
5854 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5856 dpyinfo
->mouse_face_beg_row
5857 = dpyinfo
->mouse_face_beg_col
= -1;
5858 dpyinfo
->mouse_face_end_row
5859 = dpyinfo
->mouse_face_end_col
= -1;
5860 dpyinfo
->mouse_face_window
= Qnil
;
5861 dpyinfo
->mouse_face_deferred_gc
= 0;
5862 dpyinfo
->mouse_face_mouse_frame
= 0;
5869 /* Destroy the window of frame F. */
5871 x_destroy_window (f
)
5874 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5876 x_free_frame_resources (f
);
5877 dpyinfo
->reference_count
--;
5881 /* Setting window manager hints. */
5883 /* Set the normal size hints for the window manager, for frame F.
5884 FLAGS is the flags word to use--or 0 meaning preserve the flags
5885 that the window now has.
5886 If USER_POSITION is nonzero, we set the USPosition
5887 flag (this is useful when FLAGS is 0). */
5889 x_wm_set_size_hint (f
, flags
, user_position
)
5894 Window window
= FRAME_W32_WINDOW (f
);
5898 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
5899 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
5900 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
5901 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
5906 /* Window manager things */
5908 x_wm_set_icon_position (f
, icon_x
, icon_y
)
5913 Window window
= FRAME_W32_WINDOW (f
);
5915 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
5916 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
5917 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
5919 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
5924 /***********************************************************************
5926 ***********************************************************************/
5928 static int w32_initialized
= 0;
5931 w32_initialize_display_info (display_name
)
5932 Lisp_Object display_name
;
5934 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
5936 bzero (dpyinfo
, sizeof (*dpyinfo
));
5938 /* Put it on w32_display_name_list. */
5939 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
5940 w32_display_name_list
);
5941 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
5943 dpyinfo
->w32_id_name
5944 = (char *) xmalloc (SCHARS (Vinvocation_name
)
5945 + SCHARS (Vsystem_name
)
5947 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
5948 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
5950 /* Default Console mode values - overridden when running in GUI mode
5951 with values obtained from system metrics. */
5954 dpyinfo
->height_in
= 1;
5955 dpyinfo
->width_in
= 1;
5956 dpyinfo
->n_planes
= 1;
5957 dpyinfo
->n_cbits
= 4;
5958 dpyinfo
->n_fonts
= 0;
5959 dpyinfo
->smallest_font_height
= 1;
5960 dpyinfo
->smallest_char_width
= 1;
5962 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
5963 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
5964 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
5965 dpyinfo
->mouse_face_window
= Qnil
;
5966 dpyinfo
->mouse_face_overlay
= Qnil
;
5967 dpyinfo
->mouse_face_hidden
= 0;
5969 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
5970 /* TODO: dpyinfo->gray */
5974 /* Create an xrdb-style database of resources to supercede registry settings.
5975 The database is just a concatenation of C strings, finished by an additional
5976 \0. The strings are submitted to some basic normalization, so
5978 [ *]option[ *]:[ *]value...
5984 but any whitespace following value is not removed. */
5987 w32_make_rdb (xrm_option
)
5990 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
5991 char *current
= buffer
;
5994 int before_value
= 0;
6008 if (in_option
&& (ch
== ':'))
6013 else if (before_value
)
6018 else if (!(in_option
|| before_value
))
6030 x_flush (struct frame
* f
)
6031 { /* Nothing to do */ }
6034 extern frame_parm_handler w32_frame_parm_handlers
[];
6036 static struct redisplay_interface w32_redisplay_interface
=
6038 w32_frame_parm_handlers
,
6042 x_clear_end_of_line
,
6044 x_after_update_window_line
,
6045 x_update_window_begin
,
6046 x_update_window_end
,
6049 0, /* flush_display_optional */
6050 x_clear_window_mouse_face
,
6051 x_get_glyph_overhangs
,
6052 x_fix_overlapping_area
,
6053 w32_draw_fringe_bitmap
,
6054 w32_define_fringe_bitmap
,
6055 w32_destroy_fringe_bitmap
,
6056 w32_compute_glyph_string_overhangs
,
6057 x_draw_glyph_string
,
6058 w32_define_frame_cursor
,
6059 w32_clear_frame_area
,
6060 w32_draw_window_cursor
,
6061 w32_draw_vertical_window_border
,
6062 w32_shift_glyphs_for_insert
6065 static void x_delete_terminal (struct terminal
*term
);
6067 static struct terminal
*
6068 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6070 struct terminal
*terminal
;
6072 terminal
= create_terminal ();
6074 terminal
->type
= output_w32
;
6075 terminal
->display_info
.w32
= dpyinfo
;
6076 dpyinfo
->terminal
= terminal
;
6078 /* MSVC does not type K&R functions with no arguments correctly, and
6079 so we must explicitly cast them. */
6080 terminal
->clear_frame_hook
= x_clear_frame
;
6081 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6082 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6083 terminal
->ring_bell_hook
= w32_ring_bell
;
6084 terminal
->reset_terminal_modes_hook
= w32_reset_terminal_modes
;
6085 terminal
->set_terminal_modes_hook
= w32_set_terminal_modes
;
6086 terminal
->update_begin_hook
= x_update_begin
;
6087 terminal
->update_end_hook
= x_update_end
;
6088 terminal
->set_terminal_window_hook
= w32_set_terminal_window
;
6089 terminal
->read_socket_hook
= w32_read_socket
;
6090 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6091 terminal
->mouse_position_hook
= w32_mouse_position
;
6092 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6093 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6094 // terminal->fullscreen_hook = XTfullscreen_hook;
6095 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6096 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6097 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6098 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6100 terminal
->delete_frame_hook
= x_destroy_window
;
6101 terminal
->delete_terminal_hook
= x_delete_terminal
;
6103 terminal
->rif
= &w32_redisplay_interface
;
6104 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
6105 terminal
->char_ins_del_ok
= 1;
6106 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
6107 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
6108 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
6111 /* We don't yet support separate terminals on W32, so don't try to share
6112 keyboards between virtual terminals that are on the same physical
6113 terminal like X does. */
6114 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
6115 init_kboard (terminal
->kboard
);
6116 terminal
->kboard
->Vwindow_system
= intern ("w32");
6117 terminal
->kboard
->next_kboard
= all_kboards
;
6118 all_kboards
= terminal
->kboard
;
6119 /* Don't let the initial kboard remain current longer than necessary.
6120 That would cause problems if a file loaded on startup tries to
6121 prompt in the mini-buffer. */
6122 if (current_kboard
== initial_kboard
)
6123 current_kboard
= terminal
->kboard
;
6124 terminal
->kboard
->reference_count
++;
6130 x_delete_terminal (struct terminal
*terminal
)
6132 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
6135 /* Protect against recursive calls. Fdelete_frame in
6136 delete_terminal calls us back when it deletes our last frame. */
6137 if (!terminal
->name
)
6142 x_delete_display (dpyinfo
);
6146 struct w32_display_info
*
6147 w32_term_init (display_name
, xrm_option
, resource_name
)
6148 Lisp_Object display_name
;
6150 char *resource_name
;
6152 struct w32_display_info
*dpyinfo
;
6153 struct terminal
*terminal
;
6158 if (!w32_initialized
)
6161 w32_initialized
= 1;
6164 w32_initialize_display_info (display_name
);
6166 dpyinfo
= &one_w32_display_info
;
6167 terminal
= w32_create_terminal (dpyinfo
);
6169 /* Set the name of the terminal. */
6170 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
6171 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
6172 terminal
->name
[SBYTES (display_name
)] = 0;
6174 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6176 /* Put this display on the chain. */
6177 dpyinfo
->next
= x_display_list
;
6178 x_display_list
= dpyinfo
;
6180 hdc
= GetDC (GetDesktopWindow ());
6182 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
6183 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
6184 dpyinfo
->root_window
= GetDesktopWindow ();
6185 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6186 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6187 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6188 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6189 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6190 dpyinfo
->terminal
->image_cache
= make_image_cache ();
6191 dpyinfo
->height_in
= dpyinfo
->height
/ dpyinfo
->resx
;
6192 dpyinfo
->width_in
= dpyinfo
->width
/ dpyinfo
->resy
;
6193 ReleaseDC (GetDesktopWindow (), hdc
);
6195 /* initialise palette with white and black */
6198 w32_defined_color (0, "white", &color
, 1);
6199 w32_defined_color (0, "black", &color
, 1);
6202 /* Add the default keyboard. */
6203 add_keyboard_wait_descriptor (0);
6205 /* Create Fringe Bitmaps and store them for later use.
6207 On W32, bitmaps are all unsigned short, as Windows requires
6208 bitmap data to be Word aligned. For some reason they are
6209 horizontally reflected compared to how they appear on X, so we
6210 need to bitswap and convert to unsigned shorts before creating
6212 w32_init_fringe (terminal
->rif
);
6215 fcntl (connection
, F_SETOWN
, getpid ());
6216 #endif /* ! defined (F_SETOWN) */
6219 if (interrupt_input
)
6220 init_sigio (connection
);
6221 #endif /* ! defined (SIGIO) */
6228 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6230 x_delete_display (dpyinfo
)
6231 struct w32_display_info
*dpyinfo
;
6233 /* Discard this display from w32_display_name_list and w32_display_list.
6234 We can't use Fdelq because that can quit. */
6235 if (! NILP (w32_display_name_list
)
6236 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
6237 w32_display_name_list
= XCDR (w32_display_name_list
);
6242 tail
= w32_display_name_list
;
6243 while (CONSP (tail
) && CONSP (XCDR (tail
)))
6245 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
6247 XSETCDR (tail
, XCDR (XCDR (tail
)));
6254 /* free palette table */
6256 struct w32_palette_entry
* plist
;
6258 plist
= dpyinfo
->color_list
;
6261 struct w32_palette_entry
* pentry
= plist
;
6262 plist
= plist
->next
;
6265 dpyinfo
->color_list
= NULL
;
6266 if (dpyinfo
->palette
)
6267 DeleteObject(dpyinfo
->palette
);
6269 xfree (dpyinfo
->w32_id_name
);
6271 w32_reset_fringes ();
6274 /* Set up use of W32. */
6276 DWORD WINAPI
w32_msg_worker (void * arg
);
6283 w32_system_caret_hwnd
= NULL
;
6284 w32_system_caret_height
= 0;
6285 w32_system_caret_x
= 0;
6286 w32_system_caret_y
= 0;
6288 /* Initialize w32_use_visible_system_caret based on whether a screen
6289 reader is in use. */
6290 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
6291 &w32_use_visible_system_caret
, 0))
6292 w32_use_visible_system_caret
= 0;
6294 last_tool_bar_item
= -1;
6295 any_help_event_p
= 0;
6297 /* Initialize input mode: interrupt_input off, no flow control, allow
6298 8 bit character input, standard quit char. */
6299 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
6301 /* Create the window thread - it will terminate itself or when the app terminates */
6305 dwMainThreadId
= GetCurrentThreadId ();
6306 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6307 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
6309 /* Wait for thread to start */
6314 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
6316 hWindowsThread
= CreateThread (NULL
, 0,
6318 0, 0, &dwWindowsThreadId
);
6320 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6323 /* It is desirable that mainThread should have the same notion of
6324 focus window and active window as windowsThread. Unfortunately, the
6325 following call to AttachThreadInput, which should do precisely what
6326 we need, causes major problems when Emacs is linked as a console
6327 program. Unfortunately, we have good reasons for doing that, so
6328 instead we need to send messages to windowsThread to make some API
6329 calls for us (ones that affect, or depend on, the active/focus
6331 #ifdef ATTACH_THREADS
6332 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
6335 /* Dynamically link to optional system components. */
6337 HANDLE user_lib
= LoadLibrary ("user32.dll");
6339 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
6341 LOAD_PROC (user_lib
, SetLayeredWindowAttributes
);
6345 FreeLibrary (user_lib
);
6347 /* Ensure scrollbar handle is at least 5 pixels. */
6348 vertical_scroll_bar_min_handle
= 5;
6350 /* For either kind of scroll bar, take account of the arrows; these
6351 effectively form the border of the main scroll bar range. */
6352 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
6353 = GetSystemMetrics (SM_CYVSCROLL
);
6360 staticpro (&w32_display_name_list
);
6361 w32_display_name_list
= Qnil
;
6363 staticpro (&last_mouse_scroll_bar
);
6364 last_mouse_scroll_bar
= Qnil
;
6366 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
6368 DEFVAR_INT ("w32-num-mouse-buttons",
6369 &w32_num_mouse_buttons
,
6370 doc
: /* Number of physical mouse buttons. */);
6371 w32_num_mouse_buttons
= 2;
6373 DEFVAR_LISP ("w32-swap-mouse-buttons",
6374 &Vw32_swap_mouse_buttons
,
6375 doc
: /* Swap the mapping of middle and right mouse buttons.
6376 When nil, middle button is mouse-2 and right button is mouse-3. */);
6377 Vw32_swap_mouse_buttons
= Qnil
;
6379 DEFVAR_LISP ("w32-grab-focus-on-raise",
6380 &Vw32_grab_focus_on_raise
,
6381 doc
: /* Raised frame grabs input focus.
6382 When t, `raise-frame' grabs input focus as well. This fits well
6383 with the normal Windows click-to-focus policy, but might not be
6384 desirable when using a point-to-focus policy. */);
6385 Vw32_grab_focus_on_raise
= Qt
;
6387 DEFVAR_LISP ("w32-capslock-is-shiftlock",
6388 &Vw32_capslock_is_shiftlock
,
6389 doc
: /* Apply CapsLock state to non character input keys.
6390 When nil, CapsLock only affects normal character input keys. */);
6391 Vw32_capslock_is_shiftlock
= Qnil
;
6393 DEFVAR_LISP ("w32-recognize-altgr",
6394 &Vw32_recognize_altgr
,
6395 doc
: /* Recognize right-alt and left-ctrl as AltGr.
6396 When nil, the right-alt and left-ctrl key combination is
6397 interpreted normally. */);
6398 Vw32_recognize_altgr
= Qt
;
6400 DEFVAR_BOOL ("w32-use-visible-system-caret",
6401 &w32_use_visible_system_caret
,
6402 doc
: /* Flag to make the system caret visible.
6403 When this is non-nil, Emacs will indicate the position of point by
6404 using the system caret instead of drawing its own cursor. Some screen
6405 reader software does not track the system cursor properly when it is
6406 invisible, and gets confused by Emacs drawing its own cursor, so this
6407 variable is initialized to t when Emacs detects that screen reader
6408 software is running as it starts up.
6410 When this variable is set, other variables affecting the appearance of
6411 the cursor have no effect. */);
6413 w32_use_visible_system_caret
= 0;
6415 /* We don't yet support this, but defining this here avoids whining
6416 from cus-start.el and other places, like "M-x set-variable". */
6417 DEFVAR_BOOL ("x-use-underline-position-properties",
6418 &x_use_underline_position_properties
,
6419 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
6420 A value of nil means ignore them. If you encounter fonts with bogus
6421 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
6422 to 4.1, set this to nil.
6424 NOTE: Not supported on MS-Windows yet. */);
6425 x_use_underline_position_properties
= 0;
6427 DEFVAR_BOOL ("x-underline-at-descent-line",
6428 &x_underline_at_descent_line
,
6429 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
6430 A value of nil means to draw the underline according to the value of the
6431 variable `x-use-underline-position-properties', which is usually at the
6432 baseline level. The default value is nil. */);
6433 x_underline_at_descent_line
= 0;
6435 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
6436 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
6437 Vx_toolkit_scroll_bars
= Qt
;
6439 staticpro (&last_mouse_motion_frame
);
6440 last_mouse_motion_frame
= Qnil
;
6443 /* arch-tag: 5fa70624-ab86-499c-8a85-473958ee4646
6444 (do not change this comment) */