1 /* Implementation of GUI terminal on the Microsoft W32 API.
2 Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
28 #include "blockinput.h"
47 #include "dispextern.h"
49 #include "termhooks.h"
56 #include "intervals.h"
57 #include "composite.h"
60 #define abs(x) ((x) < 0 ? -(x) : (x))
62 #define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
67 enum fringe_bitmap_type
70 LEFT_TRUNCATION_BITMAP
,
71 RIGHT_TRUNCATION_BITMAP
,
73 CONTINUED_LINE_BITMAP
,
74 CONTINUATION_LINE_BITMAP
,
78 /* Bitmaps are all unsigned short, as Windows requires bitmap data to
79 be Word aligned. For some reason they are horizontally reflected
80 compared to how they appear on X, so changes in xterm.c should be
83 /* Bitmap drawn to indicate lines not displaying text if
84 `indicate-empty-lines' is non-nil. */
89 static unsigned short zv_bits
[] = {
90 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
91 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
92 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
93 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
94 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
95 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
96 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
97 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00};
98 static HBITMAP zv_bmp
;
100 /* An arrow like this: `<-'. */
103 #define left_height 8
104 static unsigned short left_bits
[] = {
105 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
106 static HBITMAP left_bmp
;
108 /* Right truncation arrow bitmap `->'. */
110 #define right_width 8
111 #define right_height 8
112 static unsigned short right_bits
[] = {
113 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
114 static HBITMAP right_bmp
;
116 /* Marker for continued lines. */
118 #define continued_width 8
119 #define continued_height 8
120 static unsigned short continued_bits
[] = {
121 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
122 static HBITMAP continued_bmp
;
124 /* Marker for continuation lines. */
126 #define continuation_width 8
127 #define continuation_height 8
128 static unsigned short continuation_bits
[] = {
129 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
130 static HBITMAP continuation_bmp
;
132 /* Overlay arrow bitmap. */
138 static unsigned short ov_bits
[] = {
139 0x0c, 0x10, 0x3c, 0x7e, 0x5e, 0x5e, 0x46, 0x3c};
141 /* A triangular arrow. */
144 static unsigned short ov_bits
[] = {
145 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
147 static HBITMAP ov_bmp
;
149 extern Lisp_Object Qhelp_echo
;
152 /* Non-nil means Emacs uses toolkit scroll bars. */
154 Lisp_Object Vx_toolkit_scroll_bars
;
156 /* If a string, w32_read_socket generates an event to display that string.
157 (The display is done in read_char.) */
159 static Lisp_Object help_echo
;
160 static Lisp_Object help_echo_window
;
161 static Lisp_Object help_echo_object
;
162 static int help_echo_pos
;
164 /* Temporary variables for w32_read_socket. */
166 static Lisp_Object previous_help_echo
;
167 static int last_mousemove_x
= 0;
168 static int last_mousemove_y
= 0;
170 /* Non-zero means that a HELP_EVENT has been generated since Emacs
173 static int any_help_event_p
;
175 /* Non-zero means autoselect window with the mouse cursor. */
177 int mouse_autoselect_window
;
179 /* Non-zero means draw block and hollow cursor as wide as the glyph
180 under it. For example, if a block cursor is over a tab, it will be
181 drawn as wide as that tab on the display. */
183 int x_stretch_cursor_p
;
185 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
187 int x_use_underline_position_properties
;
189 extern unsigned int msh_mousewheel
;
191 extern void free_frame_menubar ();
193 extern int w32_codepage_for_font (char *fontname
);
195 extern glyph_metric
*w32_BDF_TextMetric(bdffont
*fontp
,
196 unsigned char *text
, int dim
);
197 extern Lisp_Object Vwindow_system
;
199 #define x_any_window_to_frame x_window_to_frame
200 #define x_top_window_to_frame x_window_to_frame
203 /* This is display since w32 does not support multiple ones. */
204 struct w32_display_info one_w32_display_info
;
205 struct w32_display_info
*x_display_list
;
207 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
208 one for each element of w32_display_list and in the same order.
209 NAME is the name of the frame.
210 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
211 Lisp_Object w32_display_name_list
;
213 /* Frame being updated by update_frame. This is declared in term.c.
214 This is set by update_begin and looked at by all the
215 w32 functions. It is zero while not inside an update.
216 In that case, the w32 functions assume that `SELECTED_FRAME ()'
217 is the frame to apply to. */
218 extern struct frame
*updating_frame
;
220 /* This is a frame waiting to be autoraised, within w32_read_socket. */
221 struct frame
*pending_autoraise_frame
;
223 /* Nominal cursor position -- where to draw output.
224 HPOS and VPOS are window relative glyph matrix coordinates.
225 X and Y are window relative pixel coordinates. */
227 struct cursor_pos output_cursor
;
229 /* The handle of the frame that currently owns the system caret. */
230 HWND w32_system_caret_hwnd
;
231 int w32_system_caret_height
;
232 int w32_system_caret_x
;
233 int w32_system_caret_y
;
234 int w32_use_visible_system_caret
;
236 /* Flag to enable Unicode output in case users wish to use programs
237 like Twinbridge on '95 rather than installed system level support
238 for Far East languages. */
239 int w32_enable_unicode_output
;
241 DWORD dwWindowsThreadId
= 0;
242 HANDLE hWindowsThread
= NULL
;
243 DWORD dwMainThreadId
= 0;
244 HANDLE hMainThread
= NULL
;
247 /* These definitions are new with Windows 95. */
248 #define SIF_RANGE 0x0001
249 #define SIF_PAGE 0x0002
250 #define SIF_POS 0x0004
251 #define SIF_DISABLENOSCROLL 0x0008
252 #define SIF_TRACKPOS 0x0010
253 #define SIF_ALL (SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS)
255 typedef struct tagSCROLLINFO
264 } SCROLLINFO
, FAR
*LPSCROLLINFO
;
265 typedef SCROLLINFO CONST FAR
*LPCSCROLLINFO
;
268 /* Dynamic linking to new proportional scroll bar functions. */
269 int (PASCAL
*pfnSetScrollInfo
) (HWND hwnd
, int fnBar
, LPSCROLLINFO lpsi
, BOOL fRedraw
);
270 BOOL (PASCAL
*pfnGetScrollInfo
) (HWND hwnd
, int fnBar
, LPSCROLLINFO lpsi
);
272 int vertical_scroll_bar_min_handle
;
273 int vertical_scroll_bar_top_border
;
274 int vertical_scroll_bar_bottom_border
;
276 int last_scroll_bar_drag_pos
;
278 /* Mouse movement. */
280 /* Where the mouse was last time we reported a mouse event. */
282 FRAME_PTR last_mouse_frame
;
283 static RECT last_mouse_glyph
;
284 static Lisp_Object last_mouse_press_frame
;
286 Lisp_Object Vw32_num_mouse_buttons
;
288 Lisp_Object Vw32_swap_mouse_buttons
;
290 /* Control whether x_raise_frame also sets input focus. */
291 Lisp_Object Vw32_grab_focus_on_raise
;
293 /* Control whether Caps Lock affects non-ascii characters. */
294 Lisp_Object Vw32_capslock_is_shiftlock
;
296 /* Control whether right-alt and left-ctrl should be recognized as AltGr. */
297 Lisp_Object Vw32_recognize_altgr
;
299 /* The scroll bar in which the last motion event occurred.
301 If the last motion event occurred in a scroll bar, we set this
302 so w32_mouse_position can know whether to report a scroll bar motion or
305 If the last motion event didn't occur in a scroll bar, we set this
306 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
307 static Lisp_Object last_mouse_scroll_bar
;
308 static int last_mouse_scroll_bar_pos
;
310 /* This is a hack. We would really prefer that w32_mouse_position would
311 return the time associated with the position it returns, but there
312 doesn't seem to be any way to wrest the time-stamp from the server
313 along with the position query. So, we just keep track of the time
314 of the last movement we received, and return that in hopes that
315 it's somewhat accurate. */
317 static Time last_mouse_movement_time
;
319 /* Incremented by w32_read_socket whenever it really tries to read
323 static int volatile input_signal_count
;
325 static int input_signal_count
;
328 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
330 extern Lisp_Object Qface
, Qmouse_face
;
336 /* A mask of extra modifier bits to put into every keyboard char. */
338 extern EMACS_INT extra_keyboard_modifiers
;
340 /* Enumeration for overriding/changing the face to use for drawing
341 glyphs in x_draw_glyphs. */
343 enum draw_glyphs_face
353 static void x_update_window_end
P_ ((struct window
*, int, int));
354 static void frame_to_window_pixel_xy
P_ ((struct window
*, int *, int *));
355 void w32_delete_display
P_ ((struct w32_display_info
*));
356 static int fast_find_position
P_ ((struct window
*, int, int *, int *,
357 int *, int *, Lisp_Object
));
358 static int fast_find_string_pos
P_ ((struct window
*, int, Lisp_Object
,
359 int *, int *, int *, int *, int));
360 static void set_output_cursor
P_ ((struct cursor_pos
*));
361 static struct glyph
*x_y_to_hpos_vpos
P_ ((struct window
*, int, int,
362 int *, int *, int *, int));
363 static void note_mode_line_highlight
P_ ((struct window
*, int, int));
364 static void note_mouse_highlight
P_ ((struct frame
*, int, int));
365 static void note_tool_bar_highlight
P_ ((struct frame
*f
, int, int));
366 static void w32_handle_tool_bar_click
P_ ((struct frame
*,
367 struct input_event
*));
368 static void show_mouse_face
P_ ((struct w32_display_info
*,
369 enum draw_glyphs_face
));
370 static int cursor_in_mouse_face_p
P_ ((struct window
*));
371 static int clear_mouse_face
P_ ((struct w32_display_info
*));
373 void x_lower_frame
P_ ((struct frame
*));
374 void x_scroll_bar_clear
P_ ((struct frame
*));
375 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
376 void x_raise_frame
P_ ((struct frame
*));
377 void x_set_window_size
P_ ((struct frame
*, int, int, int));
378 void x_wm_set_window_state
P_ ((struct frame
*, int));
379 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
380 void w32_initialize
P_ ((void));
381 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
382 int x_compute_min_glyph_bounds
P_ ((struct frame
*));
383 static void x_draw_phys_cursor_glyph
P_ ((struct window
*,
385 enum draw_glyphs_face
));
386 static void x_update_end
P_ ((struct frame
*));
387 static void w32_frame_up_to_date
P_ ((struct frame
*));
388 static void w32_set_terminal_modes
P_ ((void));
389 static void w32_reset_terminal_modes
P_ ((void));
390 static void w32_cursor_to
P_ ((int, int, int, int));
391 static void x_write_glyphs
P_ ((struct glyph
*, int));
392 static void x_clear_end_of_line
P_ ((int));
393 static void x_clear_frame
P_ ((void));
394 static void x_clear_cursor
P_ ((struct window
*));
395 static void frame_highlight
P_ ((struct frame
*));
396 static void frame_unhighlight
P_ ((struct frame
*));
397 static void x_new_focus_frame
P_ ((struct w32_display_info
*,
399 static void w32_frame_rehighlight
P_ ((struct frame
*));
400 static void x_frame_rehighlight
P_ ((struct w32_display_info
*));
401 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
402 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
403 enum text_cursor_kinds
));
404 static void expose_frame
P_ ((struct frame
*, int, int, int, int));
405 static int expose_window_tree
P_ ((struct window
*, RECT
*));
406 static void expose_overlaps
P_ ((struct window
*, struct glyph_row
*,
407 struct glyph_row
*));
408 static int expose_window
P_ ((struct window
*, RECT
*));
409 static void expose_area
P_ ((struct window
*, struct glyph_row
*,
410 RECT
*, enum glyph_row_area
));
411 static int expose_line
P_ ((struct window
*, struct glyph_row
*,
413 void x_update_cursor
P_ ((struct frame
*, int));
414 static void x_update_cursor_in_window_tree
P_ ((struct window
*, int));
415 static void x_update_window_cursor
P_ ((struct window
*, int));
416 static void x_erase_phys_cursor
P_ ((struct window
*));
417 void x_display_cursor
P_ ((struct window
*w
, int, int, int, int, int));
418 void x_display_and_set_cursor
P_ ((struct window
*, int, int, int, int, int));
419 static void w32_draw_fringe_bitmap
P_ ((struct window
*, HDC hdc
,
421 enum fringe_bitmap_type
, int left_p
));
422 static void w32_clip_to_row
P_ ((struct window
*, struct glyph_row
*,
424 static int x_phys_cursor_in_rect_p
P_ ((struct window
*, RECT
*));
425 static void x_draw_row_fringe_bitmaps
P_ ((struct window
*,
426 struct glyph_row
*));
427 static void notice_overwritten_cursor
P_ ((struct window
*,
429 int, int, int, int));
431 static Lisp_Object Qvendor_specific_keysyms
;
434 /***********************************************************************
436 ***********************************************************************/
440 /* This is a function useful for recording debugging information about
441 the sequence of occurrences in this file. */
449 struct record event_record
[100];
451 int event_record_index
;
453 record_event (locus
, type
)
457 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
458 event_record_index
= 0;
460 event_record
[event_record_index
].locus
= locus
;
461 event_record
[event_record_index
].type
= type
;
462 event_record_index
++;
468 void XChangeGC (void * ignore
, XGCValues
* gc
, unsigned long mask
,
471 if (mask
& GCForeground
)
472 gc
->foreground
= xgcv
->foreground
;
473 if (mask
& GCBackground
)
474 gc
->background
= xgcv
->background
;
476 gc
->font
= xgcv
->font
;
479 XGCValues
*XCreateGC (void * ignore
, Window window
, unsigned long mask
,
482 XGCValues
*gc
= (XGCValues
*) xmalloc (sizeof (XGCValues
));
483 bzero (gc
, sizeof (XGCValues
));
485 XChangeGC (ignore
, gc
, mask
, xgcv
);
490 void XGetGCValues (void* ignore
, XGCValues
*gc
,
491 unsigned long mask
, XGCValues
*xgcv
)
493 XChangeGC (ignore
, xgcv
, mask
, gc
);
497 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
501 HRGN clip_region
= CreateRectRgnIndirect (rect
);
502 SelectClipRgn (hdc
, clip_region
);
503 DeleteObject (clip_region
);
506 SelectClipRgn (hdc
, NULL
);
510 /* Draw a hollow rectangle at the specified position. */
512 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
513 int width
, int height
)
518 hb
= CreateSolidBrush (gc
->background
);
519 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
520 oldhb
= SelectObject (hdc
, hb
);
521 oldhp
= SelectObject (hdc
, hp
);
523 Rectangle (hdc
, x
, y
, x
+ width
, y
+ height
);
525 SelectObject (hdc
, oldhb
);
526 SelectObject (hdc
, oldhp
);
531 /* Draw a filled rectangle at the specified position. */
533 w32_fill_rect (f
, hdc
, pix
, lprect
)
541 hb
= CreateSolidBrush (pix
);
542 FillRect (hdc
, lprect
, hb
);
551 HDC hdc
= get_frame_dc (f
);
553 /* Under certain conditions, this can be called at startup with
554 a console frame pointer before the GUI frame is created. An HDC
555 of 0 indicates this. */
558 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
559 w32_clear_rect (f
, hdc
, &rect
);
562 release_frame_dc (f
, hdc
);
566 /***********************************************************************
567 Starting and ending an update
568 ***********************************************************************/
570 /* Start an update of frame F. This function is installed as a hook
571 for update_begin, i.e. it is called when update_begin is called.
572 This function is called prior to calls to x_update_window_begin for
573 each window being updated. */
579 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
581 if (! FRAME_W32_P (f
))
584 /* Regenerate display palette before drawing if list of requested
585 colors has changed. */
586 if (display_info
->regen_palette
)
588 w32_regenerate_palette (f
);
589 display_info
->regen_palette
= FALSE
;
594 /* Start update of window W. Set the global variable updated_window
595 to the window being updated and set output_cursor to the cursor
599 x_update_window_begin (w
)
602 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
603 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
605 /* Hide the system caret during an update. */
606 if (w32_use_visible_system_caret
)
607 SendMessage (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0);
610 set_output_cursor (&w
->cursor
);
614 if (f
== display_info
->mouse_face_mouse_frame
)
616 /* Don't do highlighting for mouse motion during the update. */
617 display_info
->mouse_face_defer
= 1;
619 /* If F needs to be redrawn, simply forget about any prior mouse
621 if (FRAME_GARBAGED_P (f
))
622 display_info
->mouse_face_window
= Qnil
;
624 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
625 their mouse_face_p flag set, which means that they are always
626 unequal to rows in a desired matrix which never have that
627 flag set. So, rows containing mouse-face glyphs are never
628 scrolled, and we don't have to switch the mouse highlight off
629 here to prevent it from being scrolled. */
631 /* Can we tell that this update does not affect the window
632 where the mouse highlight is? If so, no need to turn off.
633 Likewise, don't do anything if the frame is garbaged;
634 in that case, the frame's current matrix that we would use
635 is all wrong, and we will redisplay that line anyway. */
636 if (!NILP (display_info
->mouse_face_window
)
637 && w
== XWINDOW (display_info
->mouse_face_window
))
641 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
642 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
645 if (i
< w
->desired_matrix
->nrows
)
646 clear_mouse_face (display_info
);
655 /* Draw a vertical window border to the right of window W if W doesn't
656 have vertical scroll bars. */
659 x_draw_vertical_border (w
)
662 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
664 /* Redraw borders between horizontally adjacent windows. Don't
665 do it for frames with vertical scroll bars because either the
666 right scroll bar of a window, or the left scroll bar of its
667 neighbor will suffice as a border. */
668 if (!WINDOW_RIGHTMOST_P (w
)
669 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
674 window_box_edges (w
, -1, (int *) &r
.left
, (int *) &r
.top
,
675 (int *) &r
.right
, (int *) &r
.bottom
);
676 r
.left
= r
.right
+ FRAME_X_RIGHT_FRINGE_WIDTH (f
);
677 r
.right
= r
.left
+ 1;
680 hdc
= get_frame_dc (f
);
681 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
682 release_frame_dc (f
, hdc
);
687 /* End update of window W (which is equal to updated_window).
689 Draw vertical borders between horizontally adjacent windows, and
690 display W's cursor if CURSOR_ON_P is non-zero.
692 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
693 glyphs in mouse-face were overwritten. In that case we have to
694 make sure that the mouse-highlight is properly redrawn.
696 W may be a menu bar pseudo-window in case we don't have X toolkit
697 support. Such windows don't have a cursor, so don't display it
701 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
703 int cursor_on_p
, mouse_face_overwritten_p
;
705 struct w32_display_info
*dpyinfo
706 = FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
708 if (!w
->pseudo_window_p
)
713 x_display_and_set_cursor (w
, 1, output_cursor
.hpos
,
715 output_cursor
.x
, output_cursor
.y
);
717 x_draw_vertical_border (w
);
721 /* If a row with mouse-face was overwritten, arrange for
722 XTframe_up_to_date to redisplay the mouse highlight. */
723 if (mouse_face_overwritten_p
)
725 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
726 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
727 dpyinfo
->mouse_face_window
= Qnil
;
730 /* Unhide the caret. This won't actually show the cursor, unless it
731 was visible before the corresponding call to HideCaret in
732 x_update_window_begin. */
733 if (w32_use_visible_system_caret
)
734 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
736 updated_window
= NULL
;
740 /* End update of frame F. This function is installed as a hook in
747 if (! FRAME_W32_P (f
))
750 /* Mouse highlight may be displayed again. */
751 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
755 /* This function is called from various places in xdisp.c whenever a
756 complete update has been performed. The global variable
757 updated_window is not available here. */
760 w32_frame_up_to_date (f
)
765 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
766 if (dpyinfo
->mouse_face_deferred_gc
767 || f
== dpyinfo
->mouse_face_mouse_frame
)
770 if (dpyinfo
->mouse_face_mouse_frame
)
771 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
772 dpyinfo
->mouse_face_mouse_x
,
773 dpyinfo
->mouse_face_mouse_y
);
774 dpyinfo
->mouse_face_deferred_gc
= 0;
781 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
782 arrow bitmaps, or clear the fringes if no bitmaps are required
783 before DESIRED_ROW is made current. The window being updated is
784 found in updated_window. This function is called from
785 update_window_line only if it is known that there are differences
786 between bitmaps to be drawn between current row and DESIRED_ROW. */
789 x_after_update_window_line (desired_row
)
790 struct glyph_row
*desired_row
;
792 struct window
*w
= updated_window
;
798 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
801 x_draw_row_fringe_bitmaps (w
, desired_row
);
805 /* When a window has disappeared, make sure that no rest of
806 full-width rows stays visible in the internal border. Could
807 check here if updated_window is the leftmost/rightmost window,
808 but I guess it's not worth doing since vertically split windows
809 are almost never used, internal border is rarely set, and the
810 overhead is very small. */
811 if (windows_or_buffers_changed
812 && desired_row
->full_width_p
813 && (f
= XFRAME (w
->frame
),
814 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
816 && (height
= desired_row
->visible_height
,
819 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
820 /* Internal border is drawn below the tool bar. */
821 if (WINDOWP (f
->tool_bar_window
)
822 && w
== XWINDOW (f
->tool_bar_window
))
827 HDC hdc
= get_frame_dc (f
);
828 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
829 w32_clear_area (f
, hdc
, f
->output_data
.w32
->pixel_width
- width
,
831 release_frame_dc (f
, hdc
);
838 /* Draw the bitmap WHICH in one of the left or right fringes of
839 window W. ROW is the glyph row for which to display the bitmap; it
840 determines the vertical position at which the bitmap has to be
844 w32_draw_fringe_bitmap (w
, hdc
, row
, which
, left_p
)
847 struct glyph_row
*row
;
848 enum fringe_bitmap_type which
;
851 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
859 /* Must clip because of partially visible lines. */
860 w32_clip_to_row (w
, row
, hdc
, 1);
862 /* Convert row to frame coordinates. */
863 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
867 case NO_FRINGE_BITMAP
:
872 case LEFT_TRUNCATION_BITMAP
:
878 case OVERLAY_ARROW_BITMAP
:
884 case RIGHT_TRUNCATION_BITMAP
:
890 case CONTINUED_LINE_BITMAP
:
891 wd
= continued_width
;
892 h
= continued_height
;
893 pixmap
= continued_bmp
;
896 case CONTINUATION_LINE_BITMAP
:
897 wd
= continuation_width
;
898 h
= continuation_height
;
899 pixmap
= continuation_bmp
;
904 h
= zv_height
- (y
% zv_period
);
912 /* Clip bitmap if too high. */
916 /* Set dy to the offset in the row to start drawing the bitmap. */
917 dy
= (row
->height
- h
) / 2;
919 /* Draw the bitmap. */
920 face
= FACE_FROM_ID (f
, FRINGE_FACE_ID
);
921 PREPARE_FACE_FOR_DISPLAY (f
, face
);
923 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
928 if (wd
> FRAME_X_LEFT_FRINGE_WIDTH (f
))
929 wd
= FRAME_X_LEFT_FRINGE_WIDTH (f
);
930 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
932 - (FRAME_X_LEFT_FRINGE_WIDTH (f
) - wd
) / 2);
933 if (wd
< FRAME_X_LEFT_FRINGE_WIDTH (f
) || row
->height
> h
)
935 /* If W has a vertical border to its left, don't draw over it. */
936 int border
= ((XFASTINT (w
->left
) > 0
937 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
939 b1
= (window_box_left (w
, -1)
940 - FRAME_X_LEFT_FRINGE_WIDTH (f
)
942 b2
= (FRAME_X_LEFT_FRINGE_WIDTH (f
) - border
);
947 if (wd
> FRAME_X_RIGHT_FRINGE_WIDTH (f
))
948 wd
= FRAME_X_RIGHT_FRINGE_WIDTH (f
);
949 x
= (window_box_right (w
, -1)
950 + (FRAME_X_RIGHT_FRINGE_WIDTH (f
) - wd
) / 2);
951 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
953 if (wd
< FRAME_X_RIGHT_FRINGE_WIDTH (f
) || row
->height
> h
)
955 b1
= window_box_right (w
, -1);
956 b2
= FRAME_X_RIGHT_FRINGE_WIDTH (f
);
962 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
964 w32_fill_area (f
, hdc
, face
->background
,
966 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
969 row
->visible_height
);
972 if (which
== NO_FRINGE_BITMAP
)
975 compat_hdc
= CreateCompatibleDC (hdc
);
978 horig_obj
= SelectObject (compat_hdc
, pixmap
);
979 SetTextColor (hdc
, face
->background
);
980 SetBkColor (hdc
, face
->foreground
);
982 BitBlt (hdc
, x
, y
+ dy
, wd
, h
, compat_hdc
, 0,
983 (which
== ZV_LINE_BITMAP
? (row
->y
% zv_period
) : 0),
986 SelectObject (compat_hdc
, horig_obj
);
987 DeleteDC (compat_hdc
);
992 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
993 function with input blocked. */
996 x_draw_row_fringe_bitmaps (w
, row
)
998 struct glyph_row
*row
;
1000 struct frame
*f
= XFRAME (w
->frame
);
1001 enum fringe_bitmap_type bitmap
;
1004 xassert (interrupt_input_blocked
);
1006 /* If row is completely invisible, because of vscrolling, we
1007 don't have to draw anything. */
1008 if (row
->visible_height
<= 0)
1011 hdc
= get_frame_dc (f
);
1013 if (FRAME_X_LEFT_FRINGE_WIDTH (f
) != 0)
1015 /* Decide which bitmap to draw in the left fringe. */
1016 if (row
->overlay_arrow_p
)
1017 bitmap
= OVERLAY_ARROW_BITMAP
;
1018 else if (row
->truncated_on_left_p
)
1019 bitmap
= LEFT_TRUNCATION_BITMAP
;
1020 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
1021 bitmap
= CONTINUATION_LINE_BITMAP
;
1022 else if (row
->indicate_empty_line_p
)
1023 bitmap
= ZV_LINE_BITMAP
;
1025 bitmap
= NO_FRINGE_BITMAP
;
1027 w32_draw_fringe_bitmap (w
, hdc
, row
, bitmap
, 1);
1030 if (FRAME_X_RIGHT_FRINGE_WIDTH (f
) != 0)
1032 /* Decide which bitmap to draw in the right fringe. */
1033 if (row
->truncated_on_right_p
)
1034 bitmap
= RIGHT_TRUNCATION_BITMAP
;
1035 else if (row
->continued_p
)
1036 bitmap
= CONTINUED_LINE_BITMAP
;
1037 else if (row
->indicate_empty_line_p
&& FRAME_X_LEFT_FRINGE_WIDTH (f
) == 0)
1038 bitmap
= ZV_LINE_BITMAP
;
1040 bitmap
= NO_FRINGE_BITMAP
;
1042 w32_draw_fringe_bitmap (w
, hdc
, row
, bitmap
, 0);
1045 release_frame_dc (f
, hdc
);
1049 /* This is called when starting Emacs and when restarting after
1050 suspend. When starting Emacs, no window is mapped. And nothing
1051 must be done to Emacs's own window if it is suspended (though that
1055 w32_set_terminal_modes (void)
1059 /* This is called when exiting or suspending Emacs. Exiting will make
1060 the W32 windows go away, and suspending requires no action. */
1063 w32_reset_terminal_modes (void)
1069 /***********************************************************************
1071 ***********************************************************************/
1073 /* Set the global variable output_cursor to CURSOR. All cursor
1074 positions are relative to updated_window. */
1077 set_output_cursor (cursor
)
1078 struct cursor_pos
*cursor
;
1080 output_cursor
.hpos
= cursor
->hpos
;
1081 output_cursor
.vpos
= cursor
->vpos
;
1082 output_cursor
.x
= cursor
->x
;
1083 output_cursor
.y
= cursor
->y
;
1087 /* Set a nominal cursor position.
1089 HPOS and VPOS are column/row positions in a window glyph matrix. X
1090 and Y are window text area relative pixel positions.
1092 If this is done during an update, updated_window will contain the
1093 window that is being updated and the position is the future output
1094 cursor position for that window. If updated_window is null, use
1095 selected_window and display the cursor at the given position. */
1098 w32_cursor_to (vpos
, hpos
, y
, x
)
1099 int vpos
, hpos
, y
, x
;
1103 /* If updated_window is not set, work on selected_window. */
1107 w
= XWINDOW (selected_window
);
1109 /* Set the output cursor. */
1110 output_cursor
.hpos
= hpos
;
1111 output_cursor
.vpos
= vpos
;
1112 output_cursor
.x
= x
;
1113 output_cursor
.y
= y
;
1115 /* If not called as part of an update, really display the cursor.
1116 This will also set the cursor position of W. */
1117 if (updated_window
== NULL
)
1120 x_display_cursor (w
, 1, hpos
, vpos
, x
, y
);
1127 /***********************************************************************
1129 ***********************************************************************/
1131 /* Function prototypes of this page. */
1133 static struct face
*x_get_glyph_face_and_encoding
P_ ((struct frame
*,
1137 static struct face
*x_get_char_face_and_encoding
P_ ((struct frame
*, int,
1138 int, wchar_t *, int));
1139 static XCharStruct
*w32_per_char_metric
P_ ((XFontStruct
*,
1141 enum w32_char_font_type
));
1142 static enum w32_char_font_type
1143 w32_encode_char
P_ ((int, wchar_t *, struct font_info
*, int *));
1144 static void x_append_glyph
P_ ((struct it
*));
1145 static void x_append_composite_glyph
P_ ((struct it
*));
1146 static void x_append_stretch_glyph
P_ ((struct it
*it
, Lisp_Object
,
1148 static void x_produce_glyphs
P_ ((struct it
*));
1149 static void x_produce_image_glyph
P_ ((struct it
*it
));
1152 /* Dealing with bits of wchar_t as if they were an XChar2B. */
1153 #define BUILD_WCHAR_T(byte1, byte2) \
1154 ((wchar_t)((((byte1) & 0x00ff) << 8) | ((byte2) & 0x00ff)))
1158 (((ch) & 0xff00) >> 8)
1164 /* Get metrics of character CHAR2B in FONT. Value is always non-null.
1165 If CHAR2B is not contained in FONT, the font's default character
1166 metric is returned. */
1169 w32_bdf_per_char_metric (font
, char2b
, dim
, pcm
)
1175 glyph_metric
* bdf_metric
;
1179 buf
[0] = (char)(*char2b
);
1182 buf
[0] = BYTE1 (*char2b
);
1183 buf
[1] = BYTE2 (*char2b
);
1186 bdf_metric
= w32_BDF_TextMetric (font
->bdf
, buf
, dim
);
1190 pcm
->width
= bdf_metric
->dwidth
;
1191 pcm
->lbearing
= bdf_metric
->bbox
;
1192 pcm
->rbearing
= bdf_metric
->dwidth
1193 - (bdf_metric
->bbox
+ bdf_metric
->bbw
);
1194 pcm
->ascent
= bdf_metric
->bboy
+ bdf_metric
->bbh
;
1195 pcm
->descent
= -bdf_metric
->bboy
;
1204 w32_native_per_char_metric (font
, char2b
, font_type
, pcm
)
1207 enum w32_char_font_type font_type
;
1210 HDC hdc
= GetDC (NULL
);
1212 BOOL retval
= FALSE
;
1214 xassert (font
&& char2b
);
1215 xassert (font
->hfont
);
1216 xassert (font_type
== UNICODE_FONT
|| font_type
== ANSI_FONT
);
1218 old_font
= SelectObject (hdc
, font
->hfont
);
1220 if ((font
->tm
.tmPitchAndFamily
& TMPF_TRUETYPE
) != 0)
1224 if (font_type
== UNICODE_FONT
)
1225 retval
= GetCharABCWidthsW (hdc
, *char2b
, *char2b
, &char_widths
);
1227 retval
= GetCharABCWidthsA (hdc
, *char2b
, *char2b
, &char_widths
);
1232 /* Disabled until we can find a way to get the right results
1233 on all versions of Windows. */
1235 /* Don't trust the ABC widths. For synthesized fonts they are
1236 wrong, and so is the result of GetCharWidth()! */
1238 GetCharWidth (hdc
, *char2b
, *char2b
, &real_width
);
1240 pcm
->width
= char_widths
.abcA
+ char_widths
.abcB
+ char_widths
.abcC
;
1242 /* As far as I can tell, this is the best way to determine what
1243 ExtTextOut will do with the broken font. */
1244 if (pcm
->width
!= real_width
)
1245 pcm
->width
= (pcm
->width
+ real_width
) / 2;
1247 pcm
->lbearing
= char_widths
.abcA
;
1248 pcm
->rbearing
= char_widths
.abcA
+ char_widths
.abcB
;
1249 pcm
->ascent
= FONT_BASE (font
);
1250 pcm
->descent
= FONT_DESCENT (font
);
1256 /* Either font is not a True-type font, or GetCharABCWidthsW
1257 failed (it is not supported on Windows 9x for instance), so we
1258 can't determine the full info we would like. All is not lost
1259 though - we can call GetTextExtentPoint32 to get rbearing and
1260 deduce width based on the font's per-string overhang. lbearing
1261 is assumed to be zero. */
1263 /* TODO: Some Thai characters (and other composites if Windows
1264 supports them) do have lbearing, and report their total width
1265 as zero. Need some way of handling them when
1266 GetCharABCWidthsW fails. */
1269 if (font_type
== UNICODE_FONT
)
1270 retval
= GetTextExtentPoint32W (hdc
, char2b
, 1, &sz
);
1272 retval
= GetTextExtentPoint32A (hdc
, (char*)char2b
, 1, &sz
);
1276 pcm
->width
= sz
.cx
- font
->tm
.tmOverhang
;
1277 pcm
->rbearing
= sz
.cx
;
1279 pcm
->ascent
= FONT_BASE (font
);
1280 pcm
->descent
= FONT_DESCENT (font
);
1285 if (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0)
1290 SelectObject (hdc
, old_font
);
1291 ReleaseDC (NULL
, hdc
);
1297 static XCharStruct
*
1298 w32_per_char_metric (font
, char2b
, font_type
)
1301 enum w32_char_font_type font_type
;
1303 /* The result metric information. */
1307 xassert (font
&& char2b
);
1308 xassert (font_type
!= UNKNOWN_FONT
);
1310 /* Handle the common cases quickly. */
1311 if (!font
->bdf
&& font
->per_char
== NULL
)
1312 /* TODO: determine whether char2b exists in font? */
1313 return &font
->max_bounds
;
1314 else if (!font
->bdf
&& *char2b
< 128)
1315 return &font
->per_char
[*char2b
];
1317 pcm
= &font
->scratch
;
1319 if (font_type
== BDF_1D_FONT
)
1320 retval
= w32_bdf_per_char_metric (font
, char2b
, 1, pcm
);
1321 else if (font_type
== BDF_2D_FONT
)
1322 retval
= w32_bdf_per_char_metric (font
, char2b
, 2, pcm
);
1324 retval
= w32_native_per_char_metric (font
, char2b
, font_type
, pcm
);
1333 w32_cache_char_metrics (font
)
1336 wchar_t char2b
= L
'x';
1338 /* Cache char metrics for the common cases. */
1341 /* TODO: determine whether font is fixed-pitch. */
1342 if (!w32_bdf_per_char_metric (font
, &char2b
, 1, &font
->max_bounds
))
1344 /* Use the font width and height as max bounds, as not all BDF
1345 fonts contain the letter 'x'. */
1346 font
->max_bounds
.width
= FONT_MAX_WIDTH (font
);
1347 font
->max_bounds
.lbearing
= -font
->bdf
->llx
;
1348 font
->max_bounds
.rbearing
= FONT_MAX_WIDTH (font
) - font
->bdf
->urx
;
1349 font
->max_bounds
.ascent
= FONT_BASE (font
);
1350 font
->max_bounds
.descent
= FONT_DESCENT (font
);
1355 if (((font
->tm
.tmPitchAndFamily
& TMPF_FIXED_PITCH
) != 0)
1356 /* Some fonts (eg DBCS fonts) are marked as fixed width even
1357 though they contain characters of different widths. */
1358 || (font
->tm
.tmMaxCharWidth
!= font
->tm
.tmAveCharWidth
))
1360 /* Font is not fixed pitch, so cache per_char info for the
1361 ASCII characters. It would be much more work, and probably
1362 not worth it, to cache other chars, since we may change
1363 between using Unicode and ANSI text drawing functions at
1367 font
->per_char
= xmalloc (128 * sizeof(XCharStruct
));
1368 for (i
= 0; i
< 128; i
++)
1371 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1372 &font
->per_char
[i
]);
1376 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1382 /* Determine if a font is double byte. */
1383 int w32_font_is_double_byte (XFontStruct
*font
)
1385 return font
->double_byte_p
;
1390 w32_use_unicode_for_codepage (codepage
)
1393 /* If the current codepage is supported, use Unicode for output. */
1394 return (w32_enable_unicode_output
1395 && codepage
!= CP_8BIT
1396 && (codepage
== CP_UNICODE
|| IsValidCodePage (codepage
)));
1399 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1400 the two-byte form of C. Encoding is returned in *CHAR2B. */
1402 static INLINE
enum w32_char_font_type
1403 w32_encode_char (c
, char2b
, font_info
, two_byte_p
)
1406 struct font_info
*font_info
;
1409 int charset
= CHAR_CHARSET (c
);
1413 XFontStruct
*font
= font_info
->font
;
1415 xassert (two_byte_p
);
1417 *two_byte_p
= w32_font_is_double_byte (font
);
1419 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1420 This may be either a program in a special encoder language or a
1422 if (font_info
->font_encoder
)
1424 /* It's a program. */
1425 struct ccl_program
*ccl
= font_info
->font_encoder
;
1427 if (CHARSET_DIMENSION (charset
) == 1)
1429 ccl
->reg
[0] = charset
;
1430 ccl
->reg
[1] = BYTE2 (*char2b
);
1434 ccl
->reg
[0] = charset
;
1435 ccl
->reg
[1] = BYTE1 (*char2b
);
1436 ccl
->reg
[2] = BYTE2 (*char2b
);
1439 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
1441 /* We assume that MSBs are appropriately set/reset by CCL
1443 if (!*two_byte_p
) /* 1-byte font */
1444 *char2b
= BUILD_WCHAR_T (0, ccl
->reg
[1]);
1446 *char2b
= BUILD_WCHAR_T (ccl
->reg
[1], ccl
->reg
[2]);
1448 else if (font_info
->encoding
[charset
])
1450 /* Fixed encoding scheme. See fontset.h for the meaning of the
1451 encoding numbers. */
1452 int enc
= font_info
->encoding
[charset
];
1454 if ((enc
== 1 || enc
== 2)
1455 && CHARSET_DIMENSION (charset
) == 2)
1456 *char2b
= BUILD_WCHAR_T (BYTE1 (*char2b
) | 0x80, BYTE2 (*char2b
));
1458 if (enc
== 1 || enc
== 3
1459 || (enc
== 4 && CHARSET_DIMENSION (charset
) == 1))
1460 *char2b
= BUILD_WCHAR_T (BYTE1 (*char2b
), BYTE2 (*char2b
) | 0x80);
1465 ENCODE_SJIS (BYTE1 (*char2b
), BYTE2 (*char2b
),
1467 *char2b
= BUILD_WCHAR_T (sjis1
, sjis2
);
1470 codepage
= font_info
->codepage
;
1472 /* If charset is not ASCII or Latin-1, may need to move it into
1474 if ( font
&& !font
->bdf
&& w32_use_unicode_for_codepage (codepage
)
1475 && charset
!= CHARSET_ASCII
&& charset
!= charset_latin_iso8859_1
1476 && charset
!= CHARSET_8_BIT_CONTROL
&& charset
!= CHARSET_8_BIT_GRAPHIC
)
1479 temp
[0] = BYTE1 (*char2b
);
1480 temp
[1] = BYTE2 (*char2b
);
1482 if (codepage
!= CP_UNICODE
)
1485 MultiByteToWideChar (codepage
, 0, temp
, 2, char2b
, 1);
1487 MultiByteToWideChar (codepage
, 0, temp
+1, 1, char2b
, 1);
1493 return UNKNOWN_FONT
;
1494 else if (font
->bdf
&& CHARSET_DIMENSION (charset
) == 1)
1499 return UNICODE_FONT
;
1505 /* Get face and two-byte form of character C in face FACE_ID on frame
1506 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1507 means we want to display multibyte text. Value is a pointer to a
1508 realized face that is ready for display. */
1510 static INLINE
struct face
*
1511 x_get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
)
1517 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1521 /* Unibyte case. We don't have to encode, but we have to make
1522 sure to use a face suitable for unibyte. */
1523 *char2b
= BUILD_WCHAR_T (0, c
);
1524 face_id
= FACE_FOR_CHAR (f
, face
, c
);
1525 face
= FACE_FROM_ID (f
, face_id
);
1527 else if (c
< 128 && face_id
< BASIC_FACE_ID_SENTINEL
)
1529 /* Case of ASCII in a face known to fit ASCII. */
1530 *char2b
= BUILD_WCHAR_T (0, c
);
1534 int c1
, c2
, charset
;
1536 /* Split characters into bytes. If c2 is -1 afterwards, C is
1537 really a one-byte character so that byte1 is zero. */
1538 SPLIT_CHAR (c
, charset
, c1
, c2
);
1540 *char2b
= BUILD_WCHAR_T (c1
, c2
);
1542 *char2b
= BUILD_WCHAR_T (0, c1
);
1544 /* Maybe encode the character in *CHAR2B. */
1545 if (face
->font
!= NULL
)
1547 struct font_info
*font_info
1548 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1550 w32_encode_char (c
, char2b
, font_info
, &multibyte_p
);
1554 /* Make sure X resources of the face are allocated. */
1555 xassert (face
!= NULL
);
1556 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1562 /* Get face and two-byte form of character glyph GLYPH on frame F.
1563 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1564 a pointer to a realized face that is ready for display. */
1566 static INLINE
struct face
*
1567 x_get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
1569 struct glyph
*glyph
;
1576 xassert (glyph
->type
== CHAR_GLYPH
);
1577 face
= FACE_FROM_ID (f
, glyph
->face_id
);
1582 two_byte_p
= &dummy
;
1584 if (!glyph
->multibyte_p
)
1586 /* Unibyte case. We don't have to encode, but we have to make
1587 sure to use a face suitable for unibyte. */
1588 *char2b
= BUILD_WCHAR_T (0, glyph
->u
.ch
);
1590 else if (glyph
->u
.ch
< 128
1591 && glyph
->face_id
< BASIC_FACE_ID_SENTINEL
)
1593 /* Case of ASCII in a face known to fit ASCII. */
1594 *char2b
= BUILD_WCHAR_T (0, glyph
->u
.ch
);
1598 int c1
, c2
, charset
;
1600 /* Split characters into bytes. If c2 is -1 afterwards, C is
1601 really a one-byte character so that byte1 is zero. */
1602 SPLIT_CHAR (glyph
->u
.ch
, charset
, c1
, c2
);
1604 *char2b
= BUILD_WCHAR_T (c1
, c2
);
1606 *char2b
= BUILD_WCHAR_T (0, c1
);
1608 /* Maybe encode the character in *CHAR2B. */
1609 if (charset
!= CHARSET_ASCII
)
1611 struct font_info
*font_info
1612 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1615 glyph
->w32_font_type
1616 = w32_encode_char (glyph
->u
.ch
, char2b
, font_info
, two_byte_p
);
1621 /* Make sure X resources of the face are allocated. */
1622 xassert (face
!= NULL
);
1623 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1628 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1629 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1635 struct glyph
*glyph
;
1636 enum glyph_row_area area
= it
->area
;
1638 xassert (it
->glyph_row
);
1639 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
1641 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1642 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1644 glyph
->charpos
= CHARPOS (it
->position
);
1645 glyph
->object
= it
->object
;
1646 glyph
->pixel_width
= it
->pixel_width
;
1647 glyph
->voffset
= it
->voffset
;
1648 glyph
->type
= CHAR_GLYPH
;
1649 glyph
->multibyte_p
= it
->multibyte_p
;
1650 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1651 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1652 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1653 || it
->phys_descent
> it
->descent
);
1654 glyph
->padding_p
= 0;
1655 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
1656 glyph
->face_id
= it
->face_id
;
1657 glyph
->u
.ch
= it
->char_to_display
;
1658 glyph
->w32_font_type
= UNKNOWN_FONT
;
1659 ++it
->glyph_row
->used
[area
];
1663 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1664 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1667 x_append_composite_glyph (it
)
1670 struct glyph
*glyph
;
1671 enum glyph_row_area area
= it
->area
;
1673 xassert (it
->glyph_row
);
1675 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1676 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1678 glyph
->charpos
= CHARPOS (it
->position
);
1679 glyph
->object
= it
->object
;
1680 glyph
->pixel_width
= it
->pixel_width
;
1681 glyph
->voffset
= it
->voffset
;
1682 glyph
->type
= COMPOSITE_GLYPH
;
1683 glyph
->multibyte_p
= it
->multibyte_p
;
1684 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1685 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1686 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1687 || it
->phys_descent
> it
->descent
);
1688 glyph
->padding_p
= 0;
1689 glyph
->glyph_not_available_p
= 0;
1690 glyph
->face_id
= it
->face_id
;
1691 glyph
->u
.cmp_id
= it
->cmp_id
;
1692 glyph
->w32_font_type
= UNKNOWN_FONT
;
1693 ++it
->glyph_row
->used
[area
];
1698 /* Change IT->ascent and IT->height according to the setting of
1702 take_vertical_position_into_account (it
)
1707 if (it
->voffset
< 0)
1708 /* Increase the ascent so that we can display the text higher
1710 it
->ascent
+= abs (it
->voffset
);
1712 /* Increase the descent so that we can display the text lower
1714 it
->descent
+= it
->voffset
;
1719 /* Produce glyphs/get display metrics for the image IT is loaded with.
1720 See the description of struct display_iterator in dispextern.h for
1721 an overview of struct display_iterator. */
1724 x_produce_image_glyph (it
)
1730 xassert (it
->what
== IT_IMAGE
);
1732 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1733 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
1736 /* Make sure X resources of the face and image are loaded. */
1737 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1738 prepare_image_for_display (it
->f
, img
);
1740 it
->ascent
= it
->phys_ascent
= image_ascent (img
, face
);
1741 it
->descent
= it
->phys_descent
= img
->height
+ 2 * img
->vmargin
- it
->ascent
;
1742 it
->pixel_width
= img
->width
+ 2 * img
->hmargin
;
1746 if (face
->box
!= FACE_NO_BOX
)
1748 if (face
->box_line_width
> 0)
1750 it
->ascent
+= face
->box_line_width
;
1751 it
->descent
+= face
->box_line_width
;
1754 if (it
->start_of_box_run_p
)
1755 it
->pixel_width
+= abs (face
->box_line_width
);
1756 if (it
->end_of_box_run_p
)
1757 it
->pixel_width
+= abs (face
->box_line_width
);
1760 take_vertical_position_into_account (it
);
1764 struct glyph
*glyph
;
1765 enum glyph_row_area area
= it
->area
;
1767 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1768 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1770 glyph
->charpos
= CHARPOS (it
->position
);
1771 glyph
->object
= it
->object
;
1772 glyph
->pixel_width
= it
->pixel_width
;
1773 glyph
->voffset
= it
->voffset
;
1774 glyph
->type
= IMAGE_GLYPH
;
1775 glyph
->multibyte_p
= it
->multibyte_p
;
1776 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1777 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1778 glyph
->overlaps_vertically_p
= 0;
1779 glyph
->padding_p
= 0;
1780 glyph
->glyph_not_available_p
= 0;
1781 glyph
->face_id
= it
->face_id
;
1782 glyph
->u
.img_id
= img
->id
;
1783 glyph
->w32_font_type
= UNKNOWN_FONT
;
1784 ++it
->glyph_row
->used
[area
];
1790 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1791 of the glyph, WIDTH and HEIGHT are the width and height of the
1792 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1793 ascent of the glyph (0 <= ASCENT <= 1). */
1796 x_append_stretch_glyph (it
, object
, width
, height
, ascent
)
1802 struct glyph
*glyph
;
1803 enum glyph_row_area area
= it
->area
;
1805 xassert (ascent
>= 0 && ascent
<= 1);
1807 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1808 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1810 glyph
->charpos
= CHARPOS (it
->position
);
1811 glyph
->object
= object
;
1812 glyph
->pixel_width
= width
;
1813 glyph
->voffset
= it
->voffset
;
1814 glyph
->type
= STRETCH_GLYPH
;
1815 glyph
->multibyte_p
= it
->multibyte_p
;
1816 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1817 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1818 glyph
->overlaps_vertically_p
= 0;
1819 glyph
->padding_p
= 0;
1820 glyph
->glyph_not_available_p
= 0;
1821 glyph
->face_id
= it
->face_id
;
1822 glyph
->u
.stretch
.ascent
= height
* ascent
;
1823 glyph
->u
.stretch
.height
= height
;
1824 glyph
->w32_font_type
= UNKNOWN_FONT
;
1825 ++it
->glyph_row
->used
[area
];
1830 /* Produce a stretch glyph for iterator IT. IT->object is the value
1831 of the glyph property displayed. The value must be a list
1832 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1835 1. `:width WIDTH' specifies that the space should be WIDTH *
1836 canonical char width wide. WIDTH may be an integer or floating
1839 2. `:relative-width FACTOR' specifies that the width of the stretch
1840 should be computed from the width of the first character having the
1841 `glyph' property, and should be FACTOR times that width.
1843 3. `:align-to HPOS' specifies that the space should be wide enough
1844 to reach HPOS, a value in canonical character units.
1846 Exactly one of the above pairs must be present.
1848 4. `:height HEIGHT' specifies that the height of the stretch produced
1849 should be HEIGHT, measured in canonical character units.
1851 5. `:relative-height FACTOR' specifies that the height of the
1852 stretch should be FACTOR times the height of the characters having
1855 Either none or exactly one of 4 or 5 must be present.
1857 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1858 of the stretch should be used for the ascent of the stretch.
1859 ASCENT must be in the range 0 <= ASCENT <= 100. */
1862 ((INTEGERP (X) || FLOATP (X)) \
1868 x_produce_stretch_glyph (it
)
1871 /* (space :width WIDTH :height HEIGHT. */
1873 extern Lisp_Object Qspace
;
1875 extern Lisp_Object QCwidth
, QCheight
, QCascent
;
1876 extern Lisp_Object QCrelative_width
, QCrelative_height
;
1877 extern Lisp_Object QCalign_to
;
1878 Lisp_Object prop
, plist
;
1879 double width
= 0, height
= 0, ascent
= 0;
1880 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1881 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
1883 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1885 /* List should start with `space'. */
1886 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
1887 plist
= XCDR (it
->object
);
1889 /* Compute the width of the stretch. */
1890 if (prop
= Fplist_get (plist
, QCwidth
),
1892 /* Absolute width `:width WIDTH' specified and valid. */
1893 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
);
1894 else if (prop
= Fplist_get (plist
, QCrelative_width
),
1897 /* Relative width `:relative-width FACTOR' specified and valid.
1898 Compute the width of the characters having the `glyph'
1901 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
1904 if (it
->multibyte_p
)
1906 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
1907 - IT_BYTEPOS (*it
));
1908 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
1911 it2
.c
= *p
, it2
.len
= 1;
1913 it2
.glyph_row
= NULL
;
1914 it2
.what
= IT_CHARACTER
;
1915 x_produce_glyphs (&it2
);
1916 width
= NUMVAL (prop
) * it2
.pixel_width
;
1918 else if (prop
= Fplist_get (plist
, QCalign_to
),
1920 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
) - it
->current_x
;
1922 /* Nothing specified -> width defaults to canonical char width. */
1923 width
= CANON_X_UNIT (it
->f
);
1925 /* Compute height. */
1926 if (prop
= Fplist_get (plist
, QCheight
),
1928 height
= NUMVAL (prop
) * CANON_Y_UNIT (it
->f
);
1929 else if (prop
= Fplist_get (plist
, QCrelative_height
),
1931 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
1933 height
= FONT_HEIGHT (font
);
1935 /* Compute percentage of height used for ascent. If
1936 `:ascent ASCENT' is present and valid, use that. Otherwise,
1937 derive the ascent from the font in use. */
1938 if (prop
= Fplist_get (plist
, QCascent
),
1939 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
1940 ascent
= NUMVAL (prop
) / 100.0;
1942 ascent
= (double) FONT_BASE (font
) / FONT_HEIGHT (font
);
1951 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
1952 if (!STRINGP (object
))
1953 object
= it
->w
->buffer
;
1954 x_append_stretch_glyph (it
, object
, width
, height
, ascent
);
1957 it
->pixel_width
= width
;
1958 it
->ascent
= it
->phys_ascent
= height
* ascent
;
1959 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
1962 if (face
->box
!= FACE_NO_BOX
)
1964 if (face
->box_line_width
> 0)
1966 it
->ascent
+= face
->box_line_width
;
1967 it
->descent
+= face
->box_line_width
;
1970 if (it
->start_of_box_run_p
)
1971 it
->pixel_width
+= abs (face
->box_line_width
);
1972 if (it
->end_of_box_run_p
)
1973 it
->pixel_width
+= abs (face
->box_line_width
);
1976 take_vertical_position_into_account (it
);
1979 /* Return proper value to be used as baseline offset of font that has
1980 ASCENT and DESCENT to draw characters by the font at the vertical
1981 center of the line of frame F.
1983 Here, out task is to find the value of BOFF in the following figure;
1985 -------------------------+-----------+-
1986 -+-+---------+-+ | |
1988 | | | | F_ASCENT F_HEIGHT
1991 | | |-|-+------+-----------|------- baseline
1993 | |---------|-+-+ | |
1995 -+-+---------+-+ F_DESCENT |
1996 -------------------------+-----------+-
1998 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1999 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
2000 DESCENT = FONT->descent
2001 HEIGHT = FONT_HEIGHT (FONT)
2002 F_DESCENT = (F->output_data.x->font->descent
2003 - F->output_data.x->baseline_offset)
2004 F_HEIGHT = FRAME_LINE_HEIGHT (F)
2007 #define VCENTER_BASELINE_OFFSET(FONT, F) \
2008 (FONT_DESCENT (FONT) \
2009 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
2010 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
2011 - (FONT_DESCENT (FRAME_FONT (F)) - FRAME_BASELINE_OFFSET (F)))
2013 /* Produce glyphs/get display metrics for the display element IT is
2014 loaded with. See the description of struct display_iterator in
2015 dispextern.h for an overview of struct display_iterator. */
2018 x_produce_glyphs (it
)
2021 it
->glyph_not_available_p
= 0;
2023 if (it
->what
== IT_CHARACTER
)
2027 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2029 int font_not_found_p
;
2030 struct font_info
*font_info
;
2031 int boff
; /* baseline offset */
2032 /* We may change it->multibyte_p upon unibyte<->multibyte
2033 conversion. So, save the current value now and restore it
2036 Note: It seems that we don't have to record multibyte_p in
2037 struct glyph because the character code itself tells if or
2038 not the character is multibyte. Thus, in the future, we must
2039 consider eliminating the field `multibyte_p' in the struct
2042 int saved_multibyte_p
= it
->multibyte_p
;
2044 /* Maybe translate single-byte characters to multibyte, or the
2046 it
->char_to_display
= it
->c
;
2047 if (!ASCII_BYTE_P (it
->c
))
2049 if (unibyte_display_via_language_environment
2050 && SINGLE_BYTE_CHAR_P (it
->c
)
2052 || !NILP (Vnonascii_translation_table
)))
2054 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2055 it
->multibyte_p
= 1;
2056 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2057 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2059 else if (!SINGLE_BYTE_CHAR_P (it
->c
)
2060 && !it
->multibyte_p
)
2062 it
->multibyte_p
= 1;
2063 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2064 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2068 /* Get font to use. Encode IT->char_to_display. */
2069 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2070 it
->face_id
, &char2b
,
2074 /* When no suitable font found, use the default font. */
2075 font_not_found_p
= font
== NULL
;
2076 if (font_not_found_p
)
2078 font
= FRAME_FONT (it
->f
);
2079 boff
= it
->f
->output_data
.w32
->baseline_offset
;
2084 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2085 boff
= font_info
->baseline_offset
;
2086 if (font_info
->vertical_centering
)
2087 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2090 if (it
->char_to_display
>= ' '
2091 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
2093 /* Either unibyte or ASCII. */
2098 pcm
= w32_per_char_metric (font
, &char2b
,
2099 font
->bdf
? BDF_1D_FONT
: ANSI_FONT
);
2100 it
->ascent
= FONT_BASE (font
) + boff
;
2101 it
->descent
= FONT_DESCENT (font
) - boff
;
2105 it
->phys_ascent
= pcm
->ascent
+ boff
;
2106 it
->phys_descent
= pcm
->descent
- boff
;
2107 it
->pixel_width
= pcm
->width
;
2111 it
->glyph_not_available_p
= 1;
2112 it
->phys_ascent
= FONT_BASE (font
) + boff
;
2113 it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2114 it
->pixel_width
= FONT_WIDTH (font
);
2117 /* If this is a space inside a region of text with
2118 `space-width' property, change its width. */
2119 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
2121 it
->pixel_width
*= XFLOATINT (it
->space_width
);
2123 /* If face has a box, add the box thickness to the character
2124 height. If character has a box line to the left and/or
2125 right, add the box line width to the character's width. */
2126 if (face
->box
!= FACE_NO_BOX
)
2128 int thick
= face
->box_line_width
;
2132 it
->ascent
+= thick
;
2133 it
->descent
+= thick
;
2138 if (it
->start_of_box_run_p
)
2139 it
->pixel_width
+= thick
;
2140 if (it
->end_of_box_run_p
)
2141 it
->pixel_width
+= thick
;
2144 /* If face has an overline, add the height of the overline
2145 (1 pixel) and a 1 pixel margin to the character height. */
2146 if (face
->overline_p
)
2149 take_vertical_position_into_account (it
);
2151 /* If we have to actually produce glyphs, do it. */
2156 /* Translate a space with a `space-width' property
2157 into a stretch glyph. */
2158 double ascent
= (double) FONT_BASE (font
)
2159 / FONT_HEIGHT (font
);
2160 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
2161 it
->ascent
+ it
->descent
, ascent
);
2164 x_append_glyph (it
);
2166 /* If characters with lbearing or rbearing are displayed
2167 in this line, record that fact in a flag of the
2168 glyph row. This is used to optimize X output code. */
2169 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
2170 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2173 else if (it
->char_to_display
== '\n')
2175 /* A newline has no width but we need the height of the line. */
2176 it
->pixel_width
= 0;
2178 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
2179 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2181 if (face
->box
!= FACE_NO_BOX
2182 && face
->box_line_width
> 0)
2184 it
->ascent
+= face
->box_line_width
;
2185 it
->descent
+= face
->box_line_width
;
2188 else if (it
->char_to_display
== '\t')
2190 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
2191 int x
= it
->current_x
+ it
->continuation_lines_width
;
2192 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
2194 /* If the distance from the current position to the next tab
2195 stop is less than a canonical character width, use the
2196 tab stop after that. */
2197 if (next_tab_x
- x
< CANON_X_UNIT (it
->f
))
2198 next_tab_x
+= tab_width
;
2200 it
->pixel_width
= next_tab_x
- x
;
2202 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
2203 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2207 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
2208 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
2209 it
->ascent
+ it
->descent
, ascent
);
2214 /* A multi-byte character.
2215 If we found a font, this font should give us the right
2216 metrics. If we didn't find a font, use the frame's
2217 default font and calculate the width of the character
2218 from the charset width; this is what old redisplay code
2220 enum w32_char_font_type type
;
2222 if (font
->bdf
&& CHARSET_DIMENSION (CHAR_CHARSET (it
->c
)) == 1)
2227 type
= UNICODE_FONT
;
2229 pcm
= w32_per_char_metric (font
, &char2b
, type
);
2231 if (font_not_found_p
|| !pcm
)
2233 int charset
= CHAR_CHARSET (it
->char_to_display
);
2235 it
->glyph_not_available_p
= 1;
2236 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
2237 * CHARSET_WIDTH (charset
));
2238 it
->phys_ascent
= FONT_BASE (font
) + boff
;
2239 it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2243 it
->pixel_width
= pcm
->width
;
2244 it
->phys_ascent
= pcm
->ascent
+ boff
;
2245 it
->phys_descent
= pcm
->descent
- boff
;
2247 && (pcm
->lbearing
< 0
2248 || pcm
->rbearing
> pcm
->width
))
2249 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2252 it
->ascent
= FONT_BASE (font
) + boff
;
2253 it
->descent
= FONT_DESCENT (font
) - boff
;
2254 if (face
->box
!= FACE_NO_BOX
)
2256 int thick
= face
->box_line_width
;
2260 it
->ascent
+= thick
;
2261 it
->descent
+= thick
;
2266 if (it
->start_of_box_run_p
)
2267 it
->pixel_width
+= thick
;
2268 if (it
->end_of_box_run_p
)
2269 it
->pixel_width
+= thick
;
2272 /* If face has an overline, add the height of the overline
2273 (1 pixel) and a 1 pixel margin to the character height. */
2274 if (face
->overline_p
)
2277 take_vertical_position_into_account (it
);
2280 x_append_glyph (it
);
2282 it
->multibyte_p
= saved_multibyte_p
;
2284 else if (it
->what
== IT_COMPOSITION
)
2286 /* Note: A composition is represented as one glyph in the
2287 glyph matrix. There are no padding glyphs. */
2290 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2292 int font_not_found_p
;
2293 struct font_info
*font_info
;
2294 int boff
; /* baseline offset */
2295 struct composition
*cmp
= composition_table
[it
->cmp_id
];
2297 /* Maybe translate single-byte characters to multibyte. */
2298 it
->char_to_display
= it
->c
;
2299 if (unibyte_display_via_language_environment
2300 && SINGLE_BYTE_CHAR_P (it
->c
)
2303 && !NILP (Vnonascii_translation_table
))))
2305 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2308 /* Get face and font to use. Encode IT->char_to_display. */
2309 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2310 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2311 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2312 it
->face_id
, &char2b
, it
->multibyte_p
);
2315 /* When no suitable font found, use the default font. */
2316 font_not_found_p
= font
== NULL
;
2317 if (font_not_found_p
)
2319 font
= FRAME_FONT (it
->f
);
2320 boff
= it
->f
->output_data
.w32
->baseline_offset
;
2325 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2326 boff
= font_info
->baseline_offset
;
2327 if (font_info
->vertical_centering
)
2328 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2331 /* There are no padding glyphs, so there is only one glyph to
2332 produce for the composition. Important is that pixel_width,
2333 ascent and descent are the values of what is drawn by
2334 draw_glyphs (i.e. the values of the overall glyphs composed). */
2337 /* If we have not yet calculated pixel size data of glyphs of
2338 the composition for the current face font, calculate them
2339 now. Theoretically, we have to check all fonts for the
2340 glyphs, but that requires much time and memory space. So,
2341 here we check only the font of the first glyph. This leads
2342 to incorrect display very rarely, and C-l (recenter) can
2343 correct the display anyway. */
2344 if (cmp
->font
!= (void *) font
)
2346 /* Ascent and descent of the font of the first character of
2347 this composition (adjusted by baseline offset). Ascent
2348 and descent of overall glyphs should not be less than
2349 them respectively. */
2350 int font_ascent
= FONT_BASE (font
) + boff
;
2351 int font_descent
= FONT_DESCENT (font
) - boff
;
2352 /* Bounding box of the overall glyphs. */
2353 int leftmost
, rightmost
, lowest
, highest
;
2354 int i
, width
, ascent
, descent
;
2355 enum w32_char_font_type font_type
;
2357 cmp
->font
= (void *) font
;
2359 if (font
->bdf
&& CHARSET_DIMENSION (CHAR_CHARSET (it
->c
)) == 1)
2360 font_type
= BDF_1D_FONT
;
2362 font_type
= BDF_2D_FONT
;
2364 font_type
= UNICODE_FONT
;
2366 /* Initialize the bounding box. */
2368 && (pcm
= w32_per_char_metric (font
, &char2b
, font_type
)))
2371 ascent
= pcm
->ascent
;
2372 descent
= pcm
->descent
;
2376 width
= FONT_WIDTH (font
);
2377 ascent
= FONT_BASE (font
);
2378 descent
= FONT_DESCENT (font
);
2382 lowest
= - descent
+ boff
;
2383 highest
= ascent
+ boff
;
2387 && font_info
->default_ascent
2388 && CHAR_TABLE_P (Vuse_default_ascent
)
2389 && !NILP (Faref (Vuse_default_ascent
,
2390 make_number (it
->char_to_display
))))
2391 highest
= font_info
->default_ascent
+ boff
;
2393 /* Draw the first glyph at the normal position. It may be
2394 shifted to right later if some other glyphs are drawn at
2396 cmp
->offsets
[0] = 0;
2397 cmp
->offsets
[1] = boff
;
2399 /* Set cmp->offsets for the remaining glyphs. */
2400 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2402 int left
, right
, btm
, top
;
2403 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2404 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2406 face
= FACE_FROM_ID (it
->f
, face_id
);
2407 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2412 font
= FRAME_FONT (it
->f
);
2413 boff
= it
->f
->output_data
.w32
->baseline_offset
;
2419 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2420 boff
= font_info
->baseline_offset
;
2421 if (font_info
->vertical_centering
)
2422 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2425 if (font
->bdf
&& CHARSET_DIMENSION (CHAR_CHARSET (ch
)) == 1)
2426 font_type
= BDF_1D_FONT
;
2428 font_type
= BDF_2D_FONT
;
2430 font_type
= UNICODE_FONT
;
2433 && (pcm
= w32_per_char_metric (font
, &char2b
, font_type
)))
2436 ascent
= pcm
->ascent
;
2437 descent
= pcm
->descent
;
2441 width
= FONT_WIDTH (font
);
2446 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2448 /* Relative composition with or without
2450 left
= (leftmost
+ rightmost
- width
) / 2;
2451 btm
= - descent
+ boff
;
2452 if (font_info
&& font_info
->relative_compose
2453 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2454 || NILP (Faref (Vignore_relative_composition
,
2455 make_number (ch
)))))
2458 if (- descent
>= font_info
->relative_compose
)
2459 /* One extra pixel between two glyphs. */
2461 else if (ascent
<= 0)
2462 /* One extra pixel between two glyphs. */
2463 btm
= lowest
- 1 - ascent
- descent
;
2468 /* A composition rule is specified by an integer
2469 value that encodes global and new reference
2470 points (GREF and NREF). GREF and NREF are
2471 specified by numbers as below:
2479 ---3---4---5--- baseline
2481 6---7---8 -- descent
2483 int rule
= COMPOSITION_RULE (cmp
, i
);
2484 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2486 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2487 grefx
= gref
% 3, nrefx
= nref
% 3;
2488 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2491 + grefx
* (rightmost
- leftmost
) / 2
2492 - nrefx
* width
/ 2);
2493 btm
= ((grefy
== 0 ? highest
2495 : grefy
== 2 ? lowest
2496 : (highest
+ lowest
) / 2)
2497 - (nrefy
== 0 ? ascent
+ descent
2498 : nrefy
== 1 ? descent
- boff
2500 : (ascent
+ descent
) / 2));
2503 cmp
->offsets
[i
* 2] = left
;
2504 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
2506 /* Update the bounding box of the overall glyphs. */
2507 right
= left
+ width
;
2508 top
= btm
+ descent
+ ascent
;
2509 if (left
< leftmost
)
2511 if (right
> rightmost
)
2519 /* If there are glyphs whose x-offsets are negative,
2520 shift all glyphs to the right and make all x-offsets
2524 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2525 cmp
->offsets
[i
* 2] -= leftmost
;
2526 rightmost
-= leftmost
;
2529 cmp
->pixel_width
= rightmost
;
2530 cmp
->ascent
= highest
;
2531 cmp
->descent
= - lowest
;
2532 if (cmp
->ascent
< font_ascent
)
2533 cmp
->ascent
= font_ascent
;
2534 if (cmp
->descent
< font_descent
)
2535 cmp
->descent
= font_descent
;
2538 it
->pixel_width
= cmp
->pixel_width
;
2539 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2540 it
->descent
= it
->phys_descent
= cmp
->descent
;
2542 if (face
->box
!= FACE_NO_BOX
)
2544 int thick
= face
->box_line_width
;
2548 it
->ascent
+= thick
;
2549 it
->descent
+= thick
;
2554 if (it
->start_of_box_run_p
)
2555 it
->pixel_width
+= thick
;
2556 if (it
->end_of_box_run_p
)
2557 it
->pixel_width
+= thick
;
2560 /* If face has an overline, add the height of the overline
2561 (1 pixel) and a 1 pixel margin to the character height. */
2562 if (face
->overline_p
)
2565 take_vertical_position_into_account (it
);
2568 x_append_composite_glyph (it
);
2570 else if (it
->what
== IT_IMAGE
)
2571 x_produce_image_glyph (it
);
2572 else if (it
->what
== IT_STRETCH
)
2573 x_produce_stretch_glyph (it
);
2575 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2576 because this isn't true for images with `:ascent 100'. */
2577 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
2578 if (it
->area
== TEXT_AREA
)
2579 it
->current_x
+= it
->pixel_width
;
2581 it
->descent
+= it
->extra_line_spacing
;
2583 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2584 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2585 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2586 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2590 /* Estimate the pixel height of the mode or top line on frame F.
2591 FACE_ID specifies what line's height to estimate. */
2594 x_estimate_mode_line_height (f
, face_id
)
2596 enum face_id face_id
;
2598 int height
= FONT_HEIGHT (FRAME_FONT (f
));
2600 /* This function is called so early when Emacs starts that the face
2601 cache and mode line face are not yet initialized. */
2602 if (FRAME_FACE_CACHE (f
))
2604 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2608 height
= FONT_HEIGHT (face
->font
);
2609 if (face
->box_line_width
> 0)
2610 height
+= 2 * face
->box_line_width
;
2618 /***********************************************************************
2620 ***********************************************************************/
2622 /* A sequence of glyphs to be drawn in the same face.
2624 This data structure is not really completely X specific, so it
2625 could possibly, at least partially, be useful for other systems. It
2626 is currently not part of the external redisplay interface because
2627 it's not clear what other systems will need. */
2631 /* X-origin of the string. */
2634 /* Y-origin and y-position of the base line of this string. */
2637 /* The width of the string, not including a face extension. */
2640 /* The width of the string, including a face extension. */
2641 int background_width
;
2643 /* The height of this string. This is the height of the line this
2644 string is drawn in, and can be different from the height of the
2645 font the string is drawn in. */
2648 /* Number of pixels this string overwrites in front of its x-origin.
2649 This number is zero if the string has an lbearing >= 0; it is
2650 -lbearing, if the string has an lbearing < 0. */
2653 /* Number of pixels this string overwrites past its right-most
2654 nominal x-position, i.e. x + width. Zero if the string's
2655 rbearing is <= its nominal width, rbearing - width otherwise. */
2658 /* The frame on which the glyph string is drawn. */
2661 /* The window on which the glyph string is drawn. */
2664 /* X display and window for convenience. */
2667 /* The glyph row for which this string was built. It determines the
2668 y-origin and height of the string. */
2669 struct glyph_row
*row
;
2671 /* The area within row. */
2672 enum glyph_row_area area
;
2674 /* Characters to be drawn, and number of characters. */
2678 /* A face-override for drawing cursors, mouse face and similar. */
2679 enum draw_glyphs_face hl
;
2681 /* Face in which this string is to be drawn. */
2684 /* Font in which this string is to be drawn. */
2687 /* Font info for this string. */
2688 struct font_info
*font_info
;
2690 /* Non-null means this string describes (part of) a composition.
2691 All characters from char2b are drawn composed. */
2692 struct composition
*cmp
;
2694 /* Index of this glyph string's first character in the glyph
2695 definition of CMP. If this is zero, this glyph string describes
2696 the first character of a composition. */
2699 /* 1 means this glyph strings face has to be drawn to the right end
2700 of the window's drawing area. */
2701 unsigned extends_to_end_of_line_p
: 1;
2703 /* 1 means the background of this string has been drawn. */
2704 unsigned background_filled_p
: 1;
2706 /* 1 means glyph string must be drawn with 16-bit functions. */
2707 unsigned two_byte_p
: 1;
2709 /* 1 means that the original font determined for drawing this glyph
2710 string could not be loaded. The member `font' has been set to
2711 the frame's default font in this case. */
2712 unsigned font_not_found_p
: 1;
2714 /* 1 means that the face in which this glyph string is drawn has a
2716 unsigned stippled_p
: 1;
2718 /* 1 means only the foreground of this glyph string must be drawn,
2719 and we should use the physical height of the line this glyph
2720 string appears in as clip rect. */
2721 unsigned for_overlaps_p
: 1;
2723 /* The GC to use for drawing this glyph string. */
2728 /* A pointer to the first glyph in the string. This glyph
2729 corresponds to char2b[0]. Needed to draw rectangles if
2730 font_not_found_p is 1. */
2731 struct glyph
*first_glyph
;
2733 /* Image, if any. */
2736 struct glyph_string
*next
, *prev
;
2740 /* Encapsulate the different ways of displaying text under W32. */
2743 w32_text_out (s
, x
, y
,chars
,nchars
)
2744 struct glyph_string
* s
;
2749 int charset_dim
= w32_font_is_double_byte (s
->gc
->font
) ? 2 : 1;
2750 if (s
->gc
->font
->bdf
)
2751 w32_BDF_TextOut (s
->gc
->font
->bdf
, s
->hdc
,
2752 x
, y
, (char *) chars
, charset_dim
,
2753 nchars
* charset_dim
, 0);
2754 else if (s
->first_glyph
->w32_font_type
== UNICODE_FONT
)
2755 ExtTextOutW (s
->hdc
, x
, y
, 0, NULL
, chars
, nchars
, NULL
);
2757 ExtTextOutA (s
->hdc
, x
, y
, 0, NULL
, (char *) chars
,
2758 nchars
* charset_dim
, NULL
);
2764 x_dump_glyph_string (s
)
2765 struct glyph_string
*s
;
2767 fprintf (stderr
, "glyph string\n");
2768 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2769 s
->x
, s
->y
, s
->width
, s
->height
);
2770 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2771 fprintf (stderr
, " hl = %d\n", s
->hl
);
2772 fprintf (stderr
, " left overhang = %d, right = %d\n",
2773 s
->left_overhang
, s
->right_overhang
);
2774 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2775 fprintf (stderr
, " extends to end of line = %d\n",
2776 s
->extends_to_end_of_line_p
);
2777 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2778 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2781 #endif /* GLYPH_DEBUG */
2785 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
2786 struct glyph_string
**,
2787 struct glyph_string
*,
2788 struct glyph_string
*));
2789 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
2790 struct glyph_string
**,
2791 struct glyph_string
*,
2792 struct glyph_string
*));
2793 static void x_append_glyph_string
P_ ((struct glyph_string
**,
2794 struct glyph_string
**,
2795 struct glyph_string
*));
2796 static int x_left_overwritten
P_ ((struct glyph_string
*));
2797 static int x_left_overwriting
P_ ((struct glyph_string
*));
2798 static int x_right_overwritten
P_ ((struct glyph_string
*));
2799 static int x_right_overwriting
P_ ((struct glyph_string
*));
2800 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int, int,
2802 static void w32_init_glyph_string
P_ ((struct glyph_string
*, HDC hdc
,
2803 wchar_t *, struct window
*,
2805 enum glyph_row_area
, int,
2806 enum draw_glyphs_face
));
2807 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
2808 enum glyph_row_area
, int, int,
2809 enum draw_glyphs_face
, int));
2810 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2811 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2812 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2814 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2815 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2816 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2817 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2818 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2819 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2820 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2821 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2822 static void w32_get_glyph_overhangs
P_ ((HDC hdc
, struct glyph
*,
2825 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
2826 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
2827 static void w32_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2828 double, int, COLORREF
));
2829 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2830 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2831 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2832 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2833 static void w32_draw_image_foreground_1
P_ ((struct glyph_string
*, HBITMAP
));
2834 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
2835 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2837 static void w32_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2838 int, int, int, int, RECT
*));
2839 static void w32_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2840 int, int, int, RECT
*));
2841 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
2842 enum glyph_row_area
));
2843 static int x_fill_stretch_glyph_string
P_ ((struct glyph_string
*,
2845 enum glyph_row_area
, int, int));
2848 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
2852 /* Append the list of glyph strings with head H and tail T to the list
2853 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2856 x_append_glyph_string_lists (head
, tail
, h
, t
)
2857 struct glyph_string
**head
, **tail
;
2858 struct glyph_string
*h
, *t
;
2872 /* Prepend the list of glyph strings with head H and tail T to the
2873 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2877 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
2878 struct glyph_string
**head
, **tail
;
2879 struct glyph_string
*h
, *t
;
2893 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2894 Set *HEAD and *TAIL to the resulting list. */
2897 x_append_glyph_string (head
, tail
, s
)
2898 struct glyph_string
**head
, **tail
;
2899 struct glyph_string
*s
;
2901 s
->next
= s
->prev
= NULL
;
2902 x_append_glyph_string_lists (head
, tail
, s
, s
);
2906 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2911 struct glyph_string
*s
;
2913 if (s
->font
== FRAME_FONT (s
->f
)
2914 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2915 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2917 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
2920 /* Cursor on non-default face: must merge. */
2924 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
2925 xgcv
.foreground
= s
->face
->background
;
2927 /* If the glyph would be invisible, try a different foreground. */
2928 if (xgcv
.foreground
== xgcv
.background
)
2929 xgcv
.foreground
= s
->face
->foreground
;
2930 if (xgcv
.foreground
== xgcv
.background
)
2931 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
2932 if (xgcv
.foreground
== xgcv
.background
)
2933 xgcv
.foreground
= s
->face
->foreground
;
2935 /* Make sure the cursor is distinct from text in this face. */
2936 if (xgcv
.background
== s
->face
->background
2937 && xgcv
.foreground
== s
->face
->foreground
)
2939 xgcv
.background
= s
->face
->foreground
;
2940 xgcv
.foreground
= s
->face
->background
;
2943 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2944 xgcv
.font
= s
->font
;
2945 mask
= GCForeground
| GCBackground
| GCFont
;
2947 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2948 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2951 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2952 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
2954 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2959 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2962 x_set_mouse_face_gc (s
)
2963 struct glyph_string
*s
;
2968 /* What face has to be used last for the mouse face? */
2969 face_id
= FRAME_W32_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2970 face
= FACE_FROM_ID (s
->f
, face_id
);
2972 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
2974 if (s
->first_glyph
->type
== CHAR_GLYPH
)
2975 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2977 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
2978 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2979 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2981 /* If font in this face is same as S->font, use it. */
2982 if (s
->font
== s
->face
->font
)
2983 s
->gc
= s
->face
->gc
;
2986 /* Otherwise construct scratch_cursor_gc with values from FACE
2991 xgcv
.background
= s
->face
->background
;
2992 xgcv
.foreground
= s
->face
->foreground
;
2993 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2994 xgcv
.font
= s
->font
;
2995 mask
= GCForeground
| GCBackground
| GCFont
;
2997 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2998 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
3001 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
3002 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
3004 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
3007 xassert (s
->gc
!= 0);
3011 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
3012 Faces to use in the mode line have already been computed when the
3013 matrix was built, so there isn't much to do, here. */
3016 x_set_mode_line_face_gc (s
)
3017 struct glyph_string
*s
;
3019 s
->gc
= s
->face
->gc
;
3023 /* Set S->gc of glyph string S for drawing that glyph string. Set
3024 S->stippled_p to a non-zero value if the face of S has a stipple
3028 x_set_glyph_string_gc (s
)
3029 struct glyph_string
*s
;
3031 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
3033 if (s
->hl
== DRAW_NORMAL_TEXT
)
3035 s
->gc
= s
->face
->gc
;
3036 s
->stippled_p
= s
->face
->stipple
!= 0;
3038 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
3040 x_set_mode_line_face_gc (s
);
3041 s
->stippled_p
= s
->face
->stipple
!= 0;
3043 else if (s
->hl
== DRAW_CURSOR
)
3045 x_set_cursor_gc (s
);
3048 else if (s
->hl
== DRAW_MOUSE_FACE
)
3050 x_set_mouse_face_gc (s
);
3051 s
->stippled_p
= s
->face
->stipple
!= 0;
3053 else if (s
->hl
== DRAW_IMAGE_RAISED
3054 || s
->hl
== DRAW_IMAGE_SUNKEN
)
3056 s
->gc
= s
->face
->gc
;
3057 s
->stippled_p
= s
->face
->stipple
!= 0;
3061 s
->gc
= s
->face
->gc
;
3062 s
->stippled_p
= s
->face
->stipple
!= 0;
3065 /* GC must have been set. */
3066 xassert (s
->gc
!= 0);
3070 /* Return in *R the clipping rectangle for glyph string S. */
3073 w32_get_glyph_string_clip_rect (s
, r
)
3074 struct glyph_string
*s
;
3077 int r_height
, r_width
;
3079 if (s
->row
->full_width_p
)
3081 /* Draw full-width. X coordinates are relative to S->w->left. */
3082 int canon_x
= CANON_X_UNIT (s
->f
);
3084 r
->left
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
3085 r_width
= XFASTINT (s
->w
->width
) * canon_x
;
3087 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
3089 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
3090 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
3094 r
->left
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
3096 /* Unless displaying a mode or menu bar line, which are always
3097 fully visible, clip to the visible part of the row. */
3098 if (s
->w
->pseudo_window_p
)
3099 r_height
= s
->row
->visible_height
;
3101 r_height
= s
->height
;
3105 /* This is a text line that may be partially visible. */
3106 r
->left
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
3107 r_width
= window_box_width (s
->w
, s
->area
);
3108 r_height
= s
->row
->visible_height
;
3111 /* If S draws overlapping rows, it's sufficient to use the top and
3112 bottom of the window for clipping because this glyph string
3113 intentionally draws over other lines. */
3114 if (s
->for_overlaps_p
)
3116 r
->top
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
3117 r_height
= window_text_bottom_y (s
->w
) - r
->top
;
3121 /* Don't use S->y for clipping because it doesn't take partially
3122 visible lines into account. For example, it can be negative for
3123 partially visible lines at the top of a window. */
3124 if (!s
->row
->full_width_p
3125 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
3126 r
->top
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
3128 r
->top
= max (0, s
->row
->y
);
3130 /* If drawing a tool-bar window, draw it over the internal border
3131 at the top of the window. */
3132 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
3133 r
->top
-= s
->f
->output_data
.w32
->internal_border_width
;
3136 r
->top
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->top
);
3138 /* If drawing the cursor, don't let glyph draw outside its
3139 advertised boundaries. Cleartype does this under some circumstances. */
3140 if (s
->hl
== DRAW_CURSOR
)
3144 r_width
-= s
->x
- r
->left
;
3147 r_width
= min (r_width
, s
->first_glyph
->pixel_width
);
3150 r
->bottom
= r
->top
+ r_height
;
3151 r
->right
= r
->left
+ r_width
;
3155 /* Set clipping for output of glyph string S. S may be part of a mode
3156 line or menu if we don't have X toolkit support. */
3159 x_set_glyph_string_clipping (s
)
3160 struct glyph_string
*s
;
3163 w32_get_glyph_string_clip_rect (s
, &r
);
3164 w32_set_clip_rectangle (s
->hdc
, &r
);
3168 /* Compute left and right overhang of glyph string S. If S is a glyph
3169 string for a composition, assume overhangs don't exist. */
3172 x_compute_glyph_string_overhangs (s
)
3173 struct glyph_string
*s
;
3175 /* TODO: Windows does not appear to have a method for
3176 getting this info without getting the ABC widths for each
3177 individual character and working it out manually. */
3181 /* Compute overhangs and x-positions for glyph string S and its
3182 predecessors, or successors. X is the starting x-position for S.
3183 BACKWARD_P non-zero means process predecessors. */
3186 x_compute_overhangs_and_x (s
, x
, backward_p
)
3187 struct glyph_string
*s
;
3195 x_compute_glyph_string_overhangs (s
);
3205 x_compute_glyph_string_overhangs (s
);
3214 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
3215 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
3216 assumed to be zero. */
3219 w32_get_glyph_overhangs (hdc
, glyph
, f
, left
, right
)
3221 struct glyph
*glyph
;
3227 if (glyph
->type
== CHAR_GLYPH
)
3234 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
3238 && (pcm
= w32_per_char_metric (font
, &char2b
,
3239 glyph
->w32_font_type
)))
3241 if (pcm
->rbearing
> pcm
->width
)
3242 *right
= pcm
->rbearing
- pcm
->width
;
3243 if (pcm
->lbearing
< 0)
3244 *left
= -pcm
->lbearing
;
3251 x_get_glyph_overhangs (glyph
, f
, left
, right
)
3252 struct glyph
*glyph
;
3256 HDC hdc
= get_frame_dc (f
);
3257 /* Convert to unicode! */
3258 w32_get_glyph_overhangs (hdc
, glyph
, f
, left
, right
);
3259 release_frame_dc (f
, hdc
);
3263 /* Return the index of the first glyph preceding glyph string S that
3264 is overwritten by S because of S's left overhang. Value is -1
3265 if no glyphs are overwritten. */
3268 x_left_overwritten (s
)
3269 struct glyph_string
*s
;
3273 if (s
->left_overhang
)
3276 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3277 int first
= s
->first_glyph
- glyphs
;
3279 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
3280 x
-= glyphs
[i
].pixel_width
;
3291 /* Return the index of the first glyph preceding glyph string S that
3292 is overwriting S because of its right overhang. Value is -1 if no
3293 glyph in front of S overwrites S. */
3296 x_left_overwriting (s
)
3297 struct glyph_string
*s
;
3300 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3301 int first
= s
->first_glyph
- glyphs
;
3305 for (i
= first
- 1; i
>= 0; --i
)
3308 w32_get_glyph_overhangs (s
->hdc
, glyphs
+ i
, s
->f
, &left
, &right
);
3311 x
-= glyphs
[i
].pixel_width
;
3318 /* Return the index of the last glyph following glyph string S that is
3319 not overwritten by S because of S's right overhang. Value is -1 if
3320 no such glyph is found. */
3323 x_right_overwritten (s
)
3324 struct glyph_string
*s
;
3328 if (s
->right_overhang
)
3331 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3332 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3333 int end
= s
->row
->used
[s
->area
];
3335 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
3336 x
+= glyphs
[i
].pixel_width
;
3345 /* Return the index of the last glyph following glyph string S that
3346 overwrites S because of its left overhang. Value is negative
3347 if no such glyph is found. */
3350 x_right_overwriting (s
)
3351 struct glyph_string
*s
;
3354 int end
= s
->row
->used
[s
->area
];
3355 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3356 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3360 for (i
= first
; i
< end
; ++i
)
3363 w32_get_glyph_overhangs (s
->hdc
, glyphs
+ i
, s
->f
, &left
, &right
);
3366 x
+= glyphs
[i
].pixel_width
;
3373 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3376 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
3377 struct glyph_string
*s
;
3385 /* Take clipping into account. */
3386 if (s
->gc
->clip_mask
== Rect
)
3388 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
3389 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
3390 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
3391 - s
->gc
->clip_rectangle
.left
);
3392 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
3393 - s
->gc
->clip_rectangle
.top
);
3396 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
3401 /* Draw the background of glyph_string S. If S->background_filled_p
3402 is non-zero don't draw it. FORCE_P non-zero means draw the
3403 background even if it wouldn't be drawn normally. This is used
3404 when a string preceding S draws into the background of S, or S
3405 contains the first component of a composition. */
3408 x_draw_glyph_string_background (s
, force_p
)
3409 struct glyph_string
*s
;
3412 /* Nothing to do if background has already been drawn or if it
3413 shouldn't be drawn in the first place. */
3414 if (!s
->background_filled_p
)
3416 int box_line_width
= max (s
->face
->box_line_width
, 0);
3418 #if 0 /* TODO: stipple */
3421 /* Fill background with a stipple pattern. */
3422 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3423 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
3424 s
->y
+ box_line_width
,
3425 s
->background_width
,
3426 s
->height
- 2 * box_line_width
);
3427 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3428 s
->background_filled_p
= 1;
3432 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
3433 || s
->font_not_found_p
3434 || s
->extends_to_end_of_line_p
3438 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
3439 s
->background_width
,
3440 s
->height
- 2 * box_line_width
);
3441 s
->background_filled_p
= 1;
3447 /* Draw the foreground of glyph string S. */
3450 x_draw_glyph_string_foreground (s
)
3451 struct glyph_string
*s
;
3456 /* If first glyph of S has a left box line, start drawing the text
3457 of S to the right of that box line. */
3458 if (s
->face
->box
!= FACE_NO_BOX
3459 && s
->first_glyph
->left_box_line_p
)
3460 x
= s
->x
+ abs (s
->face
->box_line_width
);
3464 if (s
->for_overlaps_p
|| (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3465 SetBkMode (s
->hdc
, TRANSPARENT
);
3467 SetBkMode (s
->hdc
, OPAQUE
);
3469 SetTextColor (s
->hdc
, s
->gc
->foreground
);
3470 SetBkColor (s
->hdc
, s
->gc
->background
);
3471 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
3473 if (s
->font
&& s
->font
->hfont
)
3474 old_font
= SelectObject (s
->hdc
, s
->font
->hfont
);
3476 /* Draw characters of S as rectangles if S's font could not be
3478 if (s
->font_not_found_p
)
3480 for (i
= 0; i
< s
->nchars
; ++i
)
3482 struct glyph
*g
= s
->first_glyph
+ i
;
3484 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3486 x
+= g
->pixel_width
;
3491 char *char1b
= (char *) s
->char2b
;
3492 int boff
= s
->font_info
->baseline_offset
;
3494 if (s
->font_info
->vertical_centering
)
3495 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3497 /* If we can use 8-bit functions, condense S->char2b. */
3499 for (i
= 0; i
< s
->nchars
; ++i
)
3500 char1b
[i
] = BYTE2 (s
->char2b
[i
]);
3502 /* Draw text with TextOut and friends. */
3503 w32_text_out (s
, x
, s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3505 if (s
->font
&& s
->font
->hfont
)
3506 SelectObject (s
->hdc
, old_font
);
3509 /* Draw the foreground of composite glyph string S. */
3512 x_draw_composite_glyph_string_foreground (s
)
3513 struct glyph_string
*s
;
3518 /* If first glyph of S has a left box line, start drawing the text
3519 of S to the right of that box line. */
3520 if (s
->face
->box
!= FACE_NO_BOX
3521 && s
->first_glyph
->left_box_line_p
)
3522 x
= s
->x
+ abs (s
->face
->box_line_width
);
3526 /* S is a glyph string for a composition. S->gidx is the index of
3527 the first character drawn for glyphs of this composition.
3528 S->gidx == 0 means we are drawing the very first character of
3529 this composition. */
3531 SetTextColor (s
->hdc
, s
->gc
->foreground
);
3532 SetBkColor (s
->hdc
, s
->gc
->background
);
3533 SetBkMode (s
->hdc
, TRANSPARENT
);
3534 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
3536 if (s
->font
&& s
->font
->hfont
)
3537 old_font
= SelectObject (s
->hdc
, s
->font
->hfont
);
3539 /* Draw a rectangle for the composition if the font for the very
3540 first character of the composition could not be loaded. */
3541 if (s
->font_not_found_p
)
3544 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
3549 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3550 w32_text_out (s
, x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3551 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3554 if (s
->font
&& s
->font
->hfont
)
3555 SelectObject (s
->hdc
, old_font
);
3559 /* Brightness beyond which a color won't have its highlight brightness
3562 Nominally, highlight colors for `3d' faces are calculated by
3563 brightening an object's color by a constant scale factor, but this
3564 doesn't yield good results for dark colors, so for colors who's
3565 brightness is less than this value (on a scale of 0-255) have to
3566 use an additional additive factor.
3568 The value here is set so that the default menu-bar/mode-line color
3569 (grey75) will not have its highlights changed at all. */
3570 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
3573 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
3574 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3575 If this produces the same color as COLOR, try a color where all RGB
3576 values have DELTA added. Return the allocated color in *COLOR.
3577 DISPLAY is the X display, CMAP is the colormap to operate on.
3578 Value is non-zero if successful. */
3581 w32_alloc_lighter_color (f
, color
, factor
, delta
)
3590 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
3593 /* Change RGB values by specified FACTOR. Avoid overflow! */
3594 xassert (factor
>= 0);
3595 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
3596 min (0xff, factor
* GetGValue (*color
)),
3597 min (0xff, factor
* GetBValue (*color
)));
3599 /* Calculate brightness of COLOR. */
3600 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
3601 + GetBValue (*color
)) / 6;
3603 /* We only boost colors that are darker than
3604 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3605 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
3606 /* Make an additive adjustment to NEW, because it's dark enough so
3607 that scaling by FACTOR alone isn't enough. */
3609 /* How far below the limit this color is (0 - 1, 1 being darker). */
3610 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
3611 /* The additive adjustment. */
3612 int min_delta
= delta
* dimness
* factor
/ 2;
3615 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
3616 max (0, min (0xff, min_delta
- GetGValue (*color
))),
3617 max (0, min (0xff, min_delta
- GetBValue (*color
))));
3619 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
3620 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
3621 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
3625 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
3626 max (0, min (0xff, delta
+ GetGValue (*color
))),
3627 max (0, min (0xff, delta
+ GetBValue (*color
))));
3629 /* TODO: Map to palette and retry with delta if same? */
3630 /* TODO: Free colors (if using palette)? */
3641 /* Set up the foreground color for drawing relief lines of glyph
3642 string S. RELIEF is a pointer to a struct relief containing the GC
3643 with which lines will be drawn. Use a color that is FACTOR or
3644 DELTA lighter or darker than the relief's background which is found
3645 in S->f->output_data.x->relief_background. If such a color cannot
3646 be allocated, use DEFAULT_PIXEL, instead. */
3649 w32_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3651 struct relief
*relief
;
3654 COLORREF default_pixel
;
3657 struct w32_output
*di
= f
->output_data
.w32
;
3658 unsigned long mask
= GCForeground
;
3660 COLORREF background
= di
->relief_background
;
3661 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
3663 /* TODO: Free colors (if using palette)? */
3665 /* Allocate new color. */
3666 xgcv
.foreground
= default_pixel
;
3668 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
3670 relief
->allocated_p
= 1;
3671 xgcv
.foreground
= relief
->pixel
= pixel
;
3674 if (relief
->gc
== 0)
3676 #if 0 /* TODO: stipple */
3677 xgcv
.stipple
= dpyinfo
->gray
;
3680 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
3683 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
3687 /* Set up colors for the relief lines around glyph string S. */
3690 x_setup_relief_colors (s
)
3691 struct glyph_string
*s
;
3693 struct w32_output
*di
= s
->f
->output_data
.w32
;
3696 if (s
->face
->use_box_color_for_shadows_p
)
3697 color
= s
->face
->box_color
;
3698 else if (s
->first_glyph
->type
== IMAGE_GLYPH
3700 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
3701 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
3703 color
= s
->gc
->background
;
3705 if (di
->white_relief
.gc
== 0
3706 || color
!= di
->relief_background
)
3708 di
->relief_background
= color
;
3709 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3710 WHITE_PIX_DEFAULT (s
->f
));
3711 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3712 BLACK_PIX_DEFAULT (s
->f
));
3717 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3718 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3719 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3720 relief. LEFT_P non-zero means draw a relief on the left side of
3721 the rectangle. RIGHT_P non-zero means draw a relief on the right
3722 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3726 w32_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3727 raised_p
, left_p
, right_p
, clip_rect
)
3729 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
3734 HDC hdc
= get_frame_dc (f
);
3737 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
3739 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
3741 w32_set_clip_rectangle (hdc
, clip_rect
);
3744 for (i
= 0; i
< width
; ++i
)
3745 w32_fill_area (f
, hdc
, gc
.foreground
,
3746 left_x
+ i
* left_p
, top_y
+ i
,
3747 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
3751 for (i
= 0; i
< width
; ++i
)
3752 w32_fill_area (f
, hdc
, gc
.foreground
,
3753 left_x
+ i
, top_y
+ i
, 1,
3754 bottom_y
- top_y
- 2 * i
+ 1);
3757 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
3759 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
3762 for (i
= 0; i
< width
; ++i
)
3763 w32_fill_area (f
, hdc
, gc
.foreground
,
3764 left_x
+ i
* left_p
, bottom_y
- i
,
3765 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
3769 for (i
= 0; i
< width
; ++i
)
3770 w32_fill_area (f
, hdc
, gc
.foreground
,
3771 right_x
- i
, top_y
+ i
+ 1, 1,
3772 bottom_y
- top_y
- 2 * i
- 1);
3774 w32_set_clip_rectangle (hdc
, NULL
);
3776 release_frame_dc (f
, hdc
);
3780 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3781 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3782 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3783 left side of the rectangle. RIGHT_P non-zero means draw a line
3784 on the right side of the rectangle. CLIP_RECT is the clipping
3785 rectangle to use when drawing. */
3788 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3789 left_p
, right_p
, clip_rect
)
3790 struct glyph_string
*s
;
3791 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
3794 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
3797 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3798 left_x
, top_y
, right_x
- left_x
+ 1, width
);
3803 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3804 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
3808 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3809 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
3814 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3815 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
3818 w32_set_clip_rectangle (s
->hdc
, NULL
);
3822 /* Draw a box around glyph string S. */
3825 x_draw_glyph_string_box (s
)
3826 struct glyph_string
*s
;
3828 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3829 int left_p
, right_p
;
3830 struct glyph
*last_glyph
;
3833 last_x
= window_box_right (s
->w
, s
->area
);
3834 if (s
->row
->full_width_p
3835 && !s
->w
->pseudo_window_p
)
3837 last_x
+= FRAME_X_RIGHT_FRINGE_WIDTH (s
->f
);
3838 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
3839 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
3842 /* The glyph that may have a right box line. */
3843 last_glyph
= (s
->cmp
|| s
->img
3845 : s
->first_glyph
+ s
->nchars
- 1);
3847 width
= abs (s
->face
->box_line_width
);
3848 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
3850 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
3852 : min (last_x
, s
->x
+ s
->background_width
) - 1));
3854 bottom_y
= top_y
+ s
->height
- 1;
3856 left_p
= (s
->first_glyph
->left_box_line_p
3857 || (s
->hl
== DRAW_MOUSE_FACE
3859 || s
->prev
->hl
!= s
->hl
)));
3860 right_p
= (last_glyph
->right_box_line_p
3861 || (s
->hl
== DRAW_MOUSE_FACE
3863 || s
->next
->hl
!= s
->hl
)));
3865 w32_get_glyph_string_clip_rect (s
, &clip_rect
);
3867 if (s
->face
->box
== FACE_SIMPLE_BOX
)
3868 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3869 left_p
, right_p
, &clip_rect
);
3872 x_setup_relief_colors (s
);
3873 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
3874 width
, raised_p
, left_p
, right_p
, &clip_rect
);
3879 /* Draw foreground of image glyph string S. */
3882 x_draw_image_foreground (s
)
3883 struct glyph_string
*s
;
3886 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3888 /* If first glyph of S has a left box line, start drawing it to the
3889 right of that line. */
3890 if (s
->face
->box
!= FACE_NO_BOX
3891 && s
->first_glyph
->left_box_line_p
)
3892 x
= s
->x
+ abs (s
->face
->box_line_width
);
3896 /* If there is a margin around the image, adjust x- and y-position
3898 x
+= s
->img
->hmargin
;
3899 y
+= s
->img
->vmargin
;
3905 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
3906 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
3907 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
3908 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
3909 SetBkColor (compat_hdc
, RGB (255, 255, 255));
3910 SetTextColor (s
->hdc
, RGB (0, 0, 0));
3911 x_set_glyph_string_clipping (s
);
3915 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
3916 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
3918 SetTextColor (s
->hdc
, RGB (255, 255, 255));
3919 SetBkColor (s
->hdc
, RGB (0, 0, 0));
3921 BitBlt (s
->hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3922 compat_hdc
, 0, 0, SRCINVERT
);
3923 BitBlt (s
->hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3924 mask_dc
, 0, 0, SRCAND
);
3925 BitBlt (s
->hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3926 compat_hdc
, 0, 0, SRCINVERT
);
3928 SelectObject (mask_dc
, mask_orig_obj
);
3933 SetTextColor (s
->hdc
, s
->gc
->foreground
);
3934 SetBkColor (s
->hdc
, s
->gc
->background
);
3936 BitBlt (s
->hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3937 compat_hdc
, 0, 0, SRCCOPY
);
3939 /* When the image has a mask, we can expect that at
3940 least part of a mouse highlight or a block cursor will
3941 be visible. If the image doesn't have a mask, make
3942 a block cursor visible by drawing a rectangle around
3943 the image. I believe it's looking better if we do
3944 nothing here for mouse-face. */
3945 if (s
->hl
== DRAW_CURSOR
)
3947 int r
= s
->img
->relief
;
3949 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
3950 s
->img
->width
+ r
*2 - 1, s
->img
->height
+ r
*2 - 1);
3954 w32_set_clip_rectangle (s
->hdc
, NULL
);
3955 SelectObject (s
->hdc
, orig_brush
);
3956 DeleteObject (fg_brush
);
3957 SelectObject (compat_hdc
, orig_obj
);
3958 DeleteDC (compat_hdc
);
3961 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
, s
->img
->width
-1,
3962 s
->img
->height
- 1);
3964 RestoreDC (s
->hdc
,-1);
3969 /* Draw a relief around the image glyph string S. */
3972 x_draw_image_relief (s
)
3973 struct glyph_string
*s
;
3975 int x0
, y0
, x1
, y1
, thick
, raised_p
;
3978 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3980 /* If first glyph of S has a left box line, start drawing it to the
3981 right of that line. */
3982 if (s
->face
->box
!= FACE_NO_BOX
3983 && s
->first_glyph
->left_box_line_p
)
3984 x
= s
->x
+ abs (s
->face
->box_line_width
);
3988 /* If there is a margin around the image, adjust x- and y-position
3990 x
+= s
->img
->hmargin
;
3991 y
+= s
->img
->vmargin
;
3993 if (s
->hl
== DRAW_IMAGE_SUNKEN
3994 || s
->hl
== DRAW_IMAGE_RAISED
)
3996 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
3997 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
4001 thick
= abs (s
->img
->relief
);
4002 raised_p
= s
->img
->relief
> 0;
4007 x1
= x
+ s
->img
->width
+ thick
- 1;
4008 y1
= y
+ s
->img
->height
+ thick
- 1;
4010 x_setup_relief_colors (s
);
4011 w32_get_glyph_string_clip_rect (s
, &r
);
4012 w32_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
4016 /* Draw the foreground of image glyph string S to PIXMAP. */
4019 w32_draw_image_foreground_1 (s
, pixmap
)
4020 struct glyph_string
*s
;
4023 HDC hdc
= CreateCompatibleDC (s
->hdc
);
4024 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
4026 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
);
4028 /* If first glyph of S has a left box line, start drawing it to the
4029 right of that line. */
4030 if (s
->face
->box
!= FACE_NO_BOX
4031 && s
->first_glyph
->left_box_line_p
)
4032 x
= abs (s
->face
->box_line_width
);
4036 /* If there is a margin around the image, adjust x- and y-position
4038 x
+= s
->img
->hmargin
;
4039 y
+= s
->img
->vmargin
;
4043 HDC compat_hdc
= CreateCompatibleDC (hdc
);
4044 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
4045 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
4046 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
4050 HDC mask_dc
= CreateCompatibleDC (hdc
);
4051 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
4053 SetTextColor (hdc
, RGB (0, 0, 0));
4054 SetBkColor (hdc
, RGB (255, 255, 255));
4055 BitBlt (hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
4056 compat_hdc
, 0, 0, SRCINVERT
);
4057 BitBlt (hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
4058 mask_dc
, 0, 0, SRCAND
);
4059 BitBlt (hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
4060 compat_hdc
, 0, 0, SRCINVERT
);
4062 SelectObject (mask_dc
, mask_orig_obj
);
4067 SetTextColor (hdc
, s
->gc
->foreground
);
4068 SetBkColor (hdc
, s
->gc
->background
);
4070 BitBlt (hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
4071 compat_hdc
, 0, 0, SRCCOPY
);
4073 /* When the image has a mask, we can expect that at
4074 least part of a mouse highlight or a block cursor will
4075 be visible. If the image doesn't have a mask, make
4076 a block cursor visible by drawing a rectangle around
4077 the image. I believe it's looking better if we do
4078 nothing here for mouse-face. */
4079 if (s
->hl
== DRAW_CURSOR
)
4081 int r
= s
->img
->relief
;
4083 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
4084 s
->img
->width
+ r
*2 - 1, s
->img
->height
+ r
*2 - 1);
4088 SelectObject (hdc
, orig_brush
);
4089 DeleteObject (fg_brush
);
4090 SelectObject (compat_hdc
, orig_obj
);
4091 DeleteDC (compat_hdc
);
4094 w32_draw_rectangle (hdc
, s
->gc
, x
, y
, s
->img
->width
- 1,
4095 s
->img
->height
- 1);
4097 SelectObject (hdc
, orig_hdc_obj
);
4102 /* Draw part of the background of glyph string S. X, Y, W, and H
4103 give the rectangle to draw. */
4106 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
4107 struct glyph_string
*s
;
4110 #if 0 /* TODO: stipple */
4113 /* Fill background with a stipple pattern. */
4114 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4115 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
4116 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4120 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
4124 /* Draw image glyph string S.
4127 s->x +-------------------------
4130 | +-------------------------
4133 | | +-------------------
4139 x_draw_image_glyph_string (s
)
4140 struct glyph_string
*s
;
4143 int box_line_hwidth
= abs (s
->face
->box_line_width
);
4144 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
4148 height
= s
->height
- 2 * box_line_vwidth
;
4150 /* Fill background with face under the image. Do it only if row is
4151 taller than image or if image has a clip mask to reduce
4153 s
->stippled_p
= s
->face
->stipple
!= 0;
4154 if (height
> s
->img
->height
4158 || s
->img
->pixmap
== 0
4159 || s
->width
!= s
->background_width
)
4161 if (box_line_hwidth
&& s
->first_glyph
->left_box_line_p
)
4162 x
= s
->x
+ box_line_hwidth
;
4166 y
= s
->y
+ box_line_vwidth
;
4167 #if 0 /* TODO: figure out if we need to do this on Windows. */
4170 /* Create a pixmap as large as the glyph string. Fill it
4171 with the background color. Copy the image to it, using
4172 its mask. Copy the temporary pixmap to the display. */
4173 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
4174 int depth
= DefaultDepthOfScreen (screen
);
4176 /* Create a pixmap as large as the glyph string. */
4177 pixmap
= XCreatePixmap (s
->display
, s
->window
,
4178 s
->background_width
,
4181 /* Don't clip in the following because we're working on the
4183 XSetClipMask (s
->display
, s
->gc
, None
);
4185 /* Fill the pixmap with the background color/stipple. */
4188 /* Fill background with a stipple pattern. */
4189 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4190 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4191 0, 0, s
->background_width
, s
->height
);
4192 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4197 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
4199 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
4200 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4201 0, 0, s
->background_width
, s
->height
);
4202 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4207 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
4209 s
->background_filled_p
= 1;
4212 /* Draw the foreground. */
4215 w32_draw_image_foreground_1 (s
, pixmap
);
4216 x_set_glyph_string_clipping (s
);
4218 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
4219 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
4220 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
4221 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
4223 SetTextColor (s
->hdc
, s
->gc
->foreground
);
4224 SetBkColor (s
->hdc
, s
->gc
->background
);
4225 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
4226 compat_hdc
, 0, 0, SRCCOPY
);
4228 SelectObject (s
->hdc
, orig_brush
);
4229 DeleteObject (fg_brush
);
4230 SelectObject (compat_hdc
, orig_obj
);
4231 DeleteDC (compat_hdc
);
4233 DeleteObject (pixmap
);
4237 x_draw_image_foreground (s
);
4239 /* If we must draw a relief around the image, do it. */
4241 || s
->hl
== DRAW_IMAGE_RAISED
4242 || s
->hl
== DRAW_IMAGE_SUNKEN
)
4243 x_draw_image_relief (s
);
4247 /* Draw stretch glyph string S. */
4250 x_draw_stretch_glyph_string (s
)
4251 struct glyph_string
*s
;
4253 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4254 s
->stippled_p
= s
->face
->stipple
!= 0;
4256 if (s
->hl
== DRAW_CURSOR
4257 && !x_stretch_cursor_p
)
4259 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4260 as wide as the stretch glyph. */
4261 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
4264 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
4266 /* Clear rest using the GC of the original non-cursor face. */
4267 if (width
< s
->background_width
)
4269 XGCValues
*gc
= s
->face
->gc
;
4270 int x
= s
->x
+ width
, y
= s
->y
;
4271 int w
= s
->background_width
- width
, h
= s
->height
;
4275 if (s
->row
->mouse_face_p
4276 && cursor_in_mouse_face_p (s
->w
))
4278 x_set_mouse_face_gc (s
);
4284 w32_get_glyph_string_clip_rect (s
, &r
);
4285 w32_set_clip_rectangle (hdc
, &r
);
4287 #if 0 /* TODO: stipple */
4288 if (s
->face
->stipple
)
4290 /* Fill background with a stipple pattern. */
4291 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
4292 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4293 XSetFillStyle (s
->display
, gc
, FillSolid
);
4298 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
4302 else if (!s
->background_filled_p
)
4303 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
4306 s
->background_filled_p
= 1;
4310 /* Draw glyph string S. */
4313 x_draw_glyph_string (s
)
4314 struct glyph_string
*s
;
4316 int relief_drawn_p
= 0;
4318 /* If S draws into the background of its successor, draw the
4319 background of the successor first so that S can draw into it.
4320 This makes S->next use XDrawString instead of XDrawImageString. */
4321 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
4323 xassert (s
->next
->img
== NULL
);
4324 x_set_glyph_string_gc (s
->next
);
4325 x_set_glyph_string_clipping (s
->next
);
4326 x_draw_glyph_string_background (s
->next
, 1);
4329 /* Set up S->gc, set clipping and draw S. */
4330 x_set_glyph_string_gc (s
);
4332 /* Draw relief (if any) in advance for char/composition so that the
4333 glyph string can be drawn over it. */
4334 if (!s
->for_overlaps_p
4335 && s
->face
->box
!= FACE_NO_BOX
4336 && (s
->first_glyph
->type
== CHAR_GLYPH
4337 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
4340 x_set_glyph_string_clipping (s
);
4341 x_draw_glyph_string_background (s
, 1);
4342 x_draw_glyph_string_box (s
);
4343 x_set_glyph_string_clipping (s
);
4347 x_set_glyph_string_clipping (s
);
4349 switch (s
->first_glyph
->type
)
4352 x_draw_image_glyph_string (s
);
4356 x_draw_stretch_glyph_string (s
);
4360 if (s
->for_overlaps_p
)
4361 s
->background_filled_p
= 1;
4363 x_draw_glyph_string_background (s
, 0);
4364 x_draw_glyph_string_foreground (s
);
4367 case COMPOSITE_GLYPH
:
4368 if (s
->for_overlaps_p
|| s
->gidx
> 0)
4369 s
->background_filled_p
= 1;
4371 x_draw_glyph_string_background (s
, 1);
4372 x_draw_composite_glyph_string_foreground (s
);
4379 if (!s
->for_overlaps_p
)
4381 /* Draw underline. */
4382 if (s
->face
->underline_p
4383 && (s
->font
->bdf
|| !s
->font
->tm
.tmUnderlined
))
4385 unsigned long h
= 1;
4386 unsigned long dy
= s
->height
- h
;
4388 /* TODO: Use font information for positioning and thickness
4389 of underline. See OUTLINETEXTMETRIC, and xterm.c. */
4390 if (s
->face
->underline_defaulted_p
)
4392 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
4393 s
->y
+ dy
, s
->width
, 1);
4397 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
4398 s
->y
+ dy
, s
->width
, 1);
4402 /* Draw overline. */
4403 if (s
->face
->overline_p
)
4405 unsigned long dy
= 0, h
= 1;
4407 if (s
->face
->overline_color_defaulted_p
)
4409 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
4410 s
->y
+ dy
, s
->width
, h
);
4414 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
4415 s
->y
+ dy
, s
->width
, h
);
4419 /* Draw strike-through. */
4420 if (s
->face
->strike_through_p
4421 && (s
->font
->bdf
|| !s
->font
->tm
.tmStruckOut
))
4423 unsigned long h
= 1;
4424 unsigned long dy
= (s
->height
- h
) / 2;
4426 if (s
->face
->strike_through_color_defaulted_p
)
4428 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
4433 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
4434 s
->y
+ dy
, s
->width
, h
);
4439 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
4440 x_draw_glyph_string_box (s
);
4443 /* Reset clipping. */
4444 w32_set_clip_rectangle (s
->hdc
, NULL
);
4448 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4449 struct face
**, int));
4452 /* Fill glyph string S with composition components specified by S->cmp.
4454 FACES is an array of faces for all components of this composition.
4455 S->gidx is the index of the first component for S.
4456 OVERLAPS_P non-zero means S should draw the foreground only, and
4457 use its physical height for clipping.
4459 Value is the index of a component not in S. */
4462 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4463 struct glyph_string
*s
;
4464 struct face
**faces
;
4471 s
->for_overlaps_p
= overlaps_p
;
4473 s
->face
= faces
[s
->gidx
];
4474 s
->font
= s
->face
->font
;
4475 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4477 /* For all glyphs of this composition, starting at the offset
4478 S->gidx, until we reach the end of the definition or encounter a
4479 glyph that requires the different face, add it to S. */
4481 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4484 /* All glyph strings for the same composition has the same width,
4485 i.e. the width set for the first component of the composition. */
4487 s
->width
= s
->first_glyph
->pixel_width
;
4489 /* If the specified font could not be loaded, use the frame's
4490 default font, but record the fact that we couldn't load it in
4491 the glyph string so that we can draw rectangles for the
4492 characters of the glyph string. */
4493 if (s
->font
== NULL
)
4495 s
->font_not_found_p
= 1;
4496 s
->font
= FRAME_FONT (s
->f
);
4499 /* Adjust base line for subscript/superscript text. */
4500 s
->ybase
+= s
->first_glyph
->voffset
;
4502 xassert (s
->face
&& s
->face
->gc
);
4504 /* This glyph string must always be drawn with 16-bit functions. */
4507 return s
->gidx
+ s
->nchars
;
4511 /* Fill glyph string S from a sequence of character glyphs.
4513 FACE_ID is the face id of the string. START is the index of the
4514 first glyph to consider, END is the index of the last + 1.
4515 OVERLAPS_P non-zero means S should draw the foreground only, and
4516 use its physical height for clipping.
4518 Value is the index of the first glyph not in S. */
4521 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4522 struct glyph_string
*s
;
4524 int start
, end
, overlaps_p
;
4526 struct glyph
*glyph
, *last
;
4528 int glyph_not_available_p
;
4530 xassert (s
->f
== XFRAME (s
->w
->frame
));
4531 xassert (s
->nchars
== 0);
4532 xassert (start
>= 0 && end
> start
);
4534 s
->for_overlaps_p
= overlaps_p
;
4535 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4536 last
= s
->row
->glyphs
[s
->area
] + end
;
4537 voffset
= glyph
->voffset
;
4539 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4542 && glyph
->type
== CHAR_GLYPH
4543 && glyph
->voffset
== voffset
4544 /* Same face id implies same font, nowadays. */
4545 && glyph
->face_id
== face_id
4546 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4550 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4551 s
->char2b
+ s
->nchars
,
4553 s
->two_byte_p
= two_byte_p
;
4555 xassert (s
->nchars
<= end
- start
);
4556 s
->width
+= glyph
->pixel_width
;
4560 s
->font
= s
->face
->font
;
4561 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4563 /* If the specified font could not be loaded, use the frame's font,
4564 but record the fact that we couldn't load it in
4565 S->font_not_found_p so that we can draw rectangles for the
4566 characters of the glyph string. */
4567 if (s
->font
== NULL
|| glyph_not_available_p
)
4569 s
->font_not_found_p
= 1;
4570 s
->font
= FRAME_FONT (s
->f
);
4573 /* Adjust base line for subscript/superscript text. */
4574 s
->ybase
+= voffset
;
4576 xassert (s
->face
&& s
->face
->gc
);
4577 return glyph
- s
->row
->glyphs
[s
->area
];
4581 /* Fill glyph string S from image glyph S->first_glyph. */
4584 x_fill_image_glyph_string (s
)
4585 struct glyph_string
*s
;
4587 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4588 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4590 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4591 s
->font
= s
->face
->font
;
4592 s
->width
= s
->first_glyph
->pixel_width
;
4594 /* Adjust base line for subscript/superscript text. */
4595 s
->ybase
+= s
->first_glyph
->voffset
;
4599 /* Fill glyph string S from a sequence of stretch glyphs.
4601 ROW is the glyph row in which the glyphs are found, AREA is the
4602 area within the row. START is the index of the first glyph to
4603 consider, END is the index of the last + 1.
4605 Value is the index of the first glyph not in S. */
4608 x_fill_stretch_glyph_string (s
, row
, area
, start
, end
)
4609 struct glyph_string
*s
;
4610 struct glyph_row
*row
;
4611 enum glyph_row_area area
;
4614 struct glyph
*glyph
, *last
;
4615 int voffset
, face_id
;
4617 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4619 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4620 last
= s
->row
->glyphs
[s
->area
] + end
;
4621 face_id
= glyph
->face_id
;
4622 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
4623 s
->font
= s
->face
->font
;
4624 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4625 s
->width
= glyph
->pixel_width
;
4626 voffset
= glyph
->voffset
;
4630 && glyph
->type
== STRETCH_GLYPH
4631 && glyph
->voffset
== voffset
4632 && glyph
->face_id
== face_id
);
4634 s
->width
+= glyph
->pixel_width
;
4636 /* Adjust base line for subscript/superscript text. */
4637 s
->ybase
+= voffset
;
4640 return glyph
- s
->row
->glyphs
[s
->area
];
4644 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4645 of XChar2b structures for S; it can't be allocated in
4646 x_init_glyph_string because it must be allocated via `alloca'. W
4647 is the window on which S is drawn. ROW and AREA are the glyph row
4648 and area within the row from which S is constructed. START is the
4649 index of the first glyph structure covered by S. HL is a
4650 face-override for drawing S. */
4653 w32_init_glyph_string (s
, hdc
, char2b
, w
, row
, area
, start
, hl
)
4654 struct glyph_string
*s
;
4658 struct glyph_row
*row
;
4659 enum glyph_row_area area
;
4661 enum draw_glyphs_face hl
;
4663 bzero (s
, sizeof *s
);
4665 s
->f
= XFRAME (w
->frame
);
4667 s
->window
= FRAME_W32_WINDOW (s
->f
);
4672 s
->first_glyph
= row
->glyphs
[area
] + start
;
4673 s
->height
= row
->height
;
4674 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4676 /* Display the internal border below the tool-bar window. */
4677 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4678 s
->y
-= s
->f
->output_data
.w32
->internal_border_width
;
4680 s
->ybase
= s
->y
+ row
->ascent
;
4684 /* Set background width of glyph string S. START is the index of the
4685 first glyph following S. LAST_X is the right-most x-position + 1
4686 in the drawing area. */
4689 x_set_glyph_string_background_width (s
, start
, last_x
)
4690 struct glyph_string
*s
;
4694 /* If the face of this glyph string has to be drawn to the end of
4695 the drawing area, set S->extends_to_end_of_line_p. */
4696 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4698 if (start
== s
->row
->used
[s
->area
]
4699 && s
->area
== TEXT_AREA
4700 && ((s
->hl
== DRAW_NORMAL_TEXT
4701 && (s
->row
->fill_line_p
4702 || s
->face
->background
!= default_face
->background
4703 || s
->face
->stipple
!= default_face
->stipple
4704 || s
->row
->mouse_face_p
))
4705 || s
->hl
== DRAW_MOUSE_FACE
4706 || ((s
->hl
== DRAW_IMAGE_RAISED
|| s
->hl
== DRAW_IMAGE_SUNKEN
)
4707 && s
->row
->fill_line_p
)))
4708 s
->extends_to_end_of_line_p
= 1;
4710 /* If S extends its face to the end of the line, set its
4711 background_width to the distance to the right edge of the drawing
4713 if (s
->extends_to_end_of_line_p
)
4714 s
->background_width
= last_x
- s
->x
+ 1;
4716 s
->background_width
= s
->width
;
4720 /* Add a glyph string for a stretch glyph to the list of strings
4721 between HEAD and TAIL. START is the index of the stretch glyph in
4722 row area AREA of glyph row ROW. END is the index of the last glyph
4723 in that glyph row area. X is the current output position assigned
4724 to the new glyph string constructed. HL overrides that face of the
4725 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4726 is the right-most x-position of the drawing area. */
4728 #define BUILD_STRETCH_GLYPH_STRING(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4731 s = (struct glyph_string *) alloca (sizeof *s); \
4732 w32_init_glyph_string (s, hdc, NULL, W, ROW, AREA, START, HL); \
4733 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4734 x_append_glyph_string (&HEAD, &TAIL, s); \
4740 /* Add a glyph string for an image glyph to the list of strings
4741 between HEAD and TAIL. START is the index of the image glyph in
4742 row area AREA of glyph row ROW. END is the index of the last glyph
4743 in that glyph row area. X is the current output position assigned
4744 to the new glyph string constructed. HL overrides that face of the
4745 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4746 is the right-most x-position of the drawing area. */
4748 #define BUILD_IMAGE_GLYPH_STRING(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4751 s = (struct glyph_string *) alloca (sizeof *s); \
4752 w32_init_glyph_string (s, hdc, NULL, W, ROW, AREA, START, HL); \
4753 x_fill_image_glyph_string (s); \
4754 x_append_glyph_string (&HEAD, &TAIL, s); \
4761 /* Add a glyph string for a sequence of character glyphs to the list
4762 of strings between HEAD and TAIL. START is the index of the first
4763 glyph in row area AREA of glyph row ROW that is part of the new
4764 glyph string. END is the index of the last glyph in that glyph row
4765 area. X is the current output position assigned to the new glyph
4766 string constructed. HL overrides that face of the glyph; e.g. it
4767 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4768 right-most x-position of the drawing area. */
4770 #define BUILD_CHAR_GLYPH_STRINGS(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4776 c = (ROW)->glyphs[AREA][START].u.ch; \
4777 face_id = (ROW)->glyphs[AREA][START].face_id; \
4779 s = (struct glyph_string *) alloca (sizeof *s); \
4780 char2b = (wchar_t *) alloca ((END - START) * sizeof *char2b); \
4781 w32_init_glyph_string (s, hdc, char2b, W, ROW, AREA, START, HL); \
4782 x_append_glyph_string (&HEAD, &TAIL, s); \
4784 START = x_fill_glyph_string (s, face_id, START, END, \
4790 /* Add a glyph string for a composite sequence to the list of strings
4791 between HEAD and TAIL. START is the index of the first glyph in
4792 row area AREA of glyph row ROW that is part of the new glyph
4793 string. END is the index of the last glyph in that glyph row area.
4794 X is the current output position assigned to the new glyph string
4795 constructed. HL overrides that face of the glyph; e.g. it is
4796 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4797 x-position of the drawing area. */
4799 #define BUILD_COMPOSITE_GLYPH_STRING(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4801 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4802 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4803 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4804 struct composition *cmp = composition_table[cmp_id]; \
4805 int glyph_len = cmp->glyph_len; \
4807 struct face **faces; \
4808 struct glyph_string *first_s = NULL; \
4811 base_face = base_face->ascii_face; \
4812 char2b = (wchar_t *) alloca ((sizeof *char2b) * glyph_len); \
4813 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4814 /* At first, fill in `char2b' and `faces'. */ \
4815 for (n = 0; n < glyph_len; n++) \
4817 int c = COMPOSITION_GLYPH (cmp, n); \
4818 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4819 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4820 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4821 this_face_id, char2b + n, 1); \
4824 /* Make glyph_strings for each glyph sequence that is drawable by \
4825 the same face, and append them to HEAD/TAIL. */ \
4826 for (n = 0; n < cmp->glyph_len;) \
4828 s = (struct glyph_string *) alloca (sizeof *s); \
4829 w32_init_glyph_string (s, hdc, char2b + n, W, ROW, AREA, START, HL); \
4830 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4838 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4846 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4847 of AREA of glyph row ROW on window W between indices START and END.
4848 HL overrides the face for drawing glyph strings, e.g. it is
4849 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
4850 x-positions of the drawing area.
4852 This is an ugly monster macro construct because we must use alloca
4853 to allocate glyph strings (because x_draw_glyphs can be called
4856 #define BUILD_GLYPH_STRINGS(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4859 HEAD = TAIL = NULL; \
4860 while (START < END) \
4862 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
4863 switch (first_glyph->type) \
4866 BUILD_CHAR_GLYPH_STRINGS (hdc, W, ROW, AREA, START, END, \
4867 HEAD, TAIL, HL, X, LAST_X, \
4871 case COMPOSITE_GLYPH: \
4872 BUILD_COMPOSITE_GLYPH_STRING (hdc, W, ROW, AREA, START, \
4873 END, HEAD, TAIL, HL, X, \
4874 LAST_X, OVERLAPS_P); \
4877 case STRETCH_GLYPH: \
4878 BUILD_STRETCH_GLYPH_STRING (hdc, W, ROW, AREA, START, END,\
4879 HEAD, TAIL, HL, X, LAST_X); \
4883 BUILD_IMAGE_GLYPH_STRING (hdc, W, ROW, AREA, START, END, \
4884 HEAD, TAIL, HL, X, LAST_X); \
4891 x_set_glyph_string_background_width (s, START, LAST_X); \
4898 /* Draw glyphs between START and END in AREA of ROW on window W,
4899 starting at x-position X. X is relative to AREA in W. HL is a
4900 face-override with the following meaning:
4902 DRAW_NORMAL_TEXT draw normally
4903 DRAW_CURSOR draw in cursor face
4904 DRAW_MOUSE_FACE draw in mouse face.
4905 DRAW_INVERSE_VIDEO draw in mode line face
4906 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
4907 DRAW_IMAGE_RAISED draw an image with a raised relief around it
4909 If OVERLAPS_P is non-zero, draw only the foreground of characters
4910 and clip to the physical height of ROW.
4912 Value is the x-position reached, relative to AREA of W. */
4915 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, overlaps_p
)
4918 struct glyph_row
*row
;
4919 enum glyph_row_area area
;
4921 enum draw_glyphs_face hl
;
4924 struct glyph_string
*head
, *tail
;
4925 struct glyph_string
*s
;
4926 int last_x
, area_width
;
4929 HDC hdc
= get_frame_dc (XFRAME (WINDOW_FRAME (w
)));
4931 /* Let's rather be paranoid than getting a SEGV. */
4932 end
= min (end
, row
->used
[area
]);
4933 start
= max (0, start
);
4934 start
= min (end
, start
);
4936 /* Translate X to frame coordinates. Set last_x to the right
4937 end of the drawing area. */
4938 if (row
->full_width_p
)
4940 /* X is relative to the left edge of W, without scroll bars
4942 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4943 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
4946 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
4947 last_x
= window_left_x
+ area_width
;
4949 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4951 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
4952 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
4958 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
4959 last_x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
4963 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
4964 area_width
= window_box_width (w
, area
);
4965 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
4968 /* Build a doubly-linked list of glyph_string structures between
4969 head and tail from what we have to draw. Note that the macro
4970 BUILD_GLYPH_STRINGS will modify its start parameter. That's
4971 the reason we use a separate variable `i'. */
4973 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
4976 x_reached
= tail
->x
+ tail
->background_width
;
4980 /* If there are any glyphs with lbearing < 0 or rbearing > width in
4981 the row, redraw some glyphs in front or following the glyph
4982 strings built above. */
4983 if (head
&& !overlaps_p
&& row
->contains_overlapping_glyphs_p
)
4986 struct glyph_string
*h
, *t
;
4988 /* Compute overhangs for all glyph strings. */
4989 for (s
= head
; s
; s
= s
->next
)
4990 x_compute_glyph_string_overhangs (s
);
4992 /* Prepend glyph strings for glyphs in front of the first glyph
4993 string that are overwritten because of the first glyph
4994 string's left overhang. The background of all strings
4995 prepended must be drawn because the first glyph string
4997 i
= x_left_overwritten (head
);
5001 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, j
, start
, h
, t
,
5002 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5005 x_compute_overhangs_and_x (t
, head
->x
, 1);
5006 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5009 /* Prepend glyph strings for glyphs in front of the first glyph
5010 string that overwrite that glyph string because of their
5011 right overhang. For these strings, only the foreground must
5012 be drawn, because it draws over the glyph string at `head'.
5013 The background must not be drawn because this would overwrite
5014 right overhangs of preceding glyphs for which no glyph
5016 i
= x_left_overwriting (head
);
5019 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, i
, start
, h
, t
,
5020 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5022 for (s
= h
; s
; s
= s
->next
)
5023 s
->background_filled_p
= 1;
5024 x_compute_overhangs_and_x (t
, head
->x
, 1);
5025 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5028 /* Append glyphs strings for glyphs following the last glyph
5029 string tail that are overwritten by tail. The background of
5030 these strings has to be drawn because tail's foreground draws
5032 i
= x_right_overwritten (tail
);
5035 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, end
, i
, h
, t
,
5036 DRAW_NORMAL_TEXT
, x
, last_x
,
5038 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5039 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5042 /* Append glyph strings for glyphs following the last glyph
5043 string tail that overwrite tail. The foreground of such
5044 glyphs has to be drawn because it writes into the background
5045 of tail. The background must not be drawn because it could
5046 paint over the foreground of following glyphs. */
5047 i
= x_right_overwriting (tail
);
5050 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, end
, i
, h
, t
,
5051 DRAW_NORMAL_TEXT
, x
, last_x
,
5053 for (s
= h
; s
; s
= s
->next
)
5054 s
->background_filled_p
= 1;
5055 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5056 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5060 /* Draw all strings. */
5061 for (s
= head
; s
; s
= s
->next
)
5062 x_draw_glyph_string (s
);
5064 if (area
== TEXT_AREA
5065 && !row
->full_width_p
5066 /* When drawing overlapping rows, only the glyph strings'
5067 foreground is drawn, which doesn't erase a cursor
5071 int x0
= head
? head
->x
: x
;
5072 int x1
= tail
? tail
->x
+ tail
->background_width
: x
;
5074 x0
= FRAME_TO_WINDOW_PIXEL_X (w
, x0
);
5075 x1
= FRAME_TO_WINDOW_PIXEL_X (w
, x1
);
5077 if (!row
->full_width_p
&& XFASTINT (w
->left_margin_width
) != 0)
5079 int left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
5080 x0
-= left_area_width
;
5081 x1
-= left_area_width
;
5084 notice_overwritten_cursor (w
, area
, x0
, x1
,
5085 row
->y
, MATRIX_ROW_BOTTOM_Y (row
));
5088 /* Value is the x-position up to which drawn, relative to AREA of W.
5089 This doesn't include parts drawn because of overhangs. */
5090 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
5091 if (!row
->full_width_p
)
5093 if (area
> LEFT_MARGIN_AREA
)
5094 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
5095 if (area
> TEXT_AREA
)
5096 x_reached
-= window_box_width (w
, TEXT_AREA
);
5099 release_frame_dc (XFRAME (WINDOW_FRAME (w
)), hdc
);
5105 /* Fix the display of area AREA of overlapping row ROW in window W. */
5108 x_fix_overlapping_area (w
, row
, area
)
5110 struct glyph_row
*row
;
5111 enum glyph_row_area area
;
5117 if (area
== LEFT_MARGIN_AREA
)
5119 else if (area
== TEXT_AREA
)
5120 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5122 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5123 + window_box_width (w
, TEXT_AREA
));
5125 for (i
= 0; i
< row
->used
[area
];)
5127 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
5129 int start
= i
, start_x
= x
;
5133 x
+= row
->glyphs
[area
][i
].pixel_width
;
5136 while (i
< row
->used
[area
]
5137 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
5139 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
5140 DRAW_NORMAL_TEXT
, 1);
5144 x
+= row
->glyphs
[area
][i
].pixel_width
;
5153 /* Output LEN glyphs starting at START at the nominal cursor position.
5154 Advance the nominal cursor over the text. The global variable
5155 updated_window contains the window being updated, updated_row is
5156 the glyph row being updated, and updated_area is the area of that
5157 row being updated. */
5160 x_write_glyphs (start
, len
)
5161 struct glyph
*start
;
5166 xassert (updated_window
&& updated_row
);
5171 hpos
= start
- updated_row
->glyphs
[updated_area
];
5172 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
5173 updated_row
, updated_area
,
5175 DRAW_NORMAL_TEXT
, 0);
5179 /* Advance the output cursor. */
5180 output_cursor
.hpos
+= len
;
5181 output_cursor
.x
= x
;
5185 /* Insert LEN glyphs from START at the nominal cursor position. */
5188 x_insert_glyphs (start
, len
)
5189 struct glyph
*start
;
5194 int line_height
, shift_by_width
, shifted_region_width
;
5195 struct glyph_row
*row
;
5196 struct glyph
*glyph
;
5197 int frame_x
, frame_y
, hpos
;
5200 xassert (updated_window
&& updated_row
);
5203 f
= XFRAME (WINDOW_FRAME (w
));
5204 hdc
= get_frame_dc (f
);
5206 /* Get the height of the line we are in. */
5208 line_height
= row
->height
;
5210 /* Get the width of the glyphs to insert. */
5212 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
5213 shift_by_width
+= glyph
->pixel_width
;
5215 /* Get the width of the region to shift right. */
5216 shifted_region_width
= (window_box_width (w
, updated_area
)
5221 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
5222 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
5223 BitBlt (hdc
, frame_x
+ shift_by_width
, frame_y
,
5224 shifted_region_width
, line_height
,
5225 hdc
, frame_x
, frame_y
, SRCCOPY
);
5227 /* Write the glyphs. */
5228 hpos
= start
- row
->glyphs
[updated_area
];
5229 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
5230 DRAW_NORMAL_TEXT
, 0);
5232 /* Advance the output cursor. */
5233 output_cursor
.hpos
+= len
;
5234 output_cursor
.x
+= shift_by_width
;
5235 release_frame_dc (f
, hdc
);
5241 /* Delete N glyphs at the nominal cursor position. Not implemented
5253 f
= SELECTED_FRAME ();
5255 if (! FRAME_W32_P (f
))
5262 /* Erase the current text line from the nominal cursor position
5263 (inclusive) to pixel column TO_X (exclusive). The idea is that
5264 everything from TO_X onward is already erased.
5266 TO_X is a pixel position relative to updated_area of
5267 updated_window. TO_X == -1 means clear to the end of this area. */
5270 x_clear_end_of_line (to_x
)
5274 struct window
*w
= updated_window
;
5275 int max_x
, min_y
, max_y
;
5276 int from_x
, from_y
, to_y
;
5278 xassert (updated_window
&& updated_row
);
5279 f
= XFRAME (w
->frame
);
5281 if (updated_row
->full_width_p
)
5283 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5284 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5285 && !w
->pseudo_window_p
)
5286 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5289 max_x
= window_box_width (w
, updated_area
);
5290 max_y
= window_text_bottom_y (w
);
5292 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5293 of window. For TO_X > 0, truncate to end of drawing area. */
5299 to_x
= min (to_x
, max_x
);
5301 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
5303 /* Notice if the cursor will be cleared by this operation. */
5304 if (!updated_row
->full_width_p
)
5305 notice_overwritten_cursor (w
, updated_area
,
5306 output_cursor
.x
, -1,
5308 MATRIX_ROW_BOTTOM_Y (updated_row
));
5310 from_x
= output_cursor
.x
;
5312 /* Translate to frame coordinates. */
5313 if (updated_row
->full_width_p
)
5315 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
5316 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
5320 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
5321 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
5324 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
5325 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
5326 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
5328 /* Prevent inadvertently clearing to end of the X window. */
5329 if (to_x
> from_x
&& to_y
> from_y
)
5333 hdc
= get_frame_dc (f
);
5335 w32_clear_area (f
, hdc
, from_x
, from_y
, to_x
- from_x
, to_y
- from_y
);
5336 release_frame_dc (f
, hdc
);
5342 /* Clear entire frame. If updating_frame is non-null, clear that
5343 frame. Otherwise clear the selected frame. */
5353 f
= SELECTED_FRAME ();
5355 if (! FRAME_W32_P (f
))
5358 /* Clearing the frame will erase any cursor, so mark them all as no
5360 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5361 output_cursor
.hpos
= output_cursor
.vpos
= 0;
5362 output_cursor
.x
= -1;
5364 /* We don't set the output cursor here because there will always
5365 follow an explicit cursor_to. */
5368 w32_clear_window (f
);
5370 /* We have to clear the scroll bars, too. If we have changed
5371 colors or something like that, then they should be notified. */
5372 x_scroll_bar_clear (f
);
5378 /* Make audible bell. */
5381 w32_ring_bell (void)
5385 f
= SELECTED_FRAME ();
5389 if (FRAME_W32_P (f
) && visible_bell
)
5392 HWND hwnd
= FRAME_W32_WINDOW (SELECTED_FRAME ());
5394 for (i
= 0; i
< 5; i
++)
5396 FlashWindow (hwnd
, TRUE
);
5399 FlashWindow (hwnd
, FALSE
);
5402 w32_sys_ring_bell ();
5408 /* Specify how many text lines, from the top of the window,
5409 should be affected by insert-lines and delete-lines operations.
5410 This, and those operations, are used only within an update
5411 that is bounded by calls to x_update_begin and x_update_end. */
5414 w32_set_terminal_window (n
)
5417 /* This function intentionally left blank. */
5422 /***********************************************************************
5424 ***********************************************************************/
5426 /* Perform an insert-lines or delete-lines operation, inserting N
5427 lines or deleting -N lines at vertical position VPOS. */
5430 x_ins_del_lines (vpos
, n
)
5438 f
= SELECTED_FRAME ();
5440 if (! FRAME_W32_P (f
))
5447 /* Scroll part of the display as described by RUN. */
5450 x_scroll_run (w
, run
)
5454 struct frame
*f
= XFRAME (w
->frame
);
5455 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5456 HWND hwnd
= FRAME_W32_WINDOW (f
);
5459 /* Get frame-relative bounding box of the text display area of W,
5460 without mode lines. Include in this box the left and right
5462 window_box (w
, -1, &x
, &y
, &width
, &height
);
5463 width
+= FRAME_X_FRINGE_WIDTH (f
);
5464 x
-= FRAME_X_LEFT_FRINGE_WIDTH (f
);
5466 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5467 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5468 bottom_y
= y
+ height
;
5472 /* Scrolling up. Make sure we don't copy part of the mode
5473 line at the bottom. */
5474 if (from_y
+ run
->height
> bottom_y
)
5475 height
= bottom_y
- from_y
;
5477 height
= run
->height
;
5478 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
5482 /* Scolling down. Make sure we don't copy over the mode line.
5484 if (to_y
+ run
->height
> bottom_y
)
5485 height
= bottom_y
- to_y
;
5487 height
= run
->height
;
5488 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
5493 /* Cursor off. Will be switched on again in x_update_window_end. */
5500 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
5501 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
5503 from
.left
= to
.left
= x
;
5504 from
.right
= to
.right
= x
+ width
;
5506 from
.bottom
= from_y
+ height
;
5508 to
.bottom
= bottom_y
;
5510 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
5511 NULL
, SW_INVALIDATE
);
5513 /* Combine this with what we expect to be dirty. This covers the
5514 case where not all of the region we expect is actually dirty. */
5515 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
5517 /* If the dirty region is not what we expected, redraw the entire frame. */
5518 if (!EqualRgn (combined
, expect_dirty
))
5519 SET_FRAME_GARBAGED (f
);
5527 /***********************************************************************
5529 ***********************************************************************/
5531 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5532 corner of the exposed rectangle. W and H are width and height of
5533 the exposed area. All are pixel values. W or H zero means redraw
5534 the entire frame. */
5537 expose_frame (f
, x
, y
, w
, h
)
5542 int mouse_face_overwritten_p
= 0;
5544 TRACE ((stderr
, "expose_frame "));
5546 /* No need to redraw if frame will be redrawn soon. */
5547 if (FRAME_GARBAGED_P (f
))
5549 TRACE ((stderr
, " garbaged\n"));
5553 /* If basic faces haven't been realized yet, there is no point in
5554 trying to redraw anything. This can happen when we get an expose
5555 event while Emacs is starting, e.g. by moving another window. */
5556 if (FRAME_FACE_CACHE (f
) == NULL
5557 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5559 TRACE ((stderr
, " no faces\n"));
5563 if (w
== 0 || h
== 0)
5566 r
.right
= CANON_X_UNIT (f
) * f
->width
;
5567 r
.bottom
= CANON_Y_UNIT (f
) * f
->height
;
5577 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.left
, r
.top
, r
.right
, r
.bottom
));
5578 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
5580 if (WINDOWP (f
->tool_bar_window
))
5581 mouse_face_overwritten_p
5582 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
5584 /* Some window managers support a focus-follows-mouse style with
5585 delayed raising of frames. Imagine a partially obscured frame,
5586 and moving the mouse into partially obscured mouse-face on that
5587 frame. The visible part of the mouse-face will be highlighted,
5588 then the WM raises the obscured frame. With at least one WM, KDE
5589 2.1, Emacs is not getting any event for the raising of the frame
5590 (even tried with SubstructureRedirectMask), only Expose events.
5591 These expose events will draw text normally, i.e. not
5592 highlighted. Which means we must redo the highlight here.
5593 Subsume it under ``we love X''. --gerd 2001-08-15 */
5594 /* Included in Windows version because Windows most likely does not
5595 do the right thing if any third party tool offers
5596 focus-follows-mouse with delayed raise. --jason 2001-10-12 */
5597 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
5599 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5600 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5602 int x
= dpyinfo
->mouse_face_mouse_x
;
5603 int y
= dpyinfo
->mouse_face_mouse_y
;
5604 clear_mouse_face (dpyinfo
);
5605 note_mouse_highlight (f
, x
, y
);
5611 /* Redraw (parts) of all windows in the window tree rooted at W that
5612 intersect R. R contains frame pixel coordinates. */
5615 expose_window_tree (w
, r
)
5619 struct frame
*f
= XFRAME (w
->frame
);
5620 int mouse_face_overwritten_p
= 0;
5622 while (w
&& !FRAME_GARBAGED_P (f
))
5624 if (!NILP (w
->hchild
))
5625 mouse_face_overwritten_p
5626 |= expose_window_tree (XWINDOW (w
->hchild
), r
);
5627 else if (!NILP (w
->vchild
))
5628 mouse_face_overwritten_p
5629 |= expose_window_tree (XWINDOW (w
->vchild
), r
);
5631 mouse_face_overwritten_p
|= expose_window (w
, r
);
5633 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
5636 return mouse_face_overwritten_p
;
5640 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5641 which intersects rectangle R. R is in window-relative coordinates. */
5644 expose_area (w
, row
, r
, area
)
5646 struct glyph_row
*row
;
5648 enum glyph_row_area area
;
5650 struct glyph
*first
= row
->glyphs
[area
];
5651 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5653 int first_x
, start_x
, x
;
5655 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5656 /* If row extends face to end of line write the whole line. */
5657 x_draw_glyphs (w
, 0, row
, area
,
5659 DRAW_NORMAL_TEXT
, 0);
5662 /* Set START_X to the window-relative start position for drawing glyphs of
5663 AREA. The first glyph of the text area can be partially visible.
5664 The first glyphs of other areas cannot. */
5665 if (area
== LEFT_MARGIN_AREA
)
5667 else if (area
== TEXT_AREA
)
5668 start_x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5670 start_x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5671 + window_box_width (w
, TEXT_AREA
));
5674 /* Find the first glyph that must be redrawn. */
5676 && x
+ first
->pixel_width
< r
->left
)
5678 x
+= first
->pixel_width
;
5682 /* Find the last one. */
5688 x
+= last
->pixel_width
;
5694 x_draw_glyphs (w
, first_x
- start_x
, row
, area
,
5695 first
- row
->glyphs
[area
],
5696 last
- row
->glyphs
[area
],
5697 DRAW_NORMAL_TEXT
, 0);
5702 /* Redraw the parts of the glyph row ROW on window W intersecting
5703 rectangle R. R is in window-relative coordinates. Value is
5704 non-zero if mouse face was overwritten. */
5707 expose_line (w
, row
, r
)
5709 struct glyph_row
*row
;
5712 xassert (row
->enabled_p
);
5714 if (row
->mode_line_p
|| w
->pseudo_window_p
)
5715 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
5716 DRAW_NORMAL_TEXT
, 0);
5719 if (row
->used
[LEFT_MARGIN_AREA
])
5720 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
5721 if (row
->used
[TEXT_AREA
])
5722 expose_area (w
, row
, r
, TEXT_AREA
);
5723 if (row
->used
[RIGHT_MARGIN_AREA
])
5724 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
5725 x_draw_row_fringe_bitmaps (w
, row
);
5728 return row
->mouse_face_p
;
5732 /* Return non-zero if W's cursor intersects rectangle R. */
5735 x_phys_cursor_in_rect_p (w
, r
)
5740 struct glyph
*cursor_glyph
;
5742 cursor_glyph
= get_phys_cursor_glyph (w
);
5745 cr
.left
= w
->phys_cursor
.x
;
5746 cr
.top
= w
->phys_cursor
.y
;
5747 cr
.right
= cr
.left
+ cursor_glyph
->pixel_width
;
5748 cr
.bottom
= cr
.top
+ w
->phys_cursor_height
;
5749 return IntersectRect (&result
, &cr
, r
);
5756 /* Redraw those parts of glyphs rows during expose event handling that
5757 overlap other rows. Redrawing of an exposed line writes over parts
5758 of lines overlapping that exposed line; this function fixes that.
5760 W is the window being exposed. FIRST_OVERLAPPING_ROW is the first
5761 row in W's current matrix that is exposed and overlaps other rows.
5762 LAST_OVERLAPPING_ROW is the last such row. */
5765 expose_overlaps (w
, first_overlapping_row
, last_overlapping_row
)
5767 struct glyph_row
*first_overlapping_row
;
5768 struct glyph_row
*last_overlapping_row
;
5770 struct glyph_row
*row
;
5772 for (row
= first_overlapping_row
; row
<= last_overlapping_row
; ++row
)
5773 if (row
->overlapping_p
)
5775 xassert (row
->enabled_p
&& !row
->mode_line_p
);
5777 if (row
->used
[LEFT_MARGIN_AREA
])
5778 x_fix_overlapping_area (w
, row
, LEFT_MARGIN_AREA
);
5780 if (row
->used
[TEXT_AREA
])
5781 x_fix_overlapping_area (w
, row
, TEXT_AREA
);
5783 if (row
->used
[RIGHT_MARGIN_AREA
])
5784 x_fix_overlapping_area (w
, row
, RIGHT_MARGIN_AREA
);
5789 /* Redraw the part of window W intersection rectagle FR. Pixel
5790 coordinates in FR are frame relative. Call this function with
5791 input blocked. Value is non-zero if the exposure overwrites
5795 expose_window (w
, fr
)
5799 struct frame
*f
= XFRAME (w
->frame
);
5801 int mouse_face_overwritten_p
= 0;
5803 /* If window is not yet fully initialized, do nothing. This can
5804 happen when toolkit scroll bars are used and a window is split.
5805 Reconfiguring the scroll bar will generate an expose for a newly
5807 if (w
->current_matrix
== NULL
)
5810 /* When we're currently updating the window, display and current
5811 matrix usually don't agree. Arrange for a thorough display
5813 if (w
== updated_window
)
5815 SET_FRAME_GARBAGED (f
);
5819 /* Frame-relative pixel rectangle of W. */
5820 wr
.left
= XFASTINT (w
->left
) * CANON_X_UNIT (f
);
5821 wr
.top
= XFASTINT (w
->top
) * CANON_Y_UNIT (f
);
5822 wr
.right
= wr
.left
+ XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5823 wr
.bottom
= wr
.top
+ XFASTINT (w
->height
) * CANON_Y_UNIT (f
);
5825 if (IntersectRect(&r
, fr
, &wr
))
5827 int yb
= window_text_bottom_y (w
);
5828 struct glyph_row
*row
;
5829 int cursor_cleared_p
;
5830 struct glyph_row
*first_overlapping_row
, *last_overlapping_row
;
5832 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
5833 r
.left
, r
.top
, r
.right
, r
.bottom
));
5835 /* Convert to window coordinates. */
5836 r
.left
= FRAME_TO_WINDOW_PIXEL_X (w
, r
.left
);
5837 r
.right
= FRAME_TO_WINDOW_PIXEL_X (w
, r
.right
);
5838 r
.top
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
.top
);
5839 r
.bottom
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
.bottom
);
5841 /* Turn off the cursor. */
5842 if (!w
->pseudo_window_p
5843 && x_phys_cursor_in_rect_p (w
, &r
))
5846 cursor_cleared_p
= 1;
5849 cursor_cleared_p
= 0;
5851 /* Update lines intersecting rectangle R. */
5852 first_overlapping_row
= last_overlapping_row
= NULL
;
5853 for (row
= w
->current_matrix
->rows
;
5858 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
5860 if ((y0
>= r
.top
&& y0
< r
.bottom
)
5861 || (y1
> r
.top
&& y1
< r
.bottom
)
5862 || (r
.top
>= y0
&& r
.top
< y1
)
5863 || (r
.bottom
> y0
&& r
.bottom
< y1
))
5865 if (row
->overlapping_p
)
5867 if (first_overlapping_row
== NULL
)
5868 first_overlapping_row
= row
;
5869 last_overlapping_row
= row
;
5872 if (expose_line (w
, row
, &r
))
5873 mouse_face_overwritten_p
= 1;
5880 /* Display the mode line if there is one. */
5881 if (WINDOW_WANTS_MODELINE_P (w
)
5882 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
5884 && row
->y
< r
.bottom
)
5886 if (expose_line (w
, row
, &r
))
5887 mouse_face_overwritten_p
= 1;
5890 if (!w
->pseudo_window_p
)
5892 /* Fix the display of overlapping rows. */
5893 if (first_overlapping_row
)
5894 expose_overlaps (w
, first_overlapping_row
, last_overlapping_row
);
5896 /* Draw border between windows. */
5897 x_draw_vertical_border (w
);
5899 /* Turn the cursor on again. */
5900 if (cursor_cleared_p
)
5901 x_update_window_cursor (w
, 1);
5905 return mouse_face_overwritten_p
;
5913 x_update_cursor (f
, 1);
5917 frame_unhighlight (f
)
5920 x_update_cursor (f
, 1);
5923 /* The focus has changed. Update the frames as necessary to reflect
5924 the new situation. Note that we can't change the selected frame
5925 here, because the Lisp code we are interrupting might become confused.
5926 Each event gets marked with the frame in which it occurred, so the
5927 Lisp code can tell when the switch took place by examining the events. */
5930 x_new_focus_frame (dpyinfo
, frame
)
5931 struct w32_display_info
*dpyinfo
;
5932 struct frame
*frame
;
5934 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
5936 if (frame
!= dpyinfo
->w32_focus_frame
)
5938 /* Set this before calling other routines, so that they see
5939 the correct value of w32_focus_frame. */
5940 dpyinfo
->w32_focus_frame
= frame
;
5942 if (old_focus
&& old_focus
->auto_lower
)
5943 x_lower_frame (old_focus
);
5945 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
5946 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
5948 pending_autoraise_frame
= 0;
5951 x_frame_rehighlight (dpyinfo
);
5954 /* Handle an event saying the mouse has moved out of an Emacs frame. */
5957 x_mouse_leave (dpyinfo
)
5958 struct w32_display_info
*dpyinfo
;
5960 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
5963 /* The focus has changed, or we have redirected a frame's focus to
5964 another frame (this happens when a frame uses a surrogate
5965 mini-buffer frame). Shift the highlight as appropriate.
5967 The FRAME argument doesn't necessarily have anything to do with which
5968 frame is being highlighted or un-highlighted; we only use it to find
5969 the appropriate X display info. */
5972 w32_frame_rehighlight (frame
)
5973 struct frame
*frame
;
5975 if (! FRAME_W32_P (frame
))
5977 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
5981 x_frame_rehighlight (dpyinfo
)
5982 struct w32_display_info
*dpyinfo
;
5984 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
5986 if (dpyinfo
->w32_focus_frame
)
5988 dpyinfo
->x_highlight_frame
5989 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
5990 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
5991 : dpyinfo
->w32_focus_frame
);
5992 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
5994 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
5995 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
5999 dpyinfo
->x_highlight_frame
= 0;
6001 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
6004 frame_unhighlight (old_highlight
);
6005 if (dpyinfo
->x_highlight_frame
)
6006 frame_highlight (dpyinfo
->x_highlight_frame
);
6010 /* Keyboard processing - modifier keys, etc. */
6012 /* Convert a keysym to its name. */
6015 x_get_keysym_name (keysym
)
6018 /* Make static so we can always return it */
6019 static char value
[100];
6022 GetKeyNameText (keysym
, value
, 100);
6030 /* Mouse clicks and mouse movement. Rah. */
6032 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
6033 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
6034 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
6035 not force the value into range. */
6038 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
6040 register int pix_x
, pix_y
;
6041 register int *x
, *y
;
6045 /* Support tty mode: if Vwindow_system is nil, behave correctly. */
6046 if (NILP (Vwindow_system
))
6053 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
6054 even for negative values. */
6056 pix_x
-= FONT_WIDTH (FRAME_FONT (f
)) - 1;
6058 pix_y
-= (f
)->output_data
.w32
->line_height
- 1;
6060 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
6061 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
6065 bounds
->left
= CHAR_TO_PIXEL_COL (f
, pix_x
);
6066 bounds
->top
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
6067 bounds
->right
= bounds
->left
+ FONT_WIDTH (FRAME_FONT (f
)) - 1;
6068 bounds
->bottom
= bounds
->top
+ f
->output_data
.w32
->line_height
- 1;
6075 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
6076 pix_x
= FRAME_WINDOW_WIDTH (f
);
6080 else if (pix_y
> f
->height
)
6089 /* Given HPOS/VPOS in the current matrix of W, return corresponding
6090 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
6091 can't tell the positions because W's display is not up to date,
6095 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
6098 int *frame_x
, *frame_y
;
6102 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
6103 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
6105 if (display_completed
)
6107 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6108 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
6109 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
6115 *frame_x
+= glyph
->pixel_width
;
6123 *frame_y
= *frame_x
= 0;
6127 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
6128 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
6132 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
6133 the state in PUP. XBUTTON provides extra information for extended mouse
6134 button messages. Returns FALSE if unable to parse the message. */
6136 parse_button (message
, xbutton
, pbutton
, pup
)
6147 case WM_LBUTTONDOWN
:
6155 case WM_MBUTTONDOWN
:
6156 if (NILP (Vw32_swap_mouse_buttons
))
6163 if (NILP (Vw32_swap_mouse_buttons
))
6169 case WM_RBUTTONDOWN
:
6170 if (NILP (Vw32_swap_mouse_buttons
))
6177 if (NILP (Vw32_swap_mouse_buttons
))
6183 case WM_XBUTTONDOWN
:
6184 button
= xbutton
+ 2;
6188 button
= xbutton
+ 2;
6196 if (pbutton
) *pbutton
= button
;
6202 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6204 If the event is a button press, then note that we have grabbed
6208 construct_mouse_click (result
, msg
, f
)
6209 struct input_event
*result
;
6216 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
6219 /* Make the event type NO_EVENT; we'll change that when we decide
6221 result
->kind
= MOUSE_CLICK_EVENT
;
6222 result
->code
= button
;
6223 result
->timestamp
= msg
->msg
.time
;
6224 result
->modifiers
= (msg
->dwModifiers
6229 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
6230 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
6231 XSETFRAME (result
->frame_or_window
, f
);
6237 construct_mouse_wheel (result
, msg
, f
)
6238 struct input_event
*result
;
6243 result
->kind
= MOUSE_WHEEL_EVENT
;
6244 result
->code
= (short) HIWORD (msg
->msg
.wParam
);
6245 result
->timestamp
= msg
->msg
.time
;
6246 result
->modifiers
= msg
->dwModifiers
;
6247 p
.x
= LOWORD (msg
->msg
.lParam
);
6248 p
.y
= HIWORD (msg
->msg
.lParam
);
6249 ScreenToClient (msg
->msg
.hwnd
, &p
);
6250 XSETINT (result
->x
, p
.x
);
6251 XSETINT (result
->y
, p
.y
);
6252 XSETFRAME (result
->frame_or_window
, f
);
6258 construct_drag_n_drop (result
, msg
, f
)
6259 struct input_event
*result
;
6271 result
->kind
= DRAG_N_DROP_EVENT
;
6273 result
->timestamp
= msg
->msg
.time
;
6274 result
->modifiers
= msg
->dwModifiers
;
6276 hdrop
= (HDROP
) msg
->msg
.wParam
;
6277 DragQueryPoint (hdrop
, &p
);
6280 p
.x
= LOWORD (msg
->msg
.lParam
);
6281 p
.y
= HIWORD (msg
->msg
.lParam
);
6282 ScreenToClient (msg
->msg
.hwnd
, &p
);
6285 XSETINT (result
->x
, p
.x
);
6286 XSETINT (result
->y
, p
.y
);
6288 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
6291 for (i
= 0; i
< num_files
; i
++)
6293 len
= DragQueryFile (hdrop
, i
, NULL
, 0);
6296 name
= alloca (len
+ 1);
6297 DragQueryFile (hdrop
, i
, name
, len
+ 1);
6298 files
= Fcons (DECODE_FILE (build_string (name
)), files
);
6303 XSETFRAME (frame
, f
);
6304 result
->frame_or_window
= Fcons (frame
, files
);
6310 /* Function to report a mouse movement to the mainstream Emacs code.
6311 The input handler calls this.
6313 We have received a mouse movement event, which is given in *event.
6314 If the mouse is over a different glyph than it was last time, tell
6315 the mainstream emacs code by setting mouse_moved. If not, ask for
6316 another motion event, so we can check again the next time it moves. */
6318 static MSG last_mouse_motion_event
;
6319 static Lisp_Object last_mouse_motion_frame
;
6321 static void remember_mouse_glyph
P_ ((struct frame
*, int, int));
6324 note_mouse_movement (frame
, msg
)
6328 int mouse_x
= LOWORD (msg
->lParam
);
6329 int mouse_y
= HIWORD (msg
->lParam
);
6331 last_mouse_movement_time
= msg
->time
;
6332 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
6333 XSETFRAME (last_mouse_motion_frame
, frame
);
6335 #if 0 /* Calling Lisp asynchronously is not safe. */
6336 if (mouse_autoselect_window
)
6340 static Lisp_Object last_window
;
6342 window
= window_from_coordinates (frame
, mouse_x
, mouse_y
, &area
, 0);
6344 /* Window will be selected only when it is not selected now and
6345 last mouse movement event was not in it. Minibuffer window
6346 will be selected iff it is active. */
6347 if (!EQ (window
, last_window
)
6348 && !EQ (window
, selected_window
)
6349 && (!MINI_WINDOW_P (XWINDOW (window
))
6350 || (EQ (window
, minibuf_window
) && minibuf_level
> 0)))
6351 Fselect_window (window
);
6357 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
6359 frame
->mouse_moved
= 1;
6360 last_mouse_scroll_bar
= Qnil
;
6361 note_mouse_highlight (frame
, -1, -1);
6364 /* Has the mouse moved off the glyph it was on at the last sighting? */
6365 else if (mouse_x
< last_mouse_glyph
.left
6366 || mouse_x
> last_mouse_glyph
.right
6367 || mouse_y
< last_mouse_glyph
.top
6368 || mouse_y
> last_mouse_glyph
.bottom
)
6370 frame
->mouse_moved
= 1;
6371 last_mouse_scroll_bar
= Qnil
;
6372 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
6373 /* Remember the mouse position here, as w32_mouse_position only
6374 gets called when mouse tracking is enabled but we also need
6375 to keep track of the mouse for help_echo and highlighting at
6377 remember_mouse_glyph (frame
, mouse_x
, mouse_y
);
6382 /************************************************************************
6384 ************************************************************************/
6386 /* Find the glyph under window-relative coordinates X/Y in window W.
6387 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6388 strings. Return in *HPOS and *VPOS the row and column number of
6389 the glyph found. Return in *AREA the glyph area containing X.
6390 Value is a pointer to the glyph found or null if X/Y is not on
6391 text, or we can't tell because W's current matrix is not up to
6394 static struct glyph
*
6395 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
, buffer_only_p
)
6398 int *hpos
, *vpos
, *area
;
6401 struct glyph
*glyph
, *end
;
6402 struct glyph_row
*row
= NULL
;
6403 int x0
, i
, left_area_width
;
6405 /* Find row containing Y. Give up if some row is not enabled. */
6406 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6408 row
= MATRIX_ROW (w
->current_matrix
, i
);
6409 if (!row
->enabled_p
)
6411 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6418 /* Give up if Y is not in the window. */
6419 if (i
== w
->current_matrix
->nrows
)
6422 /* Get the glyph area containing X. */
6423 if (w
->pseudo_window_p
)
6430 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6431 if (x
< left_area_width
)
6433 *area
= LEFT_MARGIN_AREA
;
6436 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6439 x0
= row
->x
+ left_area_width
;
6443 *area
= RIGHT_MARGIN_AREA
;
6444 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6448 /* Find glyph containing X. */
6449 glyph
= row
->glyphs
[*area
];
6450 end
= glyph
+ row
->used
[*area
];
6453 if (x
< x0
+ glyph
->pixel_width
)
6455 if (w
->pseudo_window_p
)
6457 else if (!buffer_only_p
|| BUFFERP (glyph
->object
))
6461 x0
+= glyph
->pixel_width
;
6468 *hpos
= glyph
- row
->glyphs
[*area
];
6473 /* Convert frame-relative x/y to coordinates relative to window W.
6474 Takes pseudo-windows into account. */
6477 frame_to_window_pixel_xy (w
, x
, y
)
6481 if (w
->pseudo_window_p
)
6483 /* A pseudo-window is always full-width, and starts at the
6484 left edge of the frame, plus a frame border. */
6485 struct frame
*f
= XFRAME (w
->frame
);
6486 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6487 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6491 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6492 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6497 /* Take proper action when mouse has moved to the mode or header line of
6498 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6499 mode line. X is relative to the start of the text display area of
6500 W, so the width of fringes and scroll bars must be subtracted
6501 to get a position relative to the start of the mode line. */
6504 note_mode_line_highlight (w
, x
, mode_line_p
)
6508 struct frame
*f
= XFRAME (w
->frame
);
6509 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6510 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6511 struct glyph_row
*row
;
6514 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
6516 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
6520 struct glyph
*glyph
, *end
;
6521 Lisp_Object help
, map
;
6524 /* Find the glyph under X. */
6525 glyph
= row
->glyphs
[TEXT_AREA
];
6526 end
= glyph
+ row
->used
[TEXT_AREA
];
6527 x0
= - (FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
)
6528 + FRAME_X_LEFT_FRINGE_WIDTH (f
));
6531 && x
>= x0
+ glyph
->pixel_width
)
6533 x0
+= glyph
->pixel_width
;
6538 && STRINGP (glyph
->object
)
6539 && STRING_INTERVALS (glyph
->object
)
6540 && glyph
->charpos
>= 0
6541 && glyph
->charpos
< SCHARS (glyph
->object
))
6543 /* If we're on a string with `help-echo' text property,
6544 arrange for the help to be displayed. This is done by
6545 setting the global variable help_echo to the help string. */
6546 help
= Fget_text_property (make_number (glyph
->charpos
),
6547 Qhelp_echo
, glyph
->object
);
6551 XSETWINDOW (help_echo_window
, w
);
6552 help_echo_object
= glyph
->object
;
6553 help_echo_pos
= glyph
->charpos
;
6556 /* Change the mouse pointer according to what is under X/Y. */
6557 map
= Fget_text_property (make_number (glyph
->charpos
),
6558 Qlocal_map
, glyph
->object
);
6560 cursor
= f
->output_data
.w32
->nontext_cursor
;
6563 map
= Fget_text_property (make_number (glyph
->charpos
),
6564 Qkeymap
, glyph
->object
);
6566 cursor
= f
->output_data
.w32
->nontext_cursor
;
6570 #if 0 /* TODO: mouse cursor */
6571 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6576 /* Take proper action when the mouse has moved to position X, Y on
6577 frame F as regards highlighting characters that have mouse-face
6578 properties. Also de-highlighting chars where the mouse was before.
6579 X and Y can be negative or out of range. */
6582 note_mouse_highlight (f
, x
, y
)
6586 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6592 /* When a menu is active, don't highlight because this looks odd. */
6593 if (popup_activated ())
6596 if (NILP (Vmouse_highlight
)
6597 || !f
->glyphs_initialized_p
)
6600 dpyinfo
->mouse_face_mouse_x
= x
;
6601 dpyinfo
->mouse_face_mouse_y
= y
;
6602 dpyinfo
->mouse_face_mouse_frame
= f
;
6604 if (dpyinfo
->mouse_face_defer
)
6609 dpyinfo
->mouse_face_deferred_gc
= 1;
6613 /* Which window is that in? */
6614 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
6616 /* If we were displaying active text in another window, clear that. */
6617 if (! EQ (window
, dpyinfo
->mouse_face_window
))
6618 clear_mouse_face (dpyinfo
);
6620 /* Not on a window -> return. */
6621 if (!WINDOWP (window
))
6624 /* Reset help_echo. It will get recomputed below. */
6627 /* Convert to window-relative pixel coordinates. */
6628 w
= XWINDOW (window
);
6629 frame_to_window_pixel_xy (w
, &x
, &y
);
6631 /* Handle tool-bar window differently since it doesn't display a
6633 if (EQ (window
, f
->tool_bar_window
))
6635 note_tool_bar_highlight (f
, x
, y
);
6639 /* Mouse is on the mode or header line? */
6640 if (portion
== 1 || portion
== 3)
6642 note_mode_line_highlight (w
, x
, portion
== 1);
6645 #if 0 /* TODO: mouse cursor */
6647 cursor
= f
->output_data
.x
->horizontal_drag_cursor
;
6649 cursor
= f
->output_data
.x
->text_cursor
;
6651 /* Are we in a window whose display is up to date?
6652 And verify the buffer's text has not changed. */
6653 b
= XBUFFER (w
->buffer
);
6654 if (/* Within text portion of the window. */
6656 && EQ (w
->window_end_valid
, w
->buffer
)
6657 && XFASTINT (w
->last_modified
) == BUF_MODIFF (b
)
6658 && XFASTINT (w
->last_overlay_modified
) == BUF_OVERLAY_MODIFF (b
))
6660 int hpos
, vpos
, pos
, i
, area
;
6661 struct glyph
*glyph
;
6663 Lisp_Object mouse_face
= Qnil
, overlay
= Qnil
, position
;
6664 Lisp_Object
*overlay_vec
= NULL
;
6666 struct buffer
*obuf
;
6667 int obegv
, ozv
, same_region
;
6669 /* Find the glyph under X/Y. */
6670 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
, 0);
6672 /* Clear mouse face if X/Y not over text. */
6674 || area
!= TEXT_AREA
6675 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
6677 clear_mouse_face (dpyinfo
);
6678 /* TODO: mouse cursor */
6682 pos
= glyph
->charpos
;
6683 object
= glyph
->object
;
6684 if (!STRINGP (object
) && !BUFFERP (object
))
6687 /* If we get an out-of-range value, return now; avoid an error. */
6688 if (BUFFERP (object
) && pos
> BUF_Z (b
))
6691 /* Make the window's buffer temporarily current for
6692 overlays_at and compute_char_face. */
6693 obuf
= current_buffer
;
6700 /* Is this char mouse-active or does it have help-echo? */
6701 position
= make_number (pos
);
6703 if (BUFFERP (object
))
6705 /* Put all the overlays we want in a vector in overlay_vec.
6706 Store the length in len. If there are more than 10, make
6707 enough space for all, and try again. */
6709 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6710 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
6711 if (noverlays
> len
)
6714 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6715 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
,0);
6718 /* Sort overlays into increasing priority order. */
6719 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
6724 same_region
= (EQ (window
, dpyinfo
->mouse_face_window
)
6725 && vpos
>= dpyinfo
->mouse_face_beg_row
6726 && vpos
<= dpyinfo
->mouse_face_end_row
6727 && (vpos
> dpyinfo
->mouse_face_beg_row
6728 || hpos
>= dpyinfo
->mouse_face_beg_col
)
6729 && (vpos
< dpyinfo
->mouse_face_end_row
6730 || hpos
< dpyinfo
->mouse_face_end_col
6731 || dpyinfo
->mouse_face_past_end
));
6733 /* TODO: if (same_region)
6736 /* Check mouse-face highlighting. */
6738 /* If there exists an overlay with mouse-face overlapping
6739 the one we are currently highlighting, we have to
6740 check if we enter the overlapping overlay, and then
6742 || (OVERLAYP (dpyinfo
->mouse_face_overlay
)
6743 && mouse_face_overlay_overlaps (dpyinfo
->mouse_face_overlay
)))
6745 /* Find the highest priority overlay that has a mouse-face
6748 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
6750 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
6751 if (!NILP (mouse_face
))
6752 overlay
= overlay_vec
[i
];
6755 /* If we're actually highlighting the same overlay as
6756 before, there's no need to do that again. */
6758 && EQ (overlay
, dpyinfo
->mouse_face_overlay
))
6759 goto check_help_echo
;
6761 dpyinfo
->mouse_face_overlay
= overlay
;
6763 /* Clear the display of the old active region, if any. */
6764 clear_mouse_face (dpyinfo
);
6765 /* TODO: mouse cursor changes. */
6767 /* If no overlay applies, get a text property. */
6769 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
6771 /* Handle the overlay case. */
6772 if (!NILP (overlay
))
6774 /* Find the range of text around this char that
6775 should be active. */
6776 Lisp_Object before
, after
;
6779 before
= Foverlay_start (overlay
);
6780 after
= Foverlay_end (overlay
);
6781 /* Record this as the current active region. */
6782 fast_find_position (w
, XFASTINT (before
),
6783 &dpyinfo
->mouse_face_beg_col
,
6784 &dpyinfo
->mouse_face_beg_row
,
6785 &dpyinfo
->mouse_face_beg_x
,
6786 &dpyinfo
->mouse_face_beg_y
, Qnil
);
6788 dpyinfo
->mouse_face_past_end
6789 = !fast_find_position (w
, XFASTINT (after
),
6790 &dpyinfo
->mouse_face_end_col
,
6791 &dpyinfo
->mouse_face_end_row
,
6792 &dpyinfo
->mouse_face_end_x
,
6793 &dpyinfo
->mouse_face_end_y
, Qnil
);
6794 dpyinfo
->mouse_face_window
= window
;
6796 dpyinfo
->mouse_face_face_id
6797 = face_at_buffer_position (w
, pos
, 0, 0,
6799 !dpyinfo
->mouse_face_hidden
);
6801 /* Display it as active. */
6802 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6803 /* TODO: mouse cursor changes. */
6805 /* Handle the text property case. */
6806 else if (! NILP (mouse_face
) && BUFFERP (object
))
6808 /* Find the range of text around this char that
6809 should be active. */
6810 Lisp_Object before
, after
, beginning
, end
;
6813 beginning
= Fmarker_position (w
->start
);
6814 end
= make_number (BUF_Z (XBUFFER (object
))
6815 - XFASTINT (w
->window_end_pos
));
6817 = Fprevious_single_property_change (make_number (pos
+ 1),
6821 = Fnext_single_property_change (position
, Qmouse_face
,
6824 /* Record this as the current active region. */
6825 fast_find_position (w
, XFASTINT (before
),
6826 &dpyinfo
->mouse_face_beg_col
,
6827 &dpyinfo
->mouse_face_beg_row
,
6828 &dpyinfo
->mouse_face_beg_x
,
6829 &dpyinfo
->mouse_face_beg_y
, Qnil
);
6830 dpyinfo
->mouse_face_past_end
6831 = !fast_find_position (w
, XFASTINT (after
),
6832 &dpyinfo
->mouse_face_end_col
,
6833 &dpyinfo
->mouse_face_end_row
,
6834 &dpyinfo
->mouse_face_end_x
,
6835 &dpyinfo
->mouse_face_end_y
, Qnil
);
6836 dpyinfo
->mouse_face_window
= window
;
6838 if (BUFFERP (object
))
6839 dpyinfo
->mouse_face_face_id
6840 = face_at_buffer_position (w
, pos
, 0, 0,
6842 !dpyinfo
->mouse_face_hidden
);
6844 /* Display it as active. */
6845 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6846 /* TODO: mouse cursor changes. */
6848 else if (!NILP (mouse_face
) && STRINGP (object
))
6853 b
= Fprevious_single_property_change (make_number (pos
+ 1),
6856 e
= Fnext_single_property_change (position
, Qmouse_face
,
6859 b
= make_number (0);
6861 e
= make_number (SCHARS (object
) - 1);
6862 fast_find_string_pos (w
, XINT (b
), object
,
6863 &dpyinfo
->mouse_face_beg_col
,
6864 &dpyinfo
->mouse_face_beg_row
,
6865 &dpyinfo
->mouse_face_beg_x
,
6866 &dpyinfo
->mouse_face_beg_y
, 0);
6867 fast_find_string_pos (w
, XINT (e
), object
,
6868 &dpyinfo
->mouse_face_end_col
,
6869 &dpyinfo
->mouse_face_end_row
,
6870 &dpyinfo
->mouse_face_end_x
,
6871 &dpyinfo
->mouse_face_end_y
, 1);
6872 dpyinfo
->mouse_face_past_end
= 0;
6873 dpyinfo
->mouse_face_window
= window
;
6874 dpyinfo
->mouse_face_face_id
6875 = face_at_string_position (w
, object
, pos
, 0, 0, 0, &ignore
,
6877 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6878 /* TODO: mouse cursor changes. */
6880 else if (STRINGP (object
) && NILP (mouse_face
))
6882 /* A string which doesn't have mouse-face, but
6883 the text ``under'' it might have. */
6884 struct glyph_row
*r
= MATRIX_ROW (w
->current_matrix
, vpos
);
6885 int start
= MATRIX_ROW_START_CHARPOS (r
);
6887 pos
= string_buffer_position (w
, object
, start
);
6889 mouse_face
= get_char_property_and_overlay (make_number (pos
),
6893 if (!NILP (mouse_face
) && !NILP (overlay
))
6895 Lisp_Object before
= Foverlay_start (overlay
);
6896 Lisp_Object after
= Foverlay_end (overlay
);
6899 /* Note that we might not be able to find position
6900 BEFORE in the glyph matrix if the overlay is
6901 entirely covered by a `display' property. In
6902 this case, we overshoot. So let's stop in
6903 the glyph matrix before glyphs for OBJECT. */
6904 fast_find_position (w
, XFASTINT (before
),
6905 &dpyinfo
->mouse_face_beg_col
,
6906 &dpyinfo
->mouse_face_beg_row
,
6907 &dpyinfo
->mouse_face_beg_x
,
6908 &dpyinfo
->mouse_face_beg_y
,
6911 dpyinfo
->mouse_face_past_end
6912 = !fast_find_position (w
, XFASTINT (after
),
6913 &dpyinfo
->mouse_face_end_col
,
6914 &dpyinfo
->mouse_face_end_row
,
6915 &dpyinfo
->mouse_face_end_x
,
6916 &dpyinfo
->mouse_face_end_y
,
6918 dpyinfo
->mouse_face_window
= window
;
6919 dpyinfo
->mouse_face_face_id
6920 = face_at_buffer_position (w
, pos
, 0, 0,
6922 !dpyinfo
->mouse_face_hidden
);
6924 /* Display it as active. */
6925 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6926 /* TODO: mouse cursor changes. */
6933 /* Look for a `help-echo' property. */
6935 Lisp_Object help
, overlay
;
6937 /* Check overlays first. */
6938 help
= overlay
= Qnil
;
6939 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
6941 overlay
= overlay_vec
[i
];
6942 help
= Foverlay_get (overlay
, Qhelp_echo
);
6948 help_echo_window
= window
;
6949 help_echo_object
= overlay
;
6950 help_echo_pos
= pos
;
6954 Lisp_Object object
= glyph
->object
;
6955 int charpos
= glyph
->charpos
;
6957 /* Try text properties. */
6958 if (STRINGP (object
)
6960 && charpos
< SCHARS (object
))
6962 help
= Fget_text_property (make_number (charpos
),
6963 Qhelp_echo
, object
);
6966 /* If the string itself doesn't specify a help-echo,
6967 see if the buffer text ``under'' it does. */
6969 = MATRIX_ROW (w
->current_matrix
, vpos
);
6970 int start
= MATRIX_ROW_START_CHARPOS (r
);
6971 int pos
= string_buffer_position (w
, object
, start
);
6974 help
= Fget_char_property (make_number (pos
),
6975 Qhelp_echo
, w
->buffer
);
6984 else if (BUFFERP (object
)
6987 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
6993 help_echo_window
= window
;
6994 help_echo_object
= object
;
6995 help_echo_pos
= charpos
;
7002 current_buffer
= obuf
;
7006 /* TODO: mouse cursor changes. */
7011 redo_mouse_highlight ()
7013 if (!NILP (last_mouse_motion_frame
)
7014 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
7015 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
7016 LOWORD (last_mouse_motion_event
.lParam
),
7017 HIWORD (last_mouse_motion_event
.lParam
));
7022 /***********************************************************************
7024 ***********************************************************************/
7026 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
7027 struct glyph
**, int *, int *, int *));
7029 /* Tool-bar item index of the item on which a mouse button was pressed
7032 static int last_tool_bar_item
;
7035 /* Get information about the tool-bar item at position X/Y on frame F.
7036 Return in *GLYPH a pointer to the glyph of the tool-bar item in
7037 the current matrix of the tool-bar window of F, or NULL if not
7038 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
7039 item in F->tool_bar_items. Value is
7041 -1 if X/Y is not on a tool-bar item
7042 0 if X/Y is on the same item that was highlighted before.
7046 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
7049 struct glyph
**glyph
;
7050 int *hpos
, *vpos
, *prop_idx
;
7052 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
7053 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7056 /* Find the glyph under X/Y. */
7057 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
, 0);
7061 /* Get the start of this tool-bar item's properties in
7062 f->tool_bar_items. */
7063 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
7066 /* Is mouse on the highlighted item? */
7067 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
7068 && *vpos
>= dpyinfo
->mouse_face_beg_row
7069 && *vpos
<= dpyinfo
->mouse_face_end_row
7070 && (*vpos
> dpyinfo
->mouse_face_beg_row
7071 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
7072 && (*vpos
< dpyinfo
->mouse_face_end_row
7073 || *hpos
< dpyinfo
->mouse_face_end_col
7074 || dpyinfo
->mouse_face_past_end
))
7081 /* Handle mouse button event on the tool-bar of frame F, at
7082 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
7086 w32_handle_tool_bar_click (f
, button_event
)
7088 struct input_event
*button_event
;
7090 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
7091 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7092 int hpos
, vpos
, prop_idx
;
7093 struct glyph
*glyph
;
7094 Lisp_Object enabled_p
;
7095 int x
= XFASTINT (button_event
->x
);
7096 int y
= XFASTINT (button_event
->y
);
7098 /* If not on the highlighted tool-bar item, return. */
7099 frame_to_window_pixel_xy (w
, &x
, &y
);
7100 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
7103 /* If item is disabled, do nothing. */
7104 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7105 if (NILP (enabled_p
))
7108 if (button_event
->modifiers
& down_modifier
)
7110 /* Show item in pressed state. */
7111 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
7112 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
7113 last_tool_bar_item
= prop_idx
;
7117 Lisp_Object key
, frame
;
7118 struct input_event event
;
7120 /* Show item in released state. */
7121 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
7122 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
7124 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
7126 XSETFRAME (frame
, f
);
7127 event
.kind
= TOOL_BAR_EVENT
;
7128 event
.frame_or_window
= frame
;
7130 kbd_buffer_store_event (&event
);
7132 event
.kind
= TOOL_BAR_EVENT
;
7133 event
.frame_or_window
= frame
;
7135 /* The keyboard buffer doesn't like the up modifier being set. */
7136 event
.modifiers
= button_event
->modifiers
& ~up_modifier
;
7137 kbd_buffer_store_event (&event
);
7138 last_tool_bar_item
= -1;
7143 /* Possibly highlight a tool-bar item on frame F when mouse moves to
7144 tool-bar window-relative coordinates X/Y. Called from
7145 note_mouse_highlight. */
7148 note_tool_bar_highlight (f
, x
, y
)
7152 Lisp_Object window
= f
->tool_bar_window
;
7153 struct window
*w
= XWINDOW (window
);
7154 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
7156 struct glyph
*glyph
;
7157 struct glyph_row
*row
;
7159 Lisp_Object enabled_p
;
7161 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
7162 int mouse_down_p
, rc
;
7164 /* Function note_mouse_highlight is called with negative x(y
7165 values when mouse moves outside of the frame. */
7166 if (x
<= 0 || y
<= 0)
7168 clear_mouse_face (dpyinfo
);
7172 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
7175 /* Not on tool-bar item. */
7176 clear_mouse_face (dpyinfo
);
7180 /* On same tool-bar item as before. */
7183 clear_mouse_face (dpyinfo
);
7185 /* Mouse is down, but on different tool-bar item? */
7186 mouse_down_p
= (dpyinfo
->grabbed
7187 && f
== last_mouse_frame
7188 && FRAME_LIVE_P (f
));
7190 && last_tool_bar_item
!= prop_idx
)
7193 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
7194 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
7196 /* If tool-bar item is not enabled, don't highlight it. */
7197 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7198 if (!NILP (enabled_p
))
7200 /* Compute the x-position of the glyph. In front and past the
7201 image is a space. We include this is the highlighted area. */
7202 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
7203 for (i
= x
= 0; i
< hpos
; ++i
)
7204 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
7206 /* Record this as the current active region. */
7207 dpyinfo
->mouse_face_beg_col
= hpos
;
7208 dpyinfo
->mouse_face_beg_row
= vpos
;
7209 dpyinfo
->mouse_face_beg_x
= x
;
7210 dpyinfo
->mouse_face_beg_y
= row
->y
;
7211 dpyinfo
->mouse_face_past_end
= 0;
7213 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
7214 dpyinfo
->mouse_face_end_row
= vpos
;
7215 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
7216 dpyinfo
->mouse_face_end_y
= row
->y
;
7217 dpyinfo
->mouse_face_window
= window
;
7218 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
7220 /* Display it as active. */
7221 show_mouse_face (dpyinfo
, draw
);
7222 dpyinfo
->mouse_face_image_state
= draw
;
7227 /* Set help_echo to a help string.to display for this tool-bar item.
7228 w32_read_socket does the rest. */
7229 help_echo_object
= help_echo_window
= Qnil
;
7231 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
7232 if (NILP (help_echo
))
7233 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
7238 /* Find the glyph matrix position of buffer position CHARPOS in window
7239 *W. HPOS, *VPOS, *X, and *Y are set to the positions found. W's
7240 current glyphs must be up to date. If CHARPOS is above window
7241 start return (0, 0, 0, 0). If CHARPOS is after end of W, return end
7242 of last line in W. In the row containing CHARPOS, stop before glyphs
7243 having STOP as object. */
7245 #if 0 /* This is a version of fast_find_position that's more correct
7246 in the presence of hscrolling, for example. I didn't install
7247 it right away because the problem fixed is minor, it failed
7248 in 20.x as well, and I think it's too risky to install
7249 so near the release of 21.1. 2001-09-25 gerd. */
7252 fast_find_position (w
, charpos
, hpos
, vpos
, x
, y
, stop
)
7255 int *hpos
, *vpos
, *x
, *y
;
7258 struct glyph_row
*row
, *first
;
7259 struct glyph
*glyph
, *end
;
7260 int i
, past_end
= 0;
7262 first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7263 row
= row_containing_pos (w
, charpos
, first
, NULL
, 0);
7266 if (charpos
< MATRIX_ROW_START_CHARPOS (first
))
7268 *x
= *y
= *hpos
= *vpos
= 0;
7273 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
7280 *vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
7282 glyph
= row
->glyphs
[TEXT_AREA
];
7283 end
= glyph
+ row
->used
[TEXT_AREA
];
7285 /* Skip over glyphs not having an object at the start of the row.
7286 These are special glyphs like truncation marks on terminal
7288 if (row
->displays_text_p
)
7290 && INTEGERP (glyph
->object
)
7291 && !EQ (stop
, glyph
->object
)
7292 && glyph
->charpos
< 0)
7294 *x
+= glyph
->pixel_width
;
7299 && !INTEGERP (glyph
->object
)
7300 && !EQ (stop
, glyph
->object
)
7301 && (!BUFFERP (glyph
->object
)
7302 || glyph
->charpos
< charpos
))
7304 *x
+= glyph
->pixel_width
;
7308 *hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
7315 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
, stop
)
7318 int *hpos
, *vpos
, *x
, *y
;
7323 int maybe_next_line_p
= 0;
7324 int line_start_position
;
7325 int yb
= window_text_bottom_y (w
);
7326 struct glyph_row
*row
, *best_row
;
7327 int row_vpos
, best_row_vpos
;
7330 row
= best_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7331 row_vpos
= best_row_vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
7335 if (row
->used
[TEXT_AREA
])
7336 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
7338 line_start_position
= 0;
7340 if (line_start_position
> pos
)
7342 /* If the position sought is the end of the buffer,
7343 don't include the blank lines at the bottom of the window. */
7344 else if (line_start_position
== pos
7345 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
7347 maybe_next_line_p
= 1;
7350 else if (line_start_position
> 0)
7353 best_row_vpos
= row_vpos
;
7356 if (row
->y
+ row
->height
>= yb
)
7363 /* Find the right column within BEST_ROW. */
7365 current_x
= best_row
->x
;
7366 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
7368 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
7369 int charpos
= glyph
->charpos
;
7371 if (BUFFERP (glyph
->object
))
7376 *vpos
= best_row_vpos
;
7381 else if (charpos
> pos
)
7384 else if (EQ (glyph
->object
, stop
))
7389 current_x
+= glyph
->pixel_width
;
7392 /* If we're looking for the end of the buffer,
7393 and we didn't find it in the line we scanned,
7394 use the start of the following line. */
7395 if (maybe_next_line_p
)
7400 current_x
= best_row
->x
;
7403 *vpos
= best_row_vpos
;
7404 *hpos
= lastcol
+ 1;
7413 /* Find the position of the glyph for position POS in OBJECT in
7414 window W's current matrix, and return in *X/*Y the pixel
7415 coordinates, and return in *HPOS/*VPOS the column/row of the glyph.
7417 RIGHT_P non-zero means return the position of the right edge of the
7418 glyph, RIGHT_P zero means return the left edge position.
7420 If no glyph for POS exists in the matrix, return the position of
7421 the glyph with the next smaller position that is in the matrix, if
7422 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
7423 exists in the matrix, return the position of the glyph with the
7424 next larger position in OBJECT.
7426 Value is non-zero if a glyph was found. */
7429 fast_find_string_pos (w
, pos
, object
, hpos
, vpos
, x
, y
, right_p
)
7433 int *hpos
, *vpos
, *x
, *y
;
7436 int yb
= window_text_bottom_y (w
);
7437 struct glyph_row
*r
;
7438 struct glyph
*best_glyph
= NULL
;
7439 struct glyph_row
*best_row
= NULL
;
7442 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7443 r
->enabled_p
&& r
->y
< yb
;
7446 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
7447 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
7450 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
7451 if (EQ (g
->object
, object
))
7453 if (g
->charpos
== pos
)
7460 else if (best_glyph
== NULL
7461 || ((abs (g
->charpos
- pos
)
7462 < abs (best_glyph
->charpos
- pos
))
7465 : g
->charpos
> pos
)))
7479 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
7483 *x
+= best_glyph
->pixel_width
;
7488 *vpos
= best_row
- w
->current_matrix
->rows
;
7491 return best_glyph
!= NULL
;
7495 /* Display the active region described by mouse_face_*
7496 in its mouse-face if HL > 0, in its normal face if HL = 0. */
7499 show_mouse_face (dpyinfo
, draw
)
7500 struct w32_display_info
*dpyinfo
;
7501 enum draw_glyphs_face draw
;
7503 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
7504 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7506 if (/* If window is in the process of being destroyed, don't bother
7508 w
->current_matrix
!= NULL
7509 /* Don't update mouse highlight if hidden */
7510 && (draw
!= DRAW_MOUSE_FACE
|| !dpyinfo
->mouse_face_hidden
)
7511 /* Recognize when we are called to operate on rows that don't exist
7512 anymore. This can happen when a window is split. */
7513 && dpyinfo
->mouse_face_end_row
< w
->current_matrix
->nrows
)
7515 int phys_cursor_on_p
= w
->phys_cursor_on_p
;
7516 struct glyph_row
*row
, *first
, *last
;
7518 first
= MATRIX_ROW (w
->current_matrix
, dpyinfo
->mouse_face_beg_row
);
7519 last
= MATRIX_ROW (w
->current_matrix
, dpyinfo
->mouse_face_end_row
);
7521 for (row
= first
; row
<= last
&& row
->enabled_p
; ++row
)
7523 int start_hpos
, end_hpos
, start_x
;
7525 /* For all but the first row, the highlight starts at column 0. */
7528 start_hpos
= dpyinfo
->mouse_face_beg_col
;
7529 start_x
= dpyinfo
->mouse_face_beg_x
;
7538 end_hpos
= dpyinfo
->mouse_face_end_col
;
7540 end_hpos
= row
->used
[TEXT_AREA
];
7542 if (end_hpos
> start_hpos
)
7544 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
7545 start_hpos
, end_hpos
, draw
, 0);
7548 = draw
== DRAW_MOUSE_FACE
|| draw
== DRAW_IMAGE_RAISED
;
7552 /* When we've written over the cursor, arrange for it to
7553 be displayed again. */
7554 if (phys_cursor_on_p
&& !w
->phys_cursor_on_p
)
7555 x_display_cursor (w
, 1,
7556 w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
7557 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
7560 #if 0 /* TODO: mouse cursor */
7561 /* Change the mouse cursor. */
7562 if (draw
== DRAW_NORMAL_TEXT
)
7563 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7564 f
->output_data
.x
->text_cursor
);
7565 else if (draw
== DRAW_MOUSE_FACE
)
7566 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7567 f
->output_data
.x
->cross_cursor
);
7569 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7570 f
->output_data
.x
->nontext_cursor
);
7574 /* Clear out the mouse-highlighted active region.
7575 Redraw it un-highlighted first. */
7578 clear_mouse_face (dpyinfo
)
7579 struct w32_display_info
*dpyinfo
;
7583 if (! NILP (dpyinfo
->mouse_face_window
))
7585 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
7589 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7590 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7591 dpyinfo
->mouse_face_window
= Qnil
;
7592 dpyinfo
->mouse_face_overlay
= Qnil
;
7597 /* Clear any mouse-face on window W. This function is part of the
7598 redisplay interface, and is called from try_window_id and similar
7599 functions to ensure the mouse-highlight is off. */
7602 x_clear_mouse_face (w
)
7605 struct w32_display_info
*dpyinfo
7606 = FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
7610 XSETWINDOW (window
, w
);
7611 if (EQ (window
, dpyinfo
->mouse_face_window
))
7612 clear_mouse_face (dpyinfo
);
7617 /* Just discard the mouse face information for frame F, if any.
7618 This is used when the size of F is changed. */
7621 cancel_mouse_face (f
)
7625 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
7627 window
= dpyinfo
->mouse_face_window
;
7628 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
7630 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7631 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7632 dpyinfo
->mouse_face_window
= Qnil
;
7636 static struct scroll_bar
*x_window_to_scroll_bar ();
7637 static void x_scroll_bar_report_motion ();
7638 static void x_check_fullscreen
P_ ((struct frame
*));
7639 static void x_check_fullscreen_move
P_ ((struct frame
*));
7640 static int glyph_rect
P_ ((struct frame
*f
, int, int, RECT
*));
7643 /* Try to determine frame pixel position and size of the glyph under
7644 frame pixel coordinates X/Y on frame F . Return the position and
7645 size in *RECT. Value is non-zero if we could compute these
7649 glyph_rect (f
, x
, y
, rect
)
7657 window
= window_from_coordinates (f
, x
, y
, &part
, 0);
7660 struct window
*w
= XWINDOW (window
);
7661 struct glyph_row
*r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7662 struct glyph_row
*end
= r
+ w
->current_matrix
->nrows
- 1;
7664 frame_to_window_pixel_xy (w
, &x
, &y
);
7666 for (; r
< end
&& r
->enabled_p
; ++r
)
7667 if (r
->y
<= y
&& r
->y
+ r
->height
> y
)
7669 /* Found the row at y. */
7670 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
7671 struct glyph
*end
= g
+ r
->used
[TEXT_AREA
];
7674 rect
->top
= WINDOW_TO_FRAME_PIXEL_Y (w
, r
->y
);
7675 rect
->bottom
= rect
->top
+ r
->height
;
7679 /* x is to the left of the first glyph in the row. */
7680 rect
->left
= XINT (w
->left
);
7681 rect
->right
= WINDOW_TO_FRAME_PIXEL_X (w
, r
->x
);
7685 for (gx
= r
->x
; g
< end
; gx
+= g
->pixel_width
, ++g
)
7686 if (gx
<= x
&& gx
+ g
->pixel_width
> x
)
7688 /* x is on a glyph. */
7689 rect
->left
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
7690 rect
->right
= rect
->left
+ g
->pixel_width
;
7694 /* x is to the right of the last glyph in the row. */
7695 rect
->left
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
7696 rect
->right
= XINT (w
->left
) + XINT (w
->width
);
7701 /* The y is not on any row. */
7705 /* Record the position of the mouse in last_mouse_glyph. */
7707 remember_mouse_glyph (f1
, gx
, gy
)
7711 if (!glyph_rect (f1
, gx
, gy
, &last_mouse_glyph
))
7713 int width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
7714 int height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
7716 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
7717 round down even for negative values. */
7723 /* This was the original code from XTmouse_position, but it seems
7724 to give the position of the glyph diagonally next to the one
7725 the mouse is over. */
7726 gx
= (gx
+ width
- 1) / width
* width
;
7727 gy
= (gy
+ height
- 1) / height
* height
;
7729 gx
= gx
/ width
* width
;
7730 gy
= gy
/ height
* height
;
7733 last_mouse_glyph
.left
= gx
;
7734 last_mouse_glyph
.top
= gy
;
7735 last_mouse_glyph
.right
= gx
+ width
;
7736 last_mouse_glyph
.bottom
= gy
+ height
;
7740 /* Return the current position of the mouse.
7741 *fp should be a frame which indicates which display to ask about.
7743 If the mouse movement started in a scroll bar, set *fp, *bar_window,
7744 and *part to the frame, window, and scroll bar part that the mouse
7745 is over. Set *x and *y to the portion and whole of the mouse's
7746 position on the scroll bar.
7748 If the mouse movement started elsewhere, set *fp to the frame the
7749 mouse is on, *bar_window to nil, and *x and *y to the character cell
7752 Set *time to the server time-stamp for the time at which the mouse
7753 was at this position.
7755 Don't store anything if we don't have a valid set of values to report.
7757 This clears the mouse_moved flag, so we can wait for the next mouse
7761 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
7764 Lisp_Object
*bar_window
;
7765 enum scroll_bar_part
*part
;
7767 unsigned long *time
;
7773 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
7774 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
7779 Lisp_Object frame
, tail
;
7781 /* Clear the mouse-moved flag for every frame on this display. */
7782 FOR_EACH_FRAME (tail
, frame
)
7783 XFRAME (frame
)->mouse_moved
= 0;
7785 last_mouse_scroll_bar
= Qnil
;
7789 /* Now we have a position on the root; find the innermost window
7790 containing the pointer. */
7792 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
7793 && FRAME_LIVE_P (last_mouse_frame
))
7795 /* If mouse was grabbed on a frame, give coords for that frame
7796 even if the mouse is now outside it. */
7797 f1
= last_mouse_frame
;
7801 /* Is window under mouse one of our frames? */
7802 f1
= x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
7803 WindowFromPoint (pt
));
7806 /* If not, is it one of our scroll bars? */
7809 struct scroll_bar
*bar
7810 = x_window_to_scroll_bar (WindowFromPoint (pt
));
7814 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7818 if (f1
== 0 && insist
> 0)
7819 f1
= SELECTED_FRAME ();
7823 /* Ok, we found a frame. Store all the values.
7824 last_mouse_glyph is a rectangle used to reduce the
7825 generation of mouse events. To not miss any motion
7826 events, we must divide the frame into rectangles of the
7827 size of the smallest character that could be displayed
7828 on it, i.e. into the same rectangles that matrices on
7829 the frame are divided into. */
7831 #if OLD_REDISPLAY_CODE
7832 int ignore1
, ignore2
;
7834 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
7836 pixel_to_glyph_coords (f1
, pt
.x
, pt
.y
, &ignore1
, &ignore2
,
7838 FRAME_W32_DISPLAY_INFO (f1
)->grabbed
7841 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
7842 remember_mouse_glyph (f1
, pt
.x
, pt
.y
);
7850 *time
= last_mouse_movement_time
;
7859 /* Scroll bar support. */
7861 /* Given a window ID, find the struct scroll_bar which manages it.
7862 This can be called in GC, so we have to make sure to strip off mark
7865 static struct scroll_bar
*
7866 x_window_to_scroll_bar (window_id
)
7871 for (tail
= Vframe_list
;
7872 XGCTYPE (tail
) == Lisp_Cons
;
7875 Lisp_Object frame
, bar
, condemned
;
7877 frame
= XCAR (tail
);
7878 /* All elements of Vframe_list should be frames. */
7879 if (! GC_FRAMEP (frame
))
7882 /* Scan this frame's scroll bar list for a scroll bar with the
7884 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
7885 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
7886 /* This trick allows us to search both the ordinary and
7887 condemned scroll bar lists with one loop. */
7888 ! GC_NILP (bar
) || (bar
= condemned
,
7891 bar
= XSCROLL_BAR (bar
)->next
)
7892 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
7893 return XSCROLL_BAR (bar
);
7901 /* Set the thumb size and position of scroll bar BAR. We are currently
7902 displaying PORTION out of a whole WHOLE, and our position POSITION. */
7905 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
)
7906 struct scroll_bar
*bar
;
7907 int portion
, position
, whole
;
7909 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
7910 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
7911 int sb_page
, sb_pos
;
7912 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
7916 /* Position scroll bar at rock bottom if the bottom of the
7917 buffer is visible. This avoids shinking the thumb away
7918 to nothing if it is held at the bottom of the buffer. */
7919 if (position
+ portion
>= whole
)
7921 sb_page
= range
* (whole
- position
) / whole
7922 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
7926 sb_page
= portion
* range
/ whole
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
7927 sb_pos
= position
* range
/ whole
;
7937 if (pfnSetScrollInfo
)
7941 si
.cbSize
= sizeof (si
);
7942 /* Only update page size if currently dragging, to reduce
7945 si
.fMask
= SIF_PAGE
;
7947 si
.fMask
= SIF_PAGE
| SIF_POS
;
7951 pfnSetScrollInfo (w
, SB_CTL
, &si
, !draggingp
);
7954 SetScrollPos (w
, SB_CTL
, sb_pos
, !draggingp
);
7960 /************************************************************************
7961 Scroll bars, general
7962 ************************************************************************/
7965 my_create_scrollbar (f
, bar
)
7967 struct scroll_bar
* bar
;
7969 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
7970 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
7974 /*#define ATTACH_THREADS*/
7977 my_show_window (FRAME_PTR f
, HWND hwnd
, int how
)
7979 #ifndef ATTACH_THREADS
7980 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
7981 (WPARAM
) hwnd
, (LPARAM
) how
);
7983 return ShowWindow (hwnd
, how
);
7988 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
7989 int x
, int y
, int cx
, int cy
, UINT flags
)
7991 #ifndef ATTACH_THREADS
7993 pos
.hwndInsertAfter
= hwndAfter
;
7999 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
8001 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
8006 my_set_focus (f
, hwnd
)
8010 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
8015 my_set_foreground_window (hwnd
)
8018 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
8022 my_destroy_window (f
, hwnd
)
8026 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
8030 /* Create a scroll bar and return the scroll bar vector for it. W is
8031 the Emacs window on which to create the scroll bar. TOP, LEFT,
8032 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
8035 static struct scroll_bar
*
8036 x_scroll_bar_create (w
, top
, left
, width
, height
)
8038 int top
, left
, width
, height
;
8040 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8042 struct scroll_bar
*bar
8043 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
8047 XSETWINDOW (bar
->window
, w
);
8048 XSETINT (bar
->top
, top
);
8049 XSETINT (bar
->left
, left
);
8050 XSETINT (bar
->width
, width
);
8051 XSETINT (bar
->height
, height
);
8052 XSETINT (bar
->start
, 0);
8053 XSETINT (bar
->end
, 0);
8054 bar
->dragging
= Qnil
;
8056 /* Requires geometry to be set before call to create the real window */
8058 hwnd
= my_create_scrollbar (f
, bar
);
8060 if (pfnSetScrollInfo
)
8064 si
.cbSize
= sizeof (si
);
8067 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
8068 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8072 pfnSetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
8076 SetScrollRange (hwnd
, SB_CTL
, 0,
8077 VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
), FALSE
);
8078 SetScrollPos (hwnd
, SB_CTL
, 0, FALSE
);
8081 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
8083 /* Add bar to its frame's list of scroll bars. */
8084 bar
->next
= FRAME_SCROLL_BARS (f
);
8086 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8087 if (! NILP (bar
->next
))
8088 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8096 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
8100 x_scroll_bar_remove (bar
)
8101 struct scroll_bar
*bar
;
8103 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8107 /* Destroy the window. */
8108 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
8110 /* Disassociate this scroll bar from its window. */
8111 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
8116 /* Set the handle of the vertical scroll bar for WINDOW to indicate
8117 that we are displaying PORTION characters out of a total of WHOLE
8118 characters, starting at POSITION. If WINDOW has no scroll bar,
8121 w32_set_vertical_scroll_bar (w
, portion
, whole
, position
)
8123 int portion
, whole
, position
;
8125 struct frame
*f
= XFRAME (w
->frame
);
8126 struct scroll_bar
*bar
;
8127 int top
, height
, left
, sb_left
, width
, sb_width
;
8128 int window_x
, window_y
, window_width
, window_height
;
8130 /* Get window dimensions. */
8131 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
8133 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
8134 height
= window_height
;
8136 /* Compute the left edge of the scroll bar area. */
8137 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8138 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
8140 left
= XFASTINT (w
->left
);
8141 left
*= CANON_X_UNIT (f
);
8142 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
8144 /* Compute the width of the scroll bar which might be less than
8145 the width of the area reserved for the scroll bar. */
8146 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
8147 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
8151 /* Compute the left edge of the scroll bar. */
8152 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8153 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
8155 sb_left
= left
+ (width
- sb_width
) / 2;
8157 /* Does the scroll bar exist yet? */
8158 if (NILP (w
->vertical_scroll_bar
))
8162 if (width
> 0 && height
> 0)
8164 hdc
= get_frame_dc (f
);
8165 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
8166 release_frame_dc (f
, hdc
);
8170 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
8174 /* It may just need to be moved and resized. */
8177 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
8178 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
8180 /* If already correctly positioned, do nothing. */
8181 if ( XINT (bar
->left
) == sb_left
8182 && XINT (bar
->top
) == top
8183 && XINT (bar
->width
) == sb_width
8184 && XINT (bar
->height
) == height
)
8186 /* Redraw after clear_frame. */
8187 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
8188 InvalidateRect (hwnd
, NULL
, FALSE
);
8194 if (width
&& height
)
8196 hdc
= get_frame_dc (f
);
8197 /* Since Windows scroll bars are smaller than the space reserved
8198 for them on the frame, we have to clear "under" them. */
8199 w32_clear_area (f
, hdc
,
8204 release_frame_dc (f
, hdc
);
8206 /* Make sure scroll bar is "visible" before moving, to ensure the
8207 area of the parent window now exposed will be refreshed. */
8208 my_show_window (f
, hwnd
, SW_HIDE
);
8209 MoveWindow (hwnd
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8210 top
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8211 max (height
, 1), TRUE
);
8212 if (pfnSetScrollInfo
)
8216 si
.cbSize
= sizeof (si
);
8217 si
.fMask
= SIF_RANGE
;
8219 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
8220 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8222 pfnSetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
8225 SetScrollRange (hwnd
, SB_CTL
, 0,
8226 VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
), FALSE
);
8227 my_show_window (f
, hwnd
, SW_NORMAL
);
8228 /* InvalidateRect (w, NULL, FALSE); */
8230 /* Remember new settings. */
8231 XSETINT (bar
->left
, sb_left
);
8232 XSETINT (bar
->top
, top
);
8233 XSETINT (bar
->width
, sb_width
);
8234 XSETINT (bar
->height
, height
);
8239 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
8241 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
8245 /* The following three hooks are used when we're doing a thorough
8246 redisplay of the frame. We don't explicitly know which scroll bars
8247 are going to be deleted, because keeping track of when windows go
8248 away is a real pain - "Can you say set-window-configuration, boys
8249 and girls?" Instead, we just assert at the beginning of redisplay
8250 that *all* scroll bars are to be removed, and then save a scroll bar
8251 from the fiery pit when we actually redisplay its window. */
8253 /* Arrange for all scroll bars on FRAME to be removed at the next call
8254 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
8255 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
8258 w32_condemn_scroll_bars (frame
)
8261 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
8262 while (! NILP (FRAME_SCROLL_BARS (frame
)))
8265 bar
= FRAME_SCROLL_BARS (frame
);
8266 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
8267 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
8268 XSCROLL_BAR (bar
)->prev
= Qnil
;
8269 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
8270 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
8271 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
8276 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
8277 Note that WINDOW isn't necessarily condemned at all. */
8280 w32_redeem_scroll_bar (window
)
8281 struct window
*window
;
8283 struct scroll_bar
*bar
;
8286 /* We can't redeem this window's scroll bar if it doesn't have one. */
8287 if (NILP (window
->vertical_scroll_bar
))
8290 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
8292 /* Unlink it from the condemned list. */
8293 f
= XFRAME (WINDOW_FRAME (window
));
8294 if (NILP (bar
->prev
))
8296 /* If the prev pointer is nil, it must be the first in one of
8298 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
8299 /* It's not condemned. Everything's fine. */
8301 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
8302 window
->vertical_scroll_bar
))
8303 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
8305 /* If its prev pointer is nil, it must be at the front of
8306 one or the other! */
8310 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
8312 if (! NILP (bar
->next
))
8313 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
8315 bar
->next
= FRAME_SCROLL_BARS (f
);
8317 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8318 if (! NILP (bar
->next
))
8319 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8322 /* Remove all scroll bars on FRAME that haven't been saved since the
8323 last call to `*condemn_scroll_bars_hook'. */
8326 w32_judge_scroll_bars (f
)
8329 Lisp_Object bar
, next
;
8331 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
8333 /* Clear out the condemned list now so we won't try to process any
8334 more events on the hapless scroll bars. */
8335 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
8337 for (; ! NILP (bar
); bar
= next
)
8339 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
8341 x_scroll_bar_remove (b
);
8344 b
->next
= b
->prev
= Qnil
;
8347 /* Now there should be no references to the condemned scroll bars,
8348 and they should get garbage-collected. */
8351 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
8352 is set to something other than NO_EVENT, it is enqueued.
8354 This may be called from a signal handler, so we have to ignore GC
8358 w32_scroll_bar_handle_click (bar
, msg
, emacs_event
)
8359 struct scroll_bar
*bar
;
8361 struct input_event
*emacs_event
;
8363 if (! GC_WINDOWP (bar
->window
))
8366 emacs_event
->kind
= W32_SCROLL_BAR_CLICK_EVENT
;
8367 emacs_event
->code
= 0;
8368 /* not really meaningful to distinguish up/down */
8369 emacs_event
->modifiers
= msg
->dwModifiers
;
8370 emacs_event
->frame_or_window
= bar
->window
;
8371 emacs_event
->arg
= Qnil
;
8372 emacs_event
->timestamp
= msg
->msg
.time
;
8375 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8377 int dragging
= !NILP (bar
->dragging
);
8379 if (pfnGetScrollInfo
)
8383 si
.cbSize
= sizeof (si
);
8386 pfnGetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
8390 y
= GetScrollPos ((HWND
) msg
->msg
.lParam
, SB_CTL
);
8392 bar
->dragging
= Qnil
;
8395 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
8397 switch (LOWORD (msg
->msg
.wParam
))
8400 emacs_event
->part
= scroll_bar_down_arrow
;
8403 emacs_event
->part
= scroll_bar_up_arrow
;
8406 emacs_event
->part
= scroll_bar_above_handle
;
8409 emacs_event
->part
= scroll_bar_below_handle
;
8412 emacs_event
->part
= scroll_bar_handle
;
8416 emacs_event
->part
= scroll_bar_handle
;
8420 case SB_THUMBPOSITION
:
8421 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
8422 y
= HIWORD (msg
->msg
.wParam
);
8424 emacs_event
->part
= scroll_bar_handle
;
8426 /* "Silently" update current position. */
8427 if (pfnSetScrollInfo
)
8431 si
.cbSize
= sizeof (si
);
8434 /* Remember apparent position (we actually lag behind the real
8435 position, so don't set that directly. */
8436 last_scroll_bar_drag_pos
= y
;
8438 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
8441 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, FALSE
);
8444 /* If this is the end of a drag sequence, then reset the scroll
8445 handle size to normal and do a final redraw. Otherwise do
8449 if (pfnSetScrollInfo
)
8452 int start
= XINT (bar
->start
);
8453 int end
= XINT (bar
->end
);
8455 si
.cbSize
= sizeof (si
);
8456 si
.fMask
= SIF_PAGE
| SIF_POS
;
8457 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8458 si
.nPos
= last_scroll_bar_drag_pos
;
8459 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
8462 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, TRUE
);
8466 emacs_event
->kind
= NO_EVENT
;
8470 XSETINT (emacs_event
->x
, y
);
8471 XSETINT (emacs_event
->y
, top_range
);
8477 /* Return information to the user about the current position of the mouse
8478 on the scroll bar. */
8481 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
8483 Lisp_Object
*bar_window
;
8484 enum scroll_bar_part
*part
;
8486 unsigned long *time
;
8488 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
8489 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
8490 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8492 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8497 *bar_window
= bar
->window
;
8499 if (pfnGetScrollInfo
)
8503 si
.cbSize
= sizeof (si
);
8504 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
8506 pfnGetScrollInfo (w
, SB_CTL
, &si
);
8508 top_range
= si
.nMax
- si
.nPage
+ 1;
8511 pos
= GetScrollPos (w
, SB_CTL
);
8513 switch (LOWORD (last_mouse_scroll_bar_pos
))
8515 case SB_THUMBPOSITION
:
8517 *part
= scroll_bar_handle
;
8518 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
8519 pos
= HIWORD (last_mouse_scroll_bar_pos
);
8522 *part
= scroll_bar_handle
;
8526 *part
= scroll_bar_handle
;
8531 XSETINT (*y
, top_range
);
8534 last_mouse_scroll_bar
= Qnil
;
8536 *time
= last_mouse_movement_time
;
8542 /* The screen has been cleared so we may have changed foreground or
8543 background colors, and the scroll bars may need to be redrawn.
8544 Clear out the scroll bars, and ask for expose events, so we can
8548 x_scroll_bar_clear (f
)
8553 /* We can have scroll bars even if this is 0,
8554 if we just turned off scroll bar mode.
8555 But in that case we should not clear them. */
8556 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
8557 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
8558 bar
= XSCROLL_BAR (bar
)->next
)
8560 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
8561 HDC hdc
= GetDC (window
);
8564 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
8565 arranges to refresh the scroll bar if hidden. */
8566 my_show_window (f
, window
, SW_HIDE
);
8568 GetClientRect (window
, &rect
);
8569 select_palette (f
, hdc
);
8570 w32_clear_rect (f
, hdc
, &rect
);
8571 deselect_palette (f
, hdc
);
8573 ReleaseDC (window
, hdc
);
8578 /* The main W32 event-reading loop - w32_read_socket. */
8580 /* Record the last 100 characters stored
8581 to help debug the loss-of-chars-during-GC problem. */
8583 static int temp_index
;
8584 static short temp_buffer
[100];
8587 /* Read events coming from the W32 shell.
8588 This routine is called by the SIGIO handler.
8589 We return as soon as there are no more events to be read.
8591 Events representing keys are stored in buffer BUFP,
8592 which can hold up to NUMCHARS characters.
8593 We return the number of characters stored into the buffer,
8594 thus pretending to be `read'.
8596 EXPECTED is nonzero if the caller knows input is available.
8598 Some of these messages are reposted back to the message queue since the
8599 system calls the windows proc directly in a context where we cannot return
8600 the data nor can we guarantee the state we are in. So if we dispatch them
8601 we will get into an infinite loop. To prevent this from ever happening we
8602 will set a variable to indicate we are in the read_socket call and indicate
8603 which message we are processing since the windows proc gets called
8604 recursively with different messages by the system.
8608 w32_read_socket (sd
, bufp
, numchars
, expected
)
8610 /* register */ struct input_event
*bufp
;
8611 /* register */ int numchars
;
8615 int check_visibility
= 0;
8618 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
8620 if (interrupt_input_blocked
)
8622 interrupt_input_pending
= 1;
8626 interrupt_input_pending
= 0;
8629 /* So people can tell when we have read the available input. */
8630 input_signal_count
++;
8633 abort (); /* Don't think this happens. */
8635 /* TODO: tool-bars, ghostscript integration, mouse
8637 while (get_next_msg (&msg
, FALSE
))
8639 switch (msg
.msg
.message
)
8642 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8646 if (msg
.rect
.right
== msg
.rect
.left
||
8647 msg
.rect
.bottom
== msg
.rect
.top
)
8649 /* We may get paint messages even though the client
8650 area is clipped - these are not expose events. */
8651 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
8654 else if (f
->async_visible
!= 1)
8656 /* Definitely not obscured, so mark as visible. */
8657 f
->async_visible
= 1;
8658 f
->async_iconified
= 0;
8659 SET_FRAME_GARBAGED (f
);
8660 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
8663 /* WM_PAINT serves as MapNotify as well, so report
8664 visibility changes properly. */
8667 bufp
->kind
= DEICONIFY_EVENT
;
8668 XSETFRAME (bufp
->frame_or_window
, f
);
8674 else if (! NILP (Vframe_list
)
8675 && ! NILP (XCDR (Vframe_list
)))
8676 /* Force a redisplay sooner or later to update the
8677 frame titles in case this is the second frame. */
8678 record_asynch_buffer_change ();
8682 HDC hdc
= get_frame_dc (f
);
8684 /* Erase background again for safety. */
8685 w32_clear_rect (f
, hdc
, &msg
.rect
);
8686 release_frame_dc (f
, hdc
);
8690 msg
.rect
.right
- msg
.rect
.left
,
8691 msg
.rect
.bottom
- msg
.rect
.top
);
8696 case WM_INPUTLANGCHANGE
:
8697 /* Generate a language change event. */
8698 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8705 bufp
->kind
= LANGUAGE_CHANGE_EVENT
;
8706 XSETFRAME (bufp
->frame_or_window
, f
);
8708 bufp
->code
= msg
.msg
.wParam
;
8709 bufp
->modifiers
= msg
.msg
.lParam
& 0xffff;
8718 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8720 if (f
&& !f
->iconified
)
8722 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
8724 dpyinfo
->mouse_face_hidden
= 1;
8725 clear_mouse_face (dpyinfo
);
8728 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
8730 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
8731 bufp
->kind
= NON_ASCII_KEYSTROKE_EVENT
;
8732 bufp
->code
= msg
.msg
.wParam
;
8733 bufp
->modifiers
= msg
.dwModifiers
;
8734 XSETFRAME (bufp
->frame_or_window
, f
);
8736 bufp
->timestamp
= msg
.msg
.time
;
8745 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8747 if (f
&& !f
->iconified
)
8749 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
8751 dpyinfo
->mouse_face_hidden
= 1;
8752 clear_mouse_face (dpyinfo
);
8755 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
8757 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
8758 bufp
->kind
= ASCII_KEYSTROKE_EVENT
;
8759 bufp
->code
= msg
.msg
.wParam
;
8760 bufp
->modifiers
= msg
.dwModifiers
;
8761 XSETFRAME (bufp
->frame_or_window
, f
);
8763 bufp
->timestamp
= msg
.msg
.time
;
8771 /* Ignore non-movement. */
8773 int x
= LOWORD (msg
.msg
.lParam
);
8774 int y
= HIWORD (msg
.msg
.lParam
);
8775 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
8777 last_mousemove_x
= x
;
8778 last_mousemove_y
= y
;
8781 previous_help_echo
= help_echo
;
8783 if (dpyinfo
->grabbed
&& last_mouse_frame
8784 && FRAME_LIVE_P (last_mouse_frame
))
8785 f
= last_mouse_frame
;
8787 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8789 if (dpyinfo
->mouse_face_hidden
)
8791 dpyinfo
->mouse_face_hidden
= 0;
8792 clear_mouse_face (dpyinfo
);
8796 note_mouse_movement (f
, &msg
.msg
);
8799 /* If we move outside the frame, then we're
8800 certainly no longer on any text in the frame. */
8801 clear_mouse_face (dpyinfo
);
8804 /* If the contents of the global variable help_echo
8805 has changed, generate a HELP_EVENT. */
8806 if (help_echo
!= previous_help_echo
||
8807 (!NILP (help_echo
) && !STRINGP (help_echo
) && f
->mouse_moved
))
8812 if (help_echo
== Qnil
)
8814 help_echo_object
= help_echo_window
= Qnil
;
8819 XSETFRAME (frame
, f
);
8823 any_help_event_p
= 1;
8824 n
= gen_help_event (bufp
, numchars
, help_echo
, frame
,
8825 help_echo_window
, help_echo_object
,
8827 bufp
+= n
, count
+= n
, numchars
-= n
;
8831 case WM_LBUTTONDOWN
:
8833 case WM_MBUTTONDOWN
:
8835 case WM_RBUTTONDOWN
:
8837 case WM_XBUTTONDOWN
:
8840 /* If we decide we want to generate an event to be seen
8841 by the rest of Emacs, we put it here. */
8842 struct input_event emacs_event
;
8847 emacs_event
.kind
= NO_EVENT
;
8849 if (dpyinfo
->grabbed
&& last_mouse_frame
8850 && FRAME_LIVE_P (last_mouse_frame
))
8851 f
= last_mouse_frame
;
8853 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8857 construct_mouse_click (&emacs_event
, &msg
, f
);
8859 /* Is this in the tool-bar? */
8860 if (WINDOWP (f
->tool_bar_window
)
8861 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
))
8866 x
= XFASTINT (emacs_event
.x
);
8867 y
= XFASTINT (emacs_event
.y
);
8870 window
= window_from_coordinates (f
, x
, y
, &p
, 1);
8872 if (EQ (window
, f
->tool_bar_window
))
8874 w32_handle_tool_bar_click (f
, &emacs_event
);
8880 if (!dpyinfo
->w32_focus_frame
8881 || f
== dpyinfo
->w32_focus_frame
8884 construct_mouse_click (bufp
, &msg
, f
);
8891 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
8896 dpyinfo
->grabbed
&= ~ (1 << button
);
8900 dpyinfo
->grabbed
|= (1 << button
);
8901 last_mouse_frame
= f
;
8902 /* Ignore any mouse motion that happened
8903 before this event; any subsequent mouse-movement
8904 Emacs events should reflect only motion after
8910 last_tool_bar_item
= -1;
8916 if (dpyinfo
->grabbed
&& last_mouse_frame
8917 && FRAME_LIVE_P (last_mouse_frame
))
8918 f
= last_mouse_frame
;
8920 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8924 if ((!dpyinfo
->w32_focus_frame
8925 || f
== dpyinfo
->w32_focus_frame
)
8928 construct_mouse_wheel (bufp
, &msg
, f
);
8937 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8941 construct_drag_n_drop (bufp
, &msg
, f
);
8950 struct scroll_bar
*bar
=
8951 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
8953 if (bar
&& numchars
>= 1)
8955 if (w32_scroll_bar_handle_click (bar
, &msg
, bufp
))
8965 case WM_WINDOWPOSCHANGED
:
8966 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8969 x_check_fullscreen_move(f
);
8970 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_WAIT
)
8971 f
->output_data
.w32
->want_fullscreen
&=
8972 ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
8974 check_visibility
= 1;
8978 case WM_ACTIVATEAPP
:
8979 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8981 x_check_fullscreen (f
);
8982 check_visibility
= 1;
8986 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8988 if (f
&& !f
->async_iconified
)
8992 x_real_positions (f
, &x
, &y
);
8993 f
->output_data
.w32
->left_pos
= x
;
8994 f
->output_data
.w32
->top_pos
= y
;
8997 check_visibility
= 1;
9001 /* wParam non-zero means Window is about to be shown, 0 means
9002 about to be hidden. */
9003 /* Redo the mouse-highlight after the tooltip has gone. */
9004 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
9007 redo_mouse_highlight ();
9010 /* If window has been obscured or exposed by another window
9011 being maximised or minimised/restored, then recheck
9012 visibility of all frames. Direct changes to our own
9013 windows get handled by WM_SIZE. */
9015 if (msg
.msg
.lParam
!= 0)
9016 check_visibility
= 1;
9019 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9020 f
->async_visible
= msg
.msg
.wParam
;
9024 check_visibility
= 1;
9028 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9030 /* Inform lisp of whether frame has been iconified etc. */
9033 switch (msg
.msg
.wParam
)
9035 case SIZE_MINIMIZED
:
9036 f
->async_visible
= 0;
9037 f
->async_iconified
= 1;
9039 bufp
->kind
= ICONIFY_EVENT
;
9040 XSETFRAME (bufp
->frame_or_window
, f
);
9047 case SIZE_MAXIMIZED
:
9049 f
->async_visible
= 1;
9050 f
->async_iconified
= 0;
9052 /* wait_reading_process_input will notice this and update
9053 the frame's display structures. */
9054 SET_FRAME_GARBAGED (f
);
9060 /* Reset top and left positions of the Window
9061 here since Windows sends a WM_MOVE message
9062 BEFORE telling us the Window is minimized
9063 when the Window is iconified, with 3000,3000
9065 x_real_positions (f
, &x
, &y
);
9066 f
->output_data
.w32
->left_pos
= x
;
9067 f
->output_data
.w32
->top_pos
= y
;
9069 bufp
->kind
= DEICONIFY_EVENT
;
9070 XSETFRAME (bufp
->frame_or_window
, f
);
9076 else if (! NILP (Vframe_list
)
9077 && ! NILP (XCDR (Vframe_list
)))
9078 /* Force a redisplay sooner or later
9079 to update the frame titles
9080 in case this is the second frame. */
9081 record_asynch_buffer_change ();
9086 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
9094 GetClientRect (msg
.msg
.hwnd
, &rect
);
9096 height
= rect
.bottom
- rect
.top
;
9097 width
= rect
.right
- rect
.left
;
9099 rows
= PIXEL_TO_CHAR_HEIGHT (f
, height
);
9100 columns
= PIXEL_TO_CHAR_WIDTH (f
, width
);
9102 /* TODO: Clip size to the screen dimensions. */
9104 /* Even if the number of character rows and columns has
9105 not changed, the font size may have changed, so we need
9106 to check the pixel dimensions as well. */
9108 if (columns
!= f
->width
9109 || rows
!= f
->height
9110 || width
!= f
->output_data
.w32
->pixel_width
9111 || height
!= f
->output_data
.w32
->pixel_height
)
9113 change_frame_size (f
, rows
, columns
, 0, 1, 0);
9114 SET_FRAME_GARBAGED (f
);
9115 cancel_mouse_face (f
);
9116 f
->output_data
.w32
->pixel_width
= width
;
9117 f
->output_data
.w32
->pixel_height
= height
;
9118 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
9122 check_visibility
= 1;
9126 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9129 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9131 /* If we move outside the frame, then we're
9132 certainly no longer on any text in the frame. */
9133 clear_mouse_face (dpyinfo
);
9134 dpyinfo
->mouse_face_mouse_frame
= 0;
9137 /* Generate a nil HELP_EVENT to cancel a help-echo.
9138 Do it only if there's something to cancel.
9139 Otherwise, the startup message is cleared when
9140 the mouse leaves the frame. */
9141 if (any_help_event_p
)
9146 XSETFRAME (frame
, f
);
9148 n
= gen_help_event (bufp
, numchars
,
9149 Qnil
, frame
, Qnil
, Qnil
, 0);
9150 bufp
+= n
, count
+= n
, numchars
-= n
;
9156 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9158 dpyinfo
->w32_focus_event_frame
= f
;
9161 x_new_focus_frame (dpyinfo
, f
);
9164 dpyinfo
->grabbed
= 0;
9165 check_visibility
= 1;
9169 /* TODO: some of this belongs in MOUSE_LEAVE */
9170 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9174 if (f
== dpyinfo
->w32_focus_event_frame
)
9175 dpyinfo
->w32_focus_event_frame
= 0;
9177 if (f
== dpyinfo
->w32_focus_frame
)
9178 x_new_focus_frame (dpyinfo
, 0);
9180 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9182 /* If we move outside the frame, then we're
9183 certainly no longer on any text in the frame. */
9184 clear_mouse_face (dpyinfo
);
9185 dpyinfo
->mouse_face_mouse_frame
= 0;
9188 /* Generate a nil HELP_EVENT to cancel a help-echo.
9189 Do it only if there's something to cancel.
9190 Otherwise, the startup message is cleared when
9191 the mouse leaves the frame. */
9192 if (any_help_event_p
)
9197 XSETFRAME (frame
, f
);
9199 n
= gen_help_event (bufp
, numchars
,
9200 Qnil
, frame
, Qnil
, Qnil
, 0);
9201 bufp
+= n
, count
+= n
, numchars
-=n
;
9205 dpyinfo
->grabbed
= 0;
9206 check_visibility
= 1;
9210 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9217 bufp
->kind
= DELETE_WINDOW_EVENT
;
9218 XSETFRAME (bufp
->frame_or_window
, f
);
9227 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9234 bufp
->kind
= MENU_BAR_ACTIVATE_EVENT
;
9235 XSETFRAME (bufp
->frame_or_window
, f
);
9244 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9248 extern void menubar_selection_callback
9249 (FRAME_PTR f
, void * client_data
);
9250 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
9253 check_visibility
= 1;
9256 case WM_DISPLAYCHANGE
:
9257 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9261 dpyinfo
->width
= (short) LOWORD (msg
.msg
.lParam
);
9262 dpyinfo
->height
= (short) HIWORD (msg
.msg
.lParam
);
9263 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
9264 DebPrint (("display change: %d %d\n", dpyinfo
->width
,
9268 check_visibility
= 1;
9272 /* Check for messages registered at runtime. */
9273 if (msg
.msg
.message
== msh_mousewheel
)
9275 if (dpyinfo
->grabbed
&& last_mouse_frame
9276 && FRAME_LIVE_P (last_mouse_frame
))
9277 f
= last_mouse_frame
;
9279 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9283 if ((!dpyinfo
->w32_focus_frame
9284 || f
== dpyinfo
->w32_focus_frame
)
9287 construct_mouse_wheel (bufp
, &msg
, f
);
9298 /* If the focus was just given to an autoraising frame,
9300 /* ??? This ought to be able to handle more than one such frame. */
9301 if (pending_autoraise_frame
)
9303 x_raise_frame (pending_autoraise_frame
);
9304 pending_autoraise_frame
= 0;
9307 /* Check which frames are still visisble, if we have enqueued any user
9308 events or been notified of events that may affect visibility. We
9309 do this here because there doesn't seem to be any direct
9310 notification from Windows that the visibility of a window has
9311 changed (at least, not in all cases). */
9312 if (count
> 0 || check_visibility
)
9314 Lisp_Object tail
, frame
;
9316 FOR_EACH_FRAME (tail
, frame
)
9318 FRAME_PTR f
= XFRAME (frame
);
9319 /* The tooltip has been drawn already. Avoid the
9320 SET_FRAME_GARBAGED below. */
9321 if (EQ (frame
, tip_frame
))
9324 /* Check "visible" frames and mark each as obscured or not.
9325 Note that async_visible is nonzero for unobscured and
9326 obscured frames, but zero for hidden and iconified frames. */
9327 if (FRAME_W32_P (f
) && f
->async_visible
)
9333 /* Query clipping rectangle for the entire window area
9334 (GetWindowDC), not just the client portion (GetDC).
9335 Otherwise, the scrollbars and menubar aren't counted as
9336 part of the visible area of the frame, and we may think
9337 the frame is obscured when really a scrollbar is still
9338 visible and gets WM_PAINT messages above. */
9339 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
9340 GetClipBox (hdc
, &clipbox
);
9341 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
9344 if (clipbox
.right
== clipbox
.left
9345 || clipbox
.bottom
== clipbox
.top
)
9347 /* Frame has become completely obscured so mark as
9348 such (we do this by setting async_visible to 2 so
9349 that FRAME_VISIBLE_P is still true, but redisplay
9351 f
->async_visible
= 2;
9353 if (!FRAME_OBSCURED_P (f
))
9355 DebPrint (("frame %p (%s) obscured\n", f
,
9361 /* Frame is not obscured, so mark it as such. */
9362 f
->async_visible
= 1;
9364 if (FRAME_OBSCURED_P (f
))
9366 SET_FRAME_GARBAGED (f
);
9367 DebPrint (("obscured frame %p (%s) found to be visible\n", f
,
9370 /* Force a redisplay sooner or later. */
9371 record_asynch_buffer_change ();
9385 /***********************************************************************
9387 ***********************************************************************/
9389 /* Notice if the text cursor of window W has been overwritten by a
9390 drawing operation that outputs glyphs starting at START_X and
9391 ending at END_X in the line given by output_cursor.vpos.
9392 Coordinates are area-relative. END_X < 0 means all the rest
9393 of the line after START_X has been written. */
9396 notice_overwritten_cursor (w
, area
, x0
, x1
, y0
, y1
)
9398 enum glyph_row_area area
;
9401 if (area
== TEXT_AREA
9402 && w
->phys_cursor_on_p
9403 && y0
<= w
->phys_cursor
.y
9404 && y1
>= w
->phys_cursor
.y
+ w
->phys_cursor_height
9405 && x0
<= w
->phys_cursor
.x
9406 && (x1
< 0 || x1
> w
->phys_cursor
.x
))
9407 w
->phys_cursor_on_p
= 0;
9411 /* Set clipping for output in glyph row ROW. W is the window in which
9412 we operate. GC is the graphics context to set clipping in.
9413 WHOLE_LINE_P non-zero means include the areas used for truncation
9414 mark display and alike in the clipping rectangle.
9416 ROW may be a text row or, e.g., a mode line. Text rows must be
9417 clipped to the interior of the window dedicated to text display,
9418 mode lines must be clipped to the whole window. */
9421 w32_clip_to_row (w
, row
, hdc
, whole_line_p
)
9423 struct glyph_row
*row
;
9427 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
9429 int window_x
, window_y
, window_width
, window_height
;
9431 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
9433 clip_rect
.left
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
9434 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
9435 clip_rect
.top
= max (clip_rect
.top
, window_y
);
9436 clip_rect
.right
= clip_rect
.left
+ window_width
;
9437 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
9439 /* If clipping to the whole line, including trunc marks, extend
9440 the rectangle to the left and increase its width. */
9443 clip_rect
.left
-= FRAME_X_LEFT_FRINGE_WIDTH (f
);
9444 clip_rect
.right
+= FRAME_X_FRINGE_WIDTH (f
);
9447 w32_set_clip_rectangle (hdc
, &clip_rect
);
9451 /* Draw a hollow box cursor on window W in glyph row ROW. */
9454 x_draw_hollow_cursor (w
, row
)
9456 struct glyph_row
*row
;
9458 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
9462 struct glyph
*cursor_glyph
;
9463 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
9465 /* Compute frame-relative coordinates from window-relative
9467 rect
.left
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
9468 rect
.top
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
9469 + row
->ascent
- w
->phys_cursor_ascent
);
9470 rect
.bottom
= rect
.top
+ row
->height
;
9472 /* Get the glyph the cursor is on. If we can't tell because
9473 the current matrix is invalid or such, give up. */
9474 cursor_glyph
= get_phys_cursor_glyph (w
);
9475 if (cursor_glyph
== NULL
)
9478 /* Compute the width of the rectangle to draw. If on a stretch
9479 glyph, and `x-stretch-block-cursor' is nil, don't draw a
9480 rectangle as wide as the glyph, but use a canonical character
9482 wd
= cursor_glyph
->pixel_width
;
9483 if (cursor_glyph
->type
== STRETCH_GLYPH
9484 && !x_stretch_cursor_p
)
9485 wd
= min (CANON_X_UNIT (f
), wd
);
9487 rect
.right
= rect
.left
+ wd
;
9488 hdc
= get_frame_dc (f
);
9489 FrameRect (hdc
, &rect
, hb
);
9492 release_frame_dc (f
, hdc
);
9496 /* Draw a bar cursor on window W in glyph row ROW.
9498 Implementation note: One would like to draw a bar cursor with an
9499 angle equal to the one given by the font property XA_ITALIC_ANGLE.
9500 Unfortunately, I didn't find a font yet that has this property set.
9504 x_draw_bar_cursor (w
, row
, width
, kind
)
9506 struct glyph_row
*row
;
9508 enum text_cursor_kinds kind
;
9510 struct frame
*f
= XFRAME (w
->frame
);
9511 struct glyph
*cursor_glyph
;
9515 /* If cursor is out of bounds, don't draw garbage. This can happen
9516 in mini-buffer windows when switching between echo area glyphs
9518 cursor_glyph
= get_phys_cursor_glyph (w
);
9519 if (cursor_glyph
== NULL
)
9522 /* If on an image, draw like a normal cursor. That's usually better
9523 visible than drawing a bar, esp. if the image is large so that
9524 the bar might not be in the window. */
9525 if (cursor_glyph
->type
== IMAGE_GLYPH
)
9527 struct glyph_row
*row
;
9528 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
9529 x_draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
9533 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
9534 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
9537 width
= FRAME_CURSOR_WIDTH (f
);
9538 width
= min (cursor_glyph
->pixel_width
, width
);
9540 /* If the glyph's background equals the color we normally draw
9541 the bar cursor in, the bar cursor in its normal color is
9542 invisible. Use the glyph's foreground color instead in this
9543 case, on the assumption that the glyph's colors are chosen so
9544 that the glyph is legible. */
9545 if (face
->background
== cursor_color
)
9546 cursor_color
= face
->foreground
;
9548 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
9549 hdc
= get_frame_dc (f
);
9550 w32_clip_to_row (w
, row
, hdc
, 0);
9552 if (kind
== BAR_CURSOR
)
9554 w32_fill_area (f
, hdc
, cursor_color
, x
,
9555 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
9556 width
, row
->height
);
9560 w32_fill_area (f
, hdc
, cursor_color
, x
,
9561 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
9562 row
->height
- width
),
9563 cursor_glyph
->pixel_width
, width
);
9565 release_frame_dc (f
, hdc
);
9570 /* Clear the cursor of window W to background color, and mark the
9571 cursor as not shown. This is used when the text where the cursor
9572 is is about to be rewritten. */
9578 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
9579 x_update_window_cursor (w
, 0);
9583 /* Draw the cursor glyph of window W in glyph row ROW. See the
9584 comment of x_draw_glyphs for the meaning of HL. */
9587 x_draw_phys_cursor_glyph (w
, row
, hl
)
9589 struct glyph_row
*row
;
9590 enum draw_glyphs_face hl
;
9592 /* If cursor hpos is out of bounds, don't draw garbage. This can
9593 happen in mini-buffer windows when switching between echo area
9594 glyphs and mini-buffer. */
9595 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
9597 int on_p
= w
->phys_cursor_on_p
;
9598 x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
9599 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
9601 w
->phys_cursor_on_p
= on_p
;
9603 /* When we erase the cursor, and ROW is overlapped by other
9604 rows, make sure that these overlapping parts of other rows
9606 if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
9608 if (row
> w
->current_matrix
->rows
9609 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
9610 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
9612 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
9613 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
9614 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
9620 /* Erase the image of a cursor of window W from the screen. */
9623 x_erase_phys_cursor (w
)
9626 struct frame
*f
= XFRAME (w
->frame
);
9627 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
9628 int hpos
= w
->phys_cursor
.hpos
;
9629 int vpos
= w
->phys_cursor
.vpos
;
9630 int mouse_face_here_p
= 0;
9631 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
9632 struct glyph_row
*cursor_row
;
9633 struct glyph
*cursor_glyph
;
9634 enum draw_glyphs_face hl
;
9636 /* No cursor displayed or row invalidated => nothing to do on the
9638 if (w
->phys_cursor_type
== NO_CURSOR
)
9639 goto mark_cursor_off
;
9641 /* VPOS >= active_glyphs->nrows means that window has been resized.
9642 Don't bother to erase the cursor. */
9643 if (vpos
>= active_glyphs
->nrows
)
9644 goto mark_cursor_off
;
9646 /* If row containing cursor is marked invalid, there is nothing we
9648 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
9649 if (!cursor_row
->enabled_p
)
9650 goto mark_cursor_off
;
9652 /* If row is completely invisible, don't attempt to delete a cursor which
9653 isn't there. This may happen if cursor is at top of window, and
9654 we switch to a buffer with a header line in that window. */
9655 if (cursor_row
->visible_height
<= 0)
9656 goto mark_cursor_off
;
9658 /* This can happen when the new row is shorter than the old one.
9659 In this case, either x_draw_glyphs or clear_end_of_line
9660 should have cleared the cursor. Note that we wouldn't be
9661 able to erase the cursor in this case because we don't have a
9662 cursor glyph at hand. */
9663 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
9664 goto mark_cursor_off
;
9666 /* If the cursor is in the mouse face area, redisplay that when
9667 we clear the cursor. */
9668 if (! NILP (dpyinfo
->mouse_face_window
)
9669 && w
== XWINDOW (dpyinfo
->mouse_face_window
)
9670 && (vpos
> dpyinfo
->mouse_face_beg_row
9671 || (vpos
== dpyinfo
->mouse_face_beg_row
9672 && hpos
>= dpyinfo
->mouse_face_beg_col
))
9673 && (vpos
< dpyinfo
->mouse_face_end_row
9674 || (vpos
== dpyinfo
->mouse_face_end_row
9675 && hpos
< dpyinfo
->mouse_face_end_col
))
9676 /* Don't redraw the cursor's spot in mouse face if it is at the
9677 end of a line (on a newline). The cursor appears there, but
9678 mouse highlighting does not. */
9679 && cursor_row
->used
[TEXT_AREA
] > hpos
)
9680 mouse_face_here_p
= 1;
9682 /* Maybe clear the display under the cursor. */
9683 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
9686 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
9689 cursor_glyph
= get_phys_cursor_glyph (w
);
9690 if (cursor_glyph
== NULL
)
9691 goto mark_cursor_off
;
9693 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
9695 hdc
= get_frame_dc (f
);
9696 w32_clear_area (f
, hdc
, x
,
9697 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
9699 cursor_glyph
->pixel_width
,
9700 cursor_row
->visible_height
);
9701 release_frame_dc (f
, hdc
);
9704 /* Erase the cursor by redrawing the character underneath it. */
9705 if (mouse_face_here_p
)
9706 hl
= DRAW_MOUSE_FACE
;
9708 hl
= DRAW_NORMAL_TEXT
;
9709 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
9712 w
->phys_cursor_on_p
= 0;
9713 w
->phys_cursor_type
= NO_CURSOR
;
9717 /* Non-zero if physical cursor of window W is within mouse face. */
9720 cursor_in_mouse_face_p (w
)
9723 struct w32_display_info
*dpyinfo
9724 = FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
9725 int in_mouse_face
= 0;
9727 if (WINDOWP (dpyinfo
->mouse_face_window
)
9728 && XWINDOW (dpyinfo
->mouse_face_window
) == w
)
9730 int hpos
= w
->phys_cursor
.hpos
;
9731 int vpos
= w
->phys_cursor
.vpos
;
9733 if (vpos
>= dpyinfo
->mouse_face_beg_row
9734 && vpos
<= dpyinfo
->mouse_face_end_row
9735 && (vpos
> dpyinfo
->mouse_face_beg_row
9736 || hpos
>= dpyinfo
->mouse_face_beg_col
)
9737 && (vpos
< dpyinfo
->mouse_face_end_row
9738 || hpos
< dpyinfo
->mouse_face_end_col
9739 || dpyinfo
->mouse_face_past_end
))
9743 return in_mouse_face
;
9747 /* Display or clear cursor of window W. If ON is zero, clear the
9748 cursor. If it is non-zero, display the cursor. If ON is nonzero,
9749 where to put the cursor is specified by HPOS, VPOS, X and Y. */
9752 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
9754 int on
, hpos
, vpos
, x
, y
;
9756 struct frame
*f
= XFRAME (w
->frame
);
9757 int new_cursor_type
;
9758 int new_cursor_width
;
9760 struct glyph_matrix
*current_glyphs
;
9761 struct glyph_row
*glyph_row
;
9762 struct glyph
*glyph
;
9764 /* This is pointless on invisible frames, and dangerous on garbaged
9765 windows and frames; in the latter case, the frame or window may
9766 be in the midst of changing its size, and x and y may be off the
9768 if (! FRAME_VISIBLE_P (f
)
9769 || FRAME_GARBAGED_P (f
)
9770 || vpos
>= w
->current_matrix
->nrows
9771 || hpos
>= w
->current_matrix
->matrix_w
)
9774 /* If cursor is off and we want it off, return quickly. */
9775 if (!on
&& !w
->phys_cursor_on_p
)
9778 current_glyphs
= w
->current_matrix
;
9779 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
9780 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
9782 /* If cursor row is not enabled, we don't really know where to
9783 display the cursor. */
9784 if (!glyph_row
->enabled_p
)
9786 w
->phys_cursor_on_p
= 0;
9790 xassert (interrupt_input_blocked
);
9792 /* Set new_cursor_type to the cursor we want to be displayed. */
9793 new_cursor_type
= get_window_cursor_type (w
, &new_cursor_width
, &active_cursor
);
9795 /* If cursor is currently being shown and we don't want it to be or
9796 it is in the wrong place, or the cursor type is not what we want,
9798 if (w
->phys_cursor_on_p
9800 || w
->phys_cursor
.x
!= x
9801 || w
->phys_cursor
.y
!= y
9802 || new_cursor_type
!= w
->phys_cursor_type
9803 || ((new_cursor_type
== BAR_CURSOR
|| new_cursor_type
== HBAR_CURSOR
)
9804 && new_cursor_width
!= w
->phys_cursor_width
)))
9805 x_erase_phys_cursor (w
);
9807 /* Don't check phys_cursor_on_p here because that flag is only set
9808 to zero in some cases where we know that the cursor has been
9809 completely erased, to avoid the extra work of erasing the cursor
9810 twice. In other words, phys_cursor_on_p can be 1 and the cursor
9811 still not be visible, or it has only been partly erased. */
9814 w
->phys_cursor_ascent
= glyph_row
->ascent
;
9815 w
->phys_cursor_height
= glyph_row
->height
;
9817 /* Set phys_cursor_.* before x_draw_.* is called because some
9818 of them may need the information. */
9819 w
->phys_cursor
.x
= x
;
9820 w
->phys_cursor
.y
= glyph_row
->y
;
9821 w
->phys_cursor
.hpos
= hpos
;
9822 w
->phys_cursor
.vpos
= vpos
;
9824 /* If the user wants to use the system caret, make sure our own
9825 cursor remains invisible. */
9826 if (w32_use_visible_system_caret
)
9828 if (w
->phys_cursor_type
!= NO_CURSOR
)
9829 x_erase_phys_cursor (w
);
9831 new_cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
9832 w
->phys_cursor_width
= -1;
9836 w
->phys_cursor_type
= new_cursor_type
;
9837 w
->phys_cursor_width
= new_cursor_width
;
9840 w
->phys_cursor_on_p
= 1;
9842 /* If this is the active cursor, we need to track it with the
9843 system caret, so third party software like screen magnifiers
9844 and speech synthesizers can follow the cursor. */
9847 HWND hwnd
= FRAME_W32_WINDOW (f
);
9850 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
9852 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
9853 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
9855 /* If the size of the active cursor changed, destroy the old
9857 if (w32_system_caret_hwnd
9858 && (w32_system_caret_height
!= w
->phys_cursor_height
))
9859 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
9861 w32_system_caret_height
= w
->phys_cursor_height
;
9863 /* Move the system caret. */
9864 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
9867 switch (new_cursor_type
)
9869 case HOLLOW_BOX_CURSOR
:
9870 x_draw_hollow_cursor (w
, glyph_row
);
9873 case FILLED_BOX_CURSOR
:
9874 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
9878 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
, BAR_CURSOR
);
9882 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
, HBAR_CURSOR
);
9895 /* Display the cursor on window W, or clear it. X and Y are window
9896 relative pixel coordinates. HPOS and VPOS are glyph matrix
9897 positions. If W is not the selected window, display a hollow
9898 cursor. ON non-zero means display the cursor at X, Y which
9899 correspond to HPOS, VPOS, otherwise it is cleared. */
9902 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
9904 int on
, hpos
, vpos
, x
, y
;
9907 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
9912 /* Display the cursor on window W, or clear it, according to ON_P.
9913 Don't change the cursor's position. */
9916 x_update_cursor (f
, on_p
)
9920 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
9924 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
9925 in the window tree rooted at W. */
9928 x_update_cursor_in_window_tree (w
, on_p
)
9934 if (!NILP (w
->hchild
))
9935 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
9936 else if (!NILP (w
->vchild
))
9937 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
9939 x_update_window_cursor (w
, on_p
);
9941 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
9946 /* Switch the display of W's cursor on or off, according to the value
9950 x_update_window_cursor (w
, on
)
9954 /* Don't update cursor in windows whose frame is in the process
9955 of being deleted. */
9956 if (w
->current_matrix
)
9959 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
,
9960 w
->phys_cursor
.vpos
, w
->phys_cursor
.x
,
9972 x_bitmap_icon (f
, icon
)
9978 if (FRAME_W32_WINDOW (f
) == 0)
9982 hicon
= LoadIcon (hinst
, EMACS_CLASS
);
9983 else if (STRINGP (icon
))
9984 hicon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
9985 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
9986 else if (SYMBOLP (icon
))
9990 if (EQ (icon
, intern ("application")))
9991 name
= (LPCTSTR
) IDI_APPLICATION
;
9992 else if (EQ (icon
, intern ("hand")))
9993 name
= (LPCTSTR
) IDI_HAND
;
9994 else if (EQ (icon
, intern ("question")))
9995 name
= (LPCTSTR
) IDI_QUESTION
;
9996 else if (EQ (icon
, intern ("exclamation")))
9997 name
= (LPCTSTR
) IDI_EXCLAMATION
;
9998 else if (EQ (icon
, intern ("asterisk")))
9999 name
= (LPCTSTR
) IDI_ASTERISK
;
10000 else if (EQ (icon
, intern ("winlogo")))
10001 name
= (LPCTSTR
) IDI_WINLOGO
;
10005 hicon
= LoadIcon (NULL
, name
);
10013 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
10020 /************************************************************************
10022 ************************************************************************/
10024 /* Display Error Handling functions not used on W32. Listing them here
10025 helps diff stay in step when comparing w32term.c with xterm.c.
10027 x_error_catcher (display, error)
10028 x_catch_errors (dpy)
10029 x_catch_errors_unwind (old_val)
10030 x_check_errors (dpy, format)
10031 x_had_errors_p (dpy)
10032 x_clear_errors (dpy)
10033 x_uncatch_errors (dpy, count)
10035 x_connection_signal (signalnum)
10036 x_connection_closed (dpy, error_message)
10037 x_error_quitter (display, error)
10038 x_error_handler (display, error)
10039 x_io_error_quitter (display)
10044 /* Changing the font of the frame. */
10046 /* Give frame F the font named FONTNAME as its default font, and
10047 return the full name of that font. FONTNAME may be a wildcard
10048 pattern; in that case, we choose some font that fits the pattern.
10049 The return value shows which font we chose. */
10052 x_new_font (f
, fontname
)
10054 register char *fontname
;
10056 struct font_info
*fontp
10057 = FS_LOAD_FONT (f
, 0, fontname
, -1);
10062 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
10063 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
10064 FRAME_FONTSET (f
) = -1;
10066 /* Compute the scroll bar width in character columns. */
10067 if (f
->scroll_bar_pixel_width
> 0)
10069 int wid
= FONT_WIDTH (FRAME_FONT (f
));
10070 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
10074 int wid
= FONT_WIDTH (FRAME_FONT (f
));
10075 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
10078 /* Now make the frame display the given font. */
10079 if (FRAME_W32_WINDOW (f
) != 0)
10081 frame_update_line_height (f
);
10082 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
10083 x_set_window_size (f
, 0, f
->width
, f
->height
);
10086 /* If we are setting a new frame's font for the first time,
10087 there are no faces yet, so this font's height is the line height. */
10088 f
->output_data
.w32
->line_height
= FONT_HEIGHT (FRAME_FONT (f
));
10090 return build_string (fontp
->full_name
);
10093 /* Give frame F the fontset named FONTSETNAME as its default font, and
10094 return the full name of that fontset. FONTSETNAME may be a wildcard
10095 pattern; in that case, we choose some fontset that fits the pattern.
10096 The return value shows which fontset we chose. */
10099 x_new_fontset (f
, fontsetname
)
10103 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
10104 Lisp_Object result
;
10109 if (FRAME_FONTSET (f
) == fontset
)
10110 /* This fontset is already set in frame F. There's nothing more
10112 return fontset_name (fontset
);
10114 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
10116 if (!STRINGP (result
))
10117 /* Can't load ASCII font. */
10120 /* Since x_new_font doesn't update any fontset information, do it now. */
10121 FRAME_FONTSET(f
) = fontset
;
10123 return build_string (fontsetname
);
10126 /* Compute actual fringe widths */
10129 x_compute_fringe_widths (f
, redraw
)
10133 int o_left
= f
->output_data
.w32
->left_fringe_width
;
10134 int o_right
= f
->output_data
.w32
->right_fringe_width
;
10135 int o_cols
= f
->output_data
.w32
->fringe_cols
;
10137 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
10138 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
10139 int left_fringe_width
, right_fringe_width
;
10141 if (!NILP (left_fringe
))
10142 left_fringe
= Fcdr (left_fringe
);
10143 if (!NILP (right_fringe
))
10144 right_fringe
= Fcdr (right_fringe
);
10146 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
10147 XINT (left_fringe
));
10148 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
10149 XINT (right_fringe
));
10151 if (left_fringe_width
|| right_fringe_width
)
10153 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
10154 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
10155 int conf_wid
= left_wid
+ right_wid
;
10156 int font_wid
= FONT_WIDTH (f
->output_data
.w32
->font
);
10157 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
10158 int real_wid
= cols
* font_wid
;
10159 if (left_wid
&& right_wid
)
10161 if (left_fringe_width
< 0)
10163 /* Left fringe width is fixed, adjust right fringe if necessary */
10164 f
->output_data
.w32
->left_fringe_width
= left_wid
;
10165 f
->output_data
.w32
->right_fringe_width
= real_wid
- left_wid
;
10167 else if (right_fringe_width
< 0)
10169 /* Right fringe width is fixed, adjust left fringe if necessary */
10170 f
->output_data
.w32
->left_fringe_width
= real_wid
- right_wid
;
10171 f
->output_data
.w32
->right_fringe_width
= right_wid
;
10175 /* Adjust both fringes with an equal amount.
10176 Note that we are doing integer arithmetic here, so don't
10177 lose a pixel if the total width is an odd number. */
10178 int fill
= real_wid
- conf_wid
;
10179 f
->output_data
.w32
->left_fringe_width
= left_wid
+ fill
/2;
10180 f
->output_data
.w32
->right_fringe_width
= right_wid
+ fill
- fill
/2;
10183 else if (left_fringe_width
)
10185 f
->output_data
.w32
->left_fringe_width
= real_wid
;
10186 f
->output_data
.w32
->right_fringe_width
= 0;
10190 f
->output_data
.w32
->left_fringe_width
= 0;
10191 f
->output_data
.w32
->right_fringe_width
= real_wid
;
10193 f
->output_data
.w32
->fringe_cols
= cols
;
10194 f
->output_data
.w32
->fringes_extra
= real_wid
;
10198 f
->output_data
.w32
->left_fringe_width
= 0;
10199 f
->output_data
.w32
->right_fringe_width
= 0;
10200 f
->output_data
.w32
->fringe_cols
= 0;
10201 f
->output_data
.w32
->fringes_extra
= 0;
10204 if (redraw
&& FRAME_VISIBLE_P (f
))
10205 if (o_left
!= f
->output_data
.w32
->left_fringe_width
||
10206 o_right
!= f
->output_data
.w32
->right_fringe_width
||
10207 o_cols
!= f
->output_data
.w32
->fringe_cols
)
10211 /***********************************************************************
10212 TODO: W32 Input Methods
10213 ***********************************************************************/
10214 /* Listing missing functions from xterm.c helps diff stay in step.
10216 xim_destroy_callback (xim, client_data, call_data)
10217 xim_open_dpy (dpyinfo, resource_name)
10219 xim_instantiate_callback (display, client_data, call_data)
10220 xim_initialize (dpyinfo, resource_name)
10221 xim_close_dpy (dpyinfo)
10226 /* Calculate the absolute position in frame F
10227 from its current recorded position values and gravity. */
10230 x_calc_absolute_position (f
)
10234 int flags
= f
->output_data
.w32
->size_hint_flags
;
10238 /* Find the position of the outside upper-left corner of
10239 the inner window, with respect to the outer window.
10240 But do this only if we will need the results. */
10241 if (f
->output_data
.w32
->parent_desc
!= FRAME_W32_DISPLAY_INFO (f
)->root_window
)
10244 MapWindowPoints (FRAME_W32_WINDOW (f
),
10245 f
->output_data
.w32
->parent_desc
,
10252 rt
.left
= rt
.right
= rt
.top
= rt
.bottom
= 0;
10255 AdjustWindowRect(&rt
, f
->output_data
.w32
->dwStyle
,
10256 FRAME_EXTERNAL_MENU_BAR (f
));
10259 pt
.x
+= (rt
.right
- rt
.left
);
10260 pt
.y
+= (rt
.bottom
- rt
.top
);
10263 /* Treat negative positions as relative to the leftmost bottommost
10264 position that fits on the screen. */
10265 if (flags
& XNegative
)
10266 f
->output_data
.w32
->left_pos
= (FRAME_W32_DISPLAY_INFO (f
)->width
10267 - 2 * f
->output_data
.w32
->border_width
- pt
.x
10269 + f
->output_data
.w32
->left_pos
);
10271 if (flags
& YNegative
)
10272 f
->output_data
.w32
->top_pos
= (FRAME_W32_DISPLAY_INFO (f
)->height
10273 - 2 * f
->output_data
.w32
->border_width
- pt
.y
10275 + f
->output_data
.w32
->top_pos
);
10276 /* The left_pos and top_pos
10277 are now relative to the top and left screen edges,
10278 so the flags should correspond. */
10279 f
->output_data
.w32
->size_hint_flags
&= ~ (XNegative
| YNegative
);
10282 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
10283 to really change the position, and 0 when calling from
10284 x_make_frame_visible (in that case, XOFF and YOFF are the current
10285 position values). It is -1 when calling from x_set_frame_parameters,
10286 which means, do adjust for borders but don't change the gravity. */
10289 x_set_offset (f
, xoff
, yoff
, change_gravity
)
10291 register int xoff
, yoff
;
10292 int change_gravity
;
10294 int modified_top
, modified_left
;
10296 if (change_gravity
> 0)
10298 f
->output_data
.w32
->top_pos
= yoff
;
10299 f
->output_data
.w32
->left_pos
= xoff
;
10300 f
->output_data
.w32
->size_hint_flags
&= ~ (XNegative
| YNegative
);
10302 f
->output_data
.w32
->size_hint_flags
|= XNegative
;
10304 f
->output_data
.w32
->size_hint_flags
|= YNegative
;
10305 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
10307 x_calc_absolute_position (f
);
10310 x_wm_set_size_hint (f
, (long) 0, 0);
10312 modified_left
= f
->output_data
.w32
->left_pos
;
10313 modified_top
= f
->output_data
.w32
->top_pos
;
10315 my_set_window_pos (FRAME_W32_WINDOW (f
),
10317 modified_left
, modified_top
,
10319 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
10324 /* Check if we need to resize the frame due to a fullscreen request.
10325 If so needed, resize the frame. */
10327 x_check_fullscreen (f
)
10330 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_BOTH
)
10332 int width
, height
, ign
;
10334 x_real_positions (f
, &f
->output_data
.w32
->left_pos
,
10335 &f
->output_data
.w32
->top_pos
);
10337 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
10339 /* We do not need to move the window, it shall be taken care of
10340 when setting WM manager hints.
10341 If the frame is visible already, the position is checked by
10342 x_check_fullscreen_move. */
10343 if (f
->width
!= width
|| f
->height
!= height
)
10345 change_frame_size (f
, height
, width
, 0, 1, 0);
10346 SET_FRAME_GARBAGED (f
);
10347 cancel_mouse_face (f
);
10349 /* Wait for the change of frame size to occur */
10350 f
->output_data
.w32
->want_fullscreen
|= FULLSCREEN_WAIT
;
10355 /* If frame parameters are set after the frame is mapped, we need to move
10356 the window. This is done in xfns.c.
10357 Some window managers moves the window to the right position, some
10358 moves the outer window manager window to the specified position.
10359 Here we check that we are in the right spot. If not, make a second
10360 move, assuming we are dealing with the second kind of window manager. */
10362 x_check_fullscreen_move (f
)
10365 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_MOVE_WAIT
)
10367 int expect_top
= f
->output_data
.w32
->top_pos
;
10368 int expect_left
= f
->output_data
.w32
->left_pos
;
10370 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_HEIGHT
)
10372 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_WIDTH
)
10375 if (expect_top
!= f
->output_data
.w32
->top_pos
10376 || expect_left
!= f
->output_data
.w32
->left_pos
)
10377 x_set_offset (f
, expect_left
, expect_top
, 1);
10379 /* Just do this once */
10380 f
->output_data
.w32
->want_fullscreen
&= ~FULLSCREEN_MOVE_WAIT
;
10385 /* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
10386 wanted positions of the WM window (not emacs window).
10387 Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
10388 window (FRAME_X_WINDOW).
10391 x_fullscreen_adjust (f
, width
, height
, top_pos
, left_pos
)
10398 int newwidth
= f
->width
, newheight
= f
->height
;
10400 *top_pos
= f
->output_data
.w32
->top_pos
;
10401 *left_pos
= f
->output_data
.w32
->left_pos
;
10403 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_HEIGHT
)
10407 ph
= FRAME_X_DISPLAY_INFO (f
)->height
;
10408 newheight
= PIXEL_TO_CHAR_HEIGHT (f
, ph
);
10409 ph
= CHAR_TO_PIXEL_HEIGHT (f
, newheight
)
10410 - f
->output_data
.w32
->y_pixels_diff
;
10411 newheight
= PIXEL_TO_CHAR_HEIGHT (f
, ph
);
10415 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_WIDTH
)
10419 pw
= FRAME_X_DISPLAY_INFO (f
)->width
;
10420 newwidth
= PIXEL_TO_CHAR_WIDTH (f
, pw
);
10421 pw
= CHAR_TO_PIXEL_WIDTH (f
, newwidth
)
10422 - f
->output_data
.w32
->x_pixels_diff
;
10423 newwidth
= PIXEL_TO_CHAR_WIDTH (f
, pw
);
10428 *height
= newheight
;
10432 /* Call this to change the size of frame F's x-window.
10433 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
10434 for this size change and subsequent size changes.
10435 Otherwise we leave the window gravity unchanged. */
10438 x_set_window_size (f
, change_gravity
, cols
, rows
)
10440 int change_gravity
;
10443 int pixelwidth
, pixelheight
;
10447 check_frame_size (f
, &rows
, &cols
);
10448 f
->output_data
.w32
->vertical_scroll_bar_extra
10449 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
10451 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.w32
->font
)));
10453 x_compute_fringe_widths (f
, 0);
10455 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
10456 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
10458 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
10459 x_wm_set_size_hint (f
, (long) 0, 0);
10464 rect
.left
= rect
.top
= 0;
10465 rect
.right
= pixelwidth
;
10466 rect
.bottom
= pixelheight
;
10468 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
10469 FRAME_EXTERNAL_MENU_BAR (f
));
10471 my_set_window_pos (FRAME_W32_WINDOW (f
),
10474 rect
.right
- rect
.left
,
10475 rect
.bottom
- rect
.top
,
10476 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
10479 /* Now, strictly speaking, we can't be sure that this is accurate,
10480 but the window manager will get around to dealing with the size
10481 change request eventually, and we'll hear how it went when the
10482 ConfigureNotify event gets here.
10484 We could just not bother storing any of this information here,
10485 and let the ConfigureNotify event set everything up, but that
10486 might be kind of confusing to the Lisp code, since size changes
10487 wouldn't be reported in the frame parameters until some random
10488 point in the future when the ConfigureNotify event arrives.
10490 We pass 1 for DELAY since we can't run Lisp code inside of
10492 change_frame_size (f
, rows
, cols
, 0, 1, 0);
10493 PIXEL_WIDTH (f
) = pixelwidth
;
10494 PIXEL_HEIGHT (f
) = pixelheight
;
10496 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
10497 receive in the ConfigureNotify event; if we get what we asked
10498 for, then the event won't cause the screen to become garbaged, so
10499 we have to make sure to do it here. */
10500 SET_FRAME_GARBAGED (f
);
10502 /* If cursor was outside the new size, mark it as off. */
10503 mark_window_cursors_off (XWINDOW (f
->root_window
));
10505 /* Clear out any recollection of where the mouse highlighting was,
10506 since it might be in a place that's outside the new frame size.
10507 Actually checking whether it is outside is a pain in the neck,
10508 so don't try--just let the highlighting be done afresh with new size. */
10509 cancel_mouse_face (f
);
10514 /* Mouse warping. */
10516 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
10519 x_set_mouse_position (f
, x
, y
)
10525 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.w32
->font
) / 2;
10526 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.w32
->line_height
/ 2;
10528 if (pix_x
< 0) pix_x
= 0;
10529 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
10531 if (pix_y
< 0) pix_y
= 0;
10532 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
10534 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
10538 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
10547 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
10548 pt
.x
= rect
.left
+ pix_x
;
10549 pt
.y
= rect
.top
+ pix_y
;
10550 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
10552 SetCursorPos (pt
.x
, pt
.y
);
10558 /* focus shifting, raising and lowering. */
10561 x_focus_on_frame (f
)
10564 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
10566 /* Give input focus to frame. */
10569 /* Try not to change its Z-order if possible. */
10570 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
10571 my_set_focus (f
, FRAME_W32_WINDOW (f
));
10574 my_set_foreground_window (FRAME_W32_WINDOW (f
));
10579 x_unfocus_frame (f
)
10584 /* Raise frame F. */
10591 /* Strictly speaking, raise-frame should only change the frame's Z
10592 order, leaving input focus unchanged. This is reasonable behaviour
10593 on X where the usual policy is point-to-focus. However, this
10594 behaviour would be very odd on Windows where the usual policy is
10597 On X, if the mouse happens to be over the raised frame, it gets
10598 input focus anyway (so the window with focus will never be
10599 completely obscured) - if not, then just moving the mouse over it
10600 is sufficient to give it focus. On Windows, the user must actually
10601 click on the frame (preferrably the title bar so as not to move
10602 point), which is more awkward. Also, no other Windows program
10603 raises a window to the top but leaves another window (possibly now
10604 completely obscured) with input focus.
10606 Because there is a system setting on Windows that allows the user
10607 to choose the point to focus policy, we make the strict semantics
10608 optional, but by default we grab focus when raising. */
10610 if (NILP (Vw32_grab_focus_on_raise
))
10612 /* The obvious call to my_set_window_pos doesn't work if Emacs is
10613 not already the foreground application: the frame is raised
10614 above all other frames belonging to us, but not above the
10615 current top window. To achieve that, we have to resort to this
10616 more cumbersome method. */
10618 HDWP handle
= BeginDeferWindowPos (2);
10621 DeferWindowPos (handle
,
10622 FRAME_W32_WINDOW (f
),
10625 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
10627 DeferWindowPos (handle
,
10628 GetForegroundWindow (),
10629 FRAME_W32_WINDOW (f
),
10631 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
10633 EndDeferWindowPos (handle
);
10638 my_set_foreground_window (FRAME_W32_WINDOW (f
));
10644 /* Lower frame F. */
10650 my_set_window_pos (FRAME_W32_WINDOW (f
),
10653 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
10658 w32_frame_raise_lower (f
, raise_flag
)
10662 if (! FRAME_W32_P (f
))
10671 /* Change of visibility. */
10673 /* This tries to wait until the frame is really visible.
10674 However, if the window manager asks the user where to position
10675 the frame, this will return before the user finishes doing that.
10676 The frame will not actually be visible at that time,
10677 but it will become visible later when the window manager
10678 finishes with it. */
10681 x_make_frame_visible (f
)
10688 type
= x_icon_type (f
);
10690 x_bitmap_icon (f
, type
);
10692 if (! FRAME_VISIBLE_P (f
))
10694 /* We test FRAME_GARBAGED_P here to make sure we don't
10695 call x_set_offset a second time
10696 if we get to x_make_frame_visible a second time
10697 before the window gets really visible. */
10698 if (! FRAME_ICONIFIED_P (f
)
10699 && ! f
->output_data
.w32
->asked_for_visible
)
10700 x_set_offset (f
, f
->output_data
.w32
->left_pos
, f
->output_data
.w32
->top_pos
, 0);
10702 f
->output_data
.w32
->asked_for_visible
= 1;
10704 /* my_show_window (f, FRAME_W32_WINDOW (f), f->async_iconified ? SW_RESTORE : SW_SHOW); */
10705 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_SHOWNORMAL
);
10708 /* Synchronize to ensure Emacs knows the frame is visible
10709 before we do anything else. We do this loop with input not blocked
10710 so that incoming events are handled. */
10715 /* This must come after we set COUNT. */
10718 XSETFRAME (frame
, f
);
10720 /* Wait until the frame is visible. Process X events until a
10721 MapNotify event has been seen, or until we think we won't get a
10722 MapNotify at all.. */
10723 for (count
= input_signal_count
+ 10;
10724 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
10726 /* Force processing of queued events. */
10727 /* TODO: x_sync equivalent? */
10729 /* Machines that do polling rather than SIGIO have been observed
10730 to go into a busy-wait here. So we'll fake an alarm signal
10731 to let the handler know that there's something to be read.
10732 We used to raise a real alarm, but it seems that the handler
10733 isn't always enabled here. This is probably a bug. */
10734 if (input_polling_used ())
10736 /* It could be confusing if a real alarm arrives while processing
10737 the fake one. Turn it off and let the handler reset it. */
10738 int old_poll_suppress_count
= poll_suppress_count
;
10739 poll_suppress_count
= 1;
10740 poll_for_input_1 ();
10741 poll_suppress_count
= old_poll_suppress_count
;
10744 FRAME_SAMPLE_VISIBILITY (f
);
10748 /* Change from mapped state to withdrawn state. */
10750 /* Make the frame visible (mapped and not iconified). */
10752 x_make_frame_invisible (f
)
10755 /* Don't keep the highlight on an invisible frame. */
10756 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
10757 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
10761 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
10763 /* We can't distinguish this from iconification
10764 just by the event that we get from the server.
10765 So we can't win using the usual strategy of letting
10766 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
10767 and synchronize with the server to make sure we agree. */
10769 FRAME_ICONIFIED_P (f
) = 0;
10770 f
->async_visible
= 0;
10771 f
->async_iconified
= 0;
10776 /* Change window state from mapped to iconified. */
10779 x_iconify_frame (f
)
10784 /* Don't keep the highlight on an invisible frame. */
10785 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
10786 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
10788 if (f
->async_iconified
)
10793 type
= x_icon_type (f
);
10795 x_bitmap_icon (f
, type
);
10797 /* Simulate the user minimizing the frame. */
10798 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
10804 /* Free X resources of frame F. */
10807 x_free_frame_resources (f
)
10810 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
10814 if (FRAME_W32_WINDOW (f
))
10815 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
10817 free_frame_menubar (f
);
10819 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
10820 unload_color (f
, f
->output_data
.x
->background_pixel
);
10821 unload_color (f
, f
->output_data
.w32
->cursor_pixel
);
10822 unload_color (f
, f
->output_data
.w32
->cursor_foreground_pixel
);
10823 unload_color (f
, f
->output_data
.w32
->border_pixel
);
10824 unload_color (f
, f
->output_data
.w32
->mouse_pixel
);
10825 if (f
->output_data
.w32
->white_relief
.allocated_p
)
10826 unload_color (f
, f
->output_data
.w32
->white_relief
.pixel
);
10827 if (f
->output_data
.w32
->black_relief
.allocated_p
)
10828 unload_color (f
, f
->output_data
.w32
->black_relief
.pixel
);
10830 if (FRAME_FACE_CACHE (f
))
10831 free_frame_faces (f
);
10833 xfree (f
->output_data
.w32
);
10834 f
->output_data
.w32
= NULL
;
10836 if (f
== dpyinfo
->w32_focus_frame
)
10837 dpyinfo
->w32_focus_frame
= 0;
10838 if (f
== dpyinfo
->w32_focus_event_frame
)
10839 dpyinfo
->w32_focus_event_frame
= 0;
10840 if (f
== dpyinfo
->x_highlight_frame
)
10841 dpyinfo
->x_highlight_frame
= 0;
10843 if (f
== dpyinfo
->mouse_face_mouse_frame
)
10845 dpyinfo
->mouse_face_beg_row
10846 = dpyinfo
->mouse_face_beg_col
= -1;
10847 dpyinfo
->mouse_face_end_row
10848 = dpyinfo
->mouse_face_end_col
= -1;
10849 dpyinfo
->mouse_face_window
= Qnil
;
10850 dpyinfo
->mouse_face_deferred_gc
= 0;
10851 dpyinfo
->mouse_face_mouse_frame
= 0;
10858 /* Destroy the window of frame F. */
10860 x_destroy_window (f
)
10863 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
10865 x_free_frame_resources (f
);
10867 dpyinfo
->reference_count
--;
10871 /* Setting window manager hints. */
10873 /* Set the normal size hints for the window manager, for frame F.
10874 FLAGS is the flags word to use--or 0 meaning preserve the flags
10875 that the window now has.
10876 If USER_POSITION is nonzero, we set the USPosition
10877 flag (this is useful when FLAGS is 0). */
10879 x_wm_set_size_hint (f
, flags
, user_position
)
10884 Window window
= FRAME_W32_WINDOW (f
);
10888 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FONT_WIDTH (f
->output_data
.w32
->font
));
10889 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, f
->output_data
.w32
->line_height
);
10890 SetWindowLong (window
, WND_BORDER_INDEX
, f
->output_data
.w32
->internal_border_width
);
10891 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->output_data
.w32
->vertical_scroll_bar_extra
);
10896 /* Window manager things */
10897 x_wm_set_icon_position (f
, icon_x
, icon_y
)
10899 int icon_x
, icon_y
;
10902 Window window
= FRAME_W32_WINDOW (f
);
10904 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
10905 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
10906 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
10908 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
10913 /***********************************************************************
10915 ***********************************************************************/
10917 /* The following functions are listed here to help diff stay in step
10918 with xterm.c. See w32fns.c for definitions.
10920 x_get_font_info (f, font_idx)
10921 x_list_fonts (f, pattern, size, maxnames)
10927 /* Check that FONT is valid on frame F. It is if it can be found in F's
10931 x_check_font (f
, font
)
10936 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
10938 xassert (font
!= NULL
);
10940 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10941 if (dpyinfo
->font_table
[i
].name
10942 && font
== dpyinfo
->font_table
[i
].font
)
10945 xassert (i
< dpyinfo
->n_fonts
);
10948 #endif /* GLYPH_DEBUG != 0 */
10950 /* Set *W to the minimum width, *H to the minimum font height of FONT.
10951 Note: There are (broken) X fonts out there with invalid XFontStruct
10952 min_bounds contents. For example, handa@etl.go.jp reports that
10953 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
10954 have font->min_bounds.width == 0. */
10957 x_font_min_bounds (font
, w
, h
)
10962 * TODO: Windows does not appear to offer min bound, only
10963 * average and maximum width, and maximum height.
10965 *h
= FONT_HEIGHT (font
);
10966 *w
= FONT_WIDTH (font
);
10970 /* Compute the smallest character width and smallest font height over
10971 all fonts available on frame F. Set the members smallest_char_width
10972 and smallest_font_height in F's x_display_info structure to
10973 the values computed. Value is non-zero if smallest_font_height or
10974 smallest_char_width become smaller than they were before. */
10977 x_compute_min_glyph_bounds (f
)
10981 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
10983 int old_width
= dpyinfo
->smallest_char_width
;
10984 int old_height
= dpyinfo
->smallest_font_height
;
10986 dpyinfo
->smallest_font_height
= 100000;
10987 dpyinfo
->smallest_char_width
= 100000;
10989 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
10990 if (dpyinfo
->font_table
[i
].name
)
10992 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
10995 font
= (XFontStruct
*) fontp
->font
;
10996 xassert (font
!= (XFontStruct
*) ~0);
10997 x_font_min_bounds (font
, &w
, &h
);
10999 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
11000 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
11003 xassert (dpyinfo
->smallest_char_width
> 0
11004 && dpyinfo
->smallest_font_height
> 0);
11006 return (dpyinfo
->n_fonts
== 1
11007 || dpyinfo
->smallest_char_width
< old_width
11008 || dpyinfo
->smallest_font_height
< old_height
);
11011 /* The following functions are listed here to help diff stay in step
11012 with xterm.c. See w32fns.c for definitions.
11014 x_load_font (f, fontname, size)
11015 x_query_font (f, fontname)
11016 x_find_ccl_program (fontp)
11020 /***********************************************************************
11022 ***********************************************************************/
11024 static int w32_initialized
= 0;
11027 w32_initialize_display_info (display_name
)
11028 Lisp_Object display_name
;
11030 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
11032 bzero (dpyinfo
, sizeof (*dpyinfo
));
11034 /* Put it on w32_display_name_list. */
11035 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
11036 w32_display_name_list
);
11037 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
11039 dpyinfo
->w32_id_name
11040 = (char *) xmalloc (SCHARS (Vinvocation_name
)
11041 + SCHARS (Vsystem_name
)
11043 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
11044 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
11046 /* Default Console mode values - overridden when running in GUI mode
11047 with values obtained from system metrics. */
11050 dpyinfo
->height_in
= 1;
11051 dpyinfo
->width_in
= 1;
11052 dpyinfo
->n_planes
= 1;
11053 dpyinfo
->n_cbits
= 4;
11054 dpyinfo
->n_fonts
= 0;
11055 dpyinfo
->smallest_font_height
= 1;
11056 dpyinfo
->smallest_char_width
= 1;
11058 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
11059 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
11060 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
11061 dpyinfo
->mouse_face_window
= Qnil
;
11062 dpyinfo
->mouse_face_overlay
= Qnil
;
11063 dpyinfo
->mouse_face_hidden
= 0;
11064 /* TODO: dpyinfo->gray */
11068 struct w32_display_info
*
11069 w32_term_init (display_name
, xrm_option
, resource_name
)
11070 Lisp_Object display_name
;
11072 char *resource_name
;
11074 struct w32_display_info
*dpyinfo
;
11079 if (!w32_initialized
)
11082 w32_initialized
= 1;
11093 argv
[argc
++] = "-xrm";
11094 argv
[argc
++] = xrm_option
;
11098 w32_initialize_display_info (display_name
);
11100 dpyinfo
= &one_w32_display_info
;
11102 /* Put this display on the chain. */
11103 dpyinfo
->next
= x_display_list
;
11104 x_display_list
= dpyinfo
;
11106 hdc
= GetDC (GetDesktopWindow ());
11108 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
11109 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
11110 dpyinfo
->root_window
= GetDesktopWindow ();
11111 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
11112 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
11113 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
11114 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
11115 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
11116 dpyinfo
->image_cache
= make_image_cache ();
11117 dpyinfo
->height_in
= dpyinfo
->height
/ dpyinfo
->resx
;
11118 dpyinfo
->width_in
= dpyinfo
->width
/ dpyinfo
->resy
;
11119 ReleaseDC (GetDesktopWindow (), hdc
);
11121 /* initialise palette with white and black */
11124 w32_defined_color (0, "white", &color
, 1);
11125 w32_defined_color (0, "black", &color
, 1);
11128 /* Create Row Bitmaps and store them for later use. */
11129 left_bmp
= CreateBitmap (left_width
, left_height
, 1, 1, left_bits
);
11130 ov_bmp
= CreateBitmap (ov_width
, ov_height
, 1, 1, ov_bits
);
11131 right_bmp
= CreateBitmap (right_width
, right_height
, 1, 1, right_bits
);
11132 continued_bmp
= CreateBitmap (continued_width
, continued_height
, 1,
11133 1, continued_bits
);
11134 continuation_bmp
= CreateBitmap (continuation_width
, continuation_height
,
11135 1, 1, continuation_bits
);
11136 zv_bmp
= CreateBitmap (zv_width
, zv_height
, 1, 1, zv_bits
);
11138 #ifndef F_SETOWN_BUG
11140 #ifdef F_SETOWN_SOCK_NEG
11141 /* stdin is a socket here */
11142 fcntl (connection
, F_SETOWN
, -getpid ());
11143 #else /* ! defined (F_SETOWN_SOCK_NEG) */
11144 fcntl (connection
, F_SETOWN
, getpid ());
11145 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
11146 #endif /* ! defined (F_SETOWN) */
11147 #endif /* F_SETOWN_BUG */
11150 if (interrupt_input
)
11151 init_sigio (connection
);
11152 #endif /* ! defined (SIGIO) */
11159 /* Get rid of display DPYINFO, assuming all frames are already gone. */
11162 x_delete_display (dpyinfo
)
11163 struct w32_display_info
*dpyinfo
;
11165 /* Discard this display from w32_display_name_list and w32_display_list.
11166 We can't use Fdelq because that can quit. */
11167 if (! NILP (w32_display_name_list
)
11168 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
11169 w32_display_name_list
= XCDR (w32_display_name_list
);
11174 tail
= w32_display_name_list
;
11175 while (CONSP (tail
) && CONSP (XCDR (tail
)))
11177 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
11179 XSETCDR (tail
, XCDR (XCDR (tail
)));
11182 tail
= XCDR (tail
);
11186 /* free palette table */
11188 struct w32_palette_entry
* plist
;
11190 plist
= dpyinfo
->color_list
;
11193 struct w32_palette_entry
* pentry
= plist
;
11194 plist
= plist
->next
;
11197 dpyinfo
->color_list
= NULL
;
11198 if (dpyinfo
->palette
)
11199 DeleteObject(dpyinfo
->palette
);
11201 xfree (dpyinfo
->font_table
);
11202 xfree (dpyinfo
->w32_id_name
);
11204 /* Destroy row bitmaps. */
11205 DeleteObject (left_bmp
);
11206 DeleteObject (ov_bmp
);
11207 DeleteObject (right_bmp
);
11208 DeleteObject (continued_bmp
);
11209 DeleteObject (continuation_bmp
);
11210 DeleteObject (zv_bmp
);
11213 /* Set up use of W32. */
11215 DWORD
w32_msg_worker ();
11218 x_flush (struct frame
* f
)
11219 { /* Nothing to do */ }
11221 static struct redisplay_interface w32_redisplay_interface
=
11226 x_clear_end_of_line
,
11228 x_after_update_window_line
,
11229 x_update_window_begin
,
11230 x_update_window_end
,
11233 x_clear_mouse_face
,
11234 x_get_glyph_overhangs
,
11235 x_fix_overlapping_area
11241 rif
= &w32_redisplay_interface
;
11243 /* MSVC does not type K&R functions with no arguments correctly, and
11244 so we must explicitly cast them. */
11245 clear_frame_hook
= (void (*)(void)) x_clear_frame
;
11246 ring_bell_hook
= (void (*)(void)) w32_ring_bell
;
11247 update_begin_hook
= x_update_begin
;
11248 update_end_hook
= x_update_end
;
11250 read_socket_hook
= w32_read_socket
;
11252 frame_up_to_date_hook
= w32_frame_up_to_date
;
11254 mouse_position_hook
= w32_mouse_position
;
11255 frame_rehighlight_hook
= w32_frame_rehighlight
;
11256 frame_raise_lower_hook
= w32_frame_raise_lower
;
11257 set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
11258 condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
11259 redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
11260 judge_scroll_bars_hook
= w32_judge_scroll_bars
;
11261 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
11263 scroll_region_ok
= 1; /* we'll scroll partial frames */
11264 char_ins_del_ok
= 1;
11265 line_ins_del_ok
= 1; /* we'll just blt 'em */
11266 fast_clear_end_of_line
= 1; /* X does this well */
11267 memory_below_frame
= 0; /* we don't remember what scrolls
11271 w32_system_caret_hwnd
= NULL
;
11272 w32_system_caret_height
= 0;
11273 w32_system_caret_x
= 0;
11274 w32_system_caret_y
= 0;
11276 last_tool_bar_item
= -1;
11277 any_help_event_p
= 0;
11279 /* Initialize input mode: interrupt_input off, no flow control, allow
11280 8 bit character input, standard quit char. */
11281 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
11283 /* Create the window thread - it will terminate itself or when the app terminates */
11287 dwMainThreadId
= GetCurrentThreadId ();
11288 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
11289 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
11291 /* Wait for thread to start */
11296 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
11298 hWindowsThread
= CreateThread (NULL
, 0,
11299 (LPTHREAD_START_ROUTINE
) w32_msg_worker
,
11300 0, 0, &dwWindowsThreadId
);
11302 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
11305 /* It is desirable that mainThread should have the same notion of
11306 focus window and active window as windowsThread. Unfortunately, the
11307 following call to AttachThreadInput, which should do precisely what
11308 we need, causes major problems when Emacs is linked as a console
11309 program. Unfortunately, we have good reasons for doing that, so
11310 instead we need to send messages to windowsThread to make some API
11311 calls for us (ones that affect, or depend on, the active/focus
11313 #ifdef ATTACH_THREADS
11314 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
11317 /* Dynamically link to optional system components. */
11319 HANDLE user_lib
= LoadLibrary ("user32.dll");
11321 #define LOAD_PROC(fn) pfn##fn = (void *) GetProcAddress (user_lib, #fn)
11323 /* New proportional scroll bar functions. */
11324 LOAD_PROC (SetScrollInfo
);
11325 LOAD_PROC (GetScrollInfo
);
11329 FreeLibrary (user_lib
);
11331 /* If using proportional scroll bars, ensure handle is at least 5 pixels;
11332 otherwise use the fixed height. */
11333 vertical_scroll_bar_min_handle
= (pfnSetScrollInfo
!= NULL
) ? 5 :
11334 GetSystemMetrics (SM_CYVTHUMB
);
11336 /* For either kind of scroll bar, take account of the arrows; these
11337 effectively form the border of the main scroll bar range. */
11338 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
11339 = GetSystemMetrics (SM_CYVSCROLL
);
11346 staticpro (&w32_display_name_list
);
11347 w32_display_name_list
= Qnil
;
11349 staticpro (&last_mouse_scroll_bar
);
11350 last_mouse_scroll_bar
= Qnil
;
11352 staticpro (&Qvendor_specific_keysyms
);
11353 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
11355 DEFVAR_INT ("w32-num-mouse-buttons",
11356 &Vw32_num_mouse_buttons
,
11357 doc
: /* Number of physical mouse buttons. */);
11358 Vw32_num_mouse_buttons
= Qnil
;
11360 DEFVAR_LISP ("w32-swap-mouse-buttons",
11361 &Vw32_swap_mouse_buttons
,
11362 doc
: /* Swap the mapping of middle and right mouse buttons.
11363 When nil, middle button is mouse-2 and right button is mouse-3. */);
11364 Vw32_swap_mouse_buttons
= Qnil
;
11366 DEFVAR_LISP ("w32-grab-focus-on-raise",
11367 &Vw32_grab_focus_on_raise
,
11368 doc
: /* Raised frame grabs input focus.
11369 When t, `raise-frame' grabs input focus as well. This fits well
11370 with the normal Windows click-to-focus policy, but might not be
11371 desirable when using a point-to-focus policy. */);
11372 Vw32_grab_focus_on_raise
= Qt
;
11374 DEFVAR_LISP ("w32-capslock-is-shiftlock",
11375 &Vw32_capslock_is_shiftlock
,
11376 doc
: /* Apply CapsLock state to non character input keys.
11377 When nil, CapsLock only affects normal character input keys. */);
11378 Vw32_capslock_is_shiftlock
= Qnil
;
11380 DEFVAR_LISP ("w32-recognize-altgr",
11381 &Vw32_recognize_altgr
,
11382 doc
: /* Recognize right-alt and left-ctrl as AltGr.
11383 When nil, the right-alt and left-ctrl key combination is
11384 interpreted normally. */);
11385 Vw32_recognize_altgr
= Qt
;
11387 DEFVAR_BOOL ("w32-enable-unicode-output",
11388 &w32_enable_unicode_output
,
11389 doc
: /* Enable the use of Unicode for text output if non-nil.
11390 Unicode output may prevent some third party applications for displaying
11391 Far-East Languages on Windows 95/98 from working properly.
11392 NT uses Unicode internally anyway, so this flag will probably have no
11393 affect on NT machines. */);
11394 w32_enable_unicode_output
= 1;
11397 staticpro (&help_echo
);
11398 help_echo_object
= Qnil
;
11399 staticpro (&help_echo_object
);
11400 help_echo_window
= Qnil
;
11401 staticpro (&help_echo_window
);
11402 previous_help_echo
= Qnil
;
11403 staticpro (&previous_help_echo
);
11404 help_echo_pos
= -1;
11406 DEFVAR_BOOL ("mouse-autoselect-window", &mouse_autoselect_window
,
11407 doc
: /* *Non-nil means autoselect window with mouse pointer. */);
11408 mouse_autoselect_window
= 0;
11410 DEFVAR_BOOL ("w32-use-visible-system-caret",
11411 &w32_use_visible_system_caret
,
11412 doc
: /* Flag to make the system caret visible.
11413 When this is non-nil, Emacs will indicate the position of point by
11414 using the system caret instead of drawing its own cursor. Some screen
11415 reader software does not track the system cursor properly when it is
11416 invisible, and gets confused by Emacs drawing its own cursor, so this
11417 variable is initialized to t when Emacs detects that screen reader
11418 software is running as it starts up.
11420 When this variable is set, other variables affecting the appearance of
11421 the cursor have no effect. */);
11423 /* Initialize w32_use_visible_system_caret based on whether a screen
11424 reader is in use. */
11425 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
11426 &w32_use_visible_system_caret
, 0))
11427 w32_use_visible_system_caret
= 0;
11429 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
11430 doc
: /* *Non-nil means draw block cursor as wide as the glyph under it.
11431 For example, if a block cursor is over a tab, it will be drawn as
11432 wide as that tab on the display. */);
11433 x_stretch_cursor_p
= 0;
11435 DEFVAR_BOOL ("x-use-underline-position-properties",
11436 &x_use_underline_position_properties
,
11437 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
11438 nil means ignore them. If you encounter fonts with bogus
11439 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
11440 to 4.1, set this to nil. */);
11441 x_use_underline_position_properties
= 1;
11443 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
11444 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
11445 Vx_toolkit_scroll_bars
= Qt
;
11447 staticpro (&last_mouse_motion_frame
);
11448 last_mouse_motion_frame
= Qnil
;