1 /* Implementation of GUI terminal on the Microsoft W32 API.
2 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 2006, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
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; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
28 #include "blockinput.h"
40 #include "character.h"
44 #include "dispextern.h"
46 #include "termhooks.h"
53 #include "intervals.h"
67 static int max_fringe_bmp
= 0;
68 static HBITMAP
*fringe_bmp
= 0;
70 /* Non-nil means Emacs uses toolkit scroll bars. */
72 Lisp_Object Vx_toolkit_scroll_bars
;
74 /* Temporary variables for w32_read_socket. */
76 static int last_mousemove_x
= 0;
77 static int last_mousemove_y
= 0;
79 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
80 #ifndef GET_WHEEL_DELTA_WPARAM
81 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
84 /* Non-zero means that a HELP_EVENT has been generated since Emacs
87 static int any_help_event_p
;
89 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
90 static Lisp_Object last_window
;
92 /* Non-zero means make use of UNDERLINE_POSITION font properties.
93 (Not yet supported, see TODO in x_draw_glyph_string.) */
94 int x_use_underline_position_properties
;
96 /* Non-zero means to draw the underline at the same place as the descent line. */
98 int x_underline_at_descent_line
;
100 extern unsigned int msh_mousewheel
;
102 extern void free_frame_menubar ();
104 extern int w32_codepage_for_font (char *fontname
);
105 extern Cursor
w32_load_cursor (LPCTSTR name
);
107 extern glyph_metric
*w32_BDF_TextMetric(bdffont
*fontp
,
108 unsigned char *text
, int dim
);
109 extern Lisp_Object Vwindow_system
;
111 #define x_any_window_to_frame x_window_to_frame
112 #define x_top_window_to_frame x_window_to_frame
115 /* This is display since w32 does not support multiple ones. */
116 struct w32_display_info one_w32_display_info
;
117 struct w32_display_info
*x_display_list
;
119 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
120 one for each element of w32_display_list and in the same order.
121 NAME is the name of the frame.
122 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
123 Lisp_Object w32_display_name_list
;
127 /* Pre Windows 2000, this was not available, but define it here so
128 that Emacs compiled on such a platform will run on newer versions. */
130 typedef struct tagWCRANGE
136 typedef struct tagGLYPHSET
140 DWORD cGlyphsSupported
;
147 /* Dynamic linking to GetFontUnicodeRanges (not available on 95, 98, ME). */
148 DWORD (PASCAL
*pfnGetFontUnicodeRanges
) (HDC device
, GLYPHSET
*ranges
);
150 /* Frame being updated by update_frame. This is declared in term.c.
151 This is set by update_begin and looked at by all the
152 w32 functions. It is zero while not inside an update.
153 In that case, the w32 functions assume that `SELECTED_FRAME ()'
154 is the frame to apply to. */
155 extern struct frame
*updating_frame
;
157 /* This is a frame waiting to be autoraised, within w32_read_socket. */
158 struct frame
*pending_autoraise_frame
;
160 /* The handle of the frame that currently owns the system caret. */
161 HWND w32_system_caret_hwnd
;
162 int w32_system_caret_height
;
163 int w32_system_caret_x
;
164 int w32_system_caret_y
;
165 int w32_use_visible_system_caret
;
167 /* Flag to enable Unicode output in case users wish to use programs
168 like Twinbridge on '95 rather than installed system level support
169 for Far East languages. */
170 int w32_enable_unicode_output
;
172 /* Flag to enable Cleartype hack for font metrics. */
173 static int cleartype_active
;
175 DWORD dwWindowsThreadId
= 0;
176 HANDLE hWindowsThread
= NULL
;
177 DWORD dwMainThreadId
= 0;
178 HANDLE hMainThread
= NULL
;
180 int vertical_scroll_bar_min_handle
;
181 int vertical_scroll_bar_top_border
;
182 int vertical_scroll_bar_bottom_border
;
184 int last_scroll_bar_drag_pos
;
186 /* Mouse movement. */
188 /* Where the mouse was last time we reported a mouse event. */
190 static RECT last_mouse_glyph
;
191 static FRAME_PTR last_mouse_glyph_frame
;
192 static Lisp_Object last_mouse_press_frame
;
194 int w32_num_mouse_buttons
;
196 Lisp_Object Vw32_swap_mouse_buttons
;
198 /* Control whether x_raise_frame also sets input focus. */
199 Lisp_Object Vw32_grab_focus_on_raise
;
201 /* Control whether Caps Lock affects non-ascii characters. */
202 Lisp_Object Vw32_capslock_is_shiftlock
;
204 /* Control whether right-alt and left-ctrl should be recognized as AltGr. */
205 Lisp_Object Vw32_recognize_altgr
;
207 /* The scroll bar in which the last motion event occurred.
209 If the last motion event occurred in a scroll bar, we set this
210 so w32_mouse_position can know whether to report a scroll bar motion or
213 If the last motion event didn't occur in a scroll bar, we set this
214 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
215 static Lisp_Object last_mouse_scroll_bar
;
216 static int last_mouse_scroll_bar_pos
;
218 /* This is a hack. We would really prefer that w32_mouse_position would
219 return the time associated with the position it returns, but there
220 doesn't seem to be any way to wrest the time-stamp from the server
221 along with the position query. So, we just keep track of the time
222 of the last movement we received, and return that in hopes that
223 it's somewhat accurate. */
225 static Time last_mouse_movement_time
;
227 /* Incremented by w32_read_socket whenever it really tries to read
231 static int volatile input_signal_count
;
233 static int input_signal_count
;
236 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
242 /* A mask of extra modifier bits to put into every keyboard char. */
244 extern EMACS_INT extra_keyboard_modifiers
;
246 static void x_update_window_end
P_ ((struct window
*, int, int));
247 static void w32_handle_tool_bar_click
P_ ((struct frame
*,
248 struct input_event
*));
249 static void w32_define_cursor
P_ ((Window
, Cursor
));
251 void x_lower_frame
P_ ((struct frame
*));
252 void x_scroll_bar_clear
P_ ((struct frame
*));
253 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
254 void x_raise_frame
P_ ((struct frame
*));
255 void x_set_window_size
P_ ((struct frame
*, int, int, int));
256 void x_wm_set_window_state
P_ ((struct frame
*, int));
257 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
258 static void w32_initialize
P_ ((void));
259 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
260 int x_compute_min_glyph_bounds
P_ ((struct frame
*));
261 static void x_update_end
P_ ((struct frame
*));
262 static void w32_frame_up_to_date
P_ ((struct frame
*));
263 static void w32_set_terminal_modes
P_ ((struct terminal
*));
264 static void w32_reset_terminal_modes
P_ ((struct terminal
*));
265 static void x_clear_frame
P_ ((struct frame
*));
266 static void frame_highlight
P_ ((struct frame
*));
267 static void frame_unhighlight
P_ ((struct frame
*));
268 static void x_new_focus_frame
P_ ((struct w32_display_info
*,
270 static void x_focus_changed
P_ ((int, int, struct w32_display_info
*,
271 struct frame
*, struct input_event
*));
272 static void w32_detect_focus_change
P_ ((struct w32_display_info
*,
273 W32Msg
*, struct input_event
*));
274 static void w32_frame_rehighlight
P_ ((struct frame
*));
275 static void x_frame_rehighlight
P_ ((struct w32_display_info
*));
276 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
277 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
278 enum text_cursor_kinds
));
279 static void w32_clip_to_row
P_ ((struct window
*, struct glyph_row
*, int, HDC
));
280 static BOOL my_show_window
P_ ((struct frame
*, HWND
, int));
281 static void my_set_window_pos
P_ ((HWND
, HWND
, int, int, int, int, UINT
));
282 static void my_set_focus
P_ ((struct frame
*, HWND
));
283 static void my_set_foreground_window
P_ ((HWND
));
284 static void my_destroy_window
P_ ((struct frame
*, HWND
));
286 static Lisp_Object Qvendor_specific_keysyms
;
289 /***********************************************************************
291 ***********************************************************************/
295 /* This is a function useful for recording debugging information about
296 the sequence of occurrences in this file. */
304 struct record event_record
[100];
306 int event_record_index
;
308 record_event (locus
, type
)
312 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
313 event_record_index
= 0;
315 event_record
[event_record_index
].locus
= locus
;
316 event_record
[event_record_index
].type
= type
;
317 event_record_index
++;
324 XChangeGC (void * ignore
, XGCValues
* gc
, unsigned long mask
,
327 if (mask
& GCForeground
)
328 gc
->foreground
= xgcv
->foreground
;
329 if (mask
& GCBackground
)
330 gc
->background
= xgcv
->background
;
332 gc
->font
= xgcv
->font
;
335 XGCValues
*XCreateGC (void * ignore
, Window window
, unsigned long mask
,
338 XGCValues
*gc
= (XGCValues
*) xmalloc (sizeof (XGCValues
));
339 bzero (gc
, sizeof (XGCValues
));
341 XChangeGC (ignore
, gc
, mask
, xgcv
);
347 XGetGCValues (void* ignore
, XGCValues
*gc
,
348 unsigned long mask
, XGCValues
*xgcv
)
350 XChangeGC (ignore
, xgcv
, mask
, gc
);
354 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
358 HRGN clip_region
= CreateRectRgnIndirect (rect
);
359 SelectClipRgn (hdc
, clip_region
);
360 DeleteObject (clip_region
);
363 SelectClipRgn (hdc
, NULL
);
367 /* Draw a hollow rectangle at the specified position. */
369 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
370 int width
, int height
)
375 hb
= CreateSolidBrush (gc
->background
);
376 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
377 oldhb
= SelectObject (hdc
, hb
);
378 oldhp
= SelectObject (hdc
, hp
);
380 Rectangle (hdc
, x
, y
, x
+ width
, y
+ height
);
382 SelectObject (hdc
, oldhb
);
383 SelectObject (hdc
, oldhp
);
388 /* Draw a filled rectangle at the specified position. */
390 w32_fill_rect (f
, hdc
, pix
, lprect
)
398 hb
= CreateSolidBrush (pix
);
399 FillRect (hdc
, lprect
, hb
);
408 HDC hdc
= get_frame_dc (f
);
410 /* Under certain conditions, this can be called at startup with
411 a console frame pointer before the GUI frame is created. An HDC
412 of 0 indicates this. */
415 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
416 w32_clear_rect (f
, hdc
, &rect
);
419 release_frame_dc (f
, hdc
);
423 /***********************************************************************
424 Starting and ending an update
425 ***********************************************************************/
427 /* Start an update of frame F. This function is installed as a hook
428 for update_begin, i.e. it is called when update_begin is called.
429 This function is called prior to calls to x_update_window_begin for
430 each window being updated. */
436 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
438 if (! FRAME_W32_P (f
))
441 /* Regenerate display palette before drawing if list of requested
442 colors has changed. */
443 if (display_info
->regen_palette
)
445 w32_regenerate_palette (f
);
446 display_info
->regen_palette
= FALSE
;
451 /* Start update of window W. Set the global variable updated_window
452 to the window being updated and set output_cursor to the cursor
456 x_update_window_begin (w
)
459 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
460 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
462 /* Hide the system caret during an update. */
463 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
465 SendMessage (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0);
469 set_output_cursor (&w
->cursor
);
473 if (f
== display_info
->mouse_face_mouse_frame
)
475 /* Don't do highlighting for mouse motion during the update. */
476 display_info
->mouse_face_defer
= 1;
478 /* If F needs to be redrawn, simply forget about any prior mouse
480 if (FRAME_GARBAGED_P (f
))
481 display_info
->mouse_face_window
= Qnil
;
483 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
484 their mouse_face_p flag set, which means that they are always
485 unequal to rows in a desired matrix which never have that
486 flag set. So, rows containing mouse-face glyphs are never
487 scrolled, and we don't have to switch the mouse highlight off
488 here to prevent it from being scrolled. */
490 /* Can we tell that this update does not affect the window
491 where the mouse highlight is? If so, no need to turn off.
492 Likewise, don't do anything if the frame is garbaged;
493 in that case, the frame's current matrix that we would use
494 is all wrong, and we will redisplay that line anyway. */
495 if (!NILP (display_info
->mouse_face_window
)
496 && w
== XWINDOW (display_info
->mouse_face_window
))
500 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
501 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
504 if (i
< w
->desired_matrix
->nrows
)
505 clear_mouse_face (display_info
);
513 /* Draw a vertical window border from (x,y0) to (x,y1) */
516 w32_draw_vertical_window_border (w
, x
, y0
, y1
)
520 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
530 hdc
= get_frame_dc (f
);
531 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
533 w32_fill_rect (f
, hdc
, face
->foreground
, &r
);
535 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
537 release_frame_dc (f
, hdc
);
541 /* End update of window W (which is equal to updated_window).
543 Draw vertical borders between horizontally adjacent windows, and
544 display W's cursor if CURSOR_ON_P is non-zero.
546 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
547 glyphs in mouse-face were overwritten. In that case we have to
548 make sure that the mouse-highlight is properly redrawn.
550 W may be a menu bar pseudo-window in case we don't have X toolkit
551 support. Such windows don't have a cursor, so don't display it
555 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
557 int cursor_on_p
, mouse_face_overwritten_p
;
559 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
561 if (!w
->pseudo_window_p
)
566 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
568 output_cursor
.x
, output_cursor
.y
);
570 if (draw_window_fringes (w
, 1))
571 x_draw_vertical_border (w
);
576 /* If a row with mouse-face was overwritten, arrange for
577 XTframe_up_to_date to redisplay the mouse highlight. */
578 if (mouse_face_overwritten_p
)
580 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
581 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
582 dpyinfo
->mouse_face_window
= Qnil
;
585 /* Unhide the caret. This won't actually show the cursor, unless it
586 was visible before the corresponding call to HideCaret in
587 x_update_window_begin. */
588 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
590 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
593 updated_window
= NULL
;
597 /* End update of frame F. This function is installed as a hook in
604 if (! FRAME_W32_P (f
))
607 /* Mouse highlight may be displayed again. */
608 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
612 /* This function is called from various places in xdisp.c whenever a
613 complete update has been performed. The global variable
614 updated_window is not available here. */
617 w32_frame_up_to_date (f
)
622 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
624 if (dpyinfo
->mouse_face_deferred_gc
625 || f
== dpyinfo
->mouse_face_mouse_frame
)
628 if (dpyinfo
->mouse_face_mouse_frame
)
629 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
630 dpyinfo
->mouse_face_mouse_x
,
631 dpyinfo
->mouse_face_mouse_y
);
632 dpyinfo
->mouse_face_deferred_gc
= 0;
639 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
640 arrow bitmaps, or clear the fringes if no bitmaps are required
641 before DESIRED_ROW is made current. The window being updated is
642 found in updated_window. This function is called from
643 update_window_line only if it is known that there are differences
644 between bitmaps to be drawn between current row and DESIRED_ROW. */
647 x_after_update_window_line (desired_row
)
648 struct glyph_row
*desired_row
;
650 struct window
*w
= updated_window
;
656 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
657 desired_row
->redraw_fringe_bitmaps_p
= 1;
659 /* When a window has disappeared, make sure that no rest of
660 full-width rows stays visible in the internal border. Could
661 check here if updated_window is the leftmost/rightmost window,
662 but I guess it's not worth doing since vertically split windows
663 are almost never used, internal border is rarely set, and the
664 overhead is very small. */
665 if (windows_or_buffers_changed
666 && desired_row
->full_width_p
667 && (f
= XFRAME (w
->frame
),
668 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
670 && (height
= desired_row
->visible_height
,
673 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
675 /* Internal border is drawn below the tool bar. */
676 if (WINDOWP (f
->tool_bar_window
)
677 && w
== XWINDOW (f
->tool_bar_window
))
682 HDC hdc
= get_frame_dc (f
);
683 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
684 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
686 release_frame_dc (f
, hdc
);
693 /* Draw the bitmap WHICH in one of the left or right fringes of
694 window W. ROW is the glyph row for which to display the bitmap; it
695 determines the vertical position at which the bitmap has to be
699 w32_draw_fringe_bitmap (w
, row
, p
)
701 struct glyph_row
*row
;
702 struct draw_fringe_bitmap_params
*p
;
704 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
706 struct face
*face
= p
->face
;
709 hdc
= get_frame_dc (f
);
713 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
715 /* If the fringe is adjacent to the left (right) scroll bar of a
716 leftmost (rightmost, respectively) window, then extend its
717 background to the gap between the fringe and the bar. */
718 if ((WINDOW_LEFTMOST_P (w
)
719 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
720 || (WINDOW_RIGHTMOST_P (w
)
721 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
723 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
727 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
728 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
729 * FRAME_COLUMN_WIDTH (f
));
733 /* Bitmap fills the fringe. */
734 if (left
+ width
== p
->x
)
735 bx
= left
+ sb_width
;
736 else if (p
->x
+ p
->wd
== left
)
740 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
742 nx
= width
- sb_width
;
743 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
745 ny
= row
->visible_height
;
750 if (left
+ width
== bx
)
752 bx
= left
+ sb_width
;
753 nx
+= width
- sb_width
;
755 else if (bx
+ nx
== left
)
756 nx
+= width
- sb_width
;
761 if (bx
>= 0 && nx
> 0)
762 w32_fill_area (f
, hdc
, face
->background
, bx
, by
, nx
, ny
);
765 /* Must clip because of partially visible lines. */
766 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
769 /* Adjust position of "bottom aligned" bitmap on partially
772 int oldVH
= row
->visible_height
;
773 row
->visible_height
= p
->h
;
774 row
->y
-= rowY
- p
->y
;
775 w32_clip_to_row (w
, row
, -1, hdc
);
777 row
->visible_height
= oldVH
;
780 w32_clip_to_row (w
, row
, -1, hdc
);
782 if (p
->which
&& p
->which
< max_fringe_bmp
)
784 HBITMAP pixmap
= fringe_bmp
[p
->which
];
788 compat_hdc
= CreateCompatibleDC (hdc
);
792 horig_obj
= SelectObject (compat_hdc
, pixmap
);
794 /* Paint overlays transparently. */
797 HBRUSH h_brush
, h_orig_brush
;
799 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
800 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
801 h_brush
= CreateSolidBrush (face
->foreground
);
802 h_orig_brush
= SelectObject (hdc
, h_brush
);
804 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
805 compat_hdc
, 0, p
->dh
,
807 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
808 compat_hdc
, 0, p
->dh
,
810 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
811 compat_hdc
, 0, p
->dh
,
814 SelectObject (hdc
, h_orig_brush
);
815 DeleteObject (h_brush
);
819 SetTextColor (hdc
, face
->background
);
820 SetBkColor (hdc
, (p
->cursor_p
821 ? f
->output_data
.w32
->cursor_pixel
822 : face
->foreground
));
824 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
825 compat_hdc
, 0, p
->dh
,
829 SelectObject (compat_hdc
, horig_obj
);
830 DeleteDC (compat_hdc
);
834 w32_set_clip_rectangle (hdc
, NULL
);
836 release_frame_dc (f
, hdc
);
840 w32_define_fringe_bitmap (which
, bits
, h
, wd
)
842 unsigned short *bits
;
845 if (which
>= max_fringe_bmp
)
847 int i
= max_fringe_bmp
;
848 max_fringe_bmp
= which
+ 20;
849 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
850 while (i
< max_fringe_bmp
)
854 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
858 w32_destroy_fringe_bitmap (which
)
861 if (which
>= max_fringe_bmp
)
864 if (fringe_bmp
[which
])
865 DeleteObject (fringe_bmp
[which
]);
866 fringe_bmp
[which
] = 0;
871 /* This is called when starting Emacs and when restarting after
872 suspend. When starting Emacs, no window is mapped. And nothing
873 must be done to Emacs's own window if it is suspended (though that
877 w32_set_terminal_modes (struct terminal
*term
)
881 /* This is called when exiting or suspending Emacs. Exiting will make
882 the W32 windows go away, and suspending requires no action. */
885 w32_reset_terminal_modes (struct terminal
*term
)
891 /***********************************************************************
893 ***********************************************************************/
895 /* Function prototypes of this page. */
899 XCharStruct
*w32_per_char_metric
P_ ((XFontStruct
*, wchar_t *, int));
900 static int w32_encode_char
P_ ((int, wchar_t *, struct font_info
*,
901 struct charset
*, int *));
904 /* Get metrics of character CHAR2B in FONT. Value is always non-null.
905 If CHAR2B is not contained in FONT, the font's default character
906 metric is returned. */
909 w32_bdf_per_char_metric (font
, char2b
, dim
, pcm
)
915 glyph_metric
* bdf_metric
;
919 buf
[0] = (char)(*char2b
);
922 buf
[0] = XCHAR2B_BYTE1 (char2b
);
923 buf
[1] = XCHAR2B_BYTE2 (char2b
);
926 bdf_metric
= w32_BDF_TextMetric (font
->bdf
, buf
, dim
);
930 pcm
->width
= bdf_metric
->dwidth
;
931 pcm
->lbearing
= bdf_metric
->bbox
;
932 pcm
->rbearing
= bdf_metric
->dwidth
933 - (bdf_metric
->bbox
+ bdf_metric
->bbw
);
934 pcm
->ascent
= bdf_metric
->bboy
+ bdf_metric
->bbh
;
935 pcm
->descent
= -bdf_metric
->bboy
;
944 w32_native_per_char_metric (font
, char2b
, font_type
, pcm
)
947 enum w32_char_font_type font_type
;
950 HDC hdc
= GetDC (NULL
);
954 xassert (font
&& char2b
);
955 xassert (font
->hfont
);
956 xassert (font_type
== UNICODE_FONT
|| font_type
== ANSI_FONT
);
958 old_font
= SelectObject (hdc
, font
->hfont
);
960 if ((font
->tm
.tmPitchAndFamily
& TMPF_TRUETYPE
) != 0)
964 if (font_type
== UNICODE_FONT
)
965 retval
= GetCharABCWidthsW (hdc
, *char2b
, *char2b
, &char_widths
);
967 retval
= GetCharABCWidthsA (hdc
, *char2b
, *char2b
, &char_widths
);
972 /* Disabled until we can find a way to get the right results
973 on all versions of Windows. */
975 /* Don't trust the ABC widths. For synthesized fonts they are
976 wrong, and so is the result of GetCharWidth()! */
978 GetCharWidth (hdc
, *char2b
, *char2b
, &real_width
);
980 if (cleartype_active
)
982 /* Cleartype antialiasing causes characters to overhang
983 by a pixel on each side compared with what GetCharABCWidths
985 char_widths
.abcA
-= 1;
986 char_widths
.abcC
-= 1;
987 char_widths
.abcB
+= 2;
990 pcm
->width
= char_widths
.abcA
+ char_widths
.abcB
+ char_widths
.abcC
;
992 /* As far as I can tell, this is the best way to determine what
993 ExtTextOut will do with the broken font. */
994 if (pcm
->width
!= real_width
)
995 pcm
->width
= (pcm
->width
+ real_width
) / 2;
997 pcm
->lbearing
= char_widths
.abcA
;
998 pcm
->rbearing
= char_widths
.abcA
+ char_widths
.abcB
;
999 pcm
->ascent
= FONT_BASE (font
);
1000 pcm
->descent
= FONT_DESCENT (font
);
1006 /* Either font is not a True-type font, or GetCharABCWidthsW
1007 failed (it is not supported on Windows 9x for instance), so we
1008 can't determine the full info we would like. All is not lost
1009 though - we can call GetTextExtentPoint32 to get rbearing and
1010 deduce width based on the font's per-string overhang. lbearing
1011 is assumed to be zero. */
1013 /* TODO: Some Thai characters (and other composites if Windows
1014 supports them) do have lbearing, and report their total width
1015 as zero. Need some way of handling them when
1016 GetCharABCWidthsW fails. */
1019 if (font_type
== UNICODE_FONT
)
1020 retval
= GetTextExtentPoint32W (hdc
, char2b
, 1, &sz
);
1022 retval
= GetTextExtentPoint32A (hdc
, (char*)char2b
, 1, &sz
);
1027 pcm
->rbearing
= sz
.cx
+ font
->tm
.tmOverhang
;
1029 pcm
->ascent
= FONT_BASE (font
);
1030 pcm
->descent
= FONT_DESCENT (font
);
1035 if (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0)
1040 SelectObject (hdc
, old_font
);
1041 ReleaseDC (NULL
, hdc
);
1048 w32_per_char_metric (font
, char2b
, font_type
)
1051 int /* enum w32_char_font_type */ font_type
;
1053 /* The result metric information. */
1057 xassert (font
&& char2b
);
1059 /* TODO: This function is currently called through the RIF, and in
1060 some cases font_type is UNKNOWN_FONT. We currently allow the
1061 cached metrics to be used, which seems to work, but in cases
1062 where font_type is UNKNOWN_FONT, we probably haven't encoded
1063 char2b appropriately. All callers need checking to see what they
1064 are passing. This is most likely to affect variable width fonts
1065 outside the Latin-1 range, particularly in languages like Thai
1066 that rely on rbearing and lbearing to provide composition. I
1067 don't think that is working currently anyway, but we don't seem
1068 to have anyone testing such languages on Windows. */
1070 /* Handle the common cases quickly. */
1071 if (!font
->bdf
&& font
->per_char
== NULL
)
1072 /* TODO: determine whether char2b exists in font? */
1073 return &font
->max_bounds
;
1074 else if (!font
->bdf
&& *char2b
< 128)
1075 return &font
->per_char
[*char2b
];
1077 xassert (font_type
!= UNKNOWN_FONT
);
1079 pcm
= &font
->scratch
;
1081 if (font_type
== BDF_1D_FONT
)
1082 retval
= w32_bdf_per_char_metric (font
, char2b
, 1, pcm
);
1083 else if (font_type
== BDF_2D_FONT
)
1084 retval
= w32_bdf_per_char_metric (font
, char2b
, 2, pcm
);
1086 retval
= w32_native_per_char_metric (font
, char2b
, font_type
, pcm
);
1095 w32_cache_char_metrics (font
)
1098 wchar_t char2b
= L
'x';
1100 /* Cache char metrics for the common cases. */
1103 /* TODO: determine whether font is fixed-pitch. */
1104 if (!w32_bdf_per_char_metric (font
, &char2b
, 1, &font
->max_bounds
))
1106 /* Use the font width and height as max bounds, as not all BDF
1107 fonts contain the letter 'x'. */
1108 font
->max_bounds
.width
= FONT_WIDTH (font
);
1109 font
->max_bounds
.lbearing
= -font
->bdf
->llx
;
1110 font
->max_bounds
.rbearing
= FONT_WIDTH (font
) - font
->bdf
->urx
;
1111 font
->max_bounds
.ascent
= FONT_BASE (font
);
1112 font
->max_bounds
.descent
= FONT_DESCENT (font
);
1117 if (((font
->tm
.tmPitchAndFamily
& TMPF_FIXED_PITCH
) != 0)
1118 /* Some fonts (eg DBCS fonts) are marked as fixed width even
1119 though they contain characters of different widths. */
1120 || (font
->tm
.tmMaxCharWidth
!= font
->tm
.tmAveCharWidth
))
1122 /* Font is not fixed pitch, so cache per_char info for the
1123 ASCII characters. It would be much more work, and probably
1124 not worth it, to cache other chars, since we may change
1125 between using Unicode and ANSI text drawing functions at
1129 font
->per_char
= xmalloc (128 * sizeof(XCharStruct
));
1130 for (i
= 0; i
< 128; i
++)
1133 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1134 &font
->per_char
[i
]);
1138 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1143 /* Determine if a font is double byte. */
1145 w32_font_is_double_byte (XFontStruct
*font
)
1147 return font
->double_byte_p
;
1152 w32_use_unicode_for_codepage (codepage
)
1155 /* If the current codepage is supported, use Unicode for output. */
1156 return (w32_enable_unicode_output
1157 && codepage
!= CP_8BIT
1158 && (codepage
== CP_UNICODE
|| IsValidCodePage (codepage
)));
1161 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1162 the two-byte form of C. Encoding is returned in *CHAR2B. */
1164 static int /* enum w32_char_font_type */
1165 w32_encode_char (c
, char2b
, font_info
, charset
, two_byte_p
)
1168 struct font_info
*font_info
;
1169 struct charset
*charset
;
1174 int internal_two_byte_p
= 0;
1176 XFontStruct
*font
= font_info
->font
;
1178 internal_two_byte_p
= w32_font_is_double_byte (font
);
1179 codepage
= font_info
->codepage
;
1181 /* If font can output unicode, use the original unicode character. */
1182 if ( font
&& !font
->bdf
&& w32_use_unicode_for_codepage (codepage
)
1187 internal_two_byte_p
= 1;
1190 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1191 This may be either a program in a special encoder language or a
1193 else if (font_info
->font_encoder
)
1195 /* It's a program. */
1196 struct ccl_program
*ccl
= font_info
->font_encoder
;
1198 if (CHARSET_DIMENSION (charset
) == 1)
1200 ccl
->reg
[0] = CHARSET_ID (charset
);
1201 ccl
->reg
[1] = XCHAR2B_BYTE2 (char2b
);
1206 ccl
->reg
[0] = CHARSET_ID (charset
);
1207 ccl
->reg
[1] = XCHAR2B_BYTE1 (char2b
);
1208 ccl
->reg
[2] = XCHAR2B_BYTE2 (char2b
);
1211 ccl_driver (ccl
, NULL
, NULL
, 0, 0, Qnil
);
1213 /* We assume that MSBs are appropriately set/reset by CCL
1215 if (!internal_two_byte_p
) /* 1-byte font */
1216 STORE_XCHAR2B (char2b
, 0, ccl
->reg
[1]);
1218 STORE_XCHAR2B (char2b
, ccl
->reg
[1], ccl
->reg
[2]);
1220 else if (font_info
->encoding_type
)
1222 /* Fixed encoding scheme. See fontset.h for the meaning of the
1223 encoding numbers. */
1224 unsigned char enc
= font_info
->encoding_type
;
1226 if ((enc
== 1 || enc
== 2)
1227 && CHARSET_DIMENSION (charset
) == 2)
1228 STORE_XCHAR2B (char2b
, XCHAR2B_BYTE1 (char2b
) | 0x80, XCHAR2B_BYTE2 (char2b
));
1230 if (enc
== 1 || enc
== 3 || (enc
== 4 && CHARSET_DIMENSION (charset
) == 1))
1231 STORE_XCHAR2B (char2b
, XCHAR2B_BYTE1 (char2b
), XCHAR2B_BYTE2 (char2b
) | 0x80);
1234 int code
= (int) (*char2b
);
1237 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
1242 *two_byte_p
= internal_two_byte_p
;
1245 return UNKNOWN_FONT
;
1246 else if (font
->bdf
&& CHARSET_DIMENSION (charset
) == 1)
1251 return UNICODE_FONT
;
1257 /* Return a char-table whose elements are t if the font FONT_INFO
1258 contains a glyph for the corresponding character, and nil if not.
1260 Fixme: For the moment, this function works only for fonts whose
1261 glyph encoding is the same as Unicode (e.g. ISO10646-1 fonts). */
1264 x_get_font_repertory (f
, font_info
)
1266 struct font_info
*font_info
;
1268 XFontStruct
*font
= (XFontStruct
*) font_info
->font
;
1270 int min_byte1
, max_byte1
, min_byte2
, max_byte2
;
1272 struct charset
*charset
= CHARSET_FROM_ID (font_info
->charset
);
1273 int offset
= CHARSET_OFFSET (charset
);
1275 table
= Fmake_char_table (Qnil
, Qnil
);
1277 if (!font
->bdf
&& pfnGetFontUnicodeRanges
)
1280 DWORD glyphset_size
;
1281 HDC display
= get_frame_dc (f
);
1285 prev_font
= SelectObject (display
, font
->hfont
);
1287 /* First call GetFontUnicodeRanges to find out how big a structure
1289 glyphset_size
= pfnGetFontUnicodeRanges (display
, NULL
);
1292 glyphset
= (GLYPHSET
*) alloca (glyphset_size
);
1293 glyphset
->cbThis
= glyphset_size
;
1295 /* Now call it again to get the ranges. */
1296 glyphset_size
= pfnGetFontUnicodeRanges (display
, glyphset
);
1300 /* Store the ranges in TABLE. */
1301 for (i
= 0; i
< glyphset
->cRanges
; i
++)
1303 int from
= glyphset
->ranges
[i
].wcLow
;
1304 int to
= from
+ glyphset
->ranges
[i
].cGlyphs
- 1;
1305 char_table_set_range (table
, from
, to
, Qt
);
1310 SelectObject (display
, prev_font
);
1311 release_frame_dc (f
, display
);
1313 /* If we got the information we wanted above, then return it. */
1318 #if 0 /* TODO: Convert to work on Windows so BDF and older platforms work. */
1319 /* When GetFontUnicodeRanges is not available or does not work,
1320 work it out manually. */
1321 min_byte1
= font
->min_byte1
;
1322 max_byte1
= font
->max_byte1
;
1323 min_byte2
= font
->min_char_or_byte2
;
1324 max_byte2
= font
->max_char_or_byte2
;
1325 if (min_byte1
== 0 && max_byte1
== 0)
1327 if (! font
->per_char
|| font
->all_chars_exist
== True
)
1330 char_table_set_range (table
, offset
+ min_byte2
,
1331 offset
+ max_byte2
, Qt
);
1333 for (; min_byte2
<= max_byte2
; min_byte2
++)
1335 c
= DECODE_CHAR (charset
, min_byte2
);
1336 CHAR_TABLE_SET (table
, c
, Qt
);
1341 XCharStruct
*pcm
= font
->per_char
;
1345 for (i
= min_byte2
; i
<= max_byte2
; i
++, pcm
++)
1347 if (pcm
->width
== 0 && pcm
->rbearing
== pcm
->lbearing
)
1352 char_table_set_range (table
, offset
+ from
,
1353 offset
+ i
- 1, Qt
);
1355 for (; from
< i
; from
++)
1357 c
= DECODE_CHAR (charset
, from
);
1358 CHAR_TABLE_SET (table
, c
, Qt
);
1369 char_table_set_range (table
, offset
+ from
, offset
+ i
- 1,
1372 for (; from
< i
; from
++)
1374 c
= DECODE_CHAR (charset
, from
);
1375 CHAR_TABLE_SET (table
, c
, Qt
);
1382 if (! font
->per_char
|| font
->all_chars_exist
== True
)
1387 for (i
= min_byte1
; i
<= max_byte1
; i
++)
1388 char_table_set_range
1389 (table
, offset
+ ((i
<< 8) | min_byte2
),
1390 offset
+ ((i
<< 8) | max_byte2
), Qt
);
1392 for (i
= min_byte1
; i
<= max_byte1
; i
++)
1393 for (j
= min_byte2
; j
<= max_byte2
; j
++)
1395 unsiged code
= (i
<< 8) | j
;
1396 c
= DECODE_CHAR (charset
, code
);
1397 CHAR_TABLE_SET (table
, c
, Qt
);
1402 XCharStruct
*pcm
= font
->per_char
;
1405 for (i
= min_byte1
; i
<= max_byte1
; i
++)
1410 for (j
= min_byte2
; j
<= max_byte2
; j
++, pcm
++)
1412 if (pcm
->width
== 0 && pcm
->rbearing
== pcm
->lbearing
)
1417 char_table_set_range
1418 (table
, offset
+ ((i
<< 8) | from
),
1419 offset
+ ((i
<< 8) | (j
- 1)), Qt
);
1422 for (; from
< j
; from
++)
1424 unsigned code
= (i
<< 8) | from
;
1425 c
= ENCODE_CHAR (charset
, code
);
1426 CHAR_TABLE_SET (table
, c
, Qt
);
1438 char_table_set_range
1439 (table
, offset
+ ((i
<< 8) | from
),
1440 offset
+ ((i
<< 8) | (j
- 1)), Qt
);
1443 for (; from
< j
; from
++)
1445 unsigned code
= (i
<< 8) | from
;
1446 c
= DECODE_CHAR (charset
, code
);
1447 CHAR_TABLE_SET (table
, c
, Qt
);
1459 /***********************************************************************
1461 ***********************************************************************/
1464 /* Encapsulate the different ways of displaying text under W32. */
1467 w32_text_out (s
, x
, y
,chars
,nchars
)
1468 struct glyph_string
* s
;
1473 int charset_dim
= w32_font_is_double_byte (s
->font
) ? 2 : 1;
1475 w32_BDF_TextOut (s
->font
->bdf
, s
->hdc
,
1476 x
, y
, (char *) chars
, charset_dim
,
1477 nchars
* charset_dim
, 0);
1478 else if (s
->first_glyph
->font_type
== UNICODE_FONT
)
1479 ExtTextOutW (s
->hdc
, x
, y
, 0, NULL
, chars
, nchars
, NULL
);
1481 ExtTextOutA (s
->hdc
, x
, y
, 0, NULL
, (char *) chars
,
1482 nchars
* charset_dim
, NULL
);
1485 #endif /* OLD_FONT */
1487 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
1488 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
1489 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
1491 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
1492 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
1493 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
1494 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
1495 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
1496 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
1497 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
1498 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
1499 static void w32_setup_relief_color
P_ ((struct frame
*, struct relief
*,
1500 double, int, COLORREF
));
1501 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
1502 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
1503 static void x_draw_image_relief
P_ ((struct glyph_string
*));
1504 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
1505 static void w32_draw_image_foreground_1
P_ ((struct glyph_string
*, HBITMAP
));
1506 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
1508 static void w32_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
1509 int, int, int, int, int, int,
1511 static void w32_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
1512 int, int, int, RECT
*));
1515 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
1519 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1524 struct glyph_string
*s
;
1526 if (s
->font
== FRAME_FONT (s
->f
)
1527 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1528 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1530 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
1533 /* Cursor on non-default face: must merge. */
1537 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
1538 xgcv
.foreground
= s
->face
->background
;
1540 /* If the glyph would be invisible, try a different foreground. */
1541 if (xgcv
.foreground
== xgcv
.background
)
1542 xgcv
.foreground
= s
->face
->foreground
;
1543 if (xgcv
.foreground
== xgcv
.background
)
1544 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
1545 if (xgcv
.foreground
== xgcv
.background
)
1546 xgcv
.foreground
= s
->face
->foreground
;
1548 /* Make sure the cursor is distinct from text in this face. */
1549 if (xgcv
.background
== s
->face
->background
1550 && xgcv
.foreground
== s
->face
->foreground
)
1552 xgcv
.background
= s
->face
->foreground
;
1553 xgcv
.foreground
= s
->face
->background
;
1556 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1557 xgcv
.font
= s
->font
;
1558 mask
= GCForeground
| GCBackground
| GCFont
;
1560 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1561 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1564 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1565 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1567 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1572 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1575 x_set_mouse_face_gc (s
)
1576 struct glyph_string
*s
;
1581 /* What face has to be used last for the mouse face? */
1582 face_id
= FRAME_W32_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1583 face
= FACE_FROM_ID (s
->f
, face_id
);
1585 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1587 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1588 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1590 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1591 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1592 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1594 /* If font in this face is same as S->font, use it. */
1595 if (s
->font
== s
->face
->font
)
1596 s
->gc
= s
->face
->gc
;
1599 /* Otherwise construct scratch_cursor_gc with values from FACE
1604 xgcv
.background
= s
->face
->background
;
1605 xgcv
.foreground
= s
->face
->foreground
;
1606 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1607 xgcv
.font
= s
->font
;
1608 mask
= GCForeground
| GCBackground
| GCFont
;
1610 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1611 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1614 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1615 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1617 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1620 xassert (s
->gc
!= 0);
1624 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1625 Faces to use in the mode line have already been computed when the
1626 matrix was built, so there isn't much to do, here. */
1629 x_set_mode_line_face_gc (s
)
1630 struct glyph_string
*s
;
1632 s
->gc
= s
->face
->gc
;
1636 /* Set S->gc of glyph string S for drawing that glyph string. Set
1637 S->stippled_p to a non-zero value if the face of S has a stipple
1641 x_set_glyph_string_gc (s
)
1642 struct glyph_string
*s
;
1644 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1646 if (s
->hl
== DRAW_NORMAL_TEXT
)
1648 s
->gc
= s
->face
->gc
;
1649 s
->stippled_p
= s
->face
->stipple
!= 0;
1651 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1653 x_set_mode_line_face_gc (s
);
1654 s
->stippled_p
= s
->face
->stipple
!= 0;
1656 else if (s
->hl
== DRAW_CURSOR
)
1658 x_set_cursor_gc (s
);
1661 else if (s
->hl
== DRAW_MOUSE_FACE
)
1663 x_set_mouse_face_gc (s
);
1664 s
->stippled_p
= s
->face
->stipple
!= 0;
1666 else if (s
->hl
== DRAW_IMAGE_RAISED
1667 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1669 s
->gc
= s
->face
->gc
;
1670 s
->stippled_p
= s
->face
->stipple
!= 0;
1674 s
->gc
= s
->face
->gc
;
1675 s
->stippled_p
= s
->face
->stipple
!= 0;
1678 /* GC must have been set. */
1679 xassert (s
->gc
!= 0);
1683 /* Set clipping for output of glyph string S. S may be part of a mode
1684 line or menu if we don't have X toolkit support. */
1687 x_set_glyph_string_clipping (s
)
1688 struct glyph_string
*s
;
1691 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1694 w32_set_clip_rectangle (s
->hdc
, r
);
1697 HRGN full_clip
, clip1
, clip2
;
1698 clip1
= CreateRectRgnIndirect (r
);
1699 clip2
= CreateRectRgnIndirect (r
+ 1);
1700 if (CombineRgn (full_clip
, clip1
, clip2
, RGN_OR
) != ERROR
)
1702 SelectClipRgn (s
->hdc
, full_clip
);
1704 DeleteObject (clip1
);
1705 DeleteObject (clip2
);
1706 DeleteObject (full_clip
);
1711 /* Set SRC's clipping for output of glyph string DST. This is called
1712 when we are drawing DST's left_overhang or right_overhang only in
1716 x_set_glyph_string_clipping_exactly (src
, dst
)
1717 struct glyph_string
*src
, *dst
;
1722 r
.right
= r
.left
+ src
->width
;
1724 r
.bottom
= r
.top
+ src
->height
;
1729 struct glyph_string
*clip_head
= src
->clip_head
;
1730 struct glyph_string
*clip_tail
= src
->clip_tail
;
1732 /* This foces clipping just this glyph string. */
1733 src
->clip_head
= src
->clip_tail
= src
;
1734 get_glyph_string_clip_rect (src
, &r
);
1735 src
->clip_head
= clip_head
, src
->clip_tail
= clip_tail
;
1737 #endif /* OLD_FONT */
1738 w32_set_clip_rectangle (dst
->hdc
, &r
);
1742 Compute left and right overhang of glyph string S. */
1745 w32_compute_glyph_string_overhangs (s
)
1746 struct glyph_string
*s
;
1749 && s
->first_glyph
->type
== CHAR_GLYPH
1750 && !s
->font_not_found_p
)
1752 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1753 struct font
*font
= s
->font
;
1754 struct font_metrics metrics
;
1757 for (i
= 0; i
< s
->nchars
; i
++)
1758 code
[i
] = s
->char2b
[i
];
1759 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1760 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1761 ? metrics
.rbearing
- metrics
.width
: 0);
1762 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1766 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1767 s
->left_overhang
= -s
->cmp
->lbearing
;
1773 w32_get_glyph_overhangs (glyph
, f
, left
, right
)
1774 struct glyph
*glyph
;
1778 HDC hdc
= get_frame_dc (f
);
1779 /* Convert to unicode! */
1780 x_get_glyph_overhangs (glyph
, f
, left
, right
);
1781 release_frame_dc (f
, hdc
);
1785 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1788 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1789 struct glyph_string
*s
;
1797 /* Take clipping into account. */
1798 if (s
->gc
->clip_mask
== Rect
)
1800 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1801 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1802 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1803 - s
->gc
->clip_rectangle
.left
);
1804 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1805 - s
->gc
->clip_rectangle
.top
);
1808 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1813 /* Draw the background of glyph_string S. If S->background_filled_p
1814 is non-zero don't draw it. FORCE_P non-zero means draw the
1815 background even if it wouldn't be drawn normally. This is used
1816 when a string preceding S draws into the background of S, or S
1817 contains the first component of a composition. */
1820 x_draw_glyph_string_background (s
, force_p
)
1821 struct glyph_string
*s
;
1824 /* Nothing to do if background has already been drawn or if it
1825 shouldn't be drawn in the first place. */
1826 if (!s
->background_filled_p
)
1828 int box_line_width
= max (s
->face
->box_line_width
, 0);
1830 #if 0 /* TODO: stipple */
1833 /* Fill background with a stipple pattern. */
1834 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1835 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1836 s
->y
+ box_line_width
,
1837 s
->background_width
,
1838 s
->height
- 2 * box_line_width
);
1839 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1840 s
->background_filled_p
= 1;
1844 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1845 || s
->font_not_found_p
1846 || s
->extends_to_end_of_line_p
1847 || FONT_COMPAT (s
->font
)->bdf
1851 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1852 s
->background_width
,
1853 s
->height
- 2 * box_line_width
);
1854 s
->background_filled_p
= 1;
1860 /* Draw the foreground of glyph string S. */
1863 x_draw_glyph_string_foreground (s
)
1864 struct glyph_string
*s
;
1869 /* If first glyph of S has a left box line, start drawing the text
1870 of S to the right of that box line. */
1871 if (s
->face
->box
!= FACE_NO_BOX
1872 && s
->first_glyph
->left_box_line_p
)
1873 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1877 if (s
->for_overlaps
|| (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
)
1878 || cleartype_active
)
1879 SetBkMode (s
->hdc
, TRANSPARENT
);
1881 SetBkMode (s
->hdc
, OPAQUE
);
1883 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1884 SetBkColor (s
->hdc
, s
->gc
->background
);
1885 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1887 if (s
->font
&& FONT_COMPAT (s
->font
)->hfont
)
1888 old_font
= SelectObject (s
->hdc
, FONT_COMPAT (s
->font
)->hfont
);
1890 /* Draw characters of S as rectangles if S's font could not be
1892 if (s
->font_not_found_p
)
1894 for (i
= 0; i
< s
->nchars
; ++i
)
1896 struct glyph
*g
= s
->first_glyph
+ i
;
1898 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1900 x
+= g
->pixel_width
;
1905 int boff
= s
->font
->baseline_offset
;
1906 struct font
*font
= s
->font
;
1909 if (s
->font
->vertical_centering
)
1910 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
1912 y
= s
->ybase
- boff
;
1914 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1915 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1917 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1918 if (s
->face
->overstrike
)
1919 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1922 if (s
->font
&& FONT_COMPAT (s
->font
)->hfont
)
1923 SelectObject (s
->hdc
, old_font
);
1926 /* Draw the foreground of composite glyph string S. */
1929 x_draw_composite_glyph_string_foreground (s
)
1930 struct glyph_string
*s
;
1935 /* If first glyph of S has a left box line, start drawing the text
1936 of S to the right of that box line. */
1937 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1938 && s
->first_glyph
->left_box_line_p
)
1939 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1943 /* S is a glyph string for a composition. S->gidx is the index of
1944 the first character drawn for glyphs of this composition.
1945 S->gidx == 0 means we are drawing the very first character of
1946 this composition. */
1948 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1949 SetBkColor (s
->hdc
, s
->gc
->background
);
1950 SetBkMode (s
->hdc
, TRANSPARENT
);
1951 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1953 if (s
->font
&& FONT_COMPAT (s
->font
)->hfont
)
1954 old_font
= SelectObject (s
->hdc
, FONT_COMPAT (s
->font
)->hfont
);
1956 /* Draw a rectangle for the composition if the font for the very
1957 first character of the composition could not be loaded. */
1958 if (s
->font_not_found_p
)
1961 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1966 struct font
*font
= s
->font
;
1970 if (s
->cmp
->method
== COMPOSITION_WITH_GLYPH_STRING
)
1972 Lisp_Object gstring
= AREF (XHASH_TABLE (composition_hash_table
)
1974 s
->cmp
->hash_index
* 2);
1977 for (i
= from
= 0; i
< s
->nchars
; i
++)
1979 Lisp_Object g
= LGSTRING_GLYPH (gstring
, i
);
1980 Lisp_Object adjustment
= LGLYPH_ADJUSTMENT (g
);
1981 int xoff
, yoff
, wadjust
;
1983 if (! VECTORP (adjustment
))
1985 width
+= LGLYPH_WIDTH (g
);
1990 font
->driver
->draw (s
, from
, i
, x
, y
, 0);
1993 xoff
= XINT (AREF (adjustment
, 0));
1994 yoff
= XINT (AREF (adjustment
, 1));
1995 wadjust
= XINT (AREF (adjustment
, 2));
1997 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
2003 font
->driver
->draw (s
, from
, i
, x
, y
, 0);
2007 for (i
= 0, j
= s
->gidx
; i
< s
->nchars
; i
++, j
++)
2008 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
2010 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
2011 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
2013 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
2014 if (s
->face
->overstrike
)
2015 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
2020 if (s
->font
&& FONT_COMPAT (s
->font
)->hfont
)
2021 SelectObject (s
->hdc
, old_font
);
2025 /* Brightness beyond which a color won't have its highlight brightness
2028 Nominally, highlight colors for `3d' faces are calculated by
2029 brightening an object's color by a constant scale factor, but this
2030 doesn't yield good results for dark colors, so for colors who's
2031 brightness is less than this value (on a scale of 0-255) have to
2032 use an additional additive factor.
2034 The value here is set so that the default menu-bar/mode-line color
2035 (grey75) will not have its highlights changed at all. */
2036 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
2039 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
2040 or DELTA. Try a color with RGB values multiplied by FACTOR first.
2041 If this produces the same color as COLOR, try a color where all RGB
2042 values have DELTA added. Return the allocated color in *COLOR.
2043 DISPLAY is the X display, CMAP is the colormap to operate on.
2044 Value is non-zero if successful. */
2047 w32_alloc_lighter_color (f
, color
, factor
, delta
)
2056 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
2059 /* Change RGB values by specified FACTOR. Avoid overflow! */
2060 xassert (factor
>= 0);
2061 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
2062 min (0xff, factor
* GetGValue (*color
)),
2063 min (0xff, factor
* GetBValue (*color
)));
2065 /* Calculate brightness of COLOR. */
2066 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
2067 + GetBValue (*color
)) / 6;
2069 /* We only boost colors that are darker than
2070 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
2071 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
2072 /* Make an additive adjustment to NEW, because it's dark enough so
2073 that scaling by FACTOR alone isn't enough. */
2075 /* How far below the limit this color is (0 - 1, 1 being darker). */
2076 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
2077 /* The additive adjustment. */
2078 int min_delta
= delta
* dimness
* factor
/ 2;
2081 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
2082 max (0, min (0xff, min_delta
- GetGValue (*color
))),
2083 max (0, min (0xff, min_delta
- GetBValue (*color
))));
2085 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
2086 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
2087 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
2091 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
2092 max (0, min (0xff, delta
+ GetGValue (*color
))),
2093 max (0, min (0xff, delta
+ GetBValue (*color
))));
2095 /* TODO: Map to palette and retry with delta if same? */
2096 /* TODO: Free colors (if using palette)? */
2107 /* Set up the foreground color for drawing relief lines of glyph
2108 string S. RELIEF is a pointer to a struct relief containing the GC
2109 with which lines will be drawn. Use a color that is FACTOR or
2110 DELTA lighter or darker than the relief's background which is found
2111 in S->f->output_data.x->relief_background. If such a color cannot
2112 be allocated, use DEFAULT_PIXEL, instead. */
2115 w32_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
2117 struct relief
*relief
;
2120 COLORREF default_pixel
;
2123 struct w32_output
*di
= f
->output_data
.w32
;
2124 unsigned long mask
= GCForeground
;
2126 COLORREF background
= di
->relief_background
;
2127 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
2129 /* TODO: Free colors (if using palette)? */
2131 /* Allocate new color. */
2132 xgcv
.foreground
= default_pixel
;
2134 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
2136 relief
->allocated_p
= 1;
2137 xgcv
.foreground
= relief
->pixel
= pixel
;
2140 if (relief
->gc
== 0)
2142 #if 0 /* TODO: stipple */
2143 xgcv
.stipple
= dpyinfo
->gray
;
2146 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
2149 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
2153 /* Set up colors for the relief lines around glyph string S. */
2156 x_setup_relief_colors (s
)
2157 struct glyph_string
*s
;
2159 struct w32_output
*di
= s
->f
->output_data
.w32
;
2162 if (s
->face
->use_box_color_for_shadows_p
)
2163 color
= s
->face
->box_color
;
2164 else if (s
->first_glyph
->type
== IMAGE_GLYPH
2166 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
2167 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
2169 color
= s
->gc
->background
;
2171 if (di
->white_relief
.gc
== 0
2172 || color
!= di
->relief_background
)
2174 di
->relief_background
= color
;
2175 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
2176 WHITE_PIX_DEFAULT (s
->f
));
2177 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
2178 BLACK_PIX_DEFAULT (s
->f
));
2183 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2184 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2185 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
2186 relief. LEFT_P non-zero means draw a relief on the left side of
2187 the rectangle. RIGHT_P non-zero means draw a relief on the right
2188 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2192 w32_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
2193 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
2195 int left_x
, top_y
, right_x
, bottom_y
, width
;
2196 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
2201 HDC hdc
= get_frame_dc (f
);
2204 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
2206 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
2208 w32_set_clip_rectangle (hdc
, clip_rect
);
2212 for (i
= 0; i
< width
; ++i
)
2213 w32_fill_area (f
, hdc
, gc
.foreground
,
2214 left_x
+ i
* left_p
, top_y
+ i
,
2215 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
2219 for (i
= 0; i
< width
; ++i
)
2220 w32_fill_area (f
, hdc
, gc
.foreground
,
2221 left_x
+ i
, top_y
+ i
, 1,
2222 bottom_y
- top_y
- 2 * i
+ 1);
2225 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
2227 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
2231 for (i
= 0; i
< width
; ++i
)
2232 w32_fill_area (f
, hdc
, gc
.foreground
,
2233 left_x
+ i
* left_p
, bottom_y
- i
,
2234 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
2238 for (i
= 0; i
< width
; ++i
)
2239 w32_fill_area (f
, hdc
, gc
.foreground
,
2240 right_x
- i
, top_y
+ i
+ 1, 1,
2241 bottom_y
- top_y
- 2 * i
- 1);
2243 w32_set_clip_rectangle (hdc
, NULL
);
2245 release_frame_dc (f
, hdc
);
2249 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2250 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2251 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2252 left side of the rectangle. RIGHT_P non-zero means draw a line
2253 on the right side of the rectangle. CLIP_RECT is the clipping
2254 rectangle to use when drawing. */
2257 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2258 left_p
, right_p
, clip_rect
)
2259 struct glyph_string
*s
;
2260 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
2263 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
2266 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
2267 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2272 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
2273 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2277 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
2278 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2283 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
2284 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2287 w32_set_clip_rectangle (s
->hdc
, NULL
);
2291 /* Draw a box around glyph string S. */
2294 x_draw_glyph_string_box (s
)
2295 struct glyph_string
*s
;
2297 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2298 int left_p
, right_p
;
2299 struct glyph
*last_glyph
;
2302 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2303 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2304 : window_box_right (s
->w
, s
->area
));
2306 /* The glyph that may have a right box line. */
2307 last_glyph
= (s
->cmp
|| s
->img
2309 : s
->first_glyph
+ s
->nchars
- 1);
2311 width
= eabs (s
->face
->box_line_width
);
2312 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2314 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2316 : min (last_x
, s
->x
+ s
->background_width
) - 1));
2318 bottom_y
= top_y
+ s
->height
- 1;
2320 left_p
= (s
->first_glyph
->left_box_line_p
2321 || (s
->hl
== DRAW_MOUSE_FACE
2323 || s
->prev
->hl
!= s
->hl
)));
2324 right_p
= (last_glyph
->right_box_line_p
2325 || (s
->hl
== DRAW_MOUSE_FACE
2327 || s
->next
->hl
!= s
->hl
)));
2329 get_glyph_string_clip_rect (s
, &clip_rect
);
2331 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2332 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2333 left_p
, right_p
, &clip_rect
);
2336 x_setup_relief_colors (s
);
2337 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2338 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2343 /* Draw foreground of image glyph string S. */
2346 x_draw_image_foreground (s
)
2347 struct glyph_string
*s
;
2350 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2352 /* If first glyph of S has a left box line, start drawing it to the
2353 right of that line. */
2354 if (s
->face
->box
!= FACE_NO_BOX
2355 && s
->first_glyph
->left_box_line_p
2357 x
+= eabs (s
->face
->box_line_width
);
2359 /* If there is a margin around the image, adjust x- and y-position
2361 if (s
->slice
.x
== 0)
2362 x
+= s
->img
->hmargin
;
2363 if (s
->slice
.y
== 0)
2364 y
+= s
->img
->vmargin
;
2370 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2371 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2372 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2373 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2374 SetBkColor (compat_hdc
, RGB (255, 255, 255));
2375 SetTextColor (s
->hdc
, RGB (0, 0, 0));
2376 x_set_glyph_string_clipping (s
);
2380 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
2381 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2383 SetTextColor (s
->hdc
, RGB (255, 255, 255));
2384 SetBkColor (s
->hdc
, RGB (0, 0, 0));
2386 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2387 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2388 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2389 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2390 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2391 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2393 SelectObject (mask_dc
, mask_orig_obj
);
2398 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2399 SetBkColor (s
->hdc
, s
->gc
->background
);
2401 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2402 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2404 /* When the image has a mask, we can expect that at
2405 least part of a mouse highlight or a block cursor will
2406 be visible. If the image doesn't have a mask, make
2407 a block cursor visible by drawing a rectangle around
2408 the image. I believe it's looking better if we do
2409 nothing here for mouse-face. */
2410 if (s
->hl
== DRAW_CURSOR
)
2412 int r
= s
->img
->relief
;
2414 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
2415 s
->slice
.width
+ r
*2 - 1,
2416 s
->slice
.height
+ r
*2 - 1);
2420 w32_set_clip_rectangle (s
->hdc
, NULL
);
2421 SelectObject (s
->hdc
, orig_brush
);
2422 DeleteObject (fg_brush
);
2423 SelectObject (compat_hdc
, orig_obj
);
2424 DeleteDC (compat_hdc
);
2427 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
2428 s
->slice
.width
- 1, s
->slice
.height
- 1);
2430 RestoreDC (s
->hdc
,-1);
2434 /* Draw a relief around the image glyph string S. */
2437 x_draw_image_relief (s
)
2438 struct glyph_string
*s
;
2440 int x0
, y0
, x1
, y1
, thick
, raised_p
;
2443 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2445 /* If first glyph of S has a left box line, start drawing it to the
2446 right of that line. */
2447 if (s
->face
->box
!= FACE_NO_BOX
2448 && s
->first_glyph
->left_box_line_p
2450 x
+= eabs (s
->face
->box_line_width
);
2452 /* If there is a margin around the image, adjust x- and y-position
2454 if (s
->slice
.x
== 0)
2455 x
+= s
->img
->hmargin
;
2456 if (s
->slice
.y
== 0)
2457 y
+= s
->img
->vmargin
;
2459 if (s
->hl
== DRAW_IMAGE_SUNKEN
2460 || s
->hl
== DRAW_IMAGE_RAISED
)
2462 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2463 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2467 thick
= eabs (s
->img
->relief
);
2468 raised_p
= s
->img
->relief
> 0;
2473 x1
= x
+ s
->slice
.width
+ thick
- 1;
2474 y1
= y
+ s
->slice
.height
+ thick
- 1;
2476 x_setup_relief_colors (s
);
2477 get_glyph_string_clip_rect (s
, &r
);
2478 w32_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2480 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2482 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2487 /* Draw the foreground of image glyph string S to PIXMAP. */
2490 w32_draw_image_foreground_1 (s
, pixmap
)
2491 struct glyph_string
*s
;
2494 HDC hdc
= CreateCompatibleDC (s
->hdc
);
2495 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
2497 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2499 /* If first glyph of S has a left box line, start drawing it to the
2500 right of that line. */
2501 if (s
->face
->box
!= FACE_NO_BOX
2502 && s
->first_glyph
->left_box_line_p
2504 x
+= eabs (s
->face
->box_line_width
);
2506 /* If there is a margin around the image, adjust x- and y-position
2508 if (s
->slice
.x
== 0)
2509 x
+= s
->img
->hmargin
;
2510 if (s
->slice
.y
== 0)
2511 y
+= s
->img
->vmargin
;
2515 HDC compat_hdc
= CreateCompatibleDC (hdc
);
2516 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2517 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
2518 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2522 HDC mask_dc
= CreateCompatibleDC (hdc
);
2523 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2525 SetTextColor (hdc
, RGB (0, 0, 0));
2526 SetBkColor (hdc
, RGB (255, 255, 255));
2527 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2528 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2529 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2530 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2531 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2532 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2534 SelectObject (mask_dc
, mask_orig_obj
);
2539 SetTextColor (hdc
, s
->gc
->foreground
);
2540 SetBkColor (hdc
, s
->gc
->background
);
2542 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2543 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2545 /* When the image has a mask, we can expect that at
2546 least part of a mouse highlight or a block cursor will
2547 be visible. If the image doesn't have a mask, make
2548 a block cursor visible by drawing a rectangle around
2549 the image. I believe it's looking better if we do
2550 nothing here for mouse-face. */
2551 if (s
->hl
== DRAW_CURSOR
)
2553 int r
= s
->img
->relief
;
2555 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2556 s
->slice
.width
+ r
*2 - 1,
2557 s
->slice
.height
+ r
*2 - 1);
2561 SelectObject (hdc
, orig_brush
);
2562 DeleteObject (fg_brush
);
2563 SelectObject (compat_hdc
, orig_obj
);
2564 DeleteDC (compat_hdc
);
2567 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2568 s
->slice
.width
- 1, s
->slice
.height
- 1);
2570 SelectObject (hdc
, orig_hdc_obj
);
2575 /* Draw part of the background of glyph string S. X, Y, W, and H
2576 give the rectangle to draw. */
2579 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
2580 struct glyph_string
*s
;
2583 #if 0 /* TODO: stipple */
2586 /* Fill background with a stipple pattern. */
2587 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2588 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2589 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2593 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2597 /* Draw image glyph string S.
2600 s->x +-------------------------
2603 | +-------------------------
2606 | | +-------------------
2612 x_draw_image_glyph_string (s
)
2613 struct glyph_string
*s
;
2616 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2617 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2621 height
= s
->height
- 2 * box_line_vwidth
;
2623 /* Fill background with face under the image. Do it only if row is
2624 taller than image or if image has a clip mask to reduce
2626 s
->stippled_p
= s
->face
->stipple
!= 0;
2627 if (height
> s
->slice
.height
2631 || s
->img
->pixmap
== 0
2632 || s
->width
!= s
->background_width
)
2635 if (s
->first_glyph
->left_box_line_p
2637 x
+= box_line_hwidth
;
2640 if (s
->slice
.y
== 0)
2641 y
+= box_line_vwidth
;
2643 #if 0 /* TODO: figure out if we need to do this on Windows. */
2646 /* Create a pixmap as large as the glyph string. Fill it
2647 with the background color. Copy the image to it, using
2648 its mask. Copy the temporary pixmap to the display. */
2649 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2650 int depth
= DefaultDepthOfScreen (screen
);
2652 /* Create a pixmap as large as the glyph string. */
2653 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2654 s
->background_width
,
2657 /* Don't clip in the following because we're working on the
2659 XSetClipMask (s
->display
, s
->gc
, None
);
2661 /* Fill the pixmap with the background color/stipple. */
2664 /* Fill background with a stipple pattern. */
2665 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2666 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2667 0, 0, s
->background_width
, s
->height
);
2668 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2673 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2675 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2676 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2677 0, 0, s
->background_width
, s
->height
);
2678 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2683 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2685 s
->background_filled_p
= 1;
2688 /* Draw the foreground. */
2691 w32_draw_image_foreground_1 (s
, pixmap
);
2692 x_set_glyph_string_clipping (s
);
2694 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2695 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2696 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2697 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2699 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2700 SetBkColor (s
->hdc
, s
->gc
->background
);
2701 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2702 compat_hdc
, 0, 0, SRCCOPY
);
2704 SelectObject (s
->hdc
, orig_brush
);
2705 DeleteObject (fg_brush
);
2706 SelectObject (compat_hdc
, orig_obj
);
2707 DeleteDC (compat_hdc
);
2709 DeleteObject (pixmap
);
2713 x_draw_image_foreground (s
);
2715 /* If we must draw a relief around the image, do it. */
2717 || s
->hl
== DRAW_IMAGE_RAISED
2718 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2719 x_draw_image_relief (s
);
2723 /* Draw stretch glyph string S. */
2726 x_draw_stretch_glyph_string (s
)
2727 struct glyph_string
*s
;
2729 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2731 if (s
->hl
== DRAW_CURSOR
2732 && !x_stretch_cursor_p
)
2734 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2735 as wide as the stretch glyph. */
2736 int width
, background_width
= s
->background_width
;
2737 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2741 background_width
-= left_x
- x
;
2744 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2747 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2749 /* Clear rest using the GC of the original non-cursor face. */
2750 if (width
< background_width
)
2752 XGCValues
*gc
= s
->face
->gc
;
2754 int w
= background_width
- width
, h
= s
->height
;
2759 if (s
->row
->mouse_face_p
2760 && cursor_in_mouse_face_p (s
->w
))
2762 x_set_mouse_face_gc (s
);
2768 get_glyph_string_clip_rect (s
, &r
);
2769 w32_set_clip_rectangle (hdc
, &r
);
2771 #if 0 /* TODO: stipple */
2772 if (s
->face
->stipple
)
2774 /* Fill background with a stipple pattern. */
2775 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2776 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2777 XSetFillStyle (s
->display
, gc
, FillSolid
);
2782 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2786 else if (!s
->background_filled_p
)
2788 int background_width
= s
->background_width
;
2789 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2791 /* Don't draw into left margin, fringe or scrollbar area
2792 except for header line and mode line. */
2793 if (x
< left_x
&& !s
->row
->mode_line_p
)
2795 background_width
-= left_x
- x
;
2798 if (background_width
> 0)
2799 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2802 s
->background_filled_p
= 1;
2806 /* Draw glyph string S. */
2809 x_draw_glyph_string (s
)
2810 struct glyph_string
*s
;
2812 int relief_drawn_p
= 0;
2814 /* If S draws into the background of its successor, draw the
2815 background of the successor first so that S can draw into it.
2816 This makes S->next use XDrawString instead of XDrawImageString. */
2817 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2820 struct glyph_string
*next
;
2821 for (width
= 0, next
= s
->next
; next
;
2822 width
+= next
->width
, next
= next
->next
)
2823 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2825 x_set_glyph_string_gc (next
);
2826 x_set_glyph_string_clipping (next
);
2827 x_draw_glyph_string_background (next
, 1);
2828 next
->num_clips
= 0;
2832 /* Set up S->gc, set clipping and draw S. */
2833 x_set_glyph_string_gc (s
);
2835 /* Draw relief (if any) in advance for char/composition so that the
2836 glyph string can be drawn over it. */
2837 if (!s
->for_overlaps
2838 && s
->face
->box
!= FACE_NO_BOX
2839 && (s
->first_glyph
->type
== CHAR_GLYPH
2840 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2843 x_set_glyph_string_clipping (s
);
2844 x_draw_glyph_string_background (s
, 1);
2845 x_draw_glyph_string_box (s
);
2846 x_set_glyph_string_clipping (s
);
2849 else if ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2850 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
))
2851 /* We must clip just this glyph. left_overhang part has already
2852 drawn when s->prev was drawn, and right_overhang part will be
2853 drawn later when s->next is drawn. */
2854 x_set_glyph_string_clipping_exactly (s
, s
);
2856 x_set_glyph_string_clipping (s
);
2858 switch (s
->first_glyph
->type
)
2861 x_draw_image_glyph_string (s
);
2865 x_draw_stretch_glyph_string (s
);
2869 if (s
->for_overlaps
)
2870 s
->background_filled_p
= 1;
2872 x_draw_glyph_string_background (s
, 0);
2873 x_draw_glyph_string_foreground (s
);
2876 case COMPOSITE_GLYPH
:
2877 if (s
->for_overlaps
|| s
->gidx
> 0)
2878 s
->background_filled_p
= 1;
2880 x_draw_glyph_string_background (s
, 1);
2881 x_draw_composite_glyph_string_foreground (s
);
2888 if (!s
->for_overlaps
)
2890 /* Draw underline. */
2891 if (s
->face
->underline_p
)
2893 unsigned long thickness
, position
;
2896 if (s
->prev
&& s
->prev
->face
->underline_p
)
2898 /* We use the same underline style as the previous one. */
2899 thickness
= s
->prev
->underline_thickness
;
2900 position
= s
->prev
->underline_position
;
2904 /* Get the underline thickness. Default is 1 pixel. */
2905 if (s
->font
&& s
->font
->underline_thickness
> 0)
2906 thickness
= s
->font
->underline_thickness
;
2909 if (x_underline_at_descent_line
)
2910 position
= (s
->height
- thickness
) - s
->ybase
;
2913 /* Get the underline position. This is the recommended
2914 vertical offset in pixels from the baseline to the top of
2915 the underline. This is a signed value according to the
2916 specs, and its default is
2918 ROUND ((maximum_descent) / 2), with
2919 ROUND (x) = floor (x + 0.5) */
2921 if (x_use_underline_position_properties
2922 && s
->font
&& s
->font
->underline_position
>= 0)
2923 position
= s
->font
->underline_position
;
2925 position
= (s
->font
->descent
+ 1) / 2;
2927 s
->underline_thickness
= thickness
;
2928 s
->underline_position
=position
;
2930 y
= s
->ybase
+ position
;
2931 if (s
->face
->underline_defaulted_p
)
2933 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2934 y
, s
->background_width
, 1);
2938 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2939 y
, s
->background_width
, 1);
2942 /* Draw overline. */
2943 if (s
->face
->overline_p
)
2945 unsigned long dy
= 0, h
= 1;
2947 if (s
->face
->overline_color_defaulted_p
)
2949 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2950 s
->y
+ dy
, s
->background_width
, h
);
2954 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2955 s
->y
+ dy
, s
->background_width
, h
);
2959 /* Draw strike-through. */
2960 if (s
->face
->strike_through_p
2961 && (FONT_COMPAT (s
->font
)->bdf
2962 || !FONT_COMPAT (s
->font
)->tm
.tmStruckOut
))
2964 unsigned long h
= 1;
2965 unsigned long dy
= (s
->height
- h
) / 2;
2967 if (s
->face
->strike_through_color_defaulted_p
)
2969 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2974 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2975 s
->y
+ dy
, s
->width
, h
);
2979 /* Draw relief if not yet drawn. */
2980 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2981 x_draw_glyph_string_box (s
);
2985 struct glyph_string
*prev
;
2987 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2988 if (prev
->hl
!= s
->hl
2989 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2991 /* As prev was drawn while clipped to its own area, we
2992 must draw the right_overhang part using s->hl now. */
2993 enum draw_glyphs_face save
= prev
->hl
;
2996 x_set_glyph_string_gc (prev
);
2997 x_set_glyph_string_clipping_exactly (s
, prev
);
2998 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2999 x_draw_glyph_string_foreground (prev
);
3001 x_draw_composite_glyph_string_foreground (prev
);
3002 w32_set_clip_rectangle (prev
->hdc
, NULL
);
3004 prev
->num_clips
= 0;
3010 struct glyph_string
*next
;
3012 for (next
= s
->next
; next
; next
= next
->next
)
3013 if (next
->hl
!= s
->hl
3014 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
3016 /* As next will be drawn while clipped to its own area,
3017 we must draw the left_overhang part using s->hl now. */
3018 enum draw_glyphs_face save
= next
->hl
;
3021 x_set_glyph_string_gc (next
);
3022 x_set_glyph_string_clipping_exactly (s
, next
);
3023 if (next
->first_glyph
->type
== CHAR_GLYPH
)
3024 x_draw_glyph_string_foreground (next
);
3026 x_draw_composite_glyph_string_foreground (next
);
3027 w32_set_clip_rectangle (next
->hdc
, NULL
);
3029 next
->num_clips
= 0;
3034 /* Reset clipping. */
3035 w32_set_clip_rectangle (s
->hdc
, NULL
);
3040 /* Shift display to make room for inserted glyphs. */
3043 w32_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
3045 int x
, y
, width
, height
, shift_by
;
3049 hdc
= get_frame_dc (f
);
3050 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
3051 hdc
, x
, y
, SRCCOPY
);
3053 release_frame_dc (f
, hdc
);
3057 /* Delete N glyphs at the nominal cursor position. Not implemented
3061 x_delete_glyphs (f
, n
)
3065 if (! FRAME_W32_P (f
))
3072 /* Clear entire frame. If updating_frame is non-null, clear that
3073 frame. Otherwise clear the selected frame. */
3076 x_clear_frame (struct frame
*f
)
3078 if (! FRAME_W32_P (f
))
3081 /* Clearing the frame will erase any cursor, so mark them all as no
3083 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3084 output_cursor
.hpos
= output_cursor
.vpos
= 0;
3085 output_cursor
.x
= -1;
3087 /* We don't set the output cursor here because there will always
3088 follow an explicit cursor_to. */
3091 w32_clear_window (f
);
3093 /* We have to clear the scroll bars, too. If we have changed
3094 colors or something like that, then they should be notified. */
3095 x_scroll_bar_clear (f
);
3101 /* Make audible bell. */
3104 w32_ring_bell (struct frame
*f
)
3108 if (FRAME_W32_P (f
) && visible_bell
)
3111 HWND hwnd
= FRAME_W32_WINDOW (f
);
3113 for (i
= 0; i
< 5; i
++)
3115 FlashWindow (hwnd
, TRUE
);
3118 FlashWindow (hwnd
, FALSE
);
3121 w32_sys_ring_bell (f
);
3127 /* Specify how many text lines, from the top of the window,
3128 should be affected by insert-lines and delete-lines operations.
3129 This, and those operations, are used only within an update
3130 that is bounded by calls to x_update_begin and x_update_end. */
3133 w32_set_terminal_window (n
)
3136 /* This function intentionally left blank. */
3140 /***********************************************************************
3142 ***********************************************************************/
3144 /* Perform an insert-lines or delete-lines operation, inserting N
3145 lines or deleting -N lines at vertical position VPOS. */
3148 x_ins_del_lines (f
, vpos
, n
)
3152 if (! FRAME_W32_P (f
))
3159 /* Scroll part of the display as described by RUN. */
3162 x_scroll_run (w
, run
)
3166 struct frame
*f
= XFRAME (w
->frame
);
3167 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3168 HWND hwnd
= FRAME_W32_WINDOW (f
);
3171 /* Get frame-relative bounding box of the text display area of W,
3172 without mode lines. Include in this box the left and right
3174 window_box (w
, -1, &x
, &y
, &width
, &height
);
3176 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3177 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3178 bottom_y
= y
+ height
;
3182 /* Scrolling up. Make sure we don't copy part of the mode
3183 line at the bottom. */
3184 if (from_y
+ run
->height
> bottom_y
)
3185 height
= bottom_y
- from_y
;
3187 height
= run
->height
;
3188 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
3192 /* Scolling down. Make sure we don't copy over the mode line.
3194 if (to_y
+ run
->height
> bottom_y
)
3195 height
= bottom_y
- to_y
;
3197 height
= run
->height
;
3198 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
3203 /* Cursor off. Will be switched on again in x_update_window_end. */
3210 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
3211 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
3213 from
.left
= to
.left
= x
;
3214 from
.right
= to
.right
= x
+ width
;
3216 from
.bottom
= from_y
+ height
;
3218 to
.bottom
= bottom_y
;
3220 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
3221 NULL
, SW_INVALIDATE
);
3223 /* Combine this with what we expect to be dirty. This covers the
3224 case where not all of the region we expect is actually dirty. */
3225 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
3227 /* If the dirty region is not what we expected, redraw the entire frame. */
3228 if (!EqualRgn (combined
, expect_dirty
))
3229 SET_FRAME_GARBAGED (f
);
3231 DeleteObject (dirty
);
3232 DeleteObject (combined
);
3236 DeleteObject (expect_dirty
);
3241 /***********************************************************************
3243 ***********************************************************************/
3249 x_update_cursor (f
, 1);
3253 frame_unhighlight (f
)
3256 x_update_cursor (f
, 1);
3259 /* The focus has changed. Update the frames as necessary to reflect
3260 the new situation. Note that we can't change the selected frame
3261 here, because the Lisp code we are interrupting might become confused.
3262 Each event gets marked with the frame in which it occurred, so the
3263 Lisp code can tell when the switch took place by examining the events. */
3266 x_new_focus_frame (dpyinfo
, frame
)
3267 struct w32_display_info
*dpyinfo
;
3268 struct frame
*frame
;
3270 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
3272 if (frame
!= dpyinfo
->w32_focus_frame
)
3274 /* Set this before calling other routines, so that they see
3275 the correct value of w32_focus_frame. */
3276 dpyinfo
->w32_focus_frame
= frame
;
3278 if (old_focus
&& old_focus
->auto_lower
)
3279 x_lower_frame (old_focus
);
3281 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
3282 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
3284 pending_autoraise_frame
= 0;
3287 x_frame_rehighlight (dpyinfo
);
3291 /* Handle FocusIn and FocusOut state changes for FRAME.
3292 If FRAME has focus and there exists more than one frame, puts
3293 a FOCUS_IN_EVENT into *BUFP. */
3296 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
)
3299 struct w32_display_info
*dpyinfo
;
3300 struct frame
*frame
;
3301 struct input_event
*bufp
;
3303 if (type
== WM_SETFOCUS
)
3305 if (dpyinfo
->w32_focus_event_frame
!= frame
)
3307 x_new_focus_frame (dpyinfo
, frame
);
3308 dpyinfo
->w32_focus_event_frame
= frame
;
3310 /* Don't stop displaying the initial startup message
3311 for a switch-frame event we don't need. */
3312 if (NILP (Vterminal_frame
)
3313 && CONSP (Vframe_list
)
3314 && !NILP (XCDR (Vframe_list
)))
3316 bufp
->kind
= FOCUS_IN_EVENT
;
3317 XSETFRAME (bufp
->frame_or_window
, frame
);
3321 frame
->output_data
.x
->focus_state
|= state
;
3323 /* TODO: IME focus? */
3325 else if (type
== WM_KILLFOCUS
)
3327 frame
->output_data
.x
->focus_state
&= ~state
;
3329 if (dpyinfo
->w32_focus_event_frame
== frame
)
3331 dpyinfo
->w32_focus_event_frame
= 0;
3332 x_new_focus_frame (dpyinfo
, 0);
3335 /* TODO: IME focus? */
3340 /* The focus may have changed. Figure out if it is a real focus change,
3341 by checking both FocusIn/Out and Enter/LeaveNotify events.
3343 Returns FOCUS_IN_EVENT event in *BUFP. */
3346 w32_detect_focus_change (dpyinfo
, event
, bufp
)
3347 struct w32_display_info
*dpyinfo
;
3349 struct input_event
*bufp
;
3351 struct frame
*frame
;
3353 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
3357 /* On w32, this is only called from focus events, so no switch needed. */
3358 x_focus_changed (event
->msg
.message
,
3359 (event
->msg
.message
== WM_KILLFOCUS
?
3360 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3361 dpyinfo
, frame
, bufp
);
3365 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3368 x_mouse_leave (dpyinfo
)
3369 struct w32_display_info
*dpyinfo
;
3371 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
3374 /* The focus has changed, or we have redirected a frame's focus to
3375 another frame (this happens when a frame uses a surrogate
3376 mini-buffer frame). Shift the highlight as appropriate.
3378 The FRAME argument doesn't necessarily have anything to do with which
3379 frame is being highlighted or un-highlighted; we only use it to find
3380 the appropriate X display info. */
3383 w32_frame_rehighlight (frame
)
3384 struct frame
*frame
;
3386 if (! FRAME_W32_P (frame
))
3388 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
3392 x_frame_rehighlight (dpyinfo
)
3393 struct w32_display_info
*dpyinfo
;
3395 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3397 if (dpyinfo
->w32_focus_frame
)
3399 dpyinfo
->x_highlight_frame
3400 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
3401 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
3402 : dpyinfo
->w32_focus_frame
);
3403 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3405 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
3406 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
3410 dpyinfo
->x_highlight_frame
= 0;
3412 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3415 frame_unhighlight (old_highlight
);
3416 if (dpyinfo
->x_highlight_frame
)
3417 frame_highlight (dpyinfo
->x_highlight_frame
);
3421 /* Keyboard processing - modifier keys, etc. */
3423 /* Convert a keysym to its name. */
3426 x_get_keysym_name (keysym
)
3429 /* Make static so we can always return it */
3430 static char value
[100];
3433 GetKeyNameText (keysym
, value
, 100);
3441 /* Mouse clicks and mouse movement. Rah. */
3443 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
3444 the state in PUP. XBUTTON provides extra information for extended mouse
3445 button messages. Returns FALSE if unable to parse the message. */
3447 parse_button (message
, xbutton
, pbutton
, pup
)
3458 case WM_LBUTTONDOWN
:
3466 case WM_MBUTTONDOWN
:
3467 if (NILP (Vw32_swap_mouse_buttons
))
3474 if (NILP (Vw32_swap_mouse_buttons
))
3480 case WM_RBUTTONDOWN
:
3481 if (NILP (Vw32_swap_mouse_buttons
))
3488 if (NILP (Vw32_swap_mouse_buttons
))
3494 case WM_XBUTTONDOWN
:
3495 button
= xbutton
+ 2;
3499 button
= xbutton
+ 2;
3507 if (pbutton
) *pbutton
= button
;
3513 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3515 If the event is a button press, then note that we have grabbed
3519 construct_mouse_click (result
, msg
, f
)
3520 struct input_event
*result
;
3527 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3530 /* Make the event type NO_EVENT; we'll change that when we decide
3532 result
->kind
= MOUSE_CLICK_EVENT
;
3533 result
->code
= button
;
3534 result
->timestamp
= msg
->msg
.time
;
3535 result
->modifiers
= (msg
->dwModifiers
3540 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3541 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3542 XSETFRAME (result
->frame_or_window
, f
);
3548 construct_mouse_wheel (result
, msg
, f
)
3549 struct input_event
*result
;
3556 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3559 result
->timestamp
= msg
->msg
.time
;
3561 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3562 forward, away from the user (up); a negative value indicates that
3563 the wheel was rotated backward, toward the user (down). */
3564 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3566 /* The up and down modifiers indicate if the wheel was rotated up or
3567 down based on WHEEL_DELTA value. */
3568 result
->modifiers
= (msg
->dwModifiers
3569 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3571 /* With multiple monitors, we can legitimately get negative
3572 coordinates, so cast to short to interpret them correctly. */
3573 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3574 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3575 ScreenToClient (msg
->msg
.hwnd
, &p
);
3576 XSETINT (result
->x
, p
.x
);
3577 XSETINT (result
->y
, p
.y
);
3578 XSETFRAME (result
->frame_or_window
, f
);
3584 construct_drag_n_drop (result
, msg
, f
)
3585 struct input_event
*result
;
3597 result
->kind
= DRAG_N_DROP_EVENT
;
3599 result
->timestamp
= msg
->msg
.time
;
3600 result
->modifiers
= msg
->dwModifiers
;
3602 hdrop
= (HDROP
) msg
->msg
.wParam
;
3603 DragQueryPoint (hdrop
, &p
);
3606 p
.x
= LOWORD (msg
->msg
.lParam
);
3607 p
.y
= HIWORD (msg
->msg
.lParam
);
3608 ScreenToClient (msg
->msg
.hwnd
, &p
);
3611 XSETINT (result
->x
, p
.x
);
3612 XSETINT (result
->y
, p
.y
);
3614 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3617 for (i
= 0; i
< num_files
; i
++)
3619 len
= DragQueryFile (hdrop
, i
, NULL
, 0);
3622 name
= alloca (len
+ 1);
3623 DragQueryFile (hdrop
, i
, name
, len
+ 1);
3624 files
= Fcons (DECODE_FILE (build_string (name
)), files
);
3629 XSETFRAME (frame
, f
);
3630 result
->frame_or_window
= frame
;
3631 result
->arg
= files
;
3636 /* Function to report a mouse movement to the mainstream Emacs code.
3637 The input handler calls this.
3639 We have received a mouse movement event, which is given in *event.
3640 If the mouse is over a different glyph than it was last time, tell
3641 the mainstream emacs code by setting mouse_moved. If not, ask for
3642 another motion event, so we can check again the next time it moves. */
3644 static MSG last_mouse_motion_event
;
3645 static Lisp_Object last_mouse_motion_frame
;
3648 note_mouse_movement (frame
, msg
)
3652 int mouse_x
= LOWORD (msg
->lParam
);
3653 int mouse_y
= HIWORD (msg
->lParam
);
3655 last_mouse_movement_time
= msg
->time
;
3656 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
3657 XSETFRAME (last_mouse_motion_frame
, frame
);
3659 if (!FRAME_X_OUTPUT (frame
))
3662 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3664 frame
->mouse_moved
= 1;
3665 last_mouse_scroll_bar
= Qnil
;
3666 note_mouse_highlight (frame
, -1, -1);
3667 last_mouse_glyph_frame
= 0;
3671 /* Has the mouse moved off the glyph it was on at the last sighting? */
3672 if (frame
!= last_mouse_glyph_frame
3673 || mouse_x
< last_mouse_glyph
.left
3674 || mouse_x
>= last_mouse_glyph
.right
3675 || mouse_y
< last_mouse_glyph
.top
3676 || mouse_y
>= last_mouse_glyph
.bottom
)
3678 frame
->mouse_moved
= 1;
3679 last_mouse_scroll_bar
= Qnil
;
3680 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3681 /* Remember the mouse position here, as w32_mouse_position only
3682 gets called when mouse tracking is enabled but we also need
3683 to keep track of the mouse for help_echo and highlighting at
3685 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, &last_mouse_glyph
);
3686 last_mouse_glyph_frame
= frame
;
3694 /************************************************************************
3696 ************************************************************************/
3698 static struct scroll_bar
*x_window_to_scroll_bar ();
3699 static void x_scroll_bar_report_motion ();
3700 static void x_check_fullscreen
P_ ((struct frame
*));
3703 redo_mouse_highlight ()
3705 if (!NILP (last_mouse_motion_frame
)
3706 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3707 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3708 LOWORD (last_mouse_motion_event
.lParam
),
3709 HIWORD (last_mouse_motion_event
.lParam
));
3713 w32_define_cursor (window
, cursor
)
3717 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3719 /* Return the current position of the mouse.
3720 *fp should be a frame which indicates which display to ask about.
3722 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3723 and *part to the frame, window, and scroll bar part that the mouse
3724 is over. Set *x and *y to the portion and whole of the mouse's
3725 position on the scroll bar.
3727 If the mouse movement started elsewhere, set *fp to the frame the
3728 mouse is on, *bar_window to nil, and *x and *y to the character cell
3731 Set *time to the server time-stamp for the time at which the mouse
3732 was at this position.
3734 Don't store anything if we don't have a valid set of values to report.
3736 This clears the mouse_moved flag, so we can wait for the next mouse
3740 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3743 Lisp_Object
*bar_window
;
3744 enum scroll_bar_part
*part
;
3746 unsigned long *time
;
3752 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3753 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3758 Lisp_Object frame
, tail
;
3760 /* Clear the mouse-moved flag for every frame on this display. */
3761 FOR_EACH_FRAME (tail
, frame
)
3762 XFRAME (frame
)->mouse_moved
= 0;
3764 last_mouse_scroll_bar
= Qnil
;
3768 /* Now we have a position on the root; find the innermost window
3769 containing the pointer. */
3771 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3772 && FRAME_LIVE_P (last_mouse_frame
))
3774 /* If mouse was grabbed on a frame, give coords for that frame
3775 even if the mouse is now outside it. */
3776 f1
= last_mouse_frame
;
3780 /* Is window under mouse one of our frames? */
3781 f1
= x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
3782 WindowFromPoint (pt
));
3785 /* If not, is it one of our scroll bars? */
3788 struct scroll_bar
*bar
3789 = x_window_to_scroll_bar (WindowFromPoint (pt
));
3793 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3797 if (f1
== 0 && insist
> 0)
3798 f1
= SELECTED_FRAME ();
3802 /* Ok, we found a frame. Store all the values.
3803 last_mouse_glyph is a rectangle used to reduce the
3804 generation of mouse events. To not miss any motion
3805 events, we must divide the frame into rectangles of the
3806 size of the smallest character that could be displayed
3807 on it, i.e. into the same rectangles that matrices on
3808 the frame are divided into. */
3810 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3811 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &last_mouse_glyph
);
3812 last_mouse_glyph_frame
= f1
;
3819 *time
= last_mouse_movement_time
;
3828 /***********************************************************************
3830 ***********************************************************************/
3832 /* Handle mouse button event on the tool-bar of frame F, at
3833 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
3837 w32_handle_tool_bar_click (f
, button_event
)
3839 struct input_event
*button_event
;
3841 int x
= XFASTINT (button_event
->x
);
3842 int y
= XFASTINT (button_event
->y
);
3844 if (button_event
->modifiers
& down_modifier
)
3845 handle_tool_bar_click (f
, x
, y
, 1, 0);
3847 handle_tool_bar_click (f
, x
, y
, 0,
3848 button_event
->modifiers
& ~up_modifier
);
3853 /***********************************************************************
3855 ***********************************************************************/
3857 /* Scroll bar support. */
3859 /* Given a window ID, find the struct scroll_bar which manages it.
3860 This can be called in GC, so we have to make sure to strip off mark
3863 static struct scroll_bar
*
3864 x_window_to_scroll_bar (window_id
)
3869 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3871 Lisp_Object frame
, bar
, condemned
;
3873 frame
= XCAR (tail
);
3874 /* All elements of Vframe_list should be frames. */
3875 if (! FRAMEP (frame
))
3878 /* Scan this frame's scroll bar list for a scroll bar with the
3880 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3881 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3882 /* This trick allows us to search both the ordinary and
3883 condemned scroll bar lists with one loop. */
3884 ! NILP (bar
) || (bar
= condemned
,
3887 bar
= XSCROLL_BAR (bar
)->next
)
3888 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
3889 return XSCROLL_BAR (bar
);
3897 /* Set the thumb size and position of scroll bar BAR. We are currently
3898 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3901 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
)
3902 struct scroll_bar
*bar
;
3903 int portion
, position
, whole
;
3905 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3906 /* We use the whole scroll-bar height in the calculations below, to
3907 avoid strange effects like scrolling backwards when just clicking
3908 on the handle (without moving it). */
3909 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
))
3910 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3911 int sb_page
, sb_pos
;
3912 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
3915 /* We used to change the nPage setting while dragging the handle,
3916 but that had very strange effects (such as scrolling backwards
3917 while dragging downwards).
3919 Now, we don't change the nPage setting while dragging unless we
3920 get near to the end of the buffer, in which case we often have to
3921 resize the handle to "go all the way". */
3927 si
.cbSize
= sizeof (si
);
3928 si
.fMask
= SIF_POS
| SIF_PAGE
;
3929 GetScrollInfo(w
, SB_CTL
, &si
);
3930 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3938 /* Position scroll bar at rock bottom if the bottom of the
3939 buffer is visible. This avoids shinking the thumb away
3940 to nothing if it is held at the bottom of the buffer. */
3941 if (position
+ portion
>= whole
&& !draggingp
)
3943 sb_page
= range
* (whole
- position
) / whole
;
3948 sb_pos
= position
* range
/ whole
;
3949 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3958 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3962 si
.cbSize
= sizeof (si
);
3963 si
.fMask
= SIF_PAGE
| SIF_POS
;
3967 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3973 /************************************************************************
3974 Scroll bars, general
3975 ************************************************************************/
3978 my_create_scrollbar (f
, bar
)
3980 struct scroll_bar
* bar
;
3982 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3983 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
3987 /*#define ATTACH_THREADS*/
3990 my_show_window (FRAME_PTR f
, HWND hwnd
, int how
)
3992 #ifndef ATTACH_THREADS
3993 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3994 (WPARAM
) hwnd
, (LPARAM
) how
);
3996 return ShowWindow (hwnd
, how
);
4001 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
4002 int x
, int y
, int cx
, int cy
, UINT flags
)
4004 #ifndef ATTACH_THREADS
4006 pos
.hwndInsertAfter
= hwndAfter
;
4012 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
4014 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
4019 my_set_focus (f
, hwnd
)
4023 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
4028 my_set_foreground_window (hwnd
)
4031 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
4036 my_destroy_window (f
, hwnd
)
4040 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
4044 /* Create a scroll bar and return the scroll bar vector for it. W is
4045 the Emacs window on which to create the scroll bar. TOP, LEFT,
4046 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
4049 static struct scroll_bar
*
4050 x_scroll_bar_create (w
, top
, left
, width
, height
)
4052 int top
, left
, width
, height
;
4054 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4057 struct scroll_bar
*bar
4058 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
4062 XSETWINDOW (bar
->window
, w
);
4063 XSETINT (bar
->top
, top
);
4064 XSETINT (bar
->left
, left
);
4065 XSETINT (bar
->width
, width
);
4066 XSETINT (bar
->height
, height
);
4067 XSETINT (bar
->start
, 0);
4068 XSETINT (bar
->end
, 0);
4069 bar
->dragging
= Qnil
;
4070 bar
->fringe_extended_p
= Qnil
;
4072 /* Requires geometry to be set before call to create the real window */
4074 hwnd
= my_create_scrollbar (f
, bar
);
4076 si
.cbSize
= sizeof (si
);
4079 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
4080 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4084 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
4086 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
4088 /* Add bar to its frame's list of scroll bars. */
4089 bar
->next
= FRAME_SCROLL_BARS (f
);
4091 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4092 if (! NILP (bar
->next
))
4093 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4101 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
4105 x_scroll_bar_remove (bar
)
4106 struct scroll_bar
*bar
;
4108 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4112 /* Destroy the window. */
4113 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
4115 /* Disassociate this scroll bar from its window. */
4116 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
4121 /* Set the handle of the vertical scroll bar for WINDOW to indicate
4122 that we are displaying PORTION characters out of a total of WHOLE
4123 characters, starting at POSITION. If WINDOW has no scroll bar,
4126 w32_set_vertical_scroll_bar (w
, portion
, whole
, position
)
4128 int portion
, whole
, position
;
4130 struct frame
*f
= XFRAME (w
->frame
);
4131 struct scroll_bar
*bar
;
4132 int top
, height
, left
, sb_left
, width
, sb_width
;
4133 int window_y
, window_height
;
4134 int fringe_extended_p
;
4136 /* Get window dimensions. */
4137 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
4139 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
4140 height
= window_height
;
4142 /* Compute the left edge of the scroll bar area. */
4143 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
4145 /* Compute the width of the scroll bar which might be less than
4146 the width of the area reserved for the scroll bar. */
4147 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
4148 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
4152 /* Compute the left edge of the scroll bar. */
4153 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
4154 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
4156 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
4158 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
4159 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
4160 && WINDOW_LEFT_FRINGE_WIDTH (w
)
4161 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
4162 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
4164 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
4165 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
4166 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
4167 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
4169 /* Does the scroll bar exist yet? */
4170 if (NILP (w
->vertical_scroll_bar
))
4174 if (width
> 0 && height
> 0)
4176 hdc
= get_frame_dc (f
);
4177 if (fringe_extended_p
)
4178 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
4180 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
4181 release_frame_dc (f
, hdc
);
4185 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
4189 /* It may just need to be moved and resized. */
4192 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4193 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
4195 /* If already correctly positioned, do nothing. */
4196 if ( XINT (bar
->left
) == sb_left
4197 && XINT (bar
->top
) == top
4198 && XINT (bar
->width
) == sb_width
4199 && XINT (bar
->height
) == height
4200 && !NILP (bar
->fringe_extended_p
) == fringe_extended_p
)
4202 /* Redraw after clear_frame. */
4203 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
4204 InvalidateRect (hwnd
, NULL
, FALSE
);
4212 if (width
&& height
)
4214 hdc
= get_frame_dc (f
);
4215 /* Since Windows scroll bars are smaller than the space reserved
4216 for them on the frame, we have to clear "under" them. */
4217 if (fringe_extended_p
)
4218 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
4220 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
4221 release_frame_dc (f
, hdc
);
4223 /* Make sure scroll bar is "visible" before moving, to ensure the
4224 area of the parent window now exposed will be refreshed. */
4225 my_show_window (f
, hwnd
, SW_HIDE
);
4226 MoveWindow (hwnd
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4227 top
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4228 max (height
, 1), TRUE
);
4230 si
.cbSize
= sizeof (si
);
4231 si
.fMask
= SIF_RANGE
;
4233 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
4234 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4236 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
4238 my_show_window (f
, hwnd
, SW_NORMAL
);
4239 /* InvalidateRect (w, NULL, FALSE); */
4241 /* Remember new settings. */
4242 XSETINT (bar
->left
, sb_left
);
4243 XSETINT (bar
->top
, top
);
4244 XSETINT (bar
->width
, sb_width
);
4245 XSETINT (bar
->height
, height
);
4250 bar
->fringe_extended_p
= fringe_extended_p
? Qt
: Qnil
;
4252 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
4254 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
4258 /* The following three hooks are used when we're doing a thorough
4259 redisplay of the frame. We don't explicitly know which scroll bars
4260 are going to be deleted, because keeping track of when windows go
4261 away is a real pain - "Can you say set-window-configuration, boys
4262 and girls?" Instead, we just assert at the beginning of redisplay
4263 that *all* scroll bars are to be removed, and then save a scroll bar
4264 from the fiery pit when we actually redisplay its window. */
4266 /* Arrange for all scroll bars on FRAME to be removed at the next call
4267 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
4268 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
4271 w32_condemn_scroll_bars (frame
)
4274 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
4275 while (! NILP (FRAME_SCROLL_BARS (frame
)))
4278 bar
= FRAME_SCROLL_BARS (frame
);
4279 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
4280 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
4281 XSCROLL_BAR (bar
)->prev
= Qnil
;
4282 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
4283 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
4284 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
4289 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
4290 Note that WINDOW isn't necessarily condemned at all. */
4293 w32_redeem_scroll_bar (window
)
4294 struct window
*window
;
4296 struct scroll_bar
*bar
;
4299 /* We can't redeem this window's scroll bar if it doesn't have one. */
4300 if (NILP (window
->vertical_scroll_bar
))
4303 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
4305 /* Unlink it from the condemned list. */
4306 f
= XFRAME (WINDOW_FRAME (window
));
4307 if (NILP (bar
->prev
))
4309 /* If the prev pointer is nil, it must be the first in one of
4311 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
4312 /* It's not condemned. Everything's fine. */
4314 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4315 window
->vertical_scroll_bar
))
4316 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
4318 /* If its prev pointer is nil, it must be at the front of
4319 one or the other! */
4323 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4325 if (! NILP (bar
->next
))
4326 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4328 bar
->next
= FRAME_SCROLL_BARS (f
);
4330 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4331 if (! NILP (bar
->next
))
4332 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4335 /* Remove all scroll bars on FRAME that haven't been saved since the
4336 last call to `*condemn_scroll_bars_hook'. */
4339 w32_judge_scroll_bars (f
)
4342 Lisp_Object bar
, next
;
4344 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
4346 /* Clear out the condemned list now so we won't try to process any
4347 more events on the hapless scroll bars. */
4348 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
4350 for (; ! NILP (bar
); bar
= next
)
4352 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
4354 x_scroll_bar_remove (b
);
4357 b
->next
= b
->prev
= Qnil
;
4360 /* Now there should be no references to the condemned scroll bars,
4361 and they should get garbage-collected. */
4364 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
4365 is set to something other than NO_EVENT, it is enqueued.
4367 This may be called from a signal handler, so we have to ignore GC
4371 w32_scroll_bar_handle_click (bar
, msg
, emacs_event
)
4372 struct scroll_bar
*bar
;
4374 struct input_event
*emacs_event
;
4376 if (! WINDOWP (bar
->window
))
4379 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
4380 emacs_event
->code
= 0;
4381 /* not really meaningful to distinguish up/down */
4382 emacs_event
->modifiers
= msg
->dwModifiers
;
4383 emacs_event
->frame_or_window
= bar
->window
;
4384 emacs_event
->arg
= Qnil
;
4385 emacs_event
->timestamp
= msg
->msg
.time
;
4388 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4390 int dragging
= !NILP (bar
->dragging
);
4393 si
.cbSize
= sizeof (si
);
4396 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4399 bar
->dragging
= Qnil
;
4402 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4404 switch (LOWORD (msg
->msg
.wParam
))
4407 emacs_event
->part
= scroll_bar_down_arrow
;
4410 emacs_event
->part
= scroll_bar_up_arrow
;
4413 emacs_event
->part
= scroll_bar_above_handle
;
4416 emacs_event
->part
= scroll_bar_below_handle
;
4419 emacs_event
->part
= scroll_bar_handle
;
4423 emacs_event
->part
= scroll_bar_handle
;
4427 case SB_THUMBPOSITION
:
4428 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
4429 y
= HIWORD (msg
->msg
.wParam
);
4431 emacs_event
->part
= scroll_bar_handle
;
4433 /* "Silently" update current position. */
4437 si
.cbSize
= sizeof (si
);
4440 /* Remember apparent position (we actually lag behind the real
4441 position, so don't set that directly. */
4442 last_scroll_bar_drag_pos
= y
;
4444 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4448 /* If this is the end of a drag sequence, then reset the scroll
4449 handle size to normal and do a final redraw. Otherwise do
4454 int start
= XINT (bar
->start
);
4455 int end
= XINT (bar
->end
);
4457 si
.cbSize
= sizeof (si
);
4458 si
.fMask
= SIF_PAGE
| SIF_POS
;
4459 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4460 si
.nPos
= last_scroll_bar_drag_pos
;
4461 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4465 emacs_event
->kind
= NO_EVENT
;
4469 XSETINT (emacs_event
->x
, y
);
4470 XSETINT (emacs_event
->y
, top_range
);
4476 /* Return information to the user about the current position of the mouse
4477 on the scroll bar. */
4480 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
4482 Lisp_Object
*bar_window
;
4483 enum scroll_bar_part
*part
;
4485 unsigned long *time
;
4487 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
4488 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4489 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4491 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4497 *bar_window
= bar
->window
;
4499 si
.cbSize
= sizeof (si
);
4500 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4502 GetScrollInfo (w
, SB_CTL
, &si
);
4504 top_range
= si
.nMax
- si
.nPage
+ 1;
4506 switch (LOWORD (last_mouse_scroll_bar_pos
))
4508 case SB_THUMBPOSITION
:
4510 *part
= scroll_bar_handle
;
4511 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
4512 pos
= HIWORD (last_mouse_scroll_bar_pos
);
4515 *part
= scroll_bar_handle
;
4519 *part
= scroll_bar_handle
;
4524 XSETINT (*y
, top_range
);
4527 last_mouse_scroll_bar
= Qnil
;
4529 *time
= last_mouse_movement_time
;
4535 /* The screen has been cleared so we may have changed foreground or
4536 background colors, and the scroll bars may need to be redrawn.
4537 Clear out the scroll bars, and ask for expose events, so we can
4541 x_scroll_bar_clear (f
)
4546 /* We can have scroll bars even if this is 0,
4547 if we just turned off scroll bar mode.
4548 But in that case we should not clear them. */
4549 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4550 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4551 bar
= XSCROLL_BAR (bar
)->next
)
4553 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4554 HDC hdc
= GetDC (window
);
4557 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4558 arranges to refresh the scroll bar if hidden. */
4559 my_show_window (f
, window
, SW_HIDE
);
4561 GetClientRect (window
, &rect
);
4562 select_palette (f
, hdc
);
4563 w32_clear_rect (f
, hdc
, &rect
);
4564 deselect_palette (f
, hdc
);
4566 ReleaseDC (window
, hdc
);
4571 /* The main W32 event-reading loop - w32_read_socket. */
4573 /* Record the last 100 characters stored
4574 to help debug the loss-of-chars-during-GC problem. */
4576 static int temp_index
;
4577 static short temp_buffer
[100];
4579 /* Temporarily store lead byte of DBCS input sequences. */
4580 static char dbcs_lead
= 0;
4582 /* Read events coming from the W32 shell.
4583 This routine is called by the SIGIO handler.
4584 We return as soon as there are no more events to be read.
4586 We return the number of characters stored into the buffer,
4587 thus pretending to be `read'.
4589 EXPECTED is nonzero if the caller knows input is available.
4591 Some of these messages are reposted back to the message queue since the
4592 system calls the windows proc directly in a context where we cannot return
4593 the data nor can we guarantee the state we are in. So if we dispatch them
4594 we will get into an infinite loop. To prevent this from ever happening we
4595 will set a variable to indicate we are in the read_socket call and indicate
4596 which message we are processing since the windows proc gets called
4597 recursively with different messages by the system.
4601 w32_read_socket (sd
, expected
, hold_quit
)
4604 struct input_event
*hold_quit
;
4607 int check_visibility
= 0;
4610 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4612 if (interrupt_input_blocked
)
4614 interrupt_input_pending
= 1;
4618 interrupt_input_pending
= 0;
4621 /* So people can tell when we have read the available input. */
4622 input_signal_count
++;
4624 /* TODO: ghostscript integration. */
4625 while (get_next_msg (&msg
, FALSE
))
4627 struct input_event inev
;
4631 inev
.kind
= NO_EVENT
;
4634 switch (msg
.msg
.message
)
4637 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4641 if (msg
.rect
.right
== msg
.rect
.left
||
4642 msg
.rect
.bottom
== msg
.rect
.top
)
4644 /* We may get paint messages even though the client
4645 area is clipped - these are not expose events. */
4646 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4649 else if (f
->async_visible
!= 1)
4651 /* Definitely not obscured, so mark as visible. */
4652 f
->async_visible
= 1;
4653 f
->async_iconified
= 0;
4654 SET_FRAME_GARBAGED (f
);
4655 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4658 /* WM_PAINT serves as MapNotify as well, so report
4659 visibility changes properly. */
4662 inev
.kind
= DEICONIFY_EVENT
;
4663 XSETFRAME (inev
.frame_or_window
, f
);
4665 else if (! NILP (Vframe_list
)
4666 && ! NILP (XCDR (Vframe_list
)))
4667 /* Force a redisplay sooner or later to update the
4668 frame titles in case this is the second frame. */
4669 record_asynch_buffer_change ();
4673 HDC hdc
= get_frame_dc (f
);
4675 /* Erase background again for safety. */
4676 w32_clear_rect (f
, hdc
, &msg
.rect
);
4677 release_frame_dc (f
, hdc
);
4681 msg
.rect
.right
- msg
.rect
.left
,
4682 msg
.rect
.bottom
- msg
.rect
.top
);
4687 case WM_INPUTLANGCHANGE
:
4688 /* Generate a language change event. */
4689 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4693 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4694 XSETFRAME (inev
.frame_or_window
, f
);
4695 inev
.code
= msg
.msg
.wParam
;
4696 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4702 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4704 if (f
&& !f
->iconified
)
4706 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4707 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4709 clear_mouse_face (dpyinfo
);
4710 dpyinfo
->mouse_face_hidden
= 1;
4713 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4715 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4716 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4717 inev
.code
= msg
.msg
.wParam
;
4718 inev
.modifiers
= msg
.dwModifiers
;
4719 XSETFRAME (inev
.frame_or_window
, f
);
4720 inev
.timestamp
= msg
.msg
.time
;
4727 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4729 if (f
&& !f
->iconified
)
4731 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4732 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4734 clear_mouse_face (dpyinfo
);
4735 dpyinfo
->mouse_face_hidden
= 1;
4738 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4740 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4742 inev
.modifiers
= msg
.dwModifiers
;
4743 XSETFRAME (inev
.frame_or_window
, f
);
4744 inev
.timestamp
= msg
.msg
.time
;
4746 if (msg
.msg
.message
== WM_UNICHAR
)
4748 inev
.code
= msg
.msg
.wParam
;
4750 else if (msg
.msg
.wParam
< 256)
4755 dbcs
[1] = (char) msg
.msg
.wParam
;
4759 dbcs
[0] = dbcs_lead
;
4761 if (!MultiByteToWideChar (CP_ACP
, 0, dbcs
, 2, &code
, 1))
4764 DebPrint (("Invalid DBCS sequence: %d %d\n",
4766 inev
.kind
= NO_EVENT
;
4770 else if (IsDBCSLeadByteEx (CP_ACP
, (BYTE
) msg
.msg
.wParam
))
4772 dbcs_lead
= (char) msg
.msg
.wParam
;
4773 inev
.kind
= NO_EVENT
;
4778 if (!MultiByteToWideChar (CP_ACP
, 0, &dbcs
[1], 1,
4781 /* What to do with garbage? */
4782 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4783 inev
.kind
= NO_EVENT
;
4791 /* Windows shouldn't generate WM_CHAR events above 0xFF
4792 in non-Unicode message handlers. */
4793 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4794 inev
.kind
= NO_EVENT
;
4797 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4798 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4803 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4805 if (f
&& !f
->iconified
)
4807 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4808 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4810 clear_mouse_face (dpyinfo
);
4811 dpyinfo
->mouse_face_hidden
= 1;
4814 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4816 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4817 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4818 inev
.code
= GET_APPCOMMAND_LPARAM(msg
.msg
.lParam
);
4819 inev
.modifiers
= msg
.dwModifiers
;
4820 XSETFRAME (inev
.frame_or_window
, f
);
4821 inev
.timestamp
= msg
.msg
.time
;
4826 /* Ignore non-movement. */
4828 int x
= LOWORD (msg
.msg
.lParam
);
4829 int y
= HIWORD (msg
.msg
.lParam
);
4830 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4832 last_mousemove_x
= x
;
4833 last_mousemove_y
= y
;
4836 previous_help_echo_string
= help_echo_string
;
4837 help_echo_string
= Qnil
;
4839 if (dpyinfo
->grabbed
&& last_mouse_frame
4840 && FRAME_LIVE_P (last_mouse_frame
))
4841 f
= last_mouse_frame
;
4843 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4845 if (dpyinfo
->mouse_face_hidden
)
4847 dpyinfo
->mouse_face_hidden
= 0;
4848 clear_mouse_face (dpyinfo
);
4853 /* Generate SELECT_WINDOW_EVENTs when needed. */
4854 if (!NILP (Vmouse_autoselect_window
))
4857 int x
= LOWORD (msg
.msg
.lParam
);
4858 int y
= HIWORD (msg
.msg
.lParam
);
4860 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 0);
4862 /* Window will be selected only when it is not
4863 selected now and last mouse movement event was
4864 not in it. Minibuffer window will be selected
4865 only when it is active. */
4867 && !EQ (window
, last_window
)
4868 && !EQ (window
, selected_window
)
4869 /* For click-to-focus window managers
4870 create event iff we don't leave the
4872 && (focus_follows_mouse
4873 || (EQ (XWINDOW (window
)->frame
,
4874 XWINDOW (selected_window
)->frame
))))
4876 inev
.kind
= SELECT_WINDOW_EVENT
;
4877 inev
.frame_or_window
= window
;
4882 if (!note_mouse_movement (f
, &msg
.msg
))
4883 help_echo_string
= previous_help_echo_string
;
4887 /* If we move outside the frame, then we're
4888 certainly no longer on any text in the frame. */
4889 clear_mouse_face (dpyinfo
);
4892 /* If the contents of the global variable help_echo_string
4893 has changed, generate a HELP_EVENT. */
4894 #if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE.
4895 But it was originally changed to this to fix a bug, so I have
4896 not removed it completely in case the bug is still there. */
4897 if (help_echo_string
!= previous_help_echo_string
||
4898 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4899 #else /* This is what xterm.c does. */
4900 if (!NILP (help_echo_string
)
4901 || !NILP (previous_help_echo_string
))
4906 case WM_LBUTTONDOWN
:
4908 case WM_MBUTTONDOWN
:
4910 case WM_RBUTTONDOWN
:
4912 case WM_XBUTTONDOWN
:
4915 /* If we decide we want to generate an event to be seen
4916 by the rest of Emacs, we put it here. */
4921 if (dpyinfo
->grabbed
&& last_mouse_frame
4922 && FRAME_LIVE_P (last_mouse_frame
))
4923 f
= last_mouse_frame
;
4925 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4929 construct_mouse_click (&inev
, &msg
, f
);
4931 /* Is this in the tool-bar? */
4932 if (WINDOWP (f
->tool_bar_window
)
4933 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4936 int x
= XFASTINT (inev
.x
);
4937 int y
= XFASTINT (inev
.y
);
4939 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
4941 if (EQ (window
, f
->tool_bar_window
))
4943 w32_handle_tool_bar_click (f
, &inev
);
4949 || (dpyinfo
->w32_focus_frame
4950 && f
!= dpyinfo
->w32_focus_frame
))
4951 inev
.kind
= NO_EVENT
;
4954 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4959 dpyinfo
->grabbed
&= ~ (1 << button
);
4963 dpyinfo
->grabbed
|= (1 << button
);
4964 last_mouse_frame
= f
;
4965 /* Ignore any mouse motion that happened
4966 before this event; any subsequent mouse-movement
4967 Emacs events should reflect only motion after
4973 last_tool_bar_item
= -1;
4979 case WM_MOUSEHWHEEL
:
4981 if (dpyinfo
->grabbed
&& last_mouse_frame
4982 && FRAME_LIVE_P (last_mouse_frame
))
4983 f
= last_mouse_frame
;
4985 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4990 if (!dpyinfo
->w32_focus_frame
4991 || f
== dpyinfo
->w32_focus_frame
)
4993 /* Emit an Emacs wheel-up/down event. */
4994 construct_mouse_wheel (&inev
, &msg
, f
);
4996 /* Ignore any mouse motion that happened before this
4997 event; any subsequent mouse-movement Emacs events
4998 should reflect only motion after the
5002 last_mouse_frame
= f
;
5003 last_tool_bar_item
= -1;
5008 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5011 construct_drag_n_drop (&inev
, &msg
, f
);
5016 struct scroll_bar
*bar
=
5017 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
5020 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
5024 case WM_WINDOWPOSCHANGED
:
5025 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5028 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
5029 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
5031 check_visibility
= 1;
5035 case WM_ACTIVATEAPP
:
5036 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5038 x_check_fullscreen (f
);
5039 check_visibility
= 1;
5043 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5045 if (f
&& !f
->async_iconified
)
5049 x_real_positions (f
, &x
, &y
);
5054 check_visibility
= 1;
5058 /* wParam non-zero means Window is about to be shown, 0 means
5059 about to be hidden. */
5060 /* Redo the mouse-highlight after the tooltip has gone. */
5061 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
5064 redo_mouse_highlight ();
5067 /* If window has been obscured or exposed by another window
5068 being maximised or minimised/restored, then recheck
5069 visibility of all frames. Direct changes to our own
5070 windows get handled by WM_SIZE. */
5072 if (msg
.msg
.lParam
!= 0)
5073 check_visibility
= 1;
5076 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5077 f
->async_visible
= msg
.msg
.wParam
;
5081 check_visibility
= 1;
5085 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5087 /* Inform lisp of whether frame has been iconified etc. */
5090 switch (msg
.msg
.wParam
)
5092 case SIZE_MINIMIZED
:
5093 f
->async_visible
= 0;
5094 f
->async_iconified
= 1;
5096 inev
.kind
= ICONIFY_EVENT
;
5097 XSETFRAME (inev
.frame_or_window
, f
);
5100 case SIZE_MAXIMIZED
:
5102 f
->async_visible
= 1;
5103 f
->async_iconified
= 0;
5105 /* wait_reading_process_output will notice this and update
5106 the frame's display structures. */
5107 SET_FRAME_GARBAGED (f
);
5113 /* Reset top and left positions of the Window
5114 here since Windows sends a WM_MOVE message
5115 BEFORE telling us the Window is minimized
5116 when the Window is iconified, with 3000,3000
5118 x_real_positions (f
, &x
, &y
);
5122 inev
.kind
= DEICONIFY_EVENT
;
5123 XSETFRAME (inev
.frame_or_window
, f
);
5125 else if (! NILP (Vframe_list
)
5126 && ! NILP (XCDR (Vframe_list
)))
5127 /* Force a redisplay sooner or later
5128 to update the frame titles
5129 in case this is the second frame. */
5130 record_asynch_buffer_change ();
5135 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
5143 GetClientRect (msg
.msg
.hwnd
, &rect
);
5145 height
= rect
.bottom
- rect
.top
;
5146 width
= rect
.right
- rect
.left
;
5148 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
5149 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
5151 /* TODO: Clip size to the screen dimensions. */
5153 /* Even if the number of character rows and columns has
5154 not changed, the font size may have changed, so we need
5155 to check the pixel dimensions as well. */
5157 if (columns
!= FRAME_COLS (f
)
5158 || rows
!= FRAME_LINES (f
)
5159 || width
!= FRAME_PIXEL_WIDTH (f
)
5160 || height
!= FRAME_PIXEL_HEIGHT (f
))
5162 change_frame_size (f
, rows
, columns
, 0, 1, 0);
5163 SET_FRAME_GARBAGED (f
);
5164 cancel_mouse_face (f
);
5165 FRAME_PIXEL_WIDTH (f
) = width
;
5166 FRAME_PIXEL_HEIGHT (f
) = height
;
5167 f
->win_gravity
= NorthWestGravity
;
5171 check_visibility
= 1;
5175 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5178 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5180 /* If we move outside the frame, then we're
5181 certainly no longer on any text in the frame. */
5182 clear_mouse_face (dpyinfo
);
5183 dpyinfo
->mouse_face_mouse_frame
= 0;
5186 /* Generate a nil HELP_EVENT to cancel a help-echo.
5187 Do it only if there's something to cancel.
5188 Otherwise, the startup message is cleared when
5189 the mouse leaves the frame. */
5190 if (any_help_event_p
)
5196 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5198 dpyinfo
->grabbed
= 0;
5199 check_visibility
= 1;
5203 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5207 if (f
== dpyinfo
->w32_focus_event_frame
)
5208 dpyinfo
->w32_focus_event_frame
= 0;
5210 if (f
== dpyinfo
->w32_focus_frame
)
5211 x_new_focus_frame (dpyinfo
, 0);
5213 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5215 /* If we move outside the frame, then we're
5216 certainly no longer on any text in the frame. */
5217 clear_mouse_face (dpyinfo
);
5218 dpyinfo
->mouse_face_mouse_frame
= 0;
5221 /* Generate a nil HELP_EVENT to cancel a help-echo.
5222 Do it only if there's something to cancel.
5223 Otherwise, the startup message is cleared when
5224 the mouse leaves the frame. */
5225 if (any_help_event_p
)
5229 dpyinfo
->grabbed
= 0;
5230 check_visibility
= 1;
5234 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5238 inev
.kind
= DELETE_WINDOW_EVENT
;
5239 XSETFRAME (inev
.frame_or_window
, f
);
5244 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5248 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
5249 XSETFRAME (inev
.frame_or_window
, f
);
5254 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5258 extern void menubar_selection_callback
5259 (FRAME_PTR f
, void * client_data
);
5260 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
5263 check_visibility
= 1;
5266 case WM_DISPLAYCHANGE
:
5267 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5271 dpyinfo
->width
= (short) LOWORD (msg
.msg
.lParam
);
5272 dpyinfo
->height
= (short) HIWORD (msg
.msg
.lParam
);
5273 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
5274 DebPrint (("display change: %d %d\n", dpyinfo
->width
,
5278 check_visibility
= 1;
5282 /* Check for messages registered at runtime. */
5283 if (msg
.msg
.message
== msh_mousewheel
)
5285 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5286 msg
.msg
.message
= WM_MOUSEWHEEL
;
5292 if (inev
.kind
!= NO_EVENT
)
5294 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5299 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5304 XSETFRAME (frame
, f
);
5310 if (NILP (help_echo_string
))
5312 help_echo_object
= help_echo_window
= Qnil
;
5316 any_help_event_p
= 1;
5317 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5318 help_echo_object
, help_echo_pos
);
5322 help_echo_string
= Qnil
;
5323 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5329 /* If the focus was just given to an autoraising frame,
5331 /* ??? This ought to be able to handle more than one such frame. */
5332 if (pending_autoraise_frame
)
5334 x_raise_frame (pending_autoraise_frame
);
5335 pending_autoraise_frame
= 0;
5338 /* Check which frames are still visisble, if we have enqueued any user
5339 events or been notified of events that may affect visibility. We
5340 do this here because there doesn't seem to be any direct
5341 notification from Windows that the visibility of a window has
5342 changed (at least, not in all cases). */
5343 if (count
> 0 || check_visibility
)
5345 Lisp_Object tail
, frame
;
5347 FOR_EACH_FRAME (tail
, frame
)
5349 FRAME_PTR f
= XFRAME (frame
);
5350 /* The tooltip has been drawn already. Avoid the
5351 SET_FRAME_GARBAGED below. */
5352 if (EQ (frame
, tip_frame
))
5355 /* Check "visible" frames and mark each as obscured or not.
5356 Note that async_visible is nonzero for unobscured and
5357 obscured frames, but zero for hidden and iconified frames. */
5358 if (FRAME_W32_P (f
) && f
->async_visible
)
5364 /* Query clipping rectangle for the entire window area
5365 (GetWindowDC), not just the client portion (GetDC).
5366 Otherwise, the scrollbars and menubar aren't counted as
5367 part of the visible area of the frame, and we may think
5368 the frame is obscured when really a scrollbar is still
5369 visible and gets WM_PAINT messages above. */
5370 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5371 GetClipBox (hdc
, &clipbox
);
5372 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5375 if (clipbox
.right
== clipbox
.left
5376 || clipbox
.bottom
== clipbox
.top
)
5378 /* Frame has become completely obscured so mark as
5379 such (we do this by setting async_visible to 2 so
5380 that FRAME_VISIBLE_P is still true, but redisplay
5382 f
->async_visible
= 2;
5384 if (!FRAME_OBSCURED_P (f
))
5386 DebPrint (("frame %p (%s) obscured\n", f
,
5392 /* Frame is not obscured, so mark it as such. */
5393 f
->async_visible
= 1;
5395 if (FRAME_OBSCURED_P (f
))
5397 SET_FRAME_GARBAGED (f
);
5398 DebPrint (("obscured frame %p (%s) found to be visible\n", f
,
5401 /* Force a redisplay sooner or later. */
5402 record_asynch_buffer_change ();
5415 /***********************************************************************
5417 ***********************************************************************/
5419 /* Set clipping for output in glyph row ROW. W is the window in which
5420 we operate. GC is the graphics context to set clipping in.
5422 ROW may be a text row or, e.g., a mode line. Text rows must be
5423 clipped to the interior of the window dedicated to text display,
5424 mode lines must be clipped to the whole window. */
5427 w32_clip_to_row (w
, row
, area
, hdc
)
5429 struct glyph_row
*row
;
5433 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5435 int window_x
, window_y
, window_width
;
5437 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5439 clip_rect
.left
= window_x
;
5440 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5441 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5442 clip_rect
.right
= clip_rect
.left
+ window_width
;
5443 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5445 w32_set_clip_rectangle (hdc
, &clip_rect
);
5449 /* Draw a hollow box cursor on window W in glyph row ROW. */
5452 x_draw_hollow_cursor (w
, row
)
5454 struct glyph_row
*row
;
5456 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5460 struct glyph
*cursor_glyph
;
5461 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5463 /* Get the glyph the cursor is on. If we can't tell because
5464 the current matrix is invalid or such, give up. */
5465 cursor_glyph
= get_phys_cursor_glyph (w
);
5466 if (cursor_glyph
== NULL
)
5469 /* Compute frame-relative coordinates for phys cursor. */
5470 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5473 rect
.bottom
= rect
.top
+ h
;
5474 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5476 hdc
= get_frame_dc (f
);
5477 /* Set clipping, draw the rectangle, and reset clipping again. */
5478 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5479 FrameRect (hdc
, &rect
, hb
);
5481 w32_set_clip_rectangle (hdc
, NULL
);
5482 release_frame_dc (f
, hdc
);
5486 /* Draw a bar cursor on window W in glyph row ROW.
5488 Implementation note: One would like to draw a bar cursor with an
5489 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5490 Unfortunately, I didn't find a font yet that has this property set.
5494 x_draw_bar_cursor (w
, row
, width
, kind
)
5496 struct glyph_row
*row
;
5498 enum text_cursor_kinds kind
;
5500 struct frame
*f
= XFRAME (w
->frame
);
5501 struct glyph
*cursor_glyph
;
5505 /* If cursor is out of bounds, don't draw garbage. This can happen
5506 in mini-buffer windows when switching between echo area glyphs
5508 cursor_glyph
= get_phys_cursor_glyph (w
);
5509 if (cursor_glyph
== NULL
)
5512 /* If on an image, draw like a normal cursor. That's usually better
5513 visible than drawing a bar, esp. if the image is large so that
5514 the bar might not be in the window. */
5515 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5517 struct glyph_row
*row
;
5518 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5519 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5523 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5524 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5526 /* If the glyph's background equals the color we normally draw
5527 the bar cursor in, the bar cursor in its normal color is
5528 invisible. Use the glyph's foreground color instead in this
5529 case, on the assumption that the glyph's colors are chosen so
5530 that the glyph is legible. */
5531 if (face
->background
== cursor_color
)
5532 cursor_color
= face
->foreground
;
5534 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5537 width
= FRAME_CURSOR_WIDTH (f
);
5538 width
= min (cursor_glyph
->pixel_width
, width
);
5540 w
->phys_cursor_width
= width
;
5543 hdc
= get_frame_dc (f
);
5544 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5546 if (kind
== BAR_CURSOR
)
5548 w32_fill_area (f
, hdc
, cursor_color
, x
,
5549 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5550 width
, row
->height
);
5554 w32_fill_area (f
, hdc
, cursor_color
, x
,
5555 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5556 row
->height
- width
),
5557 cursor_glyph
->pixel_width
, width
);
5560 w32_set_clip_rectangle (hdc
, NULL
);
5561 release_frame_dc (f
, hdc
);
5566 /* RIF: Define cursor CURSOR on frame F. */
5569 w32_define_frame_cursor (f
, cursor
)
5573 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5577 /* RIF: Clear area on frame F. */
5580 w32_clear_frame_area (f
, x
, y
, width
, height
)
5582 int x
, y
, width
, height
;
5586 hdc
= get_frame_dc (f
);
5587 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5588 release_frame_dc (f
, hdc
);
5591 /* RIF: Draw or clear cursor on window W. */
5594 w32_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
5596 struct glyph_row
*glyph_row
;
5598 int cursor_type
, cursor_width
;
5603 /* If the user wants to use the system caret, make sure our own
5604 cursor remains invisible. */
5605 if (w32_use_visible_system_caret
)
5607 /* Call to erase_phys_cursor here seems to use the
5608 wrong values of w->phys_cursor, as they have been
5609 overwritten before this function was called. */
5610 if (w
->phys_cursor_type
!= NO_CURSOR
)
5611 erase_phys_cursor (w
);
5613 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5614 w
->phys_cursor_width
= -1;
5618 w
->phys_cursor_type
= cursor_type
;
5621 w
->phys_cursor_on_p
= 1;
5623 /* If this is the active cursor, we need to track it with the
5624 system caret, so third party software like screen magnifiers
5625 and speech synthesizers can follow the cursor. */
5628 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5629 HWND hwnd
= FRAME_W32_WINDOW (f
);
5632 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5634 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5635 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5637 /* If the size of the active cursor changed, destroy the old
5639 if (w32_system_caret_hwnd
5640 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5641 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5643 w32_system_caret_height
= w
->phys_cursor_height
;
5645 /* Move the system caret. */
5646 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5649 if (glyph_row
->exact_window_width_line_p
5650 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
5652 glyph_row
->cursor_in_fringe_p
= 1;
5653 draw_fringe_bitmap (w
, glyph_row
, 0);
5657 switch (cursor_type
)
5659 case HOLLOW_BOX_CURSOR
:
5660 x_draw_hollow_cursor (w
, glyph_row
);
5663 case FILLED_BOX_CURSOR
:
5664 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5668 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5672 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5676 w
->phys_cursor_width
= 0;
5690 x_bitmap_icon (f
, icon
)
5695 HANDLE small_icon
= NULL
;
5697 if (FRAME_W32_WINDOW (f
) == 0)
5701 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5702 else if (STRINGP (icon
))
5704 /* Load the main icon from the named file. */
5705 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5706 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5707 /* Try to load a small icon to go with it. */
5708 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5709 GetSystemMetrics (SM_CXSMICON
),
5710 GetSystemMetrics (SM_CYSMICON
),
5713 else if (SYMBOLP (icon
))
5717 if (EQ (icon
, intern ("application")))
5718 name
= (LPCTSTR
) IDI_APPLICATION
;
5719 else if (EQ (icon
, intern ("hand")))
5720 name
= (LPCTSTR
) IDI_HAND
;
5721 else if (EQ (icon
, intern ("question")))
5722 name
= (LPCTSTR
) IDI_QUESTION
;
5723 else if (EQ (icon
, intern ("exclamation")))
5724 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5725 else if (EQ (icon
, intern ("asterisk")))
5726 name
= (LPCTSTR
) IDI_ASTERISK
;
5727 else if (EQ (icon
, intern ("winlogo")))
5728 name
= (LPCTSTR
) IDI_WINLOGO
;
5732 main_icon
= LoadIcon (NULL
, name
);
5737 if (main_icon
== NULL
)
5740 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5741 (LPARAM
) main_icon
);
5743 /* If there is a small icon that goes with it, set that too. */
5745 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5746 (LPARAM
) small_icon
);
5752 /************************************************************************
5754 ************************************************************************/
5756 /* Display Error Handling functions not used on W32. Listing them here
5757 helps diff stay in step when comparing w32term.c with xterm.c.
5759 x_error_catcher (display, error)
5760 x_catch_errors (dpy)
5761 x_catch_errors_unwind (old_val)
5762 x_check_errors (dpy, format)
5763 x_fully_uncatch_errors ()
5764 x_catching_errors ()
5765 x_had_errors_p (dpy)
5766 x_clear_errors (dpy)
5767 x_uncatch_errors (dpy, count)
5769 x_connection_signal (signalnum)
5770 x_connection_closed (dpy, error_message)
5771 x_error_quitter (display, error)
5772 x_error_handler (display, error)
5773 x_io_error_quitter (display)
5778 /* Changing the font of the frame. */
5782 /* Give frame F the font named FONTNAME as its default font, and
5783 return the full name of that font. FONTNAME may be a wildcard
5784 pattern; in that case, we choose some font that fits the pattern.
5785 The return value shows which font we chose. */
5788 x_new_font (f
, fontname
)
5790 register char *fontname
;
5792 struct font_info
*fontp
5793 = FS_LOAD_FONT (f
, fontname
);
5798 if (FRAME_FONT (f
) == (XFontStruct
*) (fontp
->font
))
5799 /* This font is already set in frame F. There's nothing more to
5801 return build_string (fontp
->full_name
);
5803 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
5804 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
5805 FRAME_FONTSET (f
) = -1;
5807 FRAME_COLUMN_WIDTH (f
) = fontp
->average_width
;
5808 FRAME_SPACE_WIDTH (f
) = fontp
->space_width
;
5809 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
5811 compute_fringe_widths (f
, 1);
5813 /* Compute the scroll bar width in character columns. */
5814 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5816 int wid
= FRAME_COLUMN_WIDTH (f
);
5817 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5818 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
5822 int wid
= FRAME_COLUMN_WIDTH (f
);
5823 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5826 /* Now make the frame display the given font. */
5827 if (FRAME_W32_WINDOW (f
) != 0)
5829 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5830 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5833 return build_string (fontp
->full_name
);
5836 /* Give frame F the fontset named FONTSETNAME as its default fontset,
5837 and return the full name of that fontset. FONTSETNAME may be a
5838 wildcard pattern; in that case, we choose some fontset that fits
5839 the pattern. FONTSETNAME may be a font name for ASCII characters;
5840 in that case, we create a fontset from that font name.
5842 The return value shows which fontset we chose.
5843 If FONTSETNAME specifies the default fontset, return Qt.
5844 If an ASCII font in the specified fontset can't be loaded, return
5848 x_new_fontset (f
, fontsetname
)
5850 Lisp_Object fontsetname
;
5852 int fontset
= fs_query_fontset (fontsetname
, 0);
5855 if (fontset
> 0 && FRAME_FONTSET(f
) == fontset
)
5856 /* This fontset is already set in frame F. There's nothing more
5858 return fontset_name (fontset
);
5859 else if (fontset
== 0)
5860 /* The default fontset can't be the default font. */
5864 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
5866 result
= x_new_font (f
, SDATA (fontsetname
));
5868 if (!STRINGP (result
))
5869 /* Can't load ASCII font. */
5873 fontset
= new_fontset_from_font_name (result
);
5875 /* Since x_new_font doesn't update any fontset information, do it now. */
5876 FRAME_FONTSET(f
) = fontset
;
5878 return fontset_name (fontset
);
5880 #endif /* OLD_FONT */
5884 x_new_font (f
, font_object
, fontset
)
5886 Lisp_Object font_object
;
5889 struct font
*font
= XFONT_OBJECT (font_object
);
5892 fontset
= fontset_from_font (font_object
);
5893 FRAME_FONTSET (f
) = fontset
;
5894 if (FRAME_FONT (f
) == font
)
5895 /* This font is already set in frame F. There's nothing more to
5897 return fontset_name (fontset
);
5901 FRAME_FONT (f
) = font
;
5902 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5903 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
5904 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
5905 FRAME_LINE_HEIGHT (f
) = font
->height
;
5907 compute_fringe_widths (f
, 1);
5909 /* Compute the scroll bar width in character columns. */
5910 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5912 int wid
= FRAME_COLUMN_WIDTH (f
);
5913 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5914 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
- 1) / wid
;
5918 int wid
= FRAME_COLUMN_WIDTH (f
);
5919 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5922 /* Now make the frame display the given font. */
5923 if (FRAME_X_WINDOW (f
) != 0)
5925 /* Don't change the size of a tip frame; there's no point in
5926 doing it because it's done in Fx_show_tip, and it leads to
5927 problems because the tip frame has no widget. */
5928 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5929 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5934 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
5935 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
5940 return fontset_name (fontset
);
5944 /***********************************************************************
5945 TODO: W32 Input Methods
5946 ***********************************************************************/
5947 /* Listing missing functions from xterm.c helps diff stay in step.
5949 xim_destroy_callback (xim, client_data, call_data)
5950 xim_open_dpy (dpyinfo, resource_name)
5952 xim_instantiate_callback (display, client_data, call_data)
5953 xim_initialize (dpyinfo, resource_name)
5954 xim_close_dpy (dpyinfo)
5959 /* Calculate the absolute position in frame F
5960 from its current recorded position values and gravity. */
5963 x_calc_absolute_position (f
)
5966 int flags
= f
->size_hint_flags
;
5968 /* The sum of the widths of the frame's left and right borders, and
5969 the sum of the heights of the frame's top and bottom borders (in
5970 pixels) drawn by Windows. */
5971 unsigned int left_right_borders_width
, top_bottom_borders_height
;
5973 /* Try to get the actual values of these two variables. We compute
5974 the border width (height) by subtracting the width (height) of
5975 the frame's client area from the width (height) of the frame's
5977 WINDOWPLACEMENT wp
= { 0 };
5978 RECT client_rect
= { 0 };
5980 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
5981 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
5983 left_right_borders_width
=
5984 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
5985 (client_rect
.right
- client_rect
.left
);
5987 top_bottom_borders_height
=
5988 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
5989 (client_rect
.bottom
- client_rect
.top
);
5993 /* Use sensible default values. */
5994 left_right_borders_width
= 8;
5995 top_bottom_borders_height
= 32;
5998 /* Treat negative positions as relative to the rightmost bottommost
5999 position that fits on the screen. */
6000 if (flags
& XNegative
)
6001 f
->left_pos
= (FRAME_W32_DISPLAY_INFO (f
)->width
6002 - FRAME_PIXEL_WIDTH (f
)
6004 - (left_right_borders_width
- 1));
6006 if (flags
& YNegative
)
6007 f
->top_pos
= (FRAME_W32_DISPLAY_INFO (f
)->height
6008 - FRAME_PIXEL_HEIGHT (f
)
6010 - (top_bottom_borders_height
- 1));
6012 /* The left_pos and top_pos are now relative to the top and left
6013 screen edges, so the flags should correspond. */
6014 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6017 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
6018 to really change the position, and 0 when calling from
6019 x_make_frame_visible (in that case, XOFF and YOFF are the current
6020 position values). It is -1 when calling from x_set_frame_parameters,
6021 which means, do adjust for borders but don't change the gravity. */
6024 x_set_offset (f
, xoff
, yoff
, change_gravity
)
6026 register int xoff
, yoff
;
6029 int modified_top
, modified_left
;
6031 if (change_gravity
> 0)
6035 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6037 f
->size_hint_flags
|= XNegative
;
6039 f
->size_hint_flags
|= YNegative
;
6040 f
->win_gravity
= NorthWestGravity
;
6042 x_calc_absolute_position (f
);
6045 x_wm_set_size_hint (f
, (long) 0, 0);
6047 modified_left
= f
->left_pos
;
6048 modified_top
= f
->top_pos
;
6050 my_set_window_pos (FRAME_W32_WINDOW (f
),
6052 modified_left
, modified_top
,
6054 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6059 /* Check if we need to resize the frame due to a fullscreen request.
6060 If so needed, resize the frame. */
6062 x_check_fullscreen (f
)
6065 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
6067 int width
, height
, ign
;
6069 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6071 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
6073 /* We do not need to move the window, it shall be taken care of
6074 when setting WM manager hints. */
6075 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
6077 change_frame_size (f
, height
, width
, 0, 1, 0);
6078 SET_FRAME_GARBAGED (f
);
6079 cancel_mouse_face (f
);
6081 /* Wait for the change of frame size to occur */
6082 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
6087 /* Call this to change the size of frame F's x-window.
6088 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
6089 for this size change and subsequent size changes.
6090 Otherwise we leave the window gravity unchanged. */
6093 x_set_window_size (f
, change_gravity
, cols
, rows
)
6098 int pixelwidth
, pixelheight
;
6102 check_frame_size (f
, &rows
, &cols
);
6103 f
->scroll_bar_actual_width
6104 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
6106 compute_fringe_widths (f
, 0);
6108 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
6109 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
6111 f
->win_gravity
= NorthWestGravity
;
6112 x_wm_set_size_hint (f
, (long) 0, 0);
6117 rect
.left
= rect
.top
= 0;
6118 rect
.right
= pixelwidth
;
6119 rect
.bottom
= pixelheight
;
6121 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
6122 FRAME_EXTERNAL_MENU_BAR (f
));
6124 my_set_window_pos (FRAME_W32_WINDOW (f
),
6127 rect
.right
- rect
.left
,
6128 rect
.bottom
- rect
.top
,
6129 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6133 /* The following mirrors what is done in xterm.c. It appears to be
6134 for informing lisp of the new size immediately, while the actual
6135 resize will happen asynchronously. But on Windows, the menu bar
6136 automatically wraps when the frame is too narrow to contain it,
6137 and that causes any calculations made here to come out wrong. The
6138 end is some nasty buggy behaviour, including the potential loss
6141 Disabling this code is either not sufficient to fix the problems
6142 completely, or it causes fresh problems, but at least it removes
6143 the most problematic symptom of the minibuffer becoming unusable.
6145 -----------------------------------------------------------------
6147 Now, strictly speaking, we can't be sure that this is accurate,
6148 but the window manager will get around to dealing with the size
6149 change request eventually, and we'll hear how it went when the
6150 ConfigureNotify event gets here.
6152 We could just not bother storing any of this information here,
6153 and let the ConfigureNotify event set everything up, but that
6154 might be kind of confusing to the Lisp code, since size changes
6155 wouldn't be reported in the frame parameters until some random
6156 point in the future when the ConfigureNotify event arrives.
6158 We pass 1 for DELAY since we can't run Lisp code inside of
6160 change_frame_size (f
, rows
, cols
, 0, 1, 0);
6161 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
6162 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
6164 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
6165 receive in the ConfigureNotify event; if we get what we asked
6166 for, then the event won't cause the screen to become garbaged, so
6167 we have to make sure to do it here. */
6168 SET_FRAME_GARBAGED (f
);
6170 /* If cursor was outside the new size, mark it as off. */
6171 mark_window_cursors_off (XWINDOW (f
->root_window
));
6173 /* Clear out any recollection of where the mouse highlighting was,
6174 since it might be in a place that's outside the new frame size.
6175 Actually checking whether it is outside is a pain in the neck,
6176 so don't try--just let the highlighting be done afresh with new size. */
6177 cancel_mouse_face (f
);
6183 /* Mouse warping. */
6185 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
6188 x_set_mouse_position (f
, x
, y
)
6194 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
6195 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
6197 if (pix_x
< 0) pix_x
= 0;
6198 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
6200 if (pix_y
< 0) pix_y
= 0;
6201 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
6203 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
6207 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
6216 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
6217 pt
.x
= rect
.left
+ pix_x
;
6218 pt
.y
= rect
.top
+ pix_y
;
6219 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
6221 SetCursorPos (pt
.x
, pt
.y
);
6227 /* focus shifting, raising and lowering. */
6230 x_focus_on_frame (f
)
6233 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6235 /* Give input focus to frame. */
6238 /* Try not to change its Z-order if possible. */
6239 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
6240 my_set_focus (f
, FRAME_W32_WINDOW (f
));
6243 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6253 /* Raise frame F. */
6260 /* Strictly speaking, raise-frame should only change the frame's Z
6261 order, leaving input focus unchanged. This is reasonable behaviour
6262 on X where the usual policy is point-to-focus. However, this
6263 behaviour would be very odd on Windows where the usual policy is
6266 On X, if the mouse happens to be over the raised frame, it gets
6267 input focus anyway (so the window with focus will never be
6268 completely obscured) - if not, then just moving the mouse over it
6269 is sufficient to give it focus. On Windows, the user must actually
6270 click on the frame (preferrably the title bar so as not to move
6271 point), which is more awkward. Also, no other Windows program
6272 raises a window to the top but leaves another window (possibly now
6273 completely obscured) with input focus.
6275 Because there is a system setting on Windows that allows the user
6276 to choose the point to focus policy, we make the strict semantics
6277 optional, but by default we grab focus when raising. */
6279 if (NILP (Vw32_grab_focus_on_raise
))
6281 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6282 not already the foreground application: the frame is raised
6283 above all other frames belonging to us, but not above the
6284 current top window. To achieve that, we have to resort to this
6285 more cumbersome method. */
6287 HDWP handle
= BeginDeferWindowPos (2);
6290 DeferWindowPos (handle
,
6291 FRAME_W32_WINDOW (f
),
6294 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6296 DeferWindowPos (handle
,
6297 GetForegroundWindow (),
6298 FRAME_W32_WINDOW (f
),
6300 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6302 EndDeferWindowPos (handle
);
6307 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6313 /* Lower frame F. */
6319 my_set_window_pos (FRAME_W32_WINDOW (f
),
6322 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6327 w32_frame_raise_lower (f
, raise_flag
)
6331 if (! FRAME_W32_P (f
))
6340 /* Change of visibility. */
6342 /* This tries to wait until the frame is really visible.
6343 However, if the window manager asks the user where to position
6344 the frame, this will return before the user finishes doing that.
6345 The frame will not actually be visible at that time,
6346 but it will become visible later when the window manager
6347 finishes with it. */
6350 x_make_frame_visible (f
)
6357 type
= x_icon_type (f
);
6359 x_bitmap_icon (f
, type
);
6361 if (! FRAME_VISIBLE_P (f
))
6363 /* We test FRAME_GARBAGED_P here to make sure we don't
6364 call x_set_offset a second time
6365 if we get to x_make_frame_visible a second time
6366 before the window gets really visible. */
6367 if (! FRAME_ICONIFIED_P (f
)
6368 && ! f
->output_data
.w32
->asked_for_visible
)
6373 /* Adjust vertical window position in order to avoid being
6374 covered by a task bar placed at the bottom of the desktop. */
6375 SystemParametersInfo(SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6376 GetWindowRect(FRAME_W32_WINDOW(f
), &window_rect
);
6377 if (window_rect
.bottom
> workarea_rect
.bottom
6378 && window_rect
.top
> workarea_rect
.top
)
6379 f
->top_pos
= max (window_rect
.top
6380 - window_rect
.bottom
+ workarea_rect
.bottom
,
6383 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6386 f
->output_data
.w32
->asked_for_visible
= 1;
6388 /* my_show_window (f, FRAME_W32_WINDOW (f), f->async_iconified ? SW_RESTORE : SW_SHOW); */
6389 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_SHOWNORMAL
);
6392 /* Synchronize to ensure Emacs knows the frame is visible
6393 before we do anything else. We do this loop with input not blocked
6394 so that incoming events are handled. */
6399 /* This must come after we set COUNT. */
6402 XSETFRAME (frame
, f
);
6404 /* Wait until the frame is visible. Process X events until a
6405 MapNotify event has been seen, or until we think we won't get a
6406 MapNotify at all.. */
6407 for (count
= input_signal_count
+ 10;
6408 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6410 /* Force processing of queued events. */
6411 /* TODO: x_sync equivalent? */
6413 /* Machines that do polling rather than SIGIO have been observed
6414 to go into a busy-wait here. So we'll fake an alarm signal
6415 to let the handler know that there's something to be read.
6416 We used to raise a real alarm, but it seems that the handler
6417 isn't always enabled here. This is probably a bug. */
6418 if (input_polling_used ())
6420 /* It could be confusing if a real alarm arrives while processing
6421 the fake one. Turn it off and let the handler reset it. */
6422 int old_poll_suppress_count
= poll_suppress_count
;
6423 poll_suppress_count
= 1;
6424 poll_for_input_1 ();
6425 poll_suppress_count
= old_poll_suppress_count
;
6428 FRAME_SAMPLE_VISIBILITY (f
);
6432 /* Change from mapped state to withdrawn state. */
6434 /* Make the frame visible (mapped and not iconified). */
6436 x_make_frame_invisible (f
)
6439 /* Don't keep the highlight on an invisible frame. */
6440 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6441 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6445 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6447 /* We can't distinguish this from iconification
6448 just by the event that we get from the server.
6449 So we can't win using the usual strategy of letting
6450 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6451 and synchronize with the server to make sure we agree. */
6453 FRAME_ICONIFIED_P (f
) = 0;
6454 f
->async_visible
= 0;
6455 f
->async_iconified
= 0;
6460 /* Change window state from mapped to iconified. */
6468 /* Don't keep the highlight on an invisible frame. */
6469 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6470 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6472 if (f
->async_iconified
)
6477 type
= x_icon_type (f
);
6479 x_bitmap_icon (f
, type
);
6481 /* Simulate the user minimizing the frame. */
6482 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
6488 /* Free X resources of frame F. */
6491 x_free_frame_resources (f
)
6494 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6498 /* We must free faces before destroying windows because some
6499 font-driver (e.g. xft) access a window while finishing a
6501 if (FRAME_FACE_CACHE (f
))
6502 free_frame_faces (f
);
6504 if (FRAME_W32_WINDOW (f
))
6505 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6507 free_frame_menubar (f
);
6509 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
6510 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
6511 unload_color (f
, f
->output_data
.w32
->cursor_pixel
);
6512 unload_color (f
, f
->output_data
.w32
->cursor_foreground_pixel
);
6513 unload_color (f
, f
->output_data
.w32
->border_pixel
);
6514 unload_color (f
, f
->output_data
.w32
->mouse_pixel
);
6515 if (f
->output_data
.w32
->white_relief
.allocated_p
)
6516 unload_color (f
, f
->output_data
.w32
->white_relief
.pixel
);
6517 if (f
->output_data
.w32
->black_relief
.allocated_p
)
6518 unload_color (f
, f
->output_data
.w32
->black_relief
.pixel
);
6520 if (FRAME_FACE_CACHE (f
))
6521 free_frame_faces (f
);
6523 xfree (f
->output_data
.w32
);
6524 f
->output_data
.w32
= NULL
;
6526 if (f
== dpyinfo
->w32_focus_frame
)
6527 dpyinfo
->w32_focus_frame
= 0;
6528 if (f
== dpyinfo
->w32_focus_event_frame
)
6529 dpyinfo
->w32_focus_event_frame
= 0;
6530 if (f
== dpyinfo
->x_highlight_frame
)
6531 dpyinfo
->x_highlight_frame
= 0;
6533 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6535 dpyinfo
->mouse_face_beg_row
6536 = dpyinfo
->mouse_face_beg_col
= -1;
6537 dpyinfo
->mouse_face_end_row
6538 = dpyinfo
->mouse_face_end_col
= -1;
6539 dpyinfo
->mouse_face_window
= Qnil
;
6540 dpyinfo
->mouse_face_deferred_gc
= 0;
6541 dpyinfo
->mouse_face_mouse_frame
= 0;
6548 /* Destroy the window of frame F. */
6550 x_destroy_window (f
)
6553 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6555 x_free_frame_resources (f
);
6556 dpyinfo
->reference_count
--;
6560 /* Setting window manager hints. */
6562 /* Set the normal size hints for the window manager, for frame F.
6563 FLAGS is the flags word to use--or 0 meaning preserve the flags
6564 that the window now has.
6565 If USER_POSITION is nonzero, we set the USPosition
6566 flag (this is useful when FLAGS is 0). */
6568 x_wm_set_size_hint (f
, flags
, user_position
)
6573 Window window
= FRAME_W32_WINDOW (f
);
6577 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6578 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6579 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6580 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
6585 /* Window manager things */
6587 x_wm_set_icon_position (f
, icon_x
, icon_y
)
6592 Window window
= FRAME_W32_WINDOW (f
);
6594 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
6595 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
6596 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
6598 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
6603 /***********************************************************************
6605 ***********************************************************************/
6609 /* The following functions are listed here to help diff stay in step
6610 with xterm.c. See w32fns.c for definitions.
6612 x_get_font_info (f, font_idx)
6613 x_list_fonts (f, pattern, size, maxnames)
6619 /* Check that FONT is valid on frame F. It is if it can be found in F's
6623 x_check_font (f
, font
)
6628 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6630 xassert (font
!= NULL
);
6632 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
6633 if (dpyinfo
->font_table
[i
].name
6634 && font
== dpyinfo
->font_table
[i
].font
)
6637 xassert (i
< dpyinfo
->n_fonts
);
6640 #endif /* GLYPH_DEBUG != 0 */
6642 /* Set *W to the minimum width, *H to the minimum font height of FONT.
6643 Note: There are (broken) X fonts out there with invalid XFontStruct
6644 min_bounds contents. For example, handa@etl.go.jp reports that
6645 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
6646 have font->min_bounds.width == 0. */
6649 x_font_min_bounds (font
, w
, h
)
6654 * TODO: Windows does not appear to offer min bound, only
6655 * average and maximum width, and maximum height.
6657 *h
= FONT_HEIGHT (font
);
6658 *w
= FONT_AVG_WIDTH (font
);
6662 /* Compute the smallest character width and smallest font height over
6663 all fonts available on frame F. Set the members smallest_char_width
6664 and smallest_font_height in F's x_display_info structure to
6665 the values computed. Value is non-zero if smallest_font_height or
6666 smallest_char_width become smaller than they were before. */
6669 x_compute_min_glyph_bounds (f
)
6673 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6675 int old_width
= dpyinfo
->smallest_char_width
;
6676 int old_height
= dpyinfo
->smallest_font_height
;
6678 dpyinfo
->smallest_font_height
= 100000;
6679 dpyinfo
->smallest_char_width
= 100000;
6681 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
6682 if (dpyinfo
->font_table
[i
].name
)
6684 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
6687 font
= (XFontStruct
*) fontp
->font
;
6688 xassert (font
!= (XFontStruct
*) ~0);
6689 x_font_min_bounds (font
, &w
, &h
);
6691 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
6692 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
6695 xassert (dpyinfo
->smallest_char_width
> 0
6696 && dpyinfo
->smallest_font_height
> 0);
6698 return (dpyinfo
->n_fonts
== 1
6699 || dpyinfo
->smallest_char_width
< old_width
6700 || dpyinfo
->smallest_font_height
< old_height
);
6703 /* The following functions are listed here to help diff stay in step
6704 with xterm.c. See w32fns.c for definitions.
6706 x_load_font (f, fontname, size)
6707 x_query_font (f, fontname)
6708 x_find_ccl_program (fontp)
6712 #endif /* OLD_FONT */
6715 /***********************************************************************
6717 ***********************************************************************/
6719 static int w32_initialized
= 0;
6722 w32_initialize_display_info (display_name
)
6723 Lisp_Object display_name
;
6725 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6727 bzero (dpyinfo
, sizeof (*dpyinfo
));
6729 /* Put it on w32_display_name_list. */
6730 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
6731 w32_display_name_list
);
6732 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
6734 dpyinfo
->w32_id_name
6735 = (char *) xmalloc (SCHARS (Vinvocation_name
)
6736 + SCHARS (Vsystem_name
)
6738 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6739 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6741 /* Default Console mode values - overridden when running in GUI mode
6742 with values obtained from system metrics. */
6745 dpyinfo
->height_in
= 1;
6746 dpyinfo
->width_in
= 1;
6747 dpyinfo
->n_planes
= 1;
6748 dpyinfo
->n_cbits
= 4;
6749 dpyinfo
->n_fonts
= 0;
6750 dpyinfo
->smallest_font_height
= 1;
6751 dpyinfo
->smallest_char_width
= 1;
6753 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6754 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6755 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
6756 dpyinfo
->mouse_face_window
= Qnil
;
6757 dpyinfo
->mouse_face_overlay
= Qnil
;
6758 dpyinfo
->mouse_face_hidden
= 0;
6760 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6761 /* TODO: dpyinfo->gray */
6765 /* Create an xrdb-style database of resources to supercede registry settings.
6766 The database is just a concatenation of C strings, finished by an additional
6767 \0. The strings are submitted to some basic normalization, so
6769 [ *]option[ *]:[ *]value...
6775 but any whitespace following value is not removed. */
6778 w32_make_rdb (xrm_option
)
6781 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6782 char *current
= buffer
;
6785 int before_value
= 0;
6799 if (in_option
&& (ch
== ':'))
6804 else if (before_value
)
6809 else if (!(in_option
|| before_value
))
6821 x_flush (struct frame
* f
)
6822 { /* Nothing to do */ }
6825 extern frame_parm_handler w32_frame_parm_handlers
[];
6827 static struct redisplay_interface w32_redisplay_interface
=
6829 w32_frame_parm_handlers
,
6833 x_clear_end_of_line
,
6835 x_after_update_window_line
,
6836 x_update_window_begin
,
6837 x_update_window_end
,
6840 0, /* flush_display_optional */
6841 x_clear_window_mouse_face
,
6842 w32_get_glyph_overhangs
,
6843 x_fix_overlapping_area
,
6844 w32_draw_fringe_bitmap
,
6845 w32_define_fringe_bitmap
,
6846 w32_destroy_fringe_bitmap
,
6848 w32_per_char_metric
,
6851 w32_compute_glyph_string_overhangs
,
6852 x_draw_glyph_string
,
6853 w32_define_frame_cursor
,
6854 w32_clear_frame_area
,
6855 w32_draw_window_cursor
,
6856 w32_draw_vertical_window_border
,
6857 w32_shift_glyphs_for_insert
6860 static void x_delete_terminal (struct terminal
*term
);
6862 static struct terminal
*
6863 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6865 struct terminal
*terminal
;
6867 terminal
= create_terminal ();
6869 terminal
->type
= output_w32
;
6870 terminal
->display_info
.w32
= dpyinfo
;
6871 dpyinfo
->terminal
= terminal
;
6873 /* MSVC does not type K&R functions with no arguments correctly, and
6874 so we must explicitly cast them. */
6875 terminal
->clear_frame_hook
= x_clear_frame
;
6876 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6877 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6878 terminal
->ring_bell_hook
= w32_ring_bell
;
6879 terminal
->reset_terminal_modes_hook
= w32_reset_terminal_modes
;
6880 terminal
->set_terminal_modes_hook
= w32_set_terminal_modes
;
6881 terminal
->update_begin_hook
= x_update_begin
;
6882 terminal
->update_end_hook
= x_update_end
;
6883 terminal
->set_terminal_window_hook
= w32_set_terminal_window
;
6884 terminal
->read_socket_hook
= w32_read_socket
;
6885 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6886 terminal
->mouse_position_hook
= w32_mouse_position
;
6887 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6888 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6889 // terminal->fullscreen_hook = XTfullscreen_hook;
6890 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6891 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6892 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6893 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6895 terminal
->delete_frame_hook
= x_destroy_window
;
6896 terminal
->delete_terminal_hook
= x_delete_terminal
;
6898 terminal
->rif
= &w32_redisplay_interface
;
6899 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
6900 terminal
->char_ins_del_ok
= 1;
6901 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
6902 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
6903 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
6907 /* We don't yet support separate terminals on W32, so don't try to share
6908 keyboards between virtual terminals that are on the same physical
6909 terminal like X does. */
6910 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
6911 init_kboard (terminal
->kboard
);
6912 terminal
->kboard
->Vwindow_system
= intern ("w32");
6913 terminal
->kboard
->next_kboard
= all_kboards
;
6914 all_kboards
= terminal
->kboard
;
6915 /* Don't let the initial kboard remain current longer than necessary.
6916 That would cause problems if a file loaded on startup tries to
6917 prompt in the mini-buffer. */
6918 if (current_kboard
== initial_kboard
)
6919 current_kboard
= terminal
->kboard
;
6920 terminal
->kboard
->reference_count
++;
6927 x_delete_terminal (struct terminal
*terminal
)
6929 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
6932 /* Protect against recursive calls. Fdelete_frame in
6933 delete_terminal calls us back when it deletes our last frame. */
6934 if (!terminal
->name
)
6939 /* Free the fonts in the font table. */
6940 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
6941 if (dpyinfo
->font_table
[i
].name
)
6943 DeleteObject (((XFontStruct
*)(dpyinfo
->font_table
[i
].font
))->hfont
);
6947 x_delete_display (dpyinfo
);
6951 struct w32_display_info
*
6952 w32_term_init (display_name
, xrm_option
, resource_name
)
6953 Lisp_Object display_name
;
6955 char *resource_name
;
6957 struct w32_display_info
*dpyinfo
;
6958 struct terminal
*terminal
;
6963 if (!w32_initialized
)
6966 w32_initialized
= 1;
6969 w32_initialize_display_info (display_name
);
6971 dpyinfo
= &one_w32_display_info
;
6972 terminal
= w32_create_terminal (dpyinfo
);
6974 /* Set the name of the terminal. */
6975 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
6976 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
6977 terminal
->name
[SBYTES (display_name
)] = 0;
6979 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6981 /* Put this display on the chain. */
6982 dpyinfo
->next
= x_display_list
;
6983 x_display_list
= dpyinfo
;
6985 hdc
= GetDC (GetDesktopWindow ());
6987 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
6988 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
6989 dpyinfo
->root_window
= GetDesktopWindow ();
6990 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6991 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6992 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6993 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6994 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6995 dpyinfo
->terminal
->image_cache
= make_image_cache ();
6996 dpyinfo
->height_in
= dpyinfo
->height
/ dpyinfo
->resx
;
6997 dpyinfo
->width_in
= dpyinfo
->width
/ dpyinfo
->resy
;
6998 ReleaseDC (GetDesktopWindow (), hdc
);
7000 /* initialise palette with white and black */
7003 w32_defined_color (0, "white", &color
, 1);
7004 w32_defined_color (0, "black", &color
, 1);
7007 /* Add the default keyboard. */
7008 add_keyboard_wait_descriptor (0);
7010 /* Create Fringe Bitmaps and store them for later use.
7012 On W32, bitmaps are all unsigned short, as Windows requires
7013 bitmap data to be Word aligned. For some reason they are
7014 horizontally reflected compared to how they appear on X, so we
7015 need to bitswap and convert to unsigned shorts before creating
7017 w32_init_fringe (terminal
->rif
);
7020 fcntl (connection
, F_SETOWN
, getpid ());
7021 #endif /* ! defined (F_SETOWN) */
7024 if (interrupt_input
)
7025 init_sigio (connection
);
7026 #endif /* ! defined (SIGIO) */
7033 /* Get rid of display DPYINFO, assuming all frames are already gone. */
7035 x_delete_display (dpyinfo
)
7036 struct w32_display_info
*dpyinfo
;
7038 /* Discard this display from w32_display_name_list and w32_display_list.
7039 We can't use Fdelq because that can quit. */
7040 if (! NILP (w32_display_name_list
)
7041 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
7042 w32_display_name_list
= XCDR (w32_display_name_list
);
7047 tail
= w32_display_name_list
;
7048 while (CONSP (tail
) && CONSP (XCDR (tail
)))
7050 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
7052 XSETCDR (tail
, XCDR (XCDR (tail
)));
7059 /* free palette table */
7061 struct w32_palette_entry
* plist
;
7063 plist
= dpyinfo
->color_list
;
7066 struct w32_palette_entry
* pentry
= plist
;
7067 plist
= plist
->next
;
7070 dpyinfo
->color_list
= NULL
;
7071 if (dpyinfo
->palette
)
7072 DeleteObject(dpyinfo
->palette
);
7075 xfree (dpyinfo
->font_table
);
7077 xfree (dpyinfo
->w32_id_name
);
7079 w32_reset_fringes ();
7082 /* Set up use of W32. */
7084 DWORD WINAPI
w32_msg_worker (void * arg
);
7091 w32_system_caret_hwnd
= NULL
;
7092 w32_system_caret_height
= 0;
7093 w32_system_caret_x
= 0;
7094 w32_system_caret_y
= 0;
7096 /* Initialize w32_use_visible_system_caret based on whether a screen
7097 reader is in use. */
7098 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
7099 &w32_use_visible_system_caret
, 0))
7100 w32_use_visible_system_caret
= 0;
7102 last_tool_bar_item
= -1;
7103 any_help_event_p
= 0;
7105 /* Initialize input mode: interrupt_input off, no flow control, allow
7106 8 bit character input, standard quit char. */
7107 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
7109 /* Create the window thread - it will terminate itself or when the app terminates */
7113 dwMainThreadId
= GetCurrentThreadId ();
7114 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
7115 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
7117 /* Wait for thread to start */
7122 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
7124 hWindowsThread
= CreateThread (NULL
, 0,
7126 0, 0, &dwWindowsThreadId
);
7128 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
7131 /* It is desirable that mainThread should have the same notion of
7132 focus window and active window as windowsThread. Unfortunately, the
7133 following call to AttachThreadInput, which should do precisely what
7134 we need, causes major problems when Emacs is linked as a console
7135 program. Unfortunately, we have good reasons for doing that, so
7136 instead we need to send messages to windowsThread to make some API
7137 calls for us (ones that affect, or depend on, the active/focus
7139 #ifdef ATTACH_THREADS
7140 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
7143 /* Dynamically link to optional system components. */
7145 UINT smoothing_type
;
7146 BOOL smoothing_enabled
;
7148 HANDLE gdi_lib
= LoadLibrary ("gdi32.dll");
7150 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7152 LOAD_PROC (gdi_lib
, GetFontUnicodeRanges
);
7156 FreeLibrary (gdi_lib
);
7158 /* Ensure scrollbar handle is at least 5 pixels. */
7159 vertical_scroll_bar_min_handle
= 5;
7161 /* For either kind of scroll bar, take account of the arrows; these
7162 effectively form the border of the main scroll bar range. */
7163 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
7164 = GetSystemMetrics (SM_CYVSCROLL
);
7166 /* Constants that are not always defined by the system headers
7167 since they only exist on certain versions of Windows. */
7168 #ifndef SPI_GETFONTSMOOTHING
7169 #define SPI_GETFONTSMOOTHING 0x4A
7171 #ifndef SPI_GETFONTSMOOTHINGTYPE
7172 #define SPI_GETFONTSMOOTHINGTYPE 0x0200A
7174 #ifndef FE_FONTSMOOTHINGCLEARTYPE
7175 #define FE_FONTSMOOTHINGCLEARTYPE 0x2
7178 /* Determine if Cleartype is in use. Used to enable a hack in
7179 the char metric calculations which adds extra pixels to
7180 compensate for the "sub-pixels" that are not counted by the
7183 SystemParametersInfo (SPI_GETFONTSMOOTHING
, 0, &smoothing_enabled
, 0)
7184 && smoothing_enabled
7185 && SystemParametersInfo (SPI_GETFONTSMOOTHINGTYPE
, 0, &smoothing_type
, 0)
7186 && smoothing_type
== FE_FONTSMOOTHINGCLEARTYPE
;
7193 staticpro (&w32_display_name_list
);
7194 w32_display_name_list
= Qnil
;
7196 staticpro (&last_mouse_scroll_bar
);
7197 last_mouse_scroll_bar
= Qnil
;
7199 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
7201 DEFVAR_INT ("w32-num-mouse-buttons",
7202 &w32_num_mouse_buttons
,
7203 doc
: /* Number of physical mouse buttons. */);
7204 w32_num_mouse_buttons
= 2;
7206 DEFVAR_LISP ("w32-swap-mouse-buttons",
7207 &Vw32_swap_mouse_buttons
,
7208 doc
: /* Swap the mapping of middle and right mouse buttons.
7209 When nil, middle button is mouse-2 and right button is mouse-3. */);
7210 Vw32_swap_mouse_buttons
= Qnil
;
7212 DEFVAR_LISP ("w32-grab-focus-on-raise",
7213 &Vw32_grab_focus_on_raise
,
7214 doc
: /* Raised frame grabs input focus.
7215 When t, `raise-frame' grabs input focus as well. This fits well
7216 with the normal Windows click-to-focus policy, but might not be
7217 desirable when using a point-to-focus policy. */);
7218 Vw32_grab_focus_on_raise
= Qt
;
7220 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7221 &Vw32_capslock_is_shiftlock
,
7222 doc
: /* Apply CapsLock state to non character input keys.
7223 When nil, CapsLock only affects normal character input keys. */);
7224 Vw32_capslock_is_shiftlock
= Qnil
;
7226 DEFVAR_LISP ("w32-recognize-altgr",
7227 &Vw32_recognize_altgr
,
7228 doc
: /* Recognize right-alt and left-ctrl as AltGr.
7229 When nil, the right-alt and left-ctrl key combination is
7230 interpreted normally. */);
7231 Vw32_recognize_altgr
= Qt
;
7233 DEFVAR_BOOL ("w32-enable-unicode-output",
7234 &w32_enable_unicode_output
,
7235 doc
: /* Enable the use of Unicode for text output if non-nil.
7236 Unicode output may prevent some third party applications for displaying
7237 Far-East Languages on Windows 95/98 from working properly.
7238 NT uses Unicode internally anyway, so this flag will probably have no
7239 effect on NT machines. */);
7240 w32_enable_unicode_output
= 1;
7242 DEFVAR_BOOL ("w32-use-visible-system-caret",
7243 &w32_use_visible_system_caret
,
7244 doc
: /* Flag to make the system caret visible.
7245 When this is non-nil, Emacs will indicate the position of point by
7246 using the system caret instead of drawing its own cursor. Some screen
7247 reader software does not track the system cursor properly when it is
7248 invisible, and gets confused by Emacs drawing its own cursor, so this
7249 variable is initialized to t when Emacs detects that screen reader
7250 software is running as it starts up.
7252 When this variable is set, other variables affecting the appearance of
7253 the cursor have no effect. */);
7255 w32_use_visible_system_caret
= 0;
7257 /* We don't yet support this, but defining this here avoids whining
7258 from cus-start.el and other places, like "M-x set-variable". */
7259 DEFVAR_BOOL ("x-use-underline-position-properties",
7260 &x_use_underline_position_properties
,
7261 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
7262 A value of nil means ignore them. If you encounter fonts with bogus
7263 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7264 to 4.1, set this to nil.
7266 NOTE: Not supported on MS-Windows yet. */);
7267 x_use_underline_position_properties
= 0;
7269 DEFVAR_BOOL ("x-underline-at-descent-line",
7270 &x_underline_at_descent_line
,
7271 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
7272 A value of nil means to draw the underline according to the value of the
7273 variable `x-use-underline-position-properties', which is usually at the
7274 baseline level. The default value is nil. */);
7275 x_underline_at_descent_line
= 0;
7277 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
7278 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
7279 Vx_toolkit_scroll_bars
= Qt
;
7281 staticpro (&last_mouse_motion_frame
);
7282 last_mouse_motion_frame
= Qnil
;
7285 /* arch-tag: 5fa70624-ab86-499c-8a85-473958ee4646
7286 (do not change this comment) */