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, 2009 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"
37 #include "character.h"
41 #include "dispextern.h"
43 #include "termhooks.h"
50 #include "intervals.h"
63 static int max_fringe_bmp
= 0;
64 static HBITMAP
*fringe_bmp
= 0;
66 /* Non-nil means Emacs uses toolkit scroll bars. */
68 Lisp_Object Vx_toolkit_scroll_bars
;
70 /* Temporary variables for w32_read_socket. */
72 static int last_mousemove_x
= 0;
73 static int last_mousemove_y
= 0;
75 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
76 #ifndef GET_WHEEL_DELTA_WPARAM
77 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
80 /* Non-zero means that a HELP_EVENT has been generated since Emacs
83 static int any_help_event_p
;
85 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
86 static Lisp_Object last_window
;
88 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
89 int x_use_underline_position_properties
;
91 /* Non-zero means to draw the underline at the same place as the descent line. */
93 int x_underline_at_descent_line
;
95 extern unsigned int msh_mousewheel
;
97 extern void free_frame_menubar ();
99 extern int w32_codepage_for_font (char *fontname
);
100 extern Cursor
w32_load_cursor (LPCTSTR name
);
102 extern Lisp_Object Vwindow_system
;
104 #define x_any_window_to_frame x_window_to_frame
105 #define x_top_window_to_frame x_window_to_frame
108 /* This is display since w32 does not support multiple ones. */
109 struct w32_display_info one_w32_display_info
;
110 struct w32_display_info
*x_display_list
;
112 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
113 one for each element of w32_display_list and in the same order.
114 NAME is the name of the frame.
115 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
116 Lisp_Object w32_display_name_list
;
120 /* Pre Windows 2000, this was not available, but define it here so
121 that Emacs compiled on such a platform will run on newer versions. */
123 typedef struct tagWCRANGE
129 typedef struct tagGLYPHSET
133 DWORD cGlyphsSupported
;
140 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
141 BOOL (PASCAL
*pfnSetLayeredWindowAttributes
) (HWND
, COLORREF
, BYTE
, DWORD
);
144 #define LWA_ALPHA 0x02
146 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
147 later targets by MSVC headers. */
148 #ifndef WS_EX_LAYERED
149 #define WS_EX_LAYERED 0x80000
152 /* Frame being updated by update_frame. This is declared in term.c.
153 This is set by update_begin and looked at by all the
154 w32 functions. It is zero while not inside an update.
155 In that case, the w32 functions assume that `SELECTED_FRAME ()'
156 is the frame to apply to. */
157 extern struct frame
*updating_frame
;
159 /* This is a frame waiting to be autoraised, within w32_read_socket. */
160 struct frame
*pending_autoraise_frame
;
162 /* The handle of the frame that currently owns the system caret. */
163 HWND w32_system_caret_hwnd
;
164 int w32_system_caret_height
;
165 int w32_system_caret_x
;
166 int w32_system_caret_y
;
167 int w32_use_visible_system_caret
;
169 DWORD dwWindowsThreadId
= 0;
170 HANDLE hWindowsThread
= NULL
;
171 DWORD dwMainThreadId
= 0;
172 HANDLE hMainThread
= NULL
;
174 int vertical_scroll_bar_min_handle
;
175 int vertical_scroll_bar_top_border
;
176 int vertical_scroll_bar_bottom_border
;
178 int last_scroll_bar_drag_pos
;
180 /* Mouse movement. */
182 /* Where the mouse was last time we reported a mouse event. */
184 static RECT last_mouse_glyph
;
185 static FRAME_PTR last_mouse_glyph_frame
;
186 static Lisp_Object last_mouse_press_frame
;
188 int w32_num_mouse_buttons
;
190 Lisp_Object Vw32_swap_mouse_buttons
;
192 /* Control whether x_raise_frame also sets input focus. */
193 Lisp_Object Vw32_grab_focus_on_raise
;
195 /* Control whether Caps Lock affects non-ascii characters. */
196 Lisp_Object Vw32_capslock_is_shiftlock
;
198 /* Control whether right-alt and left-ctrl should be recognized as AltGr. */
199 Lisp_Object Vw32_recognize_altgr
;
201 /* The scroll bar in which the last motion event occurred.
203 If the last motion event occurred in a scroll bar, we set this
204 so w32_mouse_position can know whether to report a scroll bar motion or
207 If the last motion event didn't occur in a scroll bar, we set this
208 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
209 static Lisp_Object last_mouse_scroll_bar
;
210 static int last_mouse_scroll_bar_pos
;
212 /* This is a hack. We would really prefer that w32_mouse_position would
213 return the time associated with the position it returns, but there
214 doesn't seem to be any way to wrest the time-stamp from the server
215 along with the position query. So, we just keep track of the time
216 of the last movement we received, and return that in hopes that
217 it's somewhat accurate. */
219 static Time last_mouse_movement_time
;
221 /* Incremented by w32_read_socket whenever it really tries to read
225 static int volatile input_signal_count
;
227 static int input_signal_count
;
230 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
236 /* A mask of extra modifier bits to put into every keyboard char. */
238 extern EMACS_INT extra_keyboard_modifiers
;
240 static void x_update_window_end
P_ ((struct window
*, int, int));
241 static void w32_handle_tool_bar_click
P_ ((struct frame
*,
242 struct input_event
*));
243 static void w32_define_cursor
P_ ((Window
, Cursor
));
245 void x_lower_frame
P_ ((struct frame
*));
246 void x_scroll_bar_clear
P_ ((struct frame
*));
247 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
248 void x_raise_frame
P_ ((struct frame
*));
249 void x_set_window_size
P_ ((struct frame
*, int, int, int));
250 void x_wm_set_window_state
P_ ((struct frame
*, int));
251 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
252 static void w32_initialize
P_ ((void));
253 static void x_update_end
P_ ((struct frame
*));
254 static void w32_frame_up_to_date
P_ ((struct frame
*));
255 static void w32_set_terminal_modes
P_ ((struct terminal
*));
256 static void w32_reset_terminal_modes
P_ ((struct terminal
*));
257 static void x_clear_frame
P_ ((struct frame
*));
258 static void frame_highlight
P_ ((struct frame
*));
259 static void frame_unhighlight
P_ ((struct frame
*));
260 static void x_new_focus_frame
P_ ((struct w32_display_info
*,
262 static void x_focus_changed
P_ ((int, int, struct w32_display_info
*,
263 struct frame
*, struct input_event
*));
264 static void w32_detect_focus_change
P_ ((struct w32_display_info
*,
265 W32Msg
*, struct input_event
*));
266 static void w32_frame_rehighlight
P_ ((struct frame
*));
267 static void x_frame_rehighlight
P_ ((struct w32_display_info
*));
268 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
269 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
270 enum text_cursor_kinds
));
271 static void w32_clip_to_row
P_ ((struct window
*, struct glyph_row
*, int, HDC
));
272 static BOOL my_show_window
P_ ((struct frame
*, HWND
, int));
273 static void my_set_window_pos
P_ ((HWND
, HWND
, int, int, int, int, UINT
));
274 static void my_set_focus
P_ ((struct frame
*, HWND
));
275 static void my_set_foreground_window
P_ ((HWND
));
276 static void my_destroy_window
P_ ((struct frame
*, HWND
));
278 static Lisp_Object Qvendor_specific_keysyms
;
281 /***********************************************************************
283 ***********************************************************************/
287 /* This is a function useful for recording debugging information about
288 the sequence of occurrences in this file. */
296 struct record event_record
[100];
298 int event_record_index
;
300 record_event (locus
, type
)
304 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
305 event_record_index
= 0;
307 event_record
[event_record_index
].locus
= locus
;
308 event_record
[event_record_index
].type
= type
;
309 event_record_index
++;
316 XChangeGC (void * ignore
, XGCValues
* gc
, unsigned long mask
,
319 if (mask
& GCForeground
)
320 gc
->foreground
= xgcv
->foreground
;
321 if (mask
& GCBackground
)
322 gc
->background
= xgcv
->background
;
324 gc
->font
= xgcv
->font
;
327 XGCValues
*XCreateGC (void * ignore
, Window window
, unsigned long mask
,
330 XGCValues
*gc
= (XGCValues
*) xmalloc (sizeof (XGCValues
));
331 bzero (gc
, sizeof (XGCValues
));
333 XChangeGC (ignore
, gc
, mask
, xgcv
);
339 XGetGCValues (void* ignore
, XGCValues
*gc
,
340 unsigned long mask
, XGCValues
*xgcv
)
342 XChangeGC (ignore
, xgcv
, mask
, gc
);
346 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
350 HRGN clip_region
= CreateRectRgnIndirect (rect
);
351 SelectClipRgn (hdc
, clip_region
);
352 DeleteObject (clip_region
);
355 SelectClipRgn (hdc
, NULL
);
359 /* Draw a hollow rectangle at the specified position. */
361 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
362 int width
, int height
)
367 hb
= CreateSolidBrush (gc
->background
);
368 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
369 oldhb
= SelectObject (hdc
, hb
);
370 oldhp
= SelectObject (hdc
, hp
);
372 Rectangle (hdc
, x
, y
, x
+ width
, y
+ height
);
374 SelectObject (hdc
, oldhb
);
375 SelectObject (hdc
, oldhp
);
380 /* Draw a filled rectangle at the specified position. */
382 w32_fill_rect (f
, hdc
, pix
, lprect
)
390 hb
= CreateSolidBrush (pix
);
391 FillRect (hdc
, lprect
, hb
);
400 HDC hdc
= get_frame_dc (f
);
402 /* Under certain conditions, this can be called at startup with
403 a console frame pointer before the GUI frame is created. An HDC
404 of 0 indicates this. */
407 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
408 w32_clear_rect (f
, hdc
, &rect
);
411 release_frame_dc (f
, hdc
);
414 #define OPAQUE_FRAME 255
417 x_set_frame_alpha (f
)
420 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
422 double alpha_min
= 1.0;
425 HWND window
= FRAME_W32_WINDOW (f
);
427 /* Older versions of Windows do not support transparency. */
428 if (!pfnSetLayeredWindowAttributes
)
431 if (dpyinfo
->x_highlight_frame
== f
)
436 if (FLOATP (Vframe_alpha_lower_limit
))
437 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
438 else if (INTEGERP (Vframe_alpha_lower_limit
))
439 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
443 else if (alpha
> 1.0)
445 else if (alpha
< alpha_min
&& alpha_min
<= 1.0)
448 opac
= alpha
* OPAQUE_FRAME
;
450 ex_style
= GetWindowLong (window
, GWL_EXSTYLE
);
452 if (opac
== OPAQUE_FRAME
)
453 ex_style
&= ~WS_EX_LAYERED
;
455 ex_style
|= WS_EX_LAYERED
;
457 SetWindowLong (window
, GWL_EXSTYLE
, ex_style
);
459 if (opac
!= OPAQUE_FRAME
)
460 pfnSetLayeredWindowAttributes (window
, 0, opac
, LWA_ALPHA
);
464 x_display_pixel_height (dpyinfo
)
465 struct w32_display_info
*dpyinfo
;
467 HDC dc
= GetDC (NULL
);
468 int pixels
= GetDeviceCaps (dc
, VERTRES
);
469 ReleaseDC (NULL
, dc
);
474 x_display_pixel_width (dpyinfo
)
475 struct w32_display_info
*dpyinfo
;
477 HDC dc
= GetDC (NULL
);
478 int pixels
= GetDeviceCaps (dc
, HORZRES
);
479 ReleaseDC (NULL
, dc
);
484 /***********************************************************************
485 Starting and ending an update
486 ***********************************************************************/
488 /* Start an update of frame F. This function is installed as a hook
489 for update_begin, i.e. it is called when update_begin is called.
490 This function is called prior to calls to x_update_window_begin for
491 each window being updated. */
497 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
499 if (! FRAME_W32_P (f
))
502 /* Regenerate display palette before drawing if list of requested
503 colors has changed. */
504 if (display_info
->regen_palette
)
506 w32_regenerate_palette (f
);
507 display_info
->regen_palette
= FALSE
;
512 /* Start update of window W. Set the global variable updated_window
513 to the window being updated and set output_cursor to the cursor
517 x_update_window_begin (w
)
520 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
521 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
523 /* Hide the system caret during an update. */
524 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
526 SendMessage (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0);
530 set_output_cursor (&w
->cursor
);
534 if (f
== display_info
->mouse_face_mouse_frame
)
536 /* Don't do highlighting for mouse motion during the update. */
537 display_info
->mouse_face_defer
= 1;
539 /* If F needs to be redrawn, simply forget about any prior mouse
541 if (FRAME_GARBAGED_P (f
))
542 display_info
->mouse_face_window
= Qnil
;
544 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
545 their mouse_face_p flag set, which means that they are always
546 unequal to rows in a desired matrix which never have that
547 flag set. So, rows containing mouse-face glyphs are never
548 scrolled, and we don't have to switch the mouse highlight off
549 here to prevent it from being scrolled. */
551 /* Can we tell that this update does not affect the window
552 where the mouse highlight is? If so, no need to turn off.
553 Likewise, don't do anything if the frame is garbaged;
554 in that case, the frame's current matrix that we would use
555 is all wrong, and we will redisplay that line anyway. */
556 if (!NILP (display_info
->mouse_face_window
)
557 && w
== XWINDOW (display_info
->mouse_face_window
))
561 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
562 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
565 if (i
< w
->desired_matrix
->nrows
)
566 clear_mouse_face (display_info
);
574 /* Draw a vertical window border from (x,y0) to (x,y1) */
577 w32_draw_vertical_window_border (w
, x
, y0
, y1
)
581 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
591 hdc
= get_frame_dc (f
);
592 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
594 w32_fill_rect (f
, hdc
, face
->foreground
, &r
);
596 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
598 release_frame_dc (f
, hdc
);
602 /* End update of window W (which is equal to updated_window).
604 Draw vertical borders between horizontally adjacent windows, and
605 display W's cursor if CURSOR_ON_P is non-zero.
607 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
608 glyphs in mouse-face were overwritten. In that case we have to
609 make sure that the mouse-highlight is properly redrawn.
611 W may be a menu bar pseudo-window in case we don't have X toolkit
612 support. Such windows don't have a cursor, so don't display it
616 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
618 int cursor_on_p
, mouse_face_overwritten_p
;
620 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
622 if (!w
->pseudo_window_p
)
627 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
629 output_cursor
.x
, output_cursor
.y
);
631 if (draw_window_fringes (w
, 1))
632 x_draw_vertical_border (w
);
637 /* If a row with mouse-face was overwritten, arrange for
638 XTframe_up_to_date to redisplay the mouse highlight. */
639 if (mouse_face_overwritten_p
)
641 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
642 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
643 dpyinfo
->mouse_face_window
= Qnil
;
646 /* Unhide the caret. This won't actually show the cursor, unless it
647 was visible before the corresponding call to HideCaret in
648 x_update_window_begin. */
649 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
651 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
654 updated_window
= NULL
;
658 /* End update of frame F. This function is installed as a hook in
665 if (! FRAME_W32_P (f
))
668 /* Mouse highlight may be displayed again. */
669 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
673 /* This function is called from various places in xdisp.c whenever a
674 complete update has been performed. The global variable
675 updated_window is not available here. */
678 w32_frame_up_to_date (f
)
683 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
685 if (dpyinfo
->mouse_face_deferred_gc
686 || f
== dpyinfo
->mouse_face_mouse_frame
)
689 if (dpyinfo
->mouse_face_mouse_frame
)
690 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
691 dpyinfo
->mouse_face_mouse_x
,
692 dpyinfo
->mouse_face_mouse_y
);
693 dpyinfo
->mouse_face_deferred_gc
= 0;
700 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
701 arrow bitmaps, or clear the fringes if no bitmaps are required
702 before DESIRED_ROW is made current. The window being updated is
703 found in updated_window. This function is called from
704 update_window_line only if it is known that there are differences
705 between bitmaps to be drawn between current row and DESIRED_ROW. */
708 x_after_update_window_line (desired_row
)
709 struct glyph_row
*desired_row
;
711 struct window
*w
= updated_window
;
717 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
718 desired_row
->redraw_fringe_bitmaps_p
= 1;
720 /* When a window has disappeared, make sure that no rest of
721 full-width rows stays visible in the internal border. Could
722 check here if updated_window is the leftmost/rightmost window,
723 but I guess it's not worth doing since vertically split windows
724 are almost never used, internal border is rarely set, and the
725 overhead is very small. */
726 if (windows_or_buffers_changed
727 && desired_row
->full_width_p
728 && (f
= XFRAME (w
->frame
),
729 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
731 && (height
= desired_row
->visible_height
,
734 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
736 /* Internal border is drawn below the tool bar. */
737 if (WINDOWP (f
->tool_bar_window
)
738 && w
== XWINDOW (f
->tool_bar_window
))
743 HDC hdc
= get_frame_dc (f
);
744 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
745 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
747 release_frame_dc (f
, hdc
);
754 /* Draw the bitmap WHICH in one of the left or right fringes of
755 window W. ROW is the glyph row for which to display the bitmap; it
756 determines the vertical position at which the bitmap has to be
760 w32_draw_fringe_bitmap (w
, row
, p
)
762 struct glyph_row
*row
;
763 struct draw_fringe_bitmap_params
*p
;
765 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
767 struct face
*face
= p
->face
;
770 hdc
= get_frame_dc (f
);
774 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
776 /* If the fringe is adjacent to the left (right) scroll bar of a
777 leftmost (rightmost, respectively) window, then extend its
778 background to the gap between the fringe and the bar. */
779 if ((WINDOW_LEFTMOST_P (w
)
780 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
781 || (WINDOW_RIGHTMOST_P (w
)
782 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
784 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
788 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
789 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
790 * FRAME_COLUMN_WIDTH (f
));
794 /* Bitmap fills the fringe. */
795 if (left
+ width
== p
->x
)
796 bx
= left
+ sb_width
;
797 else if (p
->x
+ p
->wd
== left
)
801 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
803 nx
= width
- sb_width
;
804 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
806 ny
= row
->visible_height
;
811 if (left
+ width
== bx
)
813 bx
= left
+ sb_width
;
814 nx
+= width
- sb_width
;
816 else if (bx
+ nx
== left
)
817 nx
+= width
- sb_width
;
822 if (bx
>= 0 && nx
> 0)
823 w32_fill_area (f
, hdc
, face
->background
, bx
, by
, nx
, ny
);
826 /* Must clip because of partially visible lines. */
827 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
830 /* Adjust position of "bottom aligned" bitmap on partially
833 int oldVH
= row
->visible_height
;
834 row
->visible_height
= p
->h
;
835 row
->y
-= rowY
- p
->y
;
836 w32_clip_to_row (w
, row
, -1, hdc
);
838 row
->visible_height
= oldVH
;
841 w32_clip_to_row (w
, row
, -1, hdc
);
843 if (p
->which
&& p
->which
< max_fringe_bmp
)
845 HBITMAP pixmap
= fringe_bmp
[p
->which
];
849 compat_hdc
= CreateCompatibleDC (hdc
);
853 horig_obj
= SelectObject (compat_hdc
, pixmap
);
855 /* Paint overlays transparently. */
858 HBRUSH h_brush
, h_orig_brush
;
860 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
861 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
862 h_brush
= CreateSolidBrush (face
->foreground
);
863 h_orig_brush
= SelectObject (hdc
, h_brush
);
865 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
866 compat_hdc
, 0, p
->dh
,
868 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
869 compat_hdc
, 0, p
->dh
,
871 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
872 compat_hdc
, 0, p
->dh
,
875 SelectObject (hdc
, h_orig_brush
);
876 DeleteObject (h_brush
);
880 SetTextColor (hdc
, face
->background
);
881 SetBkColor (hdc
, (p
->cursor_p
882 ? f
->output_data
.w32
->cursor_pixel
883 : face
->foreground
));
885 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
886 compat_hdc
, 0, p
->dh
,
890 SelectObject (compat_hdc
, horig_obj
);
891 DeleteDC (compat_hdc
);
895 w32_set_clip_rectangle (hdc
, NULL
);
897 release_frame_dc (f
, hdc
);
901 w32_define_fringe_bitmap (which
, bits
, h
, wd
)
903 unsigned short *bits
;
906 if (which
>= max_fringe_bmp
)
908 int i
= max_fringe_bmp
;
909 max_fringe_bmp
= which
+ 20;
910 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
911 while (i
< max_fringe_bmp
)
915 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
919 w32_destroy_fringe_bitmap (which
)
922 if (which
>= max_fringe_bmp
)
925 if (fringe_bmp
[which
])
926 DeleteObject (fringe_bmp
[which
]);
927 fringe_bmp
[which
] = 0;
932 /* This is called when starting Emacs and when restarting after
933 suspend. When starting Emacs, no window is mapped. And nothing
934 must be done to Emacs's own window if it is suspended (though that
938 w32_set_terminal_modes (struct terminal
*term
)
942 /* This is called when exiting or suspending Emacs. Exiting will make
943 the W32 windows go away, and suspending requires no action. */
946 w32_reset_terminal_modes (struct terminal
*term
)
952 /***********************************************************************
954 ***********************************************************************/
956 /* Function prototypes of this page. */
958 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
959 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
960 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
962 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
963 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
964 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
965 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
966 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
967 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
968 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
969 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
970 static void w32_setup_relief_color
P_ ((struct frame
*, struct relief
*,
971 double, int, COLORREF
));
972 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
973 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
974 static void x_draw_image_relief
P_ ((struct glyph_string
*));
975 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
976 static void w32_draw_image_foreground_1
P_ ((struct glyph_string
*, HBITMAP
));
977 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
979 static void w32_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
980 int, int, int, int, int, int,
982 static void w32_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
983 int, int, int, RECT
*));
986 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
991 struct glyph_string
*s
;
993 if (s
->font
== FRAME_FONT (s
->f
)
994 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
995 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
997 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
1000 /* Cursor on non-default face: must merge. */
1004 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
1005 xgcv
.foreground
= s
->face
->background
;
1007 /* If the glyph would be invisible, try a different foreground. */
1008 if (xgcv
.foreground
== xgcv
.background
)
1009 xgcv
.foreground
= s
->face
->foreground
;
1010 if (xgcv
.foreground
== xgcv
.background
)
1011 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
1012 if (xgcv
.foreground
== xgcv
.background
)
1013 xgcv
.foreground
= s
->face
->foreground
;
1015 /* Make sure the cursor is distinct from text in this face. */
1016 if (xgcv
.background
== s
->face
->background
1017 && xgcv
.foreground
== s
->face
->foreground
)
1019 xgcv
.background
= s
->face
->foreground
;
1020 xgcv
.foreground
= s
->face
->background
;
1023 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1024 xgcv
.font
= s
->font
;
1025 mask
= GCForeground
| GCBackground
| GCFont
;
1027 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1028 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1031 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1032 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1034 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1039 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1042 x_set_mouse_face_gc (s
)
1043 struct glyph_string
*s
;
1048 /* What face has to be used last for the mouse face? */
1049 face_id
= FRAME_W32_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1050 face
= FACE_FROM_ID (s
->f
, face_id
);
1052 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1054 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1055 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1057 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1058 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1059 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1061 /* If font in this face is same as S->font, use it. */
1062 if (s
->font
== s
->face
->font
)
1063 s
->gc
= s
->face
->gc
;
1066 /* Otherwise construct scratch_cursor_gc with values from FACE
1071 xgcv
.background
= s
->face
->background
;
1072 xgcv
.foreground
= s
->face
->foreground
;
1073 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1074 xgcv
.font
= s
->font
;
1075 mask
= GCForeground
| GCBackground
| GCFont
;
1077 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1078 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1081 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1082 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1084 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1087 xassert (s
->gc
!= 0);
1091 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1092 Faces to use in the mode line have already been computed when the
1093 matrix was built, so there isn't much to do, here. */
1096 x_set_mode_line_face_gc (s
)
1097 struct glyph_string
*s
;
1099 s
->gc
= s
->face
->gc
;
1103 /* Set S->gc of glyph string S for drawing that glyph string. Set
1104 S->stippled_p to a non-zero value if the face of S has a stipple
1108 x_set_glyph_string_gc (s
)
1109 struct glyph_string
*s
;
1111 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1113 if (s
->hl
== DRAW_NORMAL_TEXT
)
1115 s
->gc
= s
->face
->gc
;
1116 s
->stippled_p
= s
->face
->stipple
!= 0;
1118 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1120 x_set_mode_line_face_gc (s
);
1121 s
->stippled_p
= s
->face
->stipple
!= 0;
1123 else if (s
->hl
== DRAW_CURSOR
)
1125 x_set_cursor_gc (s
);
1128 else if (s
->hl
== DRAW_MOUSE_FACE
)
1130 x_set_mouse_face_gc (s
);
1131 s
->stippled_p
= s
->face
->stipple
!= 0;
1133 else if (s
->hl
== DRAW_IMAGE_RAISED
1134 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1136 s
->gc
= s
->face
->gc
;
1137 s
->stippled_p
= s
->face
->stipple
!= 0;
1141 s
->gc
= s
->face
->gc
;
1142 s
->stippled_p
= s
->face
->stipple
!= 0;
1145 /* GC must have been set. */
1146 xassert (s
->gc
!= 0);
1150 /* Set clipping for output of glyph string S. S may be part of a mode
1151 line or menu if we don't have X toolkit support. */
1154 x_set_glyph_string_clipping (s
)
1155 struct glyph_string
*s
;
1158 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1161 w32_set_clip_rectangle (s
->hdc
, r
);
1164 HRGN full_clip
, clip1
, clip2
;
1165 clip1
= CreateRectRgnIndirect (r
);
1166 clip2
= CreateRectRgnIndirect (r
+ 1);
1167 if (CombineRgn (full_clip
, clip1
, clip2
, RGN_OR
) != ERROR
)
1169 SelectClipRgn (s
->hdc
, full_clip
);
1171 DeleteObject (clip1
);
1172 DeleteObject (clip2
);
1173 DeleteObject (full_clip
);
1178 /* Set SRC's clipping for output of glyph string DST. This is called
1179 when we are drawing DST's left_overhang or right_overhang only in
1183 x_set_glyph_string_clipping_exactly (src
, dst
)
1184 struct glyph_string
*src
, *dst
;
1189 r
.right
= r
.left
+ src
->width
;
1191 r
.bottom
= r
.top
+ src
->height
;
1194 w32_set_clip_rectangle (dst
->hdc
, &r
);
1198 Compute left and right overhang of glyph string S. */
1201 w32_compute_glyph_string_overhangs (s
)
1202 struct glyph_string
*s
;
1205 && s
->first_glyph
->type
== CHAR_GLYPH
1206 && !s
->font_not_found_p
)
1208 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1209 struct font
*font
= s
->font
;
1210 struct font_metrics metrics
;
1213 for (i
= 0; i
< s
->nchars
; i
++)
1214 code
[i
] = s
->char2b
[i
];
1215 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1216 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1217 ? metrics
.rbearing
- metrics
.width
: 0);
1218 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1222 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1223 s
->left_overhang
= -s
->cmp
->lbearing
;
1227 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1230 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1231 struct glyph_string
*s
;
1239 /* Take clipping into account. */
1240 if (s
->gc
->clip_mask
== Rect
)
1242 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1243 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1244 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1245 - s
->gc
->clip_rectangle
.left
);
1246 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1247 - s
->gc
->clip_rectangle
.top
);
1250 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1255 /* Draw the background of glyph_string S. If S->background_filled_p
1256 is non-zero don't draw it. FORCE_P non-zero means draw the
1257 background even if it wouldn't be drawn normally. This is used
1258 when a string preceding S draws into the background of S, or S
1259 contains the first component of a composition. */
1262 x_draw_glyph_string_background (s
, force_p
)
1263 struct glyph_string
*s
;
1266 /* Nothing to do if background has already been drawn or if it
1267 shouldn't be drawn in the first place. */
1268 if (!s
->background_filled_p
)
1270 int box_line_width
= max (s
->face
->box_line_width
, 0);
1272 #if 0 /* TODO: stipple */
1275 /* Fill background with a stipple pattern. */
1276 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1277 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1278 s
->y
+ box_line_width
,
1279 s
->background_width
,
1280 s
->height
- 2 * box_line_width
);
1281 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1282 s
->background_filled_p
= 1;
1286 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1287 || s
->font_not_found_p
1288 || s
->extends_to_end_of_line_p
1291 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1292 s
->background_width
,
1293 s
->height
- 2 * box_line_width
);
1294 s
->background_filled_p
= 1;
1300 /* Draw the foreground of glyph string S. */
1303 x_draw_glyph_string_foreground (s
)
1304 struct glyph_string
*s
;
1308 /* If first glyph of S has a left box line, start drawing the text
1309 of S to the right of that box line. */
1310 if (s
->face
->box
!= FACE_NO_BOX
1311 && s
->first_glyph
->left_box_line_p
)
1312 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1316 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1317 SetBkColor (s
->hdc
, s
->gc
->background
);
1318 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1320 /* Draw characters of S as rectangles if S's font could not be
1322 if (s
->font_not_found_p
)
1324 for (i
= 0; i
< s
->nchars
; ++i
)
1326 struct glyph
*g
= s
->first_glyph
+ i
;
1328 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1330 x
+= g
->pixel_width
;
1335 struct font
*font
= s
->font
;
1336 int boff
= font
->baseline_offset
;
1340 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1342 if (font
->vertical_centering
)
1343 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1345 y
= s
->ybase
- boff
;
1347 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1348 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1350 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1351 if (s
->face
->overstrike
)
1352 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1354 SelectObject (s
->hdc
, old_font
);
1358 /* Draw the foreground of composite glyph string S. */
1361 x_draw_composite_glyph_string_foreground (s
)
1362 struct glyph_string
*s
;
1365 struct font
*font
= s
->font
;
1367 /* If first glyph of S has a left box line, start drawing the text
1368 of S to the right of that box line. */
1369 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1370 && s
->first_glyph
->left_box_line_p
)
1371 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1375 /* S is a glyph string for a composition. S->cmp_from is the index
1376 of the first character drawn for glyphs of this composition.
1377 S->cmp_from == 0 means we are drawing the very first character of
1378 this composition. */
1380 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1381 SetBkColor (s
->hdc
, s
->gc
->background
);
1382 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1384 /* Draw a rectangle for the composition if the font for the very
1385 first character of the composition could not be loaded. */
1386 if (s
->font_not_found_p
)
1388 if (s
->cmp_from
== 0)
1389 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1392 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1398 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1400 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1401 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1403 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1404 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1406 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1407 if (s
->face
->overstrike
)
1408 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1410 SelectObject (s
->hdc
, old_font
);
1414 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1420 old_font
= SelectObject (s
->hdc
, FONT_HANDLE (font
));
1422 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1424 glyph
= LGSTRING_GLYPH (gstring
, i
);
1425 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1426 width
+= LGLYPH_WIDTH (glyph
);
1429 int xoff
, yoff
, wadjust
;
1433 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1436 xoff
= LGLYPH_XOFF (glyph
);
1437 yoff
= LGLYPH_YOFF (glyph
);
1438 wadjust
= LGLYPH_WADJUST (glyph
);
1439 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1446 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1448 SelectObject (s
->hdc
, old_font
);
1453 /* Brightness beyond which a color won't have its highlight brightness
1456 Nominally, highlight colors for `3d' faces are calculated by
1457 brightening an object's color by a constant scale factor, but this
1458 doesn't yield good results for dark colors, so for colors who's
1459 brightness is less than this value (on a scale of 0-255) have to
1460 use an additional additive factor.
1462 The value here is set so that the default menu-bar/mode-line color
1463 (grey75) will not have its highlights changed at all. */
1464 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1467 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1468 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1469 If this produces the same color as COLOR, try a color where all RGB
1470 values have DELTA added. Return the allocated color in *COLOR.
1471 DISPLAY is the X display, CMAP is the colormap to operate on.
1472 Value is non-zero if successful. */
1475 w32_alloc_lighter_color (f
, color
, factor
, delta
)
1484 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1487 /* Change RGB values by specified FACTOR. Avoid overflow! */
1488 xassert (factor
>= 0);
1489 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1490 min (0xff, factor
* GetGValue (*color
)),
1491 min (0xff, factor
* GetBValue (*color
)));
1493 /* Calculate brightness of COLOR. */
1494 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1495 + GetBValue (*color
)) / 6;
1497 /* We only boost colors that are darker than
1498 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1499 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1500 /* Make an additive adjustment to NEW, because it's dark enough so
1501 that scaling by FACTOR alone isn't enough. */
1503 /* How far below the limit this color is (0 - 1, 1 being darker). */
1504 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1505 /* The additive adjustment. */
1506 int min_delta
= delta
* dimness
* factor
/ 2;
1509 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1510 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1511 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1513 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1514 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1515 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1519 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1520 max (0, min (0xff, delta
+ GetGValue (*color
))),
1521 max (0, min (0xff, delta
+ GetBValue (*color
))));
1523 /* TODO: Map to palette and retry with delta if same? */
1524 /* TODO: Free colors (if using palette)? */
1534 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1535 colors in COLORS. On W32, we no longer try to map colors to
1538 x_query_colors (f
, colors
, ncolors
)
1545 for (i
= 0; i
< ncolors
; i
++)
1547 DWORD pixel
= colors
[i
].pixel
;
1548 /* Convert to a 16 bit value in range 0 - 0xffff. */
1549 colors
[i
].red
= GetRValue (pixel
) * 257;
1550 colors
[i
].green
= GetGValue (pixel
) * 257;
1551 colors
[i
].blue
= GetBValue (pixel
) * 257;
1556 x_query_color (f
, color
)
1560 x_query_colors (f
, color
, 1);
1564 /* Set up the foreground color for drawing relief lines of glyph
1565 string S. RELIEF is a pointer to a struct relief containing the GC
1566 with which lines will be drawn. Use a color that is FACTOR or
1567 DELTA lighter or darker than the relief's background which is found
1568 in S->f->output_data.x->relief_background. If such a color cannot
1569 be allocated, use DEFAULT_PIXEL, instead. */
1572 w32_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
1574 struct relief
*relief
;
1577 COLORREF default_pixel
;
1580 struct w32_output
*di
= f
->output_data
.w32
;
1581 unsigned long mask
= GCForeground
;
1583 COLORREF background
= di
->relief_background
;
1584 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
1586 /* TODO: Free colors (if using palette)? */
1588 /* Allocate new color. */
1589 xgcv
.foreground
= default_pixel
;
1591 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1593 relief
->allocated_p
= 1;
1594 xgcv
.foreground
= relief
->pixel
= pixel
;
1597 if (relief
->gc
== 0)
1599 #if 0 /* TODO: stipple */
1600 xgcv
.stipple
= dpyinfo
->gray
;
1603 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1606 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1610 /* Set up colors for the relief lines around glyph string S. */
1613 x_setup_relief_colors (s
)
1614 struct glyph_string
*s
;
1616 struct w32_output
*di
= s
->f
->output_data
.w32
;
1619 if (s
->face
->use_box_color_for_shadows_p
)
1620 color
= s
->face
->box_color
;
1621 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1623 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1624 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1626 color
= s
->gc
->background
;
1628 if (di
->white_relief
.gc
== 0
1629 || color
!= di
->relief_background
)
1631 di
->relief_background
= color
;
1632 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1633 WHITE_PIX_DEFAULT (s
->f
));
1634 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1635 BLACK_PIX_DEFAULT (s
->f
));
1640 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1641 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1642 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1643 relief. LEFT_P non-zero means draw a relief on the left side of
1644 the rectangle. RIGHT_P non-zero means draw a relief on the right
1645 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1649 w32_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
1650 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
1652 int left_x
, top_y
, right_x
, bottom_y
, width
;
1653 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
1658 HDC hdc
= get_frame_dc (f
);
1661 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1663 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1665 w32_set_clip_rectangle (hdc
, clip_rect
);
1669 for (i
= 0; i
< width
; ++i
)
1670 w32_fill_area (f
, hdc
, gc
.foreground
,
1671 left_x
+ i
* left_p
, top_y
+ i
,
1672 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1676 for (i
= 0; i
< width
; ++i
)
1677 w32_fill_area (f
, hdc
, gc
.foreground
,
1678 left_x
+ i
, top_y
+ i
, 1,
1679 bottom_y
- top_y
- 2 * i
+ 1);
1682 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1684 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1688 for (i
= 0; i
< width
; ++i
)
1689 w32_fill_area (f
, hdc
, gc
.foreground
,
1690 left_x
+ i
* left_p
, bottom_y
- i
,
1691 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1695 for (i
= 0; i
< width
; ++i
)
1696 w32_fill_area (f
, hdc
, gc
.foreground
,
1697 right_x
- i
, top_y
+ i
+ 1, 1,
1698 bottom_y
- top_y
- 2 * i
- 1);
1700 w32_set_clip_rectangle (hdc
, NULL
);
1702 release_frame_dc (f
, hdc
);
1706 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1707 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1708 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1709 left side of the rectangle. RIGHT_P non-zero means draw a line
1710 on the right side of the rectangle. CLIP_RECT is the clipping
1711 rectangle to use when drawing. */
1714 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1715 left_p
, right_p
, clip_rect
)
1716 struct glyph_string
*s
;
1717 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
1720 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1723 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1724 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1729 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1730 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1734 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1735 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1740 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1741 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1744 w32_set_clip_rectangle (s
->hdc
, NULL
);
1748 /* Draw a box around glyph string S. */
1751 x_draw_glyph_string_box (s
)
1752 struct glyph_string
*s
;
1754 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
1755 int left_p
, right_p
;
1756 struct glyph
*last_glyph
;
1759 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1760 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1761 : window_box_right (s
->w
, s
->area
));
1763 /* The glyph that may have a right box line. */
1764 last_glyph
= (s
->cmp
|| s
->img
1766 : s
->first_glyph
+ s
->nchars
- 1);
1768 width
= eabs (s
->face
->box_line_width
);
1769 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1771 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1773 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1775 bottom_y
= top_y
+ s
->height
- 1;
1777 left_p
= (s
->first_glyph
->left_box_line_p
1778 || (s
->hl
== DRAW_MOUSE_FACE
1780 || s
->prev
->hl
!= s
->hl
)));
1781 right_p
= (last_glyph
->right_box_line_p
1782 || (s
->hl
== DRAW_MOUSE_FACE
1784 || s
->next
->hl
!= s
->hl
)));
1786 get_glyph_string_clip_rect (s
, &clip_rect
);
1788 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1789 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1790 left_p
, right_p
, &clip_rect
);
1793 x_setup_relief_colors (s
);
1794 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1795 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1800 /* Draw foreground of image glyph string S. */
1803 x_draw_image_foreground (s
)
1804 struct glyph_string
*s
;
1807 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1809 /* If first glyph of S has a left box line, start drawing it to the
1810 right of that line. */
1811 if (s
->face
->box
!= FACE_NO_BOX
1812 && s
->first_glyph
->left_box_line_p
1814 x
+= eabs (s
->face
->box_line_width
);
1816 /* If there is a margin around the image, adjust x- and y-position
1818 if (s
->slice
.x
== 0)
1819 x
+= s
->img
->hmargin
;
1820 if (s
->slice
.y
== 0)
1821 y
+= s
->img
->vmargin
;
1827 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
1828 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1829 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
1830 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1831 SetBkColor (compat_hdc
, RGB (255, 255, 255));
1832 SetTextColor (s
->hdc
, RGB (0, 0, 0));
1833 x_set_glyph_string_clipping (s
);
1837 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
1838 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1840 SetTextColor (s
->hdc
, RGB (255, 255, 255));
1841 SetBkColor (s
->hdc
, RGB (0, 0, 0));
1843 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1844 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1845 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1846 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1847 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1848 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1850 SelectObject (mask_dc
, mask_orig_obj
);
1855 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1856 SetBkColor (s
->hdc
, s
->gc
->background
);
1858 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1859 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
1861 /* When the image has a mask, we can expect that at
1862 least part of a mouse highlight or a block cursor will
1863 be visible. If the image doesn't have a mask, make
1864 a block cursor visible by drawing a rectangle around
1865 the image. I believe it's looking better if we do
1866 nothing here for mouse-face. */
1867 if (s
->hl
== DRAW_CURSOR
)
1869 int r
= s
->img
->relief
;
1871 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
1872 s
->slice
.width
+ r
*2 - 1,
1873 s
->slice
.height
+ r
*2 - 1);
1877 w32_set_clip_rectangle (s
->hdc
, NULL
);
1878 SelectObject (s
->hdc
, orig_brush
);
1879 DeleteObject (fg_brush
);
1880 SelectObject (compat_hdc
, orig_obj
);
1881 DeleteDC (compat_hdc
);
1884 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
1885 s
->slice
.width
- 1, s
->slice
.height
- 1);
1887 RestoreDC (s
->hdc
,-1);
1891 /* Draw a relief around the image glyph string S. */
1894 x_draw_image_relief (s
)
1895 struct glyph_string
*s
;
1897 int x0
, y0
, x1
, y1
, thick
, raised_p
;
1900 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1902 /* If first glyph of S has a left box line, start drawing it to the
1903 right of that line. */
1904 if (s
->face
->box
!= FACE_NO_BOX
1905 && s
->first_glyph
->left_box_line_p
1907 x
+= eabs (s
->face
->box_line_width
);
1909 /* If there is a margin around the image, adjust x- and y-position
1911 if (s
->slice
.x
== 0)
1912 x
+= s
->img
->hmargin
;
1913 if (s
->slice
.y
== 0)
1914 y
+= s
->img
->vmargin
;
1916 if (s
->hl
== DRAW_IMAGE_SUNKEN
1917 || s
->hl
== DRAW_IMAGE_RAISED
)
1919 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
1920 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
1924 thick
= eabs (s
->img
->relief
);
1925 raised_p
= s
->img
->relief
> 0;
1930 x1
= x
+ s
->slice
.width
+ thick
- 1;
1931 y1
= y
+ s
->slice
.height
+ thick
- 1;
1933 x_setup_relief_colors (s
);
1934 get_glyph_string_clip_rect (s
, &r
);
1935 w32_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
1937 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
1939 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
1944 /* Draw the foreground of image glyph string S to PIXMAP. */
1947 w32_draw_image_foreground_1 (s
, pixmap
)
1948 struct glyph_string
*s
;
1951 HDC hdc
= CreateCompatibleDC (s
->hdc
);
1952 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
1954 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1956 /* If first glyph of S has a left box line, start drawing it to the
1957 right of that line. */
1958 if (s
->face
->box
!= FACE_NO_BOX
1959 && s
->first_glyph
->left_box_line_p
1961 x
+= eabs (s
->face
->box_line_width
);
1963 /* If there is a margin around the image, adjust x- and y-position
1965 if (s
->slice
.x
== 0)
1966 x
+= s
->img
->hmargin
;
1967 if (s
->slice
.y
== 0)
1968 y
+= s
->img
->vmargin
;
1972 HDC compat_hdc
= CreateCompatibleDC (hdc
);
1973 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
1974 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
1975 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
1979 HDC mask_dc
= CreateCompatibleDC (hdc
);
1980 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
1982 SetTextColor (hdc
, RGB (0, 0, 0));
1983 SetBkColor (hdc
, RGB (255, 255, 255));
1984 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1985 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1986 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1987 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
1988 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
1989 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
1991 SelectObject (mask_dc
, mask_orig_obj
);
1996 SetTextColor (hdc
, s
->gc
->foreground
);
1997 SetBkColor (hdc
, s
->gc
->background
);
1999 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2000 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2002 /* When the image has a mask, we can expect that at
2003 least part of a mouse highlight or a block cursor will
2004 be visible. If the image doesn't have a mask, make
2005 a block cursor visible by drawing a rectangle around
2006 the image. I believe it's looking better if we do
2007 nothing here for mouse-face. */
2008 if (s
->hl
== DRAW_CURSOR
)
2010 int r
= s
->img
->relief
;
2012 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2013 s
->slice
.width
+ r
*2 - 1,
2014 s
->slice
.height
+ r
*2 - 1);
2018 SelectObject (hdc
, orig_brush
);
2019 DeleteObject (fg_brush
);
2020 SelectObject (compat_hdc
, orig_obj
);
2021 DeleteDC (compat_hdc
);
2024 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2025 s
->slice
.width
- 1, s
->slice
.height
- 1);
2027 SelectObject (hdc
, orig_hdc_obj
);
2032 /* Draw part of the background of glyph string S. X, Y, W, and H
2033 give the rectangle to draw. */
2036 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
2037 struct glyph_string
*s
;
2040 #if 0 /* TODO: stipple */
2043 /* Fill background with a stipple pattern. */
2044 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2045 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2046 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2050 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2054 /* Draw image glyph string S.
2057 s->x +-------------------------
2060 | +-------------------------
2063 | | +-------------------
2069 x_draw_image_glyph_string (s
)
2070 struct glyph_string
*s
;
2073 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2074 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2078 height
= s
->height
- 2 * box_line_vwidth
;
2080 /* Fill background with face under the image. Do it only if row is
2081 taller than image or if image has a clip mask to reduce
2083 s
->stippled_p
= s
->face
->stipple
!= 0;
2084 if (height
> s
->slice
.height
2088 || s
->img
->pixmap
== 0
2089 || s
->width
!= s
->background_width
)
2092 if (s
->first_glyph
->left_box_line_p
2094 x
+= box_line_hwidth
;
2097 if (s
->slice
.y
== 0)
2098 y
+= box_line_vwidth
;
2100 #if 0 /* TODO: figure out if we need to do this on Windows. */
2103 /* Create a pixmap as large as the glyph string. Fill it
2104 with the background color. Copy the image to it, using
2105 its mask. Copy the temporary pixmap to the display. */
2106 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2107 int depth
= DefaultDepthOfScreen (screen
);
2109 /* Create a pixmap as large as the glyph string. */
2110 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2111 s
->background_width
,
2114 /* Don't clip in the following because we're working on the
2116 XSetClipMask (s
->display
, s
->gc
, None
);
2118 /* Fill the pixmap with the background color/stipple. */
2121 /* Fill background with a stipple pattern. */
2122 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2123 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2124 0, 0, s
->background_width
, s
->height
);
2125 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2130 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2132 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2133 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2134 0, 0, s
->background_width
, s
->height
);
2135 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2140 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2142 s
->background_filled_p
= 1;
2145 /* Draw the foreground. */
2148 w32_draw_image_foreground_1 (s
, pixmap
);
2149 x_set_glyph_string_clipping (s
);
2151 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2152 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2153 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2154 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2156 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2157 SetBkColor (s
->hdc
, s
->gc
->background
);
2158 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2159 compat_hdc
, 0, 0, SRCCOPY
);
2161 SelectObject (s
->hdc
, orig_brush
);
2162 DeleteObject (fg_brush
);
2163 SelectObject (compat_hdc
, orig_obj
);
2164 DeleteDC (compat_hdc
);
2166 DeleteObject (pixmap
);
2170 x_draw_image_foreground (s
);
2172 /* If we must draw a relief around the image, do it. */
2174 || s
->hl
== DRAW_IMAGE_RAISED
2175 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2176 x_draw_image_relief (s
);
2180 /* Draw stretch glyph string S. */
2183 x_draw_stretch_glyph_string (s
)
2184 struct glyph_string
*s
;
2186 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2188 if (s
->hl
== DRAW_CURSOR
2189 && !x_stretch_cursor_p
)
2191 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2192 as wide as the stretch glyph. */
2193 int width
, background_width
= s
->background_width
;
2194 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2198 background_width
-= left_x
- x
;
2201 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2204 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2206 /* Clear rest using the GC of the original non-cursor face. */
2207 if (width
< background_width
)
2209 XGCValues
*gc
= s
->face
->gc
;
2211 int w
= background_width
- width
, h
= s
->height
;
2216 if (s
->row
->mouse_face_p
2217 && cursor_in_mouse_face_p (s
->w
))
2219 x_set_mouse_face_gc (s
);
2225 get_glyph_string_clip_rect (s
, &r
);
2226 w32_set_clip_rectangle (hdc
, &r
);
2228 #if 0 /* TODO: stipple */
2229 if (s
->face
->stipple
)
2231 /* Fill background with a stipple pattern. */
2232 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2233 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2234 XSetFillStyle (s
->display
, gc
, FillSolid
);
2239 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2243 else if (!s
->background_filled_p
)
2245 int background_width
= s
->background_width
;
2246 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2248 /* Don't draw into left margin, fringe or scrollbar area
2249 except for header line and mode line. */
2250 if (x
< left_x
&& !s
->row
->mode_line_p
)
2252 background_width
-= left_x
- x
;
2255 if (background_width
> 0)
2256 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2259 s
->background_filled_p
= 1;
2263 /* Draw glyph string S. */
2266 x_draw_glyph_string (s
)
2267 struct glyph_string
*s
;
2269 int relief_drawn_p
= 0;
2271 /* If S draws into the background of its successor, draw the
2272 background of the successor first so that S can draw into it.
2273 This makes S->next use XDrawString instead of XDrawImageString. */
2274 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2277 struct glyph_string
*next
;
2278 for (width
= 0, next
= s
->next
;
2279 next
&& width
< s
->right_overhang
;
2280 width
+= next
->width
, next
= next
->next
)
2281 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2283 x_set_glyph_string_gc (next
);
2284 x_set_glyph_string_clipping (next
);
2285 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2286 x_draw_stretch_glyph_string (next
);
2288 x_draw_glyph_string_background (next
, 1);
2289 next
->num_clips
= 0;
2293 /* Set up S->gc, set clipping and draw S. */
2294 x_set_glyph_string_gc (s
);
2296 /* Draw relief (if any) in advance for char/composition so that the
2297 glyph string can be drawn over it. */
2298 if (!s
->for_overlaps
2299 && s
->face
->box
!= FACE_NO_BOX
2300 && (s
->first_glyph
->type
== CHAR_GLYPH
2301 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2304 x_set_glyph_string_clipping (s
);
2305 x_draw_glyph_string_background (s
, 1);
2306 x_draw_glyph_string_box (s
);
2307 x_set_glyph_string_clipping (s
);
2310 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2312 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2313 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2314 /* We must clip just this glyph. left_overhang part has already
2315 drawn when s->prev was drawn, and right_overhang part will be
2316 drawn later when s->next is drawn. */
2317 x_set_glyph_string_clipping_exactly (s
, s
);
2319 x_set_glyph_string_clipping (s
);
2321 switch (s
->first_glyph
->type
)
2324 x_draw_image_glyph_string (s
);
2328 x_draw_stretch_glyph_string (s
);
2332 if (s
->for_overlaps
)
2333 s
->background_filled_p
= 1;
2335 x_draw_glyph_string_background (s
, 0);
2336 x_draw_glyph_string_foreground (s
);
2339 case COMPOSITE_GLYPH
:
2340 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2341 && ! s
->first_glyph
->u
.cmp
.automatic
))
2342 s
->background_filled_p
= 1;
2344 x_draw_glyph_string_background (s
, 1);
2345 x_draw_composite_glyph_string_foreground (s
);
2352 if (!s
->for_overlaps
)
2354 /* Draw underline. */
2355 if (s
->face
->underline_p
)
2357 unsigned long thickness
, position
;
2360 if (s
->prev
&& s
->prev
->face
->underline_p
)
2362 /* We use the same underline style as the previous one. */
2363 thickness
= s
->prev
->underline_thickness
;
2364 position
= s
->prev
->underline_position
;
2368 /* Get the underline thickness. Default is 1 pixel. */
2369 if (s
->font
&& s
->font
->underline_thickness
> 0)
2370 thickness
= s
->font
->underline_thickness
;
2373 if (x_underline_at_descent_line
)
2374 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2377 /* Get the underline position. This is the recommended
2378 vertical offset in pixels from the baseline to the top of
2379 the underline. This is a signed value according to the
2380 specs, and its default is
2382 ROUND ((maximum_descent) / 2), with
2383 ROUND (x) = floor (x + 0.5) */
2385 if (x_use_underline_position_properties
2386 && s
->font
&& s
->font
->underline_position
>= 0)
2387 position
= s
->font
->underline_position
;
2389 position
= (s
->font
->descent
+ 1) / 2;
2391 position
= max (position
, underline_minimum_offset
);
2393 /* Check the sanity of thickness and position. We should
2394 avoid drawing underline out of the current line area. */
2395 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2396 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2397 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2398 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2399 s
->underline_thickness
= thickness
;
2400 s
->underline_position
=position
;
2401 y
= s
->ybase
+ position
;
2402 if (s
->face
->underline_defaulted_p
)
2404 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2405 y
, s
->background_width
, 1);
2409 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2410 y
, s
->background_width
, 1);
2413 /* Draw overline. */
2414 if (s
->face
->overline_p
)
2416 unsigned long dy
= 0, h
= 1;
2418 if (s
->face
->overline_color_defaulted_p
)
2420 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2421 s
->y
+ dy
, s
->background_width
, h
);
2425 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2426 s
->y
+ dy
, s
->background_width
, h
);
2430 /* Draw strike-through. */
2431 if (s
->face
->strike_through_p
2432 && !FONT_TEXTMETRIC(s
->font
).tmStruckOut
)
2434 unsigned long h
= 1;
2435 unsigned long dy
= (s
->height
- h
) / 2;
2437 if (s
->face
->strike_through_color_defaulted_p
)
2439 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2444 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2445 s
->y
+ dy
, s
->width
, h
);
2449 /* Draw relief if not yet drawn. */
2450 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2451 x_draw_glyph_string_box (s
);
2455 struct glyph_string
*prev
;
2457 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2458 if (prev
->hl
!= s
->hl
2459 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2461 /* As prev was drawn while clipped to its own area, we
2462 must draw the right_overhang part using s->hl now. */
2463 enum draw_glyphs_face save
= prev
->hl
;
2466 x_set_glyph_string_gc (prev
);
2467 x_set_glyph_string_clipping_exactly (s
, prev
);
2468 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2469 x_draw_glyph_string_foreground (prev
);
2471 x_draw_composite_glyph_string_foreground (prev
);
2472 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2474 prev
->num_clips
= 0;
2480 struct glyph_string
*next
;
2482 for (next
= s
->next
; next
; next
= next
->next
)
2483 if (next
->hl
!= s
->hl
2484 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2486 /* As next will be drawn while clipped to its own area,
2487 we must draw the left_overhang part using s->hl now. */
2488 enum draw_glyphs_face save
= next
->hl
;
2491 x_set_glyph_string_gc (next
);
2492 x_set_glyph_string_clipping_exactly (s
, next
);
2493 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2494 x_draw_glyph_string_foreground (next
);
2496 x_draw_composite_glyph_string_foreground (next
);
2497 w32_set_clip_rectangle (next
->hdc
, NULL
);
2499 next
->num_clips
= 0;
2504 /* Reset clipping. */
2505 w32_set_clip_rectangle (s
->hdc
, NULL
);
2510 /* Shift display to make room for inserted glyphs. */
2513 w32_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
2515 int x
, y
, width
, height
, shift_by
;
2519 hdc
= get_frame_dc (f
);
2520 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2521 hdc
, x
, y
, SRCCOPY
);
2523 release_frame_dc (f
, hdc
);
2527 /* Delete N glyphs at the nominal cursor position. Not implemented
2531 x_delete_glyphs (f
, n
)
2535 if (! FRAME_W32_P (f
))
2542 /* Clear entire frame. If updating_frame is non-null, clear that
2543 frame. Otherwise clear the selected frame. */
2546 x_clear_frame (struct frame
*f
)
2548 if (! FRAME_W32_P (f
))
2551 /* Clearing the frame will erase any cursor, so mark them all as no
2553 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2554 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2555 output_cursor
.x
= -1;
2557 /* We don't set the output cursor here because there will always
2558 follow an explicit cursor_to. */
2561 w32_clear_window (f
);
2563 /* We have to clear the scroll bars, too. If we have changed
2564 colors or something like that, then they should be notified. */
2565 x_scroll_bar_clear (f
);
2571 /* Make audible bell. */
2574 w32_ring_bell (struct frame
*f
)
2578 if (FRAME_W32_P (f
) && visible_bell
)
2581 HWND hwnd
= FRAME_W32_WINDOW (f
);
2583 for (i
= 0; i
< 5; i
++)
2585 FlashWindow (hwnd
, TRUE
);
2588 FlashWindow (hwnd
, FALSE
);
2591 w32_sys_ring_bell (f
);
2597 /* Specify how many text lines, from the top of the window,
2598 should be affected by insert-lines and delete-lines operations.
2599 This, and those operations, are used only within an update
2600 that is bounded by calls to x_update_begin and x_update_end. */
2603 w32_set_terminal_window (n
)
2606 /* This function intentionally left blank. */
2610 /***********************************************************************
2612 ***********************************************************************/
2614 /* Perform an insert-lines or delete-lines operation, inserting N
2615 lines or deleting -N lines at vertical position VPOS. */
2618 x_ins_del_lines (f
, vpos
, n
)
2622 if (! FRAME_W32_P (f
))
2629 /* Scroll part of the display as described by RUN. */
2632 x_scroll_run (w
, run
)
2636 struct frame
*f
= XFRAME (w
->frame
);
2637 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2638 HWND hwnd
= FRAME_W32_WINDOW (f
);
2641 /* Get frame-relative bounding box of the text display area of W,
2642 without mode lines. Include in this box the left and right
2644 window_box (w
, -1, &x
, &y
, &width
, &height
);
2646 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2647 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2648 bottom_y
= y
+ height
;
2652 /* Scrolling up. Make sure we don't copy part of the mode
2653 line at the bottom. */
2654 if (from_y
+ run
->height
> bottom_y
)
2655 height
= bottom_y
- from_y
;
2657 height
= run
->height
;
2658 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2662 /* Scolling down. Make sure we don't copy over the mode line.
2664 if (to_y
+ run
->height
> bottom_y
)
2665 height
= bottom_y
- to_y
;
2667 height
= run
->height
;
2668 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2673 /* Cursor off. Will be switched on again in x_update_window_end. */
2680 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2681 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2683 from
.left
= to
.left
= x
;
2684 from
.right
= to
.right
= x
+ width
;
2686 from
.bottom
= from_y
+ height
;
2688 to
.bottom
= bottom_y
;
2690 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2691 NULL
, SW_INVALIDATE
);
2693 /* Combine this with what we expect to be dirty. This covers the
2694 case where not all of the region we expect is actually dirty. */
2695 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2697 /* If the dirty region is not what we expected, redraw the entire frame. */
2698 if (!EqualRgn (combined
, expect_dirty
))
2699 SET_FRAME_GARBAGED (f
);
2701 DeleteObject (dirty
);
2702 DeleteObject (combined
);
2706 DeleteObject (expect_dirty
);
2711 /***********************************************************************
2713 ***********************************************************************/
2719 x_update_cursor (f
, 1);
2720 x_set_frame_alpha (f
);
2724 frame_unhighlight (f
)
2727 x_update_cursor (f
, 1);
2728 x_set_frame_alpha (f
);
2731 /* The focus has changed. Update the frames as necessary to reflect
2732 the new situation. Note that we can't change the selected frame
2733 here, because the Lisp code we are interrupting might become confused.
2734 Each event gets marked with the frame in which it occurred, so the
2735 Lisp code can tell when the switch took place by examining the events. */
2738 x_new_focus_frame (dpyinfo
, frame
)
2739 struct w32_display_info
*dpyinfo
;
2740 struct frame
*frame
;
2742 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2744 if (frame
!= dpyinfo
->w32_focus_frame
)
2746 /* Set this before calling other routines, so that they see
2747 the correct value of w32_focus_frame. */
2748 dpyinfo
->w32_focus_frame
= frame
;
2750 if (old_focus
&& old_focus
->auto_lower
)
2751 x_lower_frame (old_focus
);
2753 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2754 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2756 pending_autoraise_frame
= 0;
2759 x_frame_rehighlight (dpyinfo
);
2763 /* Handle FocusIn and FocusOut state changes for FRAME.
2764 If FRAME has focus and there exists more than one frame, puts
2765 a FOCUS_IN_EVENT into *BUFP. */
2768 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
)
2771 struct w32_display_info
*dpyinfo
;
2772 struct frame
*frame
;
2773 struct input_event
*bufp
;
2775 if (type
== WM_SETFOCUS
)
2777 if (dpyinfo
->w32_focus_event_frame
!= frame
)
2779 x_new_focus_frame (dpyinfo
, frame
);
2780 dpyinfo
->w32_focus_event_frame
= frame
;
2782 /* Don't stop displaying the initial startup message
2783 for a switch-frame event we don't need. */
2784 if (NILP (Vterminal_frame
)
2785 && CONSP (Vframe_list
)
2786 && !NILP (XCDR (Vframe_list
)))
2788 bufp
->kind
= FOCUS_IN_EVENT
;
2789 XSETFRAME (bufp
->frame_or_window
, frame
);
2793 frame
->output_data
.x
->focus_state
|= state
;
2795 /* TODO: IME focus? */
2797 else if (type
== WM_KILLFOCUS
)
2799 frame
->output_data
.x
->focus_state
&= ~state
;
2801 if (dpyinfo
->w32_focus_event_frame
== frame
)
2803 dpyinfo
->w32_focus_event_frame
= 0;
2804 x_new_focus_frame (dpyinfo
, 0);
2807 /* TODO: IME focus? */
2812 /* The focus may have changed. Figure out if it is a real focus change,
2813 by checking both FocusIn/Out and Enter/LeaveNotify events.
2815 Returns FOCUS_IN_EVENT event in *BUFP. */
2818 w32_detect_focus_change (dpyinfo
, event
, bufp
)
2819 struct w32_display_info
*dpyinfo
;
2821 struct input_event
*bufp
;
2823 struct frame
*frame
;
2825 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
2829 /* On w32, this is only called from focus events, so no switch needed. */
2830 x_focus_changed (event
->msg
.message
,
2831 (event
->msg
.message
== WM_KILLFOCUS
?
2832 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
2833 dpyinfo
, frame
, bufp
);
2837 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2840 x_mouse_leave (dpyinfo
)
2841 struct w32_display_info
*dpyinfo
;
2843 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2846 /* The focus has changed, or we have redirected a frame's focus to
2847 another frame (this happens when a frame uses a surrogate
2848 mini-buffer frame). Shift the highlight as appropriate.
2850 The FRAME argument doesn't necessarily have anything to do with which
2851 frame is being highlighted or un-highlighted; we only use it to find
2852 the appropriate X display info. */
2855 w32_frame_rehighlight (frame
)
2856 struct frame
*frame
;
2858 if (! FRAME_W32_P (frame
))
2860 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
2864 x_frame_rehighlight (dpyinfo
)
2865 struct w32_display_info
*dpyinfo
;
2867 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2869 if (dpyinfo
->w32_focus_frame
)
2871 dpyinfo
->x_highlight_frame
2872 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2873 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2874 : dpyinfo
->w32_focus_frame
);
2875 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
2877 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
2878 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
2882 dpyinfo
->x_highlight_frame
= 0;
2884 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
2887 frame_unhighlight (old_highlight
);
2888 if (dpyinfo
->x_highlight_frame
)
2889 frame_highlight (dpyinfo
->x_highlight_frame
);
2893 /* Keyboard processing - modifier keys, etc. */
2895 /* Convert a keysym to its name. */
2898 x_get_keysym_name (keysym
)
2901 /* Make static so we can always return it */
2902 static char value
[100];
2905 GetKeyNameText (keysym
, value
, 100);
2913 /* Mouse clicks and mouse movement. Rah. */
2915 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2916 the state in PUP. XBUTTON provides extra information for extended mouse
2917 button messages. Returns FALSE if unable to parse the message. */
2919 parse_button (message
, xbutton
, pbutton
, pup
)
2930 case WM_LBUTTONDOWN
:
2938 case WM_MBUTTONDOWN
:
2939 if (NILP (Vw32_swap_mouse_buttons
))
2946 if (NILP (Vw32_swap_mouse_buttons
))
2952 case WM_RBUTTONDOWN
:
2953 if (NILP (Vw32_swap_mouse_buttons
))
2960 if (NILP (Vw32_swap_mouse_buttons
))
2966 case WM_XBUTTONDOWN
:
2967 button
= xbutton
+ 2;
2971 button
= xbutton
+ 2;
2979 if (pbutton
) *pbutton
= button
;
2985 /* Prepare a mouse-event in *RESULT for placement in the input queue.
2987 If the event is a button press, then note that we have grabbed
2991 construct_mouse_click (result
, msg
, f
)
2992 struct input_event
*result
;
2999 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3002 /* Make the event type NO_EVENT; we'll change that when we decide
3004 result
->kind
= MOUSE_CLICK_EVENT
;
3005 result
->code
= button
;
3006 result
->timestamp
= msg
->msg
.time
;
3007 result
->modifiers
= (msg
->dwModifiers
3012 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3013 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3014 XSETFRAME (result
->frame_or_window
, f
);
3020 construct_mouse_wheel (result
, msg
, f
)
3021 struct input_event
*result
;
3028 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3031 result
->timestamp
= msg
->msg
.time
;
3033 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3034 forward, away from the user (up); a negative value indicates that
3035 the wheel was rotated backward, toward the user (down). */
3036 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3038 /* The up and down modifiers indicate if the wheel was rotated up or
3039 down based on WHEEL_DELTA value. */
3040 result
->modifiers
= (msg
->dwModifiers
3041 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3043 /* With multiple monitors, we can legitimately get negative
3044 coordinates, so cast to short to interpret them correctly. */
3045 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3046 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3047 ScreenToClient (msg
->msg
.hwnd
, &p
);
3048 XSETINT (result
->x
, p
.x
);
3049 XSETINT (result
->y
, p
.y
);
3050 XSETFRAME (result
->frame_or_window
, f
);
3056 construct_drag_n_drop (result
, msg
, f
)
3057 struct input_event
*result
;
3069 result
->kind
= DRAG_N_DROP_EVENT
;
3071 result
->timestamp
= msg
->msg
.time
;
3072 result
->modifiers
= msg
->dwModifiers
;
3074 hdrop
= (HDROP
) msg
->msg
.wParam
;
3075 DragQueryPoint (hdrop
, &p
);
3078 p
.x
= LOWORD (msg
->msg
.lParam
);
3079 p
.y
= HIWORD (msg
->msg
.lParam
);
3080 ScreenToClient (msg
->msg
.hwnd
, &p
);
3083 XSETINT (result
->x
, p
.x
);
3084 XSETINT (result
->y
, p
.y
);
3086 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3089 for (i
= 0; i
< num_files
; i
++)
3091 len
= DragQueryFile (hdrop
, i
, NULL
, 0);
3094 name
= alloca (len
+ 1);
3095 DragQueryFile (hdrop
, i
, name
, len
+ 1);
3096 files
= Fcons (DECODE_FILE (build_string (name
)), files
);
3101 XSETFRAME (frame
, f
);
3102 result
->frame_or_window
= frame
;
3103 result
->arg
= files
;
3108 /* Function to report a mouse movement to the mainstream Emacs code.
3109 The input handler calls this.
3111 We have received a mouse movement event, which is given in *event.
3112 If the mouse is over a different glyph than it was last time, tell
3113 the mainstream emacs code by setting mouse_moved. If not, ask for
3114 another motion event, so we can check again the next time it moves. */
3116 static MSG last_mouse_motion_event
;
3117 static Lisp_Object last_mouse_motion_frame
;
3120 note_mouse_movement (frame
, msg
)
3124 int mouse_x
= LOWORD (msg
->lParam
);
3125 int mouse_y
= HIWORD (msg
->lParam
);
3127 last_mouse_movement_time
= msg
->time
;
3128 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
3129 XSETFRAME (last_mouse_motion_frame
, frame
);
3131 if (!FRAME_X_OUTPUT (frame
))
3134 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3136 frame
->mouse_moved
= 1;
3137 last_mouse_scroll_bar
= Qnil
;
3138 note_mouse_highlight (frame
, -1, -1);
3139 last_mouse_glyph_frame
= 0;
3143 /* Has the mouse moved off the glyph it was on at the last sighting? */
3144 if (frame
!= last_mouse_glyph_frame
3145 || mouse_x
< last_mouse_glyph
.left
3146 || mouse_x
>= last_mouse_glyph
.right
3147 || mouse_y
< last_mouse_glyph
.top
3148 || mouse_y
>= last_mouse_glyph
.bottom
)
3150 frame
->mouse_moved
= 1;
3151 last_mouse_scroll_bar
= Qnil
;
3152 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3153 /* Remember the mouse position here, as w32_mouse_position only
3154 gets called when mouse tracking is enabled but we also need
3155 to keep track of the mouse for help_echo and highlighting at
3157 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, &last_mouse_glyph
);
3158 last_mouse_glyph_frame
= frame
;
3166 /************************************************************************
3168 ************************************************************************/
3170 static struct scroll_bar
*x_window_to_scroll_bar ();
3171 static void x_scroll_bar_report_motion ();
3172 static void x_check_fullscreen
P_ ((struct frame
*));
3175 redo_mouse_highlight ()
3177 if (!NILP (last_mouse_motion_frame
)
3178 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3179 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3180 LOWORD (last_mouse_motion_event
.lParam
),
3181 HIWORD (last_mouse_motion_event
.lParam
));
3185 w32_define_cursor (window
, cursor
)
3189 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3191 /* Return the current position of the mouse.
3192 *fp should be a frame which indicates which display to ask about.
3194 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3195 and *part to the frame, window, and scroll bar part that the mouse
3196 is over. Set *x and *y to the portion and whole of the mouse's
3197 position on the scroll bar.
3199 If the mouse movement started elsewhere, set *fp to the frame the
3200 mouse is on, *bar_window to nil, and *x and *y to the character cell
3203 Set *time to the server time-stamp for the time at which the mouse
3204 was at this position.
3206 Don't store anything if we don't have a valid set of values to report.
3208 This clears the mouse_moved flag, so we can wait for the next mouse
3212 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3215 Lisp_Object
*bar_window
;
3216 enum scroll_bar_part
*part
;
3218 unsigned long *time
;
3224 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3225 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3230 Lisp_Object frame
, tail
;
3232 /* Clear the mouse-moved flag for every frame on this display. */
3233 FOR_EACH_FRAME (tail
, frame
)
3234 XFRAME (frame
)->mouse_moved
= 0;
3236 last_mouse_scroll_bar
= Qnil
;
3240 /* Now we have a position on the root; find the innermost window
3241 containing the pointer. */
3243 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3244 && FRAME_LIVE_P (last_mouse_frame
))
3246 /* If mouse was grabbed on a frame, give coords for that frame
3247 even if the mouse is now outside it. */
3248 f1
= last_mouse_frame
;
3252 /* Is window under mouse one of our frames? */
3253 f1
= x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
3254 WindowFromPoint (pt
));
3257 /* If not, is it one of our scroll bars? */
3260 struct scroll_bar
*bar
3261 = x_window_to_scroll_bar (WindowFromPoint (pt
));
3265 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3269 if (f1
== 0 && insist
> 0)
3270 f1
= SELECTED_FRAME ();
3274 /* Ok, we found a frame. Store all the values.
3275 last_mouse_glyph is a rectangle used to reduce the
3276 generation of mouse events. To not miss any motion
3277 events, we must divide the frame into rectangles of the
3278 size of the smallest character that could be displayed
3279 on it, i.e. into the same rectangles that matrices on
3280 the frame are divided into. */
3282 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3283 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &last_mouse_glyph
);
3284 last_mouse_glyph_frame
= f1
;
3291 *time
= last_mouse_movement_time
;
3300 /***********************************************************************
3302 ***********************************************************************/
3304 /* Handle mouse button event on the tool-bar of frame F, at
3305 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
3309 w32_handle_tool_bar_click (f
, button_event
)
3311 struct input_event
*button_event
;
3313 int x
= XFASTINT (button_event
->x
);
3314 int y
= XFASTINT (button_event
->y
);
3316 if (button_event
->modifiers
& down_modifier
)
3317 handle_tool_bar_click (f
, x
, y
, 1, 0);
3319 handle_tool_bar_click (f
, x
, y
, 0,
3320 button_event
->modifiers
& ~up_modifier
);
3325 /***********************************************************************
3327 ***********************************************************************/
3329 /* Scroll bar support. */
3331 /* Given a window ID, find the struct scroll_bar which manages it.
3332 This can be called in GC, so we have to make sure to strip off mark
3335 static struct scroll_bar
*
3336 x_window_to_scroll_bar (window_id
)
3341 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3343 Lisp_Object frame
, bar
, condemned
;
3345 frame
= XCAR (tail
);
3346 /* All elements of Vframe_list should be frames. */
3347 if (! FRAMEP (frame
))
3350 /* Scan this frame's scroll bar list for a scroll bar with the
3352 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3353 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3354 /* This trick allows us to search both the ordinary and
3355 condemned scroll bar lists with one loop. */
3356 ! NILP (bar
) || (bar
= condemned
,
3359 bar
= XSCROLL_BAR (bar
)->next
)
3360 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
3361 return XSCROLL_BAR (bar
);
3369 /* Set the thumb size and position of scroll bar BAR. We are currently
3370 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3373 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
)
3374 struct scroll_bar
*bar
;
3375 int portion
, position
, whole
;
3377 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3378 /* We use the whole scroll-bar height in the calculations below, to
3379 avoid strange effects like scrolling backwards when just clicking
3380 on the handle (without moving it). */
3381 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
))
3382 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3383 int sb_page
, sb_pos
;
3384 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
3387 /* We used to change the nPage setting while dragging the handle,
3388 but that had very strange effects (such as scrolling backwards
3389 while dragging downwards).
3391 Now, we don't change the nPage setting while dragging unless we
3392 get near to the end of the buffer, in which case we often have to
3393 resize the handle to "go all the way". */
3399 si
.cbSize
= sizeof (si
);
3400 si
.fMask
= SIF_POS
| SIF_PAGE
;
3401 GetScrollInfo(w
, SB_CTL
, &si
);
3402 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3410 /* Position scroll bar at rock bottom if the bottom of the
3411 buffer is visible. This avoids shinking the thumb away
3412 to nothing if it is held at the bottom of the buffer. */
3413 if (position
+ portion
>= whole
&& !draggingp
)
3415 sb_page
= range
* (whole
- position
) / whole
;
3420 sb_pos
= position
* range
/ whole
;
3421 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3430 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3434 si
.cbSize
= sizeof (si
);
3435 si
.fMask
= SIF_PAGE
| SIF_POS
;
3439 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3445 /************************************************************************
3446 Scroll bars, general
3447 ************************************************************************/
3450 my_create_scrollbar (f
, bar
)
3452 struct scroll_bar
* bar
;
3454 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3455 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
3459 /*#define ATTACH_THREADS*/
3462 my_show_window (FRAME_PTR f
, HWND hwnd
, int how
)
3464 #ifndef ATTACH_THREADS
3465 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3466 (WPARAM
) hwnd
, (LPARAM
) how
);
3468 return ShowWindow (hwnd
, how
);
3473 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3474 int x
, int y
, int cx
, int cy
, UINT flags
)
3476 #ifndef ATTACH_THREADS
3478 pos
.hwndInsertAfter
= hwndAfter
;
3484 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
3486 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3491 my_set_focus (f
, hwnd
)
3495 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3500 my_set_foreground_window (hwnd
)
3503 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
3508 my_destroy_window (f
, hwnd
)
3512 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3516 /* Create a scroll bar and return the scroll bar vector for it. W is
3517 the Emacs window on which to create the scroll bar. TOP, LEFT,
3518 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
3521 static struct scroll_bar
*
3522 x_scroll_bar_create (w
, top
, left
, width
, height
)
3524 int top
, left
, width
, height
;
3526 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3529 struct scroll_bar
*bar
3530 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
3534 XSETWINDOW (bar
->window
, w
);
3535 XSETINT (bar
->top
, top
);
3536 XSETINT (bar
->left
, left
);
3537 XSETINT (bar
->width
, width
);
3538 XSETINT (bar
->height
, height
);
3539 XSETINT (bar
->start
, 0);
3540 XSETINT (bar
->end
, 0);
3541 bar
->dragging
= Qnil
;
3542 bar
->fringe_extended_p
= Qnil
;
3544 /* Requires geometry to be set before call to create the real window */
3546 hwnd
= my_create_scrollbar (f
, bar
);
3548 si
.cbSize
= sizeof (si
);
3551 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3552 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3556 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3558 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3560 /* Add bar to its frame's list of scroll bars. */
3561 bar
->next
= FRAME_SCROLL_BARS (f
);
3563 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
3564 if (! NILP (bar
->next
))
3565 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3573 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3577 x_scroll_bar_remove (bar
)
3578 struct scroll_bar
*bar
;
3580 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3584 /* Destroy the window. */
3585 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3587 /* Disassociate this scroll bar from its window. */
3588 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
3593 /* Set the handle of the vertical scroll bar for WINDOW to indicate
3594 that we are displaying PORTION characters out of a total of WHOLE
3595 characters, starting at POSITION. If WINDOW has no scroll bar,
3598 w32_set_vertical_scroll_bar (w
, portion
, whole
, position
)
3600 int portion
, whole
, position
;
3602 struct frame
*f
= XFRAME (w
->frame
);
3603 struct scroll_bar
*bar
;
3604 int top
, height
, left
, sb_left
, width
, sb_width
;
3605 int window_y
, window_height
;
3606 int fringe_extended_p
;
3608 /* Get window dimensions. */
3609 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
3611 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
3612 height
= window_height
;
3614 /* Compute the left edge of the scroll bar area. */
3615 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3617 /* Compute the width of the scroll bar which might be less than
3618 the width of the area reserved for the scroll bar. */
3619 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
3620 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
3624 /* Compute the left edge of the scroll bar. */
3625 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
3626 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
3628 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
3630 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
3631 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
3632 && WINDOW_LEFT_FRINGE_WIDTH (w
)
3633 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
3634 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
3636 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
3637 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
3638 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
3639 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
3641 /* Does the scroll bar exist yet? */
3642 if (NILP (w
->vertical_scroll_bar
))
3646 if (width
> 0 && height
> 0)
3648 hdc
= get_frame_dc (f
);
3649 if (fringe_extended_p
)
3650 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
3652 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3653 release_frame_dc (f
, hdc
);
3657 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
3661 /* It may just need to be moved and resized. */
3664 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3665 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3667 /* If already correctly positioned, do nothing. */
3668 if ( XINT (bar
->left
) == sb_left
3669 && XINT (bar
->top
) == top
3670 && XINT (bar
->width
) == sb_width
3671 && XINT (bar
->height
) == height
3672 && !NILP (bar
->fringe_extended_p
) == fringe_extended_p
)
3674 /* Redraw after clear_frame. */
3675 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3676 InvalidateRect (hwnd
, NULL
, FALSE
);
3684 if (width
&& height
)
3686 hdc
= get_frame_dc (f
);
3687 /* Since Windows scroll bars are smaller than the space reserved
3688 for them on the frame, we have to clear "under" them. */
3689 if (fringe_extended_p
)
3690 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
3692 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3693 release_frame_dc (f
, hdc
);
3695 /* Make sure scroll bar is "visible" before moving, to ensure the
3696 area of the parent window now exposed will be refreshed. */
3697 my_show_window (f
, hwnd
, SW_HIDE
);
3698 MoveWindow (hwnd
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
3699 top
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
3700 max (height
, 1), TRUE
);
3702 si
.cbSize
= sizeof (si
);
3703 si
.fMask
= SIF_RANGE
;
3705 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3706 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3708 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3710 my_show_window (f
, hwnd
, SW_NORMAL
);
3711 /* InvalidateRect (w, NULL, FALSE); */
3713 /* Remember new settings. */
3714 XSETINT (bar
->left
, sb_left
);
3715 XSETINT (bar
->top
, top
);
3716 XSETINT (bar
->width
, sb_width
);
3717 XSETINT (bar
->height
, height
);
3722 bar
->fringe_extended_p
= fringe_extended_p
? Qt
: Qnil
;
3724 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3726 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
3730 /* The following three hooks are used when we're doing a thorough
3731 redisplay of the frame. We don't explicitly know which scroll bars
3732 are going to be deleted, because keeping track of when windows go
3733 away is a real pain - "Can you say set-window-configuration, boys
3734 and girls?" Instead, we just assert at the beginning of redisplay
3735 that *all* scroll bars are to be removed, and then save a scroll bar
3736 from the fiery pit when we actually redisplay its window. */
3738 /* Arrange for all scroll bars on FRAME to be removed at the next call
3739 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
3740 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
3743 w32_condemn_scroll_bars (frame
)
3746 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
3747 while (! NILP (FRAME_SCROLL_BARS (frame
)))
3750 bar
= FRAME_SCROLL_BARS (frame
);
3751 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
3752 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
3753 XSCROLL_BAR (bar
)->prev
= Qnil
;
3754 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
3755 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
3756 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
3761 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
3762 Note that WINDOW isn't necessarily condemned at all. */
3765 w32_redeem_scroll_bar (window
)
3766 struct window
*window
;
3768 struct scroll_bar
*bar
;
3771 /* We can't redeem this window's scroll bar if it doesn't have one. */
3772 if (NILP (window
->vertical_scroll_bar
))
3775 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
3777 /* Unlink it from the condemned list. */
3778 f
= XFRAME (WINDOW_FRAME (window
));
3779 if (NILP (bar
->prev
))
3781 /* If the prev pointer is nil, it must be the first in one of
3783 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
3784 /* It's not condemned. Everything's fine. */
3786 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
3787 window
->vertical_scroll_bar
))
3788 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
3790 /* If its prev pointer is nil, it must be at the front of
3791 one or the other! */
3795 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
3797 if (! NILP (bar
->next
))
3798 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
3800 bar
->next
= FRAME_SCROLL_BARS (f
);
3802 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
3803 if (! NILP (bar
->next
))
3804 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3807 /* Remove all scroll bars on FRAME that haven't been saved since the
3808 last call to `*condemn_scroll_bars_hook'. */
3811 w32_judge_scroll_bars (f
)
3814 Lisp_Object bar
, next
;
3816 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
3818 /* Clear out the condemned list now so we won't try to process any
3819 more events on the hapless scroll bars. */
3820 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
3822 for (; ! NILP (bar
); bar
= next
)
3824 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
3826 x_scroll_bar_remove (b
);
3829 b
->next
= b
->prev
= Qnil
;
3832 /* Now there should be no references to the condemned scroll bars,
3833 and they should get garbage-collected. */
3836 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
3837 is set to something other than NO_EVENT, it is enqueued.
3839 This may be called from a signal handler, so we have to ignore GC
3843 w32_scroll_bar_handle_click (bar
, msg
, emacs_event
)
3844 struct scroll_bar
*bar
;
3846 struct input_event
*emacs_event
;
3848 if (! WINDOWP (bar
->window
))
3851 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
3852 emacs_event
->code
= 0;
3853 /* not really meaningful to distinguish up/down */
3854 emacs_event
->modifiers
= msg
->dwModifiers
;
3855 emacs_event
->frame_or_window
= bar
->window
;
3856 emacs_event
->arg
= Qnil
;
3857 emacs_event
->timestamp
= msg
->msg
.time
;
3860 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
3862 int dragging
= !NILP (bar
->dragging
);
3865 si
.cbSize
= sizeof (si
);
3868 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
3871 bar
->dragging
= Qnil
;
3874 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
3876 switch (LOWORD (msg
->msg
.wParam
))
3879 emacs_event
->part
= scroll_bar_down_arrow
;
3882 emacs_event
->part
= scroll_bar_up_arrow
;
3885 emacs_event
->part
= scroll_bar_above_handle
;
3888 emacs_event
->part
= scroll_bar_below_handle
;
3891 emacs_event
->part
= scroll_bar_handle
;
3895 emacs_event
->part
= scroll_bar_handle
;
3899 case SB_THUMBPOSITION
:
3900 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
3901 y
= HIWORD (msg
->msg
.wParam
);
3903 emacs_event
->part
= scroll_bar_handle
;
3905 /* "Silently" update current position. */
3909 si
.cbSize
= sizeof (si
);
3912 /* Remember apparent position (we actually lag behind the real
3913 position, so don't set that directly. */
3914 last_scroll_bar_drag_pos
= y
;
3916 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
3920 /* If this is the end of a drag sequence, then reset the scroll
3921 handle size to normal and do a final redraw. Otherwise do
3926 int start
= XINT (bar
->start
);
3927 int end
= XINT (bar
->end
);
3929 si
.cbSize
= sizeof (si
);
3930 si
.fMask
= SIF_PAGE
| SIF_POS
;
3931 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3932 si
.nPos
= last_scroll_bar_drag_pos
;
3933 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
3937 emacs_event
->kind
= NO_EVENT
;
3941 XSETINT (emacs_event
->x
, y
);
3942 XSETINT (emacs_event
->y
, top_range
);
3948 /* Return information to the user about the current position of the mouse
3949 on the scroll bar. */
3952 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
3954 Lisp_Object
*bar_window
;
3955 enum scroll_bar_part
*part
;
3957 unsigned long *time
;
3959 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
3960 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3961 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3963 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
3969 *bar_window
= bar
->window
;
3971 si
.cbSize
= sizeof (si
);
3972 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
3974 GetScrollInfo (w
, SB_CTL
, &si
);
3976 top_range
= si
.nMax
- si
.nPage
+ 1;
3978 switch (LOWORD (last_mouse_scroll_bar_pos
))
3980 case SB_THUMBPOSITION
:
3982 *part
= scroll_bar_handle
;
3983 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
3984 pos
= HIWORD (last_mouse_scroll_bar_pos
);
3987 *part
= scroll_bar_handle
;
3991 *part
= scroll_bar_handle
;
3996 XSETINT (*y
, top_range
);
3999 last_mouse_scroll_bar
= Qnil
;
4001 *time
= last_mouse_movement_time
;
4007 /* The screen has been cleared so we may have changed foreground or
4008 background colors, and the scroll bars may need to be redrawn.
4009 Clear out the scroll bars, and ask for expose events, so we can
4013 x_scroll_bar_clear (f
)
4018 /* We can have scroll bars even if this is 0,
4019 if we just turned off scroll bar mode.
4020 But in that case we should not clear them. */
4021 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4022 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4023 bar
= XSCROLL_BAR (bar
)->next
)
4025 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4026 HDC hdc
= GetDC (window
);
4029 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4030 arranges to refresh the scroll bar if hidden. */
4031 my_show_window (f
, window
, SW_HIDE
);
4033 GetClientRect (window
, &rect
);
4034 select_palette (f
, hdc
);
4035 w32_clear_rect (f
, hdc
, &rect
);
4036 deselect_palette (f
, hdc
);
4038 ReleaseDC (window
, hdc
);
4043 /* The main W32 event-reading loop - w32_read_socket. */
4045 /* Record the last 100 characters stored
4046 to help debug the loss-of-chars-during-GC problem. */
4048 static int temp_index
;
4049 static short temp_buffer
[100];
4051 /* Temporarily store lead byte of DBCS input sequences. */
4052 static char dbcs_lead
= 0;
4054 /* Read events coming from the W32 shell.
4055 This routine is called by the SIGIO handler.
4056 We return as soon as there are no more events to be read.
4058 We return the number of characters stored into the buffer,
4059 thus pretending to be `read'.
4061 EXPECTED is nonzero if the caller knows input is available.
4063 Some of these messages are reposted back to the message queue since the
4064 system calls the windows proc directly in a context where we cannot return
4065 the data nor can we guarantee the state we are in. So if we dispatch them
4066 we will get into an infinite loop. To prevent this from ever happening we
4067 will set a variable to indicate we are in the read_socket call and indicate
4068 which message we are processing since the windows proc gets called
4069 recursively with different messages by the system.
4073 w32_read_socket (sd
, expected
, hold_quit
)
4076 struct input_event
*hold_quit
;
4079 int check_visibility
= 0;
4082 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4084 if (interrupt_input_blocked
)
4086 interrupt_input_pending
= 1;
4090 interrupt_input_pending
= 0;
4093 /* So people can tell when we have read the available input. */
4094 input_signal_count
++;
4096 /* TODO: ghostscript integration. */
4097 while (get_next_msg (&msg
, FALSE
))
4099 struct input_event inev
;
4103 inev
.kind
= NO_EVENT
;
4106 switch (msg
.msg
.message
)
4109 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4113 if (msg
.rect
.right
== msg
.rect
.left
||
4114 msg
.rect
.bottom
== msg
.rect
.top
)
4116 /* We may get paint messages even though the client
4117 area is clipped - these are not expose events. */
4118 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4121 else if (f
->async_visible
!= 1)
4123 /* Definitely not obscured, so mark as visible. */
4124 f
->async_visible
= 1;
4125 f
->async_iconified
= 0;
4126 SET_FRAME_GARBAGED (f
);
4127 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4130 /* WM_PAINT serves as MapNotify as well, so report
4131 visibility changes properly. */
4134 inev
.kind
= DEICONIFY_EVENT
;
4135 XSETFRAME (inev
.frame_or_window
, f
);
4137 else if (! NILP (Vframe_list
)
4138 && ! NILP (XCDR (Vframe_list
)))
4139 /* Force a redisplay sooner or later to update the
4140 frame titles in case this is the second frame. */
4141 record_asynch_buffer_change ();
4145 HDC hdc
= get_frame_dc (f
);
4147 /* Erase background again for safety. */
4148 w32_clear_rect (f
, hdc
, &msg
.rect
);
4149 release_frame_dc (f
, hdc
);
4153 msg
.rect
.right
- msg
.rect
.left
,
4154 msg
.rect
.bottom
- msg
.rect
.top
);
4159 case WM_INPUTLANGCHANGE
:
4160 /* Generate a language change event. */
4161 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4165 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4166 XSETFRAME (inev
.frame_or_window
, f
);
4167 inev
.code
= msg
.msg
.wParam
;
4168 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4174 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4176 if (f
&& !f
->iconified
)
4178 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4179 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4181 clear_mouse_face (dpyinfo
);
4182 dpyinfo
->mouse_face_hidden
= 1;
4185 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4187 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4188 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4189 inev
.code
= msg
.msg
.wParam
;
4190 inev
.modifiers
= msg
.dwModifiers
;
4191 XSETFRAME (inev
.frame_or_window
, f
);
4192 inev
.timestamp
= msg
.msg
.time
;
4199 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4201 if (f
&& !f
->iconified
)
4203 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4204 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4206 clear_mouse_face (dpyinfo
);
4207 dpyinfo
->mouse_face_hidden
= 1;
4210 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4212 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4214 inev
.modifiers
= msg
.dwModifiers
;
4215 XSETFRAME (inev
.frame_or_window
, f
);
4216 inev
.timestamp
= msg
.msg
.time
;
4218 if (msg
.msg
.message
== WM_UNICHAR
)
4220 inev
.code
= msg
.msg
.wParam
;
4222 else if (msg
.msg
.wParam
< 256)
4227 dbcs
[1] = (char) msg
.msg
.wParam
;
4231 dbcs
[0] = dbcs_lead
;
4233 if (!MultiByteToWideChar (CP_ACP
, 0, dbcs
, 2, &code
, 1))
4236 DebPrint (("Invalid DBCS sequence: %d %d\n",
4238 inev
.kind
= NO_EVENT
;
4242 else if (IsDBCSLeadByteEx (CP_ACP
, (BYTE
) msg
.msg
.wParam
))
4244 dbcs_lead
= (char) msg
.msg
.wParam
;
4245 inev
.kind
= NO_EVENT
;
4250 if (!MultiByteToWideChar (CP_ACP
, 0, &dbcs
[1], 1,
4253 /* What to do with garbage? */
4254 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4255 inev
.kind
= NO_EVENT
;
4263 /* Windows shouldn't generate WM_CHAR events above 0xFF
4264 in non-Unicode message handlers. */
4265 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4266 inev
.kind
= NO_EVENT
;
4269 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4270 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4275 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4277 if (f
&& !f
->iconified
)
4279 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4280 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4282 clear_mouse_face (dpyinfo
);
4283 dpyinfo
->mouse_face_hidden
= 1;
4286 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4288 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4289 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4290 inev
.code
= GET_APPCOMMAND_LPARAM(msg
.msg
.lParam
);
4291 inev
.modifiers
= msg
.dwModifiers
;
4292 XSETFRAME (inev
.frame_or_window
, f
);
4293 inev
.timestamp
= msg
.msg
.time
;
4298 /* Ignore non-movement. */
4300 int x
= LOWORD (msg
.msg
.lParam
);
4301 int y
= HIWORD (msg
.msg
.lParam
);
4302 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4304 last_mousemove_x
= x
;
4305 last_mousemove_y
= y
;
4308 previous_help_echo_string
= help_echo_string
;
4309 help_echo_string
= Qnil
;
4311 if (dpyinfo
->grabbed
&& last_mouse_frame
4312 && FRAME_LIVE_P (last_mouse_frame
))
4313 f
= last_mouse_frame
;
4315 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4317 if (dpyinfo
->mouse_face_hidden
)
4319 dpyinfo
->mouse_face_hidden
= 0;
4320 clear_mouse_face (dpyinfo
);
4325 /* Generate SELECT_WINDOW_EVENTs when needed. */
4326 if (!NILP (Vmouse_autoselect_window
))
4329 int x
= LOWORD (msg
.msg
.lParam
);
4330 int y
= HIWORD (msg
.msg
.lParam
);
4332 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 0);
4334 /* Window will be selected only when it is not
4335 selected now and last mouse movement event was
4336 not in it. Minibuffer window will be selected
4337 only when it is active. */
4339 && !EQ (window
, last_window
)
4340 && !EQ (window
, selected_window
)
4341 /* For click-to-focus window managers
4342 create event iff we don't leave the
4344 && (focus_follows_mouse
4345 || (EQ (XWINDOW (window
)->frame
,
4346 XWINDOW (selected_window
)->frame
))))
4348 inev
.kind
= SELECT_WINDOW_EVENT
;
4349 inev
.frame_or_window
= window
;
4354 if (!note_mouse_movement (f
, &msg
.msg
))
4355 help_echo_string
= previous_help_echo_string
;
4359 /* If we move outside the frame, then we're
4360 certainly no longer on any text in the frame. */
4361 clear_mouse_face (dpyinfo
);
4364 /* If the contents of the global variable help_echo_string
4365 has changed, generate a HELP_EVENT. */
4366 #if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE.
4367 But it was originally changed to this to fix a bug, so I have
4368 not removed it completely in case the bug is still there. */
4369 if (help_echo_string
!= previous_help_echo_string
||
4370 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4371 #else /* This is what xterm.c does. */
4372 if (!NILP (help_echo_string
)
4373 || !NILP (previous_help_echo_string
))
4378 case WM_LBUTTONDOWN
:
4380 case WM_MBUTTONDOWN
:
4382 case WM_RBUTTONDOWN
:
4384 case WM_XBUTTONDOWN
:
4387 /* If we decide we want to generate an event to be seen
4388 by the rest of Emacs, we put it here. */
4393 if (dpyinfo
->grabbed
&& last_mouse_frame
4394 && FRAME_LIVE_P (last_mouse_frame
))
4395 f
= last_mouse_frame
;
4397 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4401 construct_mouse_click (&inev
, &msg
, f
);
4403 /* Is this in the tool-bar? */
4404 if (WINDOWP (f
->tool_bar_window
)
4405 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4408 int x
= XFASTINT (inev
.x
);
4409 int y
= XFASTINT (inev
.y
);
4411 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
4413 if (EQ (window
, f
->tool_bar_window
))
4415 w32_handle_tool_bar_click (f
, &inev
);
4421 || (dpyinfo
->w32_focus_frame
4422 && f
!= dpyinfo
->w32_focus_frame
))
4423 inev
.kind
= NO_EVENT
;
4426 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4431 dpyinfo
->grabbed
&= ~ (1 << button
);
4435 dpyinfo
->grabbed
|= (1 << button
);
4436 last_mouse_frame
= f
;
4437 /* Ignore any mouse motion that happened
4438 before this event; any subsequent mouse-movement
4439 Emacs events should reflect only motion after
4445 last_tool_bar_item
= -1;
4451 case WM_MOUSEHWHEEL
:
4453 if (dpyinfo
->grabbed
&& last_mouse_frame
4454 && FRAME_LIVE_P (last_mouse_frame
))
4455 f
= last_mouse_frame
;
4457 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4462 if (!dpyinfo
->w32_focus_frame
4463 || f
== dpyinfo
->w32_focus_frame
)
4465 /* Emit an Emacs wheel-up/down event. */
4466 construct_mouse_wheel (&inev
, &msg
, f
);
4468 /* Ignore any mouse motion that happened before this
4469 event; any subsequent mouse-movement Emacs events
4470 should reflect only motion after the
4474 last_mouse_frame
= f
;
4475 last_tool_bar_item
= -1;
4480 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4483 construct_drag_n_drop (&inev
, &msg
, f
);
4488 struct scroll_bar
*bar
=
4489 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
4492 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
4496 case WM_WINDOWPOSCHANGED
:
4497 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4500 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
4501 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
4503 check_visibility
= 1;
4507 case WM_ACTIVATEAPP
:
4508 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4510 x_check_fullscreen (f
);
4511 check_visibility
= 1;
4515 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4517 if (f
&& !f
->async_iconified
)
4521 x_real_positions (f
, &x
, &y
);
4526 check_visibility
= 1;
4530 /* wParam non-zero means Window is about to be shown, 0 means
4531 about to be hidden. */
4532 /* Redo the mouse-highlight after the tooltip has gone. */
4533 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
4536 redo_mouse_highlight ();
4539 /* If window has been obscured or exposed by another window
4540 being maximised or minimised/restored, then recheck
4541 visibility of all frames. Direct changes to our own
4542 windows get handled by WM_SIZE. */
4544 if (msg
.msg
.lParam
!= 0)
4545 check_visibility
= 1;
4548 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4549 f
->async_visible
= msg
.msg
.wParam
;
4553 check_visibility
= 1;
4557 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4559 /* Inform lisp of whether frame has been iconified etc. */
4562 switch (msg
.msg
.wParam
)
4564 case SIZE_MINIMIZED
:
4565 f
->async_visible
= 0;
4566 f
->async_iconified
= 1;
4568 inev
.kind
= ICONIFY_EVENT
;
4569 XSETFRAME (inev
.frame_or_window
, f
);
4572 case SIZE_MAXIMIZED
:
4574 f
->async_visible
= 1;
4575 f
->async_iconified
= 0;
4577 /* wait_reading_process_output will notice this and update
4578 the frame's display structures. */
4579 SET_FRAME_GARBAGED (f
);
4585 /* Reset top and left positions of the Window
4586 here since Windows sends a WM_MOVE message
4587 BEFORE telling us the Window is minimized
4588 when the Window is iconified, with 3000,3000
4590 x_real_positions (f
, &x
, &y
);
4594 inev
.kind
= DEICONIFY_EVENT
;
4595 XSETFRAME (inev
.frame_or_window
, f
);
4597 else if (! NILP (Vframe_list
)
4598 && ! NILP (XCDR (Vframe_list
)))
4599 /* Force a redisplay sooner or later
4600 to update the frame titles
4601 in case this is the second frame. */
4602 record_asynch_buffer_change ();
4607 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
4615 GetClientRect (msg
.msg
.hwnd
, &rect
);
4617 height
= rect
.bottom
- rect
.top
;
4618 width
= rect
.right
- rect
.left
;
4620 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
4621 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
4623 /* TODO: Clip size to the screen dimensions. */
4625 /* Even if the number of character rows and columns has
4626 not changed, the font size may have changed, so we need
4627 to check the pixel dimensions as well. */
4629 if (columns
!= FRAME_COLS (f
)
4630 || rows
!= FRAME_LINES (f
)
4631 || width
!= FRAME_PIXEL_WIDTH (f
)
4632 || height
!= FRAME_PIXEL_HEIGHT (f
))
4634 change_frame_size (f
, rows
, columns
, 0, 1, 0);
4635 SET_FRAME_GARBAGED (f
);
4636 cancel_mouse_face (f
);
4637 FRAME_PIXEL_WIDTH (f
) = width
;
4638 FRAME_PIXEL_HEIGHT (f
) = height
;
4639 f
->win_gravity
= NorthWestGravity
;
4643 check_visibility
= 1;
4647 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4650 if (f
== dpyinfo
->mouse_face_mouse_frame
)
4652 /* If we move outside the frame, then we're
4653 certainly no longer on any text in the frame. */
4654 clear_mouse_face (dpyinfo
);
4655 dpyinfo
->mouse_face_mouse_frame
= 0;
4658 /* Generate a nil HELP_EVENT to cancel a help-echo.
4659 Do it only if there's something to cancel.
4660 Otherwise, the startup message is cleared when
4661 the mouse leaves the frame. */
4662 if (any_help_event_p
)
4668 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
4670 dpyinfo
->grabbed
= 0;
4671 check_visibility
= 1;
4675 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4679 if (f
== dpyinfo
->w32_focus_event_frame
)
4680 dpyinfo
->w32_focus_event_frame
= 0;
4682 if (f
== dpyinfo
->w32_focus_frame
)
4683 x_new_focus_frame (dpyinfo
, 0);
4685 if (f
== dpyinfo
->mouse_face_mouse_frame
)
4687 /* If we move outside the frame, then we're
4688 certainly no longer on any text in the frame. */
4689 clear_mouse_face (dpyinfo
);
4690 dpyinfo
->mouse_face_mouse_frame
= 0;
4693 /* Generate a nil HELP_EVENT to cancel a help-echo.
4694 Do it only if there's something to cancel.
4695 Otherwise, the startup message is cleared when
4696 the mouse leaves the frame. */
4697 if (any_help_event_p
)
4701 dpyinfo
->grabbed
= 0;
4702 check_visibility
= 1;
4706 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4710 inev
.kind
= DELETE_WINDOW_EVENT
;
4711 XSETFRAME (inev
.frame_or_window
, f
);
4716 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4720 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
4721 XSETFRAME (inev
.frame_or_window
, f
);
4726 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4730 extern void menubar_selection_callback
4731 (FRAME_PTR f
, void * client_data
);
4732 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
4735 check_visibility
= 1;
4738 case WM_DISPLAYCHANGE
:
4739 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4743 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
4744 DebPrint (("display change: %d %d\n",
4745 (short) LOWORD (msg
.msg
.lParam
),
4746 (short) HIWORD (msg
.msg
.lParam
)));
4749 check_visibility
= 1;
4753 /* Check for messages registered at runtime. */
4754 if (msg
.msg
.message
== msh_mousewheel
)
4756 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
4757 msg
.msg
.message
= WM_MOUSEWHEEL
;
4763 if (inev
.kind
!= NO_EVENT
)
4765 kbd_buffer_store_event_hold (&inev
, hold_quit
);
4770 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
4775 XSETFRAME (frame
, f
);
4781 if (NILP (help_echo_string
))
4783 help_echo_object
= help_echo_window
= Qnil
;
4787 any_help_event_p
= 1;
4788 gen_help_event (help_echo_string
, frame
, help_echo_window
,
4789 help_echo_object
, help_echo_pos
);
4793 help_echo_string
= Qnil
;
4794 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
4800 /* If the focus was just given to an autoraising frame,
4802 /* ??? This ought to be able to handle more than one such frame. */
4803 if (pending_autoraise_frame
)
4805 x_raise_frame (pending_autoraise_frame
);
4806 pending_autoraise_frame
= 0;
4809 /* Check which frames are still visisble, if we have enqueued any user
4810 events or been notified of events that may affect visibility. We
4811 do this here because there doesn't seem to be any direct
4812 notification from Windows that the visibility of a window has
4813 changed (at least, not in all cases). */
4814 if (count
> 0 || check_visibility
)
4816 Lisp_Object tail
, frame
;
4818 FOR_EACH_FRAME (tail
, frame
)
4820 FRAME_PTR f
= XFRAME (frame
);
4821 /* The tooltip has been drawn already. Avoid the
4822 SET_FRAME_GARBAGED below. */
4823 if (EQ (frame
, tip_frame
))
4826 /* Check "visible" frames and mark each as obscured or not.
4827 Note that async_visible is nonzero for unobscured and
4828 obscured frames, but zero for hidden and iconified frames. */
4829 if (FRAME_W32_P (f
) && f
->async_visible
)
4835 /* Query clipping rectangle for the entire window area
4836 (GetWindowDC), not just the client portion (GetDC).
4837 Otherwise, the scrollbars and menubar aren't counted as
4838 part of the visible area of the frame, and we may think
4839 the frame is obscured when really a scrollbar is still
4840 visible and gets WM_PAINT messages above. */
4841 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
4842 GetClipBox (hdc
, &clipbox
);
4843 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
4846 if (clipbox
.right
== clipbox
.left
4847 || clipbox
.bottom
== clipbox
.top
)
4849 /* Frame has become completely obscured so mark as
4850 such (we do this by setting async_visible to 2 so
4851 that FRAME_VISIBLE_P is still true, but redisplay
4853 f
->async_visible
= 2;
4855 if (!FRAME_OBSCURED_P (f
))
4857 DebPrint (("frame %p (%s) obscured\n", f
,
4863 /* Frame is not obscured, so mark it as such. */
4864 f
->async_visible
= 1;
4866 if (FRAME_OBSCURED_P (f
))
4868 SET_FRAME_GARBAGED (f
);
4869 DebPrint (("obscured frame %p (%s) found to be visible\n", f
,
4872 /* Force a redisplay sooner or later. */
4873 record_asynch_buffer_change ();
4886 /***********************************************************************
4888 ***********************************************************************/
4890 /* Set clipping for output in glyph row ROW. W is the window in which
4891 we operate. GC is the graphics context to set clipping in.
4893 ROW may be a text row or, e.g., a mode line. Text rows must be
4894 clipped to the interior of the window dedicated to text display,
4895 mode lines must be clipped to the whole window. */
4898 w32_clip_to_row (w
, row
, area
, hdc
)
4900 struct glyph_row
*row
;
4904 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4906 int window_x
, window_y
, window_width
;
4908 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
4910 clip_rect
.left
= window_x
;
4911 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4912 clip_rect
.top
= max (clip_rect
.top
, window_y
);
4913 clip_rect
.right
= clip_rect
.left
+ window_width
;
4914 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
4916 w32_set_clip_rectangle (hdc
, &clip_rect
);
4920 /* Draw a hollow box cursor on window W in glyph row ROW. */
4923 x_draw_hollow_cursor (w
, row
)
4925 struct glyph_row
*row
;
4927 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4931 struct glyph
*cursor_glyph
;
4932 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
4934 /* Get the glyph the cursor is on. If we can't tell because
4935 the current matrix is invalid or such, give up. */
4936 cursor_glyph
= get_phys_cursor_glyph (w
);
4937 if (cursor_glyph
== NULL
)
4940 /* Compute frame-relative coordinates for phys cursor. */
4941 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
4944 rect
.bottom
= rect
.top
+ h
;
4945 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
4947 hdc
= get_frame_dc (f
);
4948 /* Set clipping, draw the rectangle, and reset clipping again. */
4949 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
4950 FrameRect (hdc
, &rect
, hb
);
4952 w32_set_clip_rectangle (hdc
, NULL
);
4953 release_frame_dc (f
, hdc
);
4957 /* Draw a bar cursor on window W in glyph row ROW.
4959 Implementation note: One would like to draw a bar cursor with an
4960 angle equal to the one given by the font property XA_ITALIC_ANGLE.
4961 Unfortunately, I didn't find a font yet that has this property set.
4965 x_draw_bar_cursor (w
, row
, width
, kind
)
4967 struct glyph_row
*row
;
4969 enum text_cursor_kinds kind
;
4971 struct frame
*f
= XFRAME (w
->frame
);
4972 struct glyph
*cursor_glyph
;
4976 /* If cursor is out of bounds, don't draw garbage. This can happen
4977 in mini-buffer windows when switching between echo area glyphs
4979 cursor_glyph
= get_phys_cursor_glyph (w
);
4980 if (cursor_glyph
== NULL
)
4983 /* If on an image, draw like a normal cursor. That's usually better
4984 visible than drawing a bar, esp. if the image is large so that
4985 the bar might not be in the window. */
4986 if (cursor_glyph
->type
== IMAGE_GLYPH
)
4988 struct glyph_row
*row
;
4989 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
4990 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
4994 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
4995 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
4997 /* If the glyph's background equals the color we normally draw
4998 the bar cursor in, the bar cursor in its normal color is
4999 invisible. Use the glyph's foreground color instead in this
5000 case, on the assumption that the glyph's colors are chosen so
5001 that the glyph is legible. */
5002 if (face
->background
== cursor_color
)
5003 cursor_color
= face
->foreground
;
5005 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5008 width
= FRAME_CURSOR_WIDTH (f
);
5009 width
= min (cursor_glyph
->pixel_width
, width
);
5011 w
->phys_cursor_width
= width
;
5014 hdc
= get_frame_dc (f
);
5015 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5017 if (kind
== BAR_CURSOR
)
5019 w32_fill_area (f
, hdc
, cursor_color
, x
,
5020 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5021 width
, row
->height
);
5025 w32_fill_area (f
, hdc
, cursor_color
, x
,
5026 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5027 row
->height
- width
),
5028 min (FRAME_COLUMN_WIDTH (f
), cursor_glyph
->pixel_width
),
5032 w32_set_clip_rectangle (hdc
, NULL
);
5033 release_frame_dc (f
, hdc
);
5038 /* RIF: Define cursor CURSOR on frame F. */
5041 w32_define_frame_cursor (f
, cursor
)
5045 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5049 /* RIF: Clear area on frame F. */
5052 w32_clear_frame_area (f
, x
, y
, width
, height
)
5054 int x
, y
, width
, height
;
5058 hdc
= get_frame_dc (f
);
5059 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5060 release_frame_dc (f
, hdc
);
5063 /* RIF: Draw or clear cursor on window W. */
5066 w32_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
5068 struct glyph_row
*glyph_row
;
5070 int cursor_type
, cursor_width
;
5075 /* If the user wants to use the system caret, make sure our own
5076 cursor remains invisible. */
5077 if (w32_use_visible_system_caret
)
5079 /* Call to erase_phys_cursor here seems to use the
5080 wrong values of w->phys_cursor, as they have been
5081 overwritten before this function was called. */
5082 if (w
->phys_cursor_type
!= NO_CURSOR
)
5083 erase_phys_cursor (w
);
5085 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5086 w
->phys_cursor_width
= -1;
5090 w
->phys_cursor_type
= cursor_type
;
5093 w
->phys_cursor_on_p
= 1;
5095 /* If this is the active cursor, we need to track it with the
5096 system caret, so third party software like screen magnifiers
5097 and speech synthesizers can follow the cursor. */
5100 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5101 HWND hwnd
= FRAME_W32_WINDOW (f
);
5104 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5106 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5107 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5109 /* If the size of the active cursor changed, destroy the old
5111 if (w32_system_caret_hwnd
5112 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5113 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5115 w32_system_caret_height
= w
->phys_cursor_height
;
5117 /* Move the system caret. */
5118 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5121 if (glyph_row
->exact_window_width_line_p
5122 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
5124 glyph_row
->cursor_in_fringe_p
= 1;
5125 draw_fringe_bitmap (w
, glyph_row
, 0);
5129 switch (cursor_type
)
5131 case HOLLOW_BOX_CURSOR
:
5132 x_draw_hollow_cursor (w
, glyph_row
);
5135 case FILLED_BOX_CURSOR
:
5136 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5140 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5144 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5148 w
->phys_cursor_width
= 0;
5162 x_bitmap_icon (f
, icon
)
5167 HANDLE small_icon
= NULL
;
5169 if (FRAME_W32_WINDOW (f
) == 0)
5173 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5174 else if (STRINGP (icon
))
5176 /* Load the main icon from the named file. */
5177 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5178 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5179 /* Try to load a small icon to go with it. */
5180 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5181 GetSystemMetrics (SM_CXSMICON
),
5182 GetSystemMetrics (SM_CYSMICON
),
5185 else if (SYMBOLP (icon
))
5189 if (EQ (icon
, intern ("application")))
5190 name
= (LPCTSTR
) IDI_APPLICATION
;
5191 else if (EQ (icon
, intern ("hand")))
5192 name
= (LPCTSTR
) IDI_HAND
;
5193 else if (EQ (icon
, intern ("question")))
5194 name
= (LPCTSTR
) IDI_QUESTION
;
5195 else if (EQ (icon
, intern ("exclamation")))
5196 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5197 else if (EQ (icon
, intern ("asterisk")))
5198 name
= (LPCTSTR
) IDI_ASTERISK
;
5199 else if (EQ (icon
, intern ("winlogo")))
5200 name
= (LPCTSTR
) IDI_WINLOGO
;
5204 main_icon
= LoadIcon (NULL
, name
);
5209 if (main_icon
== NULL
)
5212 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5213 (LPARAM
) main_icon
);
5215 /* If there is a small icon that goes with it, set that too. */
5217 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5218 (LPARAM
) small_icon
);
5224 /************************************************************************
5226 ************************************************************************/
5228 /* Display Error Handling functions not used on W32. Listing them here
5229 helps diff stay in step when comparing w32term.c with xterm.c.
5231 x_error_catcher (display, error)
5232 x_catch_errors (dpy)
5233 x_catch_errors_unwind (old_val)
5234 x_check_errors (dpy, format)
5235 x_fully_uncatch_errors ()
5236 x_catching_errors ()
5237 x_had_errors_p (dpy)
5238 x_clear_errors (dpy)
5239 x_uncatch_errors (dpy, count)
5241 x_connection_signal (signalnum)
5242 x_connection_closed (dpy, error_message)
5243 x_error_quitter (display, error)
5244 x_error_handler (display, error)
5245 x_io_error_quitter (display)
5250 /* Changing the font of the frame. */
5253 x_new_font (f
, font_object
, fontset
)
5255 Lisp_Object font_object
;
5258 struct font
*font
= XFONT_OBJECT (font_object
);
5261 fontset
= fontset_from_font (font_object
);
5262 FRAME_FONTSET (f
) = fontset
;
5263 if (FRAME_FONT (f
) == font
)
5264 /* This font is already set in frame F. There's nothing more to
5268 FRAME_FONT (f
) = font
;
5269 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5270 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
5271 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
5272 FRAME_LINE_HEIGHT (f
) = font
->height
;
5274 compute_fringe_widths (f
, 1);
5276 /* Compute the scroll bar width in character columns. */
5277 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5279 int wid
= FRAME_COLUMN_WIDTH (f
);
5280 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5281 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
- 1) / wid
;
5285 int wid
= FRAME_COLUMN_WIDTH (f
);
5286 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5289 /* Now make the frame display the given font. */
5290 if (FRAME_X_WINDOW (f
) != 0)
5292 /* Don't change the size of a tip frame; there's no point in
5293 doing it because it's done in Fx_show_tip, and it leads to
5294 problems because the tip frame has no widget. */
5295 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5296 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5299 /* X version sets font of input methods here also. */
5305 /***********************************************************************
5306 TODO: W32 Input Methods
5307 ***********************************************************************/
5308 /* Listing missing functions from xterm.c helps diff stay in step.
5310 xim_destroy_callback (xim, client_data, call_data)
5311 xim_open_dpy (dpyinfo, resource_name)
5313 xim_instantiate_callback (display, client_data, call_data)
5314 xim_initialize (dpyinfo, resource_name)
5315 xim_close_dpy (dpyinfo)
5320 /* Calculate the absolute position in frame F
5321 from its current recorded position values and gravity. */
5324 x_calc_absolute_position (f
)
5327 int flags
= f
->size_hint_flags
;
5329 /* The sum of the widths of the frame's left and right borders, and
5330 the sum of the heights of the frame's top and bottom borders (in
5331 pixels) drawn by Windows. */
5332 unsigned int left_right_borders_width
, top_bottom_borders_height
;
5334 /* Try to get the actual values of these two variables. We compute
5335 the border width (height) by subtracting the width (height) of
5336 the frame's client area from the width (height) of the frame's
5338 WINDOWPLACEMENT wp
= { 0 };
5339 RECT client_rect
= { 0 };
5341 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
5342 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
5344 left_right_borders_width
=
5345 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
5346 (client_rect
.right
- client_rect
.left
);
5348 top_bottom_borders_height
=
5349 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
5350 (client_rect
.bottom
- client_rect
.top
);
5354 /* Use sensible default values. */
5355 left_right_borders_width
= 8;
5356 top_bottom_borders_height
= 32;
5359 /* Treat negative positions as relative to the rightmost bottommost
5360 position that fits on the screen. */
5361 if (flags
& XNegative
)
5362 f
->left_pos
= (x_display_pixel_width (FRAME_W32_DISPLAY_INFO (f
))
5363 - FRAME_PIXEL_WIDTH (f
)
5365 - (left_right_borders_width
- 1));
5367 if (flags
& YNegative
)
5368 f
->top_pos
= (x_display_pixel_height (FRAME_W32_DISPLAY_INFO (f
))
5369 - FRAME_PIXEL_HEIGHT (f
)
5371 - (top_bottom_borders_height
- 1));
5373 /* The left_pos and top_pos are now relative to the top and left
5374 screen edges, so the flags should correspond. */
5375 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5378 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5379 to really change the position, and 0 when calling from
5380 x_make_frame_visible (in that case, XOFF and YOFF are the current
5381 position values). It is -1 when calling from x_set_frame_parameters,
5382 which means, do adjust for borders but don't change the gravity. */
5385 x_set_offset (f
, xoff
, yoff
, change_gravity
)
5387 register int xoff
, yoff
;
5390 int modified_top
, modified_left
;
5392 if (change_gravity
> 0)
5396 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5398 f
->size_hint_flags
|= XNegative
;
5400 f
->size_hint_flags
|= YNegative
;
5401 f
->win_gravity
= NorthWestGravity
;
5403 x_calc_absolute_position (f
);
5406 x_wm_set_size_hint (f
, (long) 0, 0);
5408 modified_left
= f
->left_pos
;
5409 modified_top
= f
->top_pos
;
5411 my_set_window_pos (FRAME_W32_WINDOW (f
),
5413 modified_left
, modified_top
,
5415 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5420 /* Check if we need to resize the frame due to a fullscreen request.
5421 If so needed, resize the frame. */
5423 x_check_fullscreen (f
)
5426 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
5428 int width
, height
, ign
;
5430 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5432 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
5434 /* We do not need to move the window, it shall be taken care of
5435 when setting WM manager hints. */
5436 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
5438 change_frame_size (f
, height
, width
, 0, 1, 0);
5439 SET_FRAME_GARBAGED (f
);
5440 cancel_mouse_face (f
);
5442 /* Wait for the change of frame size to occur */
5443 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
5448 /* Call this to change the size of frame F's x-window.
5449 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5450 for this size change and subsequent size changes.
5451 Otherwise we leave the window gravity unchanged. */
5454 x_set_window_size (f
, change_gravity
, cols
, rows
)
5459 int pixelwidth
, pixelheight
;
5463 check_frame_size (f
, &rows
, &cols
);
5464 f
->scroll_bar_actual_width
5465 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
5467 compute_fringe_widths (f
, 0);
5469 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
5470 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
5472 f
->win_gravity
= NorthWestGravity
;
5473 x_wm_set_size_hint (f
, (long) 0, 0);
5478 rect
.left
= rect
.top
= 0;
5479 rect
.right
= pixelwidth
;
5480 rect
.bottom
= pixelheight
;
5482 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
5483 FRAME_EXTERNAL_MENU_BAR (f
));
5485 my_set_window_pos (FRAME_W32_WINDOW (f
),
5488 rect
.right
- rect
.left
,
5489 rect
.bottom
- rect
.top
,
5490 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5494 /* The following mirrors what is done in xterm.c. It appears to be
5495 for informing lisp of the new size immediately, while the actual
5496 resize will happen asynchronously. But on Windows, the menu bar
5497 automatically wraps when the frame is too narrow to contain it,
5498 and that causes any calculations made here to come out wrong. The
5499 end is some nasty buggy behavior, including the potential loss
5502 Disabling this code is either not sufficient to fix the problems
5503 completely, or it causes fresh problems, but at least it removes
5504 the most problematic symptom of the minibuffer becoming unusable.
5506 -----------------------------------------------------------------
5508 Now, strictly speaking, we can't be sure that this is accurate,
5509 but the window manager will get around to dealing with the size
5510 change request eventually, and we'll hear how it went when the
5511 ConfigureNotify event gets here.
5513 We could just not bother storing any of this information here,
5514 and let the ConfigureNotify event set everything up, but that
5515 might be kind of confusing to the Lisp code, since size changes
5516 wouldn't be reported in the frame parameters until some random
5517 point in the future when the ConfigureNotify event arrives.
5519 We pass 1 for DELAY since we can't run Lisp code inside of
5521 change_frame_size (f
, rows
, cols
, 0, 1, 0);
5522 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
5523 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
5525 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5526 receive in the ConfigureNotify event; if we get what we asked
5527 for, then the event won't cause the screen to become garbaged, so
5528 we have to make sure to do it here. */
5529 SET_FRAME_GARBAGED (f
);
5531 /* If cursor was outside the new size, mark it as off. */
5532 mark_window_cursors_off (XWINDOW (f
->root_window
));
5534 /* Clear out any recollection of where the mouse highlighting was,
5535 since it might be in a place that's outside the new frame size.
5536 Actually checking whether it is outside is a pain in the neck,
5537 so don't try--just let the highlighting be done afresh with new size. */
5538 cancel_mouse_face (f
);
5544 /* Mouse warping. */
5546 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
5549 x_set_mouse_position (f
, x
, y
)
5555 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
5556 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
5558 if (pix_x
< 0) pix_x
= 0;
5559 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
5561 if (pix_y
< 0) pix_y
= 0;
5562 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
5564 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
5568 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
5577 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
5578 pt
.x
= rect
.left
+ pix_x
;
5579 pt
.y
= rect
.top
+ pix_y
;
5580 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
5582 SetCursorPos (pt
.x
, pt
.y
);
5588 /* focus shifting, raising and lowering. */
5591 x_focus_on_frame (f
)
5594 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
5596 /* Give input focus to frame. */
5599 /* Try not to change its Z-order if possible. */
5600 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
5601 my_set_focus (f
, FRAME_W32_WINDOW (f
));
5604 my_set_foreground_window (FRAME_W32_WINDOW (f
));
5614 /* Raise frame F. */
5621 /* Strictly speaking, raise-frame should only change the frame's Z
5622 order, leaving input focus unchanged. This is reasonable behavior
5623 on X where the usual policy is point-to-focus. However, this
5624 behavior would be very odd on Windows where the usual policy is
5627 On X, if the mouse happens to be over the raised frame, it gets
5628 input focus anyway (so the window with focus will never be
5629 completely obscured) - if not, then just moving the mouse over it
5630 is sufficient to give it focus. On Windows, the user must actually
5631 click on the frame (preferrably the title bar so as not to move
5632 point), which is more awkward. Also, no other Windows program
5633 raises a window to the top but leaves another window (possibly now
5634 completely obscured) with input focus.
5636 Because there is a system setting on Windows that allows the user
5637 to choose the point to focus policy, we make the strict semantics
5638 optional, but by default we grab focus when raising. */
5640 if (NILP (Vw32_grab_focus_on_raise
))
5642 /* The obvious call to my_set_window_pos doesn't work if Emacs is
5643 not already the foreground application: the frame is raised
5644 above all other frames belonging to us, but not above the
5645 current top window. To achieve that, we have to resort to this
5646 more cumbersome method. */
5648 HDWP handle
= BeginDeferWindowPos (2);
5651 DeferWindowPos (handle
,
5652 FRAME_W32_WINDOW (f
),
5655 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5657 DeferWindowPos (handle
,
5658 GetForegroundWindow (),
5659 FRAME_W32_WINDOW (f
),
5661 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5663 EndDeferWindowPos (handle
);
5668 my_set_foreground_window (FRAME_W32_WINDOW (f
));
5674 /* Lower frame F. */
5680 my_set_window_pos (FRAME_W32_WINDOW (f
),
5683 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5688 w32_frame_raise_lower (f
, raise_flag
)
5692 if (! FRAME_W32_P (f
))
5701 /* Change of visibility. */
5703 /* This tries to wait until the frame is really visible.
5704 However, if the window manager asks the user where to position
5705 the frame, this will return before the user finishes doing that.
5706 The frame will not actually be visible at that time,
5707 but it will become visible later when the window manager
5708 finishes with it. */
5711 x_make_frame_visible (f
)
5718 type
= x_icon_type (f
);
5720 x_bitmap_icon (f
, type
);
5722 if (! FRAME_VISIBLE_P (f
))
5724 /* We test FRAME_GARBAGED_P here to make sure we don't
5725 call x_set_offset a second time
5726 if we get to x_make_frame_visible a second time
5727 before the window gets really visible. */
5728 if (! FRAME_ICONIFIED_P (f
)
5729 && ! f
->output_data
.w32
->asked_for_visible
)
5734 /* Adjust vertical window position in order to avoid being
5735 covered by a task bar placed at the bottom of the desktop. */
5736 SystemParametersInfo(SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
5737 GetWindowRect(FRAME_W32_WINDOW(f
), &window_rect
);
5738 if (window_rect
.bottom
> workarea_rect
.bottom
5739 && window_rect
.top
> workarea_rect
.top
)
5740 f
->top_pos
= max (window_rect
.top
5741 - window_rect
.bottom
+ workarea_rect
.bottom
,
5744 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
5747 f
->output_data
.w32
->asked_for_visible
= 1;
5749 /* The first of these seems to give more expected behavior, but
5750 was added as a commented out line in Sept 1997, with the
5751 second version remaining uncommented. There may have been
5752 some problem with it that led to it not being enabled,
5753 so the old version remains commented out below in case we
5754 decide we need to go back to it [23.0.60 2008-06-09]. */
5755 my_show_window (f
, FRAME_W32_WINDOW (f
),
5756 f
->async_iconified
? SW_RESTORE
: SW_SHOW
);
5757 /* my_show_window (f, FRAME_W32_WINDOW (f), SW_SHOWNORMAL); */
5760 /* Synchronize to ensure Emacs knows the frame is visible
5761 before we do anything else. We do this loop with input not blocked
5762 so that incoming events are handled. */
5767 /* This must come after we set COUNT. */
5770 XSETFRAME (frame
, f
);
5772 /* Wait until the frame is visible. Process X events until a
5773 MapNotify event has been seen, or until we think we won't get a
5774 MapNotify at all.. */
5775 for (count
= input_signal_count
+ 10;
5776 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
5778 /* Force processing of queued events. */
5779 /* TODO: x_sync equivalent? */
5781 /* Machines that do polling rather than SIGIO have been observed
5782 to go into a busy-wait here. So we'll fake an alarm signal
5783 to let the handler know that there's something to be read.
5784 We used to raise a real alarm, but it seems that the handler
5785 isn't always enabled here. This is probably a bug. */
5786 if (input_polling_used ())
5788 /* It could be confusing if a real alarm arrives while processing
5789 the fake one. Turn it off and let the handler reset it. */
5790 int old_poll_suppress_count
= poll_suppress_count
;
5791 poll_suppress_count
= 1;
5792 poll_for_input_1 ();
5793 poll_suppress_count
= old_poll_suppress_count
;
5796 FRAME_SAMPLE_VISIBILITY (f
);
5800 /* Change from mapped state to withdrawn state. */
5802 /* Make the frame visible (mapped and not iconified). */
5804 x_make_frame_invisible (f
)
5807 /* Don't keep the highlight on an invisible frame. */
5808 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5809 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5813 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
5815 /* We can't distinguish this from iconification
5816 just by the event that we get from the server.
5817 So we can't win using the usual strategy of letting
5818 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5819 and synchronize with the server to make sure we agree. */
5821 FRAME_ICONIFIED_P (f
) = 0;
5822 f
->async_visible
= 0;
5823 f
->async_iconified
= 0;
5828 /* Change window state from mapped to iconified. */
5836 /* Don't keep the highlight on an invisible frame. */
5837 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5838 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5840 if (f
->async_iconified
)
5845 type
= x_icon_type (f
);
5847 x_bitmap_icon (f
, type
);
5849 /* Simulate the user minimizing the frame. */
5850 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
5856 /* Free X resources of frame F. */
5859 x_free_frame_resources (f
)
5862 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5866 /* We must free faces before destroying windows because some
5867 font-driver (e.g. xft) access a window while finishing a
5869 if (FRAME_FACE_CACHE (f
))
5870 free_frame_faces (f
);
5872 if (FRAME_W32_WINDOW (f
))
5873 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
5875 free_frame_menubar (f
);
5877 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
5878 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
5879 unload_color (f
, f
->output_data
.w32
->cursor_pixel
);
5880 unload_color (f
, f
->output_data
.w32
->cursor_foreground_pixel
);
5881 unload_color (f
, f
->output_data
.w32
->border_pixel
);
5882 unload_color (f
, f
->output_data
.w32
->mouse_pixel
);
5883 if (f
->output_data
.w32
->white_relief
.allocated_p
)
5884 unload_color (f
, f
->output_data
.w32
->white_relief
.pixel
);
5885 if (f
->output_data
.w32
->black_relief
.allocated_p
)
5886 unload_color (f
, f
->output_data
.w32
->black_relief
.pixel
);
5888 if (FRAME_FACE_CACHE (f
))
5889 free_frame_faces (f
);
5891 xfree (f
->output_data
.w32
);
5892 f
->output_data
.w32
= NULL
;
5894 if (f
== dpyinfo
->w32_focus_frame
)
5895 dpyinfo
->w32_focus_frame
= 0;
5896 if (f
== dpyinfo
->w32_focus_event_frame
)
5897 dpyinfo
->w32_focus_event_frame
= 0;
5898 if (f
== dpyinfo
->x_highlight_frame
)
5899 dpyinfo
->x_highlight_frame
= 0;
5901 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5903 dpyinfo
->mouse_face_beg_row
5904 = dpyinfo
->mouse_face_beg_col
= -1;
5905 dpyinfo
->mouse_face_end_row
5906 = dpyinfo
->mouse_face_end_col
= -1;
5907 dpyinfo
->mouse_face_window
= Qnil
;
5908 dpyinfo
->mouse_face_deferred_gc
= 0;
5909 dpyinfo
->mouse_face_mouse_frame
= 0;
5916 /* Destroy the window of frame F. */
5918 x_destroy_window (f
)
5921 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5923 x_free_frame_resources (f
);
5924 dpyinfo
->reference_count
--;
5928 /* Setting window manager hints. */
5930 /* Set the normal size hints for the window manager, for frame F.
5931 FLAGS is the flags word to use--or 0 meaning preserve the flags
5932 that the window now has.
5933 If USER_POSITION is nonzero, we set the USPosition
5934 flag (this is useful when FLAGS is 0). */
5936 x_wm_set_size_hint (f
, flags
, user_position
)
5941 Window window
= FRAME_W32_WINDOW (f
);
5945 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
5946 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
5947 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
5948 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
5953 /* Window manager things */
5955 x_wm_set_icon_position (f
, icon_x
, icon_y
)
5960 Window window
= FRAME_W32_WINDOW (f
);
5962 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
5963 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
5964 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
5966 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
5971 /***********************************************************************
5973 ***********************************************************************/
5975 static int w32_initialized
= 0;
5978 w32_initialize_display_info (display_name
)
5979 Lisp_Object display_name
;
5981 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
5983 bzero (dpyinfo
, sizeof (*dpyinfo
));
5985 /* Put it on w32_display_name_list. */
5986 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
5987 w32_display_name_list
);
5988 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
5990 dpyinfo
->w32_id_name
5991 = (char *) xmalloc (SCHARS (Vinvocation_name
)
5992 + SCHARS (Vsystem_name
)
5994 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
5995 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
5997 /* Default Console mode values - overridden when running in GUI mode
5998 with values obtained from system metrics. */
6001 dpyinfo
->n_planes
= 1;
6002 dpyinfo
->n_cbits
= 4;
6003 dpyinfo
->n_fonts
= 0;
6004 dpyinfo
->smallest_font_height
= 1;
6005 dpyinfo
->smallest_char_width
= 1;
6007 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6008 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6009 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
6010 dpyinfo
->mouse_face_window
= Qnil
;
6011 dpyinfo
->mouse_face_overlay
= Qnil
;
6012 dpyinfo
->mouse_face_hidden
= 0;
6014 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6015 /* TODO: dpyinfo->gray */
6019 /* Create an xrdb-style database of resources to supercede registry settings.
6020 The database is just a concatenation of C strings, finished by an additional
6021 \0. The strings are submitted to some basic normalization, so
6023 [ *]option[ *]:[ *]value...
6029 but any whitespace following value is not removed. */
6032 w32_make_rdb (xrm_option
)
6035 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6036 char *current
= buffer
;
6039 int before_value
= 0;
6053 if (in_option
&& (ch
== ':'))
6058 else if (before_value
)
6063 else if (!(in_option
|| before_value
))
6075 x_flush (struct frame
* f
)
6076 { /* Nothing to do */ }
6079 extern frame_parm_handler w32_frame_parm_handlers
[];
6081 static struct redisplay_interface w32_redisplay_interface
=
6083 w32_frame_parm_handlers
,
6087 x_clear_end_of_line
,
6089 x_after_update_window_line
,
6090 x_update_window_begin
,
6091 x_update_window_end
,
6094 0, /* flush_display_optional */
6095 x_clear_window_mouse_face
,
6096 x_get_glyph_overhangs
,
6097 x_fix_overlapping_area
,
6098 w32_draw_fringe_bitmap
,
6099 w32_define_fringe_bitmap
,
6100 w32_destroy_fringe_bitmap
,
6101 w32_compute_glyph_string_overhangs
,
6102 x_draw_glyph_string
,
6103 w32_define_frame_cursor
,
6104 w32_clear_frame_area
,
6105 w32_draw_window_cursor
,
6106 w32_draw_vertical_window_border
,
6107 w32_shift_glyphs_for_insert
6110 static void x_delete_terminal (struct terminal
*term
);
6112 static struct terminal
*
6113 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6115 struct terminal
*terminal
;
6117 terminal
= create_terminal ();
6119 terminal
->type
= output_w32
;
6120 terminal
->display_info
.w32
= dpyinfo
;
6121 dpyinfo
->terminal
= terminal
;
6123 /* MSVC does not type K&R functions with no arguments correctly, and
6124 so we must explicitly cast them. */
6125 terminal
->clear_frame_hook
= x_clear_frame
;
6126 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6127 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6128 terminal
->ring_bell_hook
= w32_ring_bell
;
6129 terminal
->reset_terminal_modes_hook
= w32_reset_terminal_modes
;
6130 terminal
->set_terminal_modes_hook
= w32_set_terminal_modes
;
6131 terminal
->update_begin_hook
= x_update_begin
;
6132 terminal
->update_end_hook
= x_update_end
;
6133 terminal
->set_terminal_window_hook
= w32_set_terminal_window
;
6134 terminal
->read_socket_hook
= w32_read_socket
;
6135 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6136 terminal
->mouse_position_hook
= w32_mouse_position
;
6137 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6138 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6139 // terminal->fullscreen_hook = XTfullscreen_hook;
6140 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6141 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6142 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6143 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6145 terminal
->delete_frame_hook
= x_destroy_window
;
6146 terminal
->delete_terminal_hook
= x_delete_terminal
;
6148 terminal
->rif
= &w32_redisplay_interface
;
6149 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
6150 terminal
->char_ins_del_ok
= 1;
6151 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
6152 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
6153 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
6156 /* We don't yet support separate terminals on W32, so don't try to share
6157 keyboards between virtual terminals that are on the same physical
6158 terminal like X does. */
6159 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
6160 init_kboard (terminal
->kboard
);
6161 terminal
->kboard
->Vwindow_system
= intern ("w32");
6162 terminal
->kboard
->next_kboard
= all_kboards
;
6163 all_kboards
= terminal
->kboard
;
6164 /* Don't let the initial kboard remain current longer than necessary.
6165 That would cause problems if a file loaded on startup tries to
6166 prompt in the mini-buffer. */
6167 if (current_kboard
== initial_kboard
)
6168 current_kboard
= terminal
->kboard
;
6169 terminal
->kboard
->reference_count
++;
6175 x_delete_terminal (struct terminal
*terminal
)
6177 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
6180 /* Protect against recursive calls. delete_frame in
6181 delete_terminal calls us back when it deletes our last frame. */
6182 if (!terminal
->name
)
6187 x_delete_display (dpyinfo
);
6191 struct w32_display_info
*
6192 w32_term_init (display_name
, xrm_option
, resource_name
)
6193 Lisp_Object display_name
;
6195 char *resource_name
;
6197 struct w32_display_info
*dpyinfo
;
6198 struct terminal
*terminal
;
6203 if (!w32_initialized
)
6206 w32_initialized
= 1;
6209 w32_initialize_display_info (display_name
);
6211 dpyinfo
= &one_w32_display_info
;
6212 terminal
= w32_create_terminal (dpyinfo
);
6214 /* Set the name of the terminal. */
6215 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
6216 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
6217 terminal
->name
[SBYTES (display_name
)] = 0;
6219 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6221 /* Put this display on the chain. */
6222 dpyinfo
->next
= x_display_list
;
6223 x_display_list
= dpyinfo
;
6227 dpyinfo
->root_window
= GetDesktopWindow ();
6228 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6229 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6230 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6231 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6232 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6233 ReleaseDC (NULL
, hdc
);
6235 /* initialise palette with white and black */
6238 w32_defined_color (0, "white", &color
, 1);
6239 w32_defined_color (0, "black", &color
, 1);
6242 /* Add the default keyboard. */
6243 add_keyboard_wait_descriptor (0);
6245 /* Create Fringe Bitmaps and store them for later use.
6247 On W32, bitmaps are all unsigned short, as Windows requires
6248 bitmap data to be Word aligned. For some reason they are
6249 horizontally reflected compared to how they appear on X, so we
6250 need to bitswap and convert to unsigned shorts before creating
6252 w32_init_fringe (terminal
->rif
);
6255 fcntl (connection
, F_SETOWN
, getpid ());
6256 #endif /* ! defined (F_SETOWN) */
6259 if (interrupt_input
)
6260 init_sigio (connection
);
6261 #endif /* ! defined (SIGIO) */
6268 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6270 x_delete_display (dpyinfo
)
6271 struct w32_display_info
*dpyinfo
;
6273 /* Discard this display from w32_display_name_list and w32_display_list.
6274 We can't use Fdelq because that can quit. */
6275 if (! NILP (w32_display_name_list
)
6276 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
6277 w32_display_name_list
= XCDR (w32_display_name_list
);
6282 tail
= w32_display_name_list
;
6283 while (CONSP (tail
) && CONSP (XCDR (tail
)))
6285 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
6287 XSETCDR (tail
, XCDR (XCDR (tail
)));
6294 /* free palette table */
6296 struct w32_palette_entry
* plist
;
6298 plist
= dpyinfo
->color_list
;
6301 struct w32_palette_entry
* pentry
= plist
;
6302 plist
= plist
->next
;
6305 dpyinfo
->color_list
= NULL
;
6306 if (dpyinfo
->palette
)
6307 DeleteObject(dpyinfo
->palette
);
6309 xfree (dpyinfo
->w32_id_name
);
6311 w32_reset_fringes ();
6314 /* Set up use of W32. */
6316 DWORD WINAPI
w32_msg_worker (void * arg
);
6323 w32_system_caret_hwnd
= NULL
;
6324 w32_system_caret_height
= 0;
6325 w32_system_caret_x
= 0;
6326 w32_system_caret_y
= 0;
6328 /* Initialize w32_use_visible_system_caret based on whether a screen
6329 reader is in use. */
6330 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
6331 &w32_use_visible_system_caret
, 0))
6332 w32_use_visible_system_caret
= 0;
6334 last_tool_bar_item
= -1;
6335 any_help_event_p
= 0;
6337 /* Initialize input mode: interrupt_input off, no flow control, allow
6338 8 bit character input, standard quit char. */
6339 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
6341 /* Create the window thread - it will terminate itself or when the app terminates */
6345 dwMainThreadId
= GetCurrentThreadId ();
6346 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6347 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
6349 /* Wait for thread to start */
6354 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
6356 hWindowsThread
= CreateThread (NULL
, 0,
6358 0, 0, &dwWindowsThreadId
);
6360 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6363 /* It is desirable that mainThread should have the same notion of
6364 focus window and active window as windowsThread. Unfortunately, the
6365 following call to AttachThreadInput, which should do precisely what
6366 we need, causes major problems when Emacs is linked as a console
6367 program. Unfortunately, we have good reasons for doing that, so
6368 instead we need to send messages to windowsThread to make some API
6369 calls for us (ones that affect, or depend on, the active/focus
6371 #ifdef ATTACH_THREADS
6372 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
6375 /* Dynamically link to optional system components. */
6377 HANDLE user_lib
= LoadLibrary ("user32.dll");
6379 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
6381 LOAD_PROC (user_lib
, SetLayeredWindowAttributes
);
6385 FreeLibrary (user_lib
);
6387 /* Ensure scrollbar handle is at least 5 pixels. */
6388 vertical_scroll_bar_min_handle
= 5;
6390 /* For either kind of scroll bar, take account of the arrows; these
6391 effectively form the border of the main scroll bar range. */
6392 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
6393 = GetSystemMetrics (SM_CYVSCROLL
);
6400 staticpro (&w32_display_name_list
);
6401 w32_display_name_list
= Qnil
;
6403 staticpro (&last_mouse_scroll_bar
);
6404 last_mouse_scroll_bar
= Qnil
;
6406 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
6408 DEFVAR_INT ("w32-num-mouse-buttons",
6409 &w32_num_mouse_buttons
,
6410 doc
: /* Number of physical mouse buttons. */);
6411 w32_num_mouse_buttons
= 2;
6413 DEFVAR_LISP ("w32-swap-mouse-buttons",
6414 &Vw32_swap_mouse_buttons
,
6415 doc
: /* Swap the mapping of middle and right mouse buttons.
6416 When nil, middle button is mouse-2 and right button is mouse-3. */);
6417 Vw32_swap_mouse_buttons
= Qnil
;
6419 DEFVAR_LISP ("w32-grab-focus-on-raise",
6420 &Vw32_grab_focus_on_raise
,
6421 doc
: /* Raised frame grabs input focus.
6422 When t, `raise-frame' grabs input focus as well. This fits well
6423 with the normal Windows click-to-focus policy, but might not be
6424 desirable when using a point-to-focus policy. */);
6425 Vw32_grab_focus_on_raise
= Qt
;
6427 DEFVAR_LISP ("w32-capslock-is-shiftlock",
6428 &Vw32_capslock_is_shiftlock
,
6429 doc
: /* Apply CapsLock state to non character input keys.
6430 When nil, CapsLock only affects normal character input keys. */);
6431 Vw32_capslock_is_shiftlock
= Qnil
;
6433 DEFVAR_LISP ("w32-recognize-altgr",
6434 &Vw32_recognize_altgr
,
6435 doc
: /* Recognize right-alt and left-ctrl as AltGr.
6436 When nil, the right-alt and left-ctrl key combination is
6437 interpreted normally. */);
6438 Vw32_recognize_altgr
= Qt
;
6440 DEFVAR_BOOL ("w32-use-visible-system-caret",
6441 &w32_use_visible_system_caret
,
6442 doc
: /* Flag to make the system caret visible.
6443 When this is non-nil, Emacs will indicate the position of point by
6444 using the system caret instead of drawing its own cursor. Some screen
6445 reader software does not track the system cursor properly when it is
6446 invisible, and gets confused by Emacs drawing its own cursor, so this
6447 variable is initialized to t when Emacs detects that screen reader
6448 software is running as it starts up.
6450 When this variable is set, other variables affecting the appearance of
6451 the cursor have no effect. */);
6453 w32_use_visible_system_caret
= 0;
6455 /* We don't yet support this, but defining this here avoids whining
6456 from cus-start.el and other places, like "M-x set-variable". */
6457 DEFVAR_BOOL ("x-use-underline-position-properties",
6458 &x_use_underline_position_properties
,
6459 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
6460 A value of nil means ignore them. If you encounter fonts with bogus
6461 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
6462 to 4.1, set this to nil.
6464 NOTE: Not supported on MS-Windows yet. */);
6465 x_use_underline_position_properties
= 0;
6467 DEFVAR_BOOL ("x-underline-at-descent-line",
6468 &x_underline_at_descent_line
,
6469 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
6470 A value of nil means to draw the underline according to the value of the
6471 variable `x-use-underline-position-properties', which is usually at the
6472 baseline level. The default value is nil. */);
6473 x_underline_at_descent_line
= 0;
6475 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
6476 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
6477 Vx_toolkit_scroll_bars
= Qt
;
6479 staticpro (&last_mouse_motion_frame
);
6480 last_mouse_motion_frame
= Qnil
;
6483 /* arch-tag: 5fa70624-ab86-499c-8a85-473958ee4646
6484 (do not change this comment) */