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 char 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 variable for w32_read_socket. */
166 static Lisp_Object previous_help_echo
;
168 /* Non-zero means that a HELP_EVENT has been generated since Emacs
171 static int any_help_event_p
;
173 /* Non-zero means autoselect window with the mouse cursor. */
175 int x_autoselect_window_p
;
177 /* Non-zero means draw block and hollow cursor as wide as the glyph
178 under it. For example, if a block cursor is over a tab, it will be
179 drawn as wide as that tab on the display. */
181 int x_stretch_cursor_p
;
183 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
185 int x_use_underline_position_properties
;
187 extern unsigned int msh_mousewheel
;
189 extern void free_frame_menubar ();
191 extern int w32_codepage_for_font (char *fontname
);
193 extern glyph_metric
*w32_BDF_TextMetric(bdffont
*fontp
,
194 unsigned char *text
, int dim
);
195 extern Lisp_Object Vwindow_system
;
197 #define x_any_window_to_frame x_window_to_frame
198 #define x_top_window_to_frame x_window_to_frame
201 /* This is display since w32 does not support multiple ones. */
202 struct w32_display_info one_w32_display_info
;
203 struct w32_display_info
*x_display_list
;
205 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
206 one for each element of w32_display_list and in the same order.
207 NAME is the name of the frame.
208 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
209 Lisp_Object w32_display_name_list
;
211 /* Frame being updated by update_frame. This is declared in term.c.
212 This is set by update_begin and looked at by all the
213 w32 functions. It is zero while not inside an update.
214 In that case, the w32 functions assume that `SELECTED_FRAME ()'
215 is the frame to apply to. */
216 extern struct frame
*updating_frame
;
218 /* This is a frame waiting to be autoraised, within w32_read_socket. */
219 struct frame
*pending_autoraise_frame
;
221 /* Nominal cursor position -- where to draw output.
222 HPOS and VPOS are window relative glyph matrix coordinates.
223 X and Y are window relative pixel coordinates. */
225 struct cursor_pos output_cursor
;
227 /* The handle of the frame that currently owns the system caret. */
228 HWND w32_system_caret_hwnd
;
229 int w32_system_caret_height
;
230 int w32_system_caret_x
;
231 int w32_system_caret_y
;
232 int w32_use_visible_system_caret
;
234 /* Flag to enable Unicode output in case users wish to use programs
235 like Twinbridge on '95 rather than installed system level support
236 for Far East languages. */
237 int w32_enable_unicode_output
;
239 DWORD dwWindowsThreadId
= 0;
240 HANDLE hWindowsThread
= NULL
;
241 DWORD dwMainThreadId
= 0;
242 HANDLE hMainThread
= NULL
;
245 /* These definitions are new with Windows 95. */
246 #define SIF_RANGE 0x0001
247 #define SIF_PAGE 0x0002
248 #define SIF_POS 0x0004
249 #define SIF_DISABLENOSCROLL 0x0008
250 #define SIF_TRACKPOS 0x0010
251 #define SIF_ALL (SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS)
253 typedef struct tagSCROLLINFO
262 } SCROLLINFO
, FAR
*LPSCROLLINFO
;
263 typedef SCROLLINFO CONST FAR
*LPCSCROLLINFO
;
266 /* Dynamic linking to new proportional scroll bar functions. */
267 int (PASCAL
*pfnSetScrollInfo
) (HWND hwnd
, int fnBar
, LPSCROLLINFO lpsi
, BOOL fRedraw
);
268 BOOL (PASCAL
*pfnGetScrollInfo
) (HWND hwnd
, int fnBar
, LPSCROLLINFO lpsi
);
270 int vertical_scroll_bar_min_handle
;
271 int vertical_scroll_bar_top_border
;
272 int vertical_scroll_bar_bottom_border
;
274 int last_scroll_bar_drag_pos
;
276 /* Mouse movement. */
278 /* Where the mouse was last time we reported a mouse event. */
280 FRAME_PTR last_mouse_frame
;
281 static RECT last_mouse_glyph
;
282 static Lisp_Object last_mouse_press_frame
;
284 Lisp_Object Vw32_num_mouse_buttons
;
286 Lisp_Object Vw32_swap_mouse_buttons
;
288 /* Control whether x_raise_frame also sets input focus. */
289 Lisp_Object Vw32_grab_focus_on_raise
;
291 /* Control whether Caps Lock affects non-ascii characters. */
292 Lisp_Object Vw32_capslock_is_shiftlock
;
294 /* Control whether right-alt and left-ctrl should be recognized as AltGr. */
295 Lisp_Object Vw32_recognize_altgr
;
297 /* The scroll bar in which the last motion event occurred.
299 If the last motion event occurred in a scroll bar, we set this
300 so w32_mouse_position can know whether to report a scroll bar motion or
303 If the last motion event didn't occur in a scroll bar, we set this
304 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
305 static Lisp_Object last_mouse_scroll_bar
;
306 static int last_mouse_scroll_bar_pos
;
308 /* This is a hack. We would really prefer that w32_mouse_position would
309 return the time associated with the position it returns, but there
310 doesn't seem to be any way to wrest the time-stamp from the server
311 along with the position query. So, we just keep track of the time
312 of the last movement we received, and return that in hopes that
313 it's somewhat accurate. */
315 static Time last_mouse_movement_time
;
317 /* Incremented by w32_read_socket whenever it really tries to read
321 static int volatile input_signal_count
;
323 static int input_signal_count
;
326 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
328 extern Lisp_Object Qface
, Qmouse_face
;
334 /* A mask of extra modifier bits to put into every keyboard char. */
336 extern int extra_keyboard_modifiers
;
338 /* Enumeration for overriding/changing the face to use for drawing
339 glyphs in x_draw_glyphs. */
341 enum draw_glyphs_face
351 static void x_update_window_end
P_ ((struct window
*, int, int));
352 static void frame_to_window_pixel_xy
P_ ((struct window
*, int *, int *));
353 void w32_delete_display
P_ ((struct w32_display_info
*));
354 static int fast_find_position
P_ ((struct window
*, int, int *, int *,
355 int *, int *, Lisp_Object
));
356 static int fast_find_string_pos
P_ ((struct window
*, int, Lisp_Object
,
357 int *, int *, int *, int *, int));
358 static void set_output_cursor
P_ ((struct cursor_pos
*));
359 static struct glyph
*x_y_to_hpos_vpos
P_ ((struct window
*, int, int,
360 int *, int *, int *, int));
361 static void note_mode_line_highlight
P_ ((struct window
*, int, int));
362 static void note_mouse_highlight
P_ ((struct frame
*, int, int));
363 static void note_tool_bar_highlight
P_ ((struct frame
*f
, int, int));
364 static void w32_handle_tool_bar_click
P_ ((struct frame
*,
365 struct input_event
*));
366 static void show_mouse_face
P_ ((struct w32_display_info
*,
367 enum draw_glyphs_face
));
368 static int cursor_in_mouse_face_p
P_ ((struct window
*));
369 static int clear_mouse_face
P_ ((struct w32_display_info
*));
371 void x_lower_frame
P_ ((struct frame
*));
372 void x_scroll_bar_clear
P_ ((struct frame
*));
373 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
374 void x_raise_frame
P_ ((struct frame
*));
375 void x_set_window_size
P_ ((struct frame
*, int, int, int));
376 void x_wm_set_window_state
P_ ((struct frame
*, int));
377 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
378 void w32_initialize
P_ ((void));
379 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
380 int x_compute_min_glyph_bounds
P_ ((struct frame
*));
381 static void x_draw_phys_cursor_glyph
P_ ((struct window
*,
383 enum draw_glyphs_face
));
384 static void x_update_end
P_ ((struct frame
*));
385 static void w32_frame_up_to_date
P_ ((struct frame
*));
386 static void w32_set_terminal_modes
P_ ((void));
387 static void w32_reset_terminal_modes
P_ ((void));
388 static void w32_cursor_to
P_ ((int, int, int, int));
389 static void x_write_glyphs
P_ ((struct glyph
*, int));
390 static void x_clear_end_of_line
P_ ((int));
391 static void x_clear_frame
P_ ((void));
392 static void x_clear_cursor
P_ ((struct window
*));
393 static void frame_highlight
P_ ((struct frame
*));
394 static void frame_unhighlight
P_ ((struct frame
*));
395 static void x_new_focus_frame
P_ ((struct w32_display_info
*,
397 static void w32_frame_rehighlight
P_ ((struct frame
*));
398 static void x_frame_rehighlight
P_ ((struct w32_display_info
*));
399 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
400 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int));
401 static void expose_frame
P_ ((struct frame
*, int, int, int, int));
402 static int expose_window_tree
P_ ((struct window
*, RECT
*));
403 static int expose_window
P_ ((struct window
*, RECT
*));
404 static void expose_area
P_ ((struct window
*, struct glyph_row
*,
405 RECT
*, enum glyph_row_area
));
406 static int expose_line
P_ ((struct window
*, struct glyph_row
*,
408 void x_update_cursor
P_ ((struct frame
*, int));
409 static void x_update_cursor_in_window_tree
P_ ((struct window
*, int));
410 static void x_update_window_cursor
P_ ((struct window
*, int));
411 static void x_erase_phys_cursor
P_ ((struct window
*));
412 void x_display_cursor
P_ ((struct window
*w
, int, int, int, int, int));
413 void x_display_and_set_cursor
P_ ((struct window
*, int, int, int, int, int));
414 static void w32_draw_fringe_bitmap
P_ ((struct window
*, HDC hdc
,
416 enum fringe_bitmap_type
, int left_p
));
417 static void w32_clip_to_row
P_ ((struct window
*, struct glyph_row
*,
419 static int x_phys_cursor_in_rect_p
P_ ((struct window
*, RECT
*));
420 static void x_draw_row_fringe_bitmaps
P_ ((struct window
*,
421 struct glyph_row
*));
422 static void notice_overwritten_cursor
P_ ((struct window
*,
424 int, int, int, int));
426 static Lisp_Object Qvendor_specific_keysyms
;
429 /***********************************************************************
431 ***********************************************************************/
435 /* This is a function useful for recording debugging information about
436 the sequence of occurrences in this file. */
444 struct record event_record
[100];
446 int event_record_index
;
448 record_event (locus
, type
)
452 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
453 event_record_index
= 0;
455 event_record
[event_record_index
].locus
= locus
;
456 event_record
[event_record_index
].type
= type
;
457 event_record_index
++;
463 void XChangeGC (void * ignore
, XGCValues
* gc
, unsigned long mask
,
466 if (mask
& GCForeground
)
467 gc
->foreground
= xgcv
->foreground
;
468 if (mask
& GCBackground
)
469 gc
->background
= xgcv
->background
;
471 gc
->font
= xgcv
->font
;
474 XGCValues
*XCreateGC (void * ignore
, Window window
, unsigned long mask
,
477 XGCValues
*gc
= (XGCValues
*) xmalloc (sizeof (XGCValues
));
478 bzero (gc
, sizeof (XGCValues
));
480 XChangeGC (ignore
, gc
, mask
, xgcv
);
485 void XGetGCValues (void* ignore
, XGCValues
*gc
,
486 unsigned long mask
, XGCValues
*xgcv
)
488 XChangeGC (ignore
, xgcv
, mask
, gc
);
492 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
496 HRGN clip_region
= CreateRectRgnIndirect (rect
);
497 SelectClipRgn (hdc
, clip_region
);
498 DeleteObject (clip_region
);
501 SelectClipRgn (hdc
, NULL
);
505 /* Draw a hollow rectangle at the specified position. */
507 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
508 int width
, int height
)
513 hb
= CreateSolidBrush (gc
->background
);
514 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
515 oldhb
= SelectObject (hdc
, hb
);
516 oldhp
= SelectObject (hdc
, hp
);
518 Rectangle (hdc
, x
, y
, x
+ width
, y
+ height
);
520 SelectObject (hdc
, oldhb
);
521 SelectObject (hdc
, oldhp
);
526 /* Draw a filled rectangle at the specified position. */
528 w32_fill_rect (f
, hdc
, pix
, lprect
)
536 hb
= CreateSolidBrush (pix
);
537 FillRect (hdc
, lprect
, hb
);
546 HDC hdc
= get_frame_dc (f
);
548 /* Under certain conditions, this can be called at startup with
549 a console frame pointer before the GUI frame is created. An HDC
550 of 0 indicates this. */
553 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
554 w32_clear_rect (f
, hdc
, &rect
);
557 release_frame_dc (f
, hdc
);
561 /***********************************************************************
562 Starting and ending an update
563 ***********************************************************************/
565 /* Start an update of frame F. This function is installed as a hook
566 for update_begin, i.e. it is called when update_begin is called.
567 This function is called prior to calls to x_update_window_begin for
568 each window being updated. */
574 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
576 if (! FRAME_W32_P (f
))
579 /* Regenerate display palette before drawing if list of requested
580 colors has changed. */
581 if (display_info
->regen_palette
)
583 w32_regenerate_palette (f
);
584 display_info
->regen_palette
= FALSE
;
589 /* Start update of window W. Set the global variable updated_window
590 to the window being updated and set output_cursor to the cursor
594 x_update_window_begin (w
)
597 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
598 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
600 /* Hide the system caret during an update. */
601 if (w32_use_visible_system_caret
)
602 SendMessage (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0);
605 set_output_cursor (&w
->cursor
);
609 if (f
== display_info
->mouse_face_mouse_frame
)
611 /* Don't do highlighting for mouse motion during the update. */
612 display_info
->mouse_face_defer
= 1;
614 /* If F needs to be redrawn, simply forget about any prior mouse
616 if (FRAME_GARBAGED_P (f
))
617 display_info
->mouse_face_window
= Qnil
;
619 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
620 their mouse_face_p flag set, which means that they are always
621 unequal to rows in a desired matrix which never have that
622 flag set. So, rows containing mouse-face glyphs are never
623 scrolled, and we don't have to switch the mouse highlight off
624 here to prevent it from being scrolled. */
626 /* Can we tell that this update does not affect the window
627 where the mouse highlight is? If so, no need to turn off.
628 Likewise, don't do anything if the frame is garbaged;
629 in that case, the frame's current matrix that we would use
630 is all wrong, and we will redisplay that line anyway. */
631 if (!NILP (display_info
->mouse_face_window
)
632 && w
== XWINDOW (display_info
->mouse_face_window
))
636 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
637 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
640 if (i
< w
->desired_matrix
->nrows
)
641 clear_mouse_face (display_info
);
650 /* Draw a vertical window border to the right of window W if W doesn't
651 have vertical scroll bars. */
654 x_draw_vertical_border (w
)
657 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
659 /* Redraw borders between horizontally adjacent windows. Don't
660 do it for frames with vertical scroll bars because either the
661 right scroll bar of a window, or the left scroll bar of its
662 neighbor will suffice as a border. */
663 if (!WINDOW_RIGHTMOST_P (w
)
664 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
669 window_box_edges (w
, -1, (int *) &r
.left
, (int *) &r
.top
,
670 (int *) &r
.right
, (int *) &r
.bottom
);
671 r
.left
= r
.right
+ FRAME_X_RIGHT_FRINGE_WIDTH (f
);
672 r
.right
= r
.left
+ 1;
675 hdc
= get_frame_dc (f
);
676 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
677 release_frame_dc (f
, hdc
);
682 /* End update of window W (which is equal to updated_window).
684 Draw vertical borders between horizontally adjacent windows, and
685 display W's cursor if CURSOR_ON_P is non-zero.
687 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
688 glyphs in mouse-face were overwritten. In that case we have to
689 make sure that the mouse-highlight is properly redrawn.
691 W may be a menu bar pseudo-window in case we don't have X toolkit
692 support. Such windows don't have a cursor, so don't display it
696 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
698 int cursor_on_p
, mouse_face_overwritten_p
;
700 struct w32_display_info
*dpyinfo
701 = FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
703 if (!w
->pseudo_window_p
)
708 x_display_and_set_cursor (w
, 1, output_cursor
.hpos
,
710 output_cursor
.x
, output_cursor
.y
);
712 x_draw_vertical_border (w
);
716 /* If a row with mouse-face was overwritten, arrange for
717 XTframe_up_to_date to redisplay the mouse highlight. */
718 if (mouse_face_overwritten_p
)
720 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
721 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
722 dpyinfo
->mouse_face_window
= Qnil
;
725 /* Unhide the caret. This won't actually show the cursor, unless it
726 was visible before the corresponding call to HideCaret in
727 x_update_window_begin. */
728 if (w32_use_visible_system_caret
)
729 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
731 updated_window
= NULL
;
735 /* End update of frame F. This function is installed as a hook in
742 if (! FRAME_W32_P (f
))
745 /* Mouse highlight may be displayed again. */
746 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
750 /* This function is called from various places in xdisp.c whenever a
751 complete update has been performed. The global variable
752 updated_window is not available here. */
755 w32_frame_up_to_date (f
)
760 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
761 if (dpyinfo
->mouse_face_deferred_gc
762 || f
== dpyinfo
->mouse_face_mouse_frame
)
765 if (dpyinfo
->mouse_face_mouse_frame
)
766 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
767 dpyinfo
->mouse_face_mouse_x
,
768 dpyinfo
->mouse_face_mouse_y
);
769 dpyinfo
->mouse_face_deferred_gc
= 0;
776 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
777 arrow bitmaps, or clear the fringes if no bitmaps are required
778 before DESIRED_ROW is made current. The window being updated is
779 found in updated_window. This function is called from
780 update_window_line only if it is known that there are differences
781 between bitmaps to be drawn between current row and DESIRED_ROW. */
784 x_after_update_window_line (desired_row
)
785 struct glyph_row
*desired_row
;
787 struct window
*w
= updated_window
;
793 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
796 x_draw_row_fringe_bitmaps (w
, desired_row
);
800 /* When a window has disappeared, make sure that no rest of
801 full-width rows stays visible in the internal border. Could
802 check here if updated_window is the leftmost/rightmost window,
803 but I guess it's not worth doing since vertically split windows
804 are almost never used, internal border is rarely set, and the
805 overhead is very small. */
806 if (windows_or_buffers_changed
807 && desired_row
->full_width_p
808 && (f
= XFRAME (w
->frame
),
809 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
811 && (height
= desired_row
->visible_height
,
814 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
815 /* Internal border is drawn below the tool bar. */
816 if (WINDOWP (f
->tool_bar_window
)
817 && w
== XWINDOW (f
->tool_bar_window
))
822 HDC hdc
= get_frame_dc (f
);
823 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
824 w32_clear_area (f
, hdc
, f
->output_data
.w32
->pixel_width
- width
,
826 release_frame_dc (f
, hdc
);
833 /* Draw the bitmap WHICH in one of the left or right fringes of
834 window W. ROW is the glyph row for which to display the bitmap; it
835 determines the vertical position at which the bitmap has to be
839 w32_draw_fringe_bitmap (w
, hdc
, row
, which
, left_p
)
842 struct glyph_row
*row
;
843 enum fringe_bitmap_type which
;
846 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
847 Window window
= FRAME_W32_WINDOW (f
);
855 /* Must clip because of partially visible lines. */
856 w32_clip_to_row (w
, row
, hdc
, 1);
858 /* Convert row to frame coordinates. */
859 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
863 case NO_FRINGE_BITMAP
:
868 case LEFT_TRUNCATION_BITMAP
:
874 case OVERLAY_ARROW_BITMAP
:
880 case RIGHT_TRUNCATION_BITMAP
:
886 case CONTINUED_LINE_BITMAP
:
887 wd
= continued_width
;
888 h
= continued_height
;
889 pixmap
= continued_bmp
;
892 case CONTINUATION_LINE_BITMAP
:
893 wd
= continuation_width
;
894 h
= continuation_height
;
895 pixmap
= continuation_bmp
;
900 h
= zv_height
- (y
% zv_period
);
908 /* Clip bitmap if too high. */
912 /* Set dy to the offset in the row to start drawing the bitmap. */
913 dy
= (row
->height
- h
) / 2;
915 /* Draw the bitmap. */
916 face
= FACE_FROM_ID (f
, FRINGE_FACE_ID
);
917 PREPARE_FACE_FOR_DISPLAY (f
, face
);
919 /* Clear left fringe if no bitmap to draw or if bitmap doesn't fill
924 if (wd
> FRAME_X_LEFT_FRINGE_WIDTH (f
))
925 wd
= FRAME_X_LEFT_FRINGE_WIDTH (f
);
926 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
928 - (FRAME_X_LEFT_FRINGE_WIDTH (f
) - wd
) / 2);
929 if (wd
< FRAME_X_LEFT_FRINGE_WIDTH (f
) || row
->height
> h
)
931 /* If W has a vertical border to its left, don't draw over it. */
932 int border
= ((XFASTINT (w
->left
) > 0
933 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
935 b1
= (window_box_left (w
, -1)
936 - FRAME_X_LEFT_FRINGE_WIDTH (f
)
938 b2
= (FRAME_X_LEFT_FRINGE_WIDTH (f
) - border
);
943 if (wd
> FRAME_X_RIGHT_FRINGE_WIDTH (f
))
944 wd
= FRAME_X_RIGHT_FRINGE_WIDTH (f
);
945 x
= (window_box_right (w
, -1)
946 + (FRAME_X_RIGHT_FRINGE_WIDTH (f
) - wd
) / 2);
947 /* Clear right fringe if no bitmap to draw of if bitmap doesn't fill
949 if (wd
< FRAME_X_RIGHT_FRINGE_WIDTH (f
) || row
->height
> h
)
951 b1
= window_box_right (w
, -1);
952 b2
= FRAME_X_RIGHT_FRINGE_WIDTH (f
);
958 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
960 w32_fill_area (f
, hdc
, face
->background
,
962 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
965 row
->visible_height
);
968 if (which
== NO_FRINGE_BITMAP
)
971 compat_hdc
= CreateCompatibleDC (hdc
);
974 horig_obj
= SelectObject (compat_hdc
, pixmap
);
975 SetTextColor (hdc
, face
->background
);
976 SetBkColor (hdc
, face
->foreground
);
978 BitBlt (hdc
, x
, y
+ dy
, wd
, h
, compat_hdc
, 0,
979 (which
== ZV_LINE_BITMAP
? (row
->y
% zv_period
) : 0),
982 SelectObject (compat_hdc
, horig_obj
);
983 DeleteDC (compat_hdc
);
988 /* Draw fringe bitmaps for glyph row ROW on window W. Call this
989 function with input blocked. */
992 x_draw_row_fringe_bitmaps (w
, row
)
994 struct glyph_row
*row
;
996 struct frame
*f
= XFRAME (w
->frame
);
997 enum fringe_bitmap_type bitmap
;
1000 xassert (interrupt_input_blocked
);
1002 /* If row is completely invisible, because of vscrolling, we
1003 don't have to draw anything. */
1004 if (row
->visible_height
<= 0)
1007 hdc
= get_frame_dc (f
);
1009 if (FRAME_X_LEFT_FRINGE_WIDTH (f
) != 0)
1011 /* Decide which bitmap to draw in the left fringe. */
1012 if (row
->overlay_arrow_p
)
1013 bitmap
= OVERLAY_ARROW_BITMAP
;
1014 else if (row
->truncated_on_left_p
)
1015 bitmap
= LEFT_TRUNCATION_BITMAP
;
1016 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
1017 bitmap
= CONTINUATION_LINE_BITMAP
;
1018 else if (row
->indicate_empty_line_p
)
1019 bitmap
= ZV_LINE_BITMAP
;
1021 bitmap
= NO_FRINGE_BITMAP
;
1023 w32_draw_fringe_bitmap (w
, hdc
, row
, bitmap
, 1);
1026 if (FRAME_X_RIGHT_FRINGE_WIDTH (f
) != 0)
1028 /* Decide which bitmap to draw in the right fringe. */
1029 if (row
->truncated_on_right_p
)
1030 bitmap
= RIGHT_TRUNCATION_BITMAP
;
1031 else if (row
->continued_p
)
1032 bitmap
= CONTINUED_LINE_BITMAP
;
1033 else if (row
->indicate_empty_line_p
&& FRAME_X_LEFT_FRINGE_WIDTH (f
) == 0)
1034 bitmap
= ZV_LINE_BITMAP
;
1036 bitmap
= NO_FRINGE_BITMAP
;
1038 w32_draw_fringe_bitmap (w
, hdc
, row
, bitmap
, 0);
1041 release_frame_dc (f
, hdc
);
1045 /* This is called when starting Emacs and when restarting after
1046 suspend. When starting Emacs, no window is mapped. And nothing
1047 must be done to Emacs's own window if it is suspended (though that
1051 w32_set_terminal_modes (void)
1055 /* This is called when exiting or suspending Emacs. Exiting will make
1056 the W32 windows go away, and suspending requires no action. */
1059 w32_reset_terminal_modes (void)
1065 /***********************************************************************
1067 ***********************************************************************/
1069 /* Set the global variable output_cursor to CURSOR. All cursor
1070 positions are relative to updated_window. */
1073 set_output_cursor (cursor
)
1074 struct cursor_pos
*cursor
;
1076 output_cursor
.hpos
= cursor
->hpos
;
1077 output_cursor
.vpos
= cursor
->vpos
;
1078 output_cursor
.x
= cursor
->x
;
1079 output_cursor
.y
= cursor
->y
;
1083 /* Set a nominal cursor position.
1085 HPOS and VPOS are column/row positions in a window glyph matrix. X
1086 and Y are window text area relative pixel positions.
1088 If this is done during an update, updated_window will contain the
1089 window that is being updated and the position is the future output
1090 cursor position for that window. If updated_window is null, use
1091 selected_window and display the cursor at the given position. */
1094 w32_cursor_to (vpos
, hpos
, y
, x
)
1095 int vpos
, hpos
, y
, x
;
1099 /* If updated_window is not set, work on selected_window. */
1103 w
= XWINDOW (selected_window
);
1105 /* Set the output cursor. */
1106 output_cursor
.hpos
= hpos
;
1107 output_cursor
.vpos
= vpos
;
1108 output_cursor
.x
= x
;
1109 output_cursor
.y
= y
;
1111 /* If not called as part of an update, really display the cursor.
1112 This will also set the cursor position of W. */
1113 if (updated_window
== NULL
)
1116 x_display_cursor (w
, 1, hpos
, vpos
, x
, y
);
1123 /***********************************************************************
1125 ***********************************************************************/
1127 /* Function prototypes of this page. */
1129 static struct face
*x_get_glyph_face_and_encoding
P_ ((struct frame
*,
1133 static struct face
*x_get_char_face_and_encoding
P_ ((struct frame
*, int,
1134 int, wchar_t *, int));
1135 static XCharStruct
*w32_per_char_metric
P_ ((XFontStruct
*,
1137 enum w32_char_font_type
));
1138 static enum w32_char_font_type
1139 w32_encode_char
P_ ((int, wchar_t *, struct font_info
*, int *));
1140 static void x_append_glyph
P_ ((struct it
*));
1141 static void x_append_composite_glyph
P_ ((struct it
*));
1142 static void x_append_stretch_glyph
P_ ((struct it
*it
, Lisp_Object
,
1144 static void x_produce_glyphs
P_ ((struct it
*));
1145 static void x_produce_image_glyph
P_ ((struct it
*it
));
1148 /* Dealing with bits of wchar_t as if they were an XChar2B. */
1149 #define BUILD_WCHAR_T(byte1, byte2) \
1150 ((wchar_t)((((byte1) & 0x00ff) << 8) | ((byte2) & 0x00ff)))
1154 (((ch) & 0xff00) >> 8)
1160 /* Get metrics of character CHAR2B in FONT. Value is always non-null.
1161 If CHAR2B is not contained in FONT, the font's default character
1162 metric is returned. */
1165 w32_bdf_per_char_metric (font
, char2b
, dim
, pcm
)
1171 glyph_metric
* bdf_metric
;
1175 buf
[0] = (char)(*char2b
);
1178 buf
[0] = BYTE1 (*char2b
);
1179 buf
[1] = BYTE2 (*char2b
);
1182 bdf_metric
= w32_BDF_TextMetric (font
->bdf
, buf
, dim
);
1186 pcm
->width
= bdf_metric
->dwidth
;
1187 pcm
->lbearing
= bdf_metric
->bbox
;
1188 pcm
->rbearing
= bdf_metric
->dwidth
1189 - (bdf_metric
->bbox
+ bdf_metric
->bbw
);
1190 pcm
->ascent
= bdf_metric
->bboy
+ bdf_metric
->bbh
;
1191 pcm
->descent
= -bdf_metric
->bboy
;
1200 w32_native_per_char_metric (font
, char2b
, font_type
, pcm
)
1203 enum w32_char_font_type font_type
;
1206 HDC hdc
= GetDC (NULL
);
1208 BOOL retval
= FALSE
;
1210 xassert (font
&& char2b
);
1211 xassert (font
->hfont
);
1212 xassert (font_type
== UNICODE_FONT
|| font_type
== ANSI_FONT
);
1214 old_font
= SelectObject (hdc
, font
->hfont
);
1216 if ((font
->tm
.tmPitchAndFamily
& TMPF_TRUETYPE
) != 0)
1220 if (font_type
== UNICODE_FONT
)
1221 retval
= GetCharABCWidthsW (hdc
, *char2b
, *char2b
, &char_widths
);
1223 retval
= GetCharABCWidthsA (hdc
, *char2b
, *char2b
, &char_widths
);
1228 /* Disabled until we can find a way to get the right results
1229 on all versions of Windows. */
1231 /* Don't trust the ABC widths. For synthesized fonts they are
1232 wrong, and so is the result of GetCharWidth()! */
1234 GetCharWidth (hdc
, *char2b
, *char2b
, &real_width
);
1236 pcm
->width
= char_widths
.abcA
+ char_widths
.abcB
+ char_widths
.abcC
;
1238 /* As far as I can tell, this is the best way to determine what
1239 ExtTextOut will do with the broken font. */
1240 if (pcm
->width
!= real_width
)
1241 pcm
->width
= (pcm
->width
+ real_width
) / 2;
1243 pcm
->lbearing
= char_widths
.abcA
;
1244 pcm
->rbearing
= char_widths
.abcA
+ char_widths
.abcB
;
1245 pcm
->ascent
= FONT_BASE (font
);
1246 pcm
->descent
= FONT_DESCENT (font
);
1252 /* Either font is not a True-type font, or GetCharABCWidthsW
1253 failed (it is not supported on Windows 9x for instance), so we
1254 can't determine the full info we would like. All is not lost
1255 though - we can call GetTextExtentPoint32 to get rbearing and
1256 deduce width based on the font's per-string overhang. lbearing
1257 is assumed to be zero. */
1259 /* TODO: Some Thai characters (and other composites if Windows
1260 supports them) do have lbearing, and report their total width
1261 as zero. Need some way of handling them when
1262 GetCharABCWidthsW fails. */
1265 if (font_type
== UNICODE_FONT
)
1266 retval
= GetTextExtentPoint32W (hdc
, char2b
, 1, &sz
);
1268 retval
= GetTextExtentPoint32A (hdc
, (char*)char2b
, 1, &sz
);
1272 pcm
->width
= sz
.cx
- font
->tm
.tmOverhang
;
1273 pcm
->rbearing
= sz
.cx
;
1275 pcm
->ascent
= FONT_BASE (font
);
1276 pcm
->descent
= FONT_DESCENT (font
);
1281 if (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0)
1286 SelectObject (hdc
, old_font
);
1287 ReleaseDC (NULL
, hdc
);
1293 static XCharStruct
*
1294 w32_per_char_metric (font
, char2b
, font_type
)
1297 enum w32_char_font_type font_type
;
1299 /* The result metric information. */
1303 xassert (font
&& char2b
);
1304 xassert (font_type
!= UNKNOWN_FONT
);
1306 /* Handle the common cases quickly. */
1307 if (!font
->bdf
&& font
->per_char
== NULL
)
1308 /* TODO: determine whether char2b exists in font? */
1309 return &font
->max_bounds
;
1310 else if (!font
->bdf
&& *char2b
< 128)
1311 return &font
->per_char
[*char2b
];
1313 pcm
= &font
->scratch
;
1315 if (font_type
== BDF_1D_FONT
)
1316 retval
= w32_bdf_per_char_metric (font
, char2b
, 1, pcm
);
1317 else if (font_type
== BDF_2D_FONT
)
1318 retval
= w32_bdf_per_char_metric (font
, char2b
, 2, pcm
);
1320 retval
= w32_native_per_char_metric (font
, char2b
, font_type
, pcm
);
1329 w32_cache_char_metrics (font
)
1332 wchar_t char2b
= L
'x';
1334 /* Cache char metrics for the common cases. */
1337 /* TODO: determine whether font is fixed-pitch. */
1338 if (!w32_bdf_per_char_metric (font
, &char2b
, 1, &font
->max_bounds
))
1340 /* Use the font width and height as max bounds, as not all BDF
1341 fonts contain the letter 'x'. */
1342 font
->max_bounds
.width
= FONT_MAX_WIDTH (font
);
1343 font
->max_bounds
.lbearing
= -font
->bdf
->llx
;
1344 font
->max_bounds
.rbearing
= FONT_MAX_WIDTH (font
) - font
->bdf
->urx
;
1345 font
->max_bounds
.ascent
= FONT_BASE (font
);
1346 font
->max_bounds
.descent
= FONT_DESCENT (font
);
1351 if (((font
->tm
.tmPitchAndFamily
& TMPF_FIXED_PITCH
) != 0)
1352 /* Some fonts (eg DBCS fonts) are marked as fixed width even
1353 though they contain characters of different widths. */
1354 || (font
->tm
.tmMaxCharWidth
!= font
->tm
.tmAveCharWidth
))
1356 /* Font is not fixed pitch, so cache per_char info for the
1357 ASCII characters. It would be much more work, and probably
1358 not worth it, to cache other chars, since we may change
1359 between using Unicode and ANSI text drawing functions at
1363 font
->per_char
= xmalloc (128 * sizeof(XCharStruct
));
1364 for (i
= 0; i
< 128; i
++)
1367 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1368 &font
->per_char
[i
]);
1372 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1378 /* Determine if a font is double byte. */
1379 int w32_font_is_double_byte (XFontStruct
*font
)
1381 return font
->double_byte_p
;
1386 w32_use_unicode_for_codepage (codepage
)
1389 /* If the current codepage is supported, use Unicode for output. */
1390 return (w32_enable_unicode_output
1391 && codepage
!= CP_8BIT
1392 && (codepage
== CP_UNICODE
|| IsValidCodePage (codepage
)));
1395 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1396 the two-byte form of C. Encoding is returned in *CHAR2B. */
1398 static INLINE
enum w32_char_font_type
1399 w32_encode_char (c
, char2b
, font_info
, two_byte_p
)
1402 struct font_info
*font_info
;
1405 int charset
= CHAR_CHARSET (c
);
1409 XFontStruct
*font
= font_info
->font
;
1411 xassert (two_byte_p
);
1413 *two_byte_p
= w32_font_is_double_byte (font
);
1415 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1416 This may be either a program in a special encoder language or a
1418 if (font_info
->font_encoder
)
1420 /* It's a program. */
1421 struct ccl_program
*ccl
= font_info
->font_encoder
;
1423 if (CHARSET_DIMENSION (charset
) == 1)
1425 ccl
->reg
[0] = charset
;
1426 ccl
->reg
[1] = BYTE2 (*char2b
);
1430 ccl
->reg
[0] = charset
;
1431 ccl
->reg
[1] = BYTE1 (*char2b
);
1432 ccl
->reg
[2] = BYTE2 (*char2b
);
1435 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
, Qnil
);
1437 /* We assume that MSBs are appropriately set/reset by CCL
1439 if (!*two_byte_p
) /* 1-byte font */
1440 *char2b
= BUILD_WCHAR_T (0, ccl
->reg
[1]);
1442 *char2b
= BUILD_WCHAR_T (ccl
->reg
[1], ccl
->reg
[2]);
1444 else if (font_info
->encoding
[charset
])
1446 /* Fixed encoding scheme. See fontset.h for the meaning of the
1447 encoding numbers. */
1448 int enc
= font_info
->encoding
[charset
];
1450 if ((enc
== 1 || enc
== 2)
1451 && CHARSET_DIMENSION (charset
) == 2)
1452 *char2b
= BUILD_WCHAR_T (BYTE1 (*char2b
) | 0x80, BYTE2 (*char2b
));
1454 if (enc
== 1 || enc
== 3
1455 || (enc
== 4 && CHARSET_DIMENSION (charset
) == 1))
1456 *char2b
= BUILD_WCHAR_T (BYTE1 (*char2b
), BYTE2 (*char2b
) | 0x80);
1461 ENCODE_SJIS (BYTE1 (*char2b
), BYTE2 (*char2b
),
1463 *char2b
= BUILD_WCHAR_T (sjis1
, sjis2
);
1466 codepage
= font_info
->codepage
;
1468 /* If charset is not ASCII or Latin-1, may need to move it into
1470 if ( font
&& !font
->bdf
&& w32_use_unicode_for_codepage (codepage
)
1471 && charset
!= CHARSET_ASCII
&& charset
!= charset_latin_iso8859_1
1472 && charset
!= CHARSET_8_BIT_CONTROL
&& charset
!= CHARSET_8_BIT_GRAPHIC
)
1475 temp
[0] = BYTE1 (*char2b
);
1476 temp
[1] = BYTE2 (*char2b
);
1478 if (codepage
!= CP_UNICODE
)
1481 MultiByteToWideChar (codepage
, 0, temp
, 2, char2b
, 1);
1483 MultiByteToWideChar (codepage
, 0, temp
+1, 1, char2b
, 1);
1489 return UNKNOWN_FONT
;
1490 else if (font
->bdf
&& CHARSET_DIMENSION (charset
) == 1)
1495 return UNICODE_FONT
;
1501 /* Get face and two-byte form of character C in face FACE_ID on frame
1502 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1503 means we want to display multibyte text. Value is a pointer to a
1504 realized face that is ready for display. */
1506 static INLINE
struct face
*
1507 x_get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
)
1513 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1517 /* Unibyte case. We don't have to encode, but we have to make
1518 sure to use a face suitable for unibyte. */
1519 *char2b
= BUILD_WCHAR_T (0, c
);
1520 face_id
= FACE_FOR_CHAR (f
, face
, c
);
1521 face
= FACE_FROM_ID (f
, face_id
);
1523 else if (c
< 128 && face_id
< BASIC_FACE_ID_SENTINEL
)
1525 /* Case of ASCII in a face known to fit ASCII. */
1526 *char2b
= BUILD_WCHAR_T (0, c
);
1530 int c1
, c2
, charset
;
1532 /* Split characters into bytes. If c2 is -1 afterwards, C is
1533 really a one-byte character so that byte1 is zero. */
1534 SPLIT_CHAR (c
, charset
, c1
, c2
);
1536 *char2b
= BUILD_WCHAR_T (c1
, c2
);
1538 *char2b
= BUILD_WCHAR_T (0, c1
);
1540 /* Maybe encode the character in *CHAR2B. */
1541 if (face
->font
!= NULL
)
1543 struct font_info
*font_info
1544 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1546 w32_encode_char (c
, char2b
, font_info
, &multibyte_p
);
1550 /* Make sure X resources of the face are allocated. */
1551 xassert (face
!= NULL
);
1552 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1558 /* Get face and two-byte form of character glyph GLYPH on frame F.
1559 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1560 a pointer to a realized face that is ready for display. */
1562 static INLINE
struct face
*
1563 x_get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
1565 struct glyph
*glyph
;
1572 xassert (glyph
->type
== CHAR_GLYPH
);
1573 face
= FACE_FROM_ID (f
, glyph
->face_id
);
1578 two_byte_p
= &dummy
;
1580 if (!glyph
->multibyte_p
)
1582 /* Unibyte case. We don't have to encode, but we have to make
1583 sure to use a face suitable for unibyte. */
1584 *char2b
= BUILD_WCHAR_T (0, glyph
->u
.ch
);
1586 else if (glyph
->u
.ch
< 128
1587 && glyph
->face_id
< BASIC_FACE_ID_SENTINEL
)
1589 /* Case of ASCII in a face known to fit ASCII. */
1590 *char2b
= BUILD_WCHAR_T (0, glyph
->u
.ch
);
1594 int c1
, c2
, charset
;
1596 /* Split characters into bytes. If c2 is -1 afterwards, C is
1597 really a one-byte character so that byte1 is zero. */
1598 SPLIT_CHAR (glyph
->u
.ch
, charset
, c1
, c2
);
1600 *char2b
= BUILD_WCHAR_T (c1
, c2
);
1602 *char2b
= BUILD_WCHAR_T (0, c1
);
1604 /* Maybe encode the character in *CHAR2B. */
1605 if (charset
!= CHARSET_ASCII
)
1607 struct font_info
*font_info
1608 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1611 glyph
->w32_font_type
1612 = w32_encode_char (glyph
->u
.ch
, char2b
, font_info
, two_byte_p
);
1617 /* Make sure X resources of the face are allocated. */
1618 xassert (face
!= NULL
);
1619 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1624 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1625 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1631 struct glyph
*glyph
;
1632 enum glyph_row_area area
= it
->area
;
1634 xassert (it
->glyph_row
);
1635 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
1637 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1638 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1640 glyph
->charpos
= CHARPOS (it
->position
);
1641 glyph
->object
= it
->object
;
1642 glyph
->pixel_width
= it
->pixel_width
;
1643 glyph
->voffset
= it
->voffset
;
1644 glyph
->type
= CHAR_GLYPH
;
1645 glyph
->multibyte_p
= it
->multibyte_p
;
1646 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1647 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1648 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1649 || it
->phys_descent
> it
->descent
);
1650 glyph
->padding_p
= 0;
1651 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
1652 glyph
->face_id
= it
->face_id
;
1653 glyph
->u
.ch
= it
->char_to_display
;
1654 glyph
->w32_font_type
= UNKNOWN_FONT
;
1655 ++it
->glyph_row
->used
[area
];
1659 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1660 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1663 x_append_composite_glyph (it
)
1666 struct glyph
*glyph
;
1667 enum glyph_row_area area
= it
->area
;
1669 xassert (it
->glyph_row
);
1671 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1672 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1674 glyph
->charpos
= CHARPOS (it
->position
);
1675 glyph
->object
= it
->object
;
1676 glyph
->pixel_width
= it
->pixel_width
;
1677 glyph
->voffset
= it
->voffset
;
1678 glyph
->type
= COMPOSITE_GLYPH
;
1679 glyph
->multibyte_p
= it
->multibyte_p
;
1680 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1681 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1682 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1683 || it
->phys_descent
> it
->descent
);
1684 glyph
->padding_p
= 0;
1685 glyph
->glyph_not_available_p
= 0;
1686 glyph
->face_id
= it
->face_id
;
1687 glyph
->u
.cmp_id
= it
->cmp_id
;
1688 glyph
->w32_font_type
= UNKNOWN_FONT
;
1689 ++it
->glyph_row
->used
[area
];
1694 /* Change IT->ascent and IT->height according to the setting of
1698 take_vertical_position_into_account (it
)
1703 if (it
->voffset
< 0)
1704 /* Increase the ascent so that we can display the text higher
1706 it
->ascent
+= abs (it
->voffset
);
1708 /* Increase the descent so that we can display the text lower
1710 it
->descent
+= it
->voffset
;
1715 /* Produce glyphs/get display metrics for the image IT is loaded with.
1716 See the description of struct display_iterator in dispextern.h for
1717 an overview of struct display_iterator. */
1720 x_produce_image_glyph (it
)
1726 xassert (it
->what
== IT_IMAGE
);
1728 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1729 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
1732 /* Make sure X resources of the face and image are loaded. */
1733 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1734 prepare_image_for_display (it
->f
, img
);
1736 it
->ascent
= it
->phys_ascent
= image_ascent (img
, face
);
1737 it
->descent
= it
->phys_descent
= img
->height
+ 2 * img
->vmargin
- it
->ascent
;
1738 it
->pixel_width
= img
->width
+ 2 * img
->hmargin
;
1742 if (face
->box
!= FACE_NO_BOX
)
1744 if (face
->box_line_width
> 0)
1746 it
->ascent
+= face
->box_line_width
;
1747 it
->descent
+= face
->box_line_width
;
1750 if (it
->start_of_box_run_p
)
1751 it
->pixel_width
+= abs (face
->box_line_width
);
1752 if (it
->end_of_box_run_p
)
1753 it
->pixel_width
+= abs (face
->box_line_width
);
1756 take_vertical_position_into_account (it
);
1760 struct glyph
*glyph
;
1761 enum glyph_row_area area
= it
->area
;
1763 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1764 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1766 glyph
->charpos
= CHARPOS (it
->position
);
1767 glyph
->object
= it
->object
;
1768 glyph
->pixel_width
= it
->pixel_width
;
1769 glyph
->voffset
= it
->voffset
;
1770 glyph
->type
= IMAGE_GLYPH
;
1771 glyph
->multibyte_p
= it
->multibyte_p
;
1772 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1773 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1774 glyph
->overlaps_vertically_p
= 0;
1775 glyph
->padding_p
= 0;
1776 glyph
->glyph_not_available_p
= 0;
1777 glyph
->face_id
= it
->face_id
;
1778 glyph
->u
.img_id
= img
->id
;
1779 glyph
->w32_font_type
= UNKNOWN_FONT
;
1780 ++it
->glyph_row
->used
[area
];
1786 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1787 of the glyph, WIDTH and HEIGHT are the width and height of the
1788 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1789 ascent of the glyph (0 <= ASCENT <= 1). */
1792 x_append_stretch_glyph (it
, object
, width
, height
, ascent
)
1798 struct glyph
*glyph
;
1799 enum glyph_row_area area
= it
->area
;
1801 xassert (ascent
>= 0 && ascent
<= 1);
1803 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1804 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1806 glyph
->charpos
= CHARPOS (it
->position
);
1807 glyph
->object
= object
;
1808 glyph
->pixel_width
= width
;
1809 glyph
->voffset
= it
->voffset
;
1810 glyph
->type
= STRETCH_GLYPH
;
1811 glyph
->multibyte_p
= it
->multibyte_p
;
1812 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1813 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1814 glyph
->overlaps_vertically_p
= 0;
1815 glyph
->padding_p
= 0;
1816 glyph
->glyph_not_available_p
= 0;
1817 glyph
->face_id
= it
->face_id
;
1818 glyph
->u
.stretch
.ascent
= height
* ascent
;
1819 glyph
->u
.stretch
.height
= height
;
1820 glyph
->w32_font_type
= UNKNOWN_FONT
;
1821 ++it
->glyph_row
->used
[area
];
1826 /* Produce a stretch glyph for iterator IT. IT->object is the value
1827 of the glyph property displayed. The value must be a list
1828 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1831 1. `:width WIDTH' specifies that the space should be WIDTH *
1832 canonical char width wide. WIDTH may be an integer or floating
1835 2. `:relative-width FACTOR' specifies that the width of the stretch
1836 should be computed from the width of the first character having the
1837 `glyph' property, and should be FACTOR times that width.
1839 3. `:align-to HPOS' specifies that the space should be wide enough
1840 to reach HPOS, a value in canonical character units.
1842 Exactly one of the above pairs must be present.
1844 4. `:height HEIGHT' specifies that the height of the stretch produced
1845 should be HEIGHT, measured in canonical character units.
1847 5. `:relative-height FACTOR' specifies that the height of the
1848 stretch should be FACTOR times the height of the characters having
1851 Either none or exactly one of 4 or 5 must be present.
1853 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1854 of the stretch should be used for the ascent of the stretch.
1855 ASCENT must be in the range 0 <= ASCENT <= 100. */
1858 ((INTEGERP (X) || FLOATP (X)) \
1864 x_produce_stretch_glyph (it
)
1867 /* (space :width WIDTH :height HEIGHT. */
1869 extern Lisp_Object Qspace
;
1871 extern Lisp_Object QCwidth
, QCheight
, QCascent
;
1872 extern Lisp_Object QCrelative_width
, QCrelative_height
;
1873 extern Lisp_Object QCalign_to
;
1874 Lisp_Object prop
, plist
;
1875 double width
= 0, height
= 0, ascent
= 0;
1876 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1877 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
1879 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1881 /* List should start with `space'. */
1882 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
1883 plist
= XCDR (it
->object
);
1885 /* Compute the width of the stretch. */
1886 if (prop
= Fplist_get (plist
, QCwidth
),
1888 /* Absolute width `:width WIDTH' specified and valid. */
1889 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
);
1890 else if (prop
= Fplist_get (plist
, QCrelative_width
),
1893 /* Relative width `:relative-width FACTOR' specified and valid.
1894 Compute the width of the characters having the `glyph'
1897 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
1900 if (it
->multibyte_p
)
1902 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
1903 - IT_BYTEPOS (*it
));
1904 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
1907 it2
.c
= *p
, it2
.len
= 1;
1909 it2
.glyph_row
= NULL
;
1910 it2
.what
= IT_CHARACTER
;
1911 x_produce_glyphs (&it2
);
1912 width
= NUMVAL (prop
) * it2
.pixel_width
;
1914 else if (prop
= Fplist_get (plist
, QCalign_to
),
1916 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
) - it
->current_x
;
1918 /* Nothing specified -> width defaults to canonical char width. */
1919 width
= CANON_X_UNIT (it
->f
);
1921 /* Compute height. */
1922 if (prop
= Fplist_get (plist
, QCheight
),
1924 height
= NUMVAL (prop
) * CANON_Y_UNIT (it
->f
);
1925 else if (prop
= Fplist_get (plist
, QCrelative_height
),
1927 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
1929 height
= FONT_HEIGHT (font
);
1931 /* Compute percentage of height used for ascent. If
1932 `:ascent ASCENT' is present and valid, use that. Otherwise,
1933 derive the ascent from the font in use. */
1934 if (prop
= Fplist_get (plist
, QCascent
),
1935 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
1936 ascent
= NUMVAL (prop
) / 100.0;
1938 ascent
= (double) FONT_BASE (font
) / FONT_HEIGHT (font
);
1947 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
1948 if (!STRINGP (object
))
1949 object
= it
->w
->buffer
;
1950 x_append_stretch_glyph (it
, object
, width
, height
, ascent
);
1953 it
->pixel_width
= width
;
1954 it
->ascent
= it
->phys_ascent
= height
* ascent
;
1955 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
1958 if (face
->box
!= FACE_NO_BOX
)
1960 if (face
->box_line_width
> 0)
1962 it
->ascent
+= face
->box_line_width
;
1963 it
->descent
+= face
->box_line_width
;
1966 if (it
->start_of_box_run_p
)
1967 it
->pixel_width
+= abs (face
->box_line_width
);
1968 if (it
->end_of_box_run_p
)
1969 it
->pixel_width
+= abs (face
->box_line_width
);
1972 take_vertical_position_into_account (it
);
1975 /* Return proper value to be used as baseline offset of font that has
1976 ASCENT and DESCENT to draw characters by the font at the vertical
1977 center of the line of frame F.
1979 Here, out task is to find the value of BOFF in the following figure;
1981 -------------------------+-----------+-
1982 -+-+---------+-+ | |
1984 | | | | F_ASCENT F_HEIGHT
1987 | | |-|-+------+-----------|------- baseline
1989 | |---------|-+-+ | |
1991 -+-+---------+-+ F_DESCENT |
1992 -------------------------+-----------+-
1994 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1995 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1996 DESCENT = FONT->descent
1997 HEIGHT = FONT_HEIGHT (FONT)
1998 F_DESCENT = (F->output_data.x->font->descent
1999 - F->output_data.x->baseline_offset)
2000 F_HEIGHT = FRAME_LINE_HEIGHT (F)
2003 #define VCENTER_BASELINE_OFFSET(FONT, F) \
2004 (FONT_DESCENT (FONT) \
2005 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
2006 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
2007 - (FONT_DESCENT (FRAME_FONT (F)) - FRAME_BASELINE_OFFSET (F)))
2009 /* Produce glyphs/get display metrics for the display element IT is
2010 loaded with. See the description of struct display_iterator in
2011 dispextern.h for an overview of struct display_iterator. */
2014 x_produce_glyphs (it
)
2017 it
->glyph_not_available_p
= 0;
2019 if (it
->what
== IT_CHARACTER
)
2023 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2025 int font_not_found_p
;
2026 struct font_info
*font_info
;
2027 int boff
; /* baseline offset */
2028 /* We may change it->multibyte_p upon unibyte<->multibyte
2029 conversion. So, save the current value now and restore it
2032 Note: It seems that we don't have to record multibyte_p in
2033 struct glyph because the character code itself tells if or
2034 not the character is multibyte. Thus, in the future, we must
2035 consider eliminating the field `multibyte_p' in the struct
2038 int saved_multibyte_p
= it
->multibyte_p
;
2040 /* Maybe translate single-byte characters to multibyte, or the
2042 it
->char_to_display
= it
->c
;
2043 if (!ASCII_CHAR_P (it
->c
))
2045 if (SINGLE_BYTE_CHAR_P (it
->c
)
2046 && unibyte_display_via_language_environment
)
2047 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2048 if (! SINGLE_BYTE_CHAR_P (it
->c
))
2050 it
->multibyte_p
= 1;
2051 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2052 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2056 /* Get font to use. Encode IT->char_to_display. */
2057 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2058 it
->face_id
, &char2b
,
2062 /* When no suitable font found, use the default font. */
2063 font_not_found_p
= font
== NULL
;
2064 if (font_not_found_p
)
2066 font
= FRAME_FONT (it
->f
);
2067 boff
= it
->f
->output_data
.w32
->baseline_offset
;
2072 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2073 boff
= font_info
->baseline_offset
;
2074 if (font_info
->vertical_centering
)
2075 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2078 if (it
->char_to_display
>= ' '
2079 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
2081 /* Either unibyte or ASCII. */
2086 pcm
= w32_per_char_metric (font
, &char2b
,
2087 font
->bdf
? BDF_1D_FONT
: ANSI_FONT
);
2088 it
->ascent
= FONT_BASE (font
) + boff
;
2089 it
->descent
= FONT_DESCENT (font
) - boff
;
2093 it
->phys_ascent
= pcm
->ascent
+ boff
;
2094 it
->phys_descent
= pcm
->descent
- boff
;
2095 it
->pixel_width
= pcm
->width
;
2099 it
->glyph_not_available_p
= 1;
2100 it
->phys_ascent
= FONT_BASE (font
) + boff
;
2101 it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2102 it
->pixel_width
= FONT_WIDTH (font
);
2105 /* If this is a space inside a region of text with
2106 `space-width' property, change its width. */
2107 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
2109 it
->pixel_width
*= XFLOATINT (it
->space_width
);
2111 /* If face has a box, add the box thickness to the character
2112 height. If character has a box line to the left and/or
2113 right, add the box line width to the character's width. */
2114 if (face
->box
!= FACE_NO_BOX
)
2116 int thick
= face
->box_line_width
;
2120 it
->ascent
+= thick
;
2121 it
->descent
+= thick
;
2126 if (it
->start_of_box_run_p
)
2127 it
->pixel_width
+= thick
;
2128 if (it
->end_of_box_run_p
)
2129 it
->pixel_width
+= thick
;
2132 /* If face has an overline, add the height of the overline
2133 (1 pixel) and a 1 pixel margin to the character height. */
2134 if (face
->overline_p
)
2137 take_vertical_position_into_account (it
);
2139 /* If we have to actually produce glyphs, do it. */
2144 /* Translate a space with a `space-width' property
2145 into a stretch glyph. */
2146 double ascent
= (double) FONT_BASE (font
)
2147 / FONT_HEIGHT (font
);
2148 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
2149 it
->ascent
+ it
->descent
, ascent
);
2152 x_append_glyph (it
);
2154 /* If characters with lbearing or rbearing are displayed
2155 in this line, record that fact in a flag of the
2156 glyph row. This is used to optimize X output code. */
2157 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
2158 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2161 else if (it
->char_to_display
== '\n')
2163 /* A newline has no width but we need the height of the line. */
2164 it
->pixel_width
= 0;
2166 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
2167 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2169 if (face
->box
!= FACE_NO_BOX
2170 && face
->box_line_width
> 0)
2172 it
->ascent
+= face
->box_line_width
;
2173 it
->descent
+= face
->box_line_width
;
2176 else if (it
->char_to_display
== '\t')
2178 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
2179 int x
= it
->current_x
+ it
->continuation_lines_width
;
2180 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
2182 /* If the distance from the current position to the next tab
2183 stop is less than a canonical character width, use the
2184 tab stop after that. */
2185 if (next_tab_x
- x
< CANON_X_UNIT (it
->f
))
2186 next_tab_x
+= tab_width
;
2188 it
->pixel_width
= next_tab_x
- x
;
2190 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
2191 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2195 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
2196 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
2197 it
->ascent
+ it
->descent
, ascent
);
2202 /* A multi-byte character.
2203 If we found a font, this font should give us the right
2204 metrics. If we didn't find a font, use the frame's
2205 default font and calculate the width of the character
2206 from the charset width; this is what old redisplay code
2208 enum w32_char_font_type type
;
2210 if (font
->bdf
&& CHARSET_DIMENSION (CHAR_CHARSET (it
->c
)) == 1)
2215 type
= UNICODE_FONT
;
2217 pcm
= w32_per_char_metric (font
, &char2b
, type
);
2219 if (font_not_found_p
|| !pcm
)
2221 int charset
= CHAR_CHARSET (it
->char_to_display
);
2223 it
->glyph_not_available_p
= 1;
2224 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
2225 * CHARSET_WIDTH (charset
));
2226 it
->phys_ascent
= FONT_BASE (font
) + boff
;
2227 it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2231 it
->pixel_width
= pcm
->width
;
2232 it
->phys_ascent
= pcm
->ascent
+ boff
;
2233 it
->phys_descent
= pcm
->descent
- boff
;
2235 && (pcm
->lbearing
< 0
2236 || pcm
->rbearing
> pcm
->width
))
2237 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2240 it
->ascent
= FONT_BASE (font
) + boff
;
2241 it
->descent
= FONT_DESCENT (font
) - boff
;
2242 if (face
->box
!= FACE_NO_BOX
)
2244 int thick
= face
->box_line_width
;
2248 it
->ascent
+= thick
;
2249 it
->descent
+= thick
;
2254 if (it
->start_of_box_run_p
)
2255 it
->pixel_width
+= thick
;
2256 if (it
->end_of_box_run_p
)
2257 it
->pixel_width
+= thick
;
2260 /* If face has an overline, add the height of the overline
2261 (1 pixel) and a 1 pixel margin to the character height. */
2262 if (face
->overline_p
)
2265 take_vertical_position_into_account (it
);
2268 x_append_glyph (it
);
2270 it
->multibyte_p
= saved_multibyte_p
;
2272 else if (it
->what
== IT_COMPOSITION
)
2274 /* Note: A composition is represented as one glyph in the
2275 glyph matrix. There are no padding glyphs. */
2278 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2280 int font_not_found_p
;
2281 struct font_info
*font_info
;
2282 int boff
; /* baseline offset */
2283 struct composition
*cmp
= composition_table
[it
->cmp_id
];
2285 /* Maybe translate single-byte characters to multibyte. */
2286 it
->char_to_display
= it
->c
;
2287 if (unibyte_display_via_language_environment
2288 && SINGLE_BYTE_CHAR_P (it
->c
)
2291 && !NILP (Vnonascii_translation_table
))))
2293 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2296 /* Get face and font to use. Encode IT->char_to_display. */
2297 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2298 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2299 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2300 it
->face_id
, &char2b
, it
->multibyte_p
);
2303 /* When no suitable font found, use the default font. */
2304 font_not_found_p
= font
== NULL
;
2305 if (font_not_found_p
)
2307 font
= FRAME_FONT (it
->f
);
2308 boff
= it
->f
->output_data
.w32
->baseline_offset
;
2313 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2314 boff
= font_info
->baseline_offset
;
2315 if (font_info
->vertical_centering
)
2316 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2319 /* There are no padding glyphs, so there is only one glyph to
2320 produce for the composition. Important is that pixel_width,
2321 ascent and descent are the values of what is drawn by
2322 draw_glyphs (i.e. the values of the overall glyphs composed). */
2325 /* If we have not yet calculated pixel size data of glyphs of
2326 the composition for the current face font, calculate them
2327 now. Theoretically, we have to check all fonts for the
2328 glyphs, but that requires much time and memory space. So,
2329 here we check only the font of the first glyph. This leads
2330 to incorrect display very rarely, and C-l (recenter) can
2331 correct the display anyway. */
2332 if (cmp
->font
!= (void *) font
)
2334 /* Ascent and descent of the font of the first character of
2335 this composition (adjusted by baseline offset). Ascent
2336 and descent of overall glyphs should not be less than
2337 them respectively. */
2338 int font_ascent
= FONT_BASE (font
) + boff
;
2339 int font_descent
= FONT_DESCENT (font
) - boff
;
2340 /* Bounding box of the overall glyphs. */
2341 int leftmost
, rightmost
, lowest
, highest
;
2342 int i
, width
, ascent
, descent
;
2343 enum w32_char_font_type font_type
;
2345 cmp
->font
= (void *) font
;
2347 if (font
->bdf
&& CHARSET_DIMENSION (CHAR_CHARSET (it
->c
)) == 1)
2348 font_type
= BDF_1D_FONT
;
2350 font_type
= BDF_2D_FONT
;
2352 font_type
= UNICODE_FONT
;
2354 /* Initialize the bounding box. */
2356 && (pcm
= w32_per_char_metric (font
, &char2b
, font_type
)))
2359 ascent
= pcm
->ascent
;
2360 descent
= pcm
->descent
;
2364 width
= FONT_WIDTH (font
);
2365 ascent
= FONT_BASE (font
);
2366 descent
= FONT_DESCENT (font
);
2370 lowest
= - descent
+ boff
;
2371 highest
= ascent
+ boff
;
2375 && font_info
->default_ascent
2376 && CHAR_TABLE_P (Vuse_default_ascent
)
2377 && !NILP (Faref (Vuse_default_ascent
,
2378 make_number (it
->char_to_display
))))
2379 highest
= font_info
->default_ascent
+ boff
;
2381 /* Draw the first glyph at the normal position. It may be
2382 shifted to right later if some other glyphs are drawn at
2384 cmp
->offsets
[0] = 0;
2385 cmp
->offsets
[1] = boff
;
2387 /* Set cmp->offsets for the remaining glyphs. */
2388 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2390 int left
, right
, btm
, top
;
2391 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2392 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2394 face
= FACE_FROM_ID (it
->f
, face_id
);
2395 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2400 font
= FRAME_FONT (it
->f
);
2401 boff
= it
->f
->output_data
.w32
->baseline_offset
;
2407 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2408 boff
= font_info
->baseline_offset
;
2409 if (font_info
->vertical_centering
)
2410 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2413 if (font
->bdf
&& CHARSET_DIMENSION (CHAR_CHARSET (ch
)) == 1)
2414 font_type
= BDF_1D_FONT
;
2416 font_type
= BDF_2D_FONT
;
2418 font_type
= UNICODE_FONT
;
2421 && (pcm
= w32_per_char_metric (font
, &char2b
, font_type
)))
2424 ascent
= pcm
->ascent
;
2425 descent
= pcm
->descent
;
2429 width
= FONT_WIDTH (font
);
2434 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2436 /* Relative composition with or without
2438 left
= (leftmost
+ rightmost
- width
) / 2;
2439 btm
= - descent
+ boff
;
2440 if (font_info
&& font_info
->relative_compose
2441 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2442 || NILP (Faref (Vignore_relative_composition
,
2443 make_number (ch
)))))
2446 if (- descent
>= font_info
->relative_compose
)
2447 /* One extra pixel between two glyphs. */
2449 else if (ascent
<= 0)
2450 /* One extra pixel between two glyphs. */
2451 btm
= lowest
- 1 - ascent
- descent
;
2456 /* A composition rule is specified by an integer
2457 value that encodes global and new reference
2458 points (GREF and NREF). GREF and NREF are
2459 specified by numbers as below:
2467 ---3---4---5--- baseline
2469 6---7---8 -- descent
2471 int rule
= COMPOSITION_RULE (cmp
, i
);
2472 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2474 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2475 grefx
= gref
% 3, nrefx
= nref
% 3;
2476 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2479 + grefx
* (rightmost
- leftmost
) / 2
2480 - nrefx
* width
/ 2);
2481 btm
= ((grefy
== 0 ? highest
2483 : grefy
== 2 ? lowest
2484 : (highest
+ lowest
) / 2)
2485 - (nrefy
== 0 ? ascent
+ descent
2486 : nrefy
== 1 ? descent
- boff
2488 : (ascent
+ descent
) / 2));
2491 cmp
->offsets
[i
* 2] = left
;
2492 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
2494 /* Update the bounding box of the overall glyphs. */
2495 right
= left
+ width
;
2496 top
= btm
+ descent
+ ascent
;
2497 if (left
< leftmost
)
2499 if (right
> rightmost
)
2507 /* If there are glyphs whose x-offsets are negative,
2508 shift all glyphs to the right and make all x-offsets
2512 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2513 cmp
->offsets
[i
* 2] -= leftmost
;
2514 rightmost
-= leftmost
;
2517 cmp
->pixel_width
= rightmost
;
2518 cmp
->ascent
= highest
;
2519 cmp
->descent
= - lowest
;
2520 if (cmp
->ascent
< font_ascent
)
2521 cmp
->ascent
= font_ascent
;
2522 if (cmp
->descent
< font_descent
)
2523 cmp
->descent
= font_descent
;
2526 it
->pixel_width
= cmp
->pixel_width
;
2527 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2528 it
->descent
= it
->phys_descent
= cmp
->descent
;
2530 if (face
->box
!= FACE_NO_BOX
)
2532 int thick
= face
->box_line_width
;
2536 it
->ascent
+= thick
;
2537 it
->descent
+= thick
;
2542 if (it
->start_of_box_run_p
)
2543 it
->pixel_width
+= thick
;
2544 if (it
->end_of_box_run_p
)
2545 it
->pixel_width
+= thick
;
2548 /* If face has an overline, add the height of the overline
2549 (1 pixel) and a 1 pixel margin to the character height. */
2550 if (face
->overline_p
)
2553 take_vertical_position_into_account (it
);
2556 x_append_composite_glyph (it
);
2558 else if (it
->what
== IT_IMAGE
)
2559 x_produce_image_glyph (it
);
2560 else if (it
->what
== IT_STRETCH
)
2561 x_produce_stretch_glyph (it
);
2563 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2564 because this isn't true for images with `:ascent 100'. */
2565 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
2566 if (it
->area
== TEXT_AREA
)
2567 it
->current_x
+= it
->pixel_width
;
2569 it
->descent
+= it
->extra_line_spacing
;
2571 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2572 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2573 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2574 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2578 /* Estimate the pixel height of the mode or top line on frame F.
2579 FACE_ID specifies what line's height to estimate. */
2582 x_estimate_mode_line_height (f
, face_id
)
2584 enum face_id face_id
;
2586 int height
= FONT_HEIGHT (FRAME_FONT (f
));
2588 /* This function is called so early when Emacs starts that the face
2589 cache and mode line face are not yet initialized. */
2590 if (FRAME_FACE_CACHE (f
))
2592 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2596 height
= FONT_HEIGHT (face
->font
);
2597 if (face
->box_line_width
> 0)
2598 height
+= 2 * face
->box_line_width
;
2606 /***********************************************************************
2608 ***********************************************************************/
2610 /* A sequence of glyphs to be drawn in the same face.
2612 This data structure is not really completely X specific, so it
2613 could possibly, at least partially, be useful for other systems. It
2614 is currently not part of the external redisplay interface because
2615 it's not clear what other systems will need. */
2619 /* X-origin of the string. */
2622 /* Y-origin and y-position of the base line of this string. */
2625 /* The width of the string, not including a face extension. */
2628 /* The width of the string, including a face extension. */
2629 int background_width
;
2631 /* The height of this string. This is the height of the line this
2632 string is drawn in, and can be different from the height of the
2633 font the string is drawn in. */
2636 /* Number of pixels this string overwrites in front of its x-origin.
2637 This number is zero if the string has an lbearing >= 0; it is
2638 -lbearing, if the string has an lbearing < 0. */
2641 /* Number of pixels this string overwrites past its right-most
2642 nominal x-position, i.e. x + width. Zero if the string's
2643 rbearing is <= its nominal width, rbearing - width otherwise. */
2646 /* The frame on which the glyph string is drawn. */
2649 /* The window on which the glyph string is drawn. */
2652 /* X display and window for convenience. */
2655 /* The glyph row for which this string was built. It determines the
2656 y-origin and height of the string. */
2657 struct glyph_row
*row
;
2659 /* The area within row. */
2660 enum glyph_row_area area
;
2662 /* Characters to be drawn, and number of characters. */
2666 /* A face-override for drawing cursors, mouse face and similar. */
2667 enum draw_glyphs_face hl
;
2669 /* Face in which this string is to be drawn. */
2672 /* Font in which this string is to be drawn. */
2675 /* Font info for this string. */
2676 struct font_info
*font_info
;
2678 /* Non-null means this string describes (part of) a composition.
2679 All characters from char2b are drawn composed. */
2680 struct composition
*cmp
;
2682 /* Index of this glyph string's first character in the glyph
2683 definition of CMP. If this is zero, this glyph string describes
2684 the first character of a composition. */
2687 /* 1 means this glyph strings face has to be drawn to the right end
2688 of the window's drawing area. */
2689 unsigned extends_to_end_of_line_p
: 1;
2691 /* 1 means the background of this string has been drawn. */
2692 unsigned background_filled_p
: 1;
2694 /* 1 means glyph string must be drawn with 16-bit functions. */
2695 unsigned two_byte_p
: 1;
2697 /* 1 means that the original font determined for drawing this glyph
2698 string could not be loaded. The member `font' has been set to
2699 the frame's default font in this case. */
2700 unsigned font_not_found_p
: 1;
2702 /* 1 means that the face in which this glyph string is drawn has a
2704 unsigned stippled_p
: 1;
2706 /* 1 means only the foreground of this glyph string must be drawn,
2707 and we should use the physical height of the line this glyph
2708 string appears in as clip rect. */
2709 unsigned for_overlaps_p
: 1;
2711 /* The GC to use for drawing this glyph string. */
2716 /* A pointer to the first glyph in the string. This glyph
2717 corresponds to char2b[0]. Needed to draw rectangles if
2718 font_not_found_p is 1. */
2719 struct glyph
*first_glyph
;
2721 /* Image, if any. */
2724 struct glyph_string
*next
, *prev
;
2728 /* Encapsulate the different ways of displaying text under W32. */
2731 w32_text_out (s
, x
, y
,chars
,nchars
)
2732 struct glyph_string
* s
;
2737 int charset_dim
= w32_font_is_double_byte (s
->gc
->font
) ? 2 : 1;
2738 if (s
->gc
->font
->bdf
)
2739 w32_BDF_TextOut (s
->gc
->font
->bdf
, s
->hdc
,
2740 x
, y
, (char *) chars
, charset_dim
,
2741 nchars
* charset_dim
, 0);
2742 else if (s
->first_glyph
->w32_font_type
== UNICODE_FONT
)
2743 ExtTextOutW (s
->hdc
, x
, y
, 0, NULL
, chars
, nchars
, NULL
);
2745 ExtTextOutA (s
->hdc
, x
, y
, 0, NULL
, (char *) chars
,
2746 nchars
* charset_dim
, NULL
);
2752 x_dump_glyph_string (s
)
2753 struct glyph_string
*s
;
2755 fprintf (stderr
, "glyph string\n");
2756 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2757 s
->x
, s
->y
, s
->width
, s
->height
);
2758 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2759 fprintf (stderr
, " hl = %d\n", s
->hl
);
2760 fprintf (stderr
, " left overhang = %d, right = %d\n",
2761 s
->left_overhang
, s
->right_overhang
);
2762 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2763 fprintf (stderr
, " extends to end of line = %d\n",
2764 s
->extends_to_end_of_line_p
);
2765 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2766 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2769 #endif /* GLYPH_DEBUG */
2773 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
2774 struct glyph_string
**,
2775 struct glyph_string
*,
2776 struct glyph_string
*));
2777 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
2778 struct glyph_string
**,
2779 struct glyph_string
*,
2780 struct glyph_string
*));
2781 static void x_append_glyph_string
P_ ((struct glyph_string
**,
2782 struct glyph_string
**,
2783 struct glyph_string
*));
2784 static int x_left_overwritten
P_ ((struct glyph_string
*));
2785 static int x_left_overwriting
P_ ((struct glyph_string
*));
2786 static int x_right_overwritten
P_ ((struct glyph_string
*));
2787 static int x_right_overwriting
P_ ((struct glyph_string
*));
2788 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int, int,
2790 static void w32_init_glyph_string
P_ ((struct glyph_string
*, HDC hdc
,
2791 wchar_t *, struct window
*,
2793 enum glyph_row_area
, int,
2794 enum draw_glyphs_face
));
2795 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
2796 enum glyph_row_area
, int, int,
2797 enum draw_glyphs_face
, int));
2798 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2799 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2800 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2802 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2803 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2804 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2805 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2806 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2807 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2808 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2809 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2810 static void w32_get_glyph_overhangs
P_ ((HDC hdc
, struct glyph
*,
2813 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
2814 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
2815 static void w32_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2816 double, int, COLORREF
));
2817 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2818 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2819 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2820 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2821 static void w32_draw_image_foreground_1
P_ ((struct glyph_string
*, HBITMAP
));
2822 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
2823 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2825 static void w32_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2826 int, int, int, int, RECT
*));
2827 static void w32_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2828 int, int, int, RECT
*));
2829 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
2830 enum glyph_row_area
));
2831 static int x_fill_stretch_glyph_string
P_ ((struct glyph_string
*,
2833 enum glyph_row_area
, int, int));
2836 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
2840 /* Append the list of glyph strings with head H and tail T to the list
2841 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2844 x_append_glyph_string_lists (head
, tail
, h
, t
)
2845 struct glyph_string
**head
, **tail
;
2846 struct glyph_string
*h
, *t
;
2860 /* Prepend the list of glyph strings with head H and tail T to the
2861 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2865 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
2866 struct glyph_string
**head
, **tail
;
2867 struct glyph_string
*h
, *t
;
2881 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2882 Set *HEAD and *TAIL to the resulting list. */
2885 x_append_glyph_string (head
, tail
, s
)
2886 struct glyph_string
**head
, **tail
;
2887 struct glyph_string
*s
;
2889 s
->next
= s
->prev
= NULL
;
2890 x_append_glyph_string_lists (head
, tail
, s
, s
);
2894 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2899 struct glyph_string
*s
;
2901 if (s
->font
== FRAME_FONT (s
->f
)
2902 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2903 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2905 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
2908 /* Cursor on non-default face: must merge. */
2912 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
2913 xgcv
.foreground
= s
->face
->background
;
2915 /* If the glyph would be invisible, try a different foreground. */
2916 if (xgcv
.foreground
== xgcv
.background
)
2917 xgcv
.foreground
= s
->face
->foreground
;
2918 if (xgcv
.foreground
== xgcv
.background
)
2919 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
2920 if (xgcv
.foreground
== xgcv
.background
)
2921 xgcv
.foreground
= s
->face
->foreground
;
2923 /* Make sure the cursor is distinct from text in this face. */
2924 if (xgcv
.background
== s
->face
->background
2925 && xgcv
.foreground
== s
->face
->foreground
)
2927 xgcv
.background
= s
->face
->foreground
;
2928 xgcv
.foreground
= s
->face
->background
;
2931 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2932 xgcv
.font
= s
->font
;
2933 mask
= GCForeground
| GCBackground
| GCFont
;
2935 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2936 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2939 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2940 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
2942 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2947 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2950 x_set_mouse_face_gc (s
)
2951 struct glyph_string
*s
;
2956 /* What face has to be used last for the mouse face? */
2957 face_id
= FRAME_W32_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2958 face
= FACE_FROM_ID (s
->f
, face_id
);
2960 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
2962 if (s
->first_glyph
->type
== CHAR_GLYPH
)
2963 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2965 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
2966 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2967 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2969 /* If font in this face is same as S->font, use it. */
2970 if (s
->font
== s
->face
->font
)
2971 s
->gc
= s
->face
->gc
;
2974 /* Otherwise construct scratch_cursor_gc with values from FACE
2979 xgcv
.background
= s
->face
->background
;
2980 xgcv
.foreground
= s
->face
->foreground
;
2981 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2982 xgcv
.font
= s
->font
;
2983 mask
= GCForeground
| GCBackground
| GCFont
;
2985 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2986 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2989 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2990 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
2992 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2995 xassert (s
->gc
!= 0);
2999 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
3000 Faces to use in the mode line have already been computed when the
3001 matrix was built, so there isn't much to do, here. */
3004 x_set_mode_line_face_gc (s
)
3005 struct glyph_string
*s
;
3007 s
->gc
= s
->face
->gc
;
3011 /* Set S->gc of glyph string S for drawing that glyph string. Set
3012 S->stippled_p to a non-zero value if the face of S has a stipple
3016 x_set_glyph_string_gc (s
)
3017 struct glyph_string
*s
;
3019 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
3021 if (s
->hl
== DRAW_NORMAL_TEXT
)
3023 s
->gc
= s
->face
->gc
;
3024 s
->stippled_p
= s
->face
->stipple
!= 0;
3026 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
3028 x_set_mode_line_face_gc (s
);
3029 s
->stippled_p
= s
->face
->stipple
!= 0;
3031 else if (s
->hl
== DRAW_CURSOR
)
3033 x_set_cursor_gc (s
);
3036 else if (s
->hl
== DRAW_MOUSE_FACE
)
3038 x_set_mouse_face_gc (s
);
3039 s
->stippled_p
= s
->face
->stipple
!= 0;
3041 else if (s
->hl
== DRAW_IMAGE_RAISED
3042 || s
->hl
== DRAW_IMAGE_SUNKEN
)
3044 s
->gc
= s
->face
->gc
;
3045 s
->stippled_p
= s
->face
->stipple
!= 0;
3049 s
->gc
= s
->face
->gc
;
3050 s
->stippled_p
= s
->face
->stipple
!= 0;
3053 /* GC must have been set. */
3054 xassert (s
->gc
!= 0);
3058 /* Return in *R the clipping rectangle for glyph string S. */
3061 w32_get_glyph_string_clip_rect (s
, r
)
3062 struct glyph_string
*s
;
3065 int r_height
, r_width
;
3067 if (s
->row
->full_width_p
)
3069 /* Draw full-width. X coordinates are relative to S->w->left. */
3070 int canon_x
= CANON_X_UNIT (s
->f
);
3072 r
->left
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
3073 r_width
= XFASTINT (s
->w
->width
) * canon_x
;
3075 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
3077 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
3078 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
3082 r
->left
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
3084 /* Unless displaying a mode or menu bar line, which are always
3085 fully visible, clip to the visible part of the row. */
3086 if (s
->w
->pseudo_window_p
)
3087 r_height
= s
->row
->visible_height
;
3089 r_height
= s
->height
;
3093 /* This is a text line that may be partially visible. */
3094 r
->left
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
3095 r_width
= window_box_width (s
->w
, s
->area
);
3096 r_height
= s
->row
->visible_height
;
3099 /* If S draws overlapping rows, it's sufficient to use the top and
3100 bottom of the window for clipping because this glyph string
3101 intentionally draws over other lines. */
3102 if (s
->for_overlaps_p
)
3104 r
->top
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
3105 r_height
= window_text_bottom_y (s
->w
) - r
->top
;
3109 /* Don't use S->y for clipping because it doesn't take partially
3110 visible lines into account. For example, it can be negative for
3111 partially visible lines at the top of a window. */
3112 if (!s
->row
->full_width_p
3113 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
3114 r
->top
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
3116 r
->top
= max (0, s
->row
->y
);
3118 /* If drawing a tool-bar window, draw it over the internal border
3119 at the top of the window. */
3120 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
3121 r
->top
-= s
->f
->output_data
.w32
->internal_border_width
;
3124 r
->top
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->top
);
3126 r
->bottom
= r
->top
+ r_height
;
3127 r
->right
= r
->left
+ r_width
;
3131 /* Set clipping for output of glyph string S. S may be part of a mode
3132 line or menu if we don't have X toolkit support. */
3135 x_set_glyph_string_clipping (s
)
3136 struct glyph_string
*s
;
3139 w32_get_glyph_string_clip_rect (s
, &r
);
3140 w32_set_clip_rectangle (s
->hdc
, &r
);
3144 /* Compute left and right overhang of glyph string S. If S is a glyph
3145 string for a composition, assume overhangs don't exist. */
3148 x_compute_glyph_string_overhangs (s
)
3149 struct glyph_string
*s
;
3151 /* TODO: Windows does not appear to have a method for
3152 getting this info without getting the ABC widths for each
3153 individual character and working it out manually. */
3157 /* Compute overhangs and x-positions for glyph string S and its
3158 predecessors, or successors. X is the starting x-position for S.
3159 BACKWARD_P non-zero means process predecessors. */
3162 x_compute_overhangs_and_x (s
, x
, backward_p
)
3163 struct glyph_string
*s
;
3171 x_compute_glyph_string_overhangs (s
);
3181 x_compute_glyph_string_overhangs (s
);
3190 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
3191 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
3192 assumed to be zero. */
3195 w32_get_glyph_overhangs (hdc
, glyph
, f
, left
, right
)
3197 struct glyph
*glyph
;
3203 if (glyph
->type
== CHAR_GLYPH
)
3210 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
3214 && (pcm
= w32_per_char_metric (font
, &char2b
,
3215 glyph
->w32_font_type
)))
3217 if (pcm
->rbearing
> pcm
->width
)
3218 *right
= pcm
->rbearing
- pcm
->width
;
3219 if (pcm
->lbearing
< 0)
3220 *left
= -pcm
->lbearing
;
3227 x_get_glyph_overhangs (glyph
, f
, left
, right
)
3228 struct glyph
*glyph
;
3232 HDC hdc
= get_frame_dc (f
);
3233 /* Convert to unicode! */
3234 w32_get_glyph_overhangs (hdc
, glyph
, f
, left
, right
);
3235 release_frame_dc (f
, hdc
);
3239 /* Return the index of the first glyph preceding glyph string S that
3240 is overwritten by S because of S's left overhang. Value is -1
3241 if no glyphs are overwritten. */
3244 x_left_overwritten (s
)
3245 struct glyph_string
*s
;
3249 if (s
->left_overhang
)
3252 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3253 int first
= s
->first_glyph
- glyphs
;
3255 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
3256 x
-= glyphs
[i
].pixel_width
;
3267 /* Return the index of the first glyph preceding glyph string S that
3268 is overwriting S because of its right overhang. Value is -1 if no
3269 glyph in front of S overwrites S. */
3272 x_left_overwriting (s
)
3273 struct glyph_string
*s
;
3276 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3277 int first
= s
->first_glyph
- glyphs
;
3281 for (i
= first
- 1; i
>= 0; --i
)
3284 w32_get_glyph_overhangs (s
->hdc
, glyphs
+ i
, s
->f
, &left
, &right
);
3287 x
-= glyphs
[i
].pixel_width
;
3294 /* Return the index of the last glyph following glyph string S that is
3295 not overwritten by S because of S's right overhang. Value is -1 if
3296 no such glyph is found. */
3299 x_right_overwritten (s
)
3300 struct glyph_string
*s
;
3304 if (s
->right_overhang
)
3307 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3308 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3309 int end
= s
->row
->used
[s
->area
];
3311 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
3312 x
+= glyphs
[i
].pixel_width
;
3321 /* Return the index of the last glyph following glyph string S that
3322 overwrites S because of its left overhang. Value is negative
3323 if no such glyph is found. */
3326 x_right_overwriting (s
)
3327 struct glyph_string
*s
;
3330 int end
= s
->row
->used
[s
->area
];
3331 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3332 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3336 for (i
= first
; i
< end
; ++i
)
3339 w32_get_glyph_overhangs (s
->hdc
, glyphs
+ i
, s
->f
, &left
, &right
);
3342 x
+= glyphs
[i
].pixel_width
;
3349 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3352 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
3353 struct glyph_string
*s
;
3361 /* Take clipping into account. */
3362 if (s
->gc
->clip_mask
== Rect
)
3364 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
3365 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
3366 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
3367 - s
->gc
->clip_rectangle
.left
);
3368 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
3369 - s
->gc
->clip_rectangle
.top
);
3372 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
3377 /* Draw the background of glyph_string S. If S->background_filled_p
3378 is non-zero don't draw it. FORCE_P non-zero means draw the
3379 background even if it wouldn't be drawn normally. This is used
3380 when a string preceding S draws into the background of S, or S
3381 contains the first component of a composition. */
3384 x_draw_glyph_string_background (s
, force_p
)
3385 struct glyph_string
*s
;
3388 /* Nothing to do if background has already been drawn or if it
3389 shouldn't be drawn in the first place. */
3390 if (!s
->background_filled_p
)
3392 int box_line_width
= max (s
->face
->box_line_width
, 0);
3394 #if 0 /* TODO: stipple */
3397 /* Fill background with a stipple pattern. */
3398 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3399 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
3400 s
->y
+ box_line_width
,
3401 s
->background_width
,
3402 s
->height
- 2 * box_line_width
);
3403 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3404 s
->background_filled_p
= 1;
3408 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
3409 || s
->font_not_found_p
3410 || s
->extends_to_end_of_line_p
3414 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
3415 s
->background_width
,
3416 s
->height
- 2 * box_line_width
);
3417 s
->background_filled_p
= 1;
3423 /* Draw the foreground of glyph string S. */
3426 x_draw_glyph_string_foreground (s
)
3427 struct glyph_string
*s
;
3432 /* If first glyph of S has a left box line, start drawing the text
3433 of S to the right of that box line. */
3434 if (s
->face
->box
!= FACE_NO_BOX
3435 && s
->first_glyph
->left_box_line_p
)
3436 x
= s
->x
+ abs (s
->face
->box_line_width
);
3440 if (s
->for_overlaps_p
|| (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3441 SetBkMode (s
->hdc
, TRANSPARENT
);
3443 SetBkMode (s
->hdc
, OPAQUE
);
3445 SetTextColor (s
->hdc
, s
->gc
->foreground
);
3446 SetBkColor (s
->hdc
, s
->gc
->background
);
3447 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
3449 if (s
->font
&& s
->font
->hfont
)
3450 old_font
= SelectObject (s
->hdc
, s
->font
->hfont
);
3452 /* Draw characters of S as rectangles if S's font could not be
3454 if (s
->font_not_found_p
)
3456 for (i
= 0; i
< s
->nchars
; ++i
)
3458 struct glyph
*g
= s
->first_glyph
+ i
;
3460 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3462 x
+= g
->pixel_width
;
3467 char *char1b
= (char *) s
->char2b
;
3468 int boff
= s
->font_info
->baseline_offset
;
3470 if (s
->font_info
->vertical_centering
)
3471 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3473 /* If we can use 8-bit functions, condense S->char2b. */
3475 for (i
= 0; i
< s
->nchars
; ++i
)
3476 char1b
[i
] = BYTE2 (s
->char2b
[i
]);
3478 /* Draw text with TextOut and friends. */
3479 w32_text_out (s
, x
, s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3481 if (s
->font
&& s
->font
->hfont
)
3482 SelectObject (s
->hdc
, old_font
);
3485 /* Draw the foreground of composite glyph string S. */
3488 x_draw_composite_glyph_string_foreground (s
)
3489 struct glyph_string
*s
;
3494 /* If first glyph of S has a left box line, start drawing the text
3495 of S to the right of that box line. */
3496 if (s
->face
->box
!= FACE_NO_BOX
3497 && s
->first_glyph
->left_box_line_p
)
3498 x
= s
->x
+ abs (s
->face
->box_line_width
);
3502 /* S is a glyph string for a composition. S->gidx is the index of
3503 the first character drawn for glyphs of this composition.
3504 S->gidx == 0 means we are drawing the very first character of
3505 this composition. */
3507 SetTextColor (s
->hdc
, s
->gc
->foreground
);
3508 SetBkColor (s
->hdc
, s
->gc
->background
);
3509 SetBkMode (s
->hdc
, TRANSPARENT
);
3510 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
3512 if (s
->font
&& s
->font
->hfont
)
3513 old_font
= SelectObject (s
->hdc
, s
->font
->hfont
);
3515 /* Draw a rectangle for the composition if the font for the very
3516 first character of the composition could not be loaded. */
3517 if (s
->font_not_found_p
)
3520 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
3525 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3526 w32_text_out (s
, x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3527 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3530 if (s
->font
&& s
->font
->hfont
)
3531 SelectObject (s
->hdc
, old_font
);
3535 /* Brightness beyond which a color won't have its highlight brightness
3538 Nominally, highlight colors for `3d' faces are calculated by
3539 brightening an object's color by a constant scale factor, but this
3540 doesn't yield good results for dark colors, so for colors who's
3541 brightness is less than this value (on a scale of 0-255) have to
3542 use an additional additive factor.
3544 The value here is set so that the default menu-bar/mode-line color
3545 (grey75) will not have its highlights changed at all. */
3546 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
3549 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
3550 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3551 If this produces the same color as COLOR, try a color where all RGB
3552 values have DELTA added. Return the allocated color in *COLOR.
3553 DISPLAY is the X display, CMAP is the colormap to operate on.
3554 Value is non-zero if successful. */
3557 w32_alloc_lighter_color (f
, color
, factor
, delta
)
3566 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
3569 /* Change RGB values by specified FACTOR. Avoid overflow! */
3570 xassert (factor
>= 0);
3571 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
3572 min (0xff, factor
* GetGValue (*color
)),
3573 min (0xff, factor
* GetBValue (*color
)));
3575 /* Calculate brightness of COLOR. */
3576 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
3577 + GetBValue (*color
)) / 6;
3579 /* We only boost colors that are darker than
3580 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3581 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
3582 /* Make an additive adjustment to NEW, because it's dark enough so
3583 that scaling by FACTOR alone isn't enough. */
3585 /* How far below the limit this color is (0 - 1, 1 being darker). */
3586 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
3587 /* The additive adjustment. */
3588 int min_delta
= delta
* dimness
* factor
/ 2;
3591 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
3592 max (0, min (0xff, min_delta
- GetGValue (*color
))),
3593 max (0, min (0xff, min_delta
- GetBValue (*color
))));
3595 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
3596 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
3597 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
3601 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
3602 max (0, min (0xff, delta
+ GetGValue (*color
))),
3603 max (0, min (0xff, delta
+ GetBValue (*color
))));
3605 /* TODO: Map to palette and retry with delta if same? */
3606 /* TODO: Free colors (if using palette)? */
3617 /* Set up the foreground color for drawing relief lines of glyph
3618 string S. RELIEF is a pointer to a struct relief containing the GC
3619 with which lines will be drawn. Use a color that is FACTOR or
3620 DELTA lighter or darker than the relief's background which is found
3621 in S->f->output_data.x->relief_background. If such a color cannot
3622 be allocated, use DEFAULT_PIXEL, instead. */
3625 w32_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3627 struct relief
*relief
;
3630 COLORREF default_pixel
;
3633 struct w32_output
*di
= f
->output_data
.w32
;
3634 unsigned long mask
= GCForeground
;
3636 COLORREF background
= di
->relief_background
;
3637 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
3639 /* TODO: Free colors (if using palette)? */
3641 /* Allocate new color. */
3642 xgcv
.foreground
= default_pixel
;
3644 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
3646 relief
->allocated_p
= 1;
3647 xgcv
.foreground
= relief
->pixel
= pixel
;
3650 if (relief
->gc
== 0)
3652 #if 0 /* TODO: stipple */
3653 xgcv
.stipple
= dpyinfo
->gray
;
3656 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
3659 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
3663 /* Set up colors for the relief lines around glyph string S. */
3666 x_setup_relief_colors (s
)
3667 struct glyph_string
*s
;
3669 struct w32_output
*di
= s
->f
->output_data
.w32
;
3672 if (s
->face
->use_box_color_for_shadows_p
)
3673 color
= s
->face
->box_color
;
3674 else if (s
->first_glyph
->type
== IMAGE_GLYPH
3676 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
3677 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
3679 color
= s
->gc
->background
;
3681 if (di
->white_relief
.gc
== 0
3682 || color
!= di
->relief_background
)
3684 di
->relief_background
= color
;
3685 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3686 WHITE_PIX_DEFAULT (s
->f
));
3687 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3688 BLACK_PIX_DEFAULT (s
->f
));
3693 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3694 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3695 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3696 relief. LEFT_P non-zero means draw a relief on the left side of
3697 the rectangle. RIGHT_P non-zero means draw a relief on the right
3698 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3702 w32_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3703 raised_p
, left_p
, right_p
, clip_rect
)
3705 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
3710 HDC hdc
= get_frame_dc (f
);
3713 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
3715 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
3717 w32_set_clip_rectangle (hdc
, clip_rect
);
3720 for (i
= 0; i
< width
; ++i
)
3721 w32_fill_area (f
, hdc
, gc
.foreground
,
3722 left_x
+ i
* left_p
, top_y
+ i
,
3723 (right_x
+ 1 - i
* right_p
) - (left_x
+ i
* left_p
) + 1, 1);
3727 for (i
= 0; i
< width
; ++i
)
3728 w32_fill_area (f
, hdc
, gc
.foreground
,
3729 left_x
+ i
, top_y
+ i
, 1,
3730 (bottom_y
- i
) - (top_y
+ i
) + 2);
3733 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
3735 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
3738 for (i
= 0; i
< width
; ++i
)
3739 w32_fill_area (f
, hdc
, gc
.foreground
,
3740 left_x
+ i
* left_p
, bottom_y
- i
,
3741 (right_x
- i
* right_p
) - (left_x
+ i
* left_p
) + 2, 1);
3745 for (i
= 0; i
< width
; ++i
)
3746 w32_fill_area (f
, hdc
, gc
.foreground
,
3747 right_x
- i
, top_y
+ i
+ 1, 1,
3748 (bottom_y
- i
) - (top_y
+ i
));
3750 w32_set_clip_rectangle (hdc
, NULL
);
3752 release_frame_dc (f
, hdc
);
3756 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3757 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3758 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3759 left side of the rectangle. RIGHT_P non-zero means draw a line
3760 on the right side of the rectangle. CLIP_RECT is the clipping
3761 rectangle to use when drawing. */
3764 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3765 left_p
, right_p
, clip_rect
)
3766 struct glyph_string
*s
;
3767 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
3770 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
3773 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3774 left_x
, top_y
, right_x
- left_x
+ 1, width
);
3779 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3780 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
3784 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3785 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
3790 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3791 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
3794 w32_set_clip_rectangle (s
->hdc
, NULL
);
3798 /* Draw a box around glyph string S. */
3801 x_draw_glyph_string_box (s
)
3802 struct glyph_string
*s
;
3804 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3805 int left_p
, right_p
;
3806 struct glyph
*last_glyph
;
3809 last_x
= window_box_right (s
->w
, s
->area
);
3810 if (s
->row
->full_width_p
3811 && !s
->w
->pseudo_window_p
)
3813 last_x
+= FRAME_X_RIGHT_FRINGE_WIDTH (s
->f
);
3814 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
3815 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
3818 /* The glyph that may have a right box line. */
3819 last_glyph
= (s
->cmp
|| s
->img
3821 : s
->first_glyph
+ s
->nchars
- 1);
3823 width
= abs (s
->face
->box_line_width
);
3824 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
3826 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
3828 : min (last_x
, s
->x
+ s
->background_width
) - 1));
3830 bottom_y
= top_y
+ s
->height
- 1;
3832 left_p
= (s
->first_glyph
->left_box_line_p
3833 || (s
->hl
== DRAW_MOUSE_FACE
3835 || s
->prev
->hl
!= s
->hl
)));
3836 right_p
= (last_glyph
->right_box_line_p
3837 || (s
->hl
== DRAW_MOUSE_FACE
3839 || s
->next
->hl
!= s
->hl
)));
3841 w32_get_glyph_string_clip_rect (s
, &clip_rect
);
3843 if (s
->face
->box
== FACE_SIMPLE_BOX
)
3844 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3845 left_p
, right_p
, &clip_rect
);
3848 x_setup_relief_colors (s
);
3849 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
3850 width
, raised_p
, left_p
, right_p
, &clip_rect
);
3855 /* Draw foreground of image glyph string S. */
3858 x_draw_image_foreground (s
)
3859 struct glyph_string
*s
;
3862 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3864 /* If first glyph of S has a left box line, start drawing it to the
3865 right of that line. */
3866 if (s
->face
->box
!= FACE_NO_BOX
3867 && s
->first_glyph
->left_box_line_p
)
3868 x
= s
->x
+ abs (s
->face
->box_line_width
);
3872 /* If there is a margin around the image, adjust x- and y-position
3874 x
+= s
->img
->hmargin
;
3875 y
+= s
->img
->vmargin
;
3881 #if 0 /* TODO: image mask */
3884 /* We can't set both a clip mask and use XSetClipRectangles
3885 because the latter also sets a clip mask. We also can't
3886 trust on the shape extension to be available
3887 (XShapeCombineRegion). So, compute the rectangle to draw
3889 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3892 XRectangle clip_rect
, image_rect
, r
;
3894 xgcv
.clip_mask
= s
->img
->mask
;
3895 xgcv
.clip_x_origin
= x
;
3896 xgcv
.clip_y_origin
= y
;
3897 xgcv
.function
= GXcopy
;
3898 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3900 w32_get_glyph_string_clip_rect (s
, &clip_rect
);
3903 image_rect
.width
= s
->img
->width
;
3904 image_rect
.height
= s
->img
->height
;
3905 if (IntersectRect (&r
, &clip_rect
, &image_rect
))
3906 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
3907 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
3912 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
3913 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
3914 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
3915 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
3916 x_set_glyph_string_clipping (s
);
3918 SetTextColor (s
->hdc
, s
->gc
->foreground
);
3919 SetBkColor (s
->hdc
, s
->gc
->background
);
3920 #if 0 /* From w32bdf.c (which is from Meadow). */
3921 BitBlt (s
->hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3922 compat_hdc
, 0, 0, SRCCOPY
);
3923 BitBlt (s
->hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3924 compat_hdc
, 0, 0, 0xB8074A);
3926 BitBlt (s
->hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3927 compat_hdc
, 0, 0, 0xE20746);
3929 SelectObject (s
->hdc
, orig_brush
);
3930 DeleteObject (fg_brush
);
3931 SelectObject (compat_hdc
, orig_obj
);
3932 DeleteDC (compat_hdc
);
3934 /* When the image has a mask, we can expect that at
3935 least part of a mouse highlight or a block cursor will
3936 be visible. If the image doesn't have a mask, make
3937 a block cursor visible by drawing a rectangle around
3938 the image. I believe it's looking better if we do
3939 nothing here for mouse-face. */
3940 if (s
->hl
== DRAW_CURSOR
)
3941 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
, s
->img
->width
- 1,
3942 s
->img
->height
- 1);
3943 w32_set_clip_rectangle (s
->hdc
, NULL
);
3947 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
, s
->img
->width
-1,
3948 s
->img
->height
- 1);
3950 RestoreDC (s
->hdc
,-1);
3955 /* Draw a relief around the image glyph string S. */
3958 x_draw_image_relief (s
)
3959 struct glyph_string
*s
;
3961 int x0
, y0
, x1
, y1
, thick
, raised_p
;
3964 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3966 /* If first glyph of S has a left box line, start drawing it to the
3967 right of that line. */
3968 if (s
->face
->box
!= FACE_NO_BOX
3969 && s
->first_glyph
->left_box_line_p
)
3970 x
= s
->x
+ abs (s
->face
->box_line_width
);
3974 /* If there is a margin around the image, adjust x- and y-position
3976 x
+= s
->img
->hmargin
;
3977 y
+= s
->img
->vmargin
;
3979 if (s
->hl
== DRAW_IMAGE_SUNKEN
3980 || s
->hl
== DRAW_IMAGE_RAISED
)
3982 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
3983 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
3987 thick
= abs (s
->img
->relief
);
3988 raised_p
= s
->img
->relief
> 0;
3993 x1
= x
+ s
->img
->width
+ thick
- 1;
3994 y1
= y
+ s
->img
->height
+ thick
- 1;
3996 x_setup_relief_colors (s
);
3997 w32_get_glyph_string_clip_rect (s
, &r
);
3998 w32_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
4002 /* Draw the foreground of image glyph string S to PIXMAP. */
4005 w32_draw_image_foreground_1 (s
, pixmap
)
4006 struct glyph_string
*s
;
4009 HDC hdc
= CreateCompatibleDC (s
->hdc
);
4010 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
4012 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
);
4014 /* If first glyph of S has a left box line, start drawing it to the
4015 right of that line. */
4016 if (s
->face
->box
!= FACE_NO_BOX
4017 && s
->first_glyph
->left_box_line_p
)
4018 x
= abs (s
->face
->box_line_width
);
4022 /* If there is a margin around the image, adjust x- and y-position
4024 x
+= s
->img
->hmargin
;
4025 y
+= s
->img
->vmargin
;
4029 #if 0 /* TODO: image mask */
4032 /* We can't set both a clip mask and use XSetClipRectangles
4033 because the latter also sets a clip mask. We also can't
4034 trust on the shape extension to be available
4035 (XShapeCombineRegion). So, compute the rectangle to draw
4037 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
4041 xgcv
.clip_mask
= s
->img
->mask
;
4042 xgcv
.clip_x_origin
= x
;
4043 xgcv
.clip_y_origin
= y
;
4044 xgcv
.function
= GXcopy
;
4045 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
4047 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4048 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4049 XSetClipMask (s
->display
, s
->gc
, None
);
4054 HDC compat_hdc
= CreateCompatibleDC (hdc
);
4055 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
4056 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
4057 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
4059 SetTextColor (hdc
, s
->gc
->foreground
);
4060 SetBkColor (hdc
, s
->gc
->background
);
4061 #if 0 /* From w32bdf.c (which is from Meadow). */
4062 BitBlt (hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
4063 compat_hdc
, 0, 0, SRCCOPY
);
4064 BitBlt (hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
4065 compat_hdc
, 0, 0, 0xB8074A);
4067 BitBlt (hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
4068 compat_hdc
, 0, 0, 0xE20746);
4070 SelectObject (hdc
, orig_brush
);
4071 DeleteObject (fg_brush
);
4072 SelectObject (compat_hdc
, orig_obj
);
4073 DeleteDC (compat_hdc
);
4075 /* When the image has a mask, we can expect that at
4076 least part of a mouse highlight or a block cursor will
4077 be visible. If the image doesn't have a mask, make
4078 a block cursor visible by drawing a rectangle around
4079 the image. I believe it's looking better if we do
4080 nothing here for mouse-face. */
4081 if (s
->hl
== DRAW_CURSOR
)
4082 w32_draw_rectangle (hdc
, s
->gc
, x
, y
, s
->img
->width
- 1,
4083 s
->img
->height
- 1);
4087 w32_draw_rectangle (hdc
, s
->gc
, x
, y
, s
->img
->width
- 1,
4088 s
->img
->height
- 1);
4090 SelectObject (hdc
, orig_hdc_obj
);
4095 /* Draw part of the background of glyph string S. X, Y, W, and H
4096 give the rectangle to draw. */
4099 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
4100 struct glyph_string
*s
;
4103 #if 0 /* TODO: stipple */
4106 /* Fill background with a stipple pattern. */
4107 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4108 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
4109 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4113 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
4117 /* Draw image glyph string S.
4120 s->x +-------------------------
4123 | +-------------------------
4126 | | +-------------------
4132 x_draw_image_glyph_string (s
)
4133 struct glyph_string
*s
;
4136 int box_line_hwidth
= abs (s
->face
->box_line_width
);
4137 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
4141 height
= s
->height
- 2 * box_line_vwidth
;
4143 /* Fill background with face under the image. Do it only if row is
4144 taller than image or if image has a clip mask to reduce
4146 s
->stippled_p
= s
->face
->stipple
!= 0;
4147 if (height
> s
->img
->height
4150 #if 0 /* TODO: image mask */
4153 || s
->img
->pixmap
== 0
4154 || s
->width
!= s
->background_width
)
4156 if (box_line_hwidth
&& s
->first_glyph
->left_box_line_p
)
4157 x
= s
->x
+ box_line_hwidth
;
4161 y
= s
->y
+ box_line_vwidth
;
4162 #if 0 /* TODO: image mask */
4165 /* Create a pixmap as large as the glyph string. Fill it
4166 with the background color. Copy the image to it, using
4167 its mask. Copy the temporary pixmap to the display. */
4168 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
4169 int depth
= DefaultDepthOfScreen (screen
);
4171 /* Create a pixmap as large as the glyph string. */
4172 pixmap
= XCreatePixmap (s
->display
, s
->window
,
4173 s
->background_width
,
4176 /* Don't clip in the following because we're working on the
4178 XSetClipMask (s
->display
, s
->gc
, None
);
4180 /* Fill the pixmap with the background color/stipple. */
4183 /* Fill background with a stipple pattern. */
4184 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4185 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4186 0, 0, s
->background_width
, s
->height
);
4187 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4192 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
4194 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
4195 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4196 0, 0, s
->background_width
, s
->height
);
4197 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4202 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
4204 s
->background_filled_p
= 1;
4207 /* Draw the foreground. */
4210 w32_draw_image_foreground_1 (s
, pixmap
);
4211 x_set_glyph_string_clipping (s
);
4213 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
4214 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
4215 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
4216 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
4218 SetTextColor (s
->hdc
, s
->gc
->foreground
);
4219 SetBkColor (s
->hdc
, s
->gc
->background
);
4220 #if 0 /* From w32bdf.c (which is from Meadow). */
4221 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
4222 compat_hdc
, 0, 0, SRCCOPY
);
4223 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
4224 compat_hdc
, 0, 0, 0xB8074A);
4226 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
4227 compat_hdc
, 0, 0, 0xE20746);
4229 SelectObject (s
->hdc
, orig_brush
);
4230 DeleteObject (fg_brush
);
4231 SelectObject (compat_hdc
, orig_obj
);
4232 DeleteDC (compat_hdc
);
4234 DeleteObject (pixmap
);
4238 x_draw_image_foreground (s
);
4240 /* If we must draw a relief around the image, do it. */
4242 || s
->hl
== DRAW_IMAGE_RAISED
4243 || s
->hl
== DRAW_IMAGE_SUNKEN
)
4244 x_draw_image_relief (s
);
4248 /* Draw stretch glyph string S. */
4251 x_draw_stretch_glyph_string (s
)
4252 struct glyph_string
*s
;
4254 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4255 s
->stippled_p
= s
->face
->stipple
!= 0;
4257 if (s
->hl
== DRAW_CURSOR
4258 && !x_stretch_cursor_p
)
4260 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4261 as wide as the stretch glyph. */
4262 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
4265 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
4267 /* Clear rest using the GC of the original non-cursor face. */
4268 if (width
< s
->background_width
)
4270 XGCValues
*gc
= s
->face
->gc
;
4271 int x
= s
->x
+ width
, y
= s
->y
;
4272 int w
= s
->background_width
- width
, h
= s
->height
;
4276 if (s
->row
->mouse_face_p
4277 && cursor_in_mouse_face_p (s
->w
))
4279 x_set_mouse_face_gc (s
);
4285 w32_get_glyph_string_clip_rect (s
, &r
);
4286 w32_set_clip_rectangle (hdc
, &r
);
4288 #if 0 /* TODO: stipple */
4289 if (s
->face
->stipple
)
4291 /* Fill background with a stipple pattern. */
4292 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
4293 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4294 XSetFillStyle (s
->display
, gc
, FillSolid
);
4299 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
4303 else if (!s
->background_filled_p
)
4304 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
4307 s
->background_filled_p
= 1;
4311 /* Draw glyph string S. */
4314 x_draw_glyph_string (s
)
4315 struct glyph_string
*s
;
4317 int relief_drawn_p
= 0;
4319 /* If S draws into the background of its successor, draw the
4320 background of the successor first so that S can draw into it.
4321 This makes S->next use XDrawString instead of XDrawImageString. */
4322 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
4324 xassert (s
->next
->img
== NULL
);
4325 x_set_glyph_string_gc (s
->next
);
4326 x_set_glyph_string_clipping (s
->next
);
4327 x_draw_glyph_string_background (s
->next
, 1);
4330 /* Set up S->gc, set clipping and draw S. */
4331 x_set_glyph_string_gc (s
);
4333 /* Draw relief (if any) in advance for char/composition so that the
4334 glyph string can be drawn over it. */
4335 if (!s
->for_overlaps_p
4336 && s
->face
->box
!= FACE_NO_BOX
4337 && (s
->first_glyph
->type
== CHAR_GLYPH
4338 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
4341 x_set_glyph_string_clipping (s
);
4342 x_draw_glyph_string_background (s
, 1);
4343 x_draw_glyph_string_box (s
);
4344 x_set_glyph_string_clipping (s
);
4348 x_set_glyph_string_clipping (s
);
4350 switch (s
->first_glyph
->type
)
4353 x_draw_image_glyph_string (s
);
4357 x_draw_stretch_glyph_string (s
);
4361 if (s
->for_overlaps_p
)
4362 s
->background_filled_p
= 1;
4364 x_draw_glyph_string_background (s
, 0);
4365 x_draw_glyph_string_foreground (s
);
4368 case COMPOSITE_GLYPH
:
4369 if (s
->for_overlaps_p
|| s
->gidx
> 0)
4370 s
->background_filled_p
= 1;
4372 x_draw_glyph_string_background (s
, 1);
4373 x_draw_composite_glyph_string_foreground (s
);
4380 if (!s
->for_overlaps_p
)
4382 /* Draw underline. */
4383 if (s
->face
->underline_p
4384 && (s
->font
->bdf
|| !s
->font
->tm
.tmUnderlined
))
4386 unsigned long h
= 1;
4387 unsigned long dy
= s
->height
- h
;
4389 /* TODO: Use font information for positioning and thickness
4390 of underline. See OUTLINETEXTMETRIC, and xterm.c. */
4391 if (s
->face
->underline_defaulted_p
)
4393 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
4394 s
->y
+ dy
, s
->width
, 1);
4398 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
4399 s
->y
+ dy
, s
->width
, 1);
4403 /* Draw overline. */
4404 if (s
->face
->overline_p
)
4406 unsigned long dy
= 0, h
= 1;
4408 if (s
->face
->overline_color_defaulted_p
)
4410 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
4411 s
->y
+ dy
, s
->width
, h
);
4415 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
4416 s
->y
+ dy
, s
->width
, h
);
4420 /* Draw strike-through. */
4421 if (s
->face
->strike_through_p
4422 && (s
->font
->bdf
|| !s
->font
->tm
.tmStruckOut
))
4424 unsigned long h
= 1;
4425 unsigned long dy
= (s
->height
- h
) / 2;
4427 if (s
->face
->strike_through_color_defaulted_p
)
4429 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
4434 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
4435 s
->y
+ dy
, s
->width
, h
);
4440 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
4441 x_draw_glyph_string_box (s
);
4444 /* Reset clipping. */
4445 w32_set_clip_rectangle (s
->hdc
, NULL
);
4449 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4450 struct face
**, int));
4453 /* Fill glyph string S with composition components specified by S->cmp.
4455 FACES is an array of faces for all components of this composition.
4456 S->gidx is the index of the first component for S.
4457 OVERLAPS_P non-zero means S should draw the foreground only, and
4458 use its physical height for clipping.
4460 Value is the index of a component not in S. */
4463 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4464 struct glyph_string
*s
;
4465 struct face
**faces
;
4472 s
->for_overlaps_p
= overlaps_p
;
4474 s
->face
= faces
[s
->gidx
];
4475 s
->font
= s
->face
->font
;
4476 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4478 /* For all glyphs of this composition, starting at the offset
4479 S->gidx, until we reach the end of the definition or encounter a
4480 glyph that requires the different face, add it to S. */
4482 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4485 /* All glyph strings for the same composition has the same width,
4486 i.e. the width set for the first component of the composition. */
4488 s
->width
= s
->first_glyph
->pixel_width
;
4490 /* If the specified font could not be loaded, use the frame's
4491 default font, but record the fact that we couldn't load it in
4492 the glyph string so that we can draw rectangles for the
4493 characters of the glyph string. */
4494 if (s
->font
== NULL
)
4496 s
->font_not_found_p
= 1;
4497 s
->font
= FRAME_FONT (s
->f
);
4500 /* Adjust base line for subscript/superscript text. */
4501 s
->ybase
+= s
->first_glyph
->voffset
;
4503 xassert (s
->face
&& s
->face
->gc
);
4505 /* This glyph string must always be drawn with 16-bit functions. */
4508 return s
->gidx
+ s
->nchars
;
4512 /* Fill glyph string S from a sequence of character glyphs.
4514 FACE_ID is the face id of the string. START is the index of the
4515 first glyph to consider, END is the index of the last + 1.
4516 OVERLAPS_P non-zero means S should draw the foreground only, and
4517 use its physical height for clipping.
4519 Value is the index of the first glyph not in S. */
4522 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4523 struct glyph_string
*s
;
4525 int start
, end
, overlaps_p
;
4527 struct glyph
*glyph
, *last
;
4529 int glyph_not_available_p
;
4531 xassert (s
->f
== XFRAME (s
->w
->frame
));
4532 xassert (s
->nchars
== 0);
4533 xassert (start
>= 0 && end
> start
);
4535 s
->for_overlaps_p
= overlaps_p
;
4536 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4537 last
= s
->row
->glyphs
[s
->area
] + end
;
4538 voffset
= glyph
->voffset
;
4540 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4543 && glyph
->type
== CHAR_GLYPH
4544 && glyph
->voffset
== voffset
4545 /* Same face id implies same font, nowadays. */
4546 && glyph
->face_id
== face_id
4547 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4551 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4552 s
->char2b
+ s
->nchars
,
4554 s
->two_byte_p
= two_byte_p
;
4556 xassert (s
->nchars
<= end
- start
);
4557 s
->width
+= glyph
->pixel_width
;
4561 s
->font
= s
->face
->font
;
4562 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4564 /* If the specified font could not be loaded, use the frame's font,
4565 but record the fact that we couldn't load it in
4566 S->font_not_found_p so that we can draw rectangles for the
4567 characters of the glyph string. */
4568 if (s
->font
== NULL
|| glyph_not_available_p
)
4570 s
->font_not_found_p
= 1;
4571 s
->font
= FRAME_FONT (s
->f
);
4574 /* Adjust base line for subscript/superscript text. */
4575 s
->ybase
+= voffset
;
4577 xassert (s
->face
&& s
->face
->gc
);
4578 return glyph
- s
->row
->glyphs
[s
->area
];
4582 /* Fill glyph string S from image glyph S->first_glyph. */
4585 x_fill_image_glyph_string (s
)
4586 struct glyph_string
*s
;
4588 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4589 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4591 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4592 s
->font
= s
->face
->font
;
4593 s
->width
= s
->first_glyph
->pixel_width
;
4595 /* Adjust base line for subscript/superscript text. */
4596 s
->ybase
+= s
->first_glyph
->voffset
;
4600 /* Fill glyph string S from a sequence of stretch glyphs.
4602 ROW is the glyph row in which the glyphs are found, AREA is the
4603 area within the row. START is the index of the first glyph to
4604 consider, END is the index of the last + 1.
4606 Value is the index of the first glyph not in S. */
4609 x_fill_stretch_glyph_string (s
, row
, area
, start
, end
)
4610 struct glyph_string
*s
;
4611 struct glyph_row
*row
;
4612 enum glyph_row_area area
;
4615 struct glyph
*glyph
, *last
;
4616 int voffset
, face_id
;
4618 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4620 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4621 last
= s
->row
->glyphs
[s
->area
] + end
;
4622 face_id
= glyph
->face_id
;
4623 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
4624 s
->font
= s
->face
->font
;
4625 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4626 s
->width
= glyph
->pixel_width
;
4627 voffset
= glyph
->voffset
;
4631 && glyph
->type
== STRETCH_GLYPH
4632 && glyph
->voffset
== voffset
4633 && glyph
->face_id
== face_id
);
4635 s
->width
+= glyph
->pixel_width
;
4637 /* Adjust base line for subscript/superscript text. */
4638 s
->ybase
+= voffset
;
4641 return glyph
- s
->row
->glyphs
[s
->area
];
4645 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4646 of XChar2b structures for S; it can't be allocated in
4647 x_init_glyph_string because it must be allocated via `alloca'. W
4648 is the window on which S is drawn. ROW and AREA are the glyph row
4649 and area within the row from which S is constructed. START is the
4650 index of the first glyph structure covered by S. HL is a
4651 face-override for drawing S. */
4654 w32_init_glyph_string (s
, hdc
, char2b
, w
, row
, area
, start
, hl
)
4655 struct glyph_string
*s
;
4659 struct glyph_row
*row
;
4660 enum glyph_row_area area
;
4662 enum draw_glyphs_face hl
;
4664 bzero (s
, sizeof *s
);
4666 s
->f
= XFRAME (w
->frame
);
4668 s
->window
= FRAME_W32_WINDOW (s
->f
);
4673 s
->first_glyph
= row
->glyphs
[area
] + start
;
4674 s
->height
= row
->height
;
4675 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4677 /* Display the internal border below the tool-bar window. */
4678 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4679 s
->y
-= s
->f
->output_data
.w32
->internal_border_width
;
4681 s
->ybase
= s
->y
+ row
->ascent
;
4685 /* Set background width of glyph string S. START is the index of the
4686 first glyph following S. LAST_X is the right-most x-position + 1
4687 in the drawing area. */
4690 x_set_glyph_string_background_width (s
, start
, last_x
)
4691 struct glyph_string
*s
;
4695 /* If the face of this glyph string has to be drawn to the end of
4696 the drawing area, set S->extends_to_end_of_line_p. */
4697 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4699 if (start
== s
->row
->used
[s
->area
]
4700 && s
->area
== TEXT_AREA
4701 && ((s
->hl
== DRAW_NORMAL_TEXT
4702 && (s
->row
->fill_line_p
4703 || s
->face
->background
!= default_face
->background
4704 || s
->face
->stipple
!= default_face
->stipple
4705 || s
->row
->mouse_face_p
))
4706 || s
->hl
== DRAW_MOUSE_FACE
4707 || ((s
->hl
== DRAW_IMAGE_RAISED
|| s
->hl
== DRAW_IMAGE_SUNKEN
)
4708 && s
->row
->fill_line_p
)))
4709 s
->extends_to_end_of_line_p
= 1;
4711 /* If S extends its face to the end of the line, set its
4712 background_width to the distance to the right edge of the drawing
4714 if (s
->extends_to_end_of_line_p
)
4715 s
->background_width
= last_x
- s
->x
+ 1;
4717 s
->background_width
= s
->width
;
4721 /* Add a glyph string for a stretch glyph to the list of strings
4722 between HEAD and TAIL. START is the index of the stretch glyph in
4723 row area AREA of glyph row ROW. END is the index of the last glyph
4724 in that glyph row area. X is the current output position assigned
4725 to the new glyph string constructed. HL overrides that face of the
4726 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4727 is the right-most x-position of the drawing area. */
4729 #define BUILD_STRETCH_GLYPH_STRING(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4732 s = (struct glyph_string *) alloca (sizeof *s); \
4733 w32_init_glyph_string (s, hdc, NULL, W, ROW, AREA, START, HL); \
4734 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4735 x_append_glyph_string (&HEAD, &TAIL, s); \
4741 /* Add a glyph string for an image glyph to the list of strings
4742 between HEAD and TAIL. START is the index of the image glyph in
4743 row area AREA of glyph row ROW. END is the index of the last glyph
4744 in that glyph row area. X is the current output position assigned
4745 to the new glyph string constructed. HL overrides that face of the
4746 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4747 is the right-most x-position of the drawing area. */
4749 #define BUILD_IMAGE_GLYPH_STRING(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4752 s = (struct glyph_string *) alloca (sizeof *s); \
4753 w32_init_glyph_string (s, hdc, NULL, W, ROW, AREA, START, HL); \
4754 x_fill_image_glyph_string (s); \
4755 x_append_glyph_string (&HEAD, &TAIL, s); \
4762 /* Add a glyph string for a sequence of character glyphs to the list
4763 of strings between HEAD and TAIL. START is the index of the first
4764 glyph in row area AREA of glyph row ROW that is part of the new
4765 glyph string. END is the index of the last glyph in that glyph row
4766 area. X is the current output position assigned to the new glyph
4767 string constructed. HL overrides that face of the glyph; e.g. it
4768 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4769 right-most x-position of the drawing area. */
4771 #define BUILD_CHAR_GLYPH_STRINGS(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4777 c = (ROW)->glyphs[AREA][START].u.ch; \
4778 face_id = (ROW)->glyphs[AREA][START].face_id; \
4780 s = (struct glyph_string *) alloca (sizeof *s); \
4781 char2b = (wchar_t *) alloca ((END - START) * sizeof *char2b); \
4782 w32_init_glyph_string (s, hdc, char2b, W, ROW, AREA, START, HL); \
4783 x_append_glyph_string (&HEAD, &TAIL, s); \
4785 START = x_fill_glyph_string (s, face_id, START, END, \
4791 /* Add a glyph string for a composite sequence to the list of strings
4792 between HEAD and TAIL. START is the index of the first glyph in
4793 row area AREA of glyph row ROW that is part of the new glyph
4794 string. END is the index of the last glyph in that glyph row area.
4795 X is the current output position assigned to the new glyph string
4796 constructed. HL overrides that face of the glyph; e.g. it is
4797 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4798 x-position of the drawing area. */
4800 #define BUILD_COMPOSITE_GLYPH_STRING(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4802 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4803 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4804 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4805 struct composition *cmp = composition_table[cmp_id]; \
4806 int glyph_len = cmp->glyph_len; \
4808 struct face **faces; \
4809 struct glyph_string *first_s = NULL; \
4812 base_face = base_face->ascii_face; \
4813 char2b = (wchar_t *) alloca ((sizeof *char2b) * glyph_len); \
4814 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4815 /* At first, fill in `char2b' and `faces'. */ \
4816 for (n = 0; n < glyph_len; n++) \
4818 int c = COMPOSITION_GLYPH (cmp, n); \
4819 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4820 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4821 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4822 this_face_id, char2b + n, 1); \
4825 /* Make glyph_strings for each glyph sequence that is drawable by \
4826 the same face, and append them to HEAD/TAIL. */ \
4827 for (n = 0; n < cmp->glyph_len;) \
4829 s = (struct glyph_string *) alloca (sizeof *s); \
4830 w32_init_glyph_string (s, hdc, char2b + n, W, ROW, AREA, START, HL); \
4831 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4839 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4847 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4848 of AREA of glyph row ROW on window W between indices START and END.
4849 HL overrides the face for drawing glyph strings, e.g. it is
4850 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
4851 x-positions of the drawing area.
4853 This is an ugly monster macro construct because we must use alloca
4854 to allocate glyph strings (because x_draw_glyphs can be called
4857 #define BUILD_GLYPH_STRINGS(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4860 HEAD = TAIL = NULL; \
4861 while (START < END) \
4863 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
4864 switch (first_glyph->type) \
4867 BUILD_CHAR_GLYPH_STRINGS (hdc, W, ROW, AREA, START, END, \
4868 HEAD, TAIL, HL, X, LAST_X, \
4872 case COMPOSITE_GLYPH: \
4873 BUILD_COMPOSITE_GLYPH_STRING (hdc, W, ROW, AREA, START, \
4874 END, HEAD, TAIL, HL, X, \
4875 LAST_X, OVERLAPS_P); \
4878 case STRETCH_GLYPH: \
4879 BUILD_STRETCH_GLYPH_STRING (hdc, W, ROW, AREA, START, END,\
4880 HEAD, TAIL, HL, X, LAST_X); \
4884 BUILD_IMAGE_GLYPH_STRING (hdc, W, ROW, AREA, START, END, \
4885 HEAD, TAIL, HL, X, LAST_X); \
4892 x_set_glyph_string_background_width (s, START, LAST_X); \
4899 /* Draw glyphs between START and END in AREA of ROW on window W,
4900 starting at x-position X. X is relative to AREA in W. HL is a
4901 face-override with the following meaning:
4903 DRAW_NORMAL_TEXT draw normally
4904 DRAW_CURSOR draw in cursor face
4905 DRAW_MOUSE_FACE draw in mouse face.
4906 DRAW_INVERSE_VIDEO draw in mode line face
4907 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
4908 DRAW_IMAGE_RAISED draw an image with a raised relief around it
4910 If OVERLAPS_P is non-zero, draw only the foreground of characters
4911 and clip to the physical height of ROW.
4913 Value is the x-position reached, relative to AREA of W. */
4916 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, overlaps_p
)
4919 struct glyph_row
*row
;
4920 enum glyph_row_area area
;
4922 enum draw_glyphs_face hl
;
4925 struct glyph_string
*head
, *tail
;
4926 struct glyph_string
*s
;
4927 int last_x
, area_width
;
4930 HDC hdc
= get_frame_dc (XFRAME (WINDOW_FRAME (w
)));
4932 /* Let's rather be paranoid than getting a SEGV. */
4933 end
= min (end
, row
->used
[area
]);
4934 start
= max (0, start
);
4935 start
= min (end
, start
);
4937 /* Translate X to frame coordinates. Set last_x to the right
4938 end of the drawing area. */
4939 if (row
->full_width_p
)
4941 /* X is relative to the left edge of W, without scroll bars
4943 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4944 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
4947 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
4948 last_x
= window_left_x
+ area_width
;
4950 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4952 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
4953 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
4959 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
4960 last_x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
4964 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
4965 area_width
= window_box_width (w
, area
);
4966 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
4969 /* Build a doubly-linked list of glyph_string structures between
4970 head and tail from what we have to draw. Note that the macro
4971 BUILD_GLYPH_STRINGS will modify its start parameter. That's
4972 the reason we use a separate variable `i'. */
4974 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
4977 x_reached
= tail
->x
+ tail
->background_width
;
4981 /* If there are any glyphs with lbearing < 0 or rbearing > width in
4982 the row, redraw some glyphs in front or following the glyph
4983 strings built above. */
4984 if (head
&& !overlaps_p
&& row
->contains_overlapping_glyphs_p
)
4987 struct glyph_string
*h
, *t
;
4989 /* Compute overhangs for all glyph strings. */
4990 for (s
= head
; s
; s
= s
->next
)
4991 x_compute_glyph_string_overhangs (s
);
4993 /* Prepend glyph strings for glyphs in front of the first glyph
4994 string that are overwritten because of the first glyph
4995 string's left overhang. The background of all strings
4996 prepended must be drawn because the first glyph string
4998 i
= x_left_overwritten (head
);
5002 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, j
, start
, h
, t
,
5003 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5006 x_compute_overhangs_and_x (t
, head
->x
, 1);
5007 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5010 /* Prepend glyph strings for glyphs in front of the first glyph
5011 string that overwrite that glyph string because of their
5012 right overhang. For these strings, only the foreground must
5013 be drawn, because it draws over the glyph string at `head'.
5014 The background must not be drawn because this would overwrite
5015 right overhangs of preceding glyphs for which no glyph
5017 i
= x_left_overwriting (head
);
5020 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, i
, start
, h
, t
,
5021 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5023 for (s
= h
; s
; s
= s
->next
)
5024 s
->background_filled_p
= 1;
5025 x_compute_overhangs_and_x (t
, head
->x
, 1);
5026 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5029 /* Append glyphs strings for glyphs following the last glyph
5030 string tail that are overwritten by tail. The background of
5031 these strings has to be drawn because tail's foreground draws
5033 i
= x_right_overwritten (tail
);
5036 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, end
, i
, h
, t
,
5037 DRAW_NORMAL_TEXT
, x
, last_x
,
5039 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5040 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5043 /* Append glyph strings for glyphs following the last glyph
5044 string tail that overwrite tail. The foreground of such
5045 glyphs has to be drawn because it writes into the background
5046 of tail. The background must not be drawn because it could
5047 paint over the foreground of following glyphs. */
5048 i
= x_right_overwriting (tail
);
5051 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, end
, i
, h
, t
,
5052 DRAW_NORMAL_TEXT
, x
, last_x
,
5054 for (s
= h
; s
; s
= s
->next
)
5055 s
->background_filled_p
= 1;
5056 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5057 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5061 /* Draw all strings. */
5062 for (s
= head
; s
; s
= s
->next
)
5063 x_draw_glyph_string (s
);
5065 if (area
== TEXT_AREA
5066 && !row
->full_width_p
5067 /* When drawing overlapping rows, only the glyph strings'
5068 foreground is drawn, which doesn't erase a cursor
5072 int x0
= head
? head
->x
: x
;
5073 int x1
= tail
? tail
->x
+ tail
->background_width
: x
;
5075 x0
= FRAME_TO_WINDOW_PIXEL_X (w
, x0
);
5076 x1
= FRAME_TO_WINDOW_PIXEL_X (w
, x1
);
5078 if (!row
->full_width_p
&& XFASTINT (w
->left_margin_width
) != 0)
5080 int left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
5081 x0
-= left_area_width
;
5082 x1
-= left_area_width
;
5085 notice_overwritten_cursor (w
, area
, x0
, x1
,
5086 row
->y
, MATRIX_ROW_BOTTOM_Y (row
));
5089 /* Value is the x-position up to which drawn, relative to AREA of W.
5090 This doesn't include parts drawn because of overhangs. */
5091 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
5092 if (!row
->full_width_p
)
5094 if (area
> LEFT_MARGIN_AREA
)
5095 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
5096 if (area
> TEXT_AREA
)
5097 x_reached
-= window_box_width (w
, TEXT_AREA
);
5100 release_frame_dc (XFRAME (WINDOW_FRAME (w
)), hdc
);
5106 /* Fix the display of area AREA of overlapping row ROW in window W. */
5109 x_fix_overlapping_area (w
, row
, area
)
5111 struct glyph_row
*row
;
5112 enum glyph_row_area area
;
5118 if (area
== LEFT_MARGIN_AREA
)
5120 else if (area
== TEXT_AREA
)
5121 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5123 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5124 + window_box_width (w
, TEXT_AREA
));
5126 for (i
= 0; i
< row
->used
[area
];)
5128 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
5130 int start
= i
, start_x
= x
;
5134 x
+= row
->glyphs
[area
][i
].pixel_width
;
5137 while (i
< row
->used
[area
]
5138 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
5140 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
5141 DRAW_NORMAL_TEXT
, 1);
5145 x
+= row
->glyphs
[area
][i
].pixel_width
;
5154 /* Output LEN glyphs starting at START at the nominal cursor position.
5155 Advance the nominal cursor over the text. The global variable
5156 updated_window contains the window being updated, updated_row is
5157 the glyph row being updated, and updated_area is the area of that
5158 row being updated. */
5161 x_write_glyphs (start
, len
)
5162 struct glyph
*start
;
5167 xassert (updated_window
&& updated_row
);
5172 hpos
= start
- updated_row
->glyphs
[updated_area
];
5173 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
5174 updated_row
, updated_area
,
5176 DRAW_NORMAL_TEXT
, 0);
5180 /* Advance the output cursor. */
5181 output_cursor
.hpos
+= len
;
5182 output_cursor
.x
= x
;
5186 /* Insert LEN glyphs from START at the nominal cursor position. */
5189 x_insert_glyphs (start
, len
)
5190 struct glyph
*start
;
5195 int line_height
, shift_by_width
, shifted_region_width
;
5196 struct glyph_row
*row
;
5197 struct glyph
*glyph
;
5198 int frame_x
, frame_y
, hpos
;
5201 xassert (updated_window
&& updated_row
);
5204 f
= XFRAME (WINDOW_FRAME (w
));
5205 hdc
= get_frame_dc (f
);
5207 /* Get the height of the line we are in. */
5209 line_height
= row
->height
;
5211 /* Get the width of the glyphs to insert. */
5213 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
5214 shift_by_width
+= glyph
->pixel_width
;
5216 /* Get the width of the region to shift right. */
5217 shifted_region_width
= (window_box_width (w
, updated_area
)
5222 frame_x
= window_box_left (w
, updated_area
) + output_cursor
.x
;
5223 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
5224 BitBlt (hdc
, frame_x
+ shift_by_width
, frame_y
,
5225 shifted_region_width
, line_height
,
5226 hdc
, frame_x
, frame_y
, SRCCOPY
);
5228 /* Write the glyphs. */
5229 hpos
= start
- row
->glyphs
[updated_area
];
5230 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
5231 DRAW_NORMAL_TEXT
, 0);
5233 /* Advance the output cursor. */
5234 output_cursor
.hpos
+= len
;
5235 output_cursor
.x
+= shift_by_width
;
5236 release_frame_dc (f
, hdc
);
5242 /* Delete N glyphs at the nominal cursor position. Not implemented
5254 f
= SELECTED_FRAME ();
5256 if (! FRAME_W32_P (f
))
5263 /* Erase the current text line from the nominal cursor position
5264 (inclusive) to pixel column TO_X (exclusive). The idea is that
5265 everything from TO_X onward is already erased.
5267 TO_X is a pixel position relative to updated_area of
5268 updated_window. TO_X == -1 means clear to the end of this area. */
5271 x_clear_end_of_line (to_x
)
5275 struct window
*w
= updated_window
;
5276 int max_x
, min_y
, max_y
;
5277 int from_x
, from_y
, to_y
;
5279 xassert (updated_window
&& updated_row
);
5280 f
= XFRAME (w
->frame
);
5282 if (updated_row
->full_width_p
)
5284 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5285 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5286 && !w
->pseudo_window_p
)
5287 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5290 max_x
= window_box_width (w
, updated_area
);
5291 max_y
= window_text_bottom_y (w
);
5293 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5294 of window. For TO_X > 0, truncate to end of drawing area. */
5300 to_x
= min (to_x
, max_x
);
5302 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
5304 /* Notice if the cursor will be cleared by this operation. */
5305 if (!updated_row
->full_width_p
)
5306 notice_overwritten_cursor (w
, updated_area
,
5307 output_cursor
.x
, -1,
5309 MATRIX_ROW_BOTTOM_Y (updated_row
));
5311 from_x
= output_cursor
.x
;
5313 /* Translate to frame coordinates. */
5314 if (updated_row
->full_width_p
)
5316 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
5317 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
5321 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
5322 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
5325 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
5326 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
5327 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
5329 /* Prevent inadvertently clearing to end of the X window. */
5330 if (to_x
> from_x
&& to_y
> from_y
)
5334 hdc
= get_frame_dc (f
);
5336 w32_clear_area (f
, hdc
, from_x
, from_y
, to_x
- from_x
, to_y
- from_y
);
5337 release_frame_dc (f
, hdc
);
5343 /* Clear entire frame. If updating_frame is non-null, clear that
5344 frame. Otherwise clear the selected frame. */
5354 f
= SELECTED_FRAME ();
5356 if (! FRAME_W32_P (f
))
5359 /* Clearing the frame will erase any cursor, so mark them all as no
5361 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5362 output_cursor
.hpos
= output_cursor
.vpos
= 0;
5363 output_cursor
.x
= -1;
5365 /* We don't set the output cursor here because there will always
5366 follow an explicit cursor_to. */
5369 w32_clear_window (f
);
5371 /* We have to clear the scroll bars, too. If we have changed
5372 colors or something like that, then they should be notified. */
5373 x_scroll_bar_clear (f
);
5379 /* Make audible bell. */
5382 w32_ring_bell (void)
5386 f
= SELECTED_FRAME ();
5390 if (FRAME_W32_P (f
) && visible_bell
)
5393 HWND hwnd
= FRAME_W32_WINDOW (SELECTED_FRAME ());
5395 for (i
= 0; i
< 5; i
++)
5397 FlashWindow (hwnd
, TRUE
);
5400 FlashWindow (hwnd
, FALSE
);
5403 w32_sys_ring_bell ();
5409 /* Specify how many text lines, from the top of the window,
5410 should be affected by insert-lines and delete-lines operations.
5411 This, and those operations, are used only within an update
5412 that is bounded by calls to x_update_begin and x_update_end. */
5415 w32_set_terminal_window (n
)
5418 /* This function intentionally left blank. */
5423 /***********************************************************************
5425 ***********************************************************************/
5427 /* Perform an insert-lines or delete-lines operation, inserting N
5428 lines or deleting -N lines at vertical position VPOS. */
5431 x_ins_del_lines (vpos
, n
)
5439 f
= SELECTED_FRAME ();
5441 if (! FRAME_W32_P (f
))
5448 /* Scroll part of the display as described by RUN. */
5451 x_scroll_run (w
, run
)
5455 struct frame
*f
= XFRAME (w
->frame
);
5456 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5457 HWND hwnd
= FRAME_W32_WINDOW (f
);
5460 /* Get frame-relative bounding box of the text display area of W,
5461 without mode lines. Include in this box the left and right
5463 window_box (w
, -1, &x
, &y
, &width
, &height
);
5464 width
+= FRAME_X_FRINGE_WIDTH (f
);
5465 x
-= FRAME_X_LEFT_FRINGE_WIDTH (f
);
5467 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5468 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5469 bottom_y
= y
+ height
;
5473 /* Scrolling up. Make sure we don't copy part of the mode
5474 line at the bottom. */
5475 if (from_y
+ run
->height
> bottom_y
)
5476 height
= bottom_y
- from_y
;
5478 height
= run
->height
;
5479 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
5483 /* Scolling down. Make sure we don't copy over the mode line.
5485 if (to_y
+ run
->height
> bottom_y
)
5486 height
= bottom_y
- to_y
;
5488 height
= run
->height
;
5489 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
5494 /* Cursor off. Will be switched on again in x_update_window_end. */
5501 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
5502 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
5504 from
.left
= to
.left
= x
;
5505 from
.right
= to
.right
= x
+ width
;
5507 from
.bottom
= from_y
+ height
;
5509 to
.bottom
= bottom_y
;
5511 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
5512 NULL
, SW_INVALIDATE
);
5514 /* Combine this with what we expect to be dirty. This covers the
5515 case where not all of the region we expect is actually dirty. */
5516 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
5518 /* If the dirty region is not what we expected, redraw the entire frame. */
5519 if (!EqualRgn (combined
, expect_dirty
))
5520 SET_FRAME_GARBAGED (f
);
5528 /***********************************************************************
5530 ***********************************************************************/
5532 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5533 corner of the exposed rectangle. W and H are width and height of
5534 the exposed area. All are pixel values. W or H zero means redraw
5535 the entire frame. */
5538 expose_frame (f
, x
, y
, w
, h
)
5543 int mouse_face_overwritten_p
= 0;
5545 TRACE ((stderr
, "expose_frame "));
5547 /* No need to redraw if frame will be redrawn soon. */
5548 if (FRAME_GARBAGED_P (f
))
5550 TRACE ((stderr
, " garbaged\n"));
5554 /* If basic faces haven't been realized yet, there is no point in
5555 trying to redraw anything. This can happen when we get an expose
5556 event while Emacs is starting, e.g. by moving another window. */
5557 if (FRAME_FACE_CACHE (f
) == NULL
5558 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5560 TRACE ((stderr
, " no faces\n"));
5564 if (w
== 0 || h
== 0)
5567 r
.right
= CANON_X_UNIT (f
) * f
->width
;
5568 r
.bottom
= CANON_Y_UNIT (f
) * f
->height
;
5578 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.left
, r
.top
, r
.right
, r
.bottom
));
5579 mouse_face_overwritten_p
= expose_window_tree (XWINDOW (f
->root_window
), &r
);
5581 if (WINDOWP (f
->tool_bar_window
))
5582 mouse_face_overwritten_p
5583 |= expose_window (XWINDOW (f
->tool_bar_window
), &r
);
5585 /* Some window managers support a focus-follows-mouse style with
5586 delayed raising of frames. Imagine a partially obscured frame,
5587 and moving the mouse into partially obscured mouse-face on that
5588 frame. The visible part of the mouse-face will be highlighted,
5589 then the WM raises the obscured frame. With at least one WM, KDE
5590 2.1, Emacs is not getting any event for the raising of the frame
5591 (even tried with SubstructureRedirectMask), only Expose events.
5592 These expose events will draw text normally, i.e. not
5593 highlighted. Which means we must redo the highlight here.
5594 Subsume it under ``we love X''. --gerd 2001-08-15 */
5595 /* Included in Windows version because Windows most likely does not
5596 do the right thing if any third party tool offers
5597 focus-follows-mouse with delayed raise. --jason 2001-10-12 */
5598 if (mouse_face_overwritten_p
&& !FRAME_GARBAGED_P (f
))
5600 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5601 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5603 int x
= dpyinfo
->mouse_face_mouse_x
;
5604 int y
= dpyinfo
->mouse_face_mouse_y
;
5605 clear_mouse_face (dpyinfo
);
5606 note_mouse_highlight (f
, x
, y
);
5612 /* Redraw (parts) of all windows in the window tree rooted at W that
5613 intersect R. R contains frame pixel coordinates. */
5616 expose_window_tree (w
, r
)
5620 struct frame
*f
= XFRAME (w
->frame
);
5621 int mouse_face_overwritten_p
= 0;
5623 while (w
&& !FRAME_GARBAGED_P (f
))
5625 if (!NILP (w
->hchild
))
5626 mouse_face_overwritten_p
5627 |= expose_window_tree (XWINDOW (w
->hchild
), r
);
5628 else if (!NILP (w
->vchild
))
5629 mouse_face_overwritten_p
5630 |= expose_window_tree (XWINDOW (w
->vchild
), r
);
5632 mouse_face_overwritten_p
|= expose_window (w
, r
);
5634 w
= NILP (w
->next
) ? NULL
: XWINDOW (w
->next
);
5637 return mouse_face_overwritten_p
;
5641 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5642 which intersects rectangle R. R is in window-relative coordinates. */
5645 expose_area (w
, row
, r
, area
)
5647 struct glyph_row
*row
;
5649 enum glyph_row_area area
;
5651 struct glyph
*first
= row
->glyphs
[area
];
5652 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5654 int first_x
, start_x
, x
;
5656 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5657 /* If row extends face to end of line write the whole line. */
5658 x_draw_glyphs (w
, 0, row
, area
,
5660 DRAW_NORMAL_TEXT
, 0);
5663 /* Set START_X to the window-relative start position for drawing glyphs of
5664 AREA. The first glyph of the text area can be partially visible.
5665 The first glyphs of other areas cannot. */
5666 if (area
== LEFT_MARGIN_AREA
)
5668 else if (area
== TEXT_AREA
)
5669 start_x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5671 start_x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5672 + window_box_width (w
, TEXT_AREA
));
5675 /* Find the first glyph that must be redrawn. */
5677 && x
+ first
->pixel_width
< r
->left
)
5679 x
+= first
->pixel_width
;
5683 /* Find the last one. */
5689 x
+= last
->pixel_width
;
5695 x_draw_glyphs (w
, first_x
- start_x
, row
, area
,
5696 first
- row
->glyphs
[area
],
5697 last
- row
->glyphs
[area
],
5698 DRAW_NORMAL_TEXT
, 0);
5703 /* Redraw the parts of the glyph row ROW on window W intersecting
5704 rectangle R. R is in window-relative coordinates. Value is
5705 non-zero if mouse face was overwritten. */
5708 expose_line (w
, row
, r
)
5710 struct glyph_row
*row
;
5713 xassert (row
->enabled_p
);
5715 if (row
->mode_line_p
|| w
->pseudo_window_p
)
5716 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
5717 DRAW_NORMAL_TEXT
, 0);
5720 if (row
->used
[LEFT_MARGIN_AREA
])
5721 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
5722 if (row
->used
[TEXT_AREA
])
5723 expose_area (w
, row
, r
, TEXT_AREA
);
5724 if (row
->used
[RIGHT_MARGIN_AREA
])
5725 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
5726 x_draw_row_fringe_bitmaps (w
, row
);
5729 return row
->mouse_face_p
;
5733 /* Return non-zero if W's cursor intersects rectangle R. */
5736 x_phys_cursor_in_rect_p (w
, r
)
5741 struct glyph
*cursor_glyph
;
5743 cursor_glyph
= get_phys_cursor_glyph (w
);
5746 cr
.left
= w
->phys_cursor
.x
;
5747 cr
.top
= w
->phys_cursor
.y
;
5748 cr
.right
= cr
.left
+ cursor_glyph
->pixel_width
;
5749 cr
.bottom
= cr
.top
+ w
->phys_cursor_height
;
5750 return IntersectRect (&result
, &cr
, r
);
5757 /* Redraw the part of window W intersection rectagle FR. Pixel
5758 coordinates in FR are frame relative. Call this function with
5759 input blocked. Value is non-zero if the exposure overwrites
5763 expose_window (w
, fr
)
5767 struct frame
*f
= XFRAME (w
->frame
);
5769 int mouse_face_overwritten_p
= 0;
5771 /* If window is not yet fully initialized, do nothing. This can
5772 happen when toolkit scroll bars are used and a window is split.
5773 Reconfiguring the scroll bar will generate an expose for a newly
5775 if (w
->current_matrix
== NULL
)
5778 /* When we're currently updating the window, display and current
5779 matrix usually don't agree. Arrange for a thorough display
5781 if (w
== updated_window
)
5783 SET_FRAME_GARBAGED (f
);
5787 /* Frame-relative pixel rectangle of W. */
5788 wr
.left
= XFASTINT (w
->left
) * CANON_X_UNIT (f
);
5789 wr
.top
= XFASTINT (w
->top
) * CANON_Y_UNIT (f
);
5790 wr
.right
= wr
.left
+ XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5791 wr
.bottom
= wr
.top
+ XFASTINT (w
->height
) * CANON_Y_UNIT (f
);
5793 if (IntersectRect(&r
, fr
, &wr
))
5795 int yb
= window_text_bottom_y (w
);
5796 struct glyph_row
*row
;
5797 int cursor_cleared_p
;
5799 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
5800 r
.left
, r
.top
, r
.right
, r
.bottom
));
5802 /* Convert to window coordinates. */
5803 r
.left
= FRAME_TO_WINDOW_PIXEL_X (w
, r
.left
);
5804 r
.right
= FRAME_TO_WINDOW_PIXEL_X (w
, r
.right
);
5805 r
.top
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
.top
);
5806 r
.bottom
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
.bottom
);
5808 /* Turn off the cursor. */
5809 if (!w
->pseudo_window_p
5810 && x_phys_cursor_in_rect_p (w
, &r
))
5813 cursor_cleared_p
= 1;
5816 cursor_cleared_p
= 0;
5818 /* Find the first row intersecting the rectangle R. */
5819 for (row
= w
->current_matrix
->rows
;
5824 int y1
= MATRIX_ROW_BOTTOM_Y (row
);
5826 if ((y0
>= r
.top
&& y0
< r
.bottom
)
5827 || (y1
> r
.top
&& y1
< r
.bottom
)
5828 || (r
.top
>= y0
&& r
.top
< y1
)
5829 || (r
.bottom
> y0
&& r
.bottom
< y1
))
5831 if (expose_line (w
, row
, &r
))
5832 mouse_face_overwritten_p
= 1;
5839 /* Display the mode line if there is one. */
5840 if (WINDOW_WANTS_MODELINE_P (w
)
5841 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
5843 && row
->y
< r
.bottom
)
5845 if (expose_line (w
, row
, &r
))
5846 mouse_face_overwritten_p
= 1;
5849 if (!w
->pseudo_window_p
)
5851 /* Draw border between windows. */
5852 x_draw_vertical_border (w
);
5854 /* Turn the cursor on again. */
5855 if (cursor_cleared_p
)
5856 x_update_window_cursor (w
, 1);
5860 return mouse_face_overwritten_p
;
5868 x_update_cursor (f
, 1);
5872 frame_unhighlight (f
)
5875 x_update_cursor (f
, 1);
5878 /* The focus has changed. Update the frames as necessary to reflect
5879 the new situation. Note that we can't change the selected frame
5880 here, because the Lisp code we are interrupting might become confused.
5881 Each event gets marked with the frame in which it occurred, so the
5882 Lisp code can tell when the switch took place by examining the events. */
5885 x_new_focus_frame (dpyinfo
, frame
)
5886 struct w32_display_info
*dpyinfo
;
5887 struct frame
*frame
;
5889 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
5891 if (frame
!= dpyinfo
->w32_focus_frame
)
5893 /* Set this before calling other routines, so that they see
5894 the correct value of w32_focus_frame. */
5895 dpyinfo
->w32_focus_frame
= frame
;
5897 if (old_focus
&& old_focus
->auto_lower
)
5898 x_lower_frame (old_focus
);
5900 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
5901 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
5903 pending_autoraise_frame
= 0;
5906 x_frame_rehighlight (dpyinfo
);
5909 /* Handle an event saying the mouse has moved out of an Emacs frame. */
5912 x_mouse_leave (dpyinfo
)
5913 struct w32_display_info
*dpyinfo
;
5915 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
5918 /* The focus has changed, or we have redirected a frame's focus to
5919 another frame (this happens when a frame uses a surrogate
5920 mini-buffer frame). Shift the highlight as appropriate.
5922 The FRAME argument doesn't necessarily have anything to do with which
5923 frame is being highlighted or un-highlighted; we only use it to find
5924 the appropriate X display info. */
5927 w32_frame_rehighlight (frame
)
5928 struct frame
*frame
;
5930 if (! FRAME_W32_P (frame
))
5932 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
5936 x_frame_rehighlight (dpyinfo
)
5937 struct w32_display_info
*dpyinfo
;
5939 struct frame
*old_highlight
= dpyinfo
->w32_highlight_frame
;
5941 if (dpyinfo
->w32_focus_frame
)
5943 dpyinfo
->w32_highlight_frame
5944 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
5945 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
5946 : dpyinfo
->w32_focus_frame
);
5947 if (! FRAME_LIVE_P (dpyinfo
->w32_highlight_frame
))
5949 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
5950 dpyinfo
->w32_highlight_frame
= dpyinfo
->w32_focus_frame
;
5954 dpyinfo
->w32_highlight_frame
= 0;
5956 if (dpyinfo
->w32_highlight_frame
!= old_highlight
)
5959 frame_unhighlight (old_highlight
);
5960 if (dpyinfo
->w32_highlight_frame
)
5961 frame_highlight (dpyinfo
->w32_highlight_frame
);
5965 /* Keyboard processing - modifier keys, etc. */
5967 /* Convert a keysym to its name. */
5970 x_get_keysym_name (keysym
)
5973 /* Make static so we can always return it */
5974 static char value
[100];
5977 GetKeyNameText (keysym
, value
, 100);
5985 /* Mouse clicks and mouse movement. Rah. */
5987 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
5988 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
5989 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
5990 not force the value into range. */
5993 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
5995 register int pix_x
, pix_y
;
5996 register int *x
, *y
;
6000 /* Support tty mode: if Vwindow_system is nil, behave correctly. */
6001 if (NILP (Vwindow_system
))
6008 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
6009 even for negative values. */
6011 pix_x
-= FONT_WIDTH (FRAME_FONT (f
)) - 1;
6013 pix_y
-= (f
)->output_data
.w32
->line_height
- 1;
6015 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
6016 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
6020 bounds
->left
= CHAR_TO_PIXEL_COL (f
, pix_x
);
6021 bounds
->top
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
6022 bounds
->right
= bounds
->left
+ FONT_WIDTH (FRAME_FONT (f
)) - 1;
6023 bounds
->bottom
= bounds
->top
+ f
->output_data
.w32
->line_height
- 1;
6030 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
6031 pix_x
= FRAME_WINDOW_WIDTH (f
);
6035 else if (pix_y
> f
->height
)
6044 /* Given HPOS/VPOS in the current matrix of W, return corresponding
6045 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
6046 can't tell the positions because W's display is not up to date,
6050 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
6053 int *frame_x
, *frame_y
;
6057 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
6058 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
6060 if (display_completed
)
6062 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6063 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
6064 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
6070 *frame_x
+= glyph
->pixel_width
;
6078 *frame_y
= *frame_x
= 0;
6082 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
6083 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
6087 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
6088 the state in PUP. XBUTTON provides extra information for extended mouse
6089 button messages. Returns FALSE if unable to parse the message. */
6091 parse_button (message
, xbutton
, pbutton
, pup
)
6102 case WM_LBUTTONDOWN
:
6110 case WM_MBUTTONDOWN
:
6111 if (NILP (Vw32_swap_mouse_buttons
))
6118 if (NILP (Vw32_swap_mouse_buttons
))
6124 case WM_RBUTTONDOWN
:
6125 if (NILP (Vw32_swap_mouse_buttons
))
6132 if (NILP (Vw32_swap_mouse_buttons
))
6138 case WM_XBUTTONDOWN
:
6139 button
= xbutton
+ 2;
6143 button
= xbutton
+ 2;
6151 if (pbutton
) *pbutton
= button
;
6157 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6159 If the event is a button press, then note that we have grabbed
6163 construct_mouse_click (result
, msg
, f
)
6164 struct input_event
*result
;
6171 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
6174 /* Make the event type no_event; we'll change that when we decide
6176 result
->kind
= mouse_click
;
6177 result
->code
= button
;
6178 result
->timestamp
= msg
->msg
.time
;
6179 result
->modifiers
= (msg
->dwModifiers
6184 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
6185 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
6186 XSETFRAME (result
->frame_or_window
, f
);
6192 construct_mouse_wheel (result
, msg
, f
)
6193 struct input_event
*result
;
6198 result
->kind
= mouse_wheel
;
6199 result
->code
= (short) HIWORD (msg
->msg
.wParam
);
6200 result
->timestamp
= msg
->msg
.time
;
6201 result
->modifiers
= msg
->dwModifiers
;
6202 p
.x
= LOWORD (msg
->msg
.lParam
);
6203 p
.y
= HIWORD (msg
->msg
.lParam
);
6204 ScreenToClient (msg
->msg
.hwnd
, &p
);
6205 XSETINT (result
->x
, p
.x
);
6206 XSETINT (result
->y
, p
.y
);
6207 XSETFRAME (result
->frame_or_window
, f
);
6213 construct_drag_n_drop (result
, msg
, f
)
6214 struct input_event
*result
;
6226 result
->kind
= drag_n_drop
;
6228 result
->timestamp
= msg
->msg
.time
;
6229 result
->modifiers
= msg
->dwModifiers
;
6231 hdrop
= (HDROP
) msg
->msg
.wParam
;
6232 DragQueryPoint (hdrop
, &p
);
6235 p
.x
= LOWORD (msg
->msg
.lParam
);
6236 p
.y
= HIWORD (msg
->msg
.lParam
);
6237 ScreenToClient (msg
->msg
.hwnd
, &p
);
6240 XSETINT (result
->x
, p
.x
);
6241 XSETINT (result
->y
, p
.y
);
6243 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
6246 for (i
= 0; i
< num_files
; i
++)
6248 len
= DragQueryFile (hdrop
, i
, NULL
, 0);
6251 name
= alloca (len
+ 1);
6252 DragQueryFile (hdrop
, i
, name
, len
+ 1);
6253 files
= Fcons (build_string (name
), files
);
6258 XSETFRAME (frame
, f
);
6259 result
->frame_or_window
= Fcons (frame
, files
);
6265 /* Function to report a mouse movement to the mainstream Emacs code.
6266 The input handler calls this.
6268 We have received a mouse movement event, which is given in *event.
6269 If the mouse is over a different glyph than it was last time, tell
6270 the mainstream emacs code by setting mouse_moved. If not, ask for
6271 another motion event, so we can check again the next time it moves. */
6273 static MSG last_mouse_motion_event
;
6274 static Lisp_Object last_mouse_motion_frame
;
6276 static void remember_mouse_glyph
P_ ((struct frame
*, int, int));
6279 note_mouse_movement (frame
, msg
)
6283 int mouse_x
= LOWORD (msg
->lParam
);
6284 int mouse_y
= HIWORD (msg
->lParam
);
6286 last_mouse_movement_time
= msg
->time
;
6287 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
6288 XSETFRAME (last_mouse_motion_frame
, frame
);
6290 if (x_autoselect_window_p
)
6294 static Lisp_Object last_window
;
6296 window
= window_from_coordinates (frame
, mouse_x
, mouse_y
, &area
, 0);
6298 /* Window will be selected only when it is not selected now and
6299 last mouse movement event was not in it. Minubuffer window
6300 will be selected iff it is active. */
6301 if (!EQ (window
, last_window
)
6302 && !EQ (window
, selected_window
)
6303 && (!MINI_WINDOW_P (XWINDOW (window
))
6304 || (EQ (window
, minibuf_window
) && minibuf_level
> 0)))
6305 Fselect_window (window
);
6310 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
6312 frame
->mouse_moved
= 1;
6313 last_mouse_scroll_bar
= Qnil
;
6314 note_mouse_highlight (frame
, -1, -1);
6317 /* Has the mouse moved off the glyph it was on at the last sighting? */
6318 else if (mouse_x
< last_mouse_glyph
.left
6319 || mouse_x
> last_mouse_glyph
.right
6320 || mouse_y
< last_mouse_glyph
.top
6321 || mouse_y
> last_mouse_glyph
.bottom
)
6323 frame
->mouse_moved
= 1;
6324 last_mouse_scroll_bar
= Qnil
;
6325 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
6326 /* Remember the mouse position here, as w32_mouse_position only
6327 gets called when mouse tracking is enabled but we also need
6328 to keep track of the mouse for help_echo and highlighting at
6330 remember_mouse_glyph (frame
, mouse_x
, mouse_y
);
6335 /************************************************************************
6337 ************************************************************************/
6339 /* Find the glyph under window-relative coordinates X/Y in window W.
6340 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6341 strings. Return in *HPOS and *VPOS the row and column number of
6342 the glyph found. Return in *AREA the glyph area containing X.
6343 Value is a pointer to the glyph found or null if X/Y is not on
6344 text, or we can't tell because W's current matrix is not up to
6347 static struct glyph
*
6348 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
, buffer_only_p
)
6351 int *hpos
, *vpos
, *area
;
6354 struct glyph
*glyph
, *end
;
6355 struct glyph_row
*row
= NULL
;
6356 int x0
, i
, left_area_width
;
6358 /* Find row containing Y. Give up if some row is not enabled. */
6359 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6361 row
= MATRIX_ROW (w
->current_matrix
, i
);
6362 if (!row
->enabled_p
)
6364 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6371 /* Give up if Y is not in the window. */
6372 if (i
== w
->current_matrix
->nrows
)
6375 /* Get the glyph area containing X. */
6376 if (w
->pseudo_window_p
)
6383 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6384 if (x
< left_area_width
)
6386 *area
= LEFT_MARGIN_AREA
;
6389 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6392 x0
= row
->x
+ left_area_width
;
6396 *area
= RIGHT_MARGIN_AREA
;
6397 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6401 /* Find glyph containing X. */
6402 glyph
= row
->glyphs
[*area
];
6403 end
= glyph
+ row
->used
[*area
];
6406 if (x
< x0
+ glyph
->pixel_width
)
6408 if (w
->pseudo_window_p
)
6410 else if (!buffer_only_p
|| BUFFERP (glyph
->object
))
6414 x0
+= glyph
->pixel_width
;
6421 *hpos
= glyph
- row
->glyphs
[*area
];
6426 /* Convert frame-relative x/y to coordinates relative to window W.
6427 Takes pseudo-windows into account. */
6430 frame_to_window_pixel_xy (w
, x
, y
)
6434 if (w
->pseudo_window_p
)
6436 /* A pseudo-window is always full-width, and starts at the
6437 left edge of the frame, plus a frame border. */
6438 struct frame
*f
= XFRAME (w
->frame
);
6439 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6440 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6444 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6445 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6450 /* Take proper action when mouse has moved to the mode or header line of
6451 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6452 mode line. X is relative to the start of the text display area of
6453 W, so the width of fringes and scroll bars must be subtracted
6454 to get a position relative to the start of the mode line. */
6457 note_mode_line_highlight (w
, x
, mode_line_p
)
6461 struct frame
*f
= XFRAME (w
->frame
);
6462 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6463 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6464 struct glyph_row
*row
;
6467 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
6469 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
6473 struct glyph
*glyph
, *end
;
6474 Lisp_Object help
, map
;
6477 /* Find the glyph under X. */
6478 glyph
= row
->glyphs
[TEXT_AREA
];
6479 end
= glyph
+ row
->used
[TEXT_AREA
];
6480 x0
= - (FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
)
6481 + FRAME_X_LEFT_FRINGE_WIDTH (f
));
6484 && x
>= x0
+ glyph
->pixel_width
)
6486 x0
+= glyph
->pixel_width
;
6491 && STRINGP (glyph
->object
)
6492 && XSTRING (glyph
->object
)->intervals
6493 && glyph
->charpos
>= 0
6494 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6496 /* If we're on a string with `help-echo' text property,
6497 arrange for the help to be displayed. This is done by
6498 setting the global variable help_echo to the help string. */
6499 help
= Fget_text_property (make_number (glyph
->charpos
),
6500 Qhelp_echo
, glyph
->object
);
6504 XSETWINDOW (help_echo_window
, w
);
6505 help_echo_object
= glyph
->object
;
6506 help_echo_pos
= glyph
->charpos
;
6509 /* Change the mouse pointer according to what is under X/Y. */
6510 map
= Fget_text_property (make_number (glyph
->charpos
),
6511 Qlocal_map
, glyph
->object
);
6513 cursor
= f
->output_data
.w32
->nontext_cursor
;
6516 map
= Fget_text_property (make_number (glyph
->charpos
),
6517 Qkeymap
, glyph
->object
);
6519 cursor
= f
->output_data
.w32
->nontext_cursor
;
6524 #if 0 /* TODO: mouse cursor */
6525 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6530 /* Take proper action when the mouse has moved to position X, Y on
6531 frame F as regards highlighting characters that have mouse-face
6532 properties. Also de-highlighting chars where the mouse was before.
6533 X and Y can be negative or out of range. */
6536 note_mouse_highlight (f
, x
, y
)
6540 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6546 /* When a menu is active, don't highlight because this looks odd. */
6547 if (popup_activated ())
6550 if (NILP (Vmouse_highlight
)
6551 || !f
->glyphs_initialized_p
)
6554 dpyinfo
->mouse_face_mouse_x
= x
;
6555 dpyinfo
->mouse_face_mouse_y
= y
;
6556 dpyinfo
->mouse_face_mouse_frame
= f
;
6558 if (dpyinfo
->mouse_face_defer
)
6563 dpyinfo
->mouse_face_deferred_gc
= 1;
6567 /* Which window is that in? */
6568 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
6570 /* If we were displaying active text in another window, clear that. */
6571 if (! EQ (window
, dpyinfo
->mouse_face_window
))
6572 clear_mouse_face (dpyinfo
);
6574 /* Not on a window -> return. */
6575 if (!WINDOWP (window
))
6578 /* Reset help_echo. It will get recomputed below. */
6581 /* Convert to window-relative pixel coordinates. */
6582 w
= XWINDOW (window
);
6583 frame_to_window_pixel_xy (w
, &x
, &y
);
6585 /* Handle tool-bar window differently since it doesn't display a
6587 if (EQ (window
, f
->tool_bar_window
))
6589 note_tool_bar_highlight (f
, x
, y
);
6593 /* Mouse is on the mode or header line? */
6594 if (portion
== 1 || portion
== 3)
6596 note_mode_line_highlight (w
, x
, portion
== 1);
6599 #if 0 /* TODO: mouse cursor */
6601 cursor
= f
->output_data
.x
->horizontal_drag_cursor
;
6603 cursor
= f
->output_data
.x
->text_cursor
;
6605 /* Are we in a window whose display is up to date?
6606 And verify the buffer's text has not changed. */
6607 b
= XBUFFER (w
->buffer
);
6608 if (/* Within text portion of the window. */
6610 && EQ (w
->window_end_valid
, w
->buffer
)
6611 && XFASTINT (w
->last_modified
) == BUF_MODIFF (b
)
6612 && XFASTINT (w
->last_overlay_modified
) == BUF_OVERLAY_MODIFF (b
))
6614 int hpos
, vpos
, pos
, i
, area
;
6615 struct glyph
*glyph
;
6617 Lisp_Object mouse_face
= Qnil
, overlay
= Qnil
, position
;
6618 Lisp_Object
*overlay_vec
= NULL
;
6620 struct buffer
*obuf
;
6621 int obegv
, ozv
, same_region
;
6623 /* Find the glyph under X/Y. */
6624 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
, 0);
6626 /* Clear mouse face if X/Y not over text. */
6628 || area
!= TEXT_AREA
6629 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
6631 clear_mouse_face (dpyinfo
);
6632 /* TODO: mouse cursor */
6636 pos
= glyph
->charpos
;
6637 object
= glyph
->object
;
6638 if (!STRINGP (object
) && !BUFFERP (object
))
6641 /* If we get an out-of-range value, return now; avoid an error. */
6642 if (BUFFERP (object
) && pos
> BUF_Z (b
))
6645 /* Make the window's buffer temporarily current for
6646 overlays_at and compute_char_face. */
6647 obuf
= current_buffer
;
6654 /* Is this char mouse-active or does it have help-echo? */
6655 position
= make_number (pos
);
6657 if (BUFFERP (object
))
6659 /* Put all the overlays we want in a vector in overlay_vec.
6660 Store the length in len. If there are more than 10, make
6661 enough space for all, and try again. */
6663 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6664 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
6665 if (noverlays
> len
)
6668 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6669 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
,0);
6672 /* Sort overlays into increasing priority order. */
6673 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
6678 same_region
= (EQ (window
, dpyinfo
->mouse_face_window
)
6679 && vpos
>= dpyinfo
->mouse_face_beg_row
6680 && vpos
<= dpyinfo
->mouse_face_end_row
6681 && (vpos
> dpyinfo
->mouse_face_beg_row
6682 || hpos
>= dpyinfo
->mouse_face_beg_col
)
6683 && (vpos
< dpyinfo
->mouse_face_end_row
6684 || hpos
< dpyinfo
->mouse_face_end_col
6685 || dpyinfo
->mouse_face_past_end
));
6687 /* TODO: if (same_region)
6690 /* Check mouse-face highlighting. */
6692 /* If there exists an overlay with mouse-face overlapping
6693 the one we are currently highlighting, we have to
6694 check if we enter the overlapping overlay, and then
6696 || (OVERLAYP (dpyinfo
->mouse_face_overlay
)
6697 && mouse_face_overlay_overlaps (dpyinfo
->mouse_face_overlay
)))
6699 /* Find the highest priority overlay that has a mouse-face
6702 for (i
= noverlays
- 1; i
>= 0 && NILP (overlay
); --i
)
6704 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
6705 if (!NILP (mouse_face
))
6706 overlay
= overlay_vec
[i
];
6709 /* If we're actually highlighting the same overlay as
6710 before, there's no need to do that again. */
6712 && EQ (overlay
, dpyinfo
->mouse_face_overlay
))
6713 goto check_help_echo
;
6715 dpyinfo
->mouse_face_overlay
= overlay
;
6717 /* Clear the display of the old active region, if any. */
6718 clear_mouse_face (dpyinfo
);
6719 /* TODO: mouse cursor changes. */
6721 /* If no overlay applies, get a text property. */
6723 mouse_face
= Fget_text_property (position
, Qmouse_face
, object
);
6725 /* Handle the overlay case. */
6726 if (!NILP (overlay
))
6728 /* Find the range of text around this char that
6729 should be active. */
6730 Lisp_Object before
, after
;
6733 before
= Foverlay_start (overlay
);
6734 after
= Foverlay_end (overlay
);
6735 /* Record this as the current active region. */
6736 fast_find_position (w
, XFASTINT (before
),
6737 &dpyinfo
->mouse_face_beg_col
,
6738 &dpyinfo
->mouse_face_beg_row
,
6739 &dpyinfo
->mouse_face_beg_x
,
6740 &dpyinfo
->mouse_face_beg_y
, Qnil
);
6742 dpyinfo
->mouse_face_past_end
6743 = !fast_find_position (w
, XFASTINT (after
),
6744 &dpyinfo
->mouse_face_end_col
,
6745 &dpyinfo
->mouse_face_end_row
,
6746 &dpyinfo
->mouse_face_end_x
,
6747 &dpyinfo
->mouse_face_end_y
, Qnil
);
6748 dpyinfo
->mouse_face_window
= window
;
6750 dpyinfo
->mouse_face_face_id
6751 = face_at_buffer_position (w
, pos
, 0, 0,
6752 &ignore
, pos
+ 1, 1);
6754 /* Display it as active. */
6755 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6756 /* TODO: mouse cursor changes. */
6758 /* Handle the text property case. */
6759 else if (! NILP (mouse_face
) && BUFFERP (object
))
6761 /* Find the range of text around this char that
6762 should be active. */
6763 Lisp_Object before
, after
, beginning
, end
;
6766 beginning
= Fmarker_position (w
->start
);
6767 end
= make_number (BUF_Z (XBUFFER (object
))
6768 - XFASTINT (w
->window_end_pos
));
6770 = Fprevious_single_property_change (make_number (pos
+ 1),
6774 = Fnext_single_property_change (position
, Qmouse_face
,
6777 /* Record this as the current active region. */
6778 fast_find_position (w
, XFASTINT (before
),
6779 &dpyinfo
->mouse_face_beg_col
,
6780 &dpyinfo
->mouse_face_beg_row
,
6781 &dpyinfo
->mouse_face_beg_x
,
6782 &dpyinfo
->mouse_face_beg_y
, Qnil
);
6783 dpyinfo
->mouse_face_past_end
6784 = !fast_find_position (w
, XFASTINT (after
),
6785 &dpyinfo
->mouse_face_end_col
,
6786 &dpyinfo
->mouse_face_end_row
,
6787 &dpyinfo
->mouse_face_end_x
,
6788 &dpyinfo
->mouse_face_end_y
, Qnil
);
6789 dpyinfo
->mouse_face_window
= window
;
6791 if (BUFFERP (object
))
6792 dpyinfo
->mouse_face_face_id
6793 = face_at_buffer_position (w
, pos
, 0, 0,
6794 &ignore
, pos
+ 1, 1);
6796 /* Display it as active. */
6797 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6798 /* TODO: mouse cursor changes. */
6800 else if (!NILP (mouse_face
) && STRINGP (object
))
6805 b
= Fprevious_single_property_change (make_number (pos
+ 1),
6808 e
= Fnext_single_property_change (position
, Qmouse_face
,
6811 b
= make_number (0);
6813 e
= make_number (XSTRING (object
)->size
- 1);
6814 fast_find_string_pos (w
, XINT (b
), object
,
6815 &dpyinfo
->mouse_face_beg_col
,
6816 &dpyinfo
->mouse_face_beg_row
,
6817 &dpyinfo
->mouse_face_beg_x
,
6818 &dpyinfo
->mouse_face_beg_y
, 0);
6819 fast_find_string_pos (w
, XINT (e
), object
,
6820 &dpyinfo
->mouse_face_end_col
,
6821 &dpyinfo
->mouse_face_end_row
,
6822 &dpyinfo
->mouse_face_end_x
,
6823 &dpyinfo
->mouse_face_end_y
, 1);
6824 dpyinfo
->mouse_face_past_end
= 0;
6825 dpyinfo
->mouse_face_window
= window
;
6826 dpyinfo
->mouse_face_face_id
6827 = face_at_string_position (w
, object
, pos
, 0, 0, 0, &ignore
,
6829 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6830 /* TODO: mouse cursor changes. */
6832 else if (STRINGP (object
) && NILP (mouse_face
))
6834 /* A string which doesn't have mouse-face, but
6835 the text ``under'' it might have. */
6836 struct glyph_row
*r
= MATRIX_ROW (w
->current_matrix
, vpos
);
6837 int start
= MATRIX_ROW_START_CHARPOS (r
);
6839 pos
= string_buffer_position (w
, object
, start
);
6841 mouse_face
= get_char_property_and_overlay (make_number (pos
),
6845 if (!NILP (mouse_face
) && !NILP (overlay
))
6847 Lisp_Object before
= Foverlay_start (overlay
);
6848 Lisp_Object after
= Foverlay_end (overlay
);
6851 /* Note that we might not be able to find position
6852 BEFORE in the glyph matrix if the overlay is
6853 entirely covered by a `display' property. In
6854 this case, we overshoot. So let's stop in
6855 the glyph matrix before glyphs for OBJECT. */
6856 fast_find_position (w
, XFASTINT (before
),
6857 &dpyinfo
->mouse_face_beg_col
,
6858 &dpyinfo
->mouse_face_beg_row
,
6859 &dpyinfo
->mouse_face_beg_x
,
6860 &dpyinfo
->mouse_face_beg_y
,
6863 dpyinfo
->mouse_face_past_end
6864 = !fast_find_position (w
, XFASTINT (after
),
6865 &dpyinfo
->mouse_face_end_col
,
6866 &dpyinfo
->mouse_face_end_row
,
6867 &dpyinfo
->mouse_face_end_x
,
6868 &dpyinfo
->mouse_face_end_y
,
6870 dpyinfo
->mouse_face_window
= window
;
6871 dpyinfo
->mouse_face_face_id
6872 = face_at_buffer_position (w
, pos
, 0, 0,
6873 &ignore
, pos
+ 1, 1);
6875 /* Display it as active. */
6876 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6877 /* TODO: mouse cursor changes. */
6884 /* Look for a `help-echo' property. */
6886 Lisp_Object help
, overlay
;
6888 /* Check overlays first. */
6889 help
= overlay
= Qnil
;
6890 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
6892 overlay
= overlay_vec
[i
];
6893 help
= Foverlay_get (overlay
, Qhelp_echo
);
6899 help_echo_window
= window
;
6900 help_echo_object
= overlay
;
6901 help_echo_pos
= pos
;
6905 Lisp_Object object
= glyph
->object
;
6906 int charpos
= glyph
->charpos
;
6908 /* Try text properties. */
6909 if (STRINGP (object
)
6911 && charpos
< XSTRING (object
)->size
)
6913 help
= Fget_text_property (make_number (charpos
),
6914 Qhelp_echo
, object
);
6917 /* If the string itself doesn't specify a help-echo,
6918 see if the buffer text ``under'' it does. */
6920 = MATRIX_ROW (w
->current_matrix
, vpos
);
6921 int start
= MATRIX_ROW_START_CHARPOS (r
);
6922 int pos
= string_buffer_position (w
, object
, start
);
6925 help
= Fget_char_property (make_number (pos
),
6926 Qhelp_echo
, w
->buffer
);
6935 else if (BUFFERP (object
)
6938 help
= Fget_text_property (make_number (charpos
), Qhelp_echo
,
6944 help_echo_window
= window
;
6945 help_echo_object
= object
;
6946 help_echo_pos
= charpos
;
6953 current_buffer
= obuf
;
6957 /* TODO: mouse cursor changes. */
6962 redo_mouse_highlight ()
6964 if (!NILP (last_mouse_motion_frame
)
6965 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
6966 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
6967 LOWORD (last_mouse_motion_event
.lParam
),
6968 HIWORD (last_mouse_motion_event
.lParam
));
6973 /***********************************************************************
6975 ***********************************************************************/
6977 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
6978 struct glyph
**, int *, int *, int *));
6980 /* Tool-bar item index of the item on which a mouse button was pressed
6983 static int last_tool_bar_item
;
6986 /* Get information about the tool-bar item at position X/Y on frame F.
6987 Return in *GLYPH a pointer to the glyph of the tool-bar item in
6988 the current matrix of the tool-bar window of F, or NULL if not
6989 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
6990 item in F->tool_bar_items. Value is
6992 -1 if X/Y is not on a tool-bar item
6993 0 if X/Y is on the same item that was highlighted before.
6997 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
7000 struct glyph
**glyph
;
7001 int *hpos
, *vpos
, *prop_idx
;
7003 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
7004 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7007 /* Find the glyph under X/Y. */
7008 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
, 0);
7012 /* Get the start of this tool-bar item's properties in
7013 f->tool_bar_items. */
7014 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
7017 /* Is mouse on the highlighted item? */
7018 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
7019 && *vpos
>= dpyinfo
->mouse_face_beg_row
7020 && *vpos
<= dpyinfo
->mouse_face_end_row
7021 && (*vpos
> dpyinfo
->mouse_face_beg_row
7022 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
7023 && (*vpos
< dpyinfo
->mouse_face_end_row
7024 || *hpos
< dpyinfo
->mouse_face_end_col
7025 || dpyinfo
->mouse_face_past_end
))
7032 /* Handle mouse button event on the tool-bar of frame F, at
7033 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
7037 w32_handle_tool_bar_click (f
, button_event
)
7039 struct input_event
*button_event
;
7041 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
7042 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7043 int hpos
, vpos
, prop_idx
;
7044 struct glyph
*glyph
;
7045 Lisp_Object enabled_p
;
7046 int x
= XFASTINT (button_event
->x
);
7047 int y
= XFASTINT (button_event
->y
);
7049 /* If not on the highlighted tool-bar item, return. */
7050 frame_to_window_pixel_xy (w
, &x
, &y
);
7051 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
7054 /* If item is disabled, do nothing. */
7055 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7056 if (NILP (enabled_p
))
7059 if (button_event
->kind
== mouse_click
)
7061 /* Show item in pressed state. */
7062 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
7063 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
7064 last_tool_bar_item
= prop_idx
;
7068 Lisp_Object key
, frame
;
7069 struct input_event event
;
7071 /* Show item in released state. */
7072 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
7073 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
7075 key
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_KEY
);
7077 XSETFRAME (frame
, f
);
7078 event
.kind
= TOOL_BAR_EVENT
;
7079 event
.frame_or_window
= frame
;
7081 kbd_buffer_store_event (&event
);
7083 event
.kind
= TOOL_BAR_EVENT
;
7084 event
.frame_or_window
= frame
;
7086 event
.modifiers
= button_event
->modifiers
;
7087 kbd_buffer_store_event (&event
);
7088 last_tool_bar_item
= -1;
7093 /* Possibly highlight a tool-bar item on frame F when mouse moves to
7094 tool-bar window-relative coordinates X/Y. Called from
7095 note_mouse_highlight. */
7098 note_tool_bar_highlight (f
, x
, y
)
7102 Lisp_Object window
= f
->tool_bar_window
;
7103 struct window
*w
= XWINDOW (window
);
7104 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
7106 struct glyph
*glyph
;
7107 struct glyph_row
*row
;
7109 Lisp_Object enabled_p
;
7111 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
7112 int mouse_down_p
, rc
;
7114 /* Function note_mouse_highlight is called with negative x(y
7115 values when mouse moves outside of the frame. */
7116 if (x
<= 0 || y
<= 0)
7118 clear_mouse_face (dpyinfo
);
7122 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
7125 /* Not on tool-bar item. */
7126 clear_mouse_face (dpyinfo
);
7130 /* On same tool-bar item as before. */
7133 clear_mouse_face (dpyinfo
);
7135 /* Mouse is down, but on different tool-bar item? */
7136 mouse_down_p
= (dpyinfo
->grabbed
7137 && f
== last_mouse_frame
7138 && FRAME_LIVE_P (f
));
7140 && last_tool_bar_item
!= prop_idx
)
7143 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
7144 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
7146 /* If tool-bar item is not enabled, don't highlight it. */
7147 enabled_p
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
);
7148 if (!NILP (enabled_p
))
7150 /* Compute the x-position of the glyph. In front and past the
7151 image is a space. We include this is the highlighted area. */
7152 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
7153 for (i
= x
= 0; i
< hpos
; ++i
)
7154 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
7156 /* Record this as the current active region. */
7157 dpyinfo
->mouse_face_beg_col
= hpos
;
7158 dpyinfo
->mouse_face_beg_row
= vpos
;
7159 dpyinfo
->mouse_face_beg_x
= x
;
7160 dpyinfo
->mouse_face_beg_y
= row
->y
;
7161 dpyinfo
->mouse_face_past_end
= 0;
7163 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
7164 dpyinfo
->mouse_face_end_row
= vpos
;
7165 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
7166 dpyinfo
->mouse_face_end_y
= row
->y
;
7167 dpyinfo
->mouse_face_window
= window
;
7168 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
7170 /* Display it as active. */
7171 show_mouse_face (dpyinfo
, draw
);
7172 dpyinfo
->mouse_face_image_state
= draw
;
7177 /* Set help_echo to a help string.to display for this tool-bar item.
7178 w32_read_socket does the rest. */
7179 help_echo_object
= help_echo_window
= Qnil
;
7181 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_HELP
);
7182 if (NILP (help_echo
))
7183 help_echo
= AREF (f
->tool_bar_items
, prop_idx
+ TOOL_BAR_ITEM_CAPTION
);
7188 /* Find the glyph matrix position of buffer position CHARPOS in window
7189 *W. HPOS, *VPOS, *X, and *Y are set to the positions found. W's
7190 current glyphs must be up to date. If CHARPOS is above window
7191 start return (0, 0, 0, 0). If CHARPOS is after end of W, return end
7192 of last line in W. In the row containing CHARPOS, stop before glyphs
7193 having STOP as object. */
7195 #if 0 /* This is a version of fast_find_position that's more correct
7196 in the presence of hscrolling, for example. I didn't install
7197 it right away because the problem fixed is minor, it failed
7198 in 20.x as well, and I think it's too risky to install
7199 so near the release of 21.1. 2001-09-25 gerd. */
7202 fast_find_position (w
, charpos
, hpos
, vpos
, x
, y
, stop
)
7205 int *hpos
, *vpos
, *x
, *y
;
7208 struct glyph_row
*row
, *first
;
7209 struct glyph
*glyph
, *end
;
7210 int i
, past_end
= 0;
7212 first
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7213 row
= row_containing_pos (w
, charpos
, first
, NULL
, 0);
7216 if (charpos
< MATRIX_ROW_START_CHARPOS (first
))
7218 *x
= *y
= *hpos
= *vpos
= 0;
7223 row
= MATRIX_ROW (w
->current_matrix
, XFASTINT (w
->window_end_vpos
));
7230 *vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
7232 glyph
= row
->glyphs
[TEXT_AREA
];
7233 end
= glyph
+ row
->used
[TEXT_AREA
];
7235 /* Skip over glyphs not having an object at the start of the row.
7236 These are special glyphs like truncation marks on terminal
7238 if (row
->displays_text_p
)
7240 && INTEGERP (glyph
->object
)
7241 && !EQ (stop
, glyph
->object
)
7242 && glyph
->charpos
< 0)
7244 *x
+= glyph
->pixel_width
;
7249 && !INTEGERP (glyph
->object
)
7250 && !EQ (stop
, glyph
->object
)
7251 && (!BUFFERP (glyph
->object
)
7252 || glyph
->charpos
< charpos
))
7254 *x
+= glyph
->pixel_width
;
7258 *hpos
= glyph
- row
->glyphs
[TEXT_AREA
];
7265 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
, stop
)
7268 int *hpos
, *vpos
, *x
, *y
;
7273 int maybe_next_line_p
= 0;
7274 int line_start_position
;
7275 int yb
= window_text_bottom_y (w
);
7276 struct glyph_row
*row
, *best_row
;
7277 int row_vpos
, best_row_vpos
;
7280 row
= best_row
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7281 row_vpos
= best_row_vpos
= MATRIX_ROW_VPOS (row
, w
->current_matrix
);
7285 if (row
->used
[TEXT_AREA
])
7286 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
7288 line_start_position
= 0;
7290 if (line_start_position
> pos
)
7292 /* If the position sought is the end of the buffer,
7293 don't include the blank lines at the bottom of the window. */
7294 else if (line_start_position
== pos
7295 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
7297 maybe_next_line_p
= 1;
7300 else if (line_start_position
> 0)
7303 best_row_vpos
= row_vpos
;
7306 if (row
->y
+ row
->height
>= yb
)
7313 /* Find the right column within BEST_ROW. */
7315 current_x
= best_row
->x
;
7316 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
7318 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
7319 int charpos
= glyph
->charpos
;
7321 if (BUFFERP (glyph
->object
))
7326 *vpos
= best_row_vpos
;
7331 else if (charpos
> pos
)
7334 else if (EQ (glyph
->object
, stop
))
7339 current_x
+= glyph
->pixel_width
;
7342 /* If we're looking for the end of the buffer,
7343 and we didn't find it in the line we scanned,
7344 use the start of the following line. */
7345 if (maybe_next_line_p
)
7350 current_x
= best_row
->x
;
7353 *vpos
= best_row_vpos
;
7354 *hpos
= lastcol
+ 1;
7363 /* Find the position of the glyph for position POS in OBJECT in
7364 window W's current matrix, and return in *X/*Y the pixel
7365 coordinates, and return in *HPOS/*VPOS the column/row of the glyph.
7367 RIGHT_P non-zero means return the position of the right edge of the
7368 glyph, RIGHT_P zero means return the left edge position.
7370 If no glyph for POS exists in the matrix, return the position of
7371 the glyph with the next smaller position that is in the matrix, if
7372 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
7373 exists in the matrix, return the position of the glyph with the
7374 next larger position in OBJECT.
7376 Value is non-zero if a glyph was found. */
7379 fast_find_string_pos (w
, pos
, object
, hpos
, vpos
, x
, y
, right_p
)
7383 int *hpos
, *vpos
, *x
, *y
;
7386 int yb
= window_text_bottom_y (w
);
7387 struct glyph_row
*r
;
7388 struct glyph
*best_glyph
= NULL
;
7389 struct glyph_row
*best_row
= NULL
;
7392 for (r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7393 r
->enabled_p
&& r
->y
< yb
;
7396 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
7397 struct glyph
*e
= g
+ r
->used
[TEXT_AREA
];
7400 for (gx
= r
->x
; g
< e
; gx
+= g
->pixel_width
, ++g
)
7401 if (EQ (g
->object
, object
))
7403 if (g
->charpos
== pos
)
7410 else if (best_glyph
== NULL
7411 || ((abs (g
->charpos
- pos
)
7412 < abs (best_glyph
->charpos
- pos
))
7415 : g
->charpos
> pos
)))
7429 *hpos
= best_glyph
- best_row
->glyphs
[TEXT_AREA
];
7433 *x
+= best_glyph
->pixel_width
;
7438 *vpos
= best_row
- w
->current_matrix
->rows
;
7441 return best_glyph
!= NULL
;
7445 /* Display the active region described by mouse_face_*
7446 in its mouse-face if HL > 0, in its normal face if HL = 0. */
7449 show_mouse_face (dpyinfo
, draw
)
7450 struct w32_display_info
*dpyinfo
;
7451 enum draw_glyphs_face draw
;
7453 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
7454 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7456 if (/* If window is in the process of being destroyed, don't bother
7458 w
->current_matrix
!= NULL
7459 /* Don't update mouse highlight if hidden */
7460 && (draw
!= DRAW_MOUSE_FACE
|| !dpyinfo
->mouse_face_hidden
)
7461 /* Recognize when we are called to operate on rows that don't exist
7462 anymore. This can happen when a window is split. */
7463 && dpyinfo
->mouse_face_end_row
< w
->current_matrix
->nrows
)
7465 int phys_cursor_on_p
= w
->phys_cursor_on_p
;
7466 struct glyph_row
*row
, *first
, *last
;
7468 first
= MATRIX_ROW (w
->current_matrix
, dpyinfo
->mouse_face_beg_row
);
7469 last
= MATRIX_ROW (w
->current_matrix
, dpyinfo
->mouse_face_end_row
);
7471 for (row
= first
; row
<= last
&& row
->enabled_p
; ++row
)
7473 int start_hpos
, end_hpos
, start_x
;
7475 /* For all but the first row, the highlight starts at column 0. */
7478 start_hpos
= dpyinfo
->mouse_face_beg_col
;
7479 start_x
= dpyinfo
->mouse_face_beg_x
;
7488 end_hpos
= dpyinfo
->mouse_face_end_col
;
7490 end_hpos
= row
->used
[TEXT_AREA
];
7492 if (end_hpos
> start_hpos
)
7494 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
7495 start_hpos
, end_hpos
, draw
, 0);
7498 = draw
== DRAW_MOUSE_FACE
|| draw
== DRAW_IMAGE_RAISED
;
7502 /* When we've written over the cursor, arrange for it to
7503 be displayed again. */
7504 if (phys_cursor_on_p
&& !w
->phys_cursor_on_p
)
7505 x_display_cursor (w
, 1,
7506 w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
7507 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
7510 #if 0 /* TODO: mouse cursor */
7511 /* Change the mouse cursor. */
7512 if (draw
== DRAW_NORMAL_TEXT
)
7513 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7514 f
->output_data
.x
->text_cursor
);
7515 else if (draw
== DRAW_MOUSE_FACE
)
7516 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7517 f
->output_data
.x
->cross_cursor
);
7519 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7520 f
->output_data
.x
->nontext_cursor
);
7524 /* Clear out the mouse-highlighted active region.
7525 Redraw it un-highlighted first. */
7528 clear_mouse_face (dpyinfo
)
7529 struct w32_display_info
*dpyinfo
;
7533 if (! NILP (dpyinfo
->mouse_face_window
))
7535 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
7539 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7540 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7541 dpyinfo
->mouse_face_window
= Qnil
;
7542 dpyinfo
->mouse_face_overlay
= Qnil
;
7547 /* Clear any mouse-face on window W. This function is part of the
7548 redisplay interface, and is called from try_window_id and similar
7549 functions to ensure the mouse-highlight is off. */
7552 x_clear_mouse_face (w
)
7555 struct w32_display_info
*dpyinfo
7556 = FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
7560 XSETWINDOW (window
, w
);
7561 if (EQ (window
, dpyinfo
->mouse_face_window
))
7562 clear_mouse_face (dpyinfo
);
7567 /* Just discard the mouse face information for frame F, if any.
7568 This is used when the size of F is changed. */
7571 cancel_mouse_face (f
)
7575 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
7577 window
= dpyinfo
->mouse_face_window
;
7578 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
7580 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7581 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7582 dpyinfo
->mouse_face_window
= Qnil
;
7586 static struct scroll_bar
*x_window_to_scroll_bar ();
7587 static void x_scroll_bar_report_motion ();
7588 static void x_check_fullscreen
P_ ((struct frame
*));
7589 static void x_check_fullscreen_move
P_ ((struct frame
*));
7590 static int glyph_rect
P_ ((struct frame
*f
, int, int, RECT
*));
7593 /* Try to determine frame pixel position and size of the glyph under
7594 frame pixel coordinates X/Y on frame F . Return the position and
7595 size in *RECT. Value is non-zero if we could compute these
7599 glyph_rect (f
, x
, y
, rect
)
7607 window
= window_from_coordinates (f
, x
, y
, &part
, 0);
7610 struct window
*w
= XWINDOW (window
);
7611 struct glyph_row
*r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
7612 struct glyph_row
*end
= r
+ w
->current_matrix
->nrows
- 1;
7614 frame_to_window_pixel_xy (w
, &x
, &y
);
7616 for (; r
< end
&& r
->enabled_p
; ++r
)
7617 if (r
->y
<= y
&& r
->y
+ r
->height
> y
)
7619 /* Found the row at y. */
7620 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
7621 struct glyph
*end
= g
+ r
->used
[TEXT_AREA
];
7624 rect
->top
= WINDOW_TO_FRAME_PIXEL_Y (w
, r
->y
);
7625 rect
->bottom
= rect
->top
+ r
->height
;
7629 /* x is to the left of the first glyph in the row. */
7630 rect
->left
= XINT (w
->left
);
7631 rect
->right
= WINDOW_TO_FRAME_PIXEL_X (w
, r
->x
);
7635 for (gx
= r
->x
; g
< end
; gx
+= g
->pixel_width
, ++g
)
7636 if (gx
<= x
&& gx
+ g
->pixel_width
> x
)
7638 /* x is on a glyph. */
7639 rect
->left
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
7640 rect
->right
= rect
->left
+ g
->pixel_width
;
7644 /* x is to the right of the last glyph in the row. */
7645 rect
->left
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
7646 rect
->right
= XINT (w
->left
) + XINT (w
->width
);
7651 /* The y is not on any row. */
7655 /* Record the position of the mouse in last_mouse_glyph. */
7657 remember_mouse_glyph (f1
, gx
, gy
)
7661 if (!glyph_rect (f1
, gx
, gy
, &last_mouse_glyph
))
7663 int width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
7664 int height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
7666 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
7667 round down even for negative values. */
7673 /* This was the original code from XTmouse_position, but it seems
7674 to give the position of the glyph diagonally next to the one
7675 the mouse is over. */
7676 gx
= (gx
+ width
- 1) / width
* width
;
7677 gy
= (gy
+ height
- 1) / height
* height
;
7679 gx
= gx
/ width
* width
;
7680 gy
= gy
/ height
* height
;
7683 last_mouse_glyph
.left
= gx
;
7684 last_mouse_glyph
.top
= gy
;
7685 last_mouse_glyph
.right
= gx
+ width
;
7686 last_mouse_glyph
.bottom
= gy
+ height
;
7690 /* Return the current position of the mouse.
7691 *fp should be a frame which indicates which display to ask about.
7693 If the mouse movement started in a scroll bar, set *fp, *bar_window,
7694 and *part to the frame, window, and scroll bar part that the mouse
7695 is over. Set *x and *y to the portion and whole of the mouse's
7696 position on the scroll bar.
7698 If the mouse movement started elsewhere, set *fp to the frame the
7699 mouse is on, *bar_window to nil, and *x and *y to the character cell
7702 Set *time to the server time-stamp for the time at which the mouse
7703 was at this position.
7705 Don't store anything if we don't have a valid set of values to report.
7707 This clears the mouse_moved flag, so we can wait for the next mouse
7711 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
7714 Lisp_Object
*bar_window
;
7715 enum scroll_bar_part
*part
;
7717 unsigned long *time
;
7723 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
7724 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
7729 Lisp_Object frame
, tail
;
7731 /* Clear the mouse-moved flag for every frame on this display. */
7732 FOR_EACH_FRAME (tail
, frame
)
7733 XFRAME (frame
)->mouse_moved
= 0;
7735 last_mouse_scroll_bar
= Qnil
;
7739 /* Now we have a position on the root; find the innermost window
7740 containing the pointer. */
7742 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
7743 && FRAME_LIVE_P (last_mouse_frame
))
7745 /* If mouse was grabbed on a frame, give coords for that frame
7746 even if the mouse is now outside it. */
7747 f1
= last_mouse_frame
;
7751 /* Is window under mouse one of our frames? */
7752 f1
= x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
7753 WindowFromPoint (pt
));
7756 /* If not, is it one of our scroll bars? */
7759 struct scroll_bar
*bar
7760 = x_window_to_scroll_bar (WindowFromPoint (pt
));
7764 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7768 if (f1
== 0 && insist
> 0)
7769 f1
= SELECTED_FRAME ();
7773 /* Ok, we found a frame. Store all the values.
7774 last_mouse_glyph is a rectangle used to reduce the
7775 generation of mouse events. To not miss any motion
7776 events, we must divide the frame into rectangles of the
7777 size of the smallest character that could be displayed
7778 on it, i.e. into the same rectangles that matrices on
7779 the frame are divided into. */
7781 #if OLD_REDISPLAY_CODE
7782 int ignore1
, ignore2
;
7784 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
7786 pixel_to_glyph_coords (f1
, pt
.x
, pt
.y
, &ignore1
, &ignore2
,
7788 FRAME_W32_DISPLAY_INFO (f1
)->grabbed
7791 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
7792 remember_mouse_glyph (f1
, pt
.x
, pt
.y
);
7800 *time
= last_mouse_movement_time
;
7809 /* Scroll bar support. */
7811 /* Given a window ID, find the struct scroll_bar which manages it.
7812 This can be called in GC, so we have to make sure to strip off mark
7815 static struct scroll_bar
*
7816 x_window_to_scroll_bar (window_id
)
7821 for (tail
= Vframe_list
;
7822 XGCTYPE (tail
) == Lisp_Cons
;
7825 Lisp_Object frame
, bar
, condemned
;
7827 frame
= XCAR (tail
);
7828 /* All elements of Vframe_list should be frames. */
7829 if (! GC_FRAMEP (frame
))
7832 /* Scan this frame's scroll bar list for a scroll bar with the
7834 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
7835 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
7836 /* This trick allows us to search both the ordinary and
7837 condemned scroll bar lists with one loop. */
7838 ! GC_NILP (bar
) || (bar
= condemned
,
7841 bar
= XSCROLL_BAR (bar
)->next
)
7842 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
7843 return XSCROLL_BAR (bar
);
7851 /* Set the thumb size and position of scroll bar BAR. We are currently
7852 displaying PORTION out of a whole WHOLE, and our position POSITION. */
7855 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
)
7856 struct scroll_bar
*bar
;
7857 int portion
, position
, whole
;
7859 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
7860 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
7861 int sb_page
, sb_pos
;
7862 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
7866 /* Position scroll bar at rock bottom if the bottom of the
7867 buffer is visible. This avoids shinking the thumb away
7868 to nothing if it is held at the bottom of the buffer. */
7869 if (position
+ portion
>= whole
)
7871 sb_page
= range
* (whole
- position
) / whole
7872 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
7876 sb_page
= portion
* range
/ whole
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
7877 sb_pos
= position
* range
/ whole
;
7887 if (pfnSetScrollInfo
)
7891 si
.cbSize
= sizeof (si
);
7892 /* Only update page size if currently dragging, to reduce
7895 si
.fMask
= SIF_PAGE
;
7897 si
.fMask
= SIF_PAGE
| SIF_POS
;
7901 pfnSetScrollInfo (w
, SB_CTL
, &si
, !draggingp
);
7904 SetScrollPos (w
, SB_CTL
, sb_pos
, !draggingp
);
7910 /************************************************************************
7911 Scroll bars, general
7912 ************************************************************************/
7915 my_create_scrollbar (f
, bar
)
7917 struct scroll_bar
* bar
;
7919 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
7920 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
7924 /*#define ATTACH_THREADS*/
7927 my_show_window (FRAME_PTR f
, HWND hwnd
, int how
)
7929 #ifndef ATTACH_THREADS
7930 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
7931 (WPARAM
) hwnd
, (LPARAM
) how
);
7933 return ShowWindow (hwnd
, how
);
7938 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
7939 int x
, int y
, int cx
, int cy
, UINT flags
)
7941 #ifndef ATTACH_THREADS
7943 pos
.hwndInsertAfter
= hwndAfter
;
7949 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
7951 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
7956 my_set_focus (f
, hwnd
)
7960 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
7965 my_set_foreground_window (hwnd
)
7968 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
7972 my_destroy_window (f
, hwnd
)
7976 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
7980 /* Create a scroll bar and return the scroll bar vector for it. W is
7981 the Emacs window on which to create the scroll bar. TOP, LEFT,
7982 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
7985 static struct scroll_bar
*
7986 x_scroll_bar_create (w
, top
, left
, width
, height
)
7988 int top
, left
, width
, height
;
7990 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7992 struct scroll_bar
*bar
7993 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
7997 XSETWINDOW (bar
->window
, w
);
7998 XSETINT (bar
->top
, top
);
7999 XSETINT (bar
->left
, left
);
8000 XSETINT (bar
->width
, width
);
8001 XSETINT (bar
->height
, height
);
8002 XSETINT (bar
->start
, 0);
8003 XSETINT (bar
->end
, 0);
8004 bar
->dragging
= Qnil
;
8006 /* Requires geometry to be set before call to create the real window */
8008 hwnd
= my_create_scrollbar (f
, bar
);
8010 if (pfnSetScrollInfo
)
8014 si
.cbSize
= sizeof (si
);
8017 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
8018 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8022 pfnSetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
8026 SetScrollRange (hwnd
, SB_CTL
, 0,
8027 VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
), FALSE
);
8028 SetScrollPos (hwnd
, SB_CTL
, 0, FALSE
);
8031 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
8033 /* Add bar to its frame's list of scroll bars. */
8034 bar
->next
= FRAME_SCROLL_BARS (f
);
8036 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8037 if (! NILP (bar
->next
))
8038 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8046 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
8050 x_scroll_bar_remove (bar
)
8051 struct scroll_bar
*bar
;
8053 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8057 /* Destroy the window. */
8058 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
8060 /* Disassociate this scroll bar from its window. */
8061 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
8066 /* Set the handle of the vertical scroll bar for WINDOW to indicate
8067 that we are displaying PORTION characters out of a total of WHOLE
8068 characters, starting at POSITION. If WINDOW has no scroll bar,
8071 w32_set_vertical_scroll_bar (w
, portion
, whole
, position
)
8073 int portion
, whole
, position
;
8075 struct frame
*f
= XFRAME (w
->frame
);
8076 struct scroll_bar
*bar
;
8077 int top
, height
, left
, sb_left
, width
, sb_width
;
8078 int window_x
, window_y
, window_width
, window_height
;
8080 /* Get window dimensions. */
8081 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
8083 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
8084 height
= window_height
;
8086 /* Compute the left edge of the scroll bar area. */
8087 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8088 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
8090 left
= XFASTINT (w
->left
);
8091 left
*= CANON_X_UNIT (f
);
8092 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
8094 /* Compute the width of the scroll bar which might be less than
8095 the width of the area reserved for the scroll bar. */
8096 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
8097 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
8101 /* Compute the left edge of the scroll bar. */
8102 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
8103 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
8105 sb_left
= left
+ (width
- sb_width
) / 2;
8107 /* Does the scroll bar exist yet? */
8108 if (NILP (w
->vertical_scroll_bar
))
8112 if (width
> 0 && height
> 0)
8114 hdc
= get_frame_dc (f
);
8115 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
8116 release_frame_dc (f
, hdc
);
8120 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
8124 /* It may just need to be moved and resized. */
8127 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
8128 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
8130 /* If already correctly positioned, do nothing. */
8131 if ( XINT (bar
->left
) == sb_left
8132 && XINT (bar
->top
) == top
8133 && XINT (bar
->width
) == sb_width
8134 && XINT (bar
->height
) == height
)
8136 /* Redraw after clear_frame. */
8137 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
8138 InvalidateRect (hwnd
, NULL
, FALSE
);
8144 if (width
&& height
)
8146 hdc
= get_frame_dc (f
);
8147 /* Since Windows scroll bars are smaller than the space reserved
8148 for them on the frame, we have to clear "under" them. */
8149 w32_clear_area (f
, hdc
,
8154 release_frame_dc (f
, hdc
);
8156 /* Make sure scroll bar is "visible" before moving, to ensure the
8157 area of the parent window now exposed will be refreshed. */
8158 my_show_window (f
, hwnd
, SW_HIDE
);
8159 MoveWindow (hwnd
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
8160 top
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
8161 max (height
, 1), TRUE
);
8162 if (pfnSetScrollInfo
)
8166 si
.cbSize
= sizeof (si
);
8167 si
.fMask
= SIF_RANGE
;
8169 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
8170 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8172 pfnSetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
8175 SetScrollRange (hwnd
, SB_CTL
, 0,
8176 VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
), FALSE
);
8177 my_show_window (f
, hwnd
, SW_NORMAL
);
8178 /* InvalidateRect (w, NULL, FALSE); */
8180 /* Remember new settings. */
8181 XSETINT (bar
->left
, sb_left
);
8182 XSETINT (bar
->top
, top
);
8183 XSETINT (bar
->width
, sb_width
);
8184 XSETINT (bar
->height
, height
);
8189 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
8191 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
8195 /* The following three hooks are used when we're doing a thorough
8196 redisplay of the frame. We don't explicitly know which scroll bars
8197 are going to be deleted, because keeping track of when windows go
8198 away is a real pain - "Can you say set-window-configuration, boys
8199 and girls?" Instead, we just assert at the beginning of redisplay
8200 that *all* scroll bars are to be removed, and then save a scroll bar
8201 from the fiery pit when we actually redisplay its window. */
8203 /* Arrange for all scroll bars on FRAME to be removed at the next call
8204 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
8205 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
8208 w32_condemn_scroll_bars (frame
)
8211 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
8212 while (! NILP (FRAME_SCROLL_BARS (frame
)))
8215 bar
= FRAME_SCROLL_BARS (frame
);
8216 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
8217 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
8218 XSCROLL_BAR (bar
)->prev
= Qnil
;
8219 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
8220 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
8221 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
8226 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
8227 Note that WINDOW isn't necessarily condemned at all. */
8230 w32_redeem_scroll_bar (window
)
8231 struct window
*window
;
8233 struct scroll_bar
*bar
;
8236 /* We can't redeem this window's scroll bar if it doesn't have one. */
8237 if (NILP (window
->vertical_scroll_bar
))
8240 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
8242 /* Unlink it from the condemned list. */
8243 f
= XFRAME (WINDOW_FRAME (window
));
8244 if (NILP (bar
->prev
))
8246 /* If the prev pointer is nil, it must be the first in one of
8248 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
8249 /* It's not condemned. Everything's fine. */
8251 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
8252 window
->vertical_scroll_bar
))
8253 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
8255 /* If its prev pointer is nil, it must be at the front of
8256 one or the other! */
8260 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
8262 if (! NILP (bar
->next
))
8263 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
8265 bar
->next
= FRAME_SCROLL_BARS (f
);
8267 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8268 if (! NILP (bar
->next
))
8269 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8272 /* Remove all scroll bars on FRAME that haven't been saved since the
8273 last call to `*condemn_scroll_bars_hook'. */
8276 w32_judge_scroll_bars (f
)
8279 Lisp_Object bar
, next
;
8281 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
8283 /* Clear out the condemned list now so we won't try to process any
8284 more events on the hapless scroll bars. */
8285 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
8287 for (; ! NILP (bar
); bar
= next
)
8289 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
8291 x_scroll_bar_remove (b
);
8294 b
->next
= b
->prev
= Qnil
;
8297 /* Now there should be no references to the condemned scroll bars,
8298 and they should get garbage-collected. */
8301 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
8302 is set to something other than no_event, it is enqueued.
8304 This may be called from a signal handler, so we have to ignore GC
8308 w32_scroll_bar_handle_click (bar
, msg
, emacs_event
)
8309 struct scroll_bar
*bar
;
8311 struct input_event
*emacs_event
;
8313 if (! GC_WINDOWP (bar
->window
))
8316 emacs_event
->kind
= w32_scroll_bar_click
;
8317 emacs_event
->code
= 0;
8318 /* not really meaningful to distinguish up/down */
8319 emacs_event
->modifiers
= msg
->dwModifiers
;
8320 emacs_event
->frame_or_window
= bar
->window
;
8321 emacs_event
->arg
= Qnil
;
8322 emacs_event
->timestamp
= msg
->msg
.time
;
8325 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8327 int dragging
= !NILP (bar
->dragging
);
8329 if (pfnGetScrollInfo
)
8333 si
.cbSize
= sizeof (si
);
8336 pfnGetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
8340 y
= GetScrollPos ((HWND
) msg
->msg
.lParam
, SB_CTL
);
8342 bar
->dragging
= Qnil
;
8345 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
8347 switch (LOWORD (msg
->msg
.wParam
))
8350 emacs_event
->part
= scroll_bar_down_arrow
;
8353 emacs_event
->part
= scroll_bar_up_arrow
;
8356 emacs_event
->part
= scroll_bar_above_handle
;
8359 emacs_event
->part
= scroll_bar_below_handle
;
8362 emacs_event
->part
= scroll_bar_handle
;
8366 emacs_event
->part
= scroll_bar_handle
;
8370 case SB_THUMBPOSITION
:
8371 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
8372 y
= HIWORD (msg
->msg
.wParam
);
8374 emacs_event
->part
= scroll_bar_handle
;
8376 /* "Silently" update current position. */
8377 if (pfnSetScrollInfo
)
8381 si
.cbSize
= sizeof (si
);
8384 /* Remember apparent position (we actually lag behind the real
8385 position, so don't set that directly. */
8386 last_scroll_bar_drag_pos
= y
;
8388 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
8391 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, FALSE
);
8394 /* If this is the end of a drag sequence, then reset the scroll
8395 handle size to normal and do a final redraw. Otherwise do
8399 if (pfnSetScrollInfo
)
8402 int start
= XINT (bar
->start
);
8403 int end
= XINT (bar
->end
);
8405 si
.cbSize
= sizeof (si
);
8406 si
.fMask
= SIF_PAGE
| SIF_POS
;
8407 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
8408 si
.nPos
= last_scroll_bar_drag_pos
;
8409 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
8412 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, TRUE
);
8416 emacs_event
->kind
= no_event
;
8420 XSETINT (emacs_event
->x
, y
);
8421 XSETINT (emacs_event
->y
, top_range
);
8427 /* Return information to the user about the current position of the mouse
8428 on the scroll bar. */
8431 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
8433 Lisp_Object
*bar_window
;
8434 enum scroll_bar_part
*part
;
8436 unsigned long *time
;
8438 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
8439 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
8440 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
8442 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8447 *bar_window
= bar
->window
;
8449 if (pfnGetScrollInfo
)
8453 si
.cbSize
= sizeof (si
);
8454 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
8456 pfnGetScrollInfo (w
, SB_CTL
, &si
);
8458 top_range
= si
.nMax
- si
.nPage
+ 1;
8461 pos
= GetScrollPos (w
, SB_CTL
);
8463 switch (LOWORD (last_mouse_scroll_bar_pos
))
8465 case SB_THUMBPOSITION
:
8467 *part
= scroll_bar_handle
;
8468 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
8469 pos
= HIWORD (last_mouse_scroll_bar_pos
);
8472 *part
= scroll_bar_handle
;
8476 *part
= scroll_bar_handle
;
8481 XSETINT (*y
, top_range
);
8484 last_mouse_scroll_bar
= Qnil
;
8486 *time
= last_mouse_movement_time
;
8492 /* The screen has been cleared so we may have changed foreground or
8493 background colors, and the scroll bars may need to be redrawn.
8494 Clear out the scroll bars, and ask for expose events, so we can
8498 x_scroll_bar_clear (f
)
8503 /* We can have scroll bars even if this is 0,
8504 if we just turned off scroll bar mode.
8505 But in that case we should not clear them. */
8506 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
8507 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
8508 bar
= XSCROLL_BAR (bar
)->next
)
8510 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
8511 HDC hdc
= GetDC (window
);
8514 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
8515 arranges to refresh the scroll bar if hidden. */
8516 my_show_window (f
, window
, SW_HIDE
);
8518 GetClientRect (window
, &rect
);
8519 select_palette (f
, hdc
);
8520 w32_clear_rect (f
, hdc
, &rect
);
8521 deselect_palette (f
, hdc
);
8523 ReleaseDC (window
, hdc
);
8528 /* The main W32 event-reading loop - w32_read_socket. */
8530 /* Record the last 100 characters stored
8531 to help debug the loss-of-chars-during-GC problem. */
8533 static int temp_index
;
8534 static short temp_buffer
[100];
8537 /* Read events coming from the W32 shell.
8538 This routine is called by the SIGIO handler.
8539 We return as soon as there are no more events to be read.
8541 Events representing keys are stored in buffer BUFP,
8542 which can hold up to NUMCHARS characters.
8543 We return the number of characters stored into the buffer,
8544 thus pretending to be `read'.
8546 EXPECTED is nonzero if the caller knows input is available.
8548 Some of these messages are reposted back to the message queue since the
8549 system calls the windows proc directly in a context where we cannot return
8550 the data nor can we guarantee the state we are in. So if we dispatch them
8551 we will get into an infinite loop. To prevent this from ever happening we
8552 will set a variable to indicate we are in the read_socket call and indicate
8553 which message we are processing since the windows proc gets called
8554 recursively with different messages by the system.
8558 w32_read_socket (sd
, bufp
, numchars
, expected
)
8560 /* register */ struct input_event
*bufp
;
8561 /* register */ int numchars
;
8565 int check_visibility
= 0;
8568 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
8570 if (interrupt_input_blocked
)
8572 interrupt_input_pending
= 1;
8576 interrupt_input_pending
= 0;
8579 /* So people can tell when we have read the available input. */
8580 input_signal_count
++;
8583 abort (); /* Don't think this happens. */
8585 /* TODO: tool-bars, ghostscript integration, mouse
8587 while (get_next_msg (&msg
, FALSE
))
8589 switch (msg
.msg
.message
)
8592 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8596 if (msg
.rect
.right
== msg
.rect
.left
||
8597 msg
.rect
.bottom
== msg
.rect
.top
)
8599 /* We may get paint messages even though the client
8600 area is clipped - these are not expose events. */
8601 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
8602 XSTRING (f
->name
)->data
));
8604 else if (f
->async_visible
!= 1)
8606 /* Definitely not obscured, so mark as visible. */
8607 f
->async_visible
= 1;
8608 f
->async_iconified
= 0;
8609 SET_FRAME_GARBAGED (f
);
8610 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
8611 XSTRING (f
->name
)->data
));
8613 /* WM_PAINT serves as MapNotify as well, so report
8614 visibility changes properly. */
8617 bufp
->kind
= deiconify_event
;
8618 XSETFRAME (bufp
->frame_or_window
, f
);
8624 else if (! NILP (Vframe_list
)
8625 && ! NILP (XCDR (Vframe_list
)))
8626 /* Force a redisplay sooner or later to update the
8627 frame titles in case this is the second frame. */
8628 record_asynch_buffer_change ();
8632 HDC hdc
= get_frame_dc (f
);
8634 /* Erase background again for safety. */
8635 w32_clear_rect (f
, hdc
, &msg
.rect
);
8636 release_frame_dc (f
, hdc
);
8640 msg
.rect
.right
- msg
.rect
.left
,
8641 msg
.rect
.bottom
- msg
.rect
.top
);
8646 case WM_INPUTLANGCHANGE
:
8647 /* Generate a language change event. */
8648 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8655 bufp
->kind
= language_change_event
;
8656 XSETFRAME (bufp
->frame_or_window
, f
);
8658 bufp
->code
= msg
.msg
.wParam
;
8659 bufp
->modifiers
= msg
.msg
.lParam
& 0xffff;
8668 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8670 if (f
&& !f
->iconified
)
8672 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
8674 dpyinfo
->mouse_face_hidden
= 1;
8675 clear_mouse_face (dpyinfo
);
8678 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
8680 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
8681 bufp
->kind
= non_ascii_keystroke
;
8682 bufp
->code
= msg
.msg
.wParam
;
8683 bufp
->modifiers
= msg
.dwModifiers
;
8684 XSETFRAME (bufp
->frame_or_window
, f
);
8686 bufp
->timestamp
= msg
.msg
.time
;
8695 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8697 if (f
&& !f
->iconified
)
8699 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
8701 dpyinfo
->mouse_face_hidden
= 1;
8702 clear_mouse_face (dpyinfo
);
8705 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
8707 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
8708 bufp
->kind
= ascii_keystroke
;
8709 bufp
->code
= msg
.msg
.wParam
;
8710 bufp
->modifiers
= msg
.dwModifiers
;
8711 XSETFRAME (bufp
->frame_or_window
, f
);
8713 bufp
->timestamp
= msg
.msg
.time
;
8721 previous_help_echo
= help_echo
;
8722 help_echo_object
= help_echo_window
= Qnil
;
8725 if (dpyinfo
->grabbed
&& last_mouse_frame
8726 && FRAME_LIVE_P (last_mouse_frame
))
8727 f
= last_mouse_frame
;
8729 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8731 if (dpyinfo
->mouse_face_hidden
)
8733 dpyinfo
->mouse_face_hidden
= 0;
8734 clear_mouse_face (dpyinfo
);
8738 note_mouse_movement (f
, &msg
.msg
);
8741 /* If we move outside the frame, then we're
8742 certainly no longer on any text in the frame. */
8743 clear_mouse_face (dpyinfo
);
8746 /* If the contents of the global variable help_echo
8747 has changed, generate a HELP_EVENT. */
8748 if (help_echo
!= previous_help_echo
)
8754 XSETFRAME (frame
, f
);
8758 any_help_event_p
= 1;
8759 n
= gen_help_event (bufp
, numchars
, help_echo
, frame
,
8760 help_echo_window
, help_echo_object
,
8762 bufp
+= n
, count
+= n
, numchars
-= n
;
8766 case WM_LBUTTONDOWN
:
8768 case WM_MBUTTONDOWN
:
8770 case WM_RBUTTONDOWN
:
8772 case WM_XBUTTONDOWN
:
8775 /* If we decide we want to generate an event to be seen
8776 by the rest of Emacs, we put it here. */
8777 struct input_event emacs_event
;
8782 emacs_event
.kind
= no_event
;
8784 if (dpyinfo
->grabbed
&& last_mouse_frame
8785 && FRAME_LIVE_P (last_mouse_frame
))
8786 f
= last_mouse_frame
;
8788 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8792 construct_mouse_click (&emacs_event
, &msg
, f
);
8794 /* Is this in the tool-bar? */
8795 if (WINDOWP (f
->tool_bar_window
)
8796 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
))
8802 window
= window_from_coordinates (f
,
8806 if (EQ (window
, f
->tool_bar_window
))
8808 w32_handle_tool_bar_click (f
, &emacs_event
);
8814 if (!dpyinfo
->w32_focus_frame
8815 || f
== dpyinfo
->w32_focus_frame
8818 construct_mouse_click (bufp
, &msg
, f
);
8825 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
8830 dpyinfo
->grabbed
&= ~ (1 << button
);
8834 dpyinfo
->grabbed
|= (1 << button
);
8835 last_mouse_frame
= f
;
8836 /* Ignore any mouse motion that happened
8837 before this event; any subsequent mouse-movement
8838 Emacs events should reflect only motion after
8844 last_tool_bar_item
= -1;
8850 if (dpyinfo
->grabbed
&& last_mouse_frame
8851 && FRAME_LIVE_P (last_mouse_frame
))
8852 f
= last_mouse_frame
;
8854 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8858 if ((!dpyinfo
->w32_focus_frame
8859 || f
== dpyinfo
->w32_focus_frame
)
8862 construct_mouse_wheel (bufp
, &msg
, f
);
8871 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8875 construct_drag_n_drop (bufp
, &msg
, f
);
8884 struct scroll_bar
*bar
=
8885 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
8887 if (bar
&& numchars
>= 1)
8889 if (w32_scroll_bar_handle_click (bar
, &msg
, bufp
))
8899 case WM_WINDOWPOSCHANGED
:
8900 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8903 x_check_fullscreen_move(f
);
8904 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_WAIT
)
8905 f
->output_data
.w32
->want_fullscreen
&=
8906 ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
8908 check_visibility
= 1;
8912 case WM_ACTIVATEAPP
:
8913 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8915 x_check_fullscreen (f
);
8916 check_visibility
= 1;
8920 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8922 if (f
&& !f
->async_iconified
)
8926 x_real_positions (f
, &x
, &y
);
8927 f
->output_data
.w32
->left_pos
= x
;
8928 f
->output_data
.w32
->top_pos
= y
;
8931 check_visibility
= 1;
8935 /* wParam non-zero means Window is about to be shown, 0 means
8936 about to be hidden. */
8937 /* Redo the mouse-highlight after the tooltip has gone. */
8938 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
8941 redo_mouse_highlight ();
8944 /* If window has been obscured or exposed by another window
8945 being maximised or minimised/restored, then recheck
8946 visibility of all frames. Direct changes to our own
8947 windows get handled by WM_SIZE. */
8949 if (msg
.msg
.lParam
!= 0)
8950 check_visibility
= 1;
8953 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8954 f
->async_visible
= msg
.msg
.wParam
;
8958 check_visibility
= 1;
8962 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8964 /* Inform lisp of whether frame has been iconified etc. */
8967 switch (msg
.msg
.wParam
)
8969 case SIZE_MINIMIZED
:
8970 f
->async_visible
= 0;
8971 f
->async_iconified
= 1;
8973 bufp
->kind
= iconify_event
;
8974 XSETFRAME (bufp
->frame_or_window
, f
);
8981 case SIZE_MAXIMIZED
:
8983 f
->async_visible
= 1;
8984 f
->async_iconified
= 0;
8986 /* wait_reading_process_input will notice this and update
8987 the frame's display structures. */
8988 SET_FRAME_GARBAGED (f
);
8994 /* Reset top and left positions of the Window
8995 here since Windows sends a WM_MOVE message
8996 BEFORE telling us the Window is minimized
8997 when the Window is iconified, with 3000,3000
8999 x_real_positions (f
, &x
, &y
);
9000 f
->output_data
.w32
->left_pos
= x
;
9001 f
->output_data
.w32
->top_pos
= y
;
9003 bufp
->kind
= deiconify_event
;
9004 XSETFRAME (bufp
->frame_or_window
, f
);
9010 else if (! NILP (Vframe_list
)
9011 && ! NILP (XCDR (Vframe_list
)))
9012 /* Force a redisplay sooner or later
9013 to update the frame titles
9014 in case this is the second frame. */
9015 record_asynch_buffer_change ();
9020 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
9028 GetClientRect (msg
.msg
.hwnd
, &rect
);
9030 height
= rect
.bottom
- rect
.top
;
9031 width
= rect
.right
- rect
.left
;
9033 rows
= PIXEL_TO_CHAR_HEIGHT (f
, height
);
9034 columns
= PIXEL_TO_CHAR_WIDTH (f
, width
);
9036 /* TODO: Clip size to the screen dimensions. */
9038 /* Even if the number of character rows and columns has
9039 not changed, the font size may have changed, so we need
9040 to check the pixel dimensions as well. */
9042 if (columns
!= f
->width
9043 || rows
!= f
->height
9044 || width
!= f
->output_data
.w32
->pixel_width
9045 || height
!= f
->output_data
.w32
->pixel_height
)
9047 change_frame_size (f
, rows
, columns
, 0, 1, 0);
9048 SET_FRAME_GARBAGED (f
);
9049 cancel_mouse_face (f
);
9050 f
->output_data
.w32
->pixel_width
= width
;
9051 f
->output_data
.w32
->pixel_height
= height
;
9052 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
9056 check_visibility
= 1;
9060 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9063 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9065 /* If we move outside the frame, then we're
9066 certainly no longer on any text in the frame. */
9067 clear_mouse_face (dpyinfo
);
9068 dpyinfo
->mouse_face_mouse_frame
= 0;
9071 /* Generate a nil HELP_EVENT to cancel a help-echo.
9072 Do it only if there's something to cancel.
9073 Otherwise, the startup message is cleared when
9074 the mouse leaves the frame. */
9075 if (any_help_event_p
)
9080 XSETFRAME (frame
, f
);
9082 n
= gen_help_event (bufp
, numchars
,
9083 Qnil
, frame
, Qnil
, Qnil
, 0);
9084 bufp
+= n
, count
+= n
, numchars
-= n
;
9090 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9092 dpyinfo
->w32_focus_event_frame
= f
;
9095 x_new_focus_frame (dpyinfo
, f
);
9098 dpyinfo
->grabbed
= 0;
9099 check_visibility
= 1;
9103 /* TODO: some of this belongs in MOUSE_LEAVE */
9104 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9108 if (f
== dpyinfo
->w32_focus_event_frame
)
9109 dpyinfo
->w32_focus_event_frame
= 0;
9111 if (f
== dpyinfo
->w32_focus_frame
)
9112 x_new_focus_frame (dpyinfo
, 0);
9114 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9116 /* If we move outside the frame, then we're
9117 certainly no longer on any text in the frame. */
9118 clear_mouse_face (dpyinfo
);
9119 dpyinfo
->mouse_face_mouse_frame
= 0;
9122 /* Generate a nil HELP_EVENT to cancel a help-echo.
9123 Do it only if there's something to cancel.
9124 Otherwise, the startup message is cleared when
9125 the mouse leaves the frame. */
9126 if (any_help_event_p
)
9131 XSETFRAME (frame
, f
);
9133 n
= gen_help_event (bufp
, numchars
,
9134 Qnil
, frame
, Qnil
, Qnil
, 0);
9135 bufp
+= n
, count
+= n
, numchars
-=n
;
9139 dpyinfo
->grabbed
= 0;
9140 check_visibility
= 1;
9144 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9151 bufp
->kind
= delete_window_event
;
9152 XSETFRAME (bufp
->frame_or_window
, f
);
9161 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9168 bufp
->kind
= menu_bar_activate_event
;
9169 XSETFRAME (bufp
->frame_or_window
, f
);
9178 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9182 extern void menubar_selection_callback
9183 (FRAME_PTR f
, void * client_data
);
9184 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
9187 check_visibility
= 1;
9190 case WM_DISPLAYCHANGE
:
9191 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9195 dpyinfo
->width
= (short) LOWORD (msg
.msg
.lParam
);
9196 dpyinfo
->height
= (short) HIWORD (msg
.msg
.lParam
);
9197 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
9198 DebPrint (("display change: %d %d\n", dpyinfo
->width
,
9202 check_visibility
= 1;
9206 /* Check for messages registered at runtime. */
9207 if (msg
.msg
.message
== msh_mousewheel
)
9209 if (dpyinfo
->grabbed
&& last_mouse_frame
9210 && FRAME_LIVE_P (last_mouse_frame
))
9211 f
= last_mouse_frame
;
9213 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
9217 if ((!dpyinfo
->w32_focus_frame
9218 || f
== dpyinfo
->w32_focus_frame
)
9221 construct_mouse_wheel (bufp
, &msg
, f
);
9232 /* If the focus was just given to an autoraising frame,
9234 /* ??? This ought to be able to handle more than one such frame. */
9235 if (pending_autoraise_frame
)
9237 x_raise_frame (pending_autoraise_frame
);
9238 pending_autoraise_frame
= 0;
9241 /* Check which frames are still visisble, if we have enqueued any user
9242 events or been notified of events that may affect visibility. We
9243 do this here because there doesn't seem to be any direct
9244 notification from Windows that the visibility of a window has
9245 changed (at least, not in all cases). */
9246 if (count
> 0 || check_visibility
)
9248 Lisp_Object tail
, frame
;
9250 FOR_EACH_FRAME (tail
, frame
)
9252 FRAME_PTR f
= XFRAME (frame
);
9253 /* The tooltip has been drawn already. Avoid the
9254 SET_FRAME_GARBAGED below. */
9255 if (EQ (frame
, tip_frame
))
9258 /* Check "visible" frames and mark each as obscured or not.
9259 Note that async_visible is nonzero for unobscured and
9260 obscured frames, but zero for hidden and iconified frames. */
9261 if (FRAME_W32_P (f
) && f
->async_visible
)
9267 /* Query clipping rectangle for the entire window area
9268 (GetWindowDC), not just the client portion (GetDC).
9269 Otherwise, the scrollbars and menubar aren't counted as
9270 part of the visible area of the frame, and we may think
9271 the frame is obscured when really a scrollbar is still
9272 visible and gets WM_PAINT messages above. */
9273 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
9274 GetClipBox (hdc
, &clipbox
);
9275 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
9278 if (clipbox
.right
== clipbox
.left
9279 || clipbox
.bottom
== clipbox
.top
)
9281 /* Frame has become completely obscured so mark as
9282 such (we do this by setting async_visible to 2 so
9283 that FRAME_VISIBLE_P is still true, but redisplay
9285 f
->async_visible
= 2;
9287 if (!FRAME_OBSCURED_P (f
))
9289 DebPrint (("frame %p (%s) obscured\n", f
,
9290 XSTRING (f
->name
)->data
));
9295 /* Frame is not obscured, so mark it as such. */
9296 f
->async_visible
= 1;
9298 if (FRAME_OBSCURED_P (f
))
9300 SET_FRAME_GARBAGED (f
);
9301 DebPrint (("obscured frame %p (%s) found to be visible\n", f
,
9302 XSTRING (f
->name
)->data
));
9304 /* Force a redisplay sooner or later. */
9305 record_asynch_buffer_change ();
9319 /***********************************************************************
9321 ***********************************************************************/
9323 /* Notice if the text cursor of window W has been overwritten by a
9324 drawing operation that outputs glyphs starting at START_X and
9325 ending at END_X in the line given by output_cursor.vpos.
9326 Coordinates are area-relative. END_X < 0 means all the rest
9327 of the line after START_X has been written. */
9330 notice_overwritten_cursor (w
, area
, x0
, x1
, y0
, y1
)
9332 enum glyph_row_area area
;
9335 if (area
== TEXT_AREA
9336 && w
->phys_cursor_on_p
9337 && y0
<= w
->phys_cursor
.y
9338 && y1
>= w
->phys_cursor
.y
+ w
->phys_cursor_height
9339 && x0
<= w
->phys_cursor
.x
9340 && (x1
< 0 || x1
> w
->phys_cursor
.x
))
9341 w
->phys_cursor_on_p
= 0;
9345 /* Set clipping for output in glyph row ROW. W is the window in which
9346 we operate. GC is the graphics context to set clipping in.
9347 WHOLE_LINE_P non-zero means include the areas used for truncation
9348 mark display and alike in the clipping rectangle.
9350 ROW may be a text row or, e.g., a mode line. Text rows must be
9351 clipped to the interior of the window dedicated to text display,
9352 mode lines must be clipped to the whole window. */
9355 w32_clip_to_row (w
, row
, hdc
, whole_line_p
)
9357 struct glyph_row
*row
;
9361 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
9363 int window_x
, window_y
, window_width
, window_height
;
9365 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
9367 clip_rect
.left
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
9368 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
9369 clip_rect
.top
= max (clip_rect
.top
, window_y
);
9370 clip_rect
.right
= clip_rect
.left
+ window_width
;
9371 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
9373 /* If clipping to the whole line, including trunc marks, extend
9374 the rectangle to the left and increase its width. */
9377 clip_rect
.left
-= FRAME_X_LEFT_FRINGE_WIDTH (f
);
9378 clip_rect
.right
+= FRAME_X_FRINGE_WIDTH (f
);
9381 w32_set_clip_rectangle (hdc
, &clip_rect
);
9385 /* Draw a hollow box cursor on window W in glyph row ROW. */
9388 x_draw_hollow_cursor (w
, row
)
9390 struct glyph_row
*row
;
9392 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
9396 struct glyph
*cursor_glyph
;
9397 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
9399 /* Compute frame-relative coordinates from window-relative
9401 rect
.left
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
9402 rect
.top
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
9403 + row
->ascent
- w
->phys_cursor_ascent
);
9404 rect
.bottom
= rect
.top
+ row
->height
- 1;
9406 /* Get the glyph the cursor is on. If we can't tell because
9407 the current matrix is invalid or such, give up. */
9408 cursor_glyph
= get_phys_cursor_glyph (w
);
9409 if (cursor_glyph
== NULL
)
9412 /* Compute the width of the rectangle to draw. If on a stretch
9413 glyph, and `x-stretch-block-cursor' is nil, don't draw a
9414 rectangle as wide as the glyph, but use a canonical character
9416 wd
= cursor_glyph
->pixel_width
- 1;
9417 if (cursor_glyph
->type
== STRETCH_GLYPH
9418 && !x_stretch_cursor_p
)
9419 wd
= min (CANON_X_UNIT (f
), wd
);
9421 rect
.right
= rect
.left
+ wd
;
9422 hdc
= get_frame_dc (f
);
9423 FrameRect (hdc
, &rect
, hb
);
9426 release_frame_dc (f
, hdc
);
9430 /* Draw a bar cursor on window W in glyph row ROW.
9432 Implementation note: One would like to draw a bar cursor with an
9433 angle equal to the one given by the font property XA_ITALIC_ANGLE.
9434 Unfortunately, I didn't find a font yet that has this property set.
9438 x_draw_bar_cursor (w
, row
, width
)
9440 struct glyph_row
*row
;
9443 struct frame
*f
= XFRAME (w
->frame
);
9444 struct glyph
*cursor_glyph
;
9448 /* If cursor is out of bounds, don't draw garbage. This can happen
9449 in mini-buffer windows when switching between echo area glyphs
9451 cursor_glyph
= get_phys_cursor_glyph (w
);
9452 if (cursor_glyph
== NULL
)
9455 /* If on an image, draw like a normal cursor. That's usually better
9456 visible than drawing a bar, esp. if the image is large so that
9457 the bar might not be in the window. */
9458 if (cursor_glyph
->type
== IMAGE_GLYPH
)
9460 struct glyph_row
*row
;
9461 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
9462 x_draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
9466 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
9467 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
9470 width
= f
->output_data
.w32
->cursor_width
;
9472 /* If the glyph's background equals the color we normally draw
9473 the bar cursor in, the bar cursor in its normal color is
9474 invisible. Use the glyph's foreground color instead in this
9475 case, on the assumption that the glyph's colors are chosen so
9476 that the glyph is legible. */
9477 if (face
->background
== cursor_color
)
9478 cursor_color
= face
->foreground
;
9480 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
9481 hdc
= get_frame_dc (f
);
9482 w32_clip_to_row (w
, row
, hdc
, 0);
9483 w32_fill_area (f
, hdc
, cursor_color
, x
,
9484 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
9485 min (cursor_glyph
->pixel_width
, width
),
9487 release_frame_dc (f
, hdc
);
9492 /* Clear the cursor of window W to background color, and mark the
9493 cursor as not shown. This is used when the text where the cursor
9494 is is about to be rewritten. */
9500 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
9501 x_update_window_cursor (w
, 0);
9505 /* Draw the cursor glyph of window W in glyph row ROW. See the
9506 comment of x_draw_glyphs for the meaning of HL. */
9509 x_draw_phys_cursor_glyph (w
, row
, hl
)
9511 struct glyph_row
*row
;
9512 enum draw_glyphs_face hl
;
9514 /* If cursor hpos is out of bounds, don't draw garbage. This can
9515 happen in mini-buffer windows when switching between echo area
9516 glyphs and mini-buffer. */
9517 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
9519 int on_p
= w
->phys_cursor_on_p
;
9520 x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
9521 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
9523 w
->phys_cursor_on_p
= on_p
;
9525 /* When we erase the cursor, and ROW is overlapped by other
9526 rows, make sure that these overlapping parts of other rows
9528 if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
9530 if (row
> w
->current_matrix
->rows
9531 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
9532 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
9534 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
9535 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
9536 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
9542 /* Erase the image of a cursor of window W from the screen. */
9545 x_erase_phys_cursor (w
)
9548 struct frame
*f
= XFRAME (w
->frame
);
9549 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
9550 int hpos
= w
->phys_cursor
.hpos
;
9551 int vpos
= w
->phys_cursor
.vpos
;
9552 int mouse_face_here_p
= 0;
9553 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
9554 struct glyph_row
*cursor_row
;
9555 struct glyph
*cursor_glyph
;
9556 enum draw_glyphs_face hl
;
9558 /* No cursor displayed or row invalidated => nothing to do on the
9560 if (w
->phys_cursor_type
== NO_CURSOR
)
9561 goto mark_cursor_off
;
9563 /* VPOS >= active_glyphs->nrows means that window has been resized.
9564 Don't bother to erase the cursor. */
9565 if (vpos
>= active_glyphs
->nrows
)
9566 goto mark_cursor_off
;
9568 /* If row containing cursor is marked invalid, there is nothing we
9570 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
9571 if (!cursor_row
->enabled_p
)
9572 goto mark_cursor_off
;
9574 /* If row is completely invisible, don't attempt to delete a cursor which
9575 isn't there. This may happen if cursor is at top of window, and
9576 we switch to a buffer with a header line in that window. */
9577 if (cursor_row
->visible_height
<= 0)
9578 goto mark_cursor_off
;
9580 /* This can happen when the new row is shorter than the old one.
9581 In this case, either x_draw_glyphs or clear_end_of_line
9582 should have cleared the cursor. Note that we wouldn't be
9583 able to erase the cursor in this case because we don't have a
9584 cursor glyph at hand. */
9585 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
9586 goto mark_cursor_off
;
9588 /* If the cursor is in the mouse face area, redisplay that when
9589 we clear the cursor. */
9590 if (! NILP (dpyinfo
->mouse_face_window
)
9591 && w
== XWINDOW (dpyinfo
->mouse_face_window
)
9592 && (vpos
> dpyinfo
->mouse_face_beg_row
9593 || (vpos
== dpyinfo
->mouse_face_beg_row
9594 && hpos
>= dpyinfo
->mouse_face_beg_col
))
9595 && (vpos
< dpyinfo
->mouse_face_end_row
9596 || (vpos
== dpyinfo
->mouse_face_end_row
9597 && hpos
< dpyinfo
->mouse_face_end_col
))
9598 /* Don't redraw the cursor's spot in mouse face if it is at the
9599 end of a line (on a newline). The cursor appears there, but
9600 mouse highlighting does not. */
9601 && cursor_row
->used
[TEXT_AREA
] > hpos
)
9602 mouse_face_here_p
= 1;
9604 /* Maybe clear the display under the cursor. */
9605 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
9608 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
9611 cursor_glyph
= get_phys_cursor_glyph (w
);
9612 if (cursor_glyph
== NULL
)
9613 goto mark_cursor_off
;
9615 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
9617 hdc
= get_frame_dc (f
);
9618 w32_clear_area (f
, hdc
, x
,
9619 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
9621 cursor_glyph
->pixel_width
,
9622 cursor_row
->visible_height
);
9623 release_frame_dc (f
, hdc
);
9626 /* Erase the cursor by redrawing the character underneath it. */
9627 if (mouse_face_here_p
)
9628 hl
= DRAW_MOUSE_FACE
;
9630 hl
= DRAW_NORMAL_TEXT
;
9631 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
9634 w
->phys_cursor_on_p
= 0;
9635 w
->phys_cursor_type
= NO_CURSOR
;
9639 /* Non-zero if physical cursor of window W is within mouse face. */
9642 cursor_in_mouse_face_p (w
)
9645 struct w32_display_info
*dpyinfo
9646 = FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
9647 int in_mouse_face
= 0;
9649 if (WINDOWP (dpyinfo
->mouse_face_window
)
9650 && XWINDOW (dpyinfo
->mouse_face_window
) == w
)
9652 int hpos
= w
->phys_cursor
.hpos
;
9653 int vpos
= w
->phys_cursor
.vpos
;
9655 if (vpos
>= dpyinfo
->mouse_face_beg_row
9656 && vpos
<= dpyinfo
->mouse_face_end_row
9657 && (vpos
> dpyinfo
->mouse_face_beg_row
9658 || hpos
>= dpyinfo
->mouse_face_beg_col
)
9659 && (vpos
< dpyinfo
->mouse_face_end_row
9660 || hpos
< dpyinfo
->mouse_face_end_col
9661 || dpyinfo
->mouse_face_past_end
))
9665 return in_mouse_face
;
9669 /* Display or clear cursor of window W. If ON is zero, clear the
9670 cursor. If it is non-zero, display the cursor. If ON is nonzero,
9671 where to put the cursor is specified by HPOS, VPOS, X and Y. */
9674 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
9676 int on
, hpos
, vpos
, x
, y
;
9678 struct frame
*f
= XFRAME (w
->frame
);
9679 int new_cursor_type
;
9680 int new_cursor_width
;
9681 struct glyph_matrix
*current_glyphs
;
9682 struct glyph_row
*glyph_row
;
9683 struct glyph
*glyph
;
9684 int cursor_non_selected
;
9685 int active_cursor
= 1;
9687 /* This is pointless on invisible frames, and dangerous on garbaged
9688 windows and frames; in the latter case, the frame or window may
9689 be in the midst of changing its size, and x and y may be off the
9691 if (! FRAME_VISIBLE_P (f
)
9692 || FRAME_GARBAGED_P (f
)
9693 || vpos
>= w
->current_matrix
->nrows
9694 || hpos
>= w
->current_matrix
->matrix_w
)
9697 /* If cursor is off and we want it off, return quickly. */
9698 if (!on
&& !w
->phys_cursor_on_p
)
9701 current_glyphs
= w
->current_matrix
;
9702 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
9703 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
9705 /* If cursor row is not enabled, we don't really know where to
9706 display the cursor. */
9707 if (!glyph_row
->enabled_p
)
9709 w
->phys_cursor_on_p
= 0;
9713 xassert (interrupt_input_blocked
);
9715 /* Set new_cursor_type to the cursor we want to be displayed. In a
9716 mini-buffer window, we want the cursor only to appear if we are
9717 reading input from this window. For the selected window, we want
9718 the cursor type given by the frame parameter. If explicitly
9719 marked off, draw no cursor. In all other cases, we want a hollow
9722 = !NILP (Fbuffer_local_value (Qcursor_in_non_selected_windows
,
9724 new_cursor_width
= -1;
9725 if (cursor_in_echo_area
9726 && FRAME_HAS_MINIBUF_P (f
)
9727 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
9729 if (w
== XWINDOW (echo_area_window
))
9730 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
9733 if (cursor_non_selected
)
9734 new_cursor_type
= HOLLOW_BOX_CURSOR
;
9736 new_cursor_type
= NO_CURSOR
;
9742 if (f
!= FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
9743 || w
!= XWINDOW (f
->selected_window
))
9747 if (MINI_WINDOW_P (w
)
9748 || !cursor_non_selected
9749 || NILP (XBUFFER (w
->buffer
)->cursor_type
))
9750 new_cursor_type
= NO_CURSOR
;
9752 new_cursor_type
= HOLLOW_BOX_CURSOR
;
9754 else if (w
->cursor_off_p
)
9755 new_cursor_type
= NO_CURSOR
;
9758 struct buffer
*b
= XBUFFER (w
->buffer
);
9760 if (EQ (b
->cursor_type
, Qt
))
9761 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
9763 new_cursor_type
= x_specified_cursor_type (b
->cursor_type
,
9768 /* If cursor is currently being shown and we don't want it to be or
9769 it is in the wrong place, or the cursor type is not what we want,
9771 if (w
->phys_cursor_on_p
9773 || w
->phys_cursor
.x
!= x
9774 || w
->phys_cursor
.y
!= y
9775 || new_cursor_type
!= w
->phys_cursor_type
))
9776 x_erase_phys_cursor (w
);
9778 /* If the cursor is now invisible and we want it to be visible,
9780 if (on
&& !w
->phys_cursor_on_p
)
9782 w
->phys_cursor_ascent
= glyph_row
->ascent
;
9783 w
->phys_cursor_height
= glyph_row
->height
;
9785 /* Set phys_cursor_.* before x_draw_.* is called because some
9786 of them may need the information. */
9787 w
->phys_cursor
.x
= x
;
9788 w
->phys_cursor
.y
= glyph_row
->y
;
9789 w
->phys_cursor
.hpos
= hpos
;
9790 w
->phys_cursor
.vpos
= vpos
;
9792 /* If the user wants to use the system caret, make sure our own
9793 cursor remains invisible. */
9794 if (w32_use_visible_system_caret
)
9796 if (w
->phys_cursor_type
!= NO_CURSOR
)
9797 x_erase_phys_cursor (w
);
9799 new_cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
9802 w
->phys_cursor_type
= new_cursor_type
;
9804 w
->phys_cursor_on_p
= 1;
9806 /* If this is the active cursor, we need to track it with the
9807 system caret, so third party software like screen magnifiers
9808 and speech synthesizers can follow the cursor. */
9811 HWND hwnd
= FRAME_W32_WINDOW (f
);
9814 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
9816 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
9817 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
9819 /* If the size of the active cursor changed, destroy the old
9821 if (w32_system_caret_hwnd
9822 && (w32_system_caret_height
!= w
->phys_cursor_height
))
9823 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
9825 w32_system_caret_height
= w
->phys_cursor_height
;
9827 /* Move the system caret. */
9828 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
9831 switch (new_cursor_type
)
9833 case HOLLOW_BOX_CURSOR
:
9834 x_draw_hollow_cursor (w
, glyph_row
);
9837 case FILLED_BOX_CURSOR
:
9838 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
9842 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
);
9855 /* Display the cursor on window W, or clear it. X and Y are window
9856 relative pixel coordinates. HPOS and VPOS are glyph matrix
9857 positions. If W is not the selected window, display a hollow
9858 cursor. ON non-zero means display the cursor at X, Y which
9859 correspond to HPOS, VPOS, otherwise it is cleared. */
9862 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
9864 int on
, hpos
, vpos
, x
, y
;
9867 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
9872 /* Display the cursor on window W, or clear it, according to ON_P.
9873 Don't change the cursor's position. */
9876 x_update_cursor (f
, on_p
)
9880 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
9884 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
9885 in the window tree rooted at W. */
9888 x_update_cursor_in_window_tree (w
, on_p
)
9894 if (!NILP (w
->hchild
))
9895 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
9896 else if (!NILP (w
->vchild
))
9897 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
9899 x_update_window_cursor (w
, on_p
);
9901 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
9906 /* Switch the display of W's cursor on or off, according to the value
9910 x_update_window_cursor (w
, on
)
9914 /* Don't update cursor in windows whose frame is in the process
9915 of being deleted. */
9916 if (w
->current_matrix
)
9919 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
,
9920 w
->phys_cursor
.vpos
, w
->phys_cursor
.x
,
9932 x_bitmap_icon (f
, icon
)
9938 if (FRAME_W32_WINDOW (f
) == 0)
9942 hicon
= LoadIcon (hinst
, EMACS_CLASS
);
9943 else if (STRINGP (icon
))
9944 hicon
= LoadImage (NULL
, (LPCTSTR
) XSTRING (icon
)->data
, IMAGE_ICON
, 0, 0,
9945 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
9946 else if (SYMBOLP (icon
))
9950 if (EQ (icon
, intern ("application")))
9951 name
= (LPCTSTR
) IDI_APPLICATION
;
9952 else if (EQ (icon
, intern ("hand")))
9953 name
= (LPCTSTR
) IDI_HAND
;
9954 else if (EQ (icon
, intern ("question")))
9955 name
= (LPCTSTR
) IDI_QUESTION
;
9956 else if (EQ (icon
, intern ("exclamation")))
9957 name
= (LPCTSTR
) IDI_EXCLAMATION
;
9958 else if (EQ (icon
, intern ("asterisk")))
9959 name
= (LPCTSTR
) IDI_ASTERISK
;
9960 else if (EQ (icon
, intern ("winlogo")))
9961 name
= (LPCTSTR
) IDI_WINLOGO
;
9965 hicon
= LoadIcon (NULL
, name
);
9973 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
9980 /************************************************************************
9982 ************************************************************************/
9984 /* Display Error Handling functions not used on W32. Listing them here
9985 helps diff stay in step when comparing w32term.c with xterm.c.
9987 x_error_catcher (display, error)
9988 x_catch_errors (dpy)
9989 x_catch_errors_unwind (old_val)
9990 x_check_errors (dpy, format)
9991 x_had_errors_p (dpy)
9992 x_clear_errors (dpy)
9993 x_uncatch_errors (dpy, count)
9995 x_connection_signal (signalnum)
9996 x_connection_closed (dpy, error_message)
9997 x_error_quitter (display, error)
9998 x_error_handler (display, error)
9999 x_io_error_quitter (display)
10004 /* Changing the font of the frame. */
10006 /* Give frame F the font named FONTNAME as its default font, and
10007 return the full name of that font. FONTNAME may be a wildcard
10008 pattern; in that case, we choose some font that fits the pattern.
10009 The return value shows which font we chose. */
10012 x_new_font (f
, fontname
)
10014 register char *fontname
;
10016 struct font_info
*fontp
10017 = FS_LOAD_FONT (f
, fontname
);
10022 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
10023 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
10024 FRAME_FONTSET (f
) = -1;
10026 /* Compute the scroll bar width in character columns. */
10027 if (f
->scroll_bar_pixel_width
> 0)
10029 int wid
= FONT_WIDTH (FRAME_FONT (f
));
10030 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
10034 int wid
= FONT_WIDTH (FRAME_FONT (f
));
10035 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
10038 /* Now make the frame display the given font. */
10039 if (FRAME_W32_WINDOW (f
) != 0)
10041 frame_update_line_height (f
);
10042 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
10043 x_set_window_size (f
, 0, f
->width
, f
->height
);
10046 /* If we are setting a new frame's font for the first time,
10047 there are no faces yet, so this font's height is the line height. */
10048 f
->output_data
.w32
->line_height
= FONT_HEIGHT (FRAME_FONT (f
));
10050 return build_string (fontp
->full_name
);
10053 /* Give frame F the fontset named FONTSETNAME as its default font, and
10054 return the full name of that fontset. FONTSETNAME may be a wildcard
10055 pattern; in that case, we choose some fontset that fits the pattern.
10056 The return value shows which fontset we chose. */
10059 x_new_fontset (f
, fontsetname
)
10063 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
10064 Lisp_Object result
;
10069 if (FRAME_FONTSET (f
) == fontset
)
10070 /* This fontset is already set in frame F. There's nothing more
10072 return fontset_name (fontset
);
10074 result
= x_new_font (f
, (XSTRING (fontset_ascii (fontset
))->data
));
10076 if (!STRINGP (result
))
10077 /* Can't load ASCII font. */
10080 /* Since x_new_font doesn't update any fontset information, do it now. */
10081 FRAME_FONTSET(f
) = fontset
;
10083 return build_string (fontsetname
);
10086 /* Compute actual fringe widths */
10089 x_compute_fringe_widths (f
, redraw
)
10093 int o_left
= f
->output_data
.w32
->left_fringe_width
;
10094 int o_right
= f
->output_data
.w32
->right_fringe_width
;
10095 int o_cols
= f
->output_data
.w32
->fringe_cols
;
10097 Lisp_Object left_fringe
= Fassq (Qleft_fringe
, f
->param_alist
);
10098 Lisp_Object right_fringe
= Fassq (Qright_fringe
, f
->param_alist
);
10099 int left_fringe_width
, right_fringe_width
;
10101 if (!NILP (left_fringe
))
10102 left_fringe
= Fcdr (left_fringe
);
10103 if (!NILP (right_fringe
))
10104 right_fringe
= Fcdr (right_fringe
);
10106 left_fringe_width
= ((NILP (left_fringe
) || !INTEGERP (left_fringe
)) ? 8 :
10107 XINT (left_fringe
));
10108 right_fringe_width
= ((NILP (right_fringe
) || !INTEGERP (right_fringe
)) ? 8 :
10109 XINT (right_fringe
));
10111 if (left_fringe_width
|| right_fringe_width
)
10113 int left_wid
= left_fringe_width
>= 0 ? left_fringe_width
: -left_fringe_width
;
10114 int right_wid
= right_fringe_width
>= 0 ? right_fringe_width
: -right_fringe_width
;
10115 int conf_wid
= left_wid
+ right_wid
;
10116 int font_wid
= FONT_WIDTH (f
->output_data
.w32
->font
);
10117 int cols
= (left_wid
+ right_wid
+ font_wid
-1) / font_wid
;
10118 int real_wid
= cols
* font_wid
;
10119 if (left_wid
&& right_wid
)
10121 if (left_fringe_width
< 0)
10123 /* Left fringe width is fixed, adjust right fringe if necessary */
10124 f
->output_data
.w32
->left_fringe_width
= left_wid
;
10125 f
->output_data
.w32
->right_fringe_width
= real_wid
- left_wid
;
10127 else if (right_fringe_width
< 0)
10129 /* Right fringe width is fixed, adjust left fringe if necessary */
10130 f
->output_data
.w32
->left_fringe_width
= real_wid
- right_wid
;
10131 f
->output_data
.w32
->right_fringe_width
= right_wid
;
10135 /* Adjust both fringes with an equal amount.
10136 Note that we are doing integer arithmetic here, so don't
10137 lose a pixel if the total width is an odd number. */
10138 int fill
= real_wid
- conf_wid
;
10139 f
->output_data
.w32
->left_fringe_width
= left_wid
+ fill
/2;
10140 f
->output_data
.w32
->right_fringe_width
= right_wid
+ fill
- fill
/2;
10143 else if (left_fringe_width
)
10145 f
->output_data
.w32
->left_fringe_width
= real_wid
;
10146 f
->output_data
.w32
->right_fringe_width
= 0;
10150 f
->output_data
.w32
->left_fringe_width
= 0;
10151 f
->output_data
.w32
->right_fringe_width
= real_wid
;
10153 f
->output_data
.w32
->fringe_cols
= cols
;
10154 f
->output_data
.w32
->fringes_extra
= real_wid
;
10158 f
->output_data
.w32
->left_fringe_width
= 0;
10159 f
->output_data
.w32
->right_fringe_width
= 0;
10160 f
->output_data
.w32
->fringe_cols
= 0;
10161 f
->output_data
.w32
->fringes_extra
= 0;
10164 if (redraw
&& FRAME_VISIBLE_P (f
))
10165 if (o_left
!= f
->output_data
.w32
->left_fringe_width
||
10166 o_right
!= f
->output_data
.w32
->right_fringe_width
||
10167 o_cols
!= f
->output_data
.w32
->fringe_cols
)
10171 /***********************************************************************
10172 TODO: W32 Input Methods
10173 ***********************************************************************/
10174 /* Listing missing functions from xterm.c helps diff stay in step.
10176 xim_destroy_callback (xim, client_data, call_data)
10177 xim_open_dpy (dpyinfo, resource_name)
10179 xim_instantiate_callback (display, client_data, call_data)
10180 xim_initialize (dpyinfo, resource_name)
10181 xim_close_dpy (dpyinfo)
10186 /* Calculate the absolute position in frame F
10187 from its current recorded position values and gravity. */
10190 x_calc_absolute_position (f
)
10194 int flags
= f
->output_data
.w32
->size_hint_flags
;
10198 /* Find the position of the outside upper-left corner of
10199 the inner window, with respect to the outer window.
10200 But do this only if we will need the results. */
10201 if (f
->output_data
.w32
->parent_desc
!= FRAME_W32_DISPLAY_INFO (f
)->root_window
)
10204 MapWindowPoints (FRAME_W32_WINDOW (f
),
10205 f
->output_data
.w32
->parent_desc
,
10212 rt
.left
= rt
.right
= rt
.top
= rt
.bottom
= 0;
10215 AdjustWindowRect(&rt
, f
->output_data
.w32
->dwStyle
,
10216 FRAME_EXTERNAL_MENU_BAR (f
));
10219 pt
.x
+= (rt
.right
- rt
.left
);
10220 pt
.y
+= (rt
.bottom
- rt
.top
);
10223 /* Treat negative positions as relative to the leftmost bottommost
10224 position that fits on the screen. */
10225 if (flags
& XNegative
)
10226 f
->output_data
.w32
->left_pos
= (FRAME_W32_DISPLAY_INFO (f
)->width
10227 - 2 * f
->output_data
.w32
->border_width
- pt
.x
10229 + f
->output_data
.w32
->left_pos
);
10231 if (flags
& YNegative
)
10232 f
->output_data
.w32
->top_pos
= (FRAME_W32_DISPLAY_INFO (f
)->height
10233 - 2 * f
->output_data
.w32
->border_width
- pt
.y
10235 + f
->output_data
.w32
->top_pos
);
10236 /* The left_pos and top_pos
10237 are now relative to the top and left screen edges,
10238 so the flags should correspond. */
10239 f
->output_data
.w32
->size_hint_flags
&= ~ (XNegative
| YNegative
);
10242 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
10243 to really change the position, and 0 when calling from
10244 x_make_frame_visible (in that case, XOFF and YOFF are the current
10245 position values). It is -1 when calling from x_set_frame_parameters,
10246 which means, do adjust for borders but don't change the gravity. */
10249 x_set_offset (f
, xoff
, yoff
, change_gravity
)
10251 register int xoff
, yoff
;
10252 int change_gravity
;
10254 int modified_top
, modified_left
;
10256 if (change_gravity
> 0)
10258 f
->output_data
.w32
->top_pos
= yoff
;
10259 f
->output_data
.w32
->left_pos
= xoff
;
10260 f
->output_data
.w32
->size_hint_flags
&= ~ (XNegative
| YNegative
);
10262 f
->output_data
.w32
->size_hint_flags
|= XNegative
;
10264 f
->output_data
.w32
->size_hint_flags
|= YNegative
;
10265 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
10267 x_calc_absolute_position (f
);
10270 x_wm_set_size_hint (f
, (long) 0, 0);
10272 modified_left
= f
->output_data
.w32
->left_pos
;
10273 modified_top
= f
->output_data
.w32
->top_pos
;
10275 my_set_window_pos (FRAME_W32_WINDOW (f
),
10277 modified_left
, modified_top
,
10279 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
10284 /* Check if we need to resize the frame due to a fullscreen request.
10285 If so needed, resize the frame. */
10287 x_check_fullscreen (f
)
10290 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_BOTH
)
10292 int width
, height
, ign
;
10294 x_real_positions (f
, &f
->output_data
.w32
->left_pos
,
10295 &f
->output_data
.w32
->top_pos
);
10297 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
10299 /* We do not need to move the window, it shall be taken care of
10300 when setting WM manager hints.
10301 If the frame is visible already, the position is checked by
10302 x_check_fullscreen_move. */
10303 if (f
->width
!= width
|| f
->height
!= height
)
10305 change_frame_size (f
, height
, width
, 0, 1, 0);
10306 SET_FRAME_GARBAGED (f
);
10307 cancel_mouse_face (f
);
10309 /* Wait for the change of frame size to occur */
10310 f
->output_data
.w32
->want_fullscreen
|= FULLSCREEN_WAIT
;
10315 /* If frame parameters are set after the frame is mapped, we need to move
10316 the window. This is done in xfns.c.
10317 Some window managers moves the window to the right position, some
10318 moves the outer window manager window to the specified position.
10319 Here we check that we are in the right spot. If not, make a second
10320 move, assuming we are dealing with the second kind of window manager. */
10322 x_check_fullscreen_move (f
)
10325 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_MOVE_WAIT
)
10327 int expect_top
= f
->output_data
.w32
->top_pos
;
10328 int expect_left
= f
->output_data
.w32
->left_pos
;
10330 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_HEIGHT
)
10332 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_WIDTH
)
10335 if (expect_top
!= f
->output_data
.w32
->top_pos
10336 || expect_left
!= f
->output_data
.w32
->left_pos
)
10337 x_set_offset (f
, expect_left
, expect_top
, 1);
10339 /* Just do this once */
10340 f
->output_data
.w32
->want_fullscreen
&= ~FULLSCREEN_MOVE_WAIT
;
10345 /* Calculate fullscreen size. Return in *TOP_POS and *LEFT_POS the
10346 wanted positions of the WM window (not emacs window).
10347 Return in *WIDTH and *HEIGHT the wanted width and height of Emacs
10348 window (FRAME_X_WINDOW).
10351 x_fullscreen_adjust (f
, width
, height
, top_pos
, left_pos
)
10358 int newwidth
= f
->width
, newheight
= f
->height
;
10360 *top_pos
= f
->output_data
.w32
->top_pos
;
10361 *left_pos
= f
->output_data
.w32
->left_pos
;
10363 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_HEIGHT
)
10367 ph
= FRAME_X_DISPLAY_INFO (f
)->height
;
10368 newheight
= PIXEL_TO_CHAR_HEIGHT (f
, ph
);
10369 ph
= CHAR_TO_PIXEL_HEIGHT (f
, newheight
)
10370 - f
->output_data
.w32
->y_pixels_diff
;
10371 newheight
= PIXEL_TO_CHAR_HEIGHT (f
, ph
);
10375 if (f
->output_data
.w32
->want_fullscreen
& FULLSCREEN_WIDTH
)
10379 pw
= FRAME_X_DISPLAY_INFO (f
)->width
;
10380 newwidth
= PIXEL_TO_CHAR_WIDTH (f
, pw
);
10381 pw
= CHAR_TO_PIXEL_WIDTH (f
, newwidth
)
10382 - f
->output_data
.w32
->x_pixels_diff
;
10383 newwidth
= PIXEL_TO_CHAR_WIDTH (f
, pw
);
10388 *height
= newheight
;
10392 /* Call this to change the size of frame F's x-window.
10393 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
10394 for this size change and subsequent size changes.
10395 Otherwise we leave the window gravity unchanged. */
10398 x_set_window_size (f
, change_gravity
, cols
, rows
)
10400 int change_gravity
;
10403 int pixelwidth
, pixelheight
;
10407 check_frame_size (f
, &rows
, &cols
);
10408 f
->output_data
.w32
->vertical_scroll_bar_extra
10409 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
10411 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.w32
->font
)));
10413 x_compute_fringe_widths (f
, 0);
10415 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
10416 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
10418 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
10419 x_wm_set_size_hint (f
, (long) 0, 0);
10424 rect
.left
= rect
.top
= 0;
10425 rect
.right
= pixelwidth
;
10426 rect
.bottom
= pixelheight
;
10428 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
10429 FRAME_EXTERNAL_MENU_BAR (f
));
10431 my_set_window_pos (FRAME_W32_WINDOW (f
),
10434 rect
.right
- rect
.left
,
10435 rect
.bottom
- rect
.top
,
10436 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
10439 /* Now, strictly speaking, we can't be sure that this is accurate,
10440 but the window manager will get around to dealing with the size
10441 change request eventually, and we'll hear how it went when the
10442 ConfigureNotify event gets here.
10444 We could just not bother storing any of this information here,
10445 and let the ConfigureNotify event set everything up, but that
10446 might be kind of confusing to the Lisp code, since size changes
10447 wouldn't be reported in the frame parameters until some random
10448 point in the future when the ConfigureNotify event arrives.
10450 We pass 1 for DELAY since we can't run Lisp code inside of
10452 change_frame_size (f
, rows
, cols
, 0, 1, 0);
10453 PIXEL_WIDTH (f
) = pixelwidth
;
10454 PIXEL_HEIGHT (f
) = pixelheight
;
10456 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
10457 receive in the ConfigureNotify event; if we get what we asked
10458 for, then the event won't cause the screen to become garbaged, so
10459 we have to make sure to do it here. */
10460 SET_FRAME_GARBAGED (f
);
10462 /* If cursor was outside the new size, mark it as off. */
10463 mark_window_cursors_off (XWINDOW (f
->root_window
));
10465 /* Clear out any recollection of where the mouse highlighting was,
10466 since it might be in a place that's outside the new frame size.
10467 Actually checking whether it is outside is a pain in the neck,
10468 so don't try--just let the highlighting be done afresh with new size. */
10469 cancel_mouse_face (f
);
10474 /* Mouse warping. */
10476 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
10479 x_set_mouse_position (f
, x
, y
)
10485 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.w32
->font
) / 2;
10486 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.w32
->line_height
/ 2;
10488 if (pix_x
< 0) pix_x
= 0;
10489 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
10491 if (pix_y
< 0) pix_y
= 0;
10492 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
10494 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
10498 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
10507 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
10508 pt
.x
= rect
.left
+ pix_x
;
10509 pt
.y
= rect
.top
+ pix_y
;
10510 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
10512 SetCursorPos (pt
.x
, pt
.y
);
10518 /* focus shifting, raising and lowering. */
10521 x_focus_on_frame (f
)
10524 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
10526 /* Give input focus to frame. */
10529 /* Try not to change its Z-order if possible. */
10530 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
10531 my_set_focus (f
, FRAME_W32_WINDOW (f
));
10534 my_set_foreground_window (FRAME_W32_WINDOW (f
));
10539 x_unfocus_frame (f
)
10544 /* Raise frame F. */
10551 /* Strictly speaking, raise-frame should only change the frame's Z
10552 order, leaving input focus unchanged. This is reasonable behaviour
10553 on X where the usual policy is point-to-focus. However, this
10554 behaviour would be very odd on Windows where the usual policy is
10557 On X, if the mouse happens to be over the raised frame, it gets
10558 input focus anyway (so the window with focus will never be
10559 completely obscured) - if not, then just moving the mouse over it
10560 is sufficient to give it focus. On Windows, the user must actually
10561 click on the frame (preferrably the title bar so as not to move
10562 point), which is more awkward. Also, no other Windows program
10563 raises a window to the top but leaves another window (possibly now
10564 completely obscured) with input focus.
10566 Because there is a system setting on Windows that allows the user
10567 to choose the point to focus policy, we make the strict semantics
10568 optional, but by default we grab focus when raising. */
10570 if (NILP (Vw32_grab_focus_on_raise
))
10572 /* The obvious call to my_set_window_pos doesn't work if Emacs is
10573 not already the foreground application: the frame is raised
10574 above all other frames belonging to us, but not above the
10575 current top window. To achieve that, we have to resort to this
10576 more cumbersome method. */
10578 HDWP handle
= BeginDeferWindowPos (2);
10581 DeferWindowPos (handle
,
10582 FRAME_W32_WINDOW (f
),
10585 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
10587 DeferWindowPos (handle
,
10588 GetForegroundWindow (),
10589 FRAME_W32_WINDOW (f
),
10591 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
10593 EndDeferWindowPos (handle
);
10598 my_set_foreground_window (FRAME_W32_WINDOW (f
));
10604 /* Lower frame F. */
10610 my_set_window_pos (FRAME_W32_WINDOW (f
),
10613 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
10618 w32_frame_raise_lower (f
, raise_flag
)
10622 if (! FRAME_W32_P (f
))
10631 /* Change of visibility. */
10633 /* This tries to wait until the frame is really visible.
10634 However, if the window manager asks the user where to position
10635 the frame, this will return before the user finishes doing that.
10636 The frame will not actually be visible at that time,
10637 but it will become visible later when the window manager
10638 finishes with it. */
10641 x_make_frame_visible (f
)
10648 type
= x_icon_type (f
);
10650 x_bitmap_icon (f
, type
);
10652 if (! FRAME_VISIBLE_P (f
))
10654 /* We test FRAME_GARBAGED_P here to make sure we don't
10655 call x_set_offset a second time
10656 if we get to x_make_frame_visible a second time
10657 before the window gets really visible. */
10658 if (! FRAME_ICONIFIED_P (f
)
10659 && ! f
->output_data
.w32
->asked_for_visible
)
10660 x_set_offset (f
, f
->output_data
.w32
->left_pos
, f
->output_data
.w32
->top_pos
, 0);
10662 f
->output_data
.w32
->asked_for_visible
= 1;
10664 /* my_show_window (f, FRAME_W32_WINDOW (f), f->async_iconified ? SW_RESTORE : SW_SHOW); */
10665 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_SHOWNORMAL
);
10668 /* Synchronize to ensure Emacs knows the frame is visible
10669 before we do anything else. We do this loop with input not blocked
10670 so that incoming events are handled. */
10675 /* This must come after we set COUNT. */
10678 XSETFRAME (frame
, f
);
10680 /* Wait until the frame is visible. Process X events until a
10681 MapNotify event has been seen, or until we think we won't get a
10682 MapNotify at all.. */
10683 for (count
= input_signal_count
+ 10;
10684 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
10686 /* Force processing of queued events. */
10687 /* TODO: x_sync equivalent? */
10689 /* Machines that do polling rather than SIGIO have been observed
10690 to go into a busy-wait here. So we'll fake an alarm signal
10691 to let the handler know that there's something to be read.
10692 We used to raise a real alarm, but it seems that the handler
10693 isn't always enabled here. This is probably a bug. */
10694 if (input_polling_used ())
10696 /* It could be confusing if a real alarm arrives while processing
10697 the fake one. Turn it off and let the handler reset it. */
10698 int old_poll_suppress_count
= poll_suppress_count
;
10699 poll_suppress_count
= 1;
10700 poll_for_input_1 ();
10701 poll_suppress_count
= old_poll_suppress_count
;
10704 FRAME_SAMPLE_VISIBILITY (f
);
10708 /* Change from mapped state to withdrawn state. */
10710 /* Make the frame visible (mapped and not iconified). */
10712 x_make_frame_invisible (f
)
10715 /* Don't keep the highlight on an invisible frame. */
10716 if (FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
== f
)
10717 FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
= 0;
10721 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
10723 /* We can't distinguish this from iconification
10724 just by the event that we get from the server.
10725 So we can't win using the usual strategy of letting
10726 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
10727 and synchronize with the server to make sure we agree. */
10729 FRAME_ICONIFIED_P (f
) = 0;
10730 f
->async_visible
= 0;
10731 f
->async_iconified
= 0;
10736 /* Change window state from mapped to iconified. */
10739 x_iconify_frame (f
)
10744 /* Don't keep the highlight on an invisible frame. */
10745 if (FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
== f
)
10746 FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
= 0;
10748 if (f
->async_iconified
)
10753 type
= x_icon_type (f
);
10755 x_bitmap_icon (f
, type
);
10757 /* Simulate the user minimizing the frame. */
10758 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
10764 /* Free X resources of frame F. */
10767 x_free_frame_resources (f
)
10770 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
10774 if (FRAME_W32_WINDOW (f
))
10775 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
10777 free_frame_menubar (f
);
10779 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
10780 unload_color (f
, f
->output_data
.x
->background_pixel
);
10781 unload_color (f
, f
->output_data
.w32
->cursor_pixel
);
10782 unload_color (f
, f
->output_data
.w32
->cursor_foreground_pixel
);
10783 unload_color (f
, f
->output_data
.w32
->border_pixel
);
10784 unload_color (f
, f
->output_data
.w32
->mouse_pixel
);
10785 if (f
->output_data
.w32
->white_relief
.allocated_p
)
10786 unload_color (f
, f
->output_data
.w32
->white_relief
.pixel
);
10787 if (f
->output_data
.w32
->black_relief
.allocated_p
)
10788 unload_color (f
, f
->output_data
.w32
->black_relief
.pixel
);
10790 if (FRAME_FACE_CACHE (f
))
10791 free_frame_faces (f
);
10793 xfree (f
->output_data
.w32
);
10794 f
->output_data
.w32
= NULL
;
10796 if (f
== dpyinfo
->w32_focus_frame
)
10797 dpyinfo
->w32_focus_frame
= 0;
10798 if (f
== dpyinfo
->w32_focus_event_frame
)
10799 dpyinfo
->w32_focus_event_frame
= 0;
10800 if (f
== dpyinfo
->w32_highlight_frame
)
10801 dpyinfo
->w32_highlight_frame
= 0;
10803 if (f
== dpyinfo
->mouse_face_mouse_frame
)
10805 dpyinfo
->mouse_face_beg_row
10806 = dpyinfo
->mouse_face_beg_col
= -1;
10807 dpyinfo
->mouse_face_end_row
10808 = dpyinfo
->mouse_face_end_col
= -1;
10809 dpyinfo
->mouse_face_window
= Qnil
;
10810 dpyinfo
->mouse_face_deferred_gc
= 0;
10811 dpyinfo
->mouse_face_mouse_frame
= 0;
10818 /* Destroy the window of frame F. */
10820 x_destroy_window (f
)
10823 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
10825 x_free_frame_resources (f
);
10827 dpyinfo
->reference_count
--;
10831 /* Setting window manager hints. */
10833 /* Set the normal size hints for the window manager, for frame F.
10834 FLAGS is the flags word to use--or 0 meaning preserve the flags
10835 that the window now has.
10836 If USER_POSITION is nonzero, we set the USPosition
10837 flag (this is useful when FLAGS is 0). */
10839 x_wm_set_size_hint (f
, flags
, user_position
)
10844 Window window
= FRAME_W32_WINDOW (f
);
10848 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FONT_WIDTH (f
->output_data
.w32
->font
));
10849 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, f
->output_data
.w32
->line_height
);
10850 SetWindowLong (window
, WND_BORDER_INDEX
, f
->output_data
.w32
->internal_border_width
);
10851 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->output_data
.w32
->vertical_scroll_bar_extra
);
10856 /* Window manager things */
10857 x_wm_set_icon_position (f
, icon_x
, icon_y
)
10859 int icon_x
, icon_y
;
10862 Window window
= FRAME_W32_WINDOW (f
);
10864 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
10865 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
10866 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
10868 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
10873 /***********************************************************************
10875 ***********************************************************************/
10877 /* The following functions are listed here to help diff stay in step
10878 with xterm.c. See w32fns.c for definitions.
10880 x_get_font_info (f, font_idx)
10881 x_list_fonts (f, pattern, size, maxnames)
10887 /* Check that FONT is valid on frame F. It is if it can be found in F's
10891 x_check_font (f
, font
)
10896 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
10898 xassert (font
!= NULL
);
10900 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10901 if (dpyinfo
->font_table
[i
].name
10902 && font
== dpyinfo
->font_table
[i
].font
)
10905 xassert (i
< dpyinfo
->n_fonts
);
10908 #endif /* GLYPH_DEBUG != 0 */
10910 /* Set *W to the minimum width, *H to the minimum font height of FONT.
10911 Note: There are (broken) X fonts out there with invalid XFontStruct
10912 min_bounds contents. For example, handa@etl.go.jp reports that
10913 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
10914 have font->min_bounds.width == 0. */
10917 x_font_min_bounds (font
, w
, h
)
10922 * TODO: Windows does not appear to offer min bound, only
10923 * average and maximum width, and maximum height.
10925 *h
= FONT_HEIGHT (font
);
10926 *w
= FONT_WIDTH (font
);
10930 /* Compute the smallest character width and smallest font height over
10931 all fonts available on frame F. Set the members smallest_char_width
10932 and smallest_font_height in F's x_display_info structure to
10933 the values computed. Value is non-zero if smallest_font_height or
10934 smallest_char_width become smaller than they were before. */
10937 x_compute_min_glyph_bounds (f
)
10941 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
10943 int old_width
= dpyinfo
->smallest_char_width
;
10944 int old_height
= dpyinfo
->smallest_font_height
;
10946 dpyinfo
->smallest_font_height
= 100000;
10947 dpyinfo
->smallest_char_width
= 100000;
10949 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
10950 if (dpyinfo
->font_table
[i
].name
)
10952 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
10955 font
= (XFontStruct
*) fontp
->font
;
10956 xassert (font
!= (XFontStruct
*) ~0);
10957 x_font_min_bounds (font
, &w
, &h
);
10959 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
10960 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
10963 xassert (dpyinfo
->smallest_char_width
> 0
10964 && dpyinfo
->smallest_font_height
> 0);
10966 return (dpyinfo
->n_fonts
== 1
10967 || dpyinfo
->smallest_char_width
< old_width
10968 || dpyinfo
->smallest_font_height
< old_height
);
10971 /* The following functions are listed here to help diff stay in step
10972 with xterm.c. See w32fns.c for definitions.
10974 x_load_font (f, fontname, size)
10975 x_query_font (f, fontname)
10976 x_find_ccl_program (fontp)
10980 /***********************************************************************
10982 ***********************************************************************/
10984 static int w32_initialized
= 0;
10987 w32_initialize_display_info (display_name
)
10988 Lisp_Object display_name
;
10990 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
10992 bzero (dpyinfo
, sizeof (*dpyinfo
));
10994 /* Put it on w32_display_name_list. */
10995 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
10996 w32_display_name_list
);
10997 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
10999 dpyinfo
->w32_id_name
11000 = (char *) xmalloc (XSTRING (Vinvocation_name
)->size
11001 + XSTRING (Vsystem_name
)->size
11003 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
11004 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
11006 /* Default Console mode values - overridden when running in GUI mode
11007 with values obtained from system metrics. */
11010 dpyinfo
->height_in
= 1;
11011 dpyinfo
->width_in
= 1;
11012 dpyinfo
->n_planes
= 1;
11013 dpyinfo
->n_cbits
= 4;
11014 dpyinfo
->n_fonts
= 0;
11015 dpyinfo
->smallest_font_height
= 1;
11016 dpyinfo
->smallest_char_width
= 1;
11018 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
11019 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
11020 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
11021 dpyinfo
->mouse_face_window
= Qnil
;
11022 dpyinfo
->mouse_face_overlay
= Qnil
;
11023 dpyinfo
->mouse_face_hidden
= 0;
11024 /* TODO: dpyinfo->gray */
11028 struct w32_display_info
*
11029 w32_term_init (display_name
, xrm_option
, resource_name
)
11030 Lisp_Object display_name
;
11032 char *resource_name
;
11034 struct w32_display_info
*dpyinfo
;
11039 if (!w32_initialized
)
11042 w32_initialized
= 1;
11053 argv
[argc
++] = "-xrm";
11054 argv
[argc
++] = xrm_option
;
11058 w32_initialize_display_info (display_name
);
11060 dpyinfo
= &one_w32_display_info
;
11062 /* Put this display on the chain. */
11063 dpyinfo
->next
= x_display_list
;
11064 x_display_list
= dpyinfo
;
11066 hdc
= GetDC (GetDesktopWindow ());
11068 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
11069 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
11070 dpyinfo
->root_window
= GetDesktopWindow ();
11071 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
11072 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
11073 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
11074 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
11075 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
11076 dpyinfo
->image_cache
= make_image_cache ();
11077 dpyinfo
->height_in
= dpyinfo
->height
/ dpyinfo
->resx
;
11078 dpyinfo
->width_in
= dpyinfo
->width
/ dpyinfo
->resy
;
11079 ReleaseDC (GetDesktopWindow (), hdc
);
11081 /* initialise palette with white and black */
11084 w32_defined_color (0, "white", &color
, 1);
11085 w32_defined_color (0, "black", &color
, 1);
11088 /* Create Row Bitmaps and store them for later use. */
11089 left_bmp
= CreateBitmap (left_width
, left_height
, 1, 1, left_bits
);
11090 ov_bmp
= CreateBitmap (ov_width
, ov_height
, 1, 1, ov_bits
);
11091 right_bmp
= CreateBitmap (right_width
, right_height
, 1, 1, right_bits
);
11092 continued_bmp
= CreateBitmap (continued_width
, continued_height
, 1,
11093 1, continued_bits
);
11094 continuation_bmp
= CreateBitmap (continuation_width
, continuation_height
,
11095 1, 1, continuation_bits
);
11096 zv_bmp
= CreateBitmap (zv_width
, zv_height
, 1, 1, zv_bits
);
11098 #ifndef F_SETOWN_BUG
11100 #ifdef F_SETOWN_SOCK_NEG
11101 /* stdin is a socket here */
11102 fcntl (connection
, F_SETOWN
, -getpid ());
11103 #else /* ! defined (F_SETOWN_SOCK_NEG) */
11104 fcntl (connection
, F_SETOWN
, getpid ());
11105 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
11106 #endif /* ! defined (F_SETOWN) */
11107 #endif /* F_SETOWN_BUG */
11110 if (interrupt_input
)
11111 init_sigio (connection
);
11112 #endif /* ! defined (SIGIO) */
11119 /* Get rid of display DPYINFO, assuming all frames are already gone. */
11122 x_delete_display (dpyinfo
)
11123 struct w32_display_info
*dpyinfo
;
11125 /* Discard this display from w32_display_name_list and w32_display_list.
11126 We can't use Fdelq because that can quit. */
11127 if (! NILP (w32_display_name_list
)
11128 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
11129 w32_display_name_list
= XCDR (w32_display_name_list
);
11134 tail
= w32_display_name_list
;
11135 while (CONSP (tail
) && CONSP (XCDR (tail
)))
11137 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
11139 XSETCDR (tail
, XCDR (XCDR (tail
)));
11142 tail
= XCDR (tail
);
11146 /* free palette table */
11148 struct w32_palette_entry
* plist
;
11150 plist
= dpyinfo
->color_list
;
11153 struct w32_palette_entry
* pentry
= plist
;
11154 plist
= plist
->next
;
11157 dpyinfo
->color_list
= NULL
;
11158 if (dpyinfo
->palette
)
11159 DeleteObject(dpyinfo
->palette
);
11161 xfree (dpyinfo
->font_table
);
11162 xfree (dpyinfo
->w32_id_name
);
11164 /* Destroy row bitmaps. */
11165 DeleteObject (left_bmp
);
11166 DeleteObject (ov_bmp
);
11167 DeleteObject (right_bmp
);
11168 DeleteObject (continued_bmp
);
11169 DeleteObject (continuation_bmp
);
11170 DeleteObject (zv_bmp
);
11173 /* Set up use of W32. */
11175 DWORD
w32_msg_worker ();
11178 x_flush (struct frame
* f
)
11179 { /* Nothing to do */ }
11181 static struct redisplay_interface w32_redisplay_interface
=
11186 x_clear_end_of_line
,
11188 x_after_update_window_line
,
11189 x_update_window_begin
,
11190 x_update_window_end
,
11193 x_clear_mouse_face
,
11194 x_get_glyph_overhangs
,
11195 x_fix_overlapping_area
11201 rif
= &w32_redisplay_interface
;
11203 /* MSVC does not type K&R functions with no arguments correctly, and
11204 so we must explicitly cast them. */
11205 clear_frame_hook
= (void (*)(void)) x_clear_frame
;
11206 ring_bell_hook
= (void (*)(void)) w32_ring_bell
;
11207 update_begin_hook
= x_update_begin
;
11208 update_end_hook
= x_update_end
;
11210 read_socket_hook
= w32_read_socket
;
11212 frame_up_to_date_hook
= w32_frame_up_to_date
;
11214 mouse_position_hook
= w32_mouse_position
;
11215 frame_rehighlight_hook
= w32_frame_rehighlight
;
11216 frame_raise_lower_hook
= w32_frame_raise_lower
;
11217 set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
11218 condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
11219 redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
11220 judge_scroll_bars_hook
= w32_judge_scroll_bars
;
11221 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
11223 scroll_region_ok
= 1; /* we'll scroll partial frames */
11224 char_ins_del_ok
= 1;
11225 line_ins_del_ok
= 1; /* we'll just blt 'em */
11226 fast_clear_end_of_line
= 1; /* X does this well */
11227 memory_below_frame
= 0; /* we don't remember what scrolls
11231 w32_system_caret_hwnd
= NULL
;
11232 w32_system_caret_height
= 0;
11233 w32_system_caret_x
= 0;
11234 w32_system_caret_y
= 0;
11236 last_tool_bar_item
= -1;
11237 any_help_event_p
= 0;
11239 /* Initialize input mode: interrupt_input off, no flow control, allow
11240 8 bit character input, standard quit char. */
11241 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
11243 /* Create the window thread - it will terminate itself or when the app terminates */
11247 dwMainThreadId
= GetCurrentThreadId ();
11248 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
11249 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
11251 /* Wait for thread to start */
11256 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
11258 hWindowsThread
= CreateThread (NULL
, 0,
11259 (LPTHREAD_START_ROUTINE
) w32_msg_worker
,
11260 0, 0, &dwWindowsThreadId
);
11262 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
11265 /* It is desirable that mainThread should have the same notion of
11266 focus window and active window as windowsThread. Unfortunately, the
11267 following call to AttachThreadInput, which should do precisely what
11268 we need, causes major problems when Emacs is linked as a console
11269 program. Unfortunately, we have good reasons for doing that, so
11270 instead we need to send messages to windowsThread to make some API
11271 calls for us (ones that affect, or depend on, the active/focus
11273 #ifdef ATTACH_THREADS
11274 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
11277 /* Dynamically link to optional system components. */
11279 HANDLE user_lib
= LoadLibrary ("user32.dll");
11281 #define LOAD_PROC(fn) pfn##fn = (void *) GetProcAddress (user_lib, #fn)
11283 /* New proportional scroll bar functions. */
11284 LOAD_PROC (SetScrollInfo
);
11285 LOAD_PROC (GetScrollInfo
);
11289 FreeLibrary (user_lib
);
11291 /* If using proportional scroll bars, ensure handle is at least 5 pixels;
11292 otherwise use the fixed height. */
11293 vertical_scroll_bar_min_handle
= (pfnSetScrollInfo
!= NULL
) ? 5 :
11294 GetSystemMetrics (SM_CYVTHUMB
);
11296 /* For either kind of scroll bar, take account of the arrows; these
11297 effectively form the border of the main scroll bar range. */
11298 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
11299 = GetSystemMetrics (SM_CYVSCROLL
);
11306 staticpro (&w32_display_name_list
);
11307 w32_display_name_list
= Qnil
;
11309 staticpro (&last_mouse_scroll_bar
);
11310 last_mouse_scroll_bar
= Qnil
;
11312 staticpro (&Qvendor_specific_keysyms
);
11313 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
11315 DEFVAR_INT ("w32-num-mouse-buttons",
11316 &Vw32_num_mouse_buttons
,
11317 doc
: /* Number of physical mouse buttons. */);
11318 Vw32_num_mouse_buttons
= Qnil
;
11320 DEFVAR_LISP ("w32-swap-mouse-buttons",
11321 &Vw32_swap_mouse_buttons
,
11322 doc
: /* Swap the mapping of middle and right mouse buttons.
11323 When nil, middle button is mouse-2 and right button is mouse-3. */);
11324 Vw32_swap_mouse_buttons
= Qnil
;
11326 DEFVAR_LISP ("w32-grab-focus-on-raise",
11327 &Vw32_grab_focus_on_raise
,
11328 doc
: /* Raised frame grabs input focus.
11329 When t, `raise-frame' grabs input focus as well. This fits well
11330 with the normal Windows click-to-focus policy, but might not be
11331 desirable when using a point-to-focus policy. */);
11332 Vw32_grab_focus_on_raise
= Qt
;
11334 DEFVAR_LISP ("w32-capslock-is-shiftlock",
11335 &Vw32_capslock_is_shiftlock
,
11336 doc
: /* Apply CapsLock state to non character input keys.
11337 When nil, CapsLock only affects normal character input keys. */);
11338 Vw32_capslock_is_shiftlock
= Qnil
;
11340 DEFVAR_LISP ("w32-recognize-altgr",
11341 &Vw32_recognize_altgr
,
11342 doc
: /* Recognize right-alt and left-ctrl as AltGr.
11343 When nil, the right-alt and left-ctrl key combination is
11344 interpreted normally. */);
11345 Vw32_recognize_altgr
= Qt
;
11347 DEFVAR_BOOL ("w32-enable-unicode-output",
11348 &w32_enable_unicode_output
,
11349 doc
: /* Enable the use of Unicode for text output if non-nil.
11350 Unicode output may prevent some third party applications for displaying
11351 Far-East Languages on Windows 95/98 from working properly.
11352 NT uses Unicode internally anyway, so this flag will probably have no
11353 affect on NT machines. */);
11354 w32_enable_unicode_output
= 1;
11357 staticpro (&help_echo
);
11358 help_echo_object
= Qnil
;
11359 staticpro (&help_echo_object
);
11360 help_echo_window
= Qnil
;
11361 staticpro (&help_echo_window
);
11362 previous_help_echo
= Qnil
;
11363 staticpro (&previous_help_echo
);
11364 help_echo_pos
= -1;
11366 DEFVAR_BOOL ("x-autoselect-window", &x_autoselect_window_p
,
11367 doc
: /* *Non-nil means autoselect window with mouse pointer. */);
11368 x_autoselect_window_p
= 0;
11370 DEFVAR_BOOL ("w32-use-visible-system-caret",
11371 &w32_use_visible_system_caret
,
11372 doc
: /* Flag to make the system caret visible.
11373 When this is non-nil, Emacs will indicate the position of point by
11374 using the system caret instead of drawing its own cursor. Some screen
11375 reader software does not track the system cursor properly when it is
11376 invisible, and gets confused by Emacs drawing its own cursor, so this
11377 variable is initialized to t when Emacs detects that screen reader
11378 software is running as it starts up.
11380 When this variable is set, other variables affecting the appearance of
11381 the cursor have no effect. */);
11383 /* Initialize w32_use_visible_system_caret based on whether a screen
11384 reader is in use. */
11385 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
11386 &w32_use_visible_system_caret
, 0))
11387 w32_use_visible_system_caret
= 0;
11389 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
11390 doc
: /* *Non-nil means draw block cursor as wide as the glyph under it.
11391 For example, if a block cursor is over a tab, it will be drawn as
11392 wide as that tab on the display. */);
11393 x_stretch_cursor_p
= 0;
11395 #if 0 /* TODO: Setting underline position from font properties. */
11396 DEFVAR_BOOL ("x-use-underline-position-properties",
11397 &x_use_underline_position_properties
,
11398 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
11399 nil means ignore them. If you encounter fonts with bogus
11400 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
11401 to 4.1, set this to nil. */);
11402 x_use_underline_position_properties
= 1;
11405 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
11406 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
11407 Vx_toolkit_scroll_bars
= Qt
;
11409 staticpro (&last_mouse_motion_frame
);
11410 last_mouse_motion_frame
= Qnil
;