1 /* Implementation of GUI terminal on the Microsoft W32 API.
2 Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000
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"
46 #include "dispextern.h"
48 #include "termhooks.h"
55 #include "intervals.h"
56 #include "composite.h"
61 #define min(x, y) (((x) < (y)) ? (x) : (y))
62 #define max(x, y) (((x) > (y)) ? (x) : (y))
64 #define abs(x) ((x) < 0 ? -(x) : (x))
66 #define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
69 /* Bitmaps for truncated lines. */
74 LEFT_TRUNCATION_BITMAP
,
75 RIGHT_TRUNCATION_BITMAP
,
77 CONTINUED_LINE_BITMAP
,
78 CONTINUATION_LINE_BITMAP
,
82 /* Bitmaps are all unsigned short, as Windows requires bitmap data to
83 be Word aligned. For some reason they are horizontally reflected
84 compared to how they appear on X, so changes in xterm.c should be
87 /* Bitmap drawn to indicate lines not displaying text if
88 `indicate-empty-lines' is non-nil. */
92 static unsigned short zv_bits
[] = {
93 0x00, 0x00, 0x78, 0x78, 0x78, 0x78, 0x00, 0x00};
94 static HBITMAP zv_bmp
;
96 /* An arrow like this: `<-'. */
100 static unsigned short left_bits
[] = {
101 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
102 static HBITMAP left_bmp
;
104 /* Right truncation arrow bitmap `->'. */
106 #define right_width 8
107 #define right_height 8
108 static unsigned short right_bits
[] = {
109 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
110 static HBITMAP right_bmp
;
112 /* Marker for continued lines. */
114 #define continued_width 8
115 #define continued_height 8
116 static unsigned short continued_bits
[] = {
117 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
118 static HBITMAP continued_bmp
;
120 /* Marker for continuation lines. */
122 #define continuation_width 8
123 #define continuation_height 8
124 static unsigned short continuation_bits
[] = {
125 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
126 static HBITMAP continuation_bmp
;
128 /* Overlay arrow bitmap. */
134 static unsigned short ov_bits
[] = {
135 0x0c, 0x10, 0x3c, 0x7e, 0x5e, 0x5e, 0x46, 0x3c};
137 /* A triangular arrow. */
140 static unsigned short ov_bits
[] = {
141 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
143 static HBITMAP ov_bmp
;
145 extern Lisp_Object Qhelp_echo
;
148 /* Non-zero means Emacs uses toolkit scroll bars. */
150 int x_toolkit_scroll_bars_p
;
152 /* If a string, w32_read_socket generates an event to display that string.
153 (The display is done in read_char.) */
155 static Lisp_Object help_echo
;
156 static Lisp_Object help_echo_window
;
157 static Lisp_Object help_echo_object
;
158 static int help_echo_pos
;
160 /* Temporary variable for w32_read_socket. */
162 static Lisp_Object previous_help_echo
;
164 /* Non-zero means that a HELP_EVENT has been generated since Emacs
167 static int any_help_event_p
;
169 /* Non-zero means draw block and hollow cursor as wide as the glyph
170 under it. For example, if a block cursor is over a tab, it will be
171 drawn as wide as that tab on the display. */
173 int x_stretch_cursor_p
;
175 extern unsigned int msh_mousewheel
;
177 extern void free_frame_menubar ();
179 extern void w32_menu_display_help (HMENU menu
, UINT menu_item
, UINT flags
);
181 extern int w32_codepage_for_font (char *fontname
);
183 extern glyph_metric
*w32_BDF_TextMetric(bdffont
*fontp
,
184 unsigned char *text
, int dim
);
185 extern Lisp_Object Vwindow_system
;
187 #define x_any_window_to_frame x_window_to_frame
188 #define x_top_window_to_frame x_window_to_frame
191 /* This is display since w32 does not support multiple ones. */
192 struct w32_display_info one_w32_display_info
;
194 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
195 one for each element of w32_display_list and in the same order.
196 NAME is the name of the frame.
197 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
198 Lisp_Object w32_display_name_list
;
200 /* Frame being updated by update_frame. This is declared in term.c.
201 This is set by update_begin and looked at by all the
202 w32 functions. It is zero while not inside an update.
203 In that case, the w32 functions assume that `SELECTED_FRAME ()'
204 is the frame to apply to. */
205 extern struct frame
*updating_frame
;
207 /* This is a frame waiting to be autoraised, within w32_read_socket. */
208 struct frame
*pending_autoraise_frame
;
210 /* Nominal cursor position -- where to draw output.
211 HPOS and VPOS are window relative glyph matrix coordinates.
212 X and Y are window relative pixel coordinates. */
214 struct cursor_pos output_cursor
;
216 /* Flag to enable Unicode output in case users wish to use programs
217 like Twinbridge on '95 rather than installed system level support
218 for Far East languages. */
219 int w32_enable_unicode_output
;
221 DWORD dwWindowsThreadId
= 0;
222 HANDLE hWindowsThread
= NULL
;
223 DWORD dwMainThreadId
= 0;
224 HANDLE hMainThread
= NULL
;
227 /* These definitions are new with Windows 95. */
228 #define SIF_RANGE 0x0001
229 #define SIF_PAGE 0x0002
230 #define SIF_POS 0x0004
231 #define SIF_DISABLENOSCROLL 0x0008
232 #define SIF_TRACKPOS 0x0010
233 #define SIF_ALL (SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS)
235 typedef struct tagSCROLLINFO
244 } SCROLLINFO
, FAR
*LPSCROLLINFO
;
245 typedef SCROLLINFO CONST FAR
*LPCSCROLLINFO
;
248 /* Dynamic linking to new proportional scroll bar functions. */
249 int (PASCAL
*pfnSetScrollInfo
) (HWND hwnd
, int fnBar
, LPSCROLLINFO lpsi
, BOOL fRedraw
);
250 BOOL (PASCAL
*pfnGetScrollInfo
) (HWND hwnd
, int fnBar
, LPSCROLLINFO lpsi
);
252 int vertical_scroll_bar_min_handle
;
253 int vertical_scroll_bar_top_border
;
254 int vertical_scroll_bar_bottom_border
;
256 int last_scroll_bar_drag_pos
;
258 /* Mouse movement. */
260 /* Where the mouse was last time we reported a mouse event. */
262 FRAME_PTR last_mouse_frame
;
263 static RECT last_mouse_glyph
;
264 static Lisp_Object last_mouse_press_frame
;
266 Lisp_Object Vw32_num_mouse_buttons
;
268 Lisp_Object Vw32_swap_mouse_buttons
;
270 /* Control whether x_raise_frame also sets input focus. */
271 Lisp_Object Vw32_grab_focus_on_raise
;
273 /* Control whether Caps Lock affects non-ascii characters. */
274 Lisp_Object Vw32_capslock_is_shiftlock
;
276 /* Control whether right-alt and left-ctrl should be recognized as AltGr. */
277 Lisp_Object Vw32_recognize_altgr
;
279 /* The scroll bar in which the last motion event occurred.
281 If the last motion event occurred in a scroll bar, we set this
282 so w32_mouse_position can know whether to report a scroll bar motion or
285 If the last motion event didn't occur in a scroll bar, we set this
286 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
287 static Lisp_Object last_mouse_scroll_bar
;
288 static int last_mouse_scroll_bar_pos
;
290 /* This is a hack. We would really prefer that w32_mouse_position would
291 return the time associated with the position it returns, but there
292 doesn't seem to be any way to wrest the time-stamp from the server
293 along with the position query. So, we just keep track of the time
294 of the last movement we received, and return that in hopes that
295 it's somewhat accurate. */
297 static Time last_mouse_movement_time
;
299 /* Incremented by w32_read_socket whenever it really tries to read
303 static int volatile input_signal_count
;
305 static int input_signal_count
;
308 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
310 extern Lisp_Object Qface
, Qmouse_face
;
316 /* A mask of extra modifier bits to put into every keyboard char. */
318 extern int extra_keyboard_modifiers
;
320 /* Enumeration for overriding/changing the face to use for drawing
321 glyphs in x_draw_glyphs. */
323 enum draw_glyphs_face
333 static void x_update_window_end
P_ ((struct window
*, int, int));
334 static void frame_to_window_pixel_xy
P_ ((struct window
*, int *, int *));
335 void w32_delete_display
P_ ((struct w32_display_info
*));
336 static int fast_find_position
P_ ((struct window
*, int, int *, int *,
338 static void set_output_cursor
P_ ((struct cursor_pos
*));
339 static struct glyph
*x_y_to_hpos_vpos
P_ ((struct window
*, int, int,
340 int *, int *, int *));
341 static void note_mode_line_highlight
P_ ((struct window
*, int, int));
342 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
343 static void note_mouse_highlight
P_ ((struct frame
*, int, int));
344 static void note_tool_bar_highlight
P_ ((struct frame
*f
, int, int));
345 static void w32_handle_tool_bar_click
P_ ((struct frame
*,
346 struct input_event
*));
347 static void show_mouse_face
P_ ((struct w32_display_info
*,
348 enum draw_glyphs_face
));
349 void clear_mouse_face
P_ ((struct w32_display_info
*));
351 void x_lower_frame
P_ ((struct frame
*));
352 void x_scroll_bar_clear
P_ ((struct frame
*));
353 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
354 void x_raise_frame
P_ ((struct frame
*));
355 void x_set_window_size
P_ ((struct frame
*, int, int, int));
356 void x_wm_set_window_state
P_ ((struct frame
*, int));
357 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
358 void w32_initialize
P_ ((void));
359 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
360 int x_compute_min_glyph_bounds
P_ ((struct frame
*));
361 static void x_draw_phys_cursor_glyph
P_ ((struct window
*,
363 enum draw_glyphs_face
));
364 static void x_update_end
P_ ((struct frame
*));
365 static void w32_frame_up_to_date
P_ ((struct frame
*));
366 static void w32_reassert_line_highlight
P_ ((int, int));
367 static void x_change_line_highlight
P_ ((int, int, int, int));
368 static void w32_set_terminal_modes
P_ ((void));
369 static void w32_reset_terminal_modes
P_ ((void));
370 static void w32_cursor_to
P_ ((int, int, int, int));
371 static void x_write_glyphs
P_ ((struct glyph
*, int));
372 static void x_clear_end_of_line
P_ ((int));
373 static void x_clear_frame
P_ ((void));
374 static void x_clear_cursor
P_ ((struct window
*));
375 static void frame_highlight
P_ ((struct frame
*));
376 static void frame_unhighlight
P_ ((struct frame
*));
377 static void w32_new_focus_frame
P_ ((struct w32_display_info
*,
379 static void w32_frame_rehighlight
P_ ((struct frame
*));
380 static void x_frame_rehighlight
P_ ((struct w32_display_info
*));
381 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
382 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int));
383 static void expose_frame
P_ ((struct frame
*, int, int, int, int));
384 static void expose_window_tree
P_ ((struct window
*, RECT
*));
385 static void expose_window
P_ ((struct window
*, RECT
*));
386 static void expose_area
P_ ((struct window
*, struct glyph_row
*,
387 RECT
*, enum glyph_row_area
));
388 static void expose_line
P_ ((struct window
*, struct glyph_row
*,
390 void x_update_cursor
P_ ((struct frame
*, int));
391 static void x_update_cursor_in_window_tree
P_ ((struct window
*, int));
392 static void x_update_window_cursor
P_ ((struct window
*, int));
393 static void x_erase_phys_cursor
P_ ((struct window
*));
394 void x_display_cursor
P_ ((struct window
*w
, int, int, int, int, int));
395 void x_display_and_set_cursor
P_ ((struct window
*, int, int, int, int, int));
396 static void w32_draw_bitmap
P_ ((struct window
*, HDC hdc
, struct glyph_row
*,
398 static int x_phys_cursor_in_rect_p
P_ ((struct window
*, RECT
*));
399 static void x_draw_row_bitmaps
P_ ((struct window
*, struct glyph_row
*));
400 static void note_overwritten_text_cursor
P_ ((struct window
*, int, int));
401 static void w32_clip_to_row
P_ ((struct window
*, struct glyph_row
*,
404 static Lisp_Object Qvendor_specific_keysyms
;
407 /***********************************************************************
409 ***********************************************************************/
413 /* This is a function useful for recording debugging information about
414 the sequence of occurrences in this file. */
422 struct record event_record
[100];
424 int event_record_index
;
426 record_event (locus
, type
)
430 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
431 event_record_index
= 0;
433 event_record
[event_record_index
].locus
= locus
;
434 event_record
[event_record_index
].type
= type
;
435 event_record_index
++;
441 void XChangeGC (void * ignore
, XGCValues
* gc
, unsigned long mask
,
444 if (mask
& GCForeground
)
445 gc
->foreground
= xgcv
->foreground
;
446 if (mask
& GCBackground
)
447 gc
->background
= xgcv
->background
;
449 gc
->font
= xgcv
->font
;
452 XGCValues
*XCreateGC (void * ignore
, Window window
, unsigned long mask
,
455 XGCValues
*gc
= (XGCValues
*) xmalloc (sizeof (XGCValues
));
456 bzero (gc
, sizeof (XGCValues
));
458 XChangeGC (ignore
, gc
, mask
, xgcv
);
463 void XGetGCValues (void* ignore
, XGCValues
*gc
,
464 unsigned long mask
, XGCValues
*xgcv
)
466 XChangeGC (ignore
, xgcv
, mask
, gc
);
470 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
474 HRGN clip_region
= CreateRectRgnIndirect (rect
);
475 SelectClipRgn (hdc
, clip_region
);
476 DeleteObject (clip_region
);
479 SelectClipRgn (hdc
, NULL
);
483 /* Draw a hollow rectangle at the specified position. */
485 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
486 int width
, int height
)
491 hb
= CreateSolidBrush (gc
->background
);
492 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
493 oldhb
= SelectObject (hdc
, hb
);
494 oldhp
= SelectObject (hdc
, hp
);
496 Rectangle (hdc
, x
, y
, x
+ width
, y
+ height
);
498 SelectObject (hdc
, oldhb
);
499 SelectObject (hdc
, oldhp
);
504 /* Draw a filled rectangle at the specified position. */
506 w32_fill_rect (f
, hdc
, pix
, lprect
)
515 hb
= CreateSolidBrush (pix
);
516 FillRect (hdc
, lprect
, hb
);
525 HDC hdc
= get_frame_dc (f
);
527 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
528 w32_clear_rect (f
, hdc
, &rect
);
529 release_frame_dc (f
, hdc
);
533 /***********************************************************************
534 Starting and ending an update
535 ***********************************************************************/
537 /* Start an update of frame F. This function is installed as a hook
538 for update_begin, i.e. it is called when update_begin is called.
539 This function is called prior to calls to x_update_window_begin for
540 each window being updated. Currently, there is nothing to do here
541 because all interesting stuff is done on a window basis. */
547 /* Nothing to do. We have to do something though, otherwise the
548 function gets optimized away and the hook is no longer valid. */
549 struct frame
*cf
= f
;
553 /* Start update of window W. Set the global variable updated_window
554 to the window being updated and set output_cursor to the cursor
558 x_update_window_begin (w
)
561 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
562 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
565 set_output_cursor (&w
->cursor
);
569 /* Regenerate display palette before drawing if list of requested
570 colors has changed. */
571 if (display_info
->regen_palette
)
573 w32_regenerate_palette (f
);
574 display_info
->regen_palette
= FALSE
;
577 if (f
== display_info
->mouse_face_mouse_frame
)
579 /* Don't do highlighting for mouse motion during the update. */
580 display_info
->mouse_face_defer
= 1;
582 /* If F needs to be redrawn, simply forget about any prior mouse
584 if (FRAME_GARBAGED_P (f
))
585 display_info
->mouse_face_window
= Qnil
;
587 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
588 their mouse_face_p flag set, which means that they are always
589 unequal to rows in a desired matrix which never have that
590 flag set. So, rows containing mouse-face glyphs are never
591 scrolled, and we don't have to switch the mouse highlight off
592 here to prevent it from being scrolled. */
594 /* Can we tell that this update does not affect the window
595 where the mouse highlight is? If so, no need to turn off.
596 Likewise, don't do anything if the frame is garbaged;
597 in that case, the frame's current matrix that we would use
598 is all wrong, and we will redisplay that line anyway. */
599 if (!NILP (display_info
->mouse_face_window
)
600 && w
== XWINDOW (display_info
->mouse_face_window
))
604 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
605 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
608 if (i
< w
->desired_matrix
->nrows
)
609 clear_mouse_face (display_info
);
618 /* Draw a vertical window border to the right of window W if W doesn't
619 have vertical scroll bars. */
622 x_draw_vertical_border (w
)
625 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
627 /* Redraw borders between horizontally adjacent windows. Don't
628 do it for frames with vertical scroll bars because either the
629 right scroll bar of a window, or the left scroll bar of its
630 neighbor will suffice as a border. */
631 if (!WINDOW_RIGHTMOST_P (w
)
632 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
637 window_box_edges (w
, -1, &r
.left
, &r
.top
, &r
.right
, &r
.bottom
);
638 r
.left
= r
.right
+ FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
);
639 r
.right
= r
.left
+ 1;
642 hdc
= get_frame_dc (f
);
643 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), r
);
644 release_frame_dc (f
, hdc
);
649 /* End update of window W (which is equal to updated_window).
651 Draw vertical borders between horizontally adjacent windows, and
652 display W's cursor if CURSOR_ON_P is non-zero.
654 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
655 glyphs in mouse-face were overwritten. In that case we have to
656 make sure that the mouse-highlight is properly redrawn.
658 W may be a menu bar pseudo-window in case we don't have X toolkit
659 support. Such windows don't have a cursor, so don't display it
663 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
665 int cursor_on_p
, mouse_face_overwritten_p
;
667 if (!w
->pseudo_window_p
)
669 struct w32_display_info
*dpyinfo
670 = FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
674 /* If a row with mouse-face was overwritten, arrange for
675 XTframe_up_to_date to redisplay the mouse highlight. */
676 if (mouse_face_overwritten_p
)
678 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
679 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
680 dpyinfo
->mouse_face_window
= Qnil
;
684 x_display_and_set_cursor (w
, 1, output_cursor
.hpos
,
686 output_cursor
.x
, output_cursor
.y
);
687 x_draw_vertical_border (w
);
691 updated_window
= NULL
;
695 /* End update of frame F. This function is installed as a hook in
702 /* Mouse highlight may be displayed again. */
703 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
707 /* This function is called from various places in xdisp.c whenever a
708 complete update has been performed. The global variable
709 updated_window is not available here. */
712 w32_frame_up_to_date (f
)
717 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
718 if (dpyinfo
->mouse_face_deferred_gc
719 || f
== dpyinfo
->mouse_face_mouse_frame
)
722 if (dpyinfo
->mouse_face_mouse_frame
)
723 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
724 dpyinfo
->mouse_face_mouse_x
,
725 dpyinfo
->mouse_face_mouse_y
);
726 dpyinfo
->mouse_face_deferred_gc
= 0;
733 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
734 arrow bitmaps, or clear the areas where they would be displayed
735 before DESIRED_ROW is made current. The window being updated is
736 found in updated_window. This function It is called from
737 update_window_line only if it is known that there are differences
738 between bitmaps to be drawn between current row and DESIRED_ROW. */
741 x_after_update_window_line (desired_row
)
742 struct glyph_row
*desired_row
;
744 struct window
*w
= updated_window
;
748 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
751 x_draw_row_bitmaps (w
, desired_row
);
753 /* When a window has disappeared, make sure that no rest of
754 full-width rows stays visible in the internal border. */
755 if (windows_or_buffers_changed
)
757 struct frame
*f
= XFRAME (w
->frame
);
758 int width
= FRAME_INTERNAL_BORDER_WIDTH (f
);
759 int height
= desired_row
->visible_height
;
760 int x
= (window_box_right (w
, -1)
761 + FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
));
762 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
763 HDC hdc
= get_frame_dc (f
);
765 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
766 release_frame_dc (f
, hdc
);
774 /* Draw the bitmap WHICH in one of the areas to the left or right of
775 window W. ROW is the glyph row for which to display the bitmap; it
776 determines the vertical position at which the bitmap has to be
780 w32_draw_bitmap (w
, hdc
, row
, which
)
783 struct glyph_row
*row
;
784 enum bitmap_type which
;
786 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
787 Window window
= FRAME_W32_WINDOW (f
);
791 HBRUSH fg_brush
, orig_brush
;
795 /* Must clip because of partially visible lines. */
796 w32_clip_to_row (w
, row
, hdc
, 1);
800 case LEFT_TRUNCATION_BITMAP
:
804 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
806 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
809 case OVERLAY_ARROW_BITMAP
:
813 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
815 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
818 case RIGHT_TRUNCATION_BITMAP
:
822 x
= window_box_right (w
, -1);
823 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
826 case CONTINUED_LINE_BITMAP
:
827 wd
= continued_width
;
828 h
= continued_height
;
829 pixmap
= continued_bmp
;
830 x
= window_box_right (w
, -1);
831 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
834 case CONTINUATION_LINE_BITMAP
:
835 wd
= continuation_width
;
836 h
= continuation_height
;
837 pixmap
= continuation_bmp
;
838 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
840 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
847 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
849 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
856 /* Convert to frame coordinates. Set dy to the offset in the row to
857 start drawing the bitmap. */
858 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
859 dy
= (row
->height
- h
) / 2;
861 /* Draw the bitmap. */
862 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
864 compat_hdc
= CreateCompatibleDC (hdc
);
866 fg_brush
= CreateSolidBrush (face
->foreground
);
867 orig_brush
= SelectObject (hdc
, fg_brush
);
868 horig_obj
= SelectObject (compat_hdc
, pixmap
);
869 SetTextColor (hdc
, face
->foreground
);
870 SetBkColor (hdc
, face
->background
);
871 #if 0 /* From w32bdf.c (which is from Meadow). */
872 /* Old versions - in case we find a reason to fall back on them. */
873 BitBlt (hdc
, x
, y
+ dy
, wd
, h
, compat_hdc
, 0, 0, SRCCOPY
);
874 BitBlt (hdc
, x
, y
+ dy
, wd
, h
, compat_hdc
, 0, 0, 0xB8074A);
876 BitBlt (hdc
, x
, y
+ dy
, wd
, h
, compat_hdc
, 0, 0, 0xE20746);
878 SelectObject (compat_hdc
, horig_obj
);
879 SelectObject (hdc
, orig_brush
);
880 DeleteObject (fg_brush
);
881 DeleteDC (compat_hdc
);
886 /* Draw flags bitmaps for glyph row ROW on window W. Call this
887 function with input blocked. */
890 x_draw_row_bitmaps (w
, row
)
892 struct glyph_row
*row
;
894 struct frame
*f
= XFRAME (w
->frame
);
895 enum bitmap_type bitmap
;
897 int header_line_height
= -1;
898 HDC hdc
= get_frame_dc (f
);
900 xassert (interrupt_input_blocked
);
902 /* If row is completely invisible, because of vscrolling, we
903 don't have to draw anything. */
904 if (row
->visible_height
<= 0)
907 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
908 PREPARE_FACE_FOR_DISPLAY (f
, face
);
910 /* Decide which bitmap to draw at the left side. */
911 if (row
->overlay_arrow_p
)
912 bitmap
= OVERLAY_ARROW_BITMAP
;
913 else if (row
->truncated_on_left_p
)
914 bitmap
= LEFT_TRUNCATION_BITMAP
;
915 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
916 bitmap
= CONTINUATION_LINE_BITMAP
;
917 else if (row
->indicate_empty_line_p
)
918 bitmap
= ZV_LINE_BITMAP
;
922 /* Clear flags area if no bitmap to draw or if bitmap doesn't fill
924 if (bitmap
== NO_BITMAP
925 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
926 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
928 /* If W has a vertical border to its left, don't draw over it. */
929 int border
= ((XFASTINT (w
->left
) > 0
930 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
932 int left
= window_box_left (w
, -1);
934 if (header_line_height
< 0)
935 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
937 w32_fill_area (f
, hdc
, face
->background
,
938 left
- FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) + border
,
939 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
941 FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - border
,
942 row
->visible_height
);
945 /* Draw the left bitmap. */
946 if (bitmap
!= NO_BITMAP
)
947 w32_draw_bitmap (w
, hdc
, row
, bitmap
);
949 /* Decide which bitmap to draw at the right side. */
950 if (row
->truncated_on_right_p
)
951 bitmap
= RIGHT_TRUNCATION_BITMAP
;
952 else if (row
->continued_p
)
953 bitmap
= CONTINUED_LINE_BITMAP
;
957 /* Clear flags area if no bitmap to draw of if bitmap doesn't fill
959 if (bitmap
== NO_BITMAP
960 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
)
961 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
963 int right
= window_box_right (w
, -1);
965 if (header_line_height
< 0)
966 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
968 w32_fill_area (f
, hdc
, face
->background
,
970 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
972 FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
),
973 row
->visible_height
);
976 /* Draw the right bitmap. */
977 if (bitmap
!= NO_BITMAP
)
978 w32_draw_bitmap (w
, hdc
, row
, bitmap
);
980 release_frame_dc (f
, hdc
);
984 /***********************************************************************
986 ***********************************************************************/
988 /* External interface to control of standout mode. Not used for W32
989 frames. Aborts when called. */
992 w32_reassert_line_highlight (new, vpos
)
998 /* Call this when about to modify line at position VPOS and change
999 whether it is highlighted. Not used for W32 frames. Aborts when
1003 x_change_line_highlight (new_highlight
, vpos
, y
, first_unused_hpos
)
1004 int new_highlight
, vpos
, y
, first_unused_hpos
;
1009 /* This is called when starting Emacs and when restarting after
1010 suspend. When starting Emacs, no window is mapped. And nothing
1011 must be done to Emacs's own window if it is suspended (though that
1015 w32_set_terminal_modes (void)
1019 /* This is called when exiting or suspending Emacs. Exiting will make
1020 the W32 windows go away, and suspending requires no action. */
1023 w32_reset_terminal_modes (void)
1029 /***********************************************************************
1031 ***********************************************************************/
1033 /* Set the global variable output_cursor to CURSOR. All cursor
1034 positions are relative to updated_window. */
1037 set_output_cursor (cursor
)
1038 struct cursor_pos
*cursor
;
1040 output_cursor
.hpos
= cursor
->hpos
;
1041 output_cursor
.vpos
= cursor
->vpos
;
1042 output_cursor
.x
= cursor
->x
;
1043 output_cursor
.y
= cursor
->y
;
1047 /* Set a nominal cursor position.
1049 HPOS and VPOS are column/row positions in a window glyph matrix. X
1050 and Y are window text area relative pixel positions.
1052 If this is done during an update, updated_window will contain the
1053 window that is being updated and the position is the future output
1054 cursor position for that window. If updated_window is null, use
1055 selected_window and display the cursor at the given position. */
1058 w32_cursor_to (vpos
, hpos
, y
, x
)
1059 int vpos
, hpos
, y
, x
;
1063 /* If updated_window is not set, work on selected_window. */
1067 w
= XWINDOW (selected_window
);
1069 /* Set the output cursor. */
1070 output_cursor
.hpos
= hpos
;
1071 output_cursor
.vpos
= vpos
;
1072 output_cursor
.x
= x
;
1073 output_cursor
.y
= y
;
1075 /* If not called as part of an update, really display the cursor.
1076 This will also set the cursor position of W. */
1077 if (updated_window
== NULL
)
1080 x_display_cursor (w
, 1, hpos
, vpos
, x
, y
);
1087 /***********************************************************************
1089 ***********************************************************************/
1091 /* Function prototypes of this page. */
1093 static struct face
*x_get_glyph_face_and_encoding
P_ ((struct frame
*,
1097 static struct face
*x_get_char_face_and_encoding
P_ ((struct frame
*, int,
1098 int, wchar_t *, int));
1099 static XCharStruct
*w32_per_char_metric
P_ ((XFontStruct
*,
1101 enum w32_char_font_type
));
1102 static enum w32_char_font_type
1103 w32_encode_char
P_ ((int, wchar_t *, struct font_info
*, int *));
1104 static void x_append_glyph
P_ ((struct it
*));
1105 static void x_append_composite_glyph
P_ ((struct it
*));
1106 static void x_append_stretch_glyph
P_ ((struct it
*it
, Lisp_Object
,
1108 static void x_produce_glyphs
P_ ((struct it
*));
1109 static void x_produce_image_glyph
P_ ((struct it
*it
));
1112 /* Dealing with bits of wchar_t as if they were an XChar2B. */
1113 #define BUILD_WCHAR_T(byte1, byte2) \
1114 ((wchar_t)((((byte1) & 0x00ff) << 8) | ((byte2) & 0x00ff)))
1118 (((ch) & 0xff00) >> 8)
1124 /* Get metrics of character CHAR2B in FONT. Value is always non-null.
1125 If CHAR2B is not contained in FONT, the font's default character
1126 metric is returned. */
1129 w32_bdf_per_char_metric (font
, char2b
, dim
, pcm
)
1135 glyph_metric
* bdf_metric
;
1139 buf
[0] = (char)char2b
;
1142 buf
[0] = BYTE1 (*char2b
);
1143 buf
[1] = BYTE2 (*char2b
);
1146 bdf_metric
= w32_BDF_TextMetric (font
->bdf
, buf
, dim
);
1150 pcm
->width
= bdf_metric
->dwidth
;
1151 pcm
->lbearing
= bdf_metric
->bbox
;
1152 pcm
->rbearing
= bdf_metric
->dwidth
1153 - (bdf_metric
->bbox
+ bdf_metric
->bbw
);
1154 pcm
->ascent
= bdf_metric
->bboy
+ bdf_metric
->bbh
;
1155 pcm
->descent
= -bdf_metric
->bboy
;
1164 w32_native_per_char_metric (font
, char2b
, font_type
, pcm
)
1167 enum w32_char_font_type font_type
;
1170 HDC hdc
= GetDC (NULL
);
1172 BOOL retval
= FALSE
;
1174 xassert (font
&& char2b
);
1175 xassert (font
->hfont
);
1176 xassert (font_type
== UNICODE_FONT
|| font_type
== ANSI_FONT
);
1178 old_font
= SelectObject (hdc
, font
->hfont
);
1180 if ((font
->tm
.tmPitchAndFamily
& TMPF_TRUETYPE
) != 0)
1184 if (font_type
== UNICODE_FONT
)
1185 retval
= GetCharABCWidthsW (hdc
, *char2b
, *char2b
, &char_widths
);
1187 retval
= GetCharABCWidthsA (hdc
, *char2b
, *char2b
, &char_widths
);
1191 pcm
->width
= char_widths
.abcA
+ char_widths
.abcB
+ char_widths
.abcC
;
1192 pcm
->lbearing
= char_widths
.abcA
;
1193 pcm
->rbearing
= pcm
->width
- char_widths
.abcC
;
1194 pcm
->ascent
= FONT_BASE (font
);
1195 pcm
->descent
= FONT_DESCENT (font
);
1201 /* Either font is not a True-type font, or GetCharABCWidthsW
1202 failed (it is not supported on Windows 9x for instance), so we
1203 can't determine the full info we would like. All is not lost
1204 though - we can call GetTextExtentPoint32 to get rbearing and
1205 deduce width based on the font's per-string overhang. lbearing
1206 is assumed to be zero. */
1208 /* TODO: Some Thai characters (and other composites if Windows
1209 supports them) do have lbearing, and report their total width
1210 as zero. Need some way of handling them when
1211 GetCharABCWidthsW fails. */
1214 if (font_type
== UNICODE_FONT
)
1215 retval
= GetTextExtentPoint32W (hdc
, char2b
, 1, &sz
);
1217 retval
= GetTextExtentPoint32A (hdc
, (char*)char2b
, 1, &sz
);
1221 pcm
->width
= sz
.cx
- font
->tm
.tmOverhang
;
1222 pcm
->rbearing
= sz
.cx
;
1224 pcm
->ascent
= FONT_BASE (font
);
1225 pcm
->descent
= FONT_DESCENT (font
);
1230 if (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0)
1235 SelectObject (hdc
, old_font
);
1236 ReleaseDC (NULL
, hdc
);
1242 static XCharStruct
*
1243 w32_per_char_metric (font
, char2b
, font_type
)
1246 enum w32_char_font_type font_type
;
1248 /* The result metric information. */
1252 xassert (font
&& char2b
);
1253 xassert (font_type
!= UNKNOWN_FONT
);
1255 /* Handle the common cases quickly. */
1256 if (font
->per_char
== NULL
)
1257 /* TODO: determine whether char2b exists in font? */
1258 return &font
->max_bounds
;
1259 else if (*char2b
< 128)
1260 return &font
->per_char
[*char2b
];
1262 pcm
= &font
->scratch
;
1264 if (font_type
== BDF_1D_FONT
)
1265 retval
= w32_bdf_per_char_metric (font
, char2b
, 1, pcm
);
1266 else if (font_type
== BDF_2D_FONT
)
1267 retval
= w32_bdf_per_char_metric (font
, char2b
, 2, pcm
);
1269 retval
= w32_native_per_char_metric (font
, char2b
, font_type
, pcm
);
1278 w32_cache_char_metrics (font
)
1281 wchar_t char2b
= L
'x';
1283 /* Cache char metrics for the common cases. */
1286 /* TODO: determine whether font is fixed-pitch. */
1287 if (!w32_bdf_per_char_metric (font
, &char2b
, 1, &font
->max_bounds
))
1289 /* Use the font width and height as max bounds, as not all BDF
1290 fonts contain the letter 'x'. */
1291 font
->max_bounds
.width
= FONT_MAX_WIDTH (font
);
1292 font
->max_bounds
.lbearing
= -font
->bdf
->llx
;
1293 font
->max_bounds
.rbearing
= FONT_MAX_WIDTH (font
) - font
->bdf
->urx
;
1294 font
->max_bounds
.ascent
= FONT_BASE (font
);
1295 font
->max_bounds
.descent
= FONT_DESCENT (font
);
1300 if (((font
->tm
.tmPitchAndFamily
& TMPF_FIXED_PITCH
) != 0)
1301 /* Some fonts (eg DBCS fonts) are marked as fixed width even
1302 though they contain characters of different widths. */
1303 || (font
->tm
.tmMaxCharWidth
!= font
->tm
.tmAveCharWidth
))
1305 /* Font is not fixed pitch, so cache per_char info for the
1306 ASCII characters. It would be much more work, and probably
1307 not worth it, to cache other chars, since we may change
1308 between using Unicode and ANSI text drawing functions at
1312 font
->per_char
= xmalloc (128 * sizeof(XCharStruct
));
1313 for (i
= 0; i
< 128; i
++)
1316 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1317 &font
->per_char
[i
]);
1321 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1327 /* Determine if a font is double byte. */
1328 int w32_font_is_double_byte (XFontStruct
*font
)
1330 return font
->double_byte_p
;
1334 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1335 the two-byte form of C. Encoding is returned in *CHAR2B. */
1337 static INLINE
enum w32_char_font_type
1338 w32_encode_char (c
, char2b
, font_info
, two_byte_p
)
1341 struct font_info
*font_info
;
1344 int charset
= CHAR_CHARSET (c
);
1348 XFontStruct
*font
= font_info
->font
;
1350 xassert (two_byte_p
);
1352 *two_byte_p
= w32_font_is_double_byte (font
);
1354 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1355 This may be either a program in a special encoder language or a
1357 if (font_info
->font_encoder
)
1359 /* It's a program. */
1360 struct ccl_program
*ccl
= font_info
->font_encoder
;
1362 if (CHARSET_DIMENSION (charset
) == 1)
1364 ccl
->reg
[0] = charset
;
1365 ccl
->reg
[1] = BYTE2 (*char2b
);
1369 ccl
->reg
[0] = charset
;
1370 ccl
->reg
[1] = BYTE1 (*char2b
);
1371 ccl
->reg
[2] = BYTE2 (*char2b
);
1374 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
1376 /* We assume that MSBs are appropriately set/reset by CCL
1378 if (!*two_byte_p
) /* 1-byte font */
1379 *char2b
= BUILD_WCHAR_T (0, ccl
->reg
[1]);
1381 *char2b
= BUILD_WCHAR_T (ccl
->reg
[1], ccl
->reg
[2]);
1383 else if (font_info
->encoding
[charset
])
1385 /* Fixed encoding scheme. See fontset.h for the meaning of the
1386 encoding numbers. */
1387 int enc
= font_info
->encoding
[charset
];
1389 if ((enc
== 1 || enc
== 2)
1390 && CHARSET_DIMENSION (charset
) == 2)
1391 *char2b
= BUILD_WCHAR_T (BYTE1 (*char2b
) | 0x80, BYTE2 (*char2b
));
1393 if (enc
== 1 || enc
== 3
1394 || (enc
== 4 && CHARSET_DIMENSION (charset
) == 1))
1395 *char2b
= BUILD_WCHAR_T (BYTE1 (*char2b
), BYTE2 (*char2b
) | 0x80);
1400 ENCODE_SJIS (BYTE1 (*char2b
), BYTE2 (*char2b
),
1402 *char2b
= BUILD_WCHAR_T (sjis1
, sjis2
);
1405 codepage
= w32_codepage_for_font (font_info
->name
);
1407 /* If charset is not ASCII or Latin-1, may need to move it into
1409 if ( font
&& !font
->bdf
&& w32_use_unicode_for_codepage (codepage
)
1410 && charset
!= CHARSET_ASCII
&& charset
!= charset_latin_iso8859_1
)
1413 temp
[0] = BYTE1 (*char2b
);
1414 temp
[1] = BYTE2 (*char2b
);
1416 if (codepage
!= CP_UNICODE
)
1419 MultiByteToWideChar (codepage
, 0, temp
, 2, char2b
, 1);
1421 MultiByteToWideChar (codepage
, 0, temp
+1, 1, char2b
, 1);
1427 return UNKNOWN_FONT
;
1428 else if (font
->bdf
&& CHARSET_DIMENSION (charset
) == 1)
1433 return UNICODE_FONT
;
1439 /* Get face and two-byte form of character C in face FACE_ID on frame
1440 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1441 means we want to display multibyte text. Value is a pointer to a
1442 realized face that is ready for display. */
1444 static INLINE
struct face
*
1445 x_get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
)
1451 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1455 /* Unibyte case. We don't have to encode, but we have to make
1456 sure to use a face suitable for unibyte. */
1457 *char2b
= BUILD_WCHAR_T (0, c
);
1458 face_id
= FACE_FOR_CHAR (f
, face
, c
);
1459 face
= FACE_FROM_ID (f
, face_id
);
1461 else if (c
< 128 && face_id
< BASIC_FACE_ID_SENTINEL
)
1463 /* Case of ASCII in a face known to fit ASCII. */
1464 *char2b
= BUILD_WCHAR_T (0, c
);
1468 int c1
, c2
, charset
;
1470 /* Split characters into bytes. If c2 is -1 afterwards, C is
1471 really a one-byte character so that byte1 is zero. */
1472 SPLIT_CHAR (c
, charset
, c1
, c2
);
1474 *char2b
= BUILD_WCHAR_T (c1
, c2
);
1476 *char2b
= BUILD_WCHAR_T (0, c1
);
1478 /* Maybe encode the character in *CHAR2B. */
1479 if (face
->font
!= NULL
)
1481 struct font_info
*font_info
1482 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1484 w32_encode_char (c
, char2b
, font_info
, &multibyte_p
);
1488 /* Make sure X resources of the face are allocated. */
1489 xassert (face
!= NULL
);
1490 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1496 /* Get face and two-byte form of character glyph GLYPH on frame F.
1497 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1498 a pointer to a realized face that is ready for display. */
1500 static INLINE
struct face
*
1501 x_get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
1503 struct glyph
*glyph
;
1510 xassert (glyph
->type
== CHAR_GLYPH
);
1511 face
= FACE_FROM_ID (f
, glyph
->face_id
);
1516 two_byte_p
= &dummy
;
1518 if (!glyph
->multibyte_p
)
1520 /* Unibyte case. We don't have to encode, but we have to make
1521 sure to use a face suitable for unibyte. */
1522 *char2b
= BUILD_WCHAR_T (0, glyph
->u
.ch
);
1524 else if (glyph
->u
.ch
< 128
1525 && glyph
->face_id
< BASIC_FACE_ID_SENTINEL
)
1527 /* Case of ASCII in a face known to fit ASCII. */
1528 *char2b
= BUILD_WCHAR_T (0, glyph
->u
.ch
);
1532 int c1
, c2
, charset
;
1534 /* Split characters into bytes. If c2 is -1 afterwards, C is
1535 really a one-byte character so that byte1 is zero. */
1536 SPLIT_CHAR (glyph
->u
.ch
, charset
, c1
, c2
);
1538 *char2b
= BUILD_WCHAR_T (c1
, c2
);
1540 *char2b
= BUILD_WCHAR_T (0, c1
);
1542 /* Maybe encode the character in *CHAR2B. */
1543 if (charset
!= CHARSET_ASCII
)
1545 struct font_info
*font_info
1546 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1549 glyph
->w32_font_type
1550 = w32_encode_char (glyph
->u
.ch
, char2b
, font_info
, two_byte_p
);
1555 /* Make sure X resources of the face are allocated. */
1556 xassert (face
!= NULL
);
1557 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1562 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1563 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1569 struct glyph
*glyph
;
1570 enum glyph_row_area area
= it
->area
;
1572 xassert (it
->glyph_row
);
1573 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
1575 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1576 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1578 glyph
->charpos
= CHARPOS (it
->position
);
1579 glyph
->object
= it
->object
;
1580 glyph
->pixel_width
= it
->pixel_width
;
1581 glyph
->voffset
= it
->voffset
;
1582 glyph
->type
= CHAR_GLYPH
;
1583 glyph
->multibyte_p
= it
->multibyte_p
;
1584 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1585 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1586 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1587 || it
->phys_descent
> it
->descent
);
1588 glyph
->padding_p
= 0;
1589 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
1590 glyph
->face_id
= it
->face_id
;
1591 glyph
->u
.ch
= it
->char_to_display
;
1592 glyph
->w32_font_type
= UNKNOWN_FONT
;
1593 ++it
->glyph_row
->used
[area
];
1597 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1598 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1601 x_append_composite_glyph (it
)
1604 struct glyph
*glyph
;
1605 enum glyph_row_area area
= it
->area
;
1607 xassert (it
->glyph_row
);
1609 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1610 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1612 glyph
->charpos
= CHARPOS (it
->position
);
1613 glyph
->object
= it
->object
;
1614 glyph
->pixel_width
= it
->pixel_width
;
1615 glyph
->voffset
= it
->voffset
;
1616 glyph
->type
= COMPOSITE_GLYPH
;
1617 glyph
->multibyte_p
= it
->multibyte_p
;
1618 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1619 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1620 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1621 || it
->phys_descent
> it
->descent
);
1622 glyph
->padding_p
= 0;
1623 glyph
->glyph_not_available_p
= 0;
1624 glyph
->face_id
= it
->face_id
;
1625 glyph
->u
.cmp_id
= it
->cmp_id
;
1626 glyph
->w32_font_type
= UNKNOWN_FONT
;
1627 ++it
->glyph_row
->used
[area
];
1632 /* Change IT->ascent and IT->height according to the setting of
1636 take_vertical_position_into_account (it
)
1641 if (it
->voffset
< 0)
1642 /* Increase the ascent so that we can display the text higher
1644 it
->ascent
+= abs (it
->voffset
);
1646 /* Increase the descent so that we can display the text lower
1648 it
->descent
+= it
->voffset
;
1653 /* Produce glyphs/get display metrics for the image IT is loaded with.
1654 See the description of struct display_iterator in dispextern.h for
1655 an overview of struct display_iterator. */
1658 x_produce_image_glyph (it
)
1664 xassert (it
->what
== IT_IMAGE
);
1666 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1667 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
1670 /* Make sure X resources of the face and image are loaded. */
1671 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1672 prepare_image_for_display (it
->f
, img
);
1674 it
->ascent
= it
->phys_ascent
= image_ascent (img
, face
);
1675 it
->descent
= it
->phys_descent
= img
->height
+ 2 * img
->margin
- it
->ascent
;
1676 it
->pixel_width
= img
->width
+ 2 * img
->margin
;
1680 if (face
->box
!= FACE_NO_BOX
)
1682 it
->ascent
+= face
->box_line_width
;
1683 it
->descent
+= face
->box_line_width
;
1685 if (it
->start_of_box_run_p
)
1686 it
->pixel_width
+= face
->box_line_width
;
1687 if (it
->end_of_box_run_p
)
1688 it
->pixel_width
+= face
->box_line_width
;
1691 take_vertical_position_into_account (it
);
1695 struct glyph
*glyph
;
1696 enum glyph_row_area area
= it
->area
;
1698 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1699 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1701 glyph
->charpos
= CHARPOS (it
->position
);
1702 glyph
->object
= it
->object
;
1703 glyph
->pixel_width
= it
->pixel_width
;
1704 glyph
->voffset
= it
->voffset
;
1705 glyph
->type
= IMAGE_GLYPH
;
1706 glyph
->multibyte_p
= it
->multibyte_p
;
1707 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1708 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1709 glyph
->overlaps_vertically_p
= 0;
1710 glyph
->padding_p
= 0;
1711 glyph
->glyph_not_available_p
= 0;
1712 glyph
->face_id
= it
->face_id
;
1713 glyph
->u
.img_id
= img
->id
;
1714 glyph
->w32_font_type
= UNKNOWN_FONT
;
1715 ++it
->glyph_row
->used
[area
];
1721 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1722 of the glyph, WIDTH and HEIGHT are the width and height of the
1723 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1724 ascent of the glyph (0 <= ASCENT <= 1). */
1727 x_append_stretch_glyph (it
, object
, width
, height
, ascent
)
1733 struct glyph
*glyph
;
1734 enum glyph_row_area area
= it
->area
;
1736 xassert (ascent
>= 0 && ascent
<= 1);
1738 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1739 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1741 glyph
->charpos
= CHARPOS (it
->position
);
1742 glyph
->object
= object
;
1743 glyph
->pixel_width
= width
;
1744 glyph
->voffset
= it
->voffset
;
1745 glyph
->type
= STRETCH_GLYPH
;
1746 glyph
->multibyte_p
= it
->multibyte_p
;
1747 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1748 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1749 glyph
->overlaps_vertically_p
= 0;
1750 glyph
->padding_p
= 0;
1751 glyph
->glyph_not_available_p
= 0;
1752 glyph
->face_id
= it
->face_id
;
1753 glyph
->u
.stretch
.ascent
= height
* ascent
;
1754 glyph
->u
.stretch
.height
= height
;
1755 glyph
->w32_font_type
= UNKNOWN_FONT
;
1756 ++it
->glyph_row
->used
[area
];
1761 /* Produce a stretch glyph for iterator IT. IT->object is the value
1762 of the glyph property displayed. The value must be a list
1763 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1766 1. `:width WIDTH' specifies that the space should be WIDTH *
1767 canonical char width wide. WIDTH may be an integer or floating
1770 2. `:relative-width FACTOR' specifies that the width of the stretch
1771 should be computed from the width of the first character having the
1772 `glyph' property, and should be FACTOR times that width.
1774 3. `:align-to HPOS' specifies that the space should be wide enough
1775 to reach HPOS, a value in canonical character units.
1777 Exactly one of the above pairs must be present.
1779 4. `:height HEIGHT' specifies that the height of the stretch produced
1780 should be HEIGHT, measured in canonical character units.
1782 5. `:relative-height FACTOR' specifies that the height of the the
1783 stretch should be FACTOR times the height of the characters having
1786 Either none or exactly one of 4 or 5 must be present.
1788 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1789 of the stretch should be used for the ascent of the stretch.
1790 ASCENT must be in the range 0 <= ASCENT <= 100. */
1793 ((INTEGERP (X) || FLOATP (X)) \
1799 x_produce_stretch_glyph (it
)
1802 /* (space :width WIDTH :height HEIGHT. */
1803 extern Lisp_Object QCwidth
, QCheight
, QCascent
, Qspace
;
1804 extern Lisp_Object QCrelative_width
, QCrelative_height
;
1805 extern Lisp_Object QCalign_to
;
1806 Lisp_Object prop
, plist
;
1807 double width
= 0, height
= 0, ascent
= 0;
1808 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1809 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
1811 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
1813 /* List should start with `space'. */
1814 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
1815 plist
= XCDR (it
->object
);
1817 /* Compute the width of the stretch. */
1818 if (prop
= Fplist_get (plist
, QCwidth
),
1820 /* Absolute width `:width WIDTH' specified and valid. */
1821 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
);
1822 else if (prop
= Fplist_get (plist
, QCrelative_width
),
1825 /* Relative width `:relative-width FACTOR' specified and valid.
1826 Compute the width of the characters having the `glyph'
1829 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
1832 if (it
->multibyte_p
)
1834 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
1835 - IT_BYTEPOS (*it
));
1836 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
1839 it2
.c
= *p
, it2
.len
= 1;
1841 it2
.glyph_row
= NULL
;
1842 it2
.what
= IT_CHARACTER
;
1843 x_produce_glyphs (&it2
);
1844 width
= NUMVAL (prop
) * it2
.pixel_width
;
1846 else if (prop
= Fplist_get (plist
, QCalign_to
),
1848 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
) - it
->current_x
;
1850 /* Nothing specified -> width defaults to canonical char width. */
1851 width
= CANON_X_UNIT (it
->f
);
1853 /* Compute height. */
1854 if (prop
= Fplist_get (plist
, QCheight
),
1856 height
= NUMVAL (prop
) * CANON_Y_UNIT (it
->f
);
1857 else if (prop
= Fplist_get (plist
, QCrelative_height
),
1859 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
1861 height
= FONT_HEIGHT (font
);
1863 /* Compute percentage of height used for ascent. If
1864 `:ascent ASCENT' is present and valid, use that. Otherwise,
1865 derive the ascent from the font in use. */
1866 if (prop
= Fplist_get (plist
, QCascent
),
1867 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
1868 ascent
= NUMVAL (prop
) / 100.0;
1870 ascent
= (double) FONT_BASE (font
) / FONT_HEIGHT (font
);
1879 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
1880 if (!STRINGP (object
))
1881 object
= it
->w
->buffer
;
1882 x_append_stretch_glyph (it
, object
, width
, height
, ascent
);
1885 it
->pixel_width
= width
;
1886 it
->ascent
= it
->phys_ascent
= height
* ascent
;
1887 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
1890 if (face
->box
!= FACE_NO_BOX
)
1892 it
->ascent
+= face
->box_line_width
;
1893 it
->descent
+= face
->box_line_width
;
1895 if (it
->start_of_box_run_p
)
1896 it
->pixel_width
+= face
->box_line_width
;
1897 if (it
->end_of_box_run_p
)
1898 it
->pixel_width
+= face
->box_line_width
;
1901 take_vertical_position_into_account (it
);
1904 /* Return proper value to be used as baseline offset of font that has
1905 ASCENT and DESCENT to draw characters by the font at the vertical
1906 center of the line of frame F.
1908 Here, out task is to find the value of BOFF in the following figure;
1910 -------------------------+-----------+-
1911 -+-+---------+-+ | |
1913 | | | | F_ASCENT F_HEIGHT
1916 | | |-|-+------+-----------|------- baseline
1918 | |---------|-+-+ | |
1920 -+-+---------+-+ F_DESCENT |
1921 -------------------------+-----------+-
1923 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1924 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1925 DESCENT = FONT->descent
1926 HEIGHT = FONT_HEIGHT (FONT)
1927 F_DESCENT = (F->output_data.x->font->descent
1928 - F->output_data.x->baseline_offset)
1929 F_HEIGHT = FRAME_LINE_HEIGHT (F)
1932 #define VCENTER_BASELINE_OFFSET(FONT, F) \
1933 (FONT_DESCENT (FONT) \
1934 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
1935 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
1936 - (FONT_DESCENT (FRAME_FONT (F)) - FRAME_BASELINE_OFFSET (F)))
1938 /* Produce glyphs/get display metrics for the display element IT is
1939 loaded with. See the description of struct display_iterator in
1940 dispextern.h for an overview of struct display_iterator. */
1943 x_produce_glyphs (it
)
1946 it
->glyph_not_available_p
= 0;
1948 if (it
->what
== IT_CHARACTER
)
1952 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1954 int font_not_found_p
;
1955 struct font_info
*font_info
;
1956 int boff
; /* baseline offset */
1957 /* We may change it->multibyte_p upon unibyte<->multibyte
1958 conversion. So, save the current value now and restore it
1961 Note: It seems that we don't have to record multibyte_p in
1962 struct glyph because the character code itself tells if or
1963 not the character is multibyte. Thus, in the future, we must
1964 consider eliminating the field `multibyte_p' in the struct
1967 int saved_multibyte_p
= it
->multibyte_p
;
1969 /* Maybe translate single-byte characters to multibyte, or the
1971 it
->char_to_display
= it
->c
;
1972 if (!ASCII_BYTE_P (it
->c
))
1974 if (unibyte_display_via_language_environment
1975 && SINGLE_BYTE_CHAR_P (it
->c
)
1977 || !NILP (Vnonascii_translation_table
)))
1979 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
1980 it
->multibyte_p
= 1;
1981 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1982 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1984 else if (!SINGLE_BYTE_CHAR_P (it
->c
)
1985 && !it
->multibyte_p
)
1987 it
->char_to_display
= multibyte_char_to_unibyte (it
->c
, Qnil
);
1988 it
->multibyte_p
= 0;
1989 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
1990 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
1994 /* Get font to use. Encode IT->char_to_display. */
1995 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
1996 it
->face_id
, &char2b
,
2000 /* When no suitable font found, use the default font. */
2001 font_not_found_p
= font
== NULL
;
2002 if (font_not_found_p
)
2004 font
= FRAME_FONT (it
->f
);
2005 boff
= it
->f
->output_data
.w32
->baseline_offset
;
2010 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2011 boff
= font_info
->baseline_offset
;
2012 if (font_info
->vertical_centering
)
2013 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2016 if (it
->char_to_display
>= ' '
2017 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
2019 /* Either unibyte or ASCII. */
2024 pcm
= w32_per_char_metric (font
, &char2b
,
2025 font
->bdf
? BDF_1D_FONT
: ANSI_FONT
);
2026 it
->ascent
= FONT_BASE (font
) + boff
;
2027 it
->descent
= FONT_DESCENT (font
) - boff
;
2031 it
->phys_ascent
= pcm
->ascent
+ boff
;
2032 it
->phys_descent
= pcm
->descent
- boff
;
2033 it
->pixel_width
= pcm
->width
;
2037 it
->glyph_not_available_p
= 1;
2038 it
->phys_ascent
= FONT_BASE (font
) + boff
;
2039 it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2040 it
->pixel_width
= FONT_WIDTH (font
);
2043 /* If this is a space inside a region of text with
2044 `space-width' property, change its width. */
2045 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
2047 it
->pixel_width
*= XFLOATINT (it
->space_width
);
2049 /* If face has a box, add the box thickness to the character
2050 height. If character has a box line to the left and/or
2051 right, add the box line width to the character's width. */
2052 if (face
->box
!= FACE_NO_BOX
)
2054 int thick
= face
->box_line_width
;
2056 it
->ascent
+= thick
;
2057 it
->descent
+= thick
;
2059 if (it
->start_of_box_run_p
)
2060 it
->pixel_width
+= thick
;
2061 if (it
->end_of_box_run_p
)
2062 it
->pixel_width
+= thick
;
2065 /* If face has an overline, add the height of the overline
2066 (1 pixel) and a 1 pixel margin to the character height. */
2067 if (face
->overline_p
)
2070 take_vertical_position_into_account (it
);
2072 /* If we have to actually produce glyphs, do it. */
2077 /* Translate a space with a `space-width' property
2078 into a stretch glyph. */
2079 double ascent
= (double) FONT_BASE (font
)
2080 / FONT_HEIGHT (font
);
2081 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
2082 it
->ascent
+ it
->descent
, ascent
);
2085 x_append_glyph (it
);
2087 /* If characters with lbearing or rbearing are displayed
2088 in this line, record that fact in a flag of the
2089 glyph row. This is used to optimize X output code. */
2090 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
2091 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2094 else if (it
->char_to_display
== '\n')
2096 /* A newline has no width but we need the height of the line. */
2097 it
->pixel_width
= 0;
2099 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
2100 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2102 if (face
->box
!= FACE_NO_BOX
)
2104 int thick
= face
->box_line_width
;
2105 it
->ascent
+= thick
;
2106 it
->descent
+= thick
;
2109 else if (it
->char_to_display
== '\t')
2111 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
2112 int x
= it
->current_x
+ it
->continuation_lines_width
;
2113 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
2115 /* If the distance from the current position to the next tab
2116 stop is less than a canonical character width, use the
2117 tab stop after that. */
2118 if (next_tab_x
- x
< CANON_X_UNIT (it
->f
))
2119 next_tab_x
+= tab_width
;
2121 it
->pixel_width
= next_tab_x
- x
;
2123 it
->ascent
= it
->phys_ascent
= FONT_BASE (font
) + boff
;
2124 it
->descent
= it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2128 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
2129 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
2130 it
->ascent
+ it
->descent
, ascent
);
2135 /* A multi-byte character.
2136 If we found a font, this font should give us the right
2137 metrics. If we didn't find a font, use the frame's
2138 default font and calculate the width of the character
2139 from the charset width; this is what old redisplay code
2141 enum w32_char_font_type type
;
2143 if (font
->bdf
&& CHARSET_DIMENSION (CHAR_CHARSET (it
->c
)) == 1)
2148 type
= UNICODE_FONT
;
2150 pcm
= w32_per_char_metric (font
, &char2b
, type
);
2152 if (font_not_found_p
|| !pcm
)
2154 int charset
= CHAR_CHARSET (it
->char_to_display
);
2156 it
->glyph_not_available_p
= 1;
2157 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
2158 * CHARSET_WIDTH (charset
));
2159 it
->phys_ascent
= FONT_BASE (font
) + boff
;
2160 it
->phys_descent
= FONT_DESCENT (font
) - boff
;
2164 it
->pixel_width
= pcm
->width
;
2165 it
->phys_ascent
= pcm
->ascent
+ boff
;
2166 it
->phys_descent
= pcm
->descent
- boff
;
2168 && (pcm
->lbearing
< 0
2169 || pcm
->rbearing
> pcm
->width
))
2170 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2173 it
->ascent
= FONT_BASE (font
) + boff
;
2174 it
->descent
= FONT_DESCENT (font
) - boff
;
2176 if (face
->box
!= FACE_NO_BOX
)
2178 int thick
= face
->box_line_width
;
2179 it
->ascent
+= thick
;
2180 it
->descent
+= thick
;
2182 if (it
->start_of_box_run_p
)
2183 it
->pixel_width
+= thick
;
2184 if (it
->end_of_box_run_p
)
2185 it
->pixel_width
+= thick
;
2188 /* If face has an overline, add the height of the overline
2189 (1 pixel) and a 1 pixel margin to the character height. */
2190 if (face
->overline_p
)
2193 take_vertical_position_into_account (it
);
2196 x_append_glyph (it
);
2198 it
->multibyte_p
= saved_multibyte_p
;
2200 else if (it
->what
== IT_COMPOSITION
)
2202 /* Note: A composition is represented as one glyph in the
2203 glyph matrix. There are no padding glyphs. */
2206 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2208 int font_not_found_p
;
2209 struct font_info
*font_info
;
2210 int boff
; /* baseline offset */
2211 struct composition
*cmp
= composition_table
[it
->cmp_id
];
2213 /* Maybe translate single-byte characters to multibyte. */
2214 it
->char_to_display
= it
->c
;
2215 if (unibyte_display_via_language_environment
2216 && SINGLE_BYTE_CHAR_P (it
->c
)
2219 && !NILP (Vnonascii_translation_table
))))
2221 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2224 /* Get face and font to use. Encode IT->char_to_display. */
2225 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2226 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2227 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2228 it
->face_id
, &char2b
, it
->multibyte_p
);
2231 /* When no suitable font found, use the default font. */
2232 font_not_found_p
= font
== NULL
;
2233 if (font_not_found_p
)
2235 font
= FRAME_FONT (it
->f
);
2236 boff
= it
->f
->output_data
.w32
->baseline_offset
;
2241 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2242 boff
= font_info
->baseline_offset
;
2243 if (font_info
->vertical_centering
)
2244 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2247 /* There are no padding glyphs, so there is only one glyph to
2248 produce for the composition. Important is that pixel_width,
2249 ascent and descent are the values of what is drawn by
2250 draw_glyphs (i.e. the values of the overall glyphs composed). */
2253 /* If we have not yet calculated pixel size data of glyphs of
2254 the composition for the current face font, calculate them
2255 now. Theoretically, we have to check all fonts for the
2256 glyphs, but that requires much time and memory space. So,
2257 here we check only the font of the first glyph. This leads
2258 to incorrect display very rarely, and C-l (recenter) can
2259 correct the display anyway. */
2260 if (cmp
->font
!= (void *) font
)
2262 /* Ascent and descent of the font of the first character of
2263 this composition (adjusted by baseline offset). Ascent
2264 and descent of overall glyphs should not be less than
2265 them respectively. */
2266 int font_ascent
= FONT_BASE (font
) + boff
;
2267 int font_descent
= FONT_DESCENT (font
) - boff
;
2268 /* Bounding box of the overall glyphs. */
2269 int leftmost
, rightmost
, lowest
, highest
;
2270 int i
, width
, ascent
, descent
;
2271 enum w32_char_font_type font_type
;
2273 cmp
->font
= (void *) font
;
2275 if (font
->bdf
&& CHARSET_DIMENSION (CHAR_CHARSET (it
->c
)) == 1)
2276 font_type
= BDF_1D_FONT
;
2278 font_type
= BDF_2D_FONT
;
2280 font_type
= UNICODE_FONT
;
2282 /* Initialize the bounding box. */
2283 pcm
= w32_per_char_metric (font
, &char2b
, font_type
);
2287 ascent
= pcm
->ascent
;
2288 descent
= pcm
->descent
;
2292 width
= FONT_WIDTH (font
);
2293 ascent
= FONT_BASE (font
);
2294 descent
= FONT_DESCENT (font
);
2298 lowest
= - descent
+ boff
;
2299 highest
= ascent
+ boff
;
2303 && font_info
->default_ascent
2304 && CHAR_TABLE_P (Vuse_default_ascent
)
2305 && !NILP (Faref (Vuse_default_ascent
,
2306 make_number (it
->char_to_display
))))
2307 highest
= font_info
->default_ascent
+ boff
;
2309 /* Draw the first glyph at the normal position. It may be
2310 shifted to right later if some other glyphs are drawn at
2312 cmp
->offsets
[0] = 0;
2313 cmp
->offsets
[1] = boff
;
2315 /* Set cmp->offsets for the remaining glyphs. */
2316 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2318 int left
, right
, btm
, top
;
2319 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2320 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2322 face
= FACE_FROM_ID (it
->f
, face_id
);
2323 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2328 font
= FRAME_FONT (it
->f
);
2329 boff
= it
->f
->output_data
.w32
->baseline_offset
;
2335 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2336 boff
= font_info
->baseline_offset
;
2337 if (font_info
->vertical_centering
)
2338 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2341 if (font
->bdf
&& CHARSET_DIMENSION (CHAR_CHARSET (ch
)) == 1)
2342 font_type
= BDF_1D_FONT
;
2344 font_type
= BDF_2D_FONT
;
2346 font_type
= UNICODE_FONT
;
2348 pcm
= w32_per_char_metric (font
, &char2b
, font_type
);
2352 ascent
= pcm
->ascent
;
2353 descent
= pcm
->descent
;
2357 width
= FONT_WIDTH (font
);
2358 ascent
= FONT_BASE (font
);
2359 descent
= FONT_DESCENT (font
);
2362 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2364 /* Relative composition with or without
2366 left
= (leftmost
+ rightmost
- width
) / 2;
2367 btm
= - descent
+ boff
;
2368 if (font_info
&& font_info
->relative_compose
2369 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2370 || NILP (Faref (Vignore_relative_composition
,
2371 make_number (ch
)))))
2374 if (- descent
>= font_info
->relative_compose
)
2375 /* One extra pixel between two glyphs. */
2377 else if (ascent
<= 0)
2378 /* One extra pixel between two glyphs. */
2379 btm
= lowest
- 1 - ascent
- descent
;
2384 /* A composition rule is specified by an integer
2385 value that encodes global and new reference
2386 points (GREF and NREF). GREF and NREF are
2387 specified by numbers as below:
2395 ---3---4---5--- baseline
2397 6---7---8 -- descent
2399 int rule
= COMPOSITION_RULE (cmp
, i
);
2400 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2402 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2403 grefx
= gref
% 3, nrefx
= nref
% 3;
2404 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2407 + grefx
* (rightmost
- leftmost
) / 2
2408 - nrefx
* width
/ 2);
2409 btm
= ((grefy
== 0 ? highest
2411 : grefy
== 2 ? lowest
2412 : (highest
+ lowest
) / 2)
2413 - (nrefy
== 0 ? ascent
+ descent
2414 : nrefy
== 1 ? descent
- boff
2416 : (ascent
+ descent
) / 2));
2419 cmp
->offsets
[i
* 2] = left
;
2420 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
2422 /* Update the bounding box of the overall glyphs. */
2423 right
= left
+ width
;
2424 top
= btm
+ descent
+ ascent
;
2425 if (left
< leftmost
)
2427 if (right
> rightmost
)
2435 /* If there are glyphs whose x-offsets are negative,
2436 shift all glyphs to the right and make all x-offsets
2440 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2441 cmp
->offsets
[i
* 2] -= leftmost
;
2442 rightmost
-= leftmost
;
2445 cmp
->pixel_width
= rightmost
;
2446 cmp
->ascent
= highest
;
2447 cmp
->descent
= - lowest
;
2448 if (cmp
->ascent
< font_ascent
)
2449 cmp
->ascent
= font_ascent
;
2450 if (cmp
->descent
< font_descent
)
2451 cmp
->descent
= font_descent
;
2454 it
->pixel_width
= cmp
->pixel_width
;
2455 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2456 it
->descent
= it
->phys_descent
= cmp
->descent
;
2458 if (face
->box
!= FACE_NO_BOX
)
2460 int thick
= face
->box_line_width
;
2461 it
->ascent
+= thick
;
2462 it
->descent
+= thick
;
2464 if (it
->start_of_box_run_p
)
2465 it
->pixel_width
+= thick
;
2466 if (it
->end_of_box_run_p
)
2467 it
->pixel_width
+= thick
;
2470 /* If face has an overline, add the height of the overline
2471 (1 pixel) and a 1 pixel margin to the character height. */
2472 if (face
->overline_p
)
2475 take_vertical_position_into_account (it
);
2478 x_append_composite_glyph (it
);
2480 else if (it
->what
== IT_IMAGE
)
2481 x_produce_image_glyph (it
);
2482 else if (it
->what
== IT_STRETCH
)
2483 x_produce_stretch_glyph (it
);
2485 /* Accumulate dimensions. */
2486 xassert (it
->ascent
>= 0 && it
->descent
> 0);
2487 if (it
->area
== TEXT_AREA
)
2488 it
->current_x
+= it
->pixel_width
;
2490 it
->descent
+= it
->extra_line_spacing
;
2492 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2493 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2494 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2495 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2499 /* Estimate the pixel height of the mode or top line on frame F.
2500 FACE_ID specifies what line's height to estimate. */
2503 x_estimate_mode_line_height (f
, face_id
)
2505 enum face_id face_id
;
2509 /* This function is called so early when Emacs starts that the face
2510 cache and mode line face are not yet initialized. */
2511 if (FRAME_FACE_CACHE (f
))
2513 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2515 height
= FONT_HEIGHT (face
->font
) + 2 * face
->box_line_width
;
2524 w32_use_unicode_for_codepage (codepage
)
2527 /* If the current codepage is supported, use Unicode for output. */
2528 return (w32_enable_unicode_output
2529 && codepage
!= CP_8BIT
2530 && (codepage
== CP_UNICODE
|| IsValidCodePage (codepage
)));
2534 /***********************************************************************
2536 ***********************************************************************/
2538 /* A sequence of glyphs to be drawn in the same face.
2540 This data structure is not really completely X specific, so it
2541 could possibly, at least partially, be useful for other systems. It
2542 is currently not part of the external redisplay interface because
2543 it's not clear what other systems will need. */
2547 /* X-origin of the string. */
2550 /* Y-origin and y-position of the base line of this string. */
2553 /* The width of the string, not including a face extension. */
2556 /* The width of the string, including a face extension. */
2557 int background_width
;
2559 /* The height of this string. This is the height of the line this
2560 string is drawn in, and can be different from the height of the
2561 font the string is drawn in. */
2564 /* Number of pixels this string overwrites in front of its x-origin.
2565 This number is zero if the string has an lbearing >= 0; it is
2566 -lbearing, if the string has an lbearing < 0. */
2569 /* Number of pixels this string overwrites past its right-most
2570 nominal x-position, i.e. x + width. Zero if the string's
2571 rbearing is <= its nominal width, rbearing - width otherwise. */
2574 /* The frame on which the glyph string is drawn. */
2577 /* The window on which the glyph string is drawn. */
2580 /* X display and window for convenience. */
2583 /* The glyph row for which this string was built. It determines the
2584 y-origin and height of the string. */
2585 struct glyph_row
*row
;
2587 /* The area within row. */
2588 enum glyph_row_area area
;
2590 /* Characters to be drawn, and number of characters. */
2594 /* A face-override for drawing cursors, mouse face and similar. */
2595 enum draw_glyphs_face hl
;
2597 /* Face in which this string is to be drawn. */
2600 /* Font in which this string is to be drawn. */
2603 /* Font info for this string. */
2604 struct font_info
*font_info
;
2606 /* Non-null means this string describes (part of) a composition.
2607 All characters from char2b are drawn composed. */
2608 struct composition
*cmp
;
2610 /* Index of this glyph string's first character in the glyph
2611 definition of CMP. If this is zero, this glyph string describes
2612 the first character of a composition. */
2615 /* 1 means this glyph strings face has to be drawn to the right end
2616 of the window's drawing area. */
2617 unsigned extends_to_end_of_line_p
: 1;
2619 /* 1 means the background of this string has been drawn. */
2620 unsigned background_filled_p
: 1;
2622 /* 1 means glyph string must be drawn with 16-bit functions. */
2623 unsigned two_byte_p
: 1;
2625 /* 1 means that the original font determined for drawing this glyph
2626 string could not be loaded. The member `font' has been set to
2627 the frame's default font in this case. */
2628 unsigned font_not_found_p
: 1;
2630 /* 1 means that the face in which this glyph string is drawn has a
2632 unsigned stippled_p
: 1;
2634 /* 1 means only the foreground of this glyph string must be drawn,
2635 and we should use the physical height of the line this glyph
2636 string appears in as clip rect. */
2637 unsigned for_overlaps_p
: 1;
2639 /* The GC to use for drawing this glyph string. */
2644 /* A pointer to the first glyph in the string. This glyph
2645 corresponds to char2b[0]. Needed to draw rectangles if
2646 font_not_found_p is 1. */
2647 struct glyph
*first_glyph
;
2649 /* Image, if any. */
2652 struct glyph_string
*next
, *prev
;
2656 /* Encapsulate the different ways of displaying text under W32. */
2658 void W32_TEXTOUT (s
, x
, y
,chars
,nchars
)
2659 struct glyph_string
* s
;
2664 int charset_dim
= w32_font_is_double_byte (s
->gc
->font
) ? 2 : 1;
2665 if (s
->gc
->font
->bdf
)
2666 w32_BDF_TextOut (s
->gc
->font
->bdf
, s
->hdc
,
2667 x
, y
, (char *) chars
, charset_dim
,
2668 nchars
* charset_dim
, 0);
2669 else if (s
->first_glyph
->w32_font_type
== UNICODE_FONT
)
2670 ExtTextOutW (s
->hdc
, x
, y
, 0, NULL
, chars
, nchars
, NULL
);
2672 ExtTextOut (s
->hdc
, x
, y
, 0, NULL
, (char *) chars
,
2673 nchars
* charset_dim
, NULL
);
2679 x_dump_glyph_string (s
)
2680 struct glyph_string
*s
;
2682 fprintf (stderr
, "glyph string\n");
2683 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2684 s
->x
, s
->y
, s
->width
, s
->height
);
2685 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2686 fprintf (stderr
, " hl = %d\n", s
->hl
);
2687 fprintf (stderr
, " left overhang = %d, right = %d\n",
2688 s
->left_overhang
, s
->right_overhang
);
2689 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2690 fprintf (stderr
, " extends to end of line = %d\n",
2691 s
->extends_to_end_of_line_p
);
2692 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2693 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2696 #endif /* GLYPH_DEBUG */
2700 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
2701 struct glyph_string
**,
2702 struct glyph_string
*,
2703 struct glyph_string
*));
2704 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
2705 struct glyph_string
**,
2706 struct glyph_string
*,
2707 struct glyph_string
*));
2708 static void x_append_glyph_string
P_ ((struct glyph_string
**,
2709 struct glyph_string
**,
2710 struct glyph_string
*));
2711 static int x_left_overwritten
P_ ((struct glyph_string
*));
2712 static int x_left_overwriting
P_ ((struct glyph_string
*));
2713 static int x_right_overwritten
P_ ((struct glyph_string
*));
2714 static int x_right_overwriting
P_ ((struct glyph_string
*));
2715 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int,
2717 static void w32_init_glyph_string
P_ ((struct glyph_string
*, HDC hdc
,
2718 wchar_t *, struct window
*,
2720 enum glyph_row_area
, int,
2721 enum draw_glyphs_face
));
2722 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
2723 enum glyph_row_area
, int, int,
2724 enum draw_glyphs_face
, int *, int *, int));
2725 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2726 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2727 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2729 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2730 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2731 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2732 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2733 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2734 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2735 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2736 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2737 static void w32_get_glyph_overhangs
P_ ((HDC hdc
, struct glyph
*,
2740 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
2741 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
2742 static void w32_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2743 double, int, COLORREF
));
2744 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2745 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2746 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2747 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2748 static void w32_draw_image_foreground_1
P_ ((struct glyph_string
*, HBITMAP
));
2749 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
2750 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2752 static void w32_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2753 int, int, int, int, RECT
*));
2754 static void w32_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2755 int, int, int, RECT
*));
2756 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
2757 enum glyph_row_area
));
2760 /* Append the list of glyph strings with head H and tail T to the list
2761 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2764 x_append_glyph_string_lists (head
, tail
, h
, t
)
2765 struct glyph_string
**head
, **tail
;
2766 struct glyph_string
*h
, *t
;
2780 /* Prepend the list of glyph strings with head H and tail T to the
2781 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2785 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
2786 struct glyph_string
**head
, **tail
;
2787 struct glyph_string
*h
, *t
;
2801 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2802 Set *HEAD and *TAIL to the resulting list. */
2805 x_append_glyph_string (head
, tail
, s
)
2806 struct glyph_string
**head
, **tail
;
2807 struct glyph_string
*s
;
2809 s
->next
= s
->prev
= NULL
;
2810 x_append_glyph_string_lists (head
, tail
, s
, s
);
2814 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2819 struct glyph_string
*s
;
2821 if (s
->font
== FRAME_FONT (s
->f
)
2822 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2823 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2825 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
2828 /* Cursor on non-default face: must merge. */
2832 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
2833 xgcv
.foreground
= s
->face
->background
;
2835 /* If the glyph would be invisible, try a different foreground. */
2836 if (xgcv
.foreground
== xgcv
.background
)
2837 xgcv
.foreground
= s
->face
->foreground
;
2838 if (xgcv
.foreground
== xgcv
.background
)
2839 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
2840 if (xgcv
.foreground
== xgcv
.background
)
2841 xgcv
.foreground
= s
->face
->foreground
;
2843 /* Make sure the cursor is distinct from text in this face. */
2844 if (xgcv
.background
== s
->face
->background
2845 && xgcv
.foreground
== s
->face
->foreground
)
2847 xgcv
.background
= s
->face
->foreground
;
2848 xgcv
.foreground
= s
->face
->background
;
2851 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2852 xgcv
.font
= s
->font
;
2853 mask
= GCForeground
| GCBackground
| GCFont
;
2855 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2856 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2859 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2860 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
2862 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2867 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2870 x_set_mouse_face_gc (s
)
2871 struct glyph_string
*s
;
2876 /* What face has to be used for the mouse face? */
2877 face_id
= FRAME_W32_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2878 face
= FACE_FROM_ID (s
->f
, face_id
);
2879 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2880 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2881 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2883 /* If font in this face is same as S->font, use it. */
2884 if (s
->font
== s
->face
->font
)
2885 s
->gc
= s
->face
->gc
;
2888 /* Otherwise construct scratch_cursor_gc with values from FACE
2893 xgcv
.background
= s
->face
->background
;
2894 xgcv
.foreground
= s
->face
->foreground
;
2895 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2896 xgcv
.font
= s
->font
;
2897 mask
= GCForeground
| GCBackground
| GCFont
;
2899 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2900 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2903 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2904 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
2906 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2909 xassert (s
->gc
!= 0);
2913 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2914 Faces to use in the mode line have already been computed when the
2915 matrix was built, so there isn't much to do, here. */
2918 x_set_mode_line_face_gc (s
)
2919 struct glyph_string
*s
;
2921 s
->gc
= s
->face
->gc
;
2925 /* Set S->gc of glyph string S for drawing that glyph string. Set
2926 S->stippled_p to a non-zero value if the face of S has a stipple
2930 x_set_glyph_string_gc (s
)
2931 struct glyph_string
*s
;
2933 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2935 if (s
->hl
== DRAW_NORMAL_TEXT
)
2937 s
->gc
= s
->face
->gc
;
2938 s
->stippled_p
= s
->face
->stipple
!= 0;
2940 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
2942 x_set_mode_line_face_gc (s
);
2943 s
->stippled_p
= s
->face
->stipple
!= 0;
2945 else if (s
->hl
== DRAW_CURSOR
)
2947 x_set_cursor_gc (s
);
2950 else if (s
->hl
== DRAW_MOUSE_FACE
)
2952 x_set_mouse_face_gc (s
);
2953 s
->stippled_p
= s
->face
->stipple
!= 0;
2955 else if (s
->hl
== DRAW_IMAGE_RAISED
2956 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2958 s
->gc
= s
->face
->gc
;
2959 s
->stippled_p
= s
->face
->stipple
!= 0;
2963 s
->gc
= s
->face
->gc
;
2964 s
->stippled_p
= s
->face
->stipple
!= 0;
2967 /* GC must have been set. */
2968 xassert (s
->gc
!= 0);
2972 /* Return in *R the clipping rectangle for glyph string S. */
2975 w32_get_glyph_string_clip_rect (s
, r
)
2976 struct glyph_string
*s
;
2979 int r_height
, r_width
;
2981 if (s
->row
->full_width_p
)
2983 /* Draw full-width. X coordinates are relative to S->w->left. */
2984 int canon_x
= CANON_X_UNIT (s
->f
);
2986 r
->left
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
2987 r_width
= XFASTINT (s
->w
->width
) * canon_x
;
2989 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
2991 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
2992 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
2996 r
->left
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
2998 /* Unless displaying a mode or menu bar line, which are always
2999 fully visible, clip to the visible part of the row. */
3000 if (s
->w
->pseudo_window_p
)
3001 r_height
= s
->row
->visible_height
;
3003 r_height
= s
->height
;
3007 /* This is a text line that may be partially visible. */
3008 r
->left
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
3009 r_width
= window_box_width (s
->w
, s
->area
);
3010 r_height
= s
->row
->visible_height
;
3013 /* Don't use S->y for clipping because it doesn't take partially
3014 visible lines into account. For example, it can be negative for
3015 partially visible lines at the top of a window. */
3016 if (!s
->row
->full_width_p
3017 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
3018 r
->top
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
3020 r
->top
= max (0, s
->row
->y
);
3022 /* If drawing a tool-bar window, draw it over the internal border
3023 at the top of the window. */
3024 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
3025 r
->top
-= s
->f
->output_data
.w32
->internal_border_width
;
3027 /* If S draws overlapping rows, it's sufficient to use the top and
3028 bottom of the window for clipping because this glyph string
3029 intentionally draws over other lines. */
3030 if (s
->for_overlaps_p
)
3032 r
->top
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
3033 r_height
= window_text_bottom_y (s
->w
) - r
->top
;
3036 r
->top
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->top
);
3038 r
->bottom
= r
->top
+ r_height
;
3039 r
->right
= r
->left
+ r_width
;
3043 /* Set clipping for output of glyph string S. S may be part of a mode
3044 line or menu if we don't have X toolkit support. */
3047 x_set_glyph_string_clipping (s
)
3048 struct glyph_string
*s
;
3051 w32_get_glyph_string_clip_rect (s
, &r
);
3052 w32_set_clip_rectangle (s
->hdc
, &r
);
3056 /* Compute left and right overhang of glyph string S. If S is a glyph
3057 string for a composition, assume overhangs don't exist. */
3060 x_compute_glyph_string_overhangs (s
)
3061 struct glyph_string
*s
;
3063 /* TODO: Windows does not appear to have a method for
3064 getting this info without getting the ABC widths for each
3065 individual character and working it out manually. */
3069 /* Compute overhangs and x-positions for glyph string S and its
3070 predecessors, or successors. X is the starting x-position for S.
3071 BACKWARD_P non-zero means process predecessors. */
3074 x_compute_overhangs_and_x (s
, x
, backward_p
)
3075 struct glyph_string
*s
;
3083 x_compute_glyph_string_overhangs (s
);
3093 x_compute_glyph_string_overhangs (s
);
3102 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
3103 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
3104 assumed to be zero. */
3107 w32_get_glyph_overhangs (hdc
, glyph
, f
, left
, right
)
3109 struct glyph
*glyph
;
3117 if (glyph
->type
== CHAR_GLYPH
)
3124 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
3128 && (pcm
= w32_per_char_metric (font
, &char2b
,
3129 glyph
->w32_font_type
)))
3131 if (pcm
->rbearing
> pcm
->width
)
3132 *right
= pcm
->rbearing
- pcm
->width
;
3133 if (pcm
->lbearing
< 0)
3134 *left
= -pcm
->lbearing
;
3141 x_get_glyph_overhangs (glyph
, f
, left
, right
)
3142 struct glyph
*glyph
;
3146 HDC hdc
= get_frame_dc (f
);
3147 /* Convert to unicode! */
3148 w32_get_glyph_overhangs (hdc
, glyph
, f
, left
, right
);
3149 release_frame_dc (f
, hdc
);
3153 /* Return the index of the first glyph preceding glyph string S that
3154 is overwritten by S because of S's left overhang. Value is -1
3155 if no glyphs are overwritten. */
3158 x_left_overwritten (s
)
3159 struct glyph_string
*s
;
3163 if (s
->left_overhang
)
3166 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3167 int first
= s
->first_glyph
- glyphs
;
3169 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
3170 x
-= glyphs
[i
].pixel_width
;
3181 /* Return the index of the first glyph preceding glyph string S that
3182 is overwriting S because of its right overhang. Value is -1 if no
3183 glyph in front of S overwrites S. */
3186 x_left_overwriting (s
)
3187 struct glyph_string
*s
;
3190 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3191 int first
= s
->first_glyph
- glyphs
;
3195 for (i
= first
- 1; i
>= 0; --i
)
3198 w32_get_glyph_overhangs (s
->hdc
, glyphs
+ i
, s
->f
, &left
, &right
);
3201 x
-= glyphs
[i
].pixel_width
;
3208 /* Return the index of the last glyph following glyph string S that is
3209 not overwritten by S because of S's right overhang. Value is -1 if
3210 no such glyph is found. */
3213 x_right_overwritten (s
)
3214 struct glyph_string
*s
;
3218 if (s
->right_overhang
)
3221 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3222 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3223 int end
= s
->row
->used
[s
->area
];
3225 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
3226 x
+= glyphs
[i
].pixel_width
;
3235 /* Return the index of the last glyph following glyph string S that
3236 overwrites S because of its left overhang. Value is negative
3237 if no such glyph is found. */
3240 x_right_overwriting (s
)
3241 struct glyph_string
*s
;
3244 int end
= s
->row
->used
[s
->area
];
3245 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3246 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3250 for (i
= first
; i
< end
; ++i
)
3253 w32_get_glyph_overhangs (s
->hdc
, glyphs
+ i
, s
->f
, &left
, &right
);
3256 x
+= glyphs
[i
].pixel_width
;
3263 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3266 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
3267 struct glyph_string
*s
;
3275 /* Take clipping into account. */
3276 if (s
->gc
->clip_mask
== Rect
)
3278 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
3279 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
3280 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
3281 - s
->gc
->clip_rectangle
.left
);
3282 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
3283 - s
->gc
->clip_rectangle
.top
);
3286 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
3291 /* Draw the background of glyph_string S. If S->background_filled_p
3292 is non-zero don't draw it. FORCE_P non-zero means draw the
3293 background even if it wouldn't be drawn normally. This is used
3294 when a string preceding S draws into the background of S, or S
3295 contains the first component of a composition. */
3298 x_draw_glyph_string_background (s
, force_p
)
3299 struct glyph_string
*s
;
3302 /* Nothing to do if background has already been drawn or if it
3303 shouldn't be drawn in the first place. */
3304 if (!s
->background_filled_p
)
3306 #if 0 /* TODO: stipple */
3309 /* Fill background with a stipple pattern. */
3310 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3311 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
3312 s
->y
+ s
->face
->box_line_width
,
3313 s
->background_width
,
3314 s
->height
- 2 * s
->face
->box_line_width
);
3315 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3316 s
->background_filled_p
= 1;
3320 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * s
->face
->box_line_width
3321 || s
->font_not_found_p
3322 || s
->extends_to_end_of_line_p
3326 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ s
->face
->box_line_width
,
3327 s
->background_width
,
3328 s
->height
- 2 * s
->face
->box_line_width
);
3329 s
->background_filled_p
= 1;
3335 /* Draw the foreground of glyph string S. */
3338 x_draw_glyph_string_foreground (s
)
3339 struct glyph_string
*s
;
3344 /* If first glyph of S has a left box line, start drawing the text
3345 of S to the right of that box line. */
3346 if (s
->face
->box
!= FACE_NO_BOX
3347 && s
->first_glyph
->left_box_line_p
)
3348 x
= s
->x
+ s
->face
->box_line_width
;
3352 if (s
->for_overlaps_p
|| (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3353 SetBkMode (s
->hdc
, TRANSPARENT
);
3355 SetBkMode (s
->hdc
, OPAQUE
);
3357 SetTextColor (s
->hdc
, s
->gc
->foreground
);
3358 SetBkColor (s
->hdc
, s
->gc
->background
);
3359 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
3361 if (s
->font
&& s
->font
->hfont
)
3362 old_font
= SelectObject (s
->hdc
, s
->font
->hfont
);
3364 /* Draw characters of S as rectangles if S's font could not be
3366 if (s
->font_not_found_p
)
3368 for (i
= 0; i
< s
->nchars
; ++i
)
3370 struct glyph
*g
= s
->first_glyph
+ i
;
3372 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3374 x
+= g
->pixel_width
;
3379 char *char1b
= (char *) s
->char2b
;
3380 int boff
= s
->font_info
->baseline_offset
;
3382 if (s
->font_info
->vertical_centering
)
3383 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3385 /* If we can use 8-bit functions, condense S->char2b. */
3387 for (i
= 0; i
< s
->nchars
; ++i
)
3388 char1b
[i
] = BYTE2 (s
->char2b
[i
]);
3390 /* Draw text with TextOut and friends. */
3391 W32_TEXTOUT (s
, x
, s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3393 if (s
->font
&& s
->font
->hfont
)
3394 SelectObject (s
->hdc
, old_font
);
3397 /* Draw the foreground of composite glyph string S. */
3400 x_draw_composite_glyph_string_foreground (s
)
3401 struct glyph_string
*s
;
3406 /* If first glyph of S has a left box line, start drawing the text
3407 of S to the right of that box line. */
3408 if (s
->face
->box
!= FACE_NO_BOX
3409 && s
->first_glyph
->left_box_line_p
)
3410 x
= s
->x
+ s
->face
->box_line_width
;
3414 /* S is a glyph string for a composition. S->gidx is the index of
3415 the first character drawn for glyphs of this composition.
3416 S->gidx == 0 means we are drawing the very first character of
3417 this composition. */
3419 SetTextColor (s
->hdc
, s
->gc
->foreground
);
3420 SetBkColor (s
->hdc
, s
->gc
->background
);
3421 SetBkMode (s
->hdc
, TRANSPARENT
);
3422 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
3424 if (s
->font
&& s
->font
->hfont
)
3425 old_font
= SelectObject (s
->hdc
, s
->font
->hfont
);
3427 /* Draw a rectangle for the composition if the font for the very
3428 first character of the composition could not be loaded. */
3429 if (s
->font_not_found_p
)
3432 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
3437 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3438 W32_TEXTOUT (s
, x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3439 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3442 if (s
->font
&& s
->font
->hfont
)
3443 SelectObject (s
->hdc
, old_font
);
3447 /* Brightness beyond which a color won't have its highlight brightness
3450 Nominally, highlight colors for `3d' faces are calculated by
3451 brightening an object's color by a constant scale factor, but this
3452 doesn't yield good results for dark colors, so for colors who's
3453 brightness is less than this value (on a scale of 0-255) have to
3454 use an additional additive factor.
3456 The value here is set so that the default menu-bar/mode-line color
3457 (grey75) will not have its highlights changed at all. */
3458 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
3461 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
3462 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3463 If this produces the same color as COLOR, try a color where all RGB
3464 values have DELTA added. Return the allocated color in *COLOR.
3465 DISPLAY is the X display, CMAP is the colormap to operate on.
3466 Value is non-zero if successful. */
3469 w32_alloc_lighter_color (f
, color
, factor
, delta
)
3478 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
3481 /* Change RGB values by specified FACTOR. Avoid overflow! */
3482 xassert (factor
>= 0);
3483 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
3484 min (0xff, factor
* GetGValue (*color
)),
3485 min (0xff, factor
* GetBValue (*color
)));
3487 /* Calculate brightness of COLOR. */
3488 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
3489 + GetBValue (*color
)) / 6;
3491 /* We only boost colors that are darker than
3492 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3493 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
3494 /* Make an additive adjustment to NEW, because it's dark enough so
3495 that scaling by FACTOR alone isn't enough. */
3497 /* How far below the limit this color is (0 - 1, 1 being darker). */
3498 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
3499 /* The additive adjustment. */
3500 int min_delta
= delta
* dimness
* factor
/ 2;
3503 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
3504 max (0, min (0xff, min_delta
- GetGValue (*color
))),
3505 max (0, min (0xff, min_delta
- GetBValue (*color
))));
3507 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
3508 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
3509 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
3513 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
3514 max (0, min (0xff, delta
+ GetGValue (*color
))),
3515 max (0, min (0xff, delta
+ GetBValue (*color
))));
3517 /* TODO: Map to palette and retry with delta if same? */
3518 /* TODO: Free colors (if using palette)? */
3529 /* Set up the foreground color for drawing relief lines of glyph
3530 string S. RELIEF is a pointer to a struct relief containing the GC
3531 with which lines will be drawn. Use a color that is FACTOR or
3532 DELTA lighter or darker than the relief's background which is found
3533 in S->f->output_data.x->relief_background. If such a color cannot
3534 be allocated, use DEFAULT_PIXEL, instead. */
3537 w32_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3539 struct relief
*relief
;
3542 COLORREF default_pixel
;
3545 struct w32_output
*di
= f
->output_data
.w32
;
3546 unsigned long mask
= GCForeground
;
3548 COLORREF background
= di
->relief_background
;
3549 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
3551 /* TODO: Free colors (if using palette)? */
3553 /* Allocate new color. */
3554 xgcv
.foreground
= default_pixel
;
3556 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
3558 relief
->allocated_p
= 1;
3559 xgcv
.foreground
= relief
->pixel
= pixel
;
3562 if (relief
->gc
== 0)
3564 #if 0 /* TODO: stipple */
3565 xgcv
.stipple
= dpyinfo
->gray
;
3568 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
3571 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
3575 /* Set up colors for the relief lines around glyph string S. */
3578 x_setup_relief_colors (s
)
3579 struct glyph_string
*s
;
3581 struct w32_output
*di
= s
->f
->output_data
.w32
;
3584 if (s
->face
->use_box_color_for_shadows_p
)
3585 color
= s
->face
->box_color
;
3587 color
= s
->gc
->background
;
3589 if (di
->white_relief
.gc
== 0
3590 || color
!= di
->relief_background
)
3592 di
->relief_background
= color
;
3593 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3594 WHITE_PIX_DEFAULT (s
->f
));
3595 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3596 BLACK_PIX_DEFAULT (s
->f
));
3601 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3602 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3603 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3604 relief. LEFT_P non-zero means draw a relief on the left side of
3605 the rectangle. RIGHT_P non-zero means draw a relief on the right
3606 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3610 w32_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3611 raised_p
, left_p
, right_p
, clip_rect
)
3613 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
3618 HDC hdc
= get_frame_dc (f
);
3621 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
3623 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
3625 w32_set_clip_rectangle (hdc
, clip_rect
);
3628 for (i
= 0; i
< width
; ++i
)
3630 w32_fill_area (f
, hdc
, gc
.foreground
,
3631 left_x
+ i
* left_p
, top_y
+ i
,
3632 (right_x
+ 1 - i
* right_p
) - (left_x
+ i
* left_p
), 1);
3637 for (i
= 0; i
< width
; ++i
)
3639 w32_fill_area (f
, hdc
, gc
.foreground
,
3640 left_x
+ i
, top_y
+ i
, 1,
3641 (bottom_y
- i
) - (top_y
+ i
));
3644 w32_set_clip_rectangle (hdc
, NULL
);
3647 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
3649 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
3652 w32_set_clip_rectangle (hdc
, clip_rect
);
3655 for (i
= 0; i
< width
; ++i
)
3657 w32_fill_area (f
, hdc
, gc
.foreground
,
3658 left_x
+ i
* left_p
, bottom_y
- i
,
3659 (right_x
+ 1 - i
* right_p
) - left_x
+ i
* left_p
, 1);
3664 for (i
= 0; i
< width
; ++i
)
3666 w32_fill_area (f
, hdc
, gc
.foreground
,
3667 right_x
- i
, top_y
+ i
+ 1, 1,
3668 (bottom_y
- i
) - (top_y
+ i
+ 1));
3671 w32_set_clip_rectangle (hdc
, NULL
);
3673 release_frame_dc (f
, hdc
);
3677 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3678 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3679 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3680 left side of the rectangle. RIGHT_P non-zero means draw a line
3681 on the right side of the rectangle. CLIP_RECT is the clipping
3682 rectangle to use when drawing. */
3685 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3686 left_p
, right_p
, clip_rect
)
3687 struct glyph_string
*s
;
3688 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
3691 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
3694 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3695 left_x
, top_y
, right_x
- left_x
+ 1, width
);
3700 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3701 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
3705 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3706 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
3711 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
3712 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
3715 w32_set_clip_rectangle (s
->hdc
, NULL
);
3719 /* Draw a box around glyph string S. */
3722 x_draw_glyph_string_box (s
)
3723 struct glyph_string
*s
;
3725 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3726 int left_p
, right_p
;
3727 struct glyph
*last_glyph
;
3730 last_x
= window_box_right (s
->w
, s
->area
);
3731 if (s
->row
->full_width_p
3732 && !s
->w
->pseudo_window_p
)
3734 last_x
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s
->f
);
3735 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
3736 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
3739 /* The glyph that may have a right box line. */
3740 last_glyph
= (s
->cmp
|| s
->img
3742 : s
->first_glyph
+ s
->nchars
- 1);
3744 width
= s
->face
->box_line_width
;
3745 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
3747 right_x
= ((s
->row
->full_width_p
3749 : min (last_x
, s
->x
+ s
->background_width
) - 1));
3751 bottom_y
= top_y
+ s
->height
- 1;
3753 left_p
= (s
->first_glyph
->left_box_line_p
3754 || (s
->hl
== DRAW_MOUSE_FACE
3756 || s
->prev
->hl
!= s
->hl
)));
3757 right_p
= (last_glyph
->right_box_line_p
3758 || (s
->hl
== DRAW_MOUSE_FACE
3760 || s
->next
->hl
!= s
->hl
)));
3762 w32_get_glyph_string_clip_rect (s
, &clip_rect
);
3764 if (s
->face
->box
== FACE_SIMPLE_BOX
)
3765 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3766 left_p
, right_p
, &clip_rect
);
3769 x_setup_relief_colors (s
);
3770 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
3771 width
, raised_p
, left_p
, right_p
, &clip_rect
);
3776 /* Draw foreground of image glyph string S. */
3779 x_draw_image_foreground (s
)
3780 struct glyph_string
*s
;
3783 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3785 /* If first glyph of S has a left box line, start drawing it to the
3786 right of that line. */
3787 if (s
->face
->box
!= FACE_NO_BOX
3788 && s
->first_glyph
->left_box_line_p
)
3789 x
= s
->x
+ s
->face
->box_line_width
;
3793 /* If there is a margin around the image, adjust x- and y-position
3797 x
+= s
->img
->margin
;
3798 y
+= s
->img
->margin
;
3805 #if 0 /* TODO: image mask */
3808 /* We can't set both a clip mask and use XSetClipRectangles
3809 because the latter also sets a clip mask. We also can't
3810 trust on the shape extension to be available
3811 (XShapeCombineRegion). So, compute the rectangle to draw
3813 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3816 XRectangle clip_rect
, image_rect
, r
;
3818 xgcv
.clip_mask
= s
->img
->mask
;
3819 xgcv
.clip_x_origin
= x
;
3820 xgcv
.clip_y_origin
= y
;
3821 xgcv
.function
= GXcopy
;
3822 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3824 w32_get_glyph_string_clip_rect (s
, &clip_rect
);
3827 image_rect
.width
= s
->img
->width
;
3828 image_rect
.height
= s
->img
->height
;
3829 if (IntersectRect (&r
, &clip_rect
, &image_rect
))
3830 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
3831 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
3836 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
3837 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
3838 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
3839 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
3840 x_set_glyph_string_clipping (s
);
3842 SetTextColor (s
->hdc
, s
->gc
->foreground
);
3843 SetBkColor (s
->hdc
, s
->gc
->background
);
3844 #if 0 /* From w32bdf.c (which is from Meadow). */
3845 BitBlt (s
->hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3846 compat_hdc
, 0, 0, SRCCOPY
);
3848 BitBlt (s
->hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3849 compat_hdc
, 0, 0, 0xB8074A);
3851 SelectObject (s
->hdc
, orig_brush
);
3852 DeleteObject (fg_brush
);
3853 SelectObject (compat_hdc
, orig_obj
);
3854 DeleteDC (compat_hdc
);
3856 /* When the image has a mask, we can expect that at
3857 least part of a mouse highlight or a block cursor will
3858 be visible. If the image doesn't have a mask, make
3859 a block cursor visible by drawing a rectangle around
3860 the image. I believe it's looking better if we do
3861 nothing here for mouse-face. */
3862 if (s
->hl
== DRAW_CURSOR
)
3863 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
, s
->img
->width
- 1,
3864 s
->img
->height
- 1);
3865 w32_set_clip_rectangle (s
->hdc
, NULL
);
3869 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
, s
->img
->width
-1,
3870 s
->img
->height
- 1);
3872 RestoreDC (s
->hdc
,-1);
3877 /* Draw a relief around the image glyph string S. */
3880 x_draw_image_relief (s
)
3881 struct glyph_string
*s
;
3883 int x0
, y0
, x1
, y1
, thick
, raised_p
;
3886 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
3888 /* If first glyph of S has a left box line, start drawing it to the
3889 right of that line. */
3890 if (s
->face
->box
!= FACE_NO_BOX
3891 && s
->first_glyph
->left_box_line_p
)
3892 x
= s
->x
+ s
->face
->box_line_width
;
3896 /* If there is a margin around the image, adjust x- and y-position
3900 x
+= s
->img
->margin
;
3901 y
+= s
->img
->margin
;
3904 if (s
->hl
== DRAW_IMAGE_SUNKEN
3905 || s
->hl
== DRAW_IMAGE_RAISED
)
3907 thick
= tool_bar_button_relief
> 0 ? tool_bar_button_relief
: 3;
3908 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
3912 thick
= abs (s
->img
->relief
);
3913 raised_p
= s
->img
->relief
> 0;
3918 x1
= x
+ s
->img
->width
+ thick
- 1;
3919 y1
= y
+ s
->img
->height
+ thick
- 1;
3921 x_setup_relief_colors (s
);
3922 w32_get_glyph_string_clip_rect (s
, &r
);
3923 w32_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
3927 /* Draw the foreground of image glyph string S to PIXMAP. */
3930 w32_draw_image_foreground_1 (s
, pixmap
)
3931 struct glyph_string
*s
;
3934 HDC hdc
= CreateCompatibleDC (s
->hdc
);
3935 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
3937 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
);
3939 /* If first glyph of S has a left box line, start drawing it to the
3940 right of that line. */
3941 if (s
->face
->box
!= FACE_NO_BOX
3942 && s
->first_glyph
->left_box_line_p
)
3943 x
= s
->face
->box_line_width
;
3947 /* If there is a margin around the image, adjust x- and y-position
3951 x
+= s
->img
->margin
;
3952 y
+= s
->img
->margin
;
3957 #if 0 /* TODO: image mask */
3960 /* We can't set both a clip mask and use XSetClipRectangles
3961 because the latter also sets a clip mask. We also can't
3962 trust on the shape extension to be available
3963 (XShapeCombineRegion). So, compute the rectangle to draw
3965 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3969 xgcv
.clip_mask
= s
->img
->mask
;
3970 xgcv
.clip_x_origin
= x
;
3971 xgcv
.clip_y_origin
= y
;
3972 xgcv
.function
= GXcopy
;
3973 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3975 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3976 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
3977 XSetClipMask (s
->display
, s
->gc
, None
);
3982 HDC compat_hdc
= CreateCompatibleDC (hdc
);
3983 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
3984 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
3985 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
3987 SetTextColor (hdc
, s
->gc
->foreground
);
3988 SetBkColor (hdc
, s
->gc
->background
);
3989 #if 0 /* From w32bdf.c (which is from Meadow). */
3990 BitBlt (hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3991 compat_hdc
, 0, 0, SRCCOPY
);
3993 BitBlt (hdc
, x
, y
, s
->img
->width
, s
->img
->height
,
3994 compat_hdc
, 0, 0, 0xB8074A);
3996 SelectObject (hdc
, orig_brush
);
3997 DeleteObject (fg_brush
);
3998 SelectObject (compat_hdc
, orig_obj
);
3999 DeleteDC (compat_hdc
);
4001 /* When the image has a mask, we can expect that at
4002 least part of a mouse highlight or a block cursor will
4003 be visible. If the image doesn't have a mask, make
4004 a block cursor visible by drawing a rectangle around
4005 the image. I believe it's looking better if we do
4006 nothing here for mouse-face. */
4007 if (s
->hl
== DRAW_CURSOR
)
4008 w32_draw_rectangle (hdc
, s
->gc
, x
, y
, s
->img
->width
- 1,
4009 s
->img
->height
- 1);
4013 w32_draw_rectangle (hdc
, s
->gc
, x
, y
, s
->img
->width
- 1,
4014 s
->img
->height
- 1);
4016 SelectObject (hdc
, orig_hdc_obj
);
4021 /* Draw part of the background of glyph string S. X, Y, W, and H
4022 give the rectangle to draw. */
4025 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
4026 struct glyph_string
*s
;
4029 #if 0 /* TODO: stipple */
4032 /* Fill background with a stipple pattern. */
4033 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4034 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
4035 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4039 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
4043 /* Draw image glyph string S.
4046 s->x +-------------------------
4049 | +-------------------------
4052 | | +-------------------
4058 x_draw_image_glyph_string (s
)
4059 struct glyph_string
*s
;
4062 int box_line_width
= s
->face
->box_line_width
;
4063 int margin
= s
->img
->margin
;
4067 height
= s
->height
- 2 * box_line_width
;
4069 /* Fill background with face under the image. Do it only if row is
4070 taller than image or if image has a clip mask to reduce
4072 s
->stippled_p
= s
->face
->stipple
!= 0;
4073 if (height
> s
->img
->height
4075 #if 0 /* TODO: image mask */
4078 || s
->img
->pixmap
== 0
4079 || s
->width
!= s
->background_width
)
4081 if (box_line_width
&& s
->first_glyph
->left_box_line_p
)
4082 x
= s
->x
+ box_line_width
;
4086 y
= s
->y
+ box_line_width
;
4087 #if 0 /* TODO: image mask */
4090 /* Create a pixmap as large as the glyph string Fill it with
4091 the background color. Copy the image to it, using its
4092 mask. Copy the temporary pixmap to the display. */
4093 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
4094 int depth
= DefaultDepthOfScreen (screen
);
4096 /* Create a pixmap as large as the glyph string. */
4097 pixmap
= XCreatePixmap (s
->display
, s
->window
,
4098 s
->background_width
,
4101 /* Don't clip in the following because we're working on the
4103 XSetClipMask (s
->display
, s
->gc
, None
);
4105 /* Fill the pixmap with the background color/stipple. */
4108 /* Fill background with a stipple pattern. */
4109 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4110 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4111 0, 0, s
->background_width
, s
->height
);
4112 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4117 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
4119 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
4120 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4121 0, 0, s
->background_width
, s
->height
);
4122 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4127 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
4129 s
->background_filled_p
= 1;
4132 /* Draw the foreground. */
4135 w32_draw_image_foreground_1 (s
, pixmap
);
4136 x_set_glyph_string_clipping (s
);
4138 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
4139 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
4140 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
4141 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
4143 SetTextColor (s
->hdc
, s
->gc
->foreground
);
4144 SetBkColor (s
->hdc
, s
->gc
->background
);
4145 #if 0 /* From w32bdf.c (which is from Meadow). */
4146 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
4147 compat_hdc
, 0, 0, SRCCOPY
);
4149 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
4150 compat_hdc
, 0, 0, 0xB8074A);
4152 SelectObject (s
->hdc
, orig_brush
);
4153 DeleteObject (fg_brush
);
4154 SelectObject (compat_hdc
, orig_obj
);
4155 DeleteDC (compat_hdc
);
4157 DeleteObject (pixmap
);
4161 x_draw_image_foreground (s
);
4163 /* If we must draw a relief around the image, do it. */
4165 || s
->hl
== DRAW_IMAGE_RAISED
4166 || s
->hl
== DRAW_IMAGE_SUNKEN
)
4167 x_draw_image_relief (s
);
4171 /* Draw stretch glyph string S. */
4174 x_draw_stretch_glyph_string (s
)
4175 struct glyph_string
*s
;
4177 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4178 s
->stippled_p
= s
->face
->stipple
!= 0;
4180 if (s
->hl
== DRAW_CURSOR
4181 && !x_stretch_cursor_p
)
4183 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4184 as wide as the stretch glyph. */
4185 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
4188 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
4190 /* Clear rest using the GC of the original non-cursor face. */
4191 if (width
< s
->background_width
)
4193 XGCValues
*gc
= s
->face
->gc
;
4194 int x
= s
->x
+ width
, y
= s
->y
;
4195 int w
= s
->background_width
- width
, h
= s
->height
;
4198 w32_get_glyph_string_clip_rect (s
, &r
);
4199 w32_set_clip_rectangle (hdc
, &r
);
4201 #if 0 /* TODO: stipple */
4202 if (s
->face
->stipple
)
4204 /* Fill background with a stipple pattern. */
4205 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
4206 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4207 XSetFillStyle (s
->display
, gc
, FillSolid
);
4212 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
4217 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
4220 s
->background_filled_p
= 1;
4224 /* Draw glyph string S. */
4227 x_draw_glyph_string (s
)
4228 struct glyph_string
*s
;
4230 /* If S draws into the background of its successor, draw the
4231 background of the successor first so that S can draw into it.
4232 This makes S->next use XDrawString instead of XDrawImageString. */
4233 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
4235 xassert (s
->next
->img
== NULL
);
4236 x_set_glyph_string_gc (s
->next
);
4237 x_set_glyph_string_clipping (s
->next
);
4238 x_draw_glyph_string_background (s
->next
, 1);
4241 /* Set up S->gc, set clipping and draw S. */
4242 x_set_glyph_string_gc (s
);
4243 x_set_glyph_string_clipping (s
);
4245 switch (s
->first_glyph
->type
)
4248 x_draw_image_glyph_string (s
);
4252 x_draw_stretch_glyph_string (s
);
4256 if (s
->for_overlaps_p
)
4257 s
->background_filled_p
= 1;
4259 x_draw_glyph_string_background (s
, 0);
4260 x_draw_glyph_string_foreground (s
);
4263 case COMPOSITE_GLYPH
:
4264 if (s
->for_overlaps_p
|| s
->gidx
> 0)
4265 s
->background_filled_p
= 1;
4267 x_draw_glyph_string_background (s
, 1);
4268 x_draw_composite_glyph_string_foreground (s
);
4275 if (!s
->for_overlaps_p
)
4277 /* Draw underline. */
4278 if (s
->face
->underline_p
4279 && (s
->font
->bdf
|| !s
->font
->tm
.tmUnderlined
))
4281 unsigned long h
= 1;
4282 unsigned long dy
= s
->height
- h
;
4284 if (s
->face
->underline_defaulted_p
)
4286 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
4287 s
->y
+ dy
, s
->width
, 1);
4291 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
4292 s
->y
+ dy
, s
->width
, 1);
4296 /* Draw overline. */
4297 if (s
->face
->overline_p
)
4299 unsigned long dy
= 0, h
= 1;
4301 if (s
->face
->overline_color_defaulted_p
)
4303 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
4304 s
->y
+ dy
, s
->width
, h
);
4308 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
4309 s
->y
+ dy
, s
->width
, h
);
4313 /* Draw strike-through. */
4314 if (s
->face
->strike_through_p
4315 && (s
->font
->bdf
|| !s
->font
->tm
.tmStruckOut
))
4317 unsigned long h
= 1;
4318 unsigned long dy
= (s
->height
- h
) / 2;
4320 if (s
->face
->strike_through_color_defaulted_p
)
4322 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
4327 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
4328 s
->y
+ dy
, s
->width
, h
);
4333 if (s
->face
->box
!= FACE_NO_BOX
)
4334 x_draw_glyph_string_box (s
);
4337 /* Reset clipping. */
4338 w32_set_clip_rectangle (s
->hdc
, NULL
);
4342 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4343 struct face
**, int));
4346 /* Load glyph string S with a composition components specified by S->cmp.
4347 FACES is an array of faces for all components of this composition.
4348 S->gidx is the index of the first component for S.
4349 OVERLAPS_P non-zero means S should draw the foreground only, and
4350 use its lines physical height for clipping.
4352 Value is the index of a component not in S. */
4355 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4356 struct glyph_string
*s
;
4357 struct face
**faces
;
4364 s
->for_overlaps_p
= overlaps_p
;
4366 s
->face
= faces
[s
->gidx
];
4367 s
->font
= s
->face
->font
;
4368 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4370 /* For all glyphs of this composition, starting at the offset
4371 S->gidx, until we reach the end of the definition or encounter a
4372 glyph that requires the different face, add it to S. */
4374 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4377 /* All glyph strings for the same composition has the same width,
4378 i.e. the width set for the first component of the composition. */
4380 s
->width
= s
->first_glyph
->pixel_width
;
4382 /* If the specified font could not be loaded, use the frame's
4383 default font, but record the fact that we couldn't load it in
4384 the glyph string so that we can draw rectangles for the
4385 characters of the glyph string. */
4386 if (s
->font
== NULL
)
4388 s
->font_not_found_p
= 1;
4389 s
->font
= FRAME_FONT (s
->f
);
4392 /* Adjust base line for subscript/superscript text. */
4393 s
->ybase
+= s
->first_glyph
->voffset
;
4395 xassert (s
->face
&& s
->face
->gc
);
4397 /* This glyph string must always be drawn with 16-bit functions. */
4400 return s
->gidx
+ s
->nchars
;
4404 /* Load glyph string S with a sequence of characters.
4405 FACE_ID is the face id of the string. START is the index of the
4406 first glyph to consider, END is the index of the last + 1.
4407 OVERLAPS_P non-zero means S should draw the foreground only, and
4408 use its lines physical height for clipping.
4410 Value is the index of the first glyph not in S. */
4413 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4414 struct glyph_string
*s
;
4416 int start
, end
, overlaps_p
;
4418 struct glyph
*glyph
, *last
;
4420 int glyph_not_available_p
;
4422 xassert (s
->f
== XFRAME (s
->w
->frame
));
4423 xassert (s
->nchars
== 0);
4424 xassert (start
>= 0 && end
> start
);
4426 s
->for_overlaps_p
= overlaps_p
;
4427 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4428 last
= s
->row
->glyphs
[s
->area
] + end
;
4429 voffset
= glyph
->voffset
;
4431 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4434 && glyph
->type
== CHAR_GLYPH
4435 && glyph
->voffset
== voffset
4436 /* Same face id implies same font, nowadays. */
4437 && glyph
->face_id
== face_id
4438 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4442 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4443 s
->char2b
+ s
->nchars
,
4445 s
->two_byte_p
= two_byte_p
;
4447 xassert (s
->nchars
<= end
- start
);
4448 s
->width
+= glyph
->pixel_width
;
4452 s
->font
= s
->face
->font
;
4453 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4455 /* If the specified font could not be loaded, use the frame's font,
4456 but record the fact that we couldn't load it in
4457 S->font_not_found_p so that we can draw rectangles for the
4458 characters of the glyph string. */
4459 if (s
->font
== NULL
|| glyph_not_available_p
)
4461 s
->font_not_found_p
= 1;
4462 s
->font
= FRAME_FONT (s
->f
);
4465 /* Adjust base line for subscript/superscript text. */
4466 s
->ybase
+= voffset
;
4468 xassert (s
->face
&& s
->face
->gc
);
4469 return glyph
- s
->row
->glyphs
[s
->area
];
4473 /* Fill glyph string S from image glyph S->first_glyph. */
4476 x_fill_image_glyph_string (s
)
4477 struct glyph_string
*s
;
4479 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4480 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4482 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4483 s
->font
= s
->face
->font
;
4484 s
->width
= s
->first_glyph
->pixel_width
;
4486 /* Adjust base line for subscript/superscript text. */
4487 s
->ybase
+= s
->first_glyph
->voffset
;
4491 /* Fill glyph string S from a sequence of stretch glyphs.
4493 ROW is the glyph row in which the glyphs are found, AREA is the
4494 area within the row. START is the index of the first glyph to
4495 consider, END is the index of the last + 1.
4497 Value is the index of the first glyph not in S. */
4500 x_fill_stretch_glyph_string (s
, row
, area
, start
, end
)
4501 struct glyph_string
*s
;
4502 struct glyph_row
*row
;
4503 enum glyph_row_area area
;
4506 struct glyph
*glyph
, *last
;
4507 int voffset
, face_id
;
4509 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4511 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4512 last
= s
->row
->glyphs
[s
->area
] + end
;
4513 face_id
= glyph
->face_id
;
4514 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
4515 s
->font
= s
->face
->font
;
4516 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4517 s
->width
= glyph
->pixel_width
;
4518 voffset
= glyph
->voffset
;
4522 && glyph
->type
== STRETCH_GLYPH
4523 && glyph
->voffset
== voffset
4524 && glyph
->face_id
== face_id
);
4526 s
->width
+= glyph
->pixel_width
;
4528 /* Adjust base line for subscript/superscript text. */
4529 s
->ybase
+= voffset
;
4531 xassert (s
->face
&& s
->face
->gc
);
4532 return glyph
- s
->row
->glyphs
[s
->area
];
4536 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4537 of XChar2b structures for S; it can't be allocated in
4538 x_init_glyph_string because it must be allocated via `alloca'. W
4539 is the window on which S is drawn. ROW and AREA are the glyph row
4540 and area within the row from which S is constructed. START is the
4541 index of the first glyph structure covered by S. HL is a
4542 face-override for drawing S. */
4545 w32_init_glyph_string (s
, hdc
, char2b
, w
, row
, area
, start
, hl
)
4546 struct glyph_string
*s
;
4550 struct glyph_row
*row
;
4551 enum glyph_row_area area
;
4553 enum draw_glyphs_face hl
;
4555 bzero (s
, sizeof *s
);
4557 s
->f
= XFRAME (w
->frame
);
4559 s
->window
= FRAME_W32_WINDOW (s
->f
);
4564 s
->first_glyph
= row
->glyphs
[area
] + start
;
4565 s
->height
= row
->height
;
4566 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4568 /* Display the internal border below the tool-bar window. */
4569 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4570 s
->y
-= s
->f
->output_data
.w32
->internal_border_width
;
4572 s
->ybase
= s
->y
+ row
->ascent
;
4576 /* Set background width of glyph string S. START is the index of the
4577 first glyph following S. LAST_X is the right-most x-position + 1
4578 in the drawing area. */
4581 x_set_glyph_string_background_width (s
, start
, last_x
)
4582 struct glyph_string
*s
;
4586 /* If the face of this glyph string has to be drawn to the end of
4587 the drawing area, set S->extends_to_end_of_line_p. */
4588 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4590 if (start
== s
->row
->used
[s
->area
]
4591 && s
->hl
== DRAW_NORMAL_TEXT
4592 && ((s
->area
== TEXT_AREA
&& s
->row
->fill_line_p
)
4593 || s
->face
->background
!= default_face
->background
4594 || s
->face
->stipple
!= default_face
->stipple
))
4595 s
->extends_to_end_of_line_p
= 1;
4597 /* If S extends its face to the end of the line, set its
4598 background_width to the distance to the right edge of the drawing
4600 if (s
->extends_to_end_of_line_p
)
4601 s
->background_width
= last_x
- s
->x
+ 1;
4603 s
->background_width
= s
->width
;
4607 /* Add a glyph string for a stretch glyph to the list of strings
4608 between HEAD and TAIL. START is the index of the stretch glyph in
4609 row area AREA of glyph row ROW. END is the index of the last glyph
4610 in that glyph row area. X is the current output position assigned
4611 to the new glyph string constructed. HL overrides that face of the
4612 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4613 is the right-most x-position of the drawing area. */
4615 #define BUILD_STRETCH_GLYPH_STRING(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4618 s = (struct glyph_string *) alloca (sizeof *s); \
4619 w32_init_glyph_string (s, hdc, NULL, W, ROW, AREA, START, HL); \
4620 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4621 x_append_glyph_string (&HEAD, &TAIL, s); \
4627 /* Add a glyph string for an image glyph to the list of strings
4628 between HEAD and TAIL. START is the index of the image glyph in
4629 row area AREA of glyph row ROW. END is the index of the last glyph
4630 in that glyph row area. X is the current output position assigned
4631 to the new glyph string constructed. HL overrides that face of the
4632 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4633 is the right-most x-position of the drawing area. */
4635 #define BUILD_IMAGE_GLYPH_STRING(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4638 s = (struct glyph_string *) alloca (sizeof *s); \
4639 w32_init_glyph_string (s, hdc, NULL, W, ROW, AREA, START, HL); \
4640 x_fill_image_glyph_string (s); \
4641 x_append_glyph_string (&HEAD, &TAIL, s); \
4648 /* Add a glyph string for a sequence of character glyphs to the list
4649 of strings between HEAD and TAIL. START is the index of the first
4650 glyph in row area AREA of glyph row ROW that is part of the new
4651 glyph string. END is the index of the last glyph in that glyph row
4652 area. X is the current output position assigned to the new glyph
4653 string constructed. HL overrides that face of the glyph; e.g. it
4654 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4655 right-most x-position of the drawing area. */
4657 #define BUILD_CHAR_GLYPH_STRINGS(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4663 c = (ROW)->glyphs[AREA][START].u.ch; \
4664 face_id = (ROW)->glyphs[AREA][START].face_id; \
4666 s = (struct glyph_string *) alloca (sizeof *s); \
4667 char2b = (wchar_t *) alloca ((END - START) * sizeof *char2b); \
4668 w32_init_glyph_string (s, hdc, char2b, W, ROW, AREA, START, HL); \
4669 x_append_glyph_string (&HEAD, &TAIL, s); \
4671 START = x_fill_glyph_string (s, face_id, START, END, \
4677 /* Add a glyph string for a composite sequence to the list of strings
4678 between HEAD and TAIL. START is the index of the first glyph in
4679 row area AREA of glyph row ROW that is part of the new glyph
4680 string. END is the index of the last glyph in that glyph row area.
4681 X is the current output position assigned to the new glyph string
4682 constructed. HL overrides that face of the glyph; e.g. it is
4683 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4684 x-position of the drawing area. */
4686 #define BUILD_COMPOSITE_GLYPH_STRING(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4688 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4689 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4690 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4691 struct composition *cmp = composition_table[cmp_id]; \
4692 int glyph_len = cmp->glyph_len; \
4694 struct face **faces; \
4695 struct glyph_string *first_s = NULL; \
4698 base_face = base_face->ascii_face; \
4699 char2b = (wchar_t *) alloca ((sizeof *char2b) * glyph_len); \
4700 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4701 /* At first, fill in `char2b' and `faces'. */ \
4702 for (n = 0; n < glyph_len; n++) \
4704 int c = COMPOSITION_GLYPH (cmp, n); \
4705 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4706 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4707 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4708 this_face_id, char2b + n, 1); \
4711 /* Make glyph_strings for each glyph sequence that is drawable by \
4712 the same face, and append them to HEAD/TAIL. */ \
4713 for (n = 0; n < cmp->glyph_len;) \
4715 s = (struct glyph_string *) alloca (sizeof *s); \
4716 w32_init_glyph_string (s, hdc, char2b + n, W, ROW, AREA, START, HL); \
4717 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4725 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4733 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4734 of AREA of glyph row ROW on window W between indices START and END.
4735 HL overrides the face for drawing glyph strings, e.g. it is
4736 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
4737 x-positions of the drawing area.
4739 This is an ugly monster macro construct because we must use alloca
4740 to allocate glyph strings (because x_draw_glyphs can be called
4743 #define BUILD_GLYPH_STRINGS(hdc, W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4746 HEAD = TAIL = NULL; \
4747 while (START < END) \
4749 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
4750 switch (first_glyph->type) \
4753 BUILD_CHAR_GLYPH_STRINGS (hdc, W, ROW, AREA, START, END, \
4754 HEAD, TAIL, HL, X, LAST_X, \
4758 case COMPOSITE_GLYPH: \
4759 BUILD_COMPOSITE_GLYPH_STRING (hdc, W, ROW, AREA, START, \
4760 END, HEAD, TAIL, HL, X, \
4761 LAST_X, OVERLAPS_P); \
4764 case STRETCH_GLYPH: \
4765 BUILD_STRETCH_GLYPH_STRING (hdc, W, ROW, AREA, START, END,\
4766 HEAD, TAIL, HL, X, LAST_X); \
4770 BUILD_IMAGE_GLYPH_STRING (hdc, W, ROW, AREA, START, END, \
4771 HEAD, TAIL, HL, X, LAST_X); \
4778 x_set_glyph_string_background_width (s, START, LAST_X); \
4785 /* Draw glyphs between START and END in AREA of ROW on window W,
4786 starting at x-position X. X is relative to AREA in W. HL is a
4787 face-override with the following meaning:
4789 DRAW_NORMAL_TEXT draw normally
4790 DRAW_CURSOR draw in cursor face
4791 DRAW_MOUSE_FACE draw in mouse face.
4792 DRAW_INVERSE_VIDEO draw in mode line face
4793 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
4794 DRAW_IMAGE_RAISED draw an image with a raised relief around it
4796 If REAL_START is non-null, return in *REAL_START the real starting
4797 position for display. This can be different from START in case
4798 overlapping glyphs must be displayed. If REAL_END is non-null,
4799 return in *REAL_END the real end position for display. This can be
4800 different from END in case overlapping glyphs must be displayed.
4802 If OVERLAPS_P is non-zero, draw only the foreground of characters
4803 and clip to the physical height of ROW.
4805 Value is the x-position reached, relative to AREA of W. */
4808 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, real_start
, real_end
,
4812 struct glyph_row
*row
;
4813 enum glyph_row_area area
;
4815 enum draw_glyphs_face hl
;
4816 int *real_start
, *real_end
;
4819 struct glyph_string
*head
, *tail
;
4820 struct glyph_string
*s
;
4821 int last_x
, area_width
;
4824 HDC hdc
= get_frame_dc (XFRAME (WINDOW_FRAME (w
)));
4826 /* Let's rather be paranoid than getting a SEGV. */
4827 end
= min (end
, row
->used
[area
]);
4828 start
= max (0, start
);
4829 start
= min (end
, start
);
4832 *real_start
= start
;
4836 /* Translate X to frame coordinates. Set last_x to the right
4837 end of the drawing area. */
4838 if (row
->full_width_p
)
4840 /* X is relative to the left edge of W, without scroll bars
4842 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4843 /* int width = FRAME_FLAGS_AREA_WIDTH (f); */
4844 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
4847 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
4848 last_x
= window_left_x
+ area_width
;
4850 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4852 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
4853 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
4859 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
4860 last_x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
4864 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
4865 area_width
= window_box_width (w
, area
);
4866 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
4869 /* Build a doubly-linked list of glyph_string structures between
4870 head and tail from what we have to draw. Note that the macro
4871 BUILD_GLYPH_STRINGS will modify its start parameter. That's
4872 the reason we use a separate variable `i'. */
4874 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
4877 x_reached
= tail
->x
+ tail
->background_width
;
4881 /* If there are any glyphs with lbearing < 0 or rbearing > width in
4882 the row, redraw some glyphs in front or following the glyph
4883 strings built above. */
4884 if (head
&& !overlaps_p
&& row
->contains_overlapping_glyphs_p
)
4887 struct glyph_string
*h
, *t
;
4889 /* Compute overhangs for all glyph strings. */
4890 for (s
= head
; s
; s
= s
->next
)
4891 x_compute_glyph_string_overhangs (s
);
4893 /* Prepend glyph strings for glyphs in front of the first glyph
4894 string that are overwritten because of the first glyph
4895 string's left overhang. The background of all strings
4896 prepended must be drawn because the first glyph string
4898 i
= x_left_overwritten (head
);
4902 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, j
, start
, h
, t
,
4903 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
4907 *real_start
= start
;
4908 x_compute_overhangs_and_x (t
, head
->x
, 1);
4909 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
4912 /* Prepend glyph strings for glyphs in front of the first glyph
4913 string that overwrite that glyph string because of their
4914 right overhang. For these strings, only the foreground must
4915 be drawn, because it draws over the glyph string at `head'.
4916 The background must not be drawn because this would overwrite
4917 right overhangs of preceding glyphs for which no glyph
4919 i
= x_left_overwriting (head
);
4922 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, i
, start
, h
, t
,
4923 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
4925 for (s
= h
; s
; s
= s
->next
)
4926 s
->background_filled_p
= 1;
4929 x_compute_overhangs_and_x (t
, head
->x
, 1);
4930 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
4933 /* Append glyphs strings for glyphs following the last glyph
4934 string tail that are overwritten by tail. The background of
4935 these strings has to be drawn because tail's foreground draws
4937 i
= x_right_overwritten (tail
);
4940 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, end
, i
, h
, t
,
4941 DRAW_NORMAL_TEXT
, x
, last_x
,
4943 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
4944 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
4949 /* Append glyph strings for glyphs following the last glyph
4950 string tail that overwrite tail. The foreground of such
4951 glyphs has to be drawn because it writes into the background
4952 of tail. The background must not be drawn because it could
4953 paint over the foreground of following glyphs. */
4954 i
= x_right_overwriting (tail
);
4957 BUILD_GLYPH_STRINGS (hdc
, w
, row
, area
, end
, i
, h
, t
,
4958 DRAW_NORMAL_TEXT
, x
, last_x
,
4960 for (s
= h
; s
; s
= s
->next
)
4961 s
->background_filled_p
= 1;
4962 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
4963 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
4969 /* Draw all strings. */
4970 for (s
= head
; s
; s
= s
->next
)
4971 x_draw_glyph_string (s
);
4973 /* Value is the x-position up to which drawn, relative to AREA of W.
4974 This doesn't include parts drawn because of overhangs. */
4975 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
4976 if (!row
->full_width_p
)
4978 if (area
> LEFT_MARGIN_AREA
)
4979 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
4980 if (area
> TEXT_AREA
)
4981 x_reached
-= window_box_width (w
, TEXT_AREA
);
4984 release_frame_dc (XFRAME (WINDOW_FRAME (w
)), hdc
);
4990 /* Fix the display of area AREA of overlapping row ROW in window W. */
4993 x_fix_overlapping_area (w
, row
, area
)
4995 struct glyph_row
*row
;
4996 enum glyph_row_area area
;
5002 if (area
== LEFT_MARGIN_AREA
)
5004 else if (area
== TEXT_AREA
)
5005 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5007 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5008 + window_box_width (w
, TEXT_AREA
));
5010 for (i
= 0; i
< row
->used
[area
];)
5012 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
5014 int start
= i
, start_x
= x
;
5018 x
+= row
->glyphs
[area
][i
].pixel_width
;
5021 while (i
< row
->used
[area
]
5022 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
5024 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
5026 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
5031 x
+= row
->glyphs
[area
][i
].pixel_width
;
5040 /* Output LEN glyphs starting at START at the nominal cursor position.
5041 Advance the nominal cursor over the text. The global variable
5042 updated_window contains the window being updated, updated_row is
5043 the glyph row being updated, and updated_area is the area of that
5044 row being updated. */
5047 x_write_glyphs (start
, len
)
5048 struct glyph
*start
;
5051 int x
, hpos
, real_start
, real_end
;
5053 xassert (updated_window
&& updated_row
);
5058 hpos
= start
- updated_row
->glyphs
[updated_area
];
5059 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
5060 updated_row
, updated_area
,
5062 (updated_row
->inverse_p
5063 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
5064 &real_start
, &real_end
, 0);
5066 /* If we drew over the cursor, note that it is not visible any more. */
5067 note_overwritten_text_cursor (updated_window
, real_start
,
5068 real_end
- real_start
);
5072 /* Advance the output cursor. */
5073 output_cursor
.hpos
+= len
;
5074 output_cursor
.x
= x
;
5078 /* Insert LEN glyphs from START at the nominal cursor position. */
5081 x_insert_glyphs (start
, len
)
5082 struct glyph
*start
;
5087 int line_height
, shift_by_width
, shifted_region_width
;
5088 struct glyph_row
*row
;
5089 struct glyph
*glyph
;
5090 int frame_x
, frame_y
, hpos
, real_start
, real_end
;
5093 xassert (updated_window
&& updated_row
);
5096 f
= XFRAME (WINDOW_FRAME (w
));
5097 hdc
= get_frame_dc (f
);
5099 /* Get the height of the line we are in. */
5101 line_height
= row
->height
;
5103 /* Get the width of the glyphs to insert. */
5105 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
5106 shift_by_width
+= glyph
->pixel_width
;
5108 /* Get the width of the region to shift right. */
5109 shifted_region_width
= (window_box_width (w
, updated_area
)
5114 frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, output_cursor
.x
);
5115 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
5116 BitBlt (hdc
, frame_x
+ shift_by_width
, frame_y
,
5117 shifted_region_width
, line_height
,
5118 hdc
, frame_x
, frame_y
, SRCCOPY
);
5120 /* Write the glyphs. */
5121 hpos
= start
- row
->glyphs
[updated_area
];
5122 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
5123 DRAW_NORMAL_TEXT
, &real_start
, &real_end
, 0);
5124 note_overwritten_text_cursor (w
, real_start
, real_end
- real_start
);
5126 /* Advance the output cursor. */
5127 output_cursor
.hpos
+= len
;
5128 output_cursor
.x
+= shift_by_width
;
5129 release_frame_dc (f
, hdc
);
5135 /* Delete N glyphs at the nominal cursor position. Not implemented
5146 /* Erase the current text line from the nominal cursor position
5147 (inclusive) to pixel column TO_X (exclusive). The idea is that
5148 everything from TO_X onward is already erased.
5150 TO_X is a pixel position relative to updated_area of
5151 updated_window. TO_X == -1 means clear to the end of this area. */
5154 x_clear_end_of_line (to_x
)
5158 struct window
*w
= updated_window
;
5159 int max_x
, min_y
, max_y
;
5160 int from_x
, from_y
, to_y
;
5162 xassert (updated_window
&& updated_row
);
5163 f
= XFRAME (w
->frame
);
5165 if (updated_row
->full_width_p
)
5167 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5168 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5169 && !w
->pseudo_window_p
)
5170 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5173 max_x
= window_box_width (w
, updated_area
);
5174 max_y
= window_text_bottom_y (w
);
5176 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5177 of window. For TO_X > 0, truncate to end of drawing area. */
5183 to_x
= min (to_x
, max_x
);
5185 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
5187 /* Notice if the cursor will be cleared by this operation. */
5188 if (!updated_row
->full_width_p
)
5189 note_overwritten_text_cursor (w
, output_cursor
.hpos
, -1);
5191 from_x
= output_cursor
.x
;
5193 /* Translate to frame coordinates. */
5194 if (updated_row
->full_width_p
)
5196 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
5197 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
5201 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
5202 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
5205 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
5206 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
5207 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
5209 /* Prevent inadvertently clearing to end of the X window. */
5210 if (to_x
> from_x
&& to_y
> from_y
)
5214 hdc
= get_frame_dc (f
);
5216 w32_clear_area (f
, hdc
, from_x
, from_y
, to_x
- from_x
, to_y
- from_y
);
5217 release_frame_dc (f
, hdc
);
5223 /* Clear entire frame. If updating_frame is non-null, clear that
5224 frame. Otherwise clear the selected frame. */
5234 f
= SELECTED_FRAME ();
5236 /* Clearing the frame will erase any cursor, so mark them all as no
5238 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5239 output_cursor
.hpos
= output_cursor
.vpos
= 0;
5240 output_cursor
.x
= -1;
5242 /* We don't set the output cursor here because there will always
5243 follow an explicit cursor_to. */
5246 w32_clear_window (f
);
5248 /* We have to clear the scroll bars, too. If we have changed
5249 colors or something like that, then they should be notified. */
5250 x_scroll_bar_clear (f
);
5256 /* Make audible bell. */
5259 w32_ring_bell (void)
5266 HWND hwnd
= FRAME_W32_WINDOW (SELECTED_FRAME ());
5268 for (i
= 0; i
< 5; i
++)
5270 FlashWindow (hwnd
, TRUE
);
5273 FlashWindow (hwnd
, FALSE
);
5276 w32_sys_ring_bell ();
5282 /* Specify how many text lines, from the top of the window,
5283 should be affected by insert-lines and delete-lines operations.
5284 This, and those operations, are used only within an update
5285 that is bounded by calls to x_update_begin and x_update_end. */
5288 w32_set_terminal_window (n
)
5291 /* This function intentionally left blank. */
5296 /***********************************************************************
5298 ***********************************************************************/
5300 /* Perform an insert-lines or delete-lines operation, inserting N
5301 lines or deleting -N lines at vertical position VPOS. */
5304 x_ins_del_lines (vpos
, n
)
5311 /* Scroll part of the display as described by RUN. */
5314 x_scroll_run (w
, run
)
5318 struct frame
*f
= XFRAME (w
->frame
);
5319 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5320 HDC hdc
= get_frame_dc (f
);
5322 /* Get frame-relative bounding box of the text display area of W,
5323 without mode lines. Include in this box the flags areas to the
5324 left and right of W. */
5325 window_box (w
, -1, &x
, &y
, &width
, &height
);
5326 width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
5327 x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
5329 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5330 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5331 bottom_y
= y
+ height
;
5335 /* Scrolling up. Make sure we don't copy part of the mode
5336 line at the bottom. */
5337 if (from_y
+ run
->height
> bottom_y
)
5338 height
= bottom_y
- from_y
;
5340 height
= run
->height
;
5344 /* Scolling down. Make sure we don't copy over the mode line.
5346 if (to_y
+ run
->height
> bottom_y
)
5347 height
= bottom_y
- to_y
;
5349 height
= run
->height
;
5354 /* Cursor off. Will be switched on again in x_update_window_end. */
5358 BitBlt (hdc
, x
, to_y
, width
, height
, hdc
, x
, from_y
, SRCCOPY
);
5361 release_frame_dc (f
, hdc
);
5366 /***********************************************************************
5368 ***********************************************************************/
5370 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5371 corner of the exposed rectangle. W and H are width and height of
5372 the exposed area. All are pixel values. W or H zero means redraw
5373 the entire frame. */
5376 expose_frame (f
, x
, y
, w
, h
)
5382 TRACE ((stderr
, "expose_frame "));
5384 /* No need to redraw if frame will be redrawn soon. */
5385 if (FRAME_GARBAGED_P (f
))
5387 TRACE ((stderr
, " garbaged\n"));
5391 /* If basic faces haven't been realized yet, there is no point in
5392 trying to redraw anything. This can happen when we get an expose
5393 event while Emacs is starting, e.g. by moving another window. */
5394 if (FRAME_FACE_CACHE (f
) == NULL
5395 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5397 TRACE ((stderr
, " no faces\n"));
5401 if (w
== 0 || h
== 0)
5404 r
.right
= CANON_X_UNIT (f
) * f
->width
;
5405 r
.bottom
= CANON_Y_UNIT (f
) * f
->height
;
5415 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.left
, r
.top
, r
.right
, r
.bottom
));
5416 expose_window_tree (XWINDOW (f
->root_window
), &r
);
5418 if (WINDOWP (f
->tool_bar_window
))
5420 struct window
*w
= XWINDOW (f
->tool_bar_window
);
5422 RECT intersection_rect
;
5423 int window_x
, window_y
, window_width
, window_height
;
5425 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5426 window_rect
.left
= window_x
;
5427 window_rect
.top
= window_y
;
5428 window_rect
.right
= window_x
+ window_width
;
5429 window_rect
.bottom
= window_y
+ window_height
;
5431 if (IntersectRect (&intersection_rect
, &r
, &window_rect
))
5432 expose_window (w
, &intersection_rect
);
5437 /* Redraw (parts) of all windows in the window tree rooted at W that
5438 intersect R. R contains frame pixel coordinates. */
5441 expose_window_tree (w
, r
)
5447 if (!NILP (w
->hchild
))
5448 expose_window_tree (XWINDOW (w
->hchild
), r
);
5449 else if (!NILP (w
->vchild
))
5450 expose_window_tree (XWINDOW (w
->vchild
), r
);
5454 RECT intersection_rect
;
5455 struct frame
*f
= XFRAME (w
->frame
);
5456 int window_x
, window_y
, window_width
, window_height
;
5458 /* Frame-relative pixel rectangle of W. */
5459 window_box (w
, -1, &window_x
, &window_y
, &window_width
,
5463 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
5464 - FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_Y_UNIT (f
));
5465 window_rect
.top
= window_y
;
5466 window_rect
.right
= window_rect
.left
5468 + FRAME_X_FLAGS_AREA_WIDTH (f
)
5469 + FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
));
5470 window_rect
.bottom
= window_rect
.top
5471 + window_height
+ CURRENT_MODE_LINE_HEIGHT (w
);
5473 if (IntersectRect (&intersection_rect
, r
, &window_rect
))
5474 expose_window (w
, &intersection_rect
);
5477 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5482 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5483 which intersects rectangle R. R is in window-relative coordinates. */
5486 expose_area (w
, row
, r
, area
)
5488 struct glyph_row
*row
;
5490 enum glyph_row_area area
;
5493 struct glyph
*first
= row
->glyphs
[area
];
5494 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5498 /* Set x to the window-relative start position for drawing glyphs of
5499 AREA. The first glyph of the text area can be partially visible.
5500 The first glyphs of other areas cannot. */
5501 if (area
== LEFT_MARGIN_AREA
)
5503 else if (area
== TEXT_AREA
)
5504 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5506 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5507 + window_box_width (w
, TEXT_AREA
));
5509 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5510 /* If row extends face to end of line write the whole line. */
5511 x_draw_glyphs (w
, x
, row
, area
,
5513 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5517 /* Find the first glyph that must be redrawn. */
5519 && x
+ first
->pixel_width
< r
->left
)
5521 x
+= first
->pixel_width
;
5525 /* Find the last one. */
5531 x
+= last
->pixel_width
;
5537 x_draw_glyphs (w
, first_x
, row
, area
,
5538 first
- row
->glyphs
[area
],
5539 last
- row
->glyphs
[area
],
5540 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5546 /* Redraw the parts of the glyph row ROW on window W intersecting
5547 rectangle R. R is in window-relative coordinates. */
5550 expose_line (w
, row
, r
)
5552 struct glyph_row
*row
;
5555 xassert (row
->enabled_p
);
5557 if (row
->mode_line_p
|| w
->pseudo_window_p
)
5558 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
5559 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5563 if (row
->used
[LEFT_MARGIN_AREA
])
5564 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
5565 if (row
->used
[TEXT_AREA
])
5566 expose_area (w
, row
, r
, TEXT_AREA
);
5567 if (row
->used
[RIGHT_MARGIN_AREA
])
5568 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
5569 x_draw_row_bitmaps (w
, row
);
5574 /* Return non-zero if W's cursor intersects rectangle R. */
5577 x_phys_cursor_in_rect_p (w
, r
)
5582 struct glyph
*cursor_glyph
;
5584 cursor_glyph
= get_phys_cursor_glyph (w
);
5587 cr
.left
= w
->phys_cursor
.x
;
5588 cr
.top
= w
->phys_cursor
.y
;
5589 cr
.right
= cr
.left
+ cursor_glyph
->pixel_width
;
5590 cr
.bottom
= cr
.top
+ w
->phys_cursor_height
;
5591 return IntersectRect (&result
, &cr
, r
);
5598 /* Redraw a rectangle of window W. R is a rectangle in window
5599 relative coordinates. Call this function with input blocked. */
5602 expose_window (w
, r
)
5606 struct glyph_row
*row
;
5608 int yb
= window_text_bottom_y (w
);
5609 int cursor_cleared_p
;
5611 /* If window is not yet fully initialized, do nothing. This can
5612 happen when toolkit scroll bars are used and a window is split.
5613 Reconfiguring the scroll bar will generate an expose for a newly
5615 if (w
->current_matrix
== NULL
)
5618 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
5619 r
->left
, r
->top
, r
->right
, r
->bottom
));
5621 /* Convert to window coordinates. */
5622 r
->left
= FRAME_TO_WINDOW_PIXEL_X (w
, r
->left
);
5623 r
->top
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
->top
);
5624 r
->right
= FRAME_TO_WINDOW_PIXEL_X (w
, r
->right
);
5625 r
->bottom
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
->bottom
);
5627 /* Turn off the cursor. */
5628 if (!w
->pseudo_window_p
5629 && x_phys_cursor_in_rect_p (w
, r
))
5632 cursor_cleared_p
= 1;
5635 cursor_cleared_p
= 0;
5637 /* Find the first row intersecting the rectangle R. */
5638 row
= w
->current_matrix
->rows
;
5640 while (row
->enabled_p
5642 && y
+ row
->height
< r
->top
)
5648 /* Display the text in the rectangle, one text line at a time. */
5649 while (row
->enabled_p
5653 expose_line (w
, row
, r
);
5658 /* Display the mode line if there is one. */
5659 if (WINDOW_WANTS_MODELINE_P (w
)
5660 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
5662 && row
->y
< r
->bottom
)
5663 expose_line (w
, row
, r
);
5665 if (!w
->pseudo_window_p
)
5667 /* Draw border between windows. */
5668 x_draw_vertical_border (w
);
5670 /* Turn the cursor on again. */
5671 if (cursor_cleared_p
)
5672 x_update_window_cursor (w
, 1);
5681 x_update_cursor (f
, 1);
5685 frame_unhighlight (f
)
5688 x_update_cursor (f
, 1);
5691 /* The focus has changed. Update the frames as necessary to reflect
5692 the new situation. Note that we can't change the selected frame
5693 here, because the Lisp code we are interrupting might become confused.
5694 Each event gets marked with the frame in which it occurred, so the
5695 Lisp code can tell when the switch took place by examining the events. */
5698 x_new_focus_frame (dpyinfo
, frame
)
5699 struct w32_display_info
*dpyinfo
;
5700 struct frame
*frame
;
5702 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
5704 if (frame
!= dpyinfo
->w32_focus_frame
)
5706 /* Set this before calling other routines, so that they see
5707 the correct value of w32_focus_frame. */
5708 dpyinfo
->w32_focus_frame
= frame
;
5710 if (old_focus
&& old_focus
->auto_lower
)
5711 x_lower_frame (old_focus
);
5713 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
5714 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
5716 pending_autoraise_frame
= 0;
5719 x_frame_rehighlight (dpyinfo
);
5722 /* Handle an event saying the mouse has moved out of an Emacs frame. */
5725 x_mouse_leave (dpyinfo
)
5726 struct w32_display_info
*dpyinfo
;
5728 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
5731 /* The focus has changed, or we have redirected a frame's focus to
5732 another frame (this happens when a frame uses a surrogate
5733 mini-buffer frame). Shift the highlight as appropriate.
5735 The FRAME argument doesn't necessarily have anything to do with which
5736 frame is being highlighted or un-highlighted; we only use it to find
5737 the appropriate X display info. */
5740 w32_frame_rehighlight (frame
)
5741 struct frame
*frame
;
5743 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
5747 x_frame_rehighlight (dpyinfo
)
5748 struct w32_display_info
*dpyinfo
;
5750 struct frame
*old_highlight
= dpyinfo
->w32_highlight_frame
;
5752 if (dpyinfo
->w32_focus_frame
)
5754 dpyinfo
->w32_highlight_frame
5755 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
5756 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
5757 : dpyinfo
->w32_focus_frame
);
5758 if (! FRAME_LIVE_P (dpyinfo
->w32_highlight_frame
))
5760 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
5761 dpyinfo
->w32_highlight_frame
= dpyinfo
->w32_focus_frame
;
5765 dpyinfo
->w32_highlight_frame
= 0;
5767 if (dpyinfo
->w32_highlight_frame
!= old_highlight
)
5770 frame_unhighlight (old_highlight
);
5771 if (dpyinfo
->w32_highlight_frame
)
5772 frame_highlight (dpyinfo
->w32_highlight_frame
);
5776 /* Keyboard processing - modifier keys, etc. */
5778 /* Convert a keysym to its name. */
5781 x_get_keysym_name (keysym
)
5784 /* Make static so we can always return it */
5785 static char value
[100];
5788 GetKeyNameText (keysym
, value
, 100);
5796 /* Mouse clicks and mouse movement. Rah. */
5798 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
5799 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
5800 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
5801 not force the value into range. */
5804 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
5806 register int pix_x
, pix_y
;
5807 register int *x
, *y
;
5811 /* Support tty mode: if Vwindow_system is nil, behave correctly. */
5812 if (NILP (Vwindow_system
))
5819 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
5820 even for negative values. */
5822 pix_x
-= FONT_WIDTH (FRAME_FONT (f
)) - 1;
5824 pix_y
-= (f
)->output_data
.w32
->line_height
- 1;
5826 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
5827 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
5831 bounds
->left
= CHAR_TO_PIXEL_COL (f
, pix_x
);
5832 bounds
->top
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
5833 bounds
->right
= bounds
->left
+ FONT_WIDTH (FRAME_FONT (f
)) - 1;
5834 bounds
->bottom
= bounds
->top
+ f
->output_data
.w32
->line_height
- 1;
5841 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
5842 pix_x
= FRAME_WINDOW_WIDTH (f
);
5846 else if (pix_y
> f
->height
)
5855 /* Given HPOS/VPOS in the current matrix of W, return corresponding
5856 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
5857 can't tell the positions because W's display is not up to date,
5861 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
5864 int *frame_x
, *frame_y
;
5868 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
5869 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
5871 if (display_completed
)
5873 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
5874 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
5875 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
5881 *frame_x
+= glyph
->pixel_width
;
5889 *frame_y
= *frame_x
= 0;
5893 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
5894 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
5899 parse_button (message
, pbutton
, pup
)
5909 case WM_LBUTTONDOWN
:
5917 case WM_MBUTTONDOWN
:
5918 if (NILP (Vw32_swap_mouse_buttons
))
5925 if (NILP (Vw32_swap_mouse_buttons
))
5931 case WM_RBUTTONDOWN
:
5932 if (NILP (Vw32_swap_mouse_buttons
))
5939 if (NILP (Vw32_swap_mouse_buttons
))
5950 if (pbutton
) *pbutton
= button
;
5956 /* Prepare a mouse-event in *RESULT for placement in the input queue.
5958 If the event is a button press, then note that we have grabbed
5962 construct_mouse_click (result
, msg
, f
)
5963 struct input_event
*result
;
5970 parse_button (msg
->msg
.message
, &button
, &up
);
5972 /* Make the event type no_event; we'll change that when we decide
5974 result
->kind
= mouse_click
;
5975 result
->code
= button
;
5976 result
->timestamp
= msg
->msg
.time
;
5977 result
->modifiers
= (msg
->dwModifiers
5982 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
5983 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
5984 XSETFRAME (result
->frame_or_window
, f
);
5990 construct_mouse_wheel (result
, msg
, f
)
5991 struct input_event
*result
;
5996 result
->kind
= mouse_wheel
;
5997 result
->code
= (short) HIWORD (msg
->msg
.wParam
);
5998 result
->timestamp
= msg
->msg
.time
;
5999 result
->modifiers
= msg
->dwModifiers
;
6000 p
.x
= LOWORD (msg
->msg
.lParam
);
6001 p
.y
= HIWORD (msg
->msg
.lParam
);
6002 ScreenToClient (msg
->msg
.hwnd
, &p
);
6003 XSETINT (result
->x
, p
.x
);
6004 XSETINT (result
->y
, p
.y
);
6005 XSETFRAME (result
->frame_or_window
, f
);
6011 construct_drag_n_drop (result
, msg
, f
)
6012 struct input_event
*result
;
6024 result
->kind
= drag_n_drop
;
6026 result
->timestamp
= msg
->msg
.time
;
6027 result
->modifiers
= msg
->dwModifiers
;
6029 hdrop
= (HDROP
) msg
->msg
.wParam
;
6030 DragQueryPoint (hdrop
, &p
);
6033 p
.x
= LOWORD (msg
->msg
.lParam
);
6034 p
.y
= HIWORD (msg
->msg
.lParam
);
6035 ScreenToClient (msg
->msg
.hwnd
, &p
);
6038 XSETINT (result
->x
, p
.x
);
6039 XSETINT (result
->y
, p
.y
);
6041 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
6044 for (i
= 0; i
< num_files
; i
++)
6046 len
= DragQueryFile (hdrop
, i
, NULL
, 0);
6049 name
= alloca (len
+ 1);
6050 DragQueryFile (hdrop
, i
, name
, len
+ 1);
6051 files
= Fcons (build_string (name
), files
);
6056 XSETFRAME (frame
, f
);
6057 result
->frame_or_window
= Fcons (frame
, files
);
6063 /* Function to report a mouse movement to the mainstream Emacs code.
6064 The input handler calls this.
6066 We have received a mouse movement event, which is given in *event.
6067 If the mouse is over a different glyph than it was last time, tell
6068 the mainstream emacs code by setting mouse_moved. If not, ask for
6069 another motion event, so we can check again the next time it moves. */
6071 static MSG last_mouse_motion_event
;
6072 static Lisp_Object last_mouse_motion_frame
;
6075 note_mouse_movement (frame
, msg
)
6079 last_mouse_movement_time
= msg
->time
;
6080 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
6081 XSETFRAME (last_mouse_motion_frame
, frame
);
6083 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
6085 frame
->mouse_moved
= 1;
6086 last_mouse_scroll_bar
= Qnil
;
6087 note_mouse_highlight (frame
, -1, -1);
6090 /* Has the mouse moved off the glyph it was on at the last sighting? */
6091 else if (LOWORD (msg
->lParam
) < last_mouse_glyph
.left
6092 || LOWORD (msg
->lParam
) > last_mouse_glyph
.right
6093 || HIWORD (msg
->lParam
) < last_mouse_glyph
.top
6094 || HIWORD (msg
->lParam
) > last_mouse_glyph
.bottom
)
6096 frame
->mouse_moved
= 1;
6097 last_mouse_scroll_bar
= Qnil
;
6099 note_mouse_highlight (frame
, LOWORD (msg
->lParam
), HIWORD (msg
->lParam
));
6103 /* This is used for debugging, to turn off note_mouse_highlight. */
6105 int disable_mouse_highlight
;
6109 /************************************************************************
6111 ************************************************************************/
6113 /* Find the glyph under window-relative coordinates X/Y in window W.
6114 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6115 strings. Return in *HPOS and *VPOS the row and column number of
6116 the glyph found. Return in *AREA the glyph area containing X.
6117 Value is a pointer to the glyph found or null if X/Y is not on
6118 text, or we can't tell because W's current matrix is not up to
6121 static struct glyph
*
6122 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
)
6125 int *hpos
, *vpos
, *area
;
6127 struct glyph
*glyph
, *end
;
6128 struct glyph_row
*row
= NULL
;
6129 int x0
, i
, left_area_width
;
6131 /* Find row containing Y. Give up if some row is not enabled. */
6132 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6134 row
= MATRIX_ROW (w
->current_matrix
, i
);
6135 if (!row
->enabled_p
)
6137 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6144 /* Give up if Y is not in the window. */
6145 if (i
== w
->current_matrix
->nrows
)
6148 /* Get the glyph area containing X. */
6149 if (w
->pseudo_window_p
)
6156 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6157 if (x
< left_area_width
)
6159 *area
= LEFT_MARGIN_AREA
;
6162 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6165 x0
= row
->x
+ left_area_width
;
6169 *area
= RIGHT_MARGIN_AREA
;
6170 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6174 /* Find glyph containing X. */
6175 glyph
= row
->glyphs
[*area
];
6176 end
= glyph
+ row
->used
[*area
];
6179 if (x
< x0
+ glyph
->pixel_width
)
6181 if (w
->pseudo_window_p
)
6183 else if (BUFFERP (glyph
->object
))
6187 x0
+= glyph
->pixel_width
;
6194 *hpos
= glyph
- row
->glyphs
[*area
];
6199 /* Convert frame-relative x/y to coordinates relative to window W.
6200 Takes pseudo-windows into account. */
6203 frame_to_window_pixel_xy (w
, x
, y
)
6207 if (w
->pseudo_window_p
)
6209 /* A pseudo-window is always full-width, and starts at the
6210 left edge of the frame, plus a frame border. */
6211 struct frame
*f
= XFRAME (w
->frame
);
6212 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6213 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6217 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6218 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6223 /* Take proper action when mouse has moved to the mode or top line of
6224 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6225 mode line. X is relative to the start of the text display area of
6226 W, so the width of bitmap areas and scroll bars must be subtracted
6227 to get a position relative to the start of the mode line. */
6230 note_mode_line_highlight (w
, x
, mode_line_p
)
6234 struct frame
*f
= XFRAME (w
->frame
);
6235 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6236 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6237 struct glyph_row
*row
;
6240 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
6242 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
6246 struct glyph
*glyph
, *end
;
6247 Lisp_Object help
, map
;
6250 /* Find the glyph under X. */
6251 glyph
= row
->glyphs
[TEXT_AREA
];
6252 end
= glyph
+ row
->used
[TEXT_AREA
];
6253 x0
= - (FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
)
6254 + FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
));
6256 && x
>= x0
+ glyph
->pixel_width
)
6258 x0
+= glyph
->pixel_width
;
6263 && STRINGP (glyph
->object
)
6264 && XSTRING (glyph
->object
)->intervals
6265 && glyph
->charpos
>= 0
6266 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6268 /* If we're on a string with `help-echo' text property,
6269 arrange for the help to be displayed. This is done by
6270 setting the global variable help_echo to the help string. */
6271 help
= Fget_text_property (make_number (glyph
->charpos
),
6272 Qhelp_echo
, glyph
->object
);
6276 XSETWINDOW (help_echo_window
, w
);
6277 help_echo_object
= glyph
->object
;
6278 help_echo_pos
= glyph
->charpos
;
6281 /* Change the mouse pointer according to what is under X/Y. */
6282 map
= Fget_text_property (make_number (glyph
->charpos
),
6283 Qlocal_map
, glyph
->object
);
6285 cursor
= f
->output_data
.w32
->nontext_cursor
;
6289 #if 0 /* TODO: mouse cursor */
6290 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6295 /* Take proper action when the mouse has moved to position X, Y on
6296 frame F as regards highlighting characters that have mouse-face
6297 properties. Also de-highlighting chars where the mouse was before.
6298 X and Y can be negative or out of range. */
6301 note_mouse_highlight (f
, x
, y
)
6305 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6310 /* When a menu is active, don't highlight because this looks odd. */
6311 if (popup_activated ())
6314 if (disable_mouse_highlight
6315 || !f
->glyphs_initialized_p
)
6318 dpyinfo
->mouse_face_mouse_x
= x
;
6319 dpyinfo
->mouse_face_mouse_y
= y
;
6320 dpyinfo
->mouse_face_mouse_frame
= f
;
6322 if (dpyinfo
->mouse_face_defer
)
6327 dpyinfo
->mouse_face_deferred_gc
= 1;
6331 /* Which window is that in? */
6332 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
6334 /* If we were displaying active text in another window, clear that. */
6335 if (! EQ (window
, dpyinfo
->mouse_face_window
))
6336 clear_mouse_face (dpyinfo
);
6338 /* Not on a window -> return. */
6339 if (!WINDOWP (window
))
6342 /* Convert to window-relative pixel coordinates. */
6343 w
= XWINDOW (window
);
6344 frame_to_window_pixel_xy (w
, &x
, &y
);
6346 /* Handle tool-bar window differently since it doesn't display a
6348 if (EQ (window
, f
->tool_bar_window
))
6350 note_tool_bar_highlight (f
, x
, y
);
6354 if (portion
== 1 || portion
== 3)
6356 /* Mouse is on the mode or top line. */
6357 note_mode_line_highlight (w
, x
, portion
== 1);
6360 #if 0 /* TODO: mouse cursor */
6362 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6363 f
->output_data
.x
->text_cursor
);
6366 /* Are we in a window whose display is up to date?
6367 And verify the buffer's text has not changed. */
6368 if (/* Within text portion of the window. */
6370 && EQ (w
->window_end_valid
, w
->buffer
)
6371 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
6372 && (XFASTINT (w
->last_overlay_modified
)
6373 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
6375 int hpos
, vpos
, pos
, i
, area
;
6376 struct glyph
*glyph
;
6378 /* Find the glyph under X/Y. */
6379 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
);
6381 /* Clear mouse face if X/Y not over text. */
6383 || area
!= TEXT_AREA
6384 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
6386 clear_mouse_face (dpyinfo
);
6390 pos
= glyph
->charpos
;
6391 xassert (w
->pseudo_window_p
|| BUFFERP (glyph
->object
));
6393 /* Check for mouse-face and help-echo. */
6395 Lisp_Object mouse_face
, overlay
, position
;
6396 Lisp_Object
*overlay_vec
;
6398 struct buffer
*obuf
;
6401 /* If we get an out-of-range value, return now; avoid an error. */
6402 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
6405 /* Make the window's buffer temporarily current for
6406 overlays_at and compute_char_face. */
6407 obuf
= current_buffer
;
6408 current_buffer
= XBUFFER (w
->buffer
);
6414 /* Is this char mouse-active or does it have help-echo? */
6415 XSETINT (position
, pos
);
6417 /* Put all the overlays we want in a vector in overlay_vec.
6418 Store the length in len. If there are more than 10, make
6419 enough space for all, and try again. */
6421 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6422 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
6423 if (noverlays
> len
)
6426 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6427 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
,0);
6430 /* Sort overlays into increasing priority order. */
6431 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
6433 /* Check mouse-face highlighting. */
6434 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
6435 && vpos
>= dpyinfo
->mouse_face_beg_row
6436 && vpos
<= dpyinfo
->mouse_face_end_row
6437 && (vpos
> dpyinfo
->mouse_face_beg_row
6438 || hpos
>= dpyinfo
->mouse_face_beg_col
)
6439 && (vpos
< dpyinfo
->mouse_face_end_row
6440 || hpos
< dpyinfo
->mouse_face_end_col
6441 || dpyinfo
->mouse_face_past_end
)))
6443 /* Clear the display of the old active region, if any. */
6444 clear_mouse_face (dpyinfo
);
6446 /* Find the highest priority overlay that has a mouse-face prop. */
6448 for (i
= noverlays
- 1; i
>= 0; --i
)
6450 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
6451 if (!NILP (mouse_face
))
6453 overlay
= overlay_vec
[i
];
6458 /* If no overlay applies, get a text property. */
6460 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
6462 /* Handle the overlay case. */
6463 if (! NILP (overlay
))
6465 /* Find the range of text around this char that
6466 should be active. */
6467 Lisp_Object before
, after
;
6470 before
= Foverlay_start (overlay
);
6471 after
= Foverlay_end (overlay
);
6472 /* Record this as the current active region. */
6473 fast_find_position (w
, XFASTINT (before
),
6474 &dpyinfo
->mouse_face_beg_col
,
6475 &dpyinfo
->mouse_face_beg_row
,
6476 &dpyinfo
->mouse_face_beg_x
,
6477 &dpyinfo
->mouse_face_beg_y
);
6478 dpyinfo
->mouse_face_past_end
6479 = !fast_find_position (w
, XFASTINT (after
),
6480 &dpyinfo
->mouse_face_end_col
,
6481 &dpyinfo
->mouse_face_end_row
,
6482 &dpyinfo
->mouse_face_end_x
,
6483 &dpyinfo
->mouse_face_end_y
);
6484 dpyinfo
->mouse_face_window
= window
;
6485 dpyinfo
->mouse_face_face_id
6486 = face_at_buffer_position (w
, pos
, 0, 0,
6487 &ignore
, pos
+ 1, 1);
6489 /* Display it as active. */
6490 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6492 /* Handle the text property case. */
6493 else if (! NILP (mouse_face
))
6495 /* Find the range of text around this char that
6496 should be active. */
6497 Lisp_Object before
, after
, beginning
, end
;
6500 beginning
= Fmarker_position (w
->start
);
6501 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
6502 - XFASTINT (w
->window_end_pos
)));
6504 = Fprevious_single_property_change (make_number (pos
+ 1),
6506 w
->buffer
, beginning
);
6508 = Fnext_single_property_change (position
, Qmouse_face
,
6510 /* Record this as the current active region. */
6511 fast_find_position (w
, XFASTINT (before
),
6512 &dpyinfo
->mouse_face_beg_col
,
6513 &dpyinfo
->mouse_face_beg_row
,
6514 &dpyinfo
->mouse_face_beg_x
,
6515 &dpyinfo
->mouse_face_beg_y
);
6516 dpyinfo
->mouse_face_past_end
6517 = !fast_find_position (w
, XFASTINT (after
),
6518 &dpyinfo
->mouse_face_end_col
,
6519 &dpyinfo
->mouse_face_end_row
,
6520 &dpyinfo
->mouse_face_end_x
,
6521 &dpyinfo
->mouse_face_end_y
);
6522 dpyinfo
->mouse_face_window
= window
;
6523 dpyinfo
->mouse_face_face_id
6524 = face_at_buffer_position (w
, pos
, 0, 0,
6525 &ignore
, pos
+ 1, 1);
6527 /* Display it as active. */
6528 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
6532 /* Look for a `help-echo' property. */
6534 Lisp_Object help
, overlay
;
6536 /* Check overlays first. */
6538 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
6540 overlay
= overlay_vec
[i
];
6541 help
= Foverlay_get (overlay
, Qhelp_echo
);
6547 help_echo_window
= window
;
6548 help_echo_object
= overlay
;
6549 help_echo_pos
= pos
;
6553 /* Try text properties. */
6554 if ((STRINGP (glyph
->object
)
6555 && glyph
->charpos
>= 0
6556 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6557 || (BUFFERP (glyph
->object
)
6558 && glyph
->charpos
>= BEGV
6559 && glyph
->charpos
< ZV
))
6560 help
= Fget_text_property (make_number (glyph
->charpos
),
6561 Qhelp_echo
, glyph
->object
);
6566 help_echo_window
= window
;
6567 help_echo_object
= glyph
->object
;
6568 help_echo_pos
= glyph
->charpos
;
6575 current_buffer
= obuf
;
6581 redo_mouse_highlight ()
6583 if (!NILP (last_mouse_motion_frame
)
6584 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
6585 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
6586 LOWORD (last_mouse_motion_event
.lParam
),
6587 HIWORD (last_mouse_motion_event
.lParam
));
6592 /***********************************************************************
6594 ***********************************************************************/
6596 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
6597 struct glyph
**, int *, int *, int *));
6599 /* Tool-bar item index of the item on which a mouse button was pressed
6602 static int last_tool_bar_item
;
6605 /* Get information about the tool-bar item at position X/Y on frame F.
6606 Return in *GLYPH a pointer to the glyph of the tool-bar item in
6607 the current matrix of the tool-bar window of F, or NULL if not
6608 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
6609 item in F->current_tool_bar_items. Value is
6611 -1 if X/Y is not on a tool-bar item
6612 0 if X/Y is on the same item that was highlighted before.
6616 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
6619 struct glyph
**glyph
;
6620 int *hpos
, *vpos
, *prop_idx
;
6622 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6623 struct window
*w
= XWINDOW (f
->tool_bar_window
);
6626 /* Find the glyph under X/Y. */
6627 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
);
6631 /* Get the start of this tool-bar item's properties in
6632 f->current_tool_bar_items. */
6633 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
6636 /* Is mouse on the highlighted item? */
6637 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
6638 && *vpos
>= dpyinfo
->mouse_face_beg_row
6639 && *vpos
<= dpyinfo
->mouse_face_end_row
6640 && (*vpos
> dpyinfo
->mouse_face_beg_row
6641 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
6642 && (*vpos
< dpyinfo
->mouse_face_end_row
6643 || *hpos
< dpyinfo
->mouse_face_end_col
6644 || dpyinfo
->mouse_face_past_end
))
6651 /* Handle mouse button event on the tool-bar of frame F, at
6652 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
6656 w32_handle_tool_bar_click (f
, button_event
)
6658 struct input_event
*button_event
;
6660 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6661 struct window
*w
= XWINDOW (f
->tool_bar_window
);
6662 int hpos
, vpos
, prop_idx
;
6663 struct glyph
*glyph
;
6664 Lisp_Object enabled_p
;
6665 int x
= XFASTINT (button_event
->x
);
6666 int y
= XFASTINT (button_event
->y
);
6668 /* If not on the highlighted tool-bar item, return. */
6669 frame_to_window_pixel_xy (w
, &x
, &y
);
6670 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
6673 /* If item is disabled, do nothing. */
6674 enabled_p
= (XVECTOR (f
->current_tool_bar_items
)
6675 ->contents
[prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
]);
6676 if (NILP (enabled_p
))
6679 if (button_event
->kind
== mouse_click
)
6681 /* Show item in pressed state. */
6682 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
6683 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
6684 last_tool_bar_item
= prop_idx
;
6688 Lisp_Object key
, frame
;
6689 struct input_event event
;
6691 /* Show item in released state. */
6692 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
6693 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
6695 key
= (XVECTOR (f
->current_tool_bar_items
)
6696 ->contents
[prop_idx
+ TOOL_BAR_ITEM_KEY
]);
6698 XSETFRAME (frame
, f
);
6699 event
.kind
= TOOL_BAR_EVENT
;
6700 event
.frame_or_window
= frame
;
6702 kbd_buffer_store_event (&event
);
6704 event
.kind
= TOOL_BAR_EVENT
;
6705 event
.frame_or_window
= frame
;
6707 event
.modifiers
= button_event
->modifiers
;
6708 kbd_buffer_store_event (&event
);
6709 last_tool_bar_item
= -1;
6714 /* Possibly highlight a tool-bar item on frame F when mouse moves to
6715 tool-bar window-relative coordinates X/Y. Called from
6716 note_mouse_highlight. */
6719 note_tool_bar_highlight (f
, x
, y
)
6723 Lisp_Object window
= f
->tool_bar_window
;
6724 struct window
*w
= XWINDOW (window
);
6725 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6727 struct glyph
*glyph
;
6728 struct glyph_row
*row
;
6730 Lisp_Object enabled_p
;
6732 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
6733 int mouse_down_p
, rc
;
6735 /* Function note_mouse_highlight is called with negative x(y
6736 values when mouse moves outside of the frame. */
6737 if (x
<= 0 || y
<= 0)
6739 clear_mouse_face (dpyinfo
);
6743 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
6746 /* Not on tool-bar item. */
6747 clear_mouse_face (dpyinfo
);
6751 /* On same tool-bar item as before. */
6754 clear_mouse_face (dpyinfo
);
6756 /* Mouse is down, but on different tool-bar item? */
6757 mouse_down_p
= (dpyinfo
->grabbed
6758 && f
== last_mouse_frame
6759 && FRAME_LIVE_P (f
));
6761 && last_tool_bar_item
!= prop_idx
)
6764 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
6765 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
6767 /* If tool-bar item is not enabled, don't highlight it. */
6768 enabled_p
= (XVECTOR (f
->current_tool_bar_items
)
6769 ->contents
[prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
]);
6770 if (!NILP (enabled_p
))
6772 /* Compute the x-position of the glyph. In front and past the
6773 image is a space. We include this is the highlighted area. */
6774 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6775 for (i
= x
= 0; i
< hpos
; ++i
)
6776 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
6778 /* Record this as the current active region. */
6779 dpyinfo
->mouse_face_beg_col
= hpos
;
6780 dpyinfo
->mouse_face_beg_row
= vpos
;
6781 dpyinfo
->mouse_face_beg_x
= x
;
6782 dpyinfo
->mouse_face_beg_y
= row
->y
;
6783 dpyinfo
->mouse_face_past_end
= 0;
6785 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
6786 dpyinfo
->mouse_face_end_row
= vpos
;
6787 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
6788 dpyinfo
->mouse_face_end_y
= row
->y
;
6789 dpyinfo
->mouse_face_window
= window
;
6790 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
6792 /* Display it as active. */
6793 show_mouse_face (dpyinfo
, draw
);
6794 dpyinfo
->mouse_face_image_state
= draw
;
6799 /* Set help_echo to a help string.to display for this tool-bar item.
6800 w32_read_socket does the rest. */
6801 help_echo_object
= help_echo_window
= Qnil
;
6803 help_echo
= (XVECTOR (f
->current_tool_bar_items
)
6804 ->contents
[prop_idx
+ TOOL_BAR_ITEM_HELP
]);
6805 if (NILP (help_echo
))
6806 help_echo
= (XVECTOR (f
->current_tool_bar_items
)
6807 ->contents
[prop_idx
+ TOOL_BAR_ITEM_CAPTION
]);
6812 /* Find the glyph matrix position of buffer position POS in window W.
6813 *HPOS, *VPOS, *X, and *Y are set to the positions found. W's
6814 current glyphs must be up to date. If POS is above window start
6815 return (0, 0, 0, 0). If POS is after end of W, return end of
6819 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
)
6822 int *hpos
, *vpos
, *x
, *y
;
6826 int maybe_next_line_p
= 0;
6827 int line_start_position
;
6828 int yb
= window_text_bottom_y (w
);
6829 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
6830 struct glyph_row
*best_row
= row
;
6831 int row_vpos
= 0, best_row_vpos
= 0;
6836 if (row
->used
[TEXT_AREA
])
6837 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
6839 line_start_position
= 0;
6841 if (line_start_position
> pos
)
6843 /* If the position sought is the end of the buffer,
6844 don't include the blank lines at the bottom of the window. */
6845 else if (line_start_position
== pos
6846 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
6848 maybe_next_line_p
= 1;
6851 else if (line_start_position
> 0)
6854 best_row_vpos
= row_vpos
;
6857 if (row
->y
+ row
->height
>= yb
)
6864 /* Find the right column within BEST_ROW. */
6866 current_x
= best_row
->x
;
6867 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
6869 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
6872 charpos
= glyph
->charpos
;
6876 *vpos
= best_row_vpos
;
6881 else if (charpos
> pos
)
6883 else if (charpos
> 0)
6886 current_x
+= glyph
->pixel_width
;
6889 /* If we're looking for the end of the buffer,
6890 and we didn't find it in the line we scanned,
6891 use the start of the following line. */
6892 if (maybe_next_line_p
)
6897 current_x
= best_row
->x
;
6900 *vpos
= best_row_vpos
;
6901 *hpos
= lastcol
+ 1;
6908 /* Display the active region described by mouse_face_*
6909 in its mouse-face if HL > 0, in its normal face if HL = 0. */
6912 show_mouse_face (dpyinfo
, draw
)
6913 struct w32_display_info
*dpyinfo
;
6914 enum draw_glyphs_face draw
;
6916 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
6917 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
6919 int cursor_off_p
= 0;
6920 struct cursor_pos saved_cursor
;
6922 saved_cursor
= output_cursor
;
6924 /* If window is in the process of being destroyed, don't bother
6926 if (w
->current_matrix
== NULL
)
6929 /* Recognize when we are called to operate on rows that don't exist
6930 anymore. This can happen when a window is split. */
6931 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
6934 set_output_cursor (&w
->phys_cursor
);
6936 /* Note that mouse_face_beg_row etc. are window relative. */
6937 for (i
= dpyinfo
->mouse_face_beg_row
;
6938 i
<= dpyinfo
->mouse_face_end_row
;
6941 int start_hpos
, end_hpos
, start_x
;
6942 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
6944 /* Don't do anything if row doesn't have valid contents. */
6945 if (!row
->enabled_p
)
6948 /* For all but the first row, the highlight starts at column 0. */
6949 if (i
== dpyinfo
->mouse_face_beg_row
)
6951 start_hpos
= dpyinfo
->mouse_face_beg_col
;
6952 start_x
= dpyinfo
->mouse_face_beg_x
;
6960 if (i
== dpyinfo
->mouse_face_end_row
)
6961 end_hpos
= dpyinfo
->mouse_face_end_col
;
6963 end_hpos
= row
->used
[TEXT_AREA
];
6965 /* If the cursor's in the text we are about to rewrite, turn the
6967 if (!w
->pseudo_window_p
6968 && i
== output_cursor
.vpos
6969 && output_cursor
.hpos
>= start_hpos
- 1
6970 && output_cursor
.hpos
<= end_hpos
)
6972 x_update_window_cursor (w
, 0);
6976 if (end_hpos
> start_hpos
)
6978 row
->mouse_face_p
= draw
== DRAW_MOUSE_FACE
;
6979 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
6980 start_hpos
, end_hpos
, draw
, NULL
, NULL
, 0);
6984 /* If we turned the cursor off, turn it back on. */
6986 x_display_cursor (w
, 1,
6987 output_cursor
.hpos
, output_cursor
.vpos
,
6988 output_cursor
.x
, output_cursor
.y
);
6990 output_cursor
= saved_cursor
;
6993 #if 0 /* TODO: mouse cursor */
6994 /* Change the mouse cursor. */
6995 if (draw
== DRAW_NORMAL_TEXT
)
6996 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6997 f
->output_data
.x
->text_cursor
);
6998 else if (draw
== DRAW_MOUSE_FACE
)
6999 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7000 f
->output_data
.x
->cross_cursor
);
7002 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7003 f
->output_data
.x
->nontext_cursor
);
7008 /* Clear out the mouse-highlighted active region.
7009 Redraw it un-highlighted first. */
7012 clear_mouse_face (dpyinfo
)
7013 struct w32_display_info
*dpyinfo
;
7018 if (! NILP (dpyinfo
->mouse_face_window
))
7019 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
7021 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7022 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7023 dpyinfo
->mouse_face_window
= Qnil
;
7027 /* Clear any mouse-face on window W. This function is part of the
7028 redisplay interface, and is called from try_window_id and similar
7029 functions to ensure the mouse-highlight is off. */
7032 x_clear_mouse_face (w
)
7035 struct w32_display_info
*dpyinfo
7036 = FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
7040 XSETWINDOW (window
, w
);
7041 if (EQ (window
, dpyinfo
->mouse_face_window
))
7042 clear_mouse_face (dpyinfo
);
7047 /* Just discard the mouse face information for frame F, if any.
7048 This is used when the size of F is changed. */
7051 cancel_mouse_face (f
)
7055 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
7057 window
= dpyinfo
->mouse_face_window
;
7058 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
7060 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7061 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7062 dpyinfo
->mouse_face_window
= Qnil
;
7066 static struct scroll_bar
*x_window_to_scroll_bar ();
7067 static void x_scroll_bar_report_motion ();
7069 /* Return the current position of the mouse.
7070 *fp should be a frame which indicates which display to ask about.
7072 If the mouse movement started in a scroll bar, set *fp, *bar_window,
7073 and *part to the frame, window, and scroll bar part that the mouse
7074 is over. Set *x and *y to the portion and whole of the mouse's
7075 position on the scroll bar.
7077 If the mouse movement started elsewhere, set *fp to the frame the
7078 mouse is on, *bar_window to nil, and *x and *y to the character cell
7081 Set *time to the server time-stamp for the time at which the mouse
7082 was at this position.
7084 Don't store anything if we don't have a valid set of values to report.
7086 This clears the mouse_moved flag, so we can wait for the next mouse
7090 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
7093 Lisp_Object
*bar_window
;
7094 enum scroll_bar_part
*part
;
7096 unsigned long *time
;
7102 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
7103 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
7108 Lisp_Object frame
, tail
;
7110 /* Clear the mouse-moved flag for every frame on this display. */
7111 FOR_EACH_FRAME (tail
, frame
)
7112 XFRAME (frame
)->mouse_moved
= 0;
7114 last_mouse_scroll_bar
= Qnil
;
7118 /* Now we have a position on the root; find the innermost window
7119 containing the pointer. */
7121 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
7122 && FRAME_LIVE_P (last_mouse_frame
))
7124 /* If mouse was grabbed on a frame, give coords for that frame
7125 even if the mouse is now outside it. */
7126 f1
= last_mouse_frame
;
7130 /* Is window under mouse one of our frames? */
7131 f1
= x_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
7132 WindowFromPoint (pt
));
7135 /* If not, is it one of our scroll bars? */
7138 struct scroll_bar
*bar
7139 = x_window_to_scroll_bar (WindowFromPoint (pt
));
7143 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7147 if (f1
== 0 && insist
> 0)
7148 f1
= SELECTED_FRAME ();
7152 /* Ok, we found a frame. Store all the values.
7153 last_mouse_glyph is a rectangle used to reduce the
7154 generation of mouse events. To not miss any motion
7155 events, we must divide the frame into rectangles of the
7156 size of the smallest character that could be displayed
7157 on it, i.e. into the same rectangles that matrices on
7158 the frame are divided into. */
7160 #if OLD_REDISPLAY_CODE
7161 int ignore1
, ignore2
;
7163 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
7165 pixel_to_glyph_coords (f1
, pt
.x
, pt
.y
, &ignore1
, &ignore2
,
7167 FRAME_W32_DISPLAY_INFO (f1
)->grabbed
7170 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
7172 int width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
7173 int height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
7177 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
7178 round down even for negative values. */
7184 last_mouse_glyph
.left
= (x
+ width
- 1) / width
* width
;
7185 last_mouse_glyph
.top
= (y
+ height
- 1) / height
* height
;
7186 last_mouse_glyph
.right
= last_mouse_glyph
.left
+ width
;
7187 last_mouse_glyph
.bottom
= last_mouse_glyph
.top
+ height
;
7196 *time
= last_mouse_movement_time
;
7205 /* Scroll bar support. */
7207 /* Given a window ID, find the struct scroll_bar which manages it.
7208 This can be called in GC, so we have to make sure to strip off mark
7211 static struct scroll_bar
*
7212 x_window_to_scroll_bar (window_id
)
7217 for (tail
= Vframe_list
;
7218 XGCTYPE (tail
) == Lisp_Cons
;
7221 Lisp_Object frame
, bar
, condemned
;
7223 frame
= XCAR (tail
);
7224 /* All elements of Vframe_list should be frames. */
7225 if (! GC_FRAMEP (frame
))
7228 /* Scan this frame's scroll bar list for a scroll bar with the
7230 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
7231 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
7232 /* This trick allows us to search both the ordinary and
7233 condemned scroll bar lists with one loop. */
7234 ! GC_NILP (bar
) || (bar
= condemned
,
7237 bar
= XSCROLL_BAR (bar
)->next
)
7238 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
7239 return XSCROLL_BAR (bar
);
7247 /* Set the thumb size and position of scroll bar BAR. We are currently
7248 displaying PORTION out of a whole WHOLE, and our position POSITION. */
7251 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
)
7252 struct scroll_bar
*bar
;
7253 int portion
, position
, whole
;
7255 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
7256 int range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
7257 int sb_page
, sb_pos
;
7258 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
7262 /* Position scroll bar at rock bottom if the bottom of the
7263 buffer is visible. This avoids shinking the thumb away
7264 to nothing if it is held at the bottom of the buffer. */
7265 if (position
+ portion
>= whole
)
7267 sb_page
= range
* (whole
- position
) / whole
7268 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
7272 sb_page
= portion
* range
/ whole
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
7273 sb_pos
= position
* range
/ whole
;
7283 if (pfnSetScrollInfo
)
7287 si
.cbSize
= sizeof (si
);
7288 /* Only update page size if currently dragging, to reduce
7291 si
.fMask
= SIF_PAGE
;
7293 si
.fMask
= SIF_PAGE
| SIF_POS
;
7297 pfnSetScrollInfo (w
, SB_CTL
, &si
, !draggingp
);
7300 SetScrollPos (w
, SB_CTL
, sb_pos
, !draggingp
);
7306 /************************************************************************
7307 Scroll bars, general
7308 ************************************************************************/
7311 my_create_scrollbar (f
, bar
)
7313 struct scroll_bar
* bar
;
7315 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
7316 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
7320 //#define ATTACH_THREADS
7323 my_show_window (FRAME_PTR f
, HWND hwnd
, int how
)
7325 #ifndef ATTACH_THREADS
7326 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
7327 (WPARAM
) hwnd
, (LPARAM
) how
);
7329 return ShowWindow (hwnd
, how
);
7334 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
7335 int x
, int y
, int cx
, int cy
, UINT flags
)
7337 #ifndef ATTACH_THREADS
7339 pos
.hwndInsertAfter
= hwndAfter
;
7345 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
7347 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
7352 my_set_focus (f
, hwnd
)
7356 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
7361 my_set_foreground_window (hwnd
)
7364 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
7368 my_destroy_window (f
, hwnd
)
7372 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
7376 /* Create a scroll bar and return the scroll bar vector for it. W is
7377 the Emacs window on which to create the scroll bar. TOP, LEFT,
7378 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
7381 static struct scroll_bar
*
7382 x_scroll_bar_create (w
, top
, left
, width
, height
)
7384 int top
, left
, width
, height
;
7386 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7388 struct scroll_bar
*bar
7389 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
7393 XSETWINDOW (bar
->window
, w
);
7394 XSETINT (bar
->top
, top
);
7395 XSETINT (bar
->left
, left
);
7396 XSETINT (bar
->width
, width
);
7397 XSETINT (bar
->height
, height
);
7398 XSETINT (bar
->start
, 0);
7399 XSETINT (bar
->end
, 0);
7400 bar
->dragging
= Qnil
;
7402 /* Requires geometry to be set before call to create the real window */
7404 hwnd
= my_create_scrollbar (f
, bar
);
7406 if (pfnSetScrollInfo
)
7410 si
.cbSize
= sizeof (si
);
7413 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
7414 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
7418 pfnSetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
7422 SetScrollRange (hwnd
, SB_CTL
, 0,
7423 VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
), FALSE
);
7424 SetScrollPos (hwnd
, SB_CTL
, 0, FALSE
);
7427 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
7429 /* Add bar to its frame's list of scroll bars. */
7430 bar
->next
= FRAME_SCROLL_BARS (f
);
7432 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
7433 if (! NILP (bar
->next
))
7434 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
7442 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
7446 x_scroll_bar_remove (bar
)
7447 struct scroll_bar
*bar
;
7449 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7453 /* Destroy the window. */
7454 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
7456 /* Disassociate this scroll bar from its window. */
7457 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
7462 /* Set the handle of the vertical scroll bar for WINDOW to indicate
7463 that we are displaying PORTION characters out of a total of WHOLE
7464 characters, starting at POSITION. If WINDOW has no scroll bar,
7467 w32_set_vertical_scroll_bar (w
, portion
, whole
, position
)
7469 int portion
, whole
, position
;
7471 struct frame
*f
= XFRAME (w
->frame
);
7472 struct scroll_bar
*bar
;
7473 int top
, height
, left
, sb_left
, width
, sb_width
;
7474 int window_x
, window_y
, window_width
, window_height
;
7476 /* Get window dimensions. */
7477 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
7479 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
7480 height
= window_height
;
7482 /* Compute the left edge of the scroll bar area. */
7483 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
7484 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
7486 left
= XFASTINT (w
->left
);
7487 left
*= CANON_X_UNIT (f
);
7488 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
7490 /* Compute the width of the scroll bar which might be less than
7491 the width of the area reserved for the scroll bar. */
7492 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
7493 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
7497 /* Compute the left edge of the scroll bar. */
7498 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
7499 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
7501 sb_left
= left
+ (width
- sb_width
) / 2;
7503 /* Does the scroll bar exist yet? */
7504 if (NILP (w
->vertical_scroll_bar
))
7508 hdc
= get_frame_dc (f
);
7509 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
7510 release_frame_dc (f
, hdc
);
7513 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
7517 /* It may just need to be moved and resized. */
7520 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
7521 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
7523 /* If already correctly positioned, do nothing. */
7524 if ( XINT (bar
->left
) == sb_left
7525 && XINT (bar
->top
) == top
7526 && XINT (bar
->width
) == sb_width
7527 && XINT (bar
->height
) == height
)
7529 /* Redraw after clear_frame. */
7530 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
7531 InvalidateRect (hwnd
, NULL
, FALSE
);
7538 hdc
= get_frame_dc (f
);
7539 /* Since Windows scroll bars are smaller than the space reserved
7540 for them on the frame, we have to clear "under" them. */
7541 w32_clear_area (f
, hdc
,
7546 release_frame_dc (f
, hdc
);
7548 /* Make sure scroll bar is "visible" before moving, to ensure the
7549 area of the parent window now exposed will be refreshed. */
7550 my_show_window (f
, hwnd
, SW_HIDE
);
7551 MoveWindow (hwnd
, sb_left
, top
,
7552 sb_width
, height
, TRUE
);
7553 if (pfnSetScrollInfo
)
7557 si
.cbSize
= sizeof (si
);
7558 si
.fMask
= SIF_RANGE
;
7560 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
7561 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
7563 pfnSetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
7566 SetScrollRange (hwnd
, SB_CTL
, 0,
7567 VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
), FALSE
);
7568 my_show_window (f
, hwnd
, SW_NORMAL
);
7569 // InvalidateRect (w, NULL, FALSE);
7571 /* Remember new settings. */
7572 XSETINT (bar
->left
, sb_left
);
7573 XSETINT (bar
->top
, top
);
7574 XSETINT (bar
->width
, sb_width
);
7575 XSETINT (bar
->height
, height
);
7580 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
7582 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
7586 /* The following three hooks are used when we're doing a thorough
7587 redisplay of the frame. We don't explicitly know which scroll bars
7588 are going to be deleted, because keeping track of when windows go
7589 away is a real pain - "Can you say set-window-configuration, boys
7590 and girls?" Instead, we just assert at the beginning of redisplay
7591 that *all* scroll bars are to be removed, and then save a scroll bar
7592 from the fiery pit when we actually redisplay its window. */
7594 /* Arrange for all scroll bars on FRAME to be removed at the next call
7595 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
7596 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
7599 w32_condemn_scroll_bars (frame
)
7602 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
7603 while (! NILP (FRAME_SCROLL_BARS (frame
)))
7606 bar
= FRAME_SCROLL_BARS (frame
);
7607 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
7608 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
7609 XSCROLL_BAR (bar
)->prev
= Qnil
;
7610 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
7611 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
7612 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
7616 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
7617 Note that WINDOW isn't necessarily condemned at all. */
7619 w32_redeem_scroll_bar (window
)
7620 struct window
*window
;
7622 struct scroll_bar
*bar
;
7624 /* We can't redeem this window's scroll bar if it doesn't have one. */
7625 if (NILP (window
->vertical_scroll_bar
))
7628 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
7630 /* Unlink it from the condemned list. */
7632 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
7634 if (NILP (bar
->prev
))
7636 /* If the prev pointer is nil, it must be the first in one of
7638 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
7639 /* It's not condemned. Everything's fine. */
7641 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
7642 window
->vertical_scroll_bar
))
7643 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
7645 /* If its prev pointer is nil, it must be at the front of
7646 one or the other! */
7650 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
7652 if (! NILP (bar
->next
))
7653 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
7655 bar
->next
= FRAME_SCROLL_BARS (f
);
7657 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
7658 if (! NILP (bar
->next
))
7659 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
7663 /* Remove all scroll bars on FRAME that haven't been saved since the
7664 last call to `*condemn_scroll_bars_hook'. */
7667 w32_judge_scroll_bars (f
)
7670 Lisp_Object bar
, next
;
7672 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
7674 /* Clear out the condemned list now so we won't try to process any
7675 more events on the hapless scroll bars. */
7676 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
7678 for (; ! NILP (bar
); bar
= next
)
7680 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
7682 x_scroll_bar_remove (b
);
7685 b
->next
= b
->prev
= Qnil
;
7688 /* Now there should be no references to the condemned scroll bars,
7689 and they should get garbage-collected. */
7692 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
7693 is set to something other than no_event, it is enqueued.
7695 This may be called from a signal handler, so we have to ignore GC
7699 x_scroll_bar_handle_click (bar
, msg
, emacs_event
)
7700 struct scroll_bar
*bar
;
7702 struct input_event
*emacs_event
;
7704 if (! GC_WINDOWP (bar
->window
))
7707 emacs_event
->kind
= w32_scroll_bar_click
;
7708 emacs_event
->code
= 0;
7709 /* not really meaningful to distinguish up/down */
7710 emacs_event
->modifiers
= msg
->dwModifiers
;
7711 emacs_event
->frame_or_window
= bar
->window
;
7712 emacs_event
->arg
= Qnil
;
7713 emacs_event
->timestamp
= msg
->msg
.time
;
7716 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
7718 int dragging
= !NILP (bar
->dragging
);
7720 if (pfnGetScrollInfo
)
7724 si
.cbSize
= sizeof (si
);
7727 pfnGetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
7731 y
= GetScrollPos ((HWND
) msg
->msg
.lParam
, SB_CTL
);
7733 bar
->dragging
= Qnil
;
7736 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
7738 switch (LOWORD (msg
->msg
.wParam
))
7741 emacs_event
->part
= scroll_bar_down_arrow
;
7744 emacs_event
->part
= scroll_bar_up_arrow
;
7747 emacs_event
->part
= scroll_bar_above_handle
;
7750 emacs_event
->part
= scroll_bar_below_handle
;
7753 emacs_event
->part
= scroll_bar_handle
;
7757 emacs_event
->part
= scroll_bar_handle
;
7761 case SB_THUMBPOSITION
:
7762 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
7763 y
= HIWORD (msg
->msg
.wParam
);
7765 emacs_event
->part
= scroll_bar_handle
;
7767 /* "Silently" update current position. */
7768 if (pfnSetScrollInfo
)
7772 si
.cbSize
= sizeof (si
);
7775 /* Remember apparent position (we actually lag behind the real
7776 position, so don't set that directly. */
7777 last_scroll_bar_drag_pos
= y
;
7779 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
7782 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, FALSE
);
7785 /* If this is the end of a drag sequence, then reset the scroll
7786 handle size to normal and do a final redraw. Otherwise do
7790 if (pfnSetScrollInfo
)
7793 int start
= XINT (bar
->start
);
7794 int end
= XINT (bar
->end
);
7796 si
.cbSize
= sizeof (si
);
7797 si
.fMask
= SIF_PAGE
| SIF_POS
;
7798 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
7799 si
.nPos
= last_scroll_bar_drag_pos
;
7800 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
7803 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, TRUE
);
7807 emacs_event
->kind
= no_event
;
7811 XSETINT (emacs_event
->x
, y
);
7812 XSETINT (emacs_event
->y
, top_range
);
7818 /* Return information to the user about the current position of the mouse
7819 on the scroll bar. */
7822 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
7824 Lisp_Object
*bar_window
;
7825 enum scroll_bar_part
*part
;
7827 unsigned long *time
;
7829 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
7830 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
7831 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7833 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
7838 *bar_window
= bar
->window
;
7840 if (pfnGetScrollInfo
)
7844 si
.cbSize
= sizeof (si
);
7845 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
7847 pfnGetScrollInfo (w
, SB_CTL
, &si
);
7849 top_range
= si
.nMax
- si
.nPage
+ 1;
7852 pos
= GetScrollPos (w
, SB_CTL
);
7854 switch (LOWORD (last_mouse_scroll_bar_pos
))
7856 case SB_THUMBPOSITION
:
7858 *part
= scroll_bar_handle
;
7859 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
7860 pos
= HIWORD (last_mouse_scroll_bar_pos
);
7863 *part
= scroll_bar_handle
;
7867 *part
= scroll_bar_handle
;
7872 XSETINT (*y
, top_range
);
7875 last_mouse_scroll_bar
= Qnil
;
7877 *time
= last_mouse_movement_time
;
7883 /* The screen has been cleared so we may have changed foreground or
7884 background colors, and the scroll bars may need to be redrawn.
7885 Clear out the scroll bars, and ask for expose events, so we can
7889 x_scroll_bar_clear (f
)
7894 /* We can have scroll bars even if this is 0,
7895 if we just turned off scroll bar mode.
7896 But in that case we should not clear them. */
7897 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
7898 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
7899 bar
= XSCROLL_BAR (bar
)->next
)
7901 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
7902 HDC hdc
= GetDC (window
);
7905 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
7906 arranges to refresh the scroll bar if hidden. */
7907 my_show_window (f
, window
, SW_HIDE
);
7909 GetClientRect (window
, &rect
);
7910 select_palette (f
, hdc
);
7911 w32_clear_rect (f
, hdc
, &rect
);
7912 deselect_palette (f
, hdc
);
7914 ReleaseDC (window
, hdc
);
7918 show_scroll_bars (f
, how
)
7924 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
7925 bar
= XSCROLL_BAR (bar
)->next
)
7927 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
7928 my_show_window (f
, window
, how
);
7933 /* The main W32 event-reading loop - w32_read_socket. */
7935 /* Time stamp of enter window event. This is only used by w32_read_socket,
7936 but we have to put it out here, since static variables within functions
7937 sometimes don't work. */
7939 static Time enter_timestamp
;
7941 /* Record the last 100 characters stored
7942 to help debug the loss-of-chars-during-GC problem. */
7944 static int temp_index
;
7945 static short temp_buffer
[100];
7948 /* Read events coming from the W32 shell.
7949 This routine is called by the SIGIO handler.
7950 We return as soon as there are no more events to be read.
7952 Events representing keys are stored in buffer BUFP,
7953 which can hold up to NUMCHARS characters.
7954 We return the number of characters stored into the buffer,
7955 thus pretending to be `read'.
7957 EXPECTED is nonzero if the caller knows input is available.
7959 Some of these messages are reposted back to the message queue since the
7960 system calls the windows proc directly in a context where we cannot return
7961 the data nor can we guarantee the state we are in. So if we dispatch them
7962 we will get into an infinite loop. To prevent this from ever happening we
7963 will set a variable to indicate we are in the read_socket call and indicate
7964 which message we are processing since the windows proc gets called
7965 recursively with different messages by the system.
7969 w32_read_socket (sd
, bufp
, numchars
, expected
)
7971 /* register */ struct input_event
*bufp
;
7972 /* register */ int numchars
;
7976 int check_visibility
= 0;
7979 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
7981 if (interrupt_input_blocked
)
7983 interrupt_input_pending
= 1;
7987 interrupt_input_pending
= 0;
7990 /* So people can tell when we have read the available input. */
7991 input_signal_count
++;
7994 abort (); /* Don't think this happens. */
7996 /* TODO: tooltips, tool-bars, ghostscript integration, mouse
7998 while (get_next_msg (&msg
, FALSE
))
8000 switch (msg
.msg
.message
)
8003 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8007 if (msg
.rect
.right
== msg
.rect
.left
||
8008 msg
.rect
.bottom
== msg
.rect
.top
)
8010 /* We may get paint messages even though the client
8011 area is clipped - these are not expose events. */
8012 DebPrint (("clipped frame %04x (%s) got WM_PAINT\n", f
,
8013 XSTRING (f
->name
)->data
));
8015 else if (f
->async_visible
!= 1)
8017 /* Definitely not obscured, so mark as visible. */
8018 f
->async_visible
= 1;
8019 f
->async_iconified
= 0;
8020 SET_FRAME_GARBAGED (f
);
8021 DebPrint (("frame %04x (%s) reexposed\n", f
,
8022 XSTRING (f
->name
)->data
));
8024 /* WM_PAINT serves as MapNotify as well, so report
8025 visibility changes properly. */
8028 bufp
->kind
= deiconify_event
;
8029 XSETFRAME (bufp
->frame_or_window
, f
);
8035 else if (! NILP (Vframe_list
)
8036 && ! NILP (XCDR (Vframe_list
)))
8037 /* Force a redisplay sooner or later to update the
8038 frame titles in case this is the second frame. */
8039 record_asynch_buffer_change ();
8043 HDC hdc
= get_frame_dc (f
);
8045 /* Erase background again for safety. */
8046 w32_clear_rect (f
, hdc
, &msg
.rect
);
8047 release_frame_dc (f
, hdc
);
8051 msg
.rect
.right
- msg
.rect
.left
,
8052 msg
.rect
.bottom
- msg
.rect
.top
);
8057 case WM_INPUTLANGCHANGE
:
8058 /* Generate a language change event. */
8059 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8066 bufp
->kind
= language_change_event
;
8067 XSETFRAME (bufp
->frame_or_window
, f
);
8069 bufp
->code
= msg
.msg
.wParam
;
8070 bufp
->modifiers
= msg
.msg
.lParam
& 0xffff;
8079 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8081 if (f
&& !f
->iconified
)
8083 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
8085 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
8086 bufp
->kind
= non_ascii_keystroke
;
8087 bufp
->code
= msg
.msg
.wParam
;
8088 bufp
->modifiers
= msg
.dwModifiers
;
8089 XSETFRAME (bufp
->frame_or_window
, f
);
8091 bufp
->timestamp
= msg
.msg
.time
;
8100 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8102 if (f
&& !f
->iconified
)
8104 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
8106 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
8107 bufp
->kind
= ascii_keystroke
;
8108 bufp
->code
= msg
.msg
.wParam
;
8109 bufp
->modifiers
= msg
.dwModifiers
;
8110 XSETFRAME (bufp
->frame_or_window
, f
);
8112 bufp
->timestamp
= msg
.msg
.time
;
8120 previous_help_echo
= help_echo
;
8121 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
8124 if (dpyinfo
->grabbed
&& last_mouse_frame
8125 && FRAME_LIVE_P (last_mouse_frame
))
8126 f
= last_mouse_frame
;
8128 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8131 note_mouse_movement (f
, &msg
.msg
);
8134 /* If we move outside the frame, then we're
8135 certainly no longer on any text in the frame. */
8136 clear_mouse_face (FRAME_W32_DISPLAY_INFO (f
));
8139 /* If the contents of the global variable help_echo
8140 has changed, generate a HELP_EVENT. */
8141 if (!NILP (help_echo
)
8142 || !NILP (previous_help_echo
))
8148 XSETFRAME (frame
, f
);
8152 any_help_event_p
= 1;
8153 n
= gen_help_event (bufp
, numchars
, help_echo
, frame
,
8154 help_echo_window
, help_echo_object
,
8156 bufp
+= n
, count
+= n
, numchars
-= n
;
8160 case WM_LBUTTONDOWN
:
8162 case WM_MBUTTONDOWN
:
8164 case WM_RBUTTONDOWN
:
8167 /* If we decide we want to generate an event to be seen
8168 by the rest of Emacs, we put it here. */
8169 struct input_event emacs_event
;
8174 emacs_event
.kind
= no_event
;
8176 if (dpyinfo
->grabbed
&& last_mouse_frame
8177 && FRAME_LIVE_P (last_mouse_frame
))
8178 f
= last_mouse_frame
;
8180 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8184 construct_mouse_click (&emacs_event
, &msg
, f
);
8186 /* Is this in the tool-bar? */
8187 if (WINDOWP (f
->tool_bar_window
)
8188 && XFASTINT (XWINDOW (f
->tool_bar_window
)->height
))
8194 window
= window_from_coordinates (f
,
8198 if (EQ (window
, f
->tool_bar_window
))
8200 w32_handle_tool_bar_click (f
, &emacs_event
);
8206 if (!dpyinfo
->w32_focus_frame
8207 || f
== dpyinfo
->w32_focus_frame
8210 construct_mouse_click (bufp
, &msg
, f
);
8217 parse_button (msg
.msg
.message
, &button
, &up
);
8221 dpyinfo
->grabbed
&= ~ (1 << button
);
8225 dpyinfo
->grabbed
|= (1 << button
);
8226 last_mouse_frame
= f
;
8227 /* Ignore any mouse motion that happened
8228 before this event; any subsequent mouse-movement
8229 Emacs events should reflect only motion after
8235 last_tool_bar_item
= -1;
8241 if (dpyinfo
->grabbed
&& last_mouse_frame
8242 && FRAME_LIVE_P (last_mouse_frame
))
8243 f
= last_mouse_frame
;
8245 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8249 if ((!dpyinfo
->w32_focus_frame
8250 || f
== dpyinfo
->w32_focus_frame
)
8253 construct_mouse_wheel (bufp
, &msg
, f
);
8263 HMENU menu
= (HMENU
) msg
.msg
.lParam
;
8264 UINT menu_item
= (UINT
) LOWORD (msg
.msg
.wParam
);
8265 UINT flags
= (UINT
) HIWORD (msg
.msg
.wParam
);
8267 w32_menu_display_help (menu
, menu_item
, flags
);
8272 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8276 construct_drag_n_drop (bufp
, &msg
, f
);
8285 struct scroll_bar
*bar
=
8286 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
8288 if (bar
&& numchars
>= 1)
8290 if (x_scroll_bar_handle_click (bar
, &msg
, bufp
))
8300 case WM_WINDOWPOSCHANGED
:
8302 case WM_ACTIVATEAPP
:
8303 check_visibility
= 1;
8307 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8309 if (f
&& !f
->async_iconified
)
8313 x_real_positions (f
, &x
, &y
);
8314 f
->output_data
.w32
->left_pos
= x
;
8315 f
->output_data
.w32
->top_pos
= y
;
8318 check_visibility
= 1;
8322 /* If window has been obscured or exposed by another window
8323 being maximised or minimised/restored, then recheck
8324 visibility of all frames. Direct changes to our own
8325 windows get handled by WM_SIZE. */
8327 if (msg
.msg
.lParam
!= 0)
8328 check_visibility
= 1;
8331 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8332 f
->async_visible
= msg
.msg
.wParam
;
8336 check_visibility
= 1;
8340 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8342 /* Inform lisp of whether frame has been iconified etc. */
8345 switch (msg
.msg
.wParam
)
8347 case SIZE_MINIMIZED
:
8348 f
->async_visible
= 0;
8349 f
->async_iconified
= 1;
8351 bufp
->kind
= iconify_event
;
8352 XSETFRAME (bufp
->frame_or_window
, f
);
8359 case SIZE_MAXIMIZED
:
8361 f
->async_visible
= 1;
8362 f
->async_iconified
= 0;
8364 /* wait_reading_process_input will notice this and update
8365 the frame's display structures. */
8366 SET_FRAME_GARBAGED (f
);
8372 /* Reset top and left positions of the Window
8373 here since Windows sends a WM_MOVE message
8374 BEFORE telling us the Window is minimized
8375 when the Window is iconified, with 3000,3000
8377 x_real_positions (f
, &x
, &y
);
8378 f
->output_data
.w32
->left_pos
= x
;
8379 f
->output_data
.w32
->top_pos
= y
;
8381 bufp
->kind
= deiconify_event
;
8382 XSETFRAME (bufp
->frame_or_window
, f
);
8388 else if (! NILP (Vframe_list
)
8389 && ! NILP (XCDR (Vframe_list
)))
8390 /* Force a redisplay sooner or later
8391 to update the frame titles
8392 in case this is the second frame. */
8393 record_asynch_buffer_change ();
8398 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
8406 GetClientRect (msg
.msg
.hwnd
, &rect
);
8408 height
= rect
.bottom
- rect
.top
;
8409 width
= rect
.right
- rect
.left
;
8411 rows
= PIXEL_TO_CHAR_HEIGHT (f
, height
);
8412 columns
= PIXEL_TO_CHAR_WIDTH (f
, width
);
8414 /* TODO: Clip size to the screen dimensions. */
8416 /* Even if the number of character rows and columns has
8417 not changed, the font size may have changed, so we need
8418 to check the pixel dimensions as well. */
8420 if (columns
!= f
->width
8421 || rows
!= f
->height
8422 || width
!= f
->output_data
.w32
->pixel_width
8423 || height
!= f
->output_data
.w32
->pixel_height
)
8425 change_frame_size (f
, rows
, columns
, 0, 1, 0);
8426 SET_FRAME_GARBAGED (f
);
8427 cancel_mouse_face (f
);
8428 f
->output_data
.w32
->pixel_width
= width
;
8429 f
->output_data
.w32
->pixel_height
= height
;
8430 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
8434 check_visibility
= 1;
8438 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8440 dpyinfo
->w32_focus_event_frame
= f
;
8443 x_new_focus_frame (dpyinfo
, f
);
8446 dpyinfo
->grabbed
= 0;
8447 check_visibility
= 1;
8451 /* TODO: some of this belongs in MOUSE_LEAVE */
8452 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8458 if (f
== dpyinfo
->w32_focus_event_frame
)
8459 dpyinfo
->w32_focus_event_frame
= 0;
8461 if (f
== dpyinfo
->w32_focus_frame
)
8462 x_new_focus_frame (dpyinfo
, 0);
8464 if (f
== dpyinfo
->mouse_face_mouse_frame
)
8466 /* If we move outside the frame, then we're
8467 certainly no longer on any text in the frame. */
8468 clear_mouse_face (dpyinfo
);
8469 dpyinfo
->mouse_face_mouse_frame
= 0;
8472 /* Generate a nil HELP_EVENT to cancel a help-echo.
8473 Do it only if there's something to cancel.
8474 Otherwise, the startup message is cleared when
8475 the mouse leaves the frame. */
8476 if (any_help_event_p
)
8480 XSETFRAME (frame
, f
);
8481 n
= gen_help_event (bufp
, numchars
, Qnil
, frame
,
8483 bufp
+= n
, count
+= n
, numchars
-=n
;
8487 dpyinfo
->grabbed
= 0;
8488 check_visibility
= 1;
8492 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8499 bufp
->kind
= delete_window_event
;
8500 XSETFRAME (bufp
->frame_or_window
, f
);
8509 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8516 bufp
->kind
= menu_bar_activate_event
;
8517 XSETFRAME (bufp
->frame_or_window
, f
);
8526 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8530 extern void menubar_selection_callback
8531 (FRAME_PTR f
, void * client_data
);
8532 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
8535 check_visibility
= 1;
8538 case WM_DISPLAYCHANGE
:
8539 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8543 dpyinfo
->width
= (short) LOWORD (msg
.msg
.lParam
);
8544 dpyinfo
->height
= (short) HIWORD (msg
.msg
.lParam
);
8545 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
8546 DebPrint (("display change: %d %d\n", dpyinfo
->width
,
8550 check_visibility
= 1;
8554 /* Check for messages registered at runtime. */
8555 if (msg
.msg
.message
== msh_mousewheel
)
8557 if (dpyinfo
->grabbed
&& last_mouse_frame
8558 && FRAME_LIVE_P (last_mouse_frame
))
8559 f
= last_mouse_frame
;
8561 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
8565 if ((!dpyinfo
->w32_focus_frame
8566 || f
== dpyinfo
->w32_focus_frame
)
8569 construct_mouse_wheel (bufp
, &msg
, f
);
8580 /* If the focus was just given to an autoraising frame,
8582 /* ??? This ought to be able to handle more than one such frame. */
8583 if (pending_autoraise_frame
)
8585 x_raise_frame (pending_autoraise_frame
);
8586 pending_autoraise_frame
= 0;
8589 /* Check which frames are still visisble, if we have enqueued any user
8590 events or been notified of events that may affect visibility. We
8591 do this here because there doesn't seem to be any direct
8592 notification from Windows that the visibility of a window has
8593 changed (at least, not in all cases). */
8594 if (count
> 0 || check_visibility
)
8596 Lisp_Object tail
, frame
;
8598 FOR_EACH_FRAME (tail
, frame
)
8600 FRAME_PTR f
= XFRAME (frame
);
8601 /* Check "visible" frames and mark each as obscured or not.
8602 Note that async_visible is nonzero for unobscured and
8603 obscured frames, but zero for hidden and iconified frames. */
8604 if (FRAME_W32_P (f
) && f
->async_visible
)
8607 HDC hdc
= get_frame_dc (f
);
8608 GetClipBox (hdc
, &clipbox
);
8609 release_frame_dc (f
, hdc
);
8611 if (clipbox
.right
== clipbox
.left
8612 || clipbox
.bottom
== clipbox
.top
)
8614 /* Frame has become completely obscured so mark as
8615 such (we do this by setting async_visible to 2 so
8616 that FRAME_VISIBLE_P is still true, but redisplay
8618 f
->async_visible
= 2;
8620 if (!FRAME_OBSCURED_P (f
))
8622 DebPrint (("frame %04x (%s) obscured\n", f
,
8623 XSTRING (f
->name
)->data
));
8628 /* Frame is not obscured, so mark it as such. */
8629 f
->async_visible
= 1;
8631 if (FRAME_OBSCURED_P (f
))
8633 SET_FRAME_GARBAGED (f
);
8634 DebPrint (("frame %04x (%s) reexposed\n", f
,
8635 XSTRING (f
->name
)->data
));
8637 /* Force a redisplay sooner or later. */
8638 record_asynch_buffer_change ();
8652 /***********************************************************************
8654 ***********************************************************************/
8656 /* Note if the text cursor of window W has been overwritten by a
8657 drawing operation that outputs N glyphs starting at HPOS in the
8658 line given by output_cursor.vpos. N < 0 means all the rest of the
8659 line after HPOS has been written. */
8662 note_overwritten_text_cursor (w
, hpos
, n
)
8666 if (updated_area
== TEXT_AREA
8667 && output_cursor
.vpos
== w
->phys_cursor
.vpos
8668 && hpos
<= w
->phys_cursor
.hpos
8670 || hpos
+ n
> w
->phys_cursor
.hpos
))
8671 w
->phys_cursor_on_p
= 0;
8675 /* Set clipping for output in glyph row ROW. W is the window in which
8676 we operate. GC is the graphics context to set clipping in.
8677 WHOLE_LINE_P non-zero means include the areas used for truncation
8678 mark display and alike in the clipping rectangle.
8680 ROW may be a text row or, e.g., a mode line. Text rows must be
8681 clipped to the interior of the window dedicated to text display,
8682 mode lines must be clipped to the whole window. */
8685 w32_clip_to_row (w
, row
, hdc
, whole_line_p
)
8687 struct glyph_row
*row
;
8691 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8693 int window_x
, window_y
, window_width
, window_height
;
8695 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
8697 clip_rect
.left
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
8698 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
8699 clip_rect
.top
= max (clip_rect
.top
, window_y
);
8700 clip_rect
.right
= clip_rect
.left
+ window_width
;
8701 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
8703 /* If clipping to the whole line, including trunc marks, extend
8704 the rectangle to the left and increase its width. */
8707 clip_rect
.left
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
8708 clip_rect
.right
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
8711 w32_set_clip_rectangle (hdc
, &clip_rect
);
8715 /* Draw a hollow box cursor on window W in glyph row ROW. */
8718 x_draw_hollow_cursor (w
, row
)
8720 struct glyph_row
*row
;
8722 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8723 HDC hdc
= get_frame_dc (f
);
8726 struct glyph
*cursor_glyph
;
8727 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
8729 /* Compute frame-relative coordinates from window-relative
8731 rect
.left
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8732 rect
.top
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
8733 + row
->ascent
- w
->phys_cursor_ascent
);
8734 rect
.bottom
= rect
.top
+ row
->height
- 1;
8736 /* Get the glyph the cursor is on. If we can't tell because
8737 the current matrix is invalid or such, give up. */
8738 cursor_glyph
= get_phys_cursor_glyph (w
);
8739 if (cursor_glyph
== NULL
)
8742 /* Compute the width of the rectangle to draw. If on a stretch
8743 glyph, and `x-stretch-block-cursor' is nil, don't draw a
8744 rectangle as wide as the glyph, but use a canonical character
8746 wd
= cursor_glyph
->pixel_width
- 1;
8747 if (cursor_glyph
->type
== STRETCH_GLYPH
8748 && !x_stretch_cursor_p
)
8749 wd
= min (CANON_X_UNIT (f
), wd
);
8751 rect
.right
= rect
.left
+ wd
;
8753 FrameRect (hdc
, &rect
, hb
);
8756 release_frame_dc (f
, hdc
);
8760 /* Draw a bar cursor on window W in glyph row ROW.
8762 Implementation note: One would like to draw a bar cursor with an
8763 angle equal to the one given by the font property XA_ITALIC_ANGLE.
8764 Unfortunately, I didn't find a font yet that has this property set.
8768 x_draw_bar_cursor (w
, row
, width
)
8770 struct glyph_row
*row
;
8773 /* If cursor hpos is out of bounds, don't draw garbage. This can
8774 happen in mini-buffer windows when switching between echo area
8775 glyphs and mini-buffer. */
8776 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
8778 struct frame
*f
= XFRAME (w
->frame
);
8779 struct glyph
*cursor_glyph
;
8783 cursor_glyph
= get_phys_cursor_glyph (w
);
8784 if (cursor_glyph
== NULL
)
8787 /* If on an image, draw like a normal cursor. That's usually better
8788 visible than drawing a bar, esp. if the image is large so that
8789 the bar might not be in the window. */
8790 if (cursor_glyph
->type
== IMAGE_GLYPH
)
8792 struct glyph_row
*row
;
8793 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
8794 x_draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
8799 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8802 width
= f
->output_data
.w32
->cursor_width
;
8804 hdc
= get_frame_dc (f
);
8805 w32_fill_area (f
, hdc
, f
->output_data
.w32
->cursor_pixel
,
8807 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
8808 min (cursor_glyph
->pixel_width
, width
),
8810 release_frame_dc (f
, hdc
);
8816 /* Clear the cursor of window W to background color, and mark the
8817 cursor as not shown. This is used when the text where the cursor
8818 is is about to be rewritten. */
8824 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
8825 x_update_window_cursor (w
, 0);
8829 /* Draw the cursor glyph of window W in glyph row ROW. See the
8830 comment of x_draw_glyphs for the meaning of HL. */
8833 x_draw_phys_cursor_glyph (w
, row
, hl
)
8835 struct glyph_row
*row
;
8836 enum draw_glyphs_face hl
;
8838 /* If cursor hpos is out of bounds, don't draw garbage. This can
8839 happen in mini-buffer windows when switching between echo area
8840 glyphs and mini-buffer. */
8841 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
8843 x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
8844 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
8847 /* When we erase the cursor, and ROW is overlapped by other
8848 rows, make sure that these overlapping parts of other rows
8850 if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
8852 if (row
> w
->current_matrix
->rows
8853 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
8854 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
8856 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
8857 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
8858 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
8864 /* Erase the image of a cursor of window W from the screen. */
8867 x_erase_phys_cursor (w
)
8870 struct frame
*f
= XFRAME (w
->frame
);
8871 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
8872 int hpos
= w
->phys_cursor
.hpos
;
8873 int vpos
= w
->phys_cursor
.vpos
;
8874 int mouse_face_here_p
= 0;
8875 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
8876 struct glyph_row
*cursor_row
;
8877 struct glyph
*cursor_glyph
;
8878 enum draw_glyphs_face hl
;
8880 /* No cursor displayed or row invalidated => nothing to do on the
8882 if (w
->phys_cursor_type
== NO_CURSOR
)
8883 goto mark_cursor_off
;
8885 /* VPOS >= active_glyphs->nrows means that window has been resized.
8886 Don't bother to erase the cursor. */
8887 if (vpos
>= active_glyphs
->nrows
)
8888 goto mark_cursor_off
;
8890 /* If row containing cursor is marked invalid, there is nothing we
8892 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
8893 if (!cursor_row
->enabled_p
)
8894 goto mark_cursor_off
;
8896 /* This can happen when the new row is shorter than the old one.
8897 In this case, either x_draw_glyphs or clear_end_of_line
8898 should have cleared the cursor. Note that we wouldn't be
8899 able to erase the cursor in this case because we don't have a
8900 cursor glyph at hand. */
8901 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
8902 goto mark_cursor_off
;
8904 /* If the cursor is in the mouse face area, redisplay that when
8905 we clear the cursor. */
8906 if (w
== XWINDOW (dpyinfo
->mouse_face_window
)
8907 && (vpos
> dpyinfo
->mouse_face_beg_row
8908 || (vpos
== dpyinfo
->mouse_face_beg_row
8909 && hpos
>= dpyinfo
->mouse_face_beg_col
))
8910 && (vpos
< dpyinfo
->mouse_face_end_row
8911 || (vpos
== dpyinfo
->mouse_face_end_row
8912 && hpos
< dpyinfo
->mouse_face_end_col
))
8913 /* Don't redraw the cursor's spot in mouse face if it is at the
8914 end of a line (on a newline). The cursor appears there, but
8915 mouse highlighting does not. */
8916 && cursor_row
->used
[TEXT_AREA
] > hpos
)
8917 mouse_face_here_p
= 1;
8919 /* Maybe clear the display under the cursor. */
8920 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
8923 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
8926 cursor_glyph
= get_phys_cursor_glyph (w
);
8927 if (cursor_glyph
== NULL
)
8928 goto mark_cursor_off
;
8930 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8932 hdc
= get_frame_dc (f
);
8933 w32_clear_area (f
, hdc
, x
,
8934 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
8936 cursor_glyph
->pixel_width
,
8937 cursor_row
->visible_height
);
8938 release_frame_dc (f
, hdc
);
8941 /* Erase the cursor by redrawing the character underneath it. */
8942 if (mouse_face_here_p
)
8943 hl
= DRAW_MOUSE_FACE
;
8944 else if (cursor_row
->inverse_p
)
8945 hl
= DRAW_INVERSE_VIDEO
;
8947 hl
= DRAW_NORMAL_TEXT
;
8948 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
8951 w
->phys_cursor_on_p
= 0;
8952 w
->phys_cursor_type
= NO_CURSOR
;
8956 /* Display or clear cursor of window W. If ON is zero, clear the
8957 cursor. If it is non-zero, display the cursor. If ON is nonzero,
8958 where to put the cursor is specified by HPOS, VPOS, X and Y. */
8961 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
8963 int on
, hpos
, vpos
, x
, y
;
8965 struct frame
*f
= XFRAME (w
->frame
);
8966 int new_cursor_type
;
8967 int new_cursor_width
;
8968 struct glyph_matrix
*current_glyphs
;
8969 struct glyph_row
*glyph_row
;
8970 struct glyph
*glyph
;
8972 /* This is pointless on invisible frames, and dangerous on garbaged
8973 windows and frames; in the latter case, the frame or window may
8974 be in the midst of changing its size, and x and y may be off the
8976 if (! FRAME_VISIBLE_P (f
)
8977 || FRAME_GARBAGED_P (f
)
8978 || vpos
>= w
->current_matrix
->nrows
8979 || hpos
>= w
->current_matrix
->matrix_w
)
8982 /* If cursor is off and we want it off, return quickly. */
8983 if (!on
&& !w
->phys_cursor_on_p
)
8986 current_glyphs
= w
->current_matrix
;
8987 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
8988 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
8990 /* If cursor row is not enabled, we don't really know where to
8991 display the cursor. */
8992 if (!glyph_row
->enabled_p
)
8994 w
->phys_cursor_on_p
= 0;
8998 xassert (interrupt_input_blocked
);
9000 /* Set new_cursor_type to the cursor we want to be displayed. In a
9001 mini-buffer window, we want the cursor only to appear if we are
9002 reading input from this window. For the selected window, we want
9003 the cursor type given by the frame parameter. If explicitly
9004 marked off, draw no cursor. In all other cases, we want a hollow
9006 new_cursor_width
= -1;
9007 if (cursor_in_echo_area
9008 && FRAME_HAS_MINIBUF_P (f
)
9009 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
9011 if (w
== XWINDOW (echo_area_window
))
9012 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
9014 new_cursor_type
= HOLLOW_BOX_CURSOR
;
9018 if (w
!= XWINDOW (selected_window
)
9019 || f
!= FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
)
9021 extern int cursor_in_non_selected_windows
;
9023 if (MINI_WINDOW_P (w
)
9024 || !cursor_in_non_selected_windows
9025 || NILP (XBUFFER (w
->buffer
)->cursor_type
))
9026 new_cursor_type
= NO_CURSOR
;
9028 new_cursor_type
= HOLLOW_BOX_CURSOR
;
9030 else if (w
->cursor_off_p
)
9031 new_cursor_type
= NO_CURSOR
;
9034 struct buffer
*b
= XBUFFER (w
->buffer
);
9036 if (EQ (b
->cursor_type
, Qt
))
9037 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
9039 new_cursor_type
= x_specified_cursor_type (b
->cursor_type
,
9044 /* If cursor is currently being shown and we don't want it to be or
9045 it is in the wrong place, or the cursor type is not what we want,
9047 if (w
->phys_cursor_on_p
9049 || w
->phys_cursor
.x
!= x
9050 || w
->phys_cursor
.y
!= y
9051 || new_cursor_type
!= w
->phys_cursor_type
))
9052 x_erase_phys_cursor (w
);
9054 /* If the cursor is now invisible and we want it to be visible,
9056 if (on
&& !w
->phys_cursor_on_p
)
9058 w
->phys_cursor_ascent
= glyph_row
->ascent
;
9059 w
->phys_cursor_height
= glyph_row
->height
;
9061 /* Set phys_cursor_.* before x_draw_.* is called because some
9062 of them may need the information. */
9063 w
->phys_cursor
.x
= x
;
9064 w
->phys_cursor
.y
= glyph_row
->y
;
9065 w
->phys_cursor
.hpos
= hpos
;
9066 w
->phys_cursor
.vpos
= vpos
;
9067 w
->phys_cursor_type
= new_cursor_type
;
9068 w
->phys_cursor_on_p
= 1;
9070 switch (new_cursor_type
)
9072 case HOLLOW_BOX_CURSOR
:
9073 x_draw_hollow_cursor (w
, glyph_row
);
9076 case FILLED_BOX_CURSOR
:
9077 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
9081 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
);
9094 /* Display the cursor on window W, or clear it. X and Y are window
9095 relative pixel coordinates. HPOS and VPOS are glyph matrix
9096 positions. If W is not the selected window, display a hollow
9097 cursor. ON non-zero means display the cursor at X, Y which
9098 correspond to HPOS, VPOS, otherwise it is cleared. */
9101 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
9103 int on
, hpos
, vpos
, x
, y
;
9106 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
9111 /* Display the cursor on window W, or clear it, according to ON_P.
9112 Don't change the cursor's position. */
9115 x_update_cursor (f
, on_p
)
9119 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
9123 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
9124 in the window tree rooted at W. */
9127 x_update_cursor_in_window_tree (w
, on_p
)
9133 if (!NILP (w
->hchild
))
9134 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
9135 else if (!NILP (w
->vchild
))
9136 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
9138 x_update_window_cursor (w
, on_p
);
9140 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
9145 /* Switch the display of W's cursor on or off, according to the value
9149 x_update_window_cursor (w
, on
)
9153 /* Don't update cursor in windows whose frame is in the process
9154 of being deleted. */
9155 if (w
->current_matrix
)
9158 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
,
9159 w
->phys_cursor
.vpos
, w
->phys_cursor
.x
,
9171 x_bitmap_icon (f
, icon
)
9175 int mask
, bitmap_id
;
9179 if (FRAME_W32_WINDOW (f
) == 0)
9183 hicon
= LoadIcon (hinst
, EMACS_CLASS
);
9184 else if (STRINGP (icon
))
9185 hicon
= LoadImage (NULL
, (LPCTSTR
) XSTRING (icon
)->data
, IMAGE_ICON
, 0, 0,
9186 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
9187 else if (SYMBOLP (icon
))
9191 if (EQ (icon
, intern ("application")))
9192 name
= (LPCTSTR
) IDI_APPLICATION
;
9193 else if (EQ (icon
, intern ("hand")))
9194 name
= (LPCTSTR
) IDI_HAND
;
9195 else if (EQ (icon
, intern ("question")))
9196 name
= (LPCTSTR
) IDI_QUESTION
;
9197 else if (EQ (icon
, intern ("exclamation")))
9198 name
= (LPCTSTR
) IDI_EXCLAMATION
;
9199 else if (EQ (icon
, intern ("asterisk")))
9200 name
= (LPCTSTR
) IDI_ASTERISK
;
9201 else if (EQ (icon
, intern ("winlogo")))
9202 name
= (LPCTSTR
) IDI_WINLOGO
;
9206 hicon
= LoadIcon (NULL
, name
);
9214 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
9221 /* Changing the font of the frame. */
9223 /* Give frame F the font named FONTNAME as its default font, and
9224 return the full name of that font. FONTNAME may be a wildcard
9225 pattern; in that case, we choose some font that fits the pattern.
9226 The return value shows which font we chose. */
9229 x_new_font (f
, fontname
)
9231 register char *fontname
;
9233 struct font_info
*fontp
9234 = FS_LOAD_FONT (f
, 0, fontname
, -1);
9239 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
9240 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
9241 FRAME_FONTSET (f
) = -1;
9243 /* Compute the scroll bar width in character columns. */
9244 if (f
->scroll_bar_pixel_width
> 0)
9246 int wid
= FONT_WIDTH (FRAME_FONT (f
));
9247 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
9251 int wid
= FONT_WIDTH (FRAME_FONT (f
));
9252 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
9255 /* Now make the frame display the given font. */
9256 if (FRAME_W32_WINDOW (f
) != 0)
9258 frame_update_line_height (f
);
9259 x_set_window_size (f
, 0, f
->width
, f
->height
);
9262 /* If we are setting a new frame's font for the first time,
9263 there are no faces yet, so this font's height is the line height. */
9264 f
->output_data
.w32
->line_height
= FONT_HEIGHT (FRAME_FONT (f
));
9266 return build_string (fontp
->full_name
);
9269 /* Give frame F the fontset named FONTSETNAME as its default font, and
9270 return the full name of that fontset. FONTSETNAME may be a wildcard
9271 pattern; in that case, we choose some fontset that fits the pattern.
9272 The return value shows which fontset we chose. */
9275 x_new_fontset (f
, fontsetname
)
9279 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
9286 if (FRAME_FONTSET (f
) == fontset
)
9287 /* This fontset is already set in frame F. There's nothing more
9289 return fontset_name (fontset
);
9291 result
= x_new_font (f
, (XSTRING (fontset_ascii (fontset
))->data
));
9293 if (!STRINGP (result
))
9294 /* Can't load ASCII font. */
9297 /* Since x_new_font doesn't update any fontset information, do it now. */
9298 FRAME_FONTSET(f
) = fontset
;
9300 return build_string (fontsetname
);
9306 /* Check that FONT is valid on frame F. It is if it can be found in F's
9310 x_check_font (f
, font
)
9315 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
9317 xassert (font
!= NULL
);
9319 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9320 if (dpyinfo
->font_table
[i
].name
9321 && font
== dpyinfo
->font_table
[i
].font
)
9324 xassert (i
< dpyinfo
->n_fonts
);
9327 #endif /* GLYPH_DEBUG != 0 */
9329 /* Set *W to the minimum width, *H to the minimum font height of FONT.
9330 Note: There are (broken) X fonts out there with invalid XFontStruct
9331 min_bounds contents. For example, handa@etl.go.jp reports that
9332 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
9333 have font->min_bounds.width == 0. */
9336 x_font_min_bounds (font
, w
, h
)
9341 * TODO: Windows does not appear to offer min bound, only
9342 * average and maximum width, and maximum height.
9344 *h
= FONT_HEIGHT (font
);
9345 *w
= FONT_WIDTH (font
);
9349 /* Compute the smallest character width and smallest font height over
9350 all fonts available on frame F. Set the members smallest_char_width
9351 and smallest_font_height in F's x_display_info structure to
9352 the values computed. Value is non-zero if smallest_font_height or
9353 smallest_char_width become smaller than they were before. */
9356 x_compute_min_glyph_bounds (f
)
9360 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
9362 int old_width
= dpyinfo
->smallest_char_width
;
9363 int old_height
= dpyinfo
->smallest_font_height
;
9365 dpyinfo
->smallest_font_height
= 100000;
9366 dpyinfo
->smallest_char_width
= 100000;
9368 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
9369 if (dpyinfo
->font_table
[i
].name
)
9371 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
9374 font
= (XFontStruct
*) fontp
->font
;
9375 xassert (font
!= (XFontStruct
*) ~0);
9376 x_font_min_bounds (font
, &w
, &h
);
9378 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
9379 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
9382 xassert (dpyinfo
->smallest_char_width
> 0
9383 && dpyinfo
->smallest_font_height
> 0);
9385 return (dpyinfo
->n_fonts
== 1
9386 || dpyinfo
->smallest_char_width
< old_width
9387 || dpyinfo
->smallest_font_height
< old_height
);
9391 /* Calculate the absolute position in frame F
9392 from its current recorded position values and gravity. */
9395 x_calc_absolute_position (f
)
9400 int flags
= f
->output_data
.w32
->size_hint_flags
;
9404 /* Find the position of the outside upper-left corner of
9405 the inner window, with respect to the outer window. */
9406 if (f
->output_data
.w32
->parent_desc
!= FRAME_W32_DISPLAY_INFO (f
)->root_window
)
9409 MapWindowPoints (FRAME_W32_WINDOW (f
),
9410 f
->output_data
.w32
->parent_desc
,
9417 rt
.left
= rt
.right
= rt
.top
= rt
.bottom
= 0;
9420 AdjustWindowRect(&rt
, f
->output_data
.w32
->dwStyle
,
9421 FRAME_EXTERNAL_MENU_BAR (f
));
9424 pt
.x
+= (rt
.right
- rt
.left
);
9425 pt
.y
+= (rt
.bottom
- rt
.top
);
9428 /* Treat negative positions as relative to the leftmost bottommost
9429 position that fits on the screen. */
9430 if (flags
& XNegative
)
9431 f
->output_data
.w32
->left_pos
= (FRAME_W32_DISPLAY_INFO (f
)->width
9432 - 2 * f
->output_data
.w32
->border_width
- pt
.x
9434 + f
->output_data
.w32
->left_pos
);
9436 if (flags
& YNegative
)
9437 f
->output_data
.w32
->top_pos
= (FRAME_W32_DISPLAY_INFO (f
)->height
9438 - 2 * f
->output_data
.w32
->border_width
- pt
.y
9440 + f
->output_data
.w32
->top_pos
);
9441 /* The left_pos and top_pos
9442 are now relative to the top and left screen edges,
9443 so the flags should correspond. */
9444 f
->output_data
.w32
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9447 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
9448 to really change the position, and 0 when calling from
9449 x_make_frame_visible (in that case, XOFF and YOFF are the current
9450 position values). It is -1 when calling from x_set_frame_parameters,
9451 which means, do adjust for borders but don't change the gravity. */
9454 x_set_offset (f
, xoff
, yoff
, change_gravity
)
9456 register int xoff
, yoff
;
9459 int modified_top
, modified_left
;
9461 if (change_gravity
> 0)
9463 f
->output_data
.w32
->top_pos
= yoff
;
9464 f
->output_data
.w32
->left_pos
= xoff
;
9465 f
->output_data
.w32
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9467 f
->output_data
.w32
->size_hint_flags
|= XNegative
;
9469 f
->output_data
.w32
->size_hint_flags
|= YNegative
;
9470 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
9472 x_calc_absolute_position (f
);
9475 x_wm_set_size_hint (f
, (long) 0, 0);
9477 modified_left
= f
->output_data
.w32
->left_pos
;
9478 modified_top
= f
->output_data
.w32
->top_pos
;
9480 my_set_window_pos (FRAME_W32_WINDOW (f
),
9482 modified_left
, modified_top
,
9484 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
9488 /* Call this to change the size of frame F's x-window.
9489 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
9490 for this size change and subsequent size changes.
9491 Otherwise we leave the window gravity unchanged. */
9493 x_set_window_size (f
, change_gravity
, cols
, rows
)
9498 int pixelwidth
, pixelheight
;
9502 check_frame_size (f
, &rows
, &cols
);
9503 f
->output_data
.w32
->vertical_scroll_bar_extra
9504 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
9506 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.w32
->font
)));
9507 f
->output_data
.w32
->flags_areas_extra
9508 = FRAME_FLAGS_AREA_WIDTH (f
);
9509 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
9510 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
9512 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
9513 x_wm_set_size_hint (f
, (long) 0, 0);
9518 rect
.left
= rect
.top
= 0;
9519 rect
.right
= pixelwidth
;
9520 rect
.bottom
= pixelheight
;
9522 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
9523 FRAME_EXTERNAL_MENU_BAR (f
));
9525 my_set_window_pos (FRAME_W32_WINDOW (f
),
9528 rect
.right
- rect
.left
,
9529 rect
.bottom
- rect
.top
,
9530 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
9533 /* Now, strictly speaking, we can't be sure that this is accurate,
9534 but the window manager will get around to dealing with the size
9535 change request eventually, and we'll hear how it went when the
9536 ConfigureNotify event gets here.
9538 We could just not bother storing any of this information here,
9539 and let the ConfigureNotify event set everything up, but that
9540 might be kind of confusing to the Lisp code, since size changes
9541 wouldn't be reported in the frame parameters until some random
9542 point in the future when the ConfigureNotify event arrives.
9544 We pass 1 for DELAY since we can't run Lisp code inside of
9546 change_frame_size (f
, rows
, cols
, 0, 1, 0);
9547 PIXEL_WIDTH (f
) = pixelwidth
;
9548 PIXEL_HEIGHT (f
) = pixelheight
;
9550 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
9551 receive in the ConfigureNotify event; if we get what we asked
9552 for, then the event won't cause the screen to become garbaged, so
9553 we have to make sure to do it here. */
9554 SET_FRAME_GARBAGED (f
);
9556 /* If cursor was outside the new size, mark it as off. */
9557 mark_window_cursors_off (XWINDOW (f
->root_window
));
9559 /* Clear out any recollection of where the mouse highlighting was,
9560 since it might be in a place that's outside the new frame size.
9561 Actually checking whether it is outside is a pain in the neck,
9562 so don't try--just let the highlighting be done afresh with new size. */
9563 cancel_mouse_face (f
);
9568 /* Mouse warping. */
9570 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
9573 x_set_mouse_position (f
, x
, y
)
9579 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.w32
->font
) / 2;
9580 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.w32
->line_height
/ 2;
9582 if (pix_x
< 0) pix_x
= 0;
9583 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
9585 if (pix_y
< 0) pix_y
= 0;
9586 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
9588 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
9592 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
9601 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
9602 pt
.x
= rect
.left
+ pix_x
;
9603 pt
.y
= rect
.top
+ pix_y
;
9604 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
9606 SetCursorPos (pt
.x
, pt
.y
);
9612 /* focus shifting, raising and lowering. */
9615 x_focus_on_frame (f
)
9618 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
9620 /* Give input focus to frame. */
9623 /* Try not to change its Z-order if possible. */
9624 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
9625 my_set_focus (f
, FRAME_W32_WINDOW (f
));
9628 my_set_foreground_window (FRAME_W32_WINDOW (f
));
9638 /* Raise frame F. */
9645 /* Strictly speaking, raise-frame should only change the frame's Z
9646 order, leaving input focus unchanged. This is reasonable behaviour
9647 on X where the usual policy is point-to-focus. However, this
9648 behaviour would be very odd on Windows where the usual policy is
9651 On X, if the mouse happens to be over the raised frame, it gets
9652 input focus anyway (so the window with focus will never be
9653 completely obscured) - if not, then just moving the mouse over it
9654 is sufficient to give it focus. On Windows, the user must actually
9655 click on the frame (preferrably the title bar so as not to move
9656 point), which is more awkward. Also, no other Windows program
9657 raises a window to the top but leaves another window (possibly now
9658 completely obscured) with input focus.
9660 Because there is a system setting on Windows that allows the user
9661 to choose the point to focus policy, we make the strict semantics
9662 optional, but by default we grab focus when raising. */
9664 if (NILP (Vw32_grab_focus_on_raise
))
9666 /* The obvious call to my_set_window_pos doesn't work if Emacs is
9667 not already the foreground application: the frame is raised
9668 above all other frames belonging to us, but not above the
9669 current top window. To achieve that, we have to resort to this
9670 more cumbersome method. */
9672 HDWP handle
= BeginDeferWindowPos (2);
9675 DeferWindowPos (handle
,
9676 FRAME_W32_WINDOW (f
),
9679 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
9681 DeferWindowPos (handle
,
9682 GetForegroundWindow (),
9683 FRAME_W32_WINDOW (f
),
9685 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
9687 EndDeferWindowPos (handle
);
9692 my_set_foreground_window (FRAME_W32_WINDOW (f
));
9698 /* Lower frame F. */
9704 my_set_window_pos (FRAME_W32_WINDOW (f
),
9707 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
9712 w32_frame_raise_lower (f
, raise_flag
)
9722 /* Change of visibility. */
9724 /* This tries to wait until the frame is really visible.
9725 However, if the window manager asks the user where to position
9726 the frame, this will return before the user finishes doing that.
9727 The frame will not actually be visible at that time,
9728 but it will become visible later when the window manager
9729 finishes with it. */
9732 x_make_frame_visible (f
)
9739 type
= x_icon_type (f
);
9741 x_bitmap_icon (f
, type
);
9743 if (! FRAME_VISIBLE_P (f
))
9745 /* We test FRAME_GARBAGED_P here to make sure we don't
9746 call x_set_offset a second time
9747 if we get to x_make_frame_visible a second time
9748 before the window gets really visible. */
9749 if (! FRAME_ICONIFIED_P (f
)
9750 && ! f
->output_data
.w32
->asked_for_visible
)
9751 x_set_offset (f
, f
->output_data
.w32
->left_pos
, f
->output_data
.w32
->top_pos
, 0);
9753 f
->output_data
.w32
->asked_for_visible
= 1;
9755 // my_show_window (f, FRAME_W32_WINDOW (f), f->async_iconified ? SW_RESTORE : SW_SHOW);
9756 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_SHOWNORMAL
);
9759 /* Synchronize to ensure Emacs knows the frame is visible
9760 before we do anything else. We do this loop with input not blocked
9761 so that incoming events are handled. */
9766 /* This must come after we set COUNT. */
9769 XSETFRAME (frame
, f
);
9771 /* Wait until the frame is visible. Process X events until a
9772 MapNotify event has been seen, or until we think we won't get a
9773 MapNotify at all.. */
9774 for (count
= input_signal_count
+ 10;
9775 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9777 /* Force processing of queued events. */
9778 /* TODO: x_sync equivalent? */
9780 /* Machines that do polling rather than SIGIO have been observed
9781 to go into a busy-wait here. So we'll fake an alarm signal
9782 to let the handler know that there's something to be read.
9783 We used to raise a real alarm, but it seems that the handler
9784 isn't always enabled here. This is probably a bug. */
9785 if (input_polling_used ())
9787 /* It could be confusing if a real alarm arrives while processing
9788 the fake one. Turn it off and let the handler reset it. */
9789 int old_poll_suppress_count
= poll_suppress_count
;
9790 poll_suppress_count
= 1;
9791 poll_for_input_1 ();
9792 poll_suppress_count
= old_poll_suppress_count
;
9795 FRAME_SAMPLE_VISIBILITY (f
);
9799 /* Change from mapped state to withdrawn state. */
9801 /* Make the frame visible (mapped and not iconified). */
9803 x_make_frame_invisible (f
)
9806 /* Don't keep the highlight on an invisible frame. */
9807 if (FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
== f
)
9808 FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
= 0;
9812 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
9814 /* We can't distinguish this from iconification
9815 just by the event that we get from the server.
9816 So we can't win using the usual strategy of letting
9817 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9818 and synchronize with the server to make sure we agree. */
9820 FRAME_ICONIFIED_P (f
) = 0;
9821 f
->async_visible
= 0;
9822 f
->async_iconified
= 0;
9827 /* Change window state from mapped to iconified. */
9836 /* Don't keep the highlight on an invisible frame. */
9837 if (FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
== f
)
9838 FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
= 0;
9840 if (f
->async_iconified
)
9845 type
= x_icon_type (f
);
9847 x_bitmap_icon (f
, type
);
9849 /* Simulate the user minimizing the frame. */
9850 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
9855 /* Destroy the window of frame F. */
9857 x_destroy_window (f
)
9860 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
9864 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
9865 free_frame_menubar (f
);
9866 free_frame_faces (f
);
9868 xfree (f
->output_data
.w32
);
9869 f
->output_data
.w32
= 0;
9870 if (f
== dpyinfo
->w32_focus_frame
)
9871 dpyinfo
->w32_focus_frame
= 0;
9872 if (f
== dpyinfo
->w32_focus_event_frame
)
9873 dpyinfo
->w32_focus_event_frame
= 0;
9874 if (f
== dpyinfo
->w32_highlight_frame
)
9875 dpyinfo
->w32_highlight_frame
= 0;
9877 dpyinfo
->reference_count
--;
9879 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9881 dpyinfo
->mouse_face_beg_row
9882 = dpyinfo
->mouse_face_beg_col
= -1;
9883 dpyinfo
->mouse_face_end_row
9884 = dpyinfo
->mouse_face_end_col
= -1;
9885 dpyinfo
->mouse_face_window
= Qnil
;
9891 /* Setting window manager hints. */
9893 /* Set the normal size hints for the window manager, for frame F.
9894 FLAGS is the flags word to use--or 0 meaning preserve the flags
9895 that the window now has.
9896 If USER_POSITION is nonzero, we set the USPosition
9897 flag (this is useful when FLAGS is 0). */
9899 x_wm_set_size_hint (f
, flags
, user_position
)
9904 Window window
= FRAME_W32_WINDOW (f
);
9908 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FONT_WIDTH (f
->output_data
.w32
->font
));
9909 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, f
->output_data
.w32
->line_height
);
9910 SetWindowLong (window
, WND_BORDER_INDEX
, f
->output_data
.w32
->internal_border_width
);
9911 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->output_data
.w32
->vertical_scroll_bar_extra
);
9916 /* Window manager things */
9917 x_wm_set_icon_position (f
, icon_x
, icon_y
)
9922 Window window
= FRAME_W32_WINDOW (f
);
9924 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
9925 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
9926 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
9928 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
9934 /***********************************************************************
9936 ***********************************************************************/
9938 static int w32_initialized
= 0;
9941 w32_initialize_display_info (display_name
)
9942 Lisp_Object display_name
;
9944 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
9946 bzero (dpyinfo
, sizeof (*dpyinfo
));
9948 /* Put it on w32_display_name_list. */
9949 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
9950 w32_display_name_list
);
9951 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
9953 dpyinfo
->w32_id_name
9954 = (char *) xmalloc (XSTRING (Vinvocation_name
)->size
9955 + XSTRING (Vsystem_name
)->size
9957 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
9958 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
9960 /* Default Console mode values - overridden when running in GUI mode
9961 with values obtained from system metrics. */
9964 dpyinfo
->height_in
= 1;
9965 dpyinfo
->width_in
= 1;
9966 dpyinfo
->n_planes
= 1;
9967 dpyinfo
->n_cbits
= 4;
9968 dpyinfo
->n_fonts
= 0;
9969 dpyinfo
->smallest_font_height
= 1;
9970 dpyinfo
->smallest_char_width
= 1;
9972 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
9973 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
9974 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
9975 dpyinfo
->mouse_face_window
= Qnil
;
9977 /* TODO: dpyinfo->gray */
9981 struct w32_display_info
*
9982 w32_term_init (display_name
, xrm_option
, resource_name
)
9983 Lisp_Object display_name
;
9985 char *resource_name
;
9987 struct w32_display_info
*dpyinfo
;
9992 if (!w32_initialized
)
9995 w32_initialized
= 1;
10006 argv
[argc
++] = "-xrm";
10007 argv
[argc
++] = xrm_option
;
10011 w32_initialize_display_info (display_name
);
10013 dpyinfo
= &one_w32_display_info
;
10015 hdc
= GetDC (GetDesktopWindow ());
10017 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
10018 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
10019 dpyinfo
->root_window
= GetDesktopWindow ();
10020 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
10021 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
10022 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
10023 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
10024 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
10025 dpyinfo
->image_cache
= make_image_cache ();
10026 dpyinfo
->height_in
= dpyinfo
->height
/ dpyinfo
->resx
;
10027 dpyinfo
->width_in
= dpyinfo
->width
/ dpyinfo
->resy
;
10028 ReleaseDC (GetDesktopWindow (), hdc
);
10030 /* initialise palette with white and black */
10033 w32_defined_color (0, "white", &color
, 1);
10034 w32_defined_color (0, "black", &color
, 1);
10037 /* Create Row Bitmaps and store them for later use. */
10038 left_bmp
= CreateBitmap (left_width
, left_height
, 1, 1, left_bits
);
10039 ov_bmp
= CreateBitmap (ov_width
, ov_height
, 1, 1, ov_bits
);
10040 right_bmp
= CreateBitmap (right_width
, right_height
, 1, 1, right_bits
);
10041 continued_bmp
= CreateBitmap (continued_width
, continued_height
, 1,
10042 1, continued_bits
);
10043 continuation_bmp
= CreateBitmap (continuation_width
, continuation_height
,
10044 1, 1, continuation_bits
);
10045 zv_bmp
= CreateBitmap (zv_width
, zv_height
, 1, 1, zv_bits
);
10047 #ifndef F_SETOWN_BUG
10049 #ifdef F_SETOWN_SOCK_NEG
10050 /* stdin is a socket here */
10051 fcntl (connection
, F_SETOWN
, -getpid ());
10052 #else /* ! defined (F_SETOWN_SOCK_NEG) */
10053 fcntl (connection
, F_SETOWN
, getpid ());
10054 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
10055 #endif /* ! defined (F_SETOWN) */
10056 #endif /* F_SETOWN_BUG */
10059 if (interrupt_input
)
10060 init_sigio (connection
);
10061 #endif /* ! defined (SIGIO) */
10068 /* Get rid of display DPYINFO, assuming all frames are already gone. */
10071 x_delete_display (dpyinfo
)
10072 struct w32_display_info
*dpyinfo
;
10074 /* Discard this display from w32_display_name_list and w32_display_list.
10075 We can't use Fdelq because that can quit. */
10076 if (! NILP (w32_display_name_list
)
10077 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
10078 w32_display_name_list
= XCDR (w32_display_name_list
);
10083 tail
= w32_display_name_list
;
10084 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10086 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10088 XCDR (tail
) = XCDR (XCDR (tail
));
10091 tail
= XCDR (tail
);
10095 /* free palette table */
10097 struct w32_palette_entry
* plist
;
10099 plist
= dpyinfo
->color_list
;
10102 struct w32_palette_entry
* pentry
= plist
;
10103 plist
= plist
->next
;
10106 dpyinfo
->color_list
= NULL
;
10107 if (dpyinfo
->palette
)
10108 DeleteObject(dpyinfo
->palette
);
10110 xfree (dpyinfo
->font_table
);
10111 xfree (dpyinfo
->w32_id_name
);
10113 /* Destroy row bitmaps. */
10114 DeleteObject (left_bmp
);
10115 DeleteObject (ov_bmp
);
10116 DeleteObject (right_bmp
);
10117 DeleteObject (continued_bmp
);
10118 DeleteObject (continuation_bmp
);
10119 DeleteObject (zv_bmp
);
10122 /* Set up use of W32. */
10124 DWORD
w32_msg_worker ();
10127 x_flush (struct frame
* f
)
10128 { /* Nothing to do */ }
10130 static struct redisplay_interface w32_redisplay_interface
=
10135 x_clear_end_of_line
,
10137 x_after_update_window_line
,
10138 x_update_window_begin
,
10139 x_update_window_end
,
10142 x_clear_mouse_face
,
10143 x_get_glyph_overhangs
,
10144 x_fix_overlapping_area
10150 rif
= &w32_redisplay_interface
;
10152 /* MSVC does not type K&R functions with no arguments correctly, and
10153 so we must explicitly cast them. */
10154 clear_frame_hook
= (void (*)(void)) x_clear_frame
;
10155 ins_del_lines_hook
= x_ins_del_lines
;
10156 change_line_highlight_hook
= x_change_line_highlight
;
10157 delete_glyphs_hook
= x_delete_glyphs
;
10158 ring_bell_hook
= (void (*)(void)) w32_ring_bell
;
10159 reset_terminal_modes_hook
= (void (*)(void)) w32_reset_terminal_modes
;
10160 set_terminal_modes_hook
= (void (*)(void)) w32_set_terminal_modes
;
10161 update_begin_hook
= x_update_begin
;
10162 update_end_hook
= x_update_end
;
10163 set_terminal_window_hook
= w32_set_terminal_window
;
10164 read_socket_hook
= w32_read_socket
;
10165 frame_up_to_date_hook
= w32_frame_up_to_date
;
10166 reassert_line_highlight_hook
= w32_reassert_line_highlight
;
10167 mouse_position_hook
= w32_mouse_position
;
10168 frame_rehighlight_hook
= w32_frame_rehighlight
;
10169 frame_raise_lower_hook
= w32_frame_raise_lower
;
10170 set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
10171 condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
10172 redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
10173 judge_scroll_bars_hook
= w32_judge_scroll_bars
;
10174 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
10176 scroll_region_ok
= 1; /* we'll scroll partial frames */
10177 char_ins_del_ok
= 0; /* just as fast to write the line */
10178 line_ins_del_ok
= 1; /* we'll just blt 'em */
10179 fast_clear_end_of_line
= 1; /* X does this well */
10180 memory_below_frame
= 0; /* we don't remember what scrolls
10184 last_tool_bar_item
= -1;
10185 any_help_event_p
= 0;
10187 /* Initialize input mode: interrupt_input off, no flow control, allow
10188 8 bit character input, standard quit char. */
10189 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
10191 /* Create the window thread - it will terminate itself or when the app terminates */
10195 dwMainThreadId
= GetCurrentThreadId ();
10196 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
10197 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
10199 /* Wait for thread to start */
10204 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
10206 hWindowsThread
= CreateThread (NULL
, 0,
10207 (LPTHREAD_START_ROUTINE
) w32_msg_worker
,
10208 0, 0, &dwWindowsThreadId
);
10210 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
10213 /* It is desirable that mainThread should have the same notion of
10214 focus window and active window as windowsThread. Unfortunately, the
10215 following call to AttachThreadInput, which should do precisely what
10216 we need, causes major problems when Emacs is linked as a console
10217 program. Unfortunately, we have good reasons for doing that, so
10218 instead we need to send messages to windowsThread to make some API
10219 calls for us (ones that affect, or depend on, the active/focus
10221 #ifdef ATTACH_THREADS
10222 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
10225 /* Dynamically link to optional system components. */
10227 HANDLE user_lib
= LoadLibrary ("user32.dll");
10229 #define LOAD_PROC(fn) pfn##fn = (void *) GetProcAddress (user_lib, #fn)
10231 /* New proportional scroll bar functions. */
10232 LOAD_PROC (SetScrollInfo
);
10233 LOAD_PROC (GetScrollInfo
);
10237 FreeLibrary (user_lib
);
10239 /* If using proportional scroll bars, ensure handle is at least 5 pixels;
10240 otherwise use the fixed height. */
10241 vertical_scroll_bar_min_handle
= (pfnSetScrollInfo
!= NULL
) ? 5 :
10242 GetSystemMetrics (SM_CYVTHUMB
);
10244 /* For either kind of scroll bar, take account of the arrows; these
10245 effectively form the border of the main scroll bar range. */
10246 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
10247 = GetSystemMetrics (SM_CYVSCROLL
);
10254 staticpro (&w32_display_name_list
);
10255 w32_display_name_list
= Qnil
;
10257 staticpro (&last_mouse_scroll_bar
);
10258 last_mouse_scroll_bar
= Qnil
;
10260 staticpro (&Qvendor_specific_keysyms
);
10261 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
10263 DEFVAR_INT ("w32-num-mouse-buttons",
10264 &Vw32_num_mouse_buttons
,
10265 "Number of physical mouse buttons.");
10266 Vw32_num_mouse_buttons
= Qnil
;
10268 DEFVAR_LISP ("w32-swap-mouse-buttons",
10269 &Vw32_swap_mouse_buttons
,
10270 "Swap the mapping of middle and right mouse buttons.\n\
10271 When nil, middle button is mouse-2 and right button is mouse-3.");
10272 Vw32_swap_mouse_buttons
= Qnil
;
10274 DEFVAR_LISP ("w32-grab-focus-on-raise",
10275 &Vw32_grab_focus_on_raise
,
10276 "Raised frame grabs input focus.\n\
10277 When t, `raise-frame' grabs input focus as well. This fits well\n\
10278 with the normal Windows click-to-focus policy, but might not be\n\
10279 desirable when using a point-to-focus policy.");
10280 Vw32_grab_focus_on_raise
= Qt
;
10282 DEFVAR_LISP ("w32-capslock-is-shiftlock",
10283 &Vw32_capslock_is_shiftlock
,
10284 "Apply CapsLock state to non character input keys.\n\
10285 When nil, CapsLock only affects normal character input keys.");
10286 Vw32_capslock_is_shiftlock
= Qnil
;
10288 DEFVAR_LISP ("w32-recognize-altgr",
10289 &Vw32_recognize_altgr
,
10290 "Recognize right-alt and left-ctrl as AltGr.\n\
10291 When nil, the right-alt and left-ctrl key combination is\n\
10292 interpreted normally.");
10293 Vw32_recognize_altgr
= Qt
;
10295 DEFVAR_BOOL ("w32-enable-unicode-output",
10296 &w32_enable_unicode_output
,
10297 "Enable the use of Unicode for text output if non-nil.\n\
10298 Unicode output may prevent some third party applications for displaying\n\
10299 Far-East Languages on Windows 95/98 from working properly.\n\
10300 NT uses Unicode internally anyway, so this flag will probably have no\n\
10301 affect on NT machines.");
10302 w32_enable_unicode_output
= 1;
10305 staticpro (&help_echo
);
10306 help_echo_object
= Qnil
;
10307 staticpro (&help_echo_object
);
10308 help_echo_window
= Qnil
;
10309 staticpro (&help_echo_window
);
10310 previous_help_echo
= Qnil
;
10311 staticpro (&previous_help_echo
);
10312 help_echo_pos
= -1;
10314 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
10315 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
10316 For example, if a block cursor is over a tab, it will be drawn as\n\
10317 wide as that tab on the display.");
10318 x_stretch_cursor_p
= 0;
10320 DEFVAR_BOOL ("x-toolkit-scroll-bars-p", &x_toolkit_scroll_bars_p
,
10321 "If not nil, Emacs uses toolkit scroll bars.");
10322 x_toolkit_scroll_bars_p
= 1;
10324 staticpro (&last_mouse_motion_frame
);
10325 last_mouse_motion_frame
= Qnil
;