1 /* Implementation of GUI terminal on the Microsoft W32 API.
2 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 2006, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
26 #include "blockinput.h"
38 #include "character.h"
42 #include "dispextern.h"
44 #include "termhooks.h"
51 #include "intervals.h"
65 static int max_fringe_bmp
= 0;
66 static HBITMAP
*fringe_bmp
= 0;
68 /* Non-nil means Emacs uses toolkit scroll bars. */
70 Lisp_Object Vx_toolkit_scroll_bars
;
72 /* Temporary variables for w32_read_socket. */
74 static int last_mousemove_x
= 0;
75 static int last_mousemove_y
= 0;
77 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
78 #ifndef GET_WHEEL_DELTA_WPARAM
79 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
82 /* Non-zero means that a HELP_EVENT has been generated since Emacs
85 static int any_help_event_p
;
87 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
88 static Lisp_Object last_window
;
90 /* Non-zero means make use of UNDERLINE_POSITION font properties.
91 (Not yet supported, see TODO in x_draw_glyph_string.) */
92 int x_use_underline_position_properties
;
94 /* Non-zero means to draw the underline at the same place as the descent line. */
96 int x_underline_at_descent_line
;
98 extern unsigned int msh_mousewheel
;
100 extern void free_frame_menubar ();
102 extern int w32_codepage_for_font (char *fontname
);
103 extern Cursor
w32_load_cursor (LPCTSTR name
);
105 extern glyph_metric
*w32_BDF_TextMetric(bdffont
*fontp
,
106 unsigned char *text
, int dim
);
107 extern Lisp_Object Vwindow_system
;
109 #define x_any_window_to_frame x_window_to_frame
110 #define x_top_window_to_frame x_window_to_frame
113 /* This is display since w32 does not support multiple ones. */
114 struct w32_display_info one_w32_display_info
;
115 struct w32_display_info
*x_display_list
;
117 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
118 one for each element of w32_display_list and in the same order.
119 NAME is the name of the frame.
120 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
121 Lisp_Object w32_display_name_list
;
125 /* Pre Windows 2000, this was not available, but define it here so
126 that Emacs compiled on such a platform will run on newer versions. */
128 typedef struct tagWCRANGE
134 typedef struct tagGLYPHSET
138 DWORD cGlyphsSupported
;
145 /* Dynamic linking to GetFontUnicodeRanges (not available on 95, 98, ME). */
146 DWORD (PASCAL
*pfnGetFontUnicodeRanges
) (HDC device
, GLYPHSET
*ranges
);
148 /* Frame being updated by update_frame. This is declared in term.c.
149 This is set by update_begin and looked at by all the
150 w32 functions. It is zero while not inside an update.
151 In that case, the w32 functions assume that `SELECTED_FRAME ()'
152 is the frame to apply to. */
153 extern struct frame
*updating_frame
;
155 /* This is a frame waiting to be autoraised, within w32_read_socket. */
156 struct frame
*pending_autoraise_frame
;
158 /* The handle of the frame that currently owns the system caret. */
159 HWND w32_system_caret_hwnd
;
160 int w32_system_caret_height
;
161 int w32_system_caret_x
;
162 int w32_system_caret_y
;
163 int w32_use_visible_system_caret
;
165 /* Flag to enable Unicode output in case users wish to use programs
166 like Twinbridge on '95 rather than installed system level support
167 for Far East languages. */
168 int w32_enable_unicode_output
;
170 /* Flag to enable Cleartype hack for font metrics. */
171 static int cleartype_active
;
173 DWORD dwWindowsThreadId
= 0;
174 HANDLE hWindowsThread
= NULL
;
175 DWORD dwMainThreadId
= 0;
176 HANDLE hMainThread
= NULL
;
178 int vertical_scroll_bar_min_handle
;
179 int vertical_scroll_bar_top_border
;
180 int vertical_scroll_bar_bottom_border
;
182 int last_scroll_bar_drag_pos
;
184 /* Mouse movement. */
186 /* Where the mouse was last time we reported a mouse event. */
188 static RECT last_mouse_glyph
;
189 static FRAME_PTR last_mouse_glyph_frame
;
190 static Lisp_Object last_mouse_press_frame
;
192 int w32_num_mouse_buttons
;
194 Lisp_Object Vw32_swap_mouse_buttons
;
196 /* Control whether x_raise_frame also sets input focus. */
197 Lisp_Object Vw32_grab_focus_on_raise
;
199 /* Control whether Caps Lock affects non-ascii characters. */
200 Lisp_Object Vw32_capslock_is_shiftlock
;
202 /* Control whether right-alt and left-ctrl should be recognized as AltGr. */
203 Lisp_Object Vw32_recognize_altgr
;
205 /* The scroll bar in which the last motion event occurred.
207 If the last motion event occurred in a scroll bar, we set this
208 so w32_mouse_position can know whether to report a scroll bar motion or
211 If the last motion event didn't occur in a scroll bar, we set this
212 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
213 static Lisp_Object last_mouse_scroll_bar
;
214 static int last_mouse_scroll_bar_pos
;
216 /* This is a hack. We would really prefer that w32_mouse_position would
217 return the time associated with the position it returns, but there
218 doesn't seem to be any way to wrest the time-stamp from the server
219 along with the position query. So, we just keep track of the time
220 of the last movement we received, and return that in hopes that
221 it's somewhat accurate. */
223 static Time last_mouse_movement_time
;
225 /* Incremented by w32_read_socket whenever it really tries to read
229 static int volatile input_signal_count
;
231 static int input_signal_count
;
234 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
240 /* A mask of extra modifier bits to put into every keyboard char. */
242 extern EMACS_INT extra_keyboard_modifiers
;
244 static void x_update_window_end
P_ ((struct window
*, int, int));
245 static void w32_handle_tool_bar_click
P_ ((struct frame
*,
246 struct input_event
*));
247 static void w32_define_cursor
P_ ((Window
, Cursor
));
249 void x_lower_frame
P_ ((struct frame
*));
250 void x_scroll_bar_clear
P_ ((struct frame
*));
251 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
252 void x_raise_frame
P_ ((struct frame
*));
253 void x_set_window_size
P_ ((struct frame
*, int, int, int));
254 void x_wm_set_window_state
P_ ((struct frame
*, int));
255 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
256 static void w32_initialize
P_ ((void));
257 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
258 int x_compute_min_glyph_bounds
P_ ((struct frame
*));
259 static void x_update_end
P_ ((struct frame
*));
260 static void w32_frame_up_to_date
P_ ((struct frame
*));
261 static void w32_set_terminal_modes
P_ ((struct terminal
*));
262 static void w32_reset_terminal_modes
P_ ((struct terminal
*));
263 static void x_clear_frame
P_ ((struct frame
*));
264 static void frame_highlight
P_ ((struct frame
*));
265 static void frame_unhighlight
P_ ((struct frame
*));
266 static void x_new_focus_frame
P_ ((struct w32_display_info
*,
268 static void x_focus_changed
P_ ((int, int, struct w32_display_info
*,
269 struct frame
*, struct input_event
*));
270 static void w32_detect_focus_change
P_ ((struct w32_display_info
*,
271 W32Msg
*, struct input_event
*));
272 static void w32_frame_rehighlight
P_ ((struct frame
*));
273 static void x_frame_rehighlight
P_ ((struct w32_display_info
*));
274 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
275 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
276 enum text_cursor_kinds
));
277 static void w32_clip_to_row
P_ ((struct window
*, struct glyph_row
*, int, HDC
));
278 static BOOL my_show_window
P_ ((struct frame
*, HWND
, int));
279 static void my_set_window_pos
P_ ((HWND
, HWND
, int, int, int, int, UINT
));
280 static void my_set_focus
P_ ((struct frame
*, HWND
));
281 static void my_set_foreground_window
P_ ((HWND
));
282 static void my_destroy_window
P_ ((struct frame
*, HWND
));
284 static Lisp_Object Qvendor_specific_keysyms
;
287 /***********************************************************************
289 ***********************************************************************/
293 /* This is a function useful for recording debugging information about
294 the sequence of occurrences in this file. */
302 struct record event_record
[100];
304 int event_record_index
;
306 record_event (locus
, type
)
310 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
311 event_record_index
= 0;
313 event_record
[event_record_index
].locus
= locus
;
314 event_record
[event_record_index
].type
= type
;
315 event_record_index
++;
322 XChangeGC (void * ignore
, XGCValues
* gc
, unsigned long mask
,
325 if (mask
& GCForeground
)
326 gc
->foreground
= xgcv
->foreground
;
327 if (mask
& GCBackground
)
328 gc
->background
= xgcv
->background
;
330 gc
->font
= xgcv
->font
;
333 XGCValues
*XCreateGC (void * ignore
, Window window
, unsigned long mask
,
336 XGCValues
*gc
= (XGCValues
*) xmalloc (sizeof (XGCValues
));
337 bzero (gc
, sizeof (XGCValues
));
339 XChangeGC (ignore
, gc
, mask
, xgcv
);
345 XGetGCValues (void* ignore
, XGCValues
*gc
,
346 unsigned long mask
, XGCValues
*xgcv
)
348 XChangeGC (ignore
, xgcv
, mask
, gc
);
352 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
356 HRGN clip_region
= CreateRectRgnIndirect (rect
);
357 SelectClipRgn (hdc
, clip_region
);
358 DeleteObject (clip_region
);
361 SelectClipRgn (hdc
, NULL
);
365 /* Draw a hollow rectangle at the specified position. */
367 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
368 int width
, int height
)
373 hb
= CreateSolidBrush (gc
->background
);
374 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
375 oldhb
= SelectObject (hdc
, hb
);
376 oldhp
= SelectObject (hdc
, hp
);
378 Rectangle (hdc
, x
, y
, x
+ width
, y
+ height
);
380 SelectObject (hdc
, oldhb
);
381 SelectObject (hdc
, oldhp
);
386 /* Draw a filled rectangle at the specified position. */
388 w32_fill_rect (f
, hdc
, pix
, lprect
)
396 hb
= CreateSolidBrush (pix
);
397 FillRect (hdc
, lprect
, hb
);
406 HDC hdc
= get_frame_dc (f
);
408 /* Under certain conditions, this can be called at startup with
409 a console frame pointer before the GUI frame is created. An HDC
410 of 0 indicates this. */
413 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
414 w32_clear_rect (f
, hdc
, &rect
);
417 release_frame_dc (f
, hdc
);
421 /***********************************************************************
422 Starting and ending an update
423 ***********************************************************************/
425 /* Start an update of frame F. This function is installed as a hook
426 for update_begin, i.e. it is called when update_begin is called.
427 This function is called prior to calls to x_update_window_begin for
428 each window being updated. */
434 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
436 if (! FRAME_W32_P (f
))
439 /* Regenerate display palette before drawing if list of requested
440 colors has changed. */
441 if (display_info
->regen_palette
)
443 w32_regenerate_palette (f
);
444 display_info
->regen_palette
= FALSE
;
449 /* Start update of window W. Set the global variable updated_window
450 to the window being updated and set output_cursor to the cursor
454 x_update_window_begin (w
)
457 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
458 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
460 /* Hide the system caret during an update. */
461 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
463 SendMessage (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0);
467 set_output_cursor (&w
->cursor
);
471 if (f
== display_info
->mouse_face_mouse_frame
)
473 /* Don't do highlighting for mouse motion during the update. */
474 display_info
->mouse_face_defer
= 1;
476 /* If F needs to be redrawn, simply forget about any prior mouse
478 if (FRAME_GARBAGED_P (f
))
479 display_info
->mouse_face_window
= Qnil
;
481 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
482 their mouse_face_p flag set, which means that they are always
483 unequal to rows in a desired matrix which never have that
484 flag set. So, rows containing mouse-face glyphs are never
485 scrolled, and we don't have to switch the mouse highlight off
486 here to prevent it from being scrolled. */
488 /* Can we tell that this update does not affect the window
489 where the mouse highlight is? If so, no need to turn off.
490 Likewise, don't do anything if the frame is garbaged;
491 in that case, the frame's current matrix that we would use
492 is all wrong, and we will redisplay that line anyway. */
493 if (!NILP (display_info
->mouse_face_window
)
494 && w
== XWINDOW (display_info
->mouse_face_window
))
498 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
499 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
502 if (i
< w
->desired_matrix
->nrows
)
503 clear_mouse_face (display_info
);
511 /* Draw a vertical window border from (x,y0) to (x,y1) */
514 w32_draw_vertical_window_border (w
, x
, y0
, y1
)
518 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
528 hdc
= get_frame_dc (f
);
529 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
531 w32_fill_rect (f
, hdc
, face
->foreground
, &r
);
533 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
535 release_frame_dc (f
, hdc
);
539 /* End update of window W (which is equal to updated_window).
541 Draw vertical borders between horizontally adjacent windows, and
542 display W's cursor if CURSOR_ON_P is non-zero.
544 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
545 glyphs in mouse-face were overwritten. In that case we have to
546 make sure that the mouse-highlight is properly redrawn.
548 W may be a menu bar pseudo-window in case we don't have X toolkit
549 support. Such windows don't have a cursor, so don't display it
553 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
555 int cursor_on_p
, mouse_face_overwritten_p
;
557 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
559 if (!w
->pseudo_window_p
)
564 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
566 output_cursor
.x
, output_cursor
.y
);
568 if (draw_window_fringes (w
, 1))
569 x_draw_vertical_border (w
);
574 /* If a row with mouse-face was overwritten, arrange for
575 XTframe_up_to_date to redisplay the mouse highlight. */
576 if (mouse_face_overwritten_p
)
578 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
579 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
580 dpyinfo
->mouse_face_window
= Qnil
;
583 /* Unhide the caret. This won't actually show the cursor, unless it
584 was visible before the corresponding call to HideCaret in
585 x_update_window_begin. */
586 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
588 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
591 updated_window
= NULL
;
595 /* End update of frame F. This function is installed as a hook in
602 if (! FRAME_W32_P (f
))
605 /* Mouse highlight may be displayed again. */
606 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
610 /* This function is called from various places in xdisp.c whenever a
611 complete update has been performed. The global variable
612 updated_window is not available here. */
615 w32_frame_up_to_date (f
)
620 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
622 if (dpyinfo
->mouse_face_deferred_gc
623 || f
== dpyinfo
->mouse_face_mouse_frame
)
626 if (dpyinfo
->mouse_face_mouse_frame
)
627 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
628 dpyinfo
->mouse_face_mouse_x
,
629 dpyinfo
->mouse_face_mouse_y
);
630 dpyinfo
->mouse_face_deferred_gc
= 0;
637 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
638 arrow bitmaps, or clear the fringes if no bitmaps are required
639 before DESIRED_ROW is made current. The window being updated is
640 found in updated_window. This function is called from
641 update_window_line only if it is known that there are differences
642 between bitmaps to be drawn between current row and DESIRED_ROW. */
645 x_after_update_window_line (desired_row
)
646 struct glyph_row
*desired_row
;
648 struct window
*w
= updated_window
;
654 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
655 desired_row
->redraw_fringe_bitmaps_p
= 1;
657 /* When a window has disappeared, make sure that no rest of
658 full-width rows stays visible in the internal border. Could
659 check here if updated_window is the leftmost/rightmost window,
660 but I guess it's not worth doing since vertically split windows
661 are almost never used, internal border is rarely set, and the
662 overhead is very small. */
663 if (windows_or_buffers_changed
664 && desired_row
->full_width_p
665 && (f
= XFRAME (w
->frame
),
666 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
668 && (height
= desired_row
->visible_height
,
671 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
673 /* Internal border is drawn below the tool bar. */
674 if (WINDOWP (f
->tool_bar_window
)
675 && w
== XWINDOW (f
->tool_bar_window
))
680 HDC hdc
= get_frame_dc (f
);
681 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
682 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
684 release_frame_dc (f
, hdc
);
691 /* Draw the bitmap WHICH in one of the left or right fringes of
692 window W. ROW is the glyph row for which to display the bitmap; it
693 determines the vertical position at which the bitmap has to be
697 w32_draw_fringe_bitmap (w
, row
, p
)
699 struct glyph_row
*row
;
700 struct draw_fringe_bitmap_params
*p
;
702 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
704 struct face
*face
= p
->face
;
707 hdc
= get_frame_dc (f
);
711 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
713 /* If the fringe is adjacent to the left (right) scroll bar of a
714 leftmost (rightmost, respectively) window, then extend its
715 background to the gap between the fringe and the bar. */
716 if ((WINDOW_LEFTMOST_P (w
)
717 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
718 || (WINDOW_RIGHTMOST_P (w
)
719 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
721 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
725 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
726 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
727 * FRAME_COLUMN_WIDTH (f
));
731 /* Bitmap fills the fringe. */
732 if (left
+ width
== p
->x
)
733 bx
= left
+ sb_width
;
734 else if (p
->x
+ p
->wd
== left
)
738 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
740 nx
= width
- sb_width
;
741 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
743 ny
= row
->visible_height
;
748 if (left
+ width
== bx
)
750 bx
= left
+ sb_width
;
751 nx
+= width
- sb_width
;
753 else if (bx
+ nx
== left
)
754 nx
+= width
- sb_width
;
759 if (bx
>= 0 && nx
> 0)
760 w32_fill_area (f
, hdc
, face
->background
, bx
, by
, nx
, ny
);
763 /* Must clip because of partially visible lines. */
764 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
767 /* Adjust position of "bottom aligned" bitmap on partially
770 int oldVH
= row
->visible_height
;
771 row
->visible_height
= p
->h
;
772 row
->y
-= rowY
- p
->y
;
773 w32_clip_to_row (w
, row
, -1, hdc
);
775 row
->visible_height
= oldVH
;
778 w32_clip_to_row (w
, row
, -1, hdc
);
780 if (p
->which
&& p
->which
< max_fringe_bmp
)
782 HBITMAP pixmap
= fringe_bmp
[p
->which
];
786 compat_hdc
= CreateCompatibleDC (hdc
);
790 horig_obj
= SelectObject (compat_hdc
, pixmap
);
792 /* Paint overlays transparently. */
795 HBRUSH h_brush
, h_orig_brush
;
797 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
798 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
799 h_brush
= CreateSolidBrush (face
->foreground
);
800 h_orig_brush
= SelectObject (hdc
, h_brush
);
802 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
803 compat_hdc
, 0, p
->dh
,
805 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
806 compat_hdc
, 0, p
->dh
,
808 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
809 compat_hdc
, 0, p
->dh
,
812 SelectObject (hdc
, h_orig_brush
);
813 DeleteObject (h_brush
);
817 SetTextColor (hdc
, face
->background
);
818 SetBkColor (hdc
, (p
->cursor_p
819 ? f
->output_data
.w32
->cursor_pixel
820 : face
->foreground
));
822 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
823 compat_hdc
, 0, p
->dh
,
827 SelectObject (compat_hdc
, horig_obj
);
828 DeleteDC (compat_hdc
);
832 w32_set_clip_rectangle (hdc
, NULL
);
834 release_frame_dc (f
, hdc
);
838 w32_define_fringe_bitmap (which
, bits
, h
, wd
)
840 unsigned short *bits
;
843 if (which
>= max_fringe_bmp
)
845 int i
= max_fringe_bmp
;
846 max_fringe_bmp
= which
+ 20;
847 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
848 while (i
< max_fringe_bmp
)
852 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
856 w32_destroy_fringe_bitmap (which
)
859 if (which
>= max_fringe_bmp
)
862 if (fringe_bmp
[which
])
863 DeleteObject (fringe_bmp
[which
]);
864 fringe_bmp
[which
] = 0;
869 /* This is called when starting Emacs and when restarting after
870 suspend. When starting Emacs, no window is mapped. And nothing
871 must be done to Emacs's own window if it is suspended (though that
875 w32_set_terminal_modes (struct terminal
*term
)
879 /* This is called when exiting or suspending Emacs. Exiting will make
880 the W32 windows go away, and suspending requires no action. */
883 w32_reset_terminal_modes (struct terminal
*term
)
889 /***********************************************************************
891 ***********************************************************************/
893 /* Function prototypes of this page. */
897 XCharStruct
*w32_per_char_metric
P_ ((XFontStruct
*, wchar_t *, int));
898 static int w32_encode_char
P_ ((int, wchar_t *, struct font_info
*,
899 struct charset
*, int *));
902 /* Get metrics of character CHAR2B in FONT. Value is always non-null.
903 If CHAR2B is not contained in FONT, the font's default character
904 metric is returned. */
907 w32_bdf_per_char_metric (font
, char2b
, dim
, pcm
)
913 glyph_metric
* bdf_metric
;
917 buf
[0] = (char)(*char2b
);
920 buf
[0] = XCHAR2B_BYTE1 (char2b
);
921 buf
[1] = XCHAR2B_BYTE2 (char2b
);
924 bdf_metric
= w32_BDF_TextMetric (font
->bdf
, buf
, dim
);
928 pcm
->width
= bdf_metric
->dwidth
;
929 pcm
->lbearing
= bdf_metric
->bbox
;
930 pcm
->rbearing
= bdf_metric
->dwidth
931 - (bdf_metric
->bbox
+ bdf_metric
->bbw
);
932 pcm
->ascent
= bdf_metric
->bboy
+ bdf_metric
->bbh
;
933 pcm
->descent
= -bdf_metric
->bboy
;
942 w32_native_per_char_metric (font
, char2b
, font_type
, pcm
)
945 enum w32_char_font_type font_type
;
948 HDC hdc
= GetDC (NULL
);
952 xassert (font
&& char2b
);
953 xassert (font
->hfont
);
954 xassert (font_type
== UNICODE_FONT
|| font_type
== ANSI_FONT
);
956 old_font
= SelectObject (hdc
, font
->hfont
);
958 if ((font
->tm
.tmPitchAndFamily
& TMPF_TRUETYPE
) != 0)
962 if (font_type
== UNICODE_FONT
)
963 retval
= GetCharABCWidthsW (hdc
, *char2b
, *char2b
, &char_widths
);
965 retval
= GetCharABCWidthsA (hdc
, *char2b
, *char2b
, &char_widths
);
970 /* Disabled until we can find a way to get the right results
971 on all versions of Windows. */
973 /* Don't trust the ABC widths. For synthesized fonts they are
974 wrong, and so is the result of GetCharWidth()! */
976 GetCharWidth (hdc
, *char2b
, *char2b
, &real_width
);
978 if (cleartype_active
)
980 /* Cleartype antialiasing causes characters to overhang
981 by a pixel on each side compared with what GetCharABCWidths
983 char_widths
.abcA
-= 1;
984 char_widths
.abcC
-= 1;
985 char_widths
.abcB
+= 2;
988 pcm
->width
= char_widths
.abcA
+ char_widths
.abcB
+ char_widths
.abcC
;
990 /* As far as I can tell, this is the best way to determine what
991 ExtTextOut will do with the broken font. */
992 if (pcm
->width
!= real_width
)
993 pcm
->width
= (pcm
->width
+ real_width
) / 2;
995 pcm
->lbearing
= char_widths
.abcA
;
996 pcm
->rbearing
= char_widths
.abcA
+ char_widths
.abcB
;
997 pcm
->ascent
= FONT_BASE (font
);
998 pcm
->descent
= FONT_DESCENT (font
);
1004 /* Either font is not a True-type font, or GetCharABCWidthsW
1005 failed (it is not supported on Windows 9x for instance), so we
1006 can't determine the full info we would like. All is not lost
1007 though - we can call GetTextExtentPoint32 to get rbearing and
1008 deduce width based on the font's per-string overhang. lbearing
1009 is assumed to be zero. */
1011 /* TODO: Some Thai characters (and other composites if Windows
1012 supports them) do have lbearing, and report their total width
1013 as zero. Need some way of handling them when
1014 GetCharABCWidthsW fails. */
1017 if (font_type
== UNICODE_FONT
)
1018 retval
= GetTextExtentPoint32W (hdc
, char2b
, 1, &sz
);
1020 retval
= GetTextExtentPoint32A (hdc
, (char*)char2b
, 1, &sz
);
1025 pcm
->rbearing
= sz
.cx
+ font
->tm
.tmOverhang
;
1027 pcm
->ascent
= FONT_BASE (font
);
1028 pcm
->descent
= FONT_DESCENT (font
);
1033 if (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0)
1038 SelectObject (hdc
, old_font
);
1039 ReleaseDC (NULL
, hdc
);
1046 w32_per_char_metric (font
, char2b
, font_type
)
1049 int /* enum w32_char_font_type */ font_type
;
1051 /* The result metric information. */
1055 xassert (font
&& char2b
);
1057 /* TODO: This function is currently called through the RIF, and in
1058 some cases font_type is UNKNOWN_FONT. We currently allow the
1059 cached metrics to be used, which seems to work, but in cases
1060 where font_type is UNKNOWN_FONT, we probably haven't encoded
1061 char2b appropriately. All callers need checking to see what they
1062 are passing. This is most likely to affect variable width fonts
1063 outside the Latin-1 range, particularly in languages like Thai
1064 that rely on rbearing and lbearing to provide composition. I
1065 don't think that is working currently anyway, but we don't seem
1066 to have anyone testing such languages on Windows. */
1068 /* Handle the common cases quickly. */
1069 if (!font
->bdf
&& font
->per_char
== NULL
)
1070 /* TODO: determine whether char2b exists in font? */
1071 return &font
->max_bounds
;
1072 else if (!font
->bdf
&& *char2b
< 128)
1073 return &font
->per_char
[*char2b
];
1075 xassert (font_type
!= UNKNOWN_FONT
);
1077 pcm
= &font
->scratch
;
1079 if (font_type
== BDF_1D_FONT
)
1080 retval
= w32_bdf_per_char_metric (font
, char2b
, 1, pcm
);
1081 else if (font_type
== BDF_2D_FONT
)
1082 retval
= w32_bdf_per_char_metric (font
, char2b
, 2, pcm
);
1084 retval
= w32_native_per_char_metric (font
, char2b
, font_type
, pcm
);
1093 w32_cache_char_metrics (font
)
1096 wchar_t char2b
= L
'x';
1098 /* Cache char metrics for the common cases. */
1101 /* TODO: determine whether font is fixed-pitch. */
1102 if (!w32_bdf_per_char_metric (font
, &char2b
, 1, &font
->max_bounds
))
1104 /* Use the font width and height as max bounds, as not all BDF
1105 fonts contain the letter 'x'. */
1106 font
->max_bounds
.width
= FONT_WIDTH (font
);
1107 font
->max_bounds
.lbearing
= -font
->bdf
->llx
;
1108 font
->max_bounds
.rbearing
= FONT_WIDTH (font
) - font
->bdf
->urx
;
1109 font
->max_bounds
.ascent
= FONT_BASE (font
);
1110 font
->max_bounds
.descent
= FONT_DESCENT (font
);
1115 if (((font
->tm
.tmPitchAndFamily
& TMPF_FIXED_PITCH
) != 0)
1116 /* Some fonts (eg DBCS fonts) are marked as fixed width even
1117 though they contain characters of different widths. */
1118 || (font
->tm
.tmMaxCharWidth
!= font
->tm
.tmAveCharWidth
))
1120 /* Font is not fixed pitch, so cache per_char info for the
1121 ASCII characters. It would be much more work, and probably
1122 not worth it, to cache other chars, since we may change
1123 between using Unicode and ANSI text drawing functions at
1127 font
->per_char
= xmalloc (128 * sizeof(XCharStruct
));
1128 for (i
= 0; i
< 128; i
++)
1131 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1132 &font
->per_char
[i
]);
1136 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1141 /* Determine if a font is double byte. */
1143 w32_font_is_double_byte (XFontStruct
*font
)
1145 return font
->double_byte_p
;
1150 w32_use_unicode_for_codepage (codepage
)
1153 /* If the current codepage is supported, use Unicode for output. */
1154 return (w32_enable_unicode_output
1155 && codepage
!= CP_8BIT
1156 && (codepage
== CP_UNICODE
|| IsValidCodePage (codepage
)));
1159 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1160 the two-byte form of C. Encoding is returned in *CHAR2B. */
1162 static int /* enum w32_char_font_type */
1163 w32_encode_char (c
, char2b
, font_info
, charset
, two_byte_p
)
1166 struct font_info
*font_info
;
1167 struct charset
*charset
;
1172 int internal_two_byte_p
= 0;
1174 XFontStruct
*font
= font_info
->font
;
1176 internal_two_byte_p
= w32_font_is_double_byte (font
);
1177 codepage
= font_info
->codepage
;
1179 /* If font can output unicode, use the original unicode character. */
1180 if ( font
&& !font
->bdf
&& w32_use_unicode_for_codepage (codepage
)
1185 internal_two_byte_p
= 1;
1188 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1189 This may be either a program in a special encoder language or a
1191 else if (font_info
->font_encoder
)
1193 /* It's a program. */
1194 struct ccl_program
*ccl
= font_info
->font_encoder
;
1196 if (CHARSET_DIMENSION (charset
) == 1)
1198 ccl
->reg
[0] = CHARSET_ID (charset
);
1199 ccl
->reg
[1] = XCHAR2B_BYTE2 (char2b
);
1204 ccl
->reg
[0] = CHARSET_ID (charset
);
1205 ccl
->reg
[1] = XCHAR2B_BYTE1 (char2b
);
1206 ccl
->reg
[2] = XCHAR2B_BYTE2 (char2b
);
1209 ccl_driver (ccl
, NULL
, NULL
, 0, 0, Qnil
);
1211 /* We assume that MSBs are appropriately set/reset by CCL
1213 if (!internal_two_byte_p
) /* 1-byte font */
1214 STORE_XCHAR2B (char2b
, 0, ccl
->reg
[1]);
1216 STORE_XCHAR2B (char2b
, ccl
->reg
[1], ccl
->reg
[2]);
1218 else if (font_info
->encoding_type
)
1220 /* Fixed encoding scheme. See fontset.h for the meaning of the
1221 encoding numbers. */
1222 unsigned char enc
= font_info
->encoding_type
;
1224 if ((enc
== 1 || enc
== 2)
1225 && CHARSET_DIMENSION (charset
) == 2)
1226 STORE_XCHAR2B (char2b
, XCHAR2B_BYTE1 (char2b
) | 0x80, XCHAR2B_BYTE2 (char2b
));
1228 if (enc
== 1 || enc
== 3 || (enc
== 4 && CHARSET_DIMENSION (charset
) == 1))
1229 STORE_XCHAR2B (char2b
, XCHAR2B_BYTE1 (char2b
), XCHAR2B_BYTE2 (char2b
) | 0x80);
1232 int code
= (int) (*char2b
);
1235 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
1240 *two_byte_p
= internal_two_byte_p
;
1243 return UNKNOWN_FONT
;
1244 else if (font
->bdf
&& CHARSET_DIMENSION (charset
) == 1)
1249 return UNICODE_FONT
;
1255 /* Return a char-table whose elements are t if the font FONT_INFO
1256 contains a glyph for the corresponding character, and nil if not.
1258 Fixme: For the moment, this function works only for fonts whose
1259 glyph encoding is the same as Unicode (e.g. ISO10646-1 fonts). */
1262 x_get_font_repertory (f
, font_info
)
1264 struct font_info
*font_info
;
1266 XFontStruct
*font
= (XFontStruct
*) font_info
->font
;
1268 int min_byte1
, max_byte1
, min_byte2
, max_byte2
;
1270 struct charset
*charset
= CHARSET_FROM_ID (font_info
->charset
);
1271 int offset
= CHARSET_OFFSET (charset
);
1273 table
= Fmake_char_table (Qnil
, Qnil
);
1275 if (!font
->bdf
&& pfnGetFontUnicodeRanges
)
1278 DWORD glyphset_size
;
1279 HDC display
= get_frame_dc (f
);
1283 prev_font
= SelectObject (display
, font
->hfont
);
1285 /* First call GetFontUnicodeRanges to find out how big a structure
1287 glyphset_size
= pfnGetFontUnicodeRanges (display
, NULL
);
1290 glyphset
= (GLYPHSET
*) alloca (glyphset_size
);
1291 glyphset
->cbThis
= glyphset_size
;
1293 /* Now call it again to get the ranges. */
1294 glyphset_size
= pfnGetFontUnicodeRanges (display
, glyphset
);
1298 /* Store the ranges in TABLE. */
1299 for (i
= 0; i
< glyphset
->cRanges
; i
++)
1301 int from
= glyphset
->ranges
[i
].wcLow
;
1302 int to
= from
+ glyphset
->ranges
[i
].cGlyphs
- 1;
1303 char_table_set_range (table
, from
, to
, Qt
);
1308 SelectObject (display
, prev_font
);
1309 release_frame_dc (f
, display
);
1311 /* If we got the information we wanted above, then return it. */
1316 #if 0 /* TODO: Convert to work on Windows so BDF and older platforms work. */
1317 /* When GetFontUnicodeRanges is not available or does not work,
1318 work it out manually. */
1319 min_byte1
= font
->min_byte1
;
1320 max_byte1
= font
->max_byte1
;
1321 min_byte2
= font
->min_char_or_byte2
;
1322 max_byte2
= font
->max_char_or_byte2
;
1323 if (min_byte1
== 0 && max_byte1
== 0)
1325 if (! font
->per_char
|| font
->all_chars_exist
== True
)
1328 char_table_set_range (table
, offset
+ min_byte2
,
1329 offset
+ max_byte2
, Qt
);
1331 for (; min_byte2
<= max_byte2
; min_byte2
++)
1333 c
= DECODE_CHAR (charset
, min_byte2
);
1334 CHAR_TABLE_SET (table
, c
, Qt
);
1339 XCharStruct
*pcm
= font
->per_char
;
1343 for (i
= min_byte2
; i
<= max_byte2
; i
++, pcm
++)
1345 if (pcm
->width
== 0 && pcm
->rbearing
== pcm
->lbearing
)
1350 char_table_set_range (table
, offset
+ from
,
1351 offset
+ i
- 1, Qt
);
1353 for (; from
< i
; from
++)
1355 c
= DECODE_CHAR (charset
, from
);
1356 CHAR_TABLE_SET (table
, c
, Qt
);
1367 char_table_set_range (table
, offset
+ from
, offset
+ i
- 1,
1370 for (; from
< i
; from
++)
1372 c
= DECODE_CHAR (charset
, from
);
1373 CHAR_TABLE_SET (table
, c
, Qt
);
1380 if (! font
->per_char
|| font
->all_chars_exist
== True
)
1385 for (i
= min_byte1
; i
<= max_byte1
; i
++)
1386 char_table_set_range
1387 (table
, offset
+ ((i
<< 8) | min_byte2
),
1388 offset
+ ((i
<< 8) | max_byte2
), Qt
);
1390 for (i
= min_byte1
; i
<= max_byte1
; i
++)
1391 for (j
= min_byte2
; j
<= max_byte2
; j
++)
1393 unsiged code
= (i
<< 8) | j
;
1394 c
= DECODE_CHAR (charset
, code
);
1395 CHAR_TABLE_SET (table
, c
, Qt
);
1400 XCharStruct
*pcm
= font
->per_char
;
1403 for (i
= min_byte1
; i
<= max_byte1
; i
++)
1408 for (j
= min_byte2
; j
<= max_byte2
; j
++, pcm
++)
1410 if (pcm
->width
== 0 && pcm
->rbearing
== pcm
->lbearing
)
1415 char_table_set_range
1416 (table
, offset
+ ((i
<< 8) | from
),
1417 offset
+ ((i
<< 8) | (j
- 1)), Qt
);
1420 for (; from
< j
; from
++)
1422 unsigned code
= (i
<< 8) | from
;
1423 c
= ENCODE_CHAR (charset
, code
);
1424 CHAR_TABLE_SET (table
, c
, Qt
);
1436 char_table_set_range
1437 (table
, offset
+ ((i
<< 8) | from
),
1438 offset
+ ((i
<< 8) | (j
- 1)), Qt
);
1441 for (; from
< j
; from
++)
1443 unsigned code
= (i
<< 8) | from
;
1444 c
= DECODE_CHAR (charset
, code
);
1445 CHAR_TABLE_SET (table
, c
, Qt
);
1457 /***********************************************************************
1459 ***********************************************************************/
1462 /* Encapsulate the different ways of displaying text under W32. */
1465 w32_text_out (s
, x
, y
,chars
,nchars
)
1466 struct glyph_string
* s
;
1471 int charset_dim
= w32_font_is_double_byte (s
->font
) ? 2 : 1;
1473 w32_BDF_TextOut (s
->font
->bdf
, s
->hdc
,
1474 x
, y
, (char *) chars
, charset_dim
,
1475 nchars
* charset_dim
, 0);
1476 else if (s
->first_glyph
->font_type
== UNICODE_FONT
)
1477 ExtTextOutW (s
->hdc
, x
, y
, 0, NULL
, chars
, nchars
, NULL
);
1479 ExtTextOutA (s
->hdc
, x
, y
, 0, NULL
, (char *) chars
,
1480 nchars
* charset_dim
, NULL
);
1483 #endif /* OLD_FONT */
1485 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
1486 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
1487 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
1489 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
1490 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
1491 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
1492 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
1493 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
1494 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
1495 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
1496 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
1497 static void w32_setup_relief_color
P_ ((struct frame
*, struct relief
*,
1498 double, int, COLORREF
));
1499 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
1500 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
1501 static void x_draw_image_relief
P_ ((struct glyph_string
*));
1502 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
1503 static void w32_draw_image_foreground_1
P_ ((struct glyph_string
*, HBITMAP
));
1504 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
1506 static void w32_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
1507 int, int, int, int, int, int,
1509 static void w32_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
1510 int, int, int, RECT
*));
1513 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
1517 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1522 struct glyph_string
*s
;
1524 if (s
->font
== FRAME_FONT (s
->f
)
1525 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1526 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1528 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
1531 /* Cursor on non-default face: must merge. */
1535 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
1536 xgcv
.foreground
= s
->face
->background
;
1538 /* If the glyph would be invisible, try a different foreground. */
1539 if (xgcv
.foreground
== xgcv
.background
)
1540 xgcv
.foreground
= s
->face
->foreground
;
1541 if (xgcv
.foreground
== xgcv
.background
)
1542 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
1543 if (xgcv
.foreground
== xgcv
.background
)
1544 xgcv
.foreground
= s
->face
->foreground
;
1546 /* Make sure the cursor is distinct from text in this face. */
1547 if (xgcv
.background
== s
->face
->background
1548 && xgcv
.foreground
== s
->face
->foreground
)
1550 xgcv
.background
= s
->face
->foreground
;
1551 xgcv
.foreground
= s
->face
->background
;
1554 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1555 xgcv
.font
= s
->font
;
1556 mask
= GCForeground
| GCBackground
| GCFont
;
1558 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1559 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1562 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1563 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1565 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1570 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1573 x_set_mouse_face_gc (s
)
1574 struct glyph_string
*s
;
1579 /* What face has to be used last for the mouse face? */
1580 face_id
= FRAME_W32_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1581 face
= FACE_FROM_ID (s
->f
, face_id
);
1583 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1585 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1586 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1588 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1589 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1590 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1592 /* If font in this face is same as S->font, use it. */
1593 if (s
->font
== s
->face
->font
)
1594 s
->gc
= s
->face
->gc
;
1597 /* Otherwise construct scratch_cursor_gc with values from FACE
1602 xgcv
.background
= s
->face
->background
;
1603 xgcv
.foreground
= s
->face
->foreground
;
1604 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1605 xgcv
.font
= s
->font
;
1606 mask
= GCForeground
| GCBackground
| GCFont
;
1608 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1609 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1612 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1613 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1615 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1618 xassert (s
->gc
!= 0);
1622 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1623 Faces to use in the mode line have already been computed when the
1624 matrix was built, so there isn't much to do, here. */
1627 x_set_mode_line_face_gc (s
)
1628 struct glyph_string
*s
;
1630 s
->gc
= s
->face
->gc
;
1634 /* Set S->gc of glyph string S for drawing that glyph string. Set
1635 S->stippled_p to a non-zero value if the face of S has a stipple
1639 x_set_glyph_string_gc (s
)
1640 struct glyph_string
*s
;
1642 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1644 if (s
->hl
== DRAW_NORMAL_TEXT
)
1646 s
->gc
= s
->face
->gc
;
1647 s
->stippled_p
= s
->face
->stipple
!= 0;
1649 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1651 x_set_mode_line_face_gc (s
);
1652 s
->stippled_p
= s
->face
->stipple
!= 0;
1654 else if (s
->hl
== DRAW_CURSOR
)
1656 x_set_cursor_gc (s
);
1659 else if (s
->hl
== DRAW_MOUSE_FACE
)
1661 x_set_mouse_face_gc (s
);
1662 s
->stippled_p
= s
->face
->stipple
!= 0;
1664 else if (s
->hl
== DRAW_IMAGE_RAISED
1665 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1667 s
->gc
= s
->face
->gc
;
1668 s
->stippled_p
= s
->face
->stipple
!= 0;
1672 s
->gc
= s
->face
->gc
;
1673 s
->stippled_p
= s
->face
->stipple
!= 0;
1676 /* GC must have been set. */
1677 xassert (s
->gc
!= 0);
1681 /* Set clipping for output of glyph string S. S may be part of a mode
1682 line or menu if we don't have X toolkit support. */
1685 x_set_glyph_string_clipping (s
)
1686 struct glyph_string
*s
;
1689 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1692 w32_set_clip_rectangle (s
->hdc
, r
);
1695 HRGN full_clip
, clip1
, clip2
;
1696 clip1
= CreateRectRgnIndirect (r
);
1697 clip2
= CreateRectRgnIndirect (r
+ 1);
1698 if (CombineRgn (full_clip
, clip1
, clip2
, RGN_OR
) != ERROR
)
1700 SelectClipRgn (s
->hdc
, full_clip
);
1702 DeleteObject (clip1
);
1703 DeleteObject (clip2
);
1704 DeleteObject (full_clip
);
1709 /* Set SRC's clipping for output of glyph string DST. This is called
1710 when we are drawing DST's left_overhang or right_overhang only in
1714 x_set_glyph_string_clipping_exactly (src
, dst
)
1715 struct glyph_string
*src
, *dst
;
1720 r
.right
= r
.left
+ src
->width
;
1722 r
.bottom
= r
.top
+ src
->height
;
1727 struct glyph_string
*clip_head
= src
->clip_head
;
1728 struct glyph_string
*clip_tail
= src
->clip_tail
;
1730 /* This foces clipping just this glyph string. */
1731 src
->clip_head
= src
->clip_tail
= src
;
1732 get_glyph_string_clip_rect (src
, &r
);
1733 src
->clip_head
= clip_head
, src
->clip_tail
= clip_tail
;
1735 #endif /* OLD_FONT */
1736 w32_set_clip_rectangle (dst
->hdc
, &r
);
1740 Compute left and right overhang of glyph string S. */
1743 w32_compute_glyph_string_overhangs (s
)
1744 struct glyph_string
*s
;
1747 && s
->first_glyph
->type
== CHAR_GLYPH
1748 && !s
->font_not_found_p
)
1750 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1751 struct font
*font
= s
->font
;
1752 struct font_metrics metrics
;
1755 for (i
= 0; i
< s
->nchars
; i
++)
1756 code
[i
] = s
->char2b
[i
];
1757 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1758 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1759 ? metrics
.rbearing
- metrics
.width
: 0);
1760 s
->left_overhang
= metrics
.lbearing
< 0 ? -metrics
.lbearing
: 0;
1764 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1765 s
->left_overhang
= -s
->cmp
->lbearing
;
1769 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1772 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1773 struct glyph_string
*s
;
1781 /* Take clipping into account. */
1782 if (s
->gc
->clip_mask
== Rect
)
1784 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1785 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1786 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1787 - s
->gc
->clip_rectangle
.left
);
1788 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1789 - s
->gc
->clip_rectangle
.top
);
1792 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1797 /* Draw the background of glyph_string S. If S->background_filled_p
1798 is non-zero don't draw it. FORCE_P non-zero means draw the
1799 background even if it wouldn't be drawn normally. This is used
1800 when a string preceding S draws into the background of S, or S
1801 contains the first component of a composition. */
1804 x_draw_glyph_string_background (s
, force_p
)
1805 struct glyph_string
*s
;
1808 /* Nothing to do if background has already been drawn or if it
1809 shouldn't be drawn in the first place. */
1810 if (!s
->background_filled_p
)
1812 int box_line_width
= max (s
->face
->box_line_width
, 0);
1814 #if 0 /* TODO: stipple */
1817 /* Fill background with a stipple pattern. */
1818 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1819 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1820 s
->y
+ box_line_width
,
1821 s
->background_width
,
1822 s
->height
- 2 * box_line_width
);
1823 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1824 s
->background_filled_p
= 1;
1828 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1829 || s
->font_not_found_p
1830 || s
->extends_to_end_of_line_p
1831 || FONT_COMPAT (s
->font
)->bdf
1835 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1836 s
->background_width
,
1837 s
->height
- 2 * box_line_width
);
1838 s
->background_filled_p
= 1;
1844 /* Draw the foreground of glyph string S. */
1847 x_draw_glyph_string_foreground (s
)
1848 struct glyph_string
*s
;
1853 /* If first glyph of S has a left box line, start drawing the text
1854 of S to the right of that box line. */
1855 if (s
->face
->box
!= FACE_NO_BOX
1856 && s
->first_glyph
->left_box_line_p
)
1857 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1861 if (s
->for_overlaps
|| (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
)
1862 || cleartype_active
)
1863 SetBkMode (s
->hdc
, TRANSPARENT
);
1865 SetBkMode (s
->hdc
, OPAQUE
);
1867 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1868 SetBkColor (s
->hdc
, s
->gc
->background
);
1869 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1871 if (s
->font
&& FONT_COMPAT (s
->font
)->hfont
)
1872 old_font
= SelectObject (s
->hdc
, FONT_COMPAT (s
->font
)->hfont
);
1874 /* Draw characters of S as rectangles if S's font could not be
1876 if (s
->font_not_found_p
)
1878 for (i
= 0; i
< s
->nchars
; ++i
)
1880 struct glyph
*g
= s
->first_glyph
+ i
;
1882 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1884 x
+= g
->pixel_width
;
1889 int boff
= s
->font
->baseline_offset
;
1890 struct font
*font
= s
->font
;
1893 if (s
->font
->vertical_centering
)
1894 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
1896 y
= s
->ybase
- boff
;
1898 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1899 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1901 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1902 if (s
->face
->overstrike
)
1903 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1906 if (s
->font
&& FONT_COMPAT (s
->font
)->hfont
)
1907 SelectObject (s
->hdc
, old_font
);
1910 /* Draw the foreground of composite glyph string S. */
1913 x_draw_composite_glyph_string_foreground (s
)
1914 struct glyph_string
*s
;
1919 /* If first glyph of S has a left box line, start drawing the text
1920 of S to the right of that box line. */
1921 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1922 && s
->first_glyph
->left_box_line_p
)
1923 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1927 /* S is a glyph string for a composition. S->gidx is the index of
1928 the first character drawn for glyphs of this composition.
1929 S->gidx == 0 means we are drawing the very first character of
1930 this composition. */
1932 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1933 SetBkColor (s
->hdc
, s
->gc
->background
);
1934 SetBkMode (s
->hdc
, TRANSPARENT
);
1935 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1937 if (s
->font
&& FONT_COMPAT (s
->font
)->hfont
)
1938 old_font
= SelectObject (s
->hdc
, FONT_COMPAT (s
->font
)->hfont
);
1940 /* Draw a rectangle for the composition if the font for the very
1941 first character of the composition could not be loaded. */
1942 if (s
->font_not_found_p
)
1945 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1950 struct font
*font
= s
->font
;
1954 if (s
->cmp
->method
== COMPOSITION_WITH_GLYPH_STRING
)
1956 Lisp_Object gstring
= AREF (XHASH_TABLE (composition_hash_table
)
1958 s
->cmp
->hash_index
* 2);
1961 for (i
= from
= 0; i
< s
->nchars
; i
++)
1963 Lisp_Object g
= LGSTRING_GLYPH (gstring
, i
);
1964 Lisp_Object adjustment
= LGLYPH_ADJUSTMENT (g
);
1965 int xoff
, yoff
, wadjust
;
1967 if (! VECTORP (adjustment
))
1969 width
+= LGLYPH_WIDTH (g
);
1974 font
->driver
->draw (s
, from
, i
, x
, y
, 0);
1977 xoff
= XINT (AREF (adjustment
, 0));
1978 yoff
= XINT (AREF (adjustment
, 1));
1979 wadjust
= XINT (AREF (adjustment
, 2));
1981 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1987 font
->driver
->draw (s
, from
, i
, x
, y
, 0);
1991 for (i
= 0, j
= s
->gidx
; i
< s
->nchars
; i
++, j
++)
1992 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1994 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1995 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1997 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1998 if (s
->face
->overstrike
)
1999 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
2004 if (s
->font
&& FONT_COMPAT (s
->font
)->hfont
)
2005 SelectObject (s
->hdc
, old_font
);
2009 /* Brightness beyond which a color won't have its highlight brightness
2012 Nominally, highlight colors for `3d' faces are calculated by
2013 brightening an object's color by a constant scale factor, but this
2014 doesn't yield good results for dark colors, so for colors who's
2015 brightness is less than this value (on a scale of 0-255) have to
2016 use an additional additive factor.
2018 The value here is set so that the default menu-bar/mode-line color
2019 (grey75) will not have its highlights changed at all. */
2020 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
2023 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
2024 or DELTA. Try a color with RGB values multiplied by FACTOR first.
2025 If this produces the same color as COLOR, try a color where all RGB
2026 values have DELTA added. Return the allocated color in *COLOR.
2027 DISPLAY is the X display, CMAP is the colormap to operate on.
2028 Value is non-zero if successful. */
2031 w32_alloc_lighter_color (f
, color
, factor
, delta
)
2040 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
2043 /* Change RGB values by specified FACTOR. Avoid overflow! */
2044 xassert (factor
>= 0);
2045 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
2046 min (0xff, factor
* GetGValue (*color
)),
2047 min (0xff, factor
* GetBValue (*color
)));
2049 /* Calculate brightness of COLOR. */
2050 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
2051 + GetBValue (*color
)) / 6;
2053 /* We only boost colors that are darker than
2054 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
2055 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
2056 /* Make an additive adjustment to NEW, because it's dark enough so
2057 that scaling by FACTOR alone isn't enough. */
2059 /* How far below the limit this color is (0 - 1, 1 being darker). */
2060 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
2061 /* The additive adjustment. */
2062 int min_delta
= delta
* dimness
* factor
/ 2;
2065 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
2066 max (0, min (0xff, min_delta
- GetGValue (*color
))),
2067 max (0, min (0xff, min_delta
- GetBValue (*color
))));
2069 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
2070 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
2071 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
2075 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
2076 max (0, min (0xff, delta
+ GetGValue (*color
))),
2077 max (0, min (0xff, delta
+ GetBValue (*color
))));
2079 /* TODO: Map to palette and retry with delta if same? */
2080 /* TODO: Free colors (if using palette)? */
2091 /* Set up the foreground color for drawing relief lines of glyph
2092 string S. RELIEF is a pointer to a struct relief containing the GC
2093 with which lines will be drawn. Use a color that is FACTOR or
2094 DELTA lighter or darker than the relief's background which is found
2095 in S->f->output_data.x->relief_background. If such a color cannot
2096 be allocated, use DEFAULT_PIXEL, instead. */
2099 w32_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
2101 struct relief
*relief
;
2104 COLORREF default_pixel
;
2107 struct w32_output
*di
= f
->output_data
.w32
;
2108 unsigned long mask
= GCForeground
;
2110 COLORREF background
= di
->relief_background
;
2111 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
2113 /* TODO: Free colors (if using palette)? */
2115 /* Allocate new color. */
2116 xgcv
.foreground
= default_pixel
;
2118 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
2120 relief
->allocated_p
= 1;
2121 xgcv
.foreground
= relief
->pixel
= pixel
;
2124 if (relief
->gc
== 0)
2126 #if 0 /* TODO: stipple */
2127 xgcv
.stipple
= dpyinfo
->gray
;
2130 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
2133 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
2137 /* Set up colors for the relief lines around glyph string S. */
2140 x_setup_relief_colors (s
)
2141 struct glyph_string
*s
;
2143 struct w32_output
*di
= s
->f
->output_data
.w32
;
2146 if (s
->face
->use_box_color_for_shadows_p
)
2147 color
= s
->face
->box_color
;
2148 else if (s
->first_glyph
->type
== IMAGE_GLYPH
2150 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
2151 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
2153 color
= s
->gc
->background
;
2155 if (di
->white_relief
.gc
== 0
2156 || color
!= di
->relief_background
)
2158 di
->relief_background
= color
;
2159 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
2160 WHITE_PIX_DEFAULT (s
->f
));
2161 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
2162 BLACK_PIX_DEFAULT (s
->f
));
2167 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2168 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2169 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
2170 relief. LEFT_P non-zero means draw a relief on the left side of
2171 the rectangle. RIGHT_P non-zero means draw a relief on the right
2172 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2176 w32_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
2177 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
2179 int left_x
, top_y
, right_x
, bottom_y
, width
;
2180 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
2185 HDC hdc
= get_frame_dc (f
);
2188 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
2190 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
2192 w32_set_clip_rectangle (hdc
, clip_rect
);
2196 for (i
= 0; i
< width
; ++i
)
2197 w32_fill_area (f
, hdc
, gc
.foreground
,
2198 left_x
+ i
* left_p
, top_y
+ i
,
2199 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
2203 for (i
= 0; i
< width
; ++i
)
2204 w32_fill_area (f
, hdc
, gc
.foreground
,
2205 left_x
+ i
, top_y
+ i
, 1,
2206 bottom_y
- top_y
- 2 * i
+ 1);
2209 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
2211 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
2215 for (i
= 0; i
< width
; ++i
)
2216 w32_fill_area (f
, hdc
, gc
.foreground
,
2217 left_x
+ i
* left_p
, bottom_y
- i
,
2218 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
2222 for (i
= 0; i
< width
; ++i
)
2223 w32_fill_area (f
, hdc
, gc
.foreground
,
2224 right_x
- i
, top_y
+ i
+ 1, 1,
2225 bottom_y
- top_y
- 2 * i
- 1);
2227 w32_set_clip_rectangle (hdc
, NULL
);
2229 release_frame_dc (f
, hdc
);
2233 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2234 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2235 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2236 left side of the rectangle. RIGHT_P non-zero means draw a line
2237 on the right side of the rectangle. CLIP_RECT is the clipping
2238 rectangle to use when drawing. */
2241 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2242 left_p
, right_p
, clip_rect
)
2243 struct glyph_string
*s
;
2244 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
2247 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
2250 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
2251 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2256 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
2257 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2261 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
2262 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2267 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
2268 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2271 w32_set_clip_rectangle (s
->hdc
, NULL
);
2275 /* Draw a box around glyph string S. */
2278 x_draw_glyph_string_box (s
)
2279 struct glyph_string
*s
;
2281 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2282 int left_p
, right_p
;
2283 struct glyph
*last_glyph
;
2286 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2287 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2288 : window_box_right (s
->w
, s
->area
));
2290 /* The glyph that may have a right box line. */
2291 last_glyph
= (s
->cmp
|| s
->img
2293 : s
->first_glyph
+ s
->nchars
- 1);
2295 width
= eabs (s
->face
->box_line_width
);
2296 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2298 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2300 : min (last_x
, s
->x
+ s
->background_width
) - 1));
2302 bottom_y
= top_y
+ s
->height
- 1;
2304 left_p
= (s
->first_glyph
->left_box_line_p
2305 || (s
->hl
== DRAW_MOUSE_FACE
2307 || s
->prev
->hl
!= s
->hl
)));
2308 right_p
= (last_glyph
->right_box_line_p
2309 || (s
->hl
== DRAW_MOUSE_FACE
2311 || s
->next
->hl
!= s
->hl
)));
2313 get_glyph_string_clip_rect (s
, &clip_rect
);
2315 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2316 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2317 left_p
, right_p
, &clip_rect
);
2320 x_setup_relief_colors (s
);
2321 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2322 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2327 /* Draw foreground of image glyph string S. */
2330 x_draw_image_foreground (s
)
2331 struct glyph_string
*s
;
2334 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2336 /* If first glyph of S has a left box line, start drawing it to the
2337 right of that line. */
2338 if (s
->face
->box
!= FACE_NO_BOX
2339 && s
->first_glyph
->left_box_line_p
2341 x
+= eabs (s
->face
->box_line_width
);
2343 /* If there is a margin around the image, adjust x- and y-position
2345 if (s
->slice
.x
== 0)
2346 x
+= s
->img
->hmargin
;
2347 if (s
->slice
.y
== 0)
2348 y
+= s
->img
->vmargin
;
2354 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2355 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2356 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2357 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2358 SetBkColor (compat_hdc
, RGB (255, 255, 255));
2359 SetTextColor (s
->hdc
, RGB (0, 0, 0));
2360 x_set_glyph_string_clipping (s
);
2364 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
2365 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2367 SetTextColor (s
->hdc
, RGB (255, 255, 255));
2368 SetBkColor (s
->hdc
, RGB (0, 0, 0));
2370 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2371 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2372 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2373 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2374 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2375 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2377 SelectObject (mask_dc
, mask_orig_obj
);
2382 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2383 SetBkColor (s
->hdc
, s
->gc
->background
);
2385 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2386 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2388 /* When the image has a mask, we can expect that at
2389 least part of a mouse highlight or a block cursor will
2390 be visible. If the image doesn't have a mask, make
2391 a block cursor visible by drawing a rectangle around
2392 the image. I believe it's looking better if we do
2393 nothing here for mouse-face. */
2394 if (s
->hl
== DRAW_CURSOR
)
2396 int r
= s
->img
->relief
;
2398 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
2399 s
->slice
.width
+ r
*2 - 1,
2400 s
->slice
.height
+ r
*2 - 1);
2404 w32_set_clip_rectangle (s
->hdc
, NULL
);
2405 SelectObject (s
->hdc
, orig_brush
);
2406 DeleteObject (fg_brush
);
2407 SelectObject (compat_hdc
, orig_obj
);
2408 DeleteDC (compat_hdc
);
2411 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
2412 s
->slice
.width
- 1, s
->slice
.height
- 1);
2414 RestoreDC (s
->hdc
,-1);
2418 /* Draw a relief around the image glyph string S. */
2421 x_draw_image_relief (s
)
2422 struct glyph_string
*s
;
2424 int x0
, y0
, x1
, y1
, thick
, raised_p
;
2427 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2429 /* If first glyph of S has a left box line, start drawing it to the
2430 right of that line. */
2431 if (s
->face
->box
!= FACE_NO_BOX
2432 && s
->first_glyph
->left_box_line_p
2434 x
+= eabs (s
->face
->box_line_width
);
2436 /* If there is a margin around the image, adjust x- and y-position
2438 if (s
->slice
.x
== 0)
2439 x
+= s
->img
->hmargin
;
2440 if (s
->slice
.y
== 0)
2441 y
+= s
->img
->vmargin
;
2443 if (s
->hl
== DRAW_IMAGE_SUNKEN
2444 || s
->hl
== DRAW_IMAGE_RAISED
)
2446 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2447 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2451 thick
= eabs (s
->img
->relief
);
2452 raised_p
= s
->img
->relief
> 0;
2457 x1
= x
+ s
->slice
.width
+ thick
- 1;
2458 y1
= y
+ s
->slice
.height
+ thick
- 1;
2460 x_setup_relief_colors (s
);
2461 get_glyph_string_clip_rect (s
, &r
);
2462 w32_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2464 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2466 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2471 /* Draw the foreground of image glyph string S to PIXMAP. */
2474 w32_draw_image_foreground_1 (s
, pixmap
)
2475 struct glyph_string
*s
;
2478 HDC hdc
= CreateCompatibleDC (s
->hdc
);
2479 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
2481 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2483 /* If first glyph of S has a left box line, start drawing it to the
2484 right of that line. */
2485 if (s
->face
->box
!= FACE_NO_BOX
2486 && s
->first_glyph
->left_box_line_p
2488 x
+= eabs (s
->face
->box_line_width
);
2490 /* If there is a margin around the image, adjust x- and y-position
2492 if (s
->slice
.x
== 0)
2493 x
+= s
->img
->hmargin
;
2494 if (s
->slice
.y
== 0)
2495 y
+= s
->img
->vmargin
;
2499 HDC compat_hdc
= CreateCompatibleDC (hdc
);
2500 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2501 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
2502 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2506 HDC mask_dc
= CreateCompatibleDC (hdc
);
2507 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2509 SetTextColor (hdc
, RGB (0, 0, 0));
2510 SetBkColor (hdc
, RGB (255, 255, 255));
2511 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2512 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2513 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2514 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2515 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2516 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2518 SelectObject (mask_dc
, mask_orig_obj
);
2523 SetTextColor (hdc
, s
->gc
->foreground
);
2524 SetBkColor (hdc
, s
->gc
->background
);
2526 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2527 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2529 /* When the image has a mask, we can expect that at
2530 least part of a mouse highlight or a block cursor will
2531 be visible. If the image doesn't have a mask, make
2532 a block cursor visible by drawing a rectangle around
2533 the image. I believe it's looking better if we do
2534 nothing here for mouse-face. */
2535 if (s
->hl
== DRAW_CURSOR
)
2537 int r
= s
->img
->relief
;
2539 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2540 s
->slice
.width
+ r
*2 - 1,
2541 s
->slice
.height
+ r
*2 - 1);
2545 SelectObject (hdc
, orig_brush
);
2546 DeleteObject (fg_brush
);
2547 SelectObject (compat_hdc
, orig_obj
);
2548 DeleteDC (compat_hdc
);
2551 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2552 s
->slice
.width
- 1, s
->slice
.height
- 1);
2554 SelectObject (hdc
, orig_hdc_obj
);
2559 /* Draw part of the background of glyph string S. X, Y, W, and H
2560 give the rectangle to draw. */
2563 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
2564 struct glyph_string
*s
;
2567 #if 0 /* TODO: stipple */
2570 /* Fill background with a stipple pattern. */
2571 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2572 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2573 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2577 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2581 /* Draw image glyph string S.
2584 s->x +-------------------------
2587 | +-------------------------
2590 | | +-------------------
2596 x_draw_image_glyph_string (s
)
2597 struct glyph_string
*s
;
2600 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2601 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2605 height
= s
->height
- 2 * box_line_vwidth
;
2607 /* Fill background with face under the image. Do it only if row is
2608 taller than image or if image has a clip mask to reduce
2610 s
->stippled_p
= s
->face
->stipple
!= 0;
2611 if (height
> s
->slice
.height
2615 || s
->img
->pixmap
== 0
2616 || s
->width
!= s
->background_width
)
2619 if (s
->first_glyph
->left_box_line_p
2621 x
+= box_line_hwidth
;
2624 if (s
->slice
.y
== 0)
2625 y
+= box_line_vwidth
;
2627 #if 0 /* TODO: figure out if we need to do this on Windows. */
2630 /* Create a pixmap as large as the glyph string. Fill it
2631 with the background color. Copy the image to it, using
2632 its mask. Copy the temporary pixmap to the display. */
2633 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2634 int depth
= DefaultDepthOfScreen (screen
);
2636 /* Create a pixmap as large as the glyph string. */
2637 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2638 s
->background_width
,
2641 /* Don't clip in the following because we're working on the
2643 XSetClipMask (s
->display
, s
->gc
, None
);
2645 /* Fill the pixmap with the background color/stipple. */
2648 /* Fill background with a stipple pattern. */
2649 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2650 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2651 0, 0, s
->background_width
, s
->height
);
2652 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2657 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2659 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2660 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2661 0, 0, s
->background_width
, s
->height
);
2662 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2667 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2669 s
->background_filled_p
= 1;
2672 /* Draw the foreground. */
2675 w32_draw_image_foreground_1 (s
, pixmap
);
2676 x_set_glyph_string_clipping (s
);
2678 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2679 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2680 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2681 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2683 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2684 SetBkColor (s
->hdc
, s
->gc
->background
);
2685 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2686 compat_hdc
, 0, 0, SRCCOPY
);
2688 SelectObject (s
->hdc
, orig_brush
);
2689 DeleteObject (fg_brush
);
2690 SelectObject (compat_hdc
, orig_obj
);
2691 DeleteDC (compat_hdc
);
2693 DeleteObject (pixmap
);
2697 x_draw_image_foreground (s
);
2699 /* If we must draw a relief around the image, do it. */
2701 || s
->hl
== DRAW_IMAGE_RAISED
2702 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2703 x_draw_image_relief (s
);
2707 /* Draw stretch glyph string S. */
2710 x_draw_stretch_glyph_string (s
)
2711 struct glyph_string
*s
;
2713 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2715 if (s
->hl
== DRAW_CURSOR
2716 && !x_stretch_cursor_p
)
2718 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2719 as wide as the stretch glyph. */
2720 int width
, background_width
= s
->background_width
;
2721 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2725 background_width
-= left_x
- x
;
2728 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2731 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2733 /* Clear rest using the GC of the original non-cursor face. */
2734 if (width
< background_width
)
2736 XGCValues
*gc
= s
->face
->gc
;
2738 int w
= background_width
- width
, h
= s
->height
;
2743 if (s
->row
->mouse_face_p
2744 && cursor_in_mouse_face_p (s
->w
))
2746 x_set_mouse_face_gc (s
);
2752 get_glyph_string_clip_rect (s
, &r
);
2753 w32_set_clip_rectangle (hdc
, &r
);
2755 #if 0 /* TODO: stipple */
2756 if (s
->face
->stipple
)
2758 /* Fill background with a stipple pattern. */
2759 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2760 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2761 XSetFillStyle (s
->display
, gc
, FillSolid
);
2766 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2770 else if (!s
->background_filled_p
)
2772 int background_width
= s
->background_width
;
2773 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2775 /* Don't draw into left margin, fringe or scrollbar area
2776 except for header line and mode line. */
2777 if (x
< left_x
&& !s
->row
->mode_line_p
)
2779 background_width
-= left_x
- x
;
2782 if (background_width
> 0)
2783 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2786 s
->background_filled_p
= 1;
2790 /* Draw glyph string S. */
2793 x_draw_glyph_string (s
)
2794 struct glyph_string
*s
;
2796 int relief_drawn_p
= 0;
2798 /* If S draws into the background of its successor, draw the
2799 background of the successor first so that S can draw into it.
2800 This makes S->next use XDrawString instead of XDrawImageString. */
2801 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2804 struct glyph_string
*next
;
2805 for (width
= 0, next
= s
->next
; next
;
2806 width
+= next
->width
, next
= next
->next
)
2807 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2809 x_set_glyph_string_gc (next
);
2810 x_set_glyph_string_clipping (next
);
2811 x_draw_glyph_string_background (next
, 1);
2812 next
->num_clips
= 0;
2816 /* Set up S->gc, set clipping and draw S. */
2817 x_set_glyph_string_gc (s
);
2819 /* Draw relief (if any) in advance for char/composition so that the
2820 glyph string can be drawn over it. */
2821 if (!s
->for_overlaps
2822 && s
->face
->box
!= FACE_NO_BOX
2823 && (s
->first_glyph
->type
== CHAR_GLYPH
2824 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2827 x_set_glyph_string_clipping (s
);
2828 x_draw_glyph_string_background (s
, 1);
2829 x_draw_glyph_string_box (s
);
2830 x_set_glyph_string_clipping (s
);
2833 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2835 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2836 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2837 /* We must clip just this glyph. left_overhang part has already
2838 drawn when s->prev was drawn, and right_overhang part will be
2839 drawn later when s->next is drawn. */
2840 x_set_glyph_string_clipping_exactly (s
, s
);
2842 x_set_glyph_string_clipping (s
);
2844 switch (s
->first_glyph
->type
)
2847 x_draw_image_glyph_string (s
);
2851 x_draw_stretch_glyph_string (s
);
2855 if (s
->for_overlaps
)
2856 s
->background_filled_p
= 1;
2858 x_draw_glyph_string_background (s
, 0);
2859 x_draw_glyph_string_foreground (s
);
2862 case COMPOSITE_GLYPH
:
2863 if (s
->for_overlaps
|| s
->gidx
> 0)
2864 s
->background_filled_p
= 1;
2866 x_draw_glyph_string_background (s
, 1);
2867 x_draw_composite_glyph_string_foreground (s
);
2874 if (!s
->for_overlaps
)
2876 /* Draw underline. */
2877 if (s
->face
->underline_p
)
2879 unsigned long thickness
, position
;
2882 if (s
->prev
&& s
->prev
->face
->underline_p
)
2884 /* We use the same underline style as the previous one. */
2885 thickness
= s
->prev
->underline_thickness
;
2886 position
= s
->prev
->underline_position
;
2890 /* Get the underline thickness. Default is 1 pixel. */
2891 if (s
->font
&& s
->font
->underline_thickness
> 0)
2892 thickness
= s
->font
->underline_thickness
;
2895 if (x_underline_at_descent_line
)
2896 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2899 /* Get the underline position. This is the recommended
2900 vertical offset in pixels from the baseline to the top of
2901 the underline. This is a signed value according to the
2902 specs, and its default is
2904 ROUND ((maximum_descent) / 2), with
2905 ROUND (x) = floor (x + 0.5) */
2907 if (x_use_underline_position_properties
2908 && s
->font
&& s
->font
->underline_position
>= 0)
2909 position
= s
->font
->underline_position
;
2911 position
= (s
->font
->descent
+ 1) / 2;
2913 position
= max (position
, underline_minimum_offset
);
2915 /* Check the sanity of thickness and position. We should
2916 avoid drawing underline out of the current line area. */
2917 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2918 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2919 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2920 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2921 s
->underline_thickness
= thickness
;
2922 s
->underline_position
=position
;
2923 y
= s
->ybase
+ position
;
2924 if (s
->face
->underline_defaulted_p
)
2926 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2927 y
, s
->background_width
, 1);
2931 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2932 y
, s
->background_width
, 1);
2935 /* Draw overline. */
2936 if (s
->face
->overline_p
)
2938 unsigned long dy
= 0, h
= 1;
2940 if (s
->face
->overline_color_defaulted_p
)
2942 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2943 s
->y
+ dy
, s
->background_width
, h
);
2947 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2948 s
->y
+ dy
, s
->background_width
, h
);
2952 /* Draw strike-through. */
2953 if (s
->face
->strike_through_p
2954 && (FONT_COMPAT (s
->font
)->bdf
2955 || !FONT_COMPAT (s
->font
)->tm
.tmStruckOut
))
2957 unsigned long h
= 1;
2958 unsigned long dy
= (s
->height
- h
) / 2;
2960 if (s
->face
->strike_through_color_defaulted_p
)
2962 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2967 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2968 s
->y
+ dy
, s
->width
, h
);
2972 /* Draw relief if not yet drawn. */
2973 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2974 x_draw_glyph_string_box (s
);
2978 struct glyph_string
*prev
;
2980 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2981 if (prev
->hl
!= s
->hl
2982 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2984 /* As prev was drawn while clipped to its own area, we
2985 must draw the right_overhang part using s->hl now. */
2986 enum draw_glyphs_face save
= prev
->hl
;
2989 x_set_glyph_string_gc (prev
);
2990 x_set_glyph_string_clipping_exactly (s
, prev
);
2991 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2992 x_draw_glyph_string_foreground (prev
);
2994 x_draw_composite_glyph_string_foreground (prev
);
2995 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2997 prev
->num_clips
= 0;
3003 struct glyph_string
*next
;
3005 for (next
= s
->next
; next
; next
= next
->next
)
3006 if (next
->hl
!= s
->hl
3007 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
3009 /* As next will be drawn while clipped to its own area,
3010 we must draw the left_overhang part using s->hl now. */
3011 enum draw_glyphs_face save
= next
->hl
;
3014 x_set_glyph_string_gc (next
);
3015 x_set_glyph_string_clipping_exactly (s
, next
);
3016 if (next
->first_glyph
->type
== CHAR_GLYPH
)
3017 x_draw_glyph_string_foreground (next
);
3019 x_draw_composite_glyph_string_foreground (next
);
3020 w32_set_clip_rectangle (next
->hdc
, NULL
);
3022 next
->num_clips
= 0;
3027 /* Reset clipping. */
3028 w32_set_clip_rectangle (s
->hdc
, NULL
);
3033 /* Shift display to make room for inserted glyphs. */
3036 w32_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
3038 int x
, y
, width
, height
, shift_by
;
3042 hdc
= get_frame_dc (f
);
3043 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
3044 hdc
, x
, y
, SRCCOPY
);
3046 release_frame_dc (f
, hdc
);
3050 /* Delete N glyphs at the nominal cursor position. Not implemented
3054 x_delete_glyphs (f
, n
)
3058 if (! FRAME_W32_P (f
))
3065 /* Clear entire frame. If updating_frame is non-null, clear that
3066 frame. Otherwise clear the selected frame. */
3069 x_clear_frame (struct frame
*f
)
3071 if (! FRAME_W32_P (f
))
3074 /* Clearing the frame will erase any cursor, so mark them all as no
3076 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3077 output_cursor
.hpos
= output_cursor
.vpos
= 0;
3078 output_cursor
.x
= -1;
3080 /* We don't set the output cursor here because there will always
3081 follow an explicit cursor_to. */
3084 w32_clear_window (f
);
3086 /* We have to clear the scroll bars, too. If we have changed
3087 colors or something like that, then they should be notified. */
3088 x_scroll_bar_clear (f
);
3094 /* Make audible bell. */
3097 w32_ring_bell (struct frame
*f
)
3101 if (FRAME_W32_P (f
) && visible_bell
)
3104 HWND hwnd
= FRAME_W32_WINDOW (f
);
3106 for (i
= 0; i
< 5; i
++)
3108 FlashWindow (hwnd
, TRUE
);
3111 FlashWindow (hwnd
, FALSE
);
3114 w32_sys_ring_bell (f
);
3120 /* Specify how many text lines, from the top of the window,
3121 should be affected by insert-lines and delete-lines operations.
3122 This, and those operations, are used only within an update
3123 that is bounded by calls to x_update_begin and x_update_end. */
3126 w32_set_terminal_window (n
)
3129 /* This function intentionally left blank. */
3133 /***********************************************************************
3135 ***********************************************************************/
3137 /* Perform an insert-lines or delete-lines operation, inserting N
3138 lines or deleting -N lines at vertical position VPOS. */
3141 x_ins_del_lines (f
, vpos
, n
)
3145 if (! FRAME_W32_P (f
))
3152 /* Scroll part of the display as described by RUN. */
3155 x_scroll_run (w
, run
)
3159 struct frame
*f
= XFRAME (w
->frame
);
3160 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3161 HWND hwnd
= FRAME_W32_WINDOW (f
);
3164 /* Get frame-relative bounding box of the text display area of W,
3165 without mode lines. Include in this box the left and right
3167 window_box (w
, -1, &x
, &y
, &width
, &height
);
3169 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3170 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3171 bottom_y
= y
+ height
;
3175 /* Scrolling up. Make sure we don't copy part of the mode
3176 line at the bottom. */
3177 if (from_y
+ run
->height
> bottom_y
)
3178 height
= bottom_y
- from_y
;
3180 height
= run
->height
;
3181 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
3185 /* Scolling down. Make sure we don't copy over the mode line.
3187 if (to_y
+ run
->height
> bottom_y
)
3188 height
= bottom_y
- to_y
;
3190 height
= run
->height
;
3191 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
3196 /* Cursor off. Will be switched on again in x_update_window_end. */
3203 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
3204 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
3206 from
.left
= to
.left
= x
;
3207 from
.right
= to
.right
= x
+ width
;
3209 from
.bottom
= from_y
+ height
;
3211 to
.bottom
= bottom_y
;
3213 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
3214 NULL
, SW_INVALIDATE
);
3216 /* Combine this with what we expect to be dirty. This covers the
3217 case where not all of the region we expect is actually dirty. */
3218 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
3220 /* If the dirty region is not what we expected, redraw the entire frame. */
3221 if (!EqualRgn (combined
, expect_dirty
))
3222 SET_FRAME_GARBAGED (f
);
3224 DeleteObject (dirty
);
3225 DeleteObject (combined
);
3229 DeleteObject (expect_dirty
);
3234 /***********************************************************************
3236 ***********************************************************************/
3242 x_update_cursor (f
, 1);
3246 frame_unhighlight (f
)
3249 x_update_cursor (f
, 1);
3252 /* The focus has changed. Update the frames as necessary to reflect
3253 the new situation. Note that we can't change the selected frame
3254 here, because the Lisp code we are interrupting might become confused.
3255 Each event gets marked with the frame in which it occurred, so the
3256 Lisp code can tell when the switch took place by examining the events. */
3259 x_new_focus_frame (dpyinfo
, frame
)
3260 struct w32_display_info
*dpyinfo
;
3261 struct frame
*frame
;
3263 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
3265 if (frame
!= dpyinfo
->w32_focus_frame
)
3267 /* Set this before calling other routines, so that they see
3268 the correct value of w32_focus_frame. */
3269 dpyinfo
->w32_focus_frame
= frame
;
3271 if (old_focus
&& old_focus
->auto_lower
)
3272 x_lower_frame (old_focus
);
3274 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
3275 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
3277 pending_autoraise_frame
= 0;
3280 x_frame_rehighlight (dpyinfo
);
3284 /* Handle FocusIn and FocusOut state changes for FRAME.
3285 If FRAME has focus and there exists more than one frame, puts
3286 a FOCUS_IN_EVENT into *BUFP. */
3289 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
)
3292 struct w32_display_info
*dpyinfo
;
3293 struct frame
*frame
;
3294 struct input_event
*bufp
;
3296 if (type
== WM_SETFOCUS
)
3298 if (dpyinfo
->w32_focus_event_frame
!= frame
)
3300 x_new_focus_frame (dpyinfo
, frame
);
3301 dpyinfo
->w32_focus_event_frame
= frame
;
3303 /* Don't stop displaying the initial startup message
3304 for a switch-frame event we don't need. */
3305 if (NILP (Vterminal_frame
)
3306 && CONSP (Vframe_list
)
3307 && !NILP (XCDR (Vframe_list
)))
3309 bufp
->kind
= FOCUS_IN_EVENT
;
3310 XSETFRAME (bufp
->frame_or_window
, frame
);
3314 frame
->output_data
.x
->focus_state
|= state
;
3316 /* TODO: IME focus? */
3318 else if (type
== WM_KILLFOCUS
)
3320 frame
->output_data
.x
->focus_state
&= ~state
;
3322 if (dpyinfo
->w32_focus_event_frame
== frame
)
3324 dpyinfo
->w32_focus_event_frame
= 0;
3325 x_new_focus_frame (dpyinfo
, 0);
3328 /* TODO: IME focus? */
3333 /* The focus may have changed. Figure out if it is a real focus change,
3334 by checking both FocusIn/Out and Enter/LeaveNotify events.
3336 Returns FOCUS_IN_EVENT event in *BUFP. */
3339 w32_detect_focus_change (dpyinfo
, event
, bufp
)
3340 struct w32_display_info
*dpyinfo
;
3342 struct input_event
*bufp
;
3344 struct frame
*frame
;
3346 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
3350 /* On w32, this is only called from focus events, so no switch needed. */
3351 x_focus_changed (event
->msg
.message
,
3352 (event
->msg
.message
== WM_KILLFOCUS
?
3353 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3354 dpyinfo
, frame
, bufp
);
3358 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3361 x_mouse_leave (dpyinfo
)
3362 struct w32_display_info
*dpyinfo
;
3364 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
3367 /* The focus has changed, or we have redirected a frame's focus to
3368 another frame (this happens when a frame uses a surrogate
3369 mini-buffer frame). Shift the highlight as appropriate.
3371 The FRAME argument doesn't necessarily have anything to do with which
3372 frame is being highlighted or un-highlighted; we only use it to find
3373 the appropriate X display info. */
3376 w32_frame_rehighlight (frame
)
3377 struct frame
*frame
;
3379 if (! FRAME_W32_P (frame
))
3381 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
3385 x_frame_rehighlight (dpyinfo
)
3386 struct w32_display_info
*dpyinfo
;
3388 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3390 if (dpyinfo
->w32_focus_frame
)
3392 dpyinfo
->x_highlight_frame
3393 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
3394 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
3395 : dpyinfo
->w32_focus_frame
);
3396 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3398 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
3399 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
3403 dpyinfo
->x_highlight_frame
= 0;
3405 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3408 frame_unhighlight (old_highlight
);
3409 if (dpyinfo
->x_highlight_frame
)
3410 frame_highlight (dpyinfo
->x_highlight_frame
);
3414 /* Keyboard processing - modifier keys, etc. */
3416 /* Convert a keysym to its name. */
3419 x_get_keysym_name (keysym
)
3422 /* Make static so we can always return it */
3423 static char value
[100];
3426 GetKeyNameText (keysym
, value
, 100);
3434 /* Mouse clicks and mouse movement. Rah. */
3436 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
3437 the state in PUP. XBUTTON provides extra information for extended mouse
3438 button messages. Returns FALSE if unable to parse the message. */
3440 parse_button (message
, xbutton
, pbutton
, pup
)
3451 case WM_LBUTTONDOWN
:
3459 case WM_MBUTTONDOWN
:
3460 if (NILP (Vw32_swap_mouse_buttons
))
3467 if (NILP (Vw32_swap_mouse_buttons
))
3473 case WM_RBUTTONDOWN
:
3474 if (NILP (Vw32_swap_mouse_buttons
))
3481 if (NILP (Vw32_swap_mouse_buttons
))
3487 case WM_XBUTTONDOWN
:
3488 button
= xbutton
+ 2;
3492 button
= xbutton
+ 2;
3500 if (pbutton
) *pbutton
= button
;
3506 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3508 If the event is a button press, then note that we have grabbed
3512 construct_mouse_click (result
, msg
, f
)
3513 struct input_event
*result
;
3520 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3523 /* Make the event type NO_EVENT; we'll change that when we decide
3525 result
->kind
= MOUSE_CLICK_EVENT
;
3526 result
->code
= button
;
3527 result
->timestamp
= msg
->msg
.time
;
3528 result
->modifiers
= (msg
->dwModifiers
3533 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3534 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3535 XSETFRAME (result
->frame_or_window
, f
);
3541 construct_mouse_wheel (result
, msg
, f
)
3542 struct input_event
*result
;
3549 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3552 result
->timestamp
= msg
->msg
.time
;
3554 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3555 forward, away from the user (up); a negative value indicates that
3556 the wheel was rotated backward, toward the user (down). */
3557 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3559 /* The up and down modifiers indicate if the wheel was rotated up or
3560 down based on WHEEL_DELTA value. */
3561 result
->modifiers
= (msg
->dwModifiers
3562 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3564 /* With multiple monitors, we can legitimately get negative
3565 coordinates, so cast to short to interpret them correctly. */
3566 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3567 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3568 ScreenToClient (msg
->msg
.hwnd
, &p
);
3569 XSETINT (result
->x
, p
.x
);
3570 XSETINT (result
->y
, p
.y
);
3571 XSETFRAME (result
->frame_or_window
, f
);
3577 construct_drag_n_drop (result
, msg
, f
)
3578 struct input_event
*result
;
3590 result
->kind
= DRAG_N_DROP_EVENT
;
3592 result
->timestamp
= msg
->msg
.time
;
3593 result
->modifiers
= msg
->dwModifiers
;
3595 hdrop
= (HDROP
) msg
->msg
.wParam
;
3596 DragQueryPoint (hdrop
, &p
);
3599 p
.x
= LOWORD (msg
->msg
.lParam
);
3600 p
.y
= HIWORD (msg
->msg
.lParam
);
3601 ScreenToClient (msg
->msg
.hwnd
, &p
);
3604 XSETINT (result
->x
, p
.x
);
3605 XSETINT (result
->y
, p
.y
);
3607 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3610 for (i
= 0; i
< num_files
; i
++)
3612 len
= DragQueryFile (hdrop
, i
, NULL
, 0);
3615 name
= alloca (len
+ 1);
3616 DragQueryFile (hdrop
, i
, name
, len
+ 1);
3617 files
= Fcons (DECODE_FILE (build_string (name
)), files
);
3622 XSETFRAME (frame
, f
);
3623 result
->frame_or_window
= frame
;
3624 result
->arg
= files
;
3629 /* Function to report a mouse movement to the mainstream Emacs code.
3630 The input handler calls this.
3632 We have received a mouse movement event, which is given in *event.
3633 If the mouse is over a different glyph than it was last time, tell
3634 the mainstream emacs code by setting mouse_moved. If not, ask for
3635 another motion event, so we can check again the next time it moves. */
3637 static MSG last_mouse_motion_event
;
3638 static Lisp_Object last_mouse_motion_frame
;
3641 note_mouse_movement (frame
, msg
)
3645 int mouse_x
= LOWORD (msg
->lParam
);
3646 int mouse_y
= HIWORD (msg
->lParam
);
3648 last_mouse_movement_time
= msg
->time
;
3649 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
3650 XSETFRAME (last_mouse_motion_frame
, frame
);
3652 if (!FRAME_X_OUTPUT (frame
))
3655 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3657 frame
->mouse_moved
= 1;
3658 last_mouse_scroll_bar
= Qnil
;
3659 note_mouse_highlight (frame
, -1, -1);
3660 last_mouse_glyph_frame
= 0;
3664 /* Has the mouse moved off the glyph it was on at the last sighting? */
3665 if (frame
!= last_mouse_glyph_frame
3666 || mouse_x
< last_mouse_glyph
.left
3667 || mouse_x
>= last_mouse_glyph
.right
3668 || mouse_y
< last_mouse_glyph
.top
3669 || mouse_y
>= last_mouse_glyph
.bottom
)
3671 frame
->mouse_moved
= 1;
3672 last_mouse_scroll_bar
= Qnil
;
3673 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3674 /* Remember the mouse position here, as w32_mouse_position only
3675 gets called when mouse tracking is enabled but we also need
3676 to keep track of the mouse for help_echo and highlighting at
3678 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, &last_mouse_glyph
);
3679 last_mouse_glyph_frame
= frame
;
3687 /************************************************************************
3689 ************************************************************************/
3691 static struct scroll_bar
*x_window_to_scroll_bar ();
3692 static void x_scroll_bar_report_motion ();
3693 static void x_check_fullscreen
P_ ((struct frame
*));
3696 redo_mouse_highlight ()
3698 if (!NILP (last_mouse_motion_frame
)
3699 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3700 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3701 LOWORD (last_mouse_motion_event
.lParam
),
3702 HIWORD (last_mouse_motion_event
.lParam
));
3706 w32_define_cursor (window
, cursor
)
3710 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3712 /* Return the current position of the mouse.
3713 *fp should be a frame which indicates which display to ask about.
3715 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3716 and *part to the frame, window, and scroll bar part that the mouse
3717 is over. Set *x and *y to the portion and whole of the mouse's
3718 position on the scroll bar.
3720 If the mouse movement started elsewhere, set *fp to the frame the
3721 mouse is on, *bar_window to nil, and *x and *y to the character cell
3724 Set *time to the server time-stamp for the time at which the mouse
3725 was at this position.
3727 Don't store anything if we don't have a valid set of values to report.
3729 This clears the mouse_moved flag, so we can wait for the next mouse
3733 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3736 Lisp_Object
*bar_window
;
3737 enum scroll_bar_part
*part
;
3739 unsigned long *time
;
3745 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3746 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3751 Lisp_Object frame
, tail
;
3753 /* Clear the mouse-moved flag for every frame on this display. */
3754 FOR_EACH_FRAME (tail
, frame
)
3755 XFRAME (frame
)->mouse_moved
= 0;
3757 last_mouse_scroll_bar
= Qnil
;
3761 /* Now we have a position on the root; find the innermost window
3762 containing the pointer. */
3764 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3765 && FRAME_LIVE_P (last_mouse_frame
))
3767 /* If mouse was grabbed on a frame, give coords for that frame
3768 even if the mouse is now outside it. */
3769 f1
= last_mouse_frame
;
3773 /* Is window under mouse one of our frames? */
3774 f1
= x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
3775 WindowFromPoint (pt
));
3778 /* If not, is it one of our scroll bars? */
3781 struct scroll_bar
*bar
3782 = x_window_to_scroll_bar (WindowFromPoint (pt
));
3786 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3790 if (f1
== 0 && insist
> 0)
3791 f1
= SELECTED_FRAME ();
3795 /* Ok, we found a frame. Store all the values.
3796 last_mouse_glyph is a rectangle used to reduce the
3797 generation of mouse events. To not miss any motion
3798 events, we must divide the frame into rectangles of the
3799 size of the smallest character that could be displayed
3800 on it, i.e. into the same rectangles that matrices on
3801 the frame are divided into. */
3803 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3804 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &last_mouse_glyph
);
3805 last_mouse_glyph_frame
= f1
;
3812 *time
= last_mouse_movement_time
;
3821 /***********************************************************************
3823 ***********************************************************************/
3825 /* Handle mouse button event on the tool-bar of frame F, at
3826 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
3830 w32_handle_tool_bar_click (f
, button_event
)
3832 struct input_event
*button_event
;
3834 int x
= XFASTINT (button_event
->x
);
3835 int y
= XFASTINT (button_event
->y
);
3837 if (button_event
->modifiers
& down_modifier
)
3838 handle_tool_bar_click (f
, x
, y
, 1, 0);
3840 handle_tool_bar_click (f
, x
, y
, 0,
3841 button_event
->modifiers
& ~up_modifier
);
3846 /***********************************************************************
3848 ***********************************************************************/
3850 /* Scroll bar support. */
3852 /* Given a window ID, find the struct scroll_bar which manages it.
3853 This can be called in GC, so we have to make sure to strip off mark
3856 static struct scroll_bar
*
3857 x_window_to_scroll_bar (window_id
)
3862 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3864 Lisp_Object frame
, bar
, condemned
;
3866 frame
= XCAR (tail
);
3867 /* All elements of Vframe_list should be frames. */
3868 if (! FRAMEP (frame
))
3871 /* Scan this frame's scroll bar list for a scroll bar with the
3873 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3874 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3875 /* This trick allows us to search both the ordinary and
3876 condemned scroll bar lists with one loop. */
3877 ! NILP (bar
) || (bar
= condemned
,
3880 bar
= XSCROLL_BAR (bar
)->next
)
3881 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
3882 return XSCROLL_BAR (bar
);
3890 /* Set the thumb size and position of scroll bar BAR. We are currently
3891 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3894 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
)
3895 struct scroll_bar
*bar
;
3896 int portion
, position
, whole
;
3898 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3899 /* We use the whole scroll-bar height in the calculations below, to
3900 avoid strange effects like scrolling backwards when just clicking
3901 on the handle (without moving it). */
3902 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
))
3903 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3904 int sb_page
, sb_pos
;
3905 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
3908 /* We used to change the nPage setting while dragging the handle,
3909 but that had very strange effects (such as scrolling backwards
3910 while dragging downwards).
3912 Now, we don't change the nPage setting while dragging unless we
3913 get near to the end of the buffer, in which case we often have to
3914 resize the handle to "go all the way". */
3920 si
.cbSize
= sizeof (si
);
3921 si
.fMask
= SIF_POS
| SIF_PAGE
;
3922 GetScrollInfo(w
, SB_CTL
, &si
);
3923 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3931 /* Position scroll bar at rock bottom if the bottom of the
3932 buffer is visible. This avoids shinking the thumb away
3933 to nothing if it is held at the bottom of the buffer. */
3934 if (position
+ portion
>= whole
&& !draggingp
)
3936 sb_page
= range
* (whole
- position
) / whole
;
3941 sb_pos
= position
* range
/ whole
;
3942 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3951 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3955 si
.cbSize
= sizeof (si
);
3956 si
.fMask
= SIF_PAGE
| SIF_POS
;
3960 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3966 /************************************************************************
3967 Scroll bars, general
3968 ************************************************************************/
3971 my_create_scrollbar (f
, bar
)
3973 struct scroll_bar
* bar
;
3975 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3976 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
3980 /*#define ATTACH_THREADS*/
3983 my_show_window (FRAME_PTR f
, HWND hwnd
, int how
)
3985 #ifndef ATTACH_THREADS
3986 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3987 (WPARAM
) hwnd
, (LPARAM
) how
);
3989 return ShowWindow (hwnd
, how
);
3994 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3995 int x
, int y
, int cx
, int cy
, UINT flags
)
3997 #ifndef ATTACH_THREADS
3999 pos
.hwndInsertAfter
= hwndAfter
;
4005 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
4007 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
4012 my_set_focus (f
, hwnd
)
4016 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
4021 my_set_foreground_window (hwnd
)
4024 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
4029 my_destroy_window (f
, hwnd
)
4033 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
4037 /* Create a scroll bar and return the scroll bar vector for it. W is
4038 the Emacs window on which to create the scroll bar. TOP, LEFT,
4039 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
4042 static struct scroll_bar
*
4043 x_scroll_bar_create (w
, top
, left
, width
, height
)
4045 int top
, left
, width
, height
;
4047 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4050 struct scroll_bar
*bar
4051 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
4055 XSETWINDOW (bar
->window
, w
);
4056 XSETINT (bar
->top
, top
);
4057 XSETINT (bar
->left
, left
);
4058 XSETINT (bar
->width
, width
);
4059 XSETINT (bar
->height
, height
);
4060 XSETINT (bar
->start
, 0);
4061 XSETINT (bar
->end
, 0);
4062 bar
->dragging
= Qnil
;
4063 bar
->fringe_extended_p
= Qnil
;
4065 /* Requires geometry to be set before call to create the real window */
4067 hwnd
= my_create_scrollbar (f
, bar
);
4069 si
.cbSize
= sizeof (si
);
4072 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
4073 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4077 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
4079 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
4081 /* Add bar to its frame's list of scroll bars. */
4082 bar
->next
= FRAME_SCROLL_BARS (f
);
4084 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4085 if (! NILP (bar
->next
))
4086 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4094 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
4098 x_scroll_bar_remove (bar
)
4099 struct scroll_bar
*bar
;
4101 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4105 /* Destroy the window. */
4106 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
4108 /* Disassociate this scroll bar from its window. */
4109 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
4114 /* Set the handle of the vertical scroll bar for WINDOW to indicate
4115 that we are displaying PORTION characters out of a total of WHOLE
4116 characters, starting at POSITION. If WINDOW has no scroll bar,
4119 w32_set_vertical_scroll_bar (w
, portion
, whole
, position
)
4121 int portion
, whole
, position
;
4123 struct frame
*f
= XFRAME (w
->frame
);
4124 struct scroll_bar
*bar
;
4125 int top
, height
, left
, sb_left
, width
, sb_width
;
4126 int window_y
, window_height
;
4127 int fringe_extended_p
;
4129 /* Get window dimensions. */
4130 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
4132 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
4133 height
= window_height
;
4135 /* Compute the left edge of the scroll bar area. */
4136 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
4138 /* Compute the width of the scroll bar which might be less than
4139 the width of the area reserved for the scroll bar. */
4140 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
4141 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
4145 /* Compute the left edge of the scroll bar. */
4146 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
4147 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
4149 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
4151 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
4152 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
4153 && WINDOW_LEFT_FRINGE_WIDTH (w
)
4154 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
4155 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
4157 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
4158 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
4159 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
4160 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
4162 /* Does the scroll bar exist yet? */
4163 if (NILP (w
->vertical_scroll_bar
))
4167 if (width
> 0 && height
> 0)
4169 hdc
= get_frame_dc (f
);
4170 if (fringe_extended_p
)
4171 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
4173 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
4174 release_frame_dc (f
, hdc
);
4178 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
4182 /* It may just need to be moved and resized. */
4185 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4186 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
4188 /* If already correctly positioned, do nothing. */
4189 if ( XINT (bar
->left
) == sb_left
4190 && XINT (bar
->top
) == top
4191 && XINT (bar
->width
) == sb_width
4192 && XINT (bar
->height
) == height
4193 && !NILP (bar
->fringe_extended_p
) == fringe_extended_p
)
4195 /* Redraw after clear_frame. */
4196 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
4197 InvalidateRect (hwnd
, NULL
, FALSE
);
4205 if (width
&& height
)
4207 hdc
= get_frame_dc (f
);
4208 /* Since Windows scroll bars are smaller than the space reserved
4209 for them on the frame, we have to clear "under" them. */
4210 if (fringe_extended_p
)
4211 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
4213 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
4214 release_frame_dc (f
, hdc
);
4216 /* Make sure scroll bar is "visible" before moving, to ensure the
4217 area of the parent window now exposed will be refreshed. */
4218 my_show_window (f
, hwnd
, SW_HIDE
);
4219 MoveWindow (hwnd
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4220 top
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4221 max (height
, 1), TRUE
);
4223 si
.cbSize
= sizeof (si
);
4224 si
.fMask
= SIF_RANGE
;
4226 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
4227 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4229 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
4231 my_show_window (f
, hwnd
, SW_NORMAL
);
4232 /* InvalidateRect (w, NULL, FALSE); */
4234 /* Remember new settings. */
4235 XSETINT (bar
->left
, sb_left
);
4236 XSETINT (bar
->top
, top
);
4237 XSETINT (bar
->width
, sb_width
);
4238 XSETINT (bar
->height
, height
);
4243 bar
->fringe_extended_p
= fringe_extended_p
? Qt
: Qnil
;
4245 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
4247 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
4251 /* The following three hooks are used when we're doing a thorough
4252 redisplay of the frame. We don't explicitly know which scroll bars
4253 are going to be deleted, because keeping track of when windows go
4254 away is a real pain - "Can you say set-window-configuration, boys
4255 and girls?" Instead, we just assert at the beginning of redisplay
4256 that *all* scroll bars are to be removed, and then save a scroll bar
4257 from the fiery pit when we actually redisplay its window. */
4259 /* Arrange for all scroll bars on FRAME to be removed at the next call
4260 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
4261 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
4264 w32_condemn_scroll_bars (frame
)
4267 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
4268 while (! NILP (FRAME_SCROLL_BARS (frame
)))
4271 bar
= FRAME_SCROLL_BARS (frame
);
4272 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
4273 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
4274 XSCROLL_BAR (bar
)->prev
= Qnil
;
4275 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
4276 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
4277 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
4282 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
4283 Note that WINDOW isn't necessarily condemned at all. */
4286 w32_redeem_scroll_bar (window
)
4287 struct window
*window
;
4289 struct scroll_bar
*bar
;
4292 /* We can't redeem this window's scroll bar if it doesn't have one. */
4293 if (NILP (window
->vertical_scroll_bar
))
4296 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
4298 /* Unlink it from the condemned list. */
4299 f
= XFRAME (WINDOW_FRAME (window
));
4300 if (NILP (bar
->prev
))
4302 /* If the prev pointer is nil, it must be the first in one of
4304 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
4305 /* It's not condemned. Everything's fine. */
4307 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4308 window
->vertical_scroll_bar
))
4309 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
4311 /* If its prev pointer is nil, it must be at the front of
4312 one or the other! */
4316 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4318 if (! NILP (bar
->next
))
4319 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4321 bar
->next
= FRAME_SCROLL_BARS (f
);
4323 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4324 if (! NILP (bar
->next
))
4325 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4328 /* Remove all scroll bars on FRAME that haven't been saved since the
4329 last call to `*condemn_scroll_bars_hook'. */
4332 w32_judge_scroll_bars (f
)
4335 Lisp_Object bar
, next
;
4337 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
4339 /* Clear out the condemned list now so we won't try to process any
4340 more events on the hapless scroll bars. */
4341 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
4343 for (; ! NILP (bar
); bar
= next
)
4345 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
4347 x_scroll_bar_remove (b
);
4350 b
->next
= b
->prev
= Qnil
;
4353 /* Now there should be no references to the condemned scroll bars,
4354 and they should get garbage-collected. */
4357 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
4358 is set to something other than NO_EVENT, it is enqueued.
4360 This may be called from a signal handler, so we have to ignore GC
4364 w32_scroll_bar_handle_click (bar
, msg
, emacs_event
)
4365 struct scroll_bar
*bar
;
4367 struct input_event
*emacs_event
;
4369 if (! WINDOWP (bar
->window
))
4372 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
4373 emacs_event
->code
= 0;
4374 /* not really meaningful to distinguish up/down */
4375 emacs_event
->modifiers
= msg
->dwModifiers
;
4376 emacs_event
->frame_or_window
= bar
->window
;
4377 emacs_event
->arg
= Qnil
;
4378 emacs_event
->timestamp
= msg
->msg
.time
;
4381 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4383 int dragging
= !NILP (bar
->dragging
);
4386 si
.cbSize
= sizeof (si
);
4389 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4392 bar
->dragging
= Qnil
;
4395 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4397 switch (LOWORD (msg
->msg
.wParam
))
4400 emacs_event
->part
= scroll_bar_down_arrow
;
4403 emacs_event
->part
= scroll_bar_up_arrow
;
4406 emacs_event
->part
= scroll_bar_above_handle
;
4409 emacs_event
->part
= scroll_bar_below_handle
;
4412 emacs_event
->part
= scroll_bar_handle
;
4416 emacs_event
->part
= scroll_bar_handle
;
4420 case SB_THUMBPOSITION
:
4421 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
4422 y
= HIWORD (msg
->msg
.wParam
);
4424 emacs_event
->part
= scroll_bar_handle
;
4426 /* "Silently" update current position. */
4430 si
.cbSize
= sizeof (si
);
4433 /* Remember apparent position (we actually lag behind the real
4434 position, so don't set that directly. */
4435 last_scroll_bar_drag_pos
= y
;
4437 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4441 /* If this is the end of a drag sequence, then reset the scroll
4442 handle size to normal and do a final redraw. Otherwise do
4447 int start
= XINT (bar
->start
);
4448 int end
= XINT (bar
->end
);
4450 si
.cbSize
= sizeof (si
);
4451 si
.fMask
= SIF_PAGE
| SIF_POS
;
4452 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4453 si
.nPos
= last_scroll_bar_drag_pos
;
4454 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4458 emacs_event
->kind
= NO_EVENT
;
4462 XSETINT (emacs_event
->x
, y
);
4463 XSETINT (emacs_event
->y
, top_range
);
4469 /* Return information to the user about the current position of the mouse
4470 on the scroll bar. */
4473 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
4475 Lisp_Object
*bar_window
;
4476 enum scroll_bar_part
*part
;
4478 unsigned long *time
;
4480 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
4481 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4482 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4484 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4490 *bar_window
= bar
->window
;
4492 si
.cbSize
= sizeof (si
);
4493 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4495 GetScrollInfo (w
, SB_CTL
, &si
);
4497 top_range
= si
.nMax
- si
.nPage
+ 1;
4499 switch (LOWORD (last_mouse_scroll_bar_pos
))
4501 case SB_THUMBPOSITION
:
4503 *part
= scroll_bar_handle
;
4504 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
4505 pos
= HIWORD (last_mouse_scroll_bar_pos
);
4508 *part
= scroll_bar_handle
;
4512 *part
= scroll_bar_handle
;
4517 XSETINT (*y
, top_range
);
4520 last_mouse_scroll_bar
= Qnil
;
4522 *time
= last_mouse_movement_time
;
4528 /* The screen has been cleared so we may have changed foreground or
4529 background colors, and the scroll bars may need to be redrawn.
4530 Clear out the scroll bars, and ask for expose events, so we can
4534 x_scroll_bar_clear (f
)
4539 /* We can have scroll bars even if this is 0,
4540 if we just turned off scroll bar mode.
4541 But in that case we should not clear them. */
4542 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4543 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4544 bar
= XSCROLL_BAR (bar
)->next
)
4546 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4547 HDC hdc
= GetDC (window
);
4550 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4551 arranges to refresh the scroll bar if hidden. */
4552 my_show_window (f
, window
, SW_HIDE
);
4554 GetClientRect (window
, &rect
);
4555 select_palette (f
, hdc
);
4556 w32_clear_rect (f
, hdc
, &rect
);
4557 deselect_palette (f
, hdc
);
4559 ReleaseDC (window
, hdc
);
4564 /* The main W32 event-reading loop - w32_read_socket. */
4566 /* Record the last 100 characters stored
4567 to help debug the loss-of-chars-during-GC problem. */
4569 static int temp_index
;
4570 static short temp_buffer
[100];
4572 /* Temporarily store lead byte of DBCS input sequences. */
4573 static char dbcs_lead
= 0;
4575 /* Read events coming from the W32 shell.
4576 This routine is called by the SIGIO handler.
4577 We return as soon as there are no more events to be read.
4579 We return the number of characters stored into the buffer,
4580 thus pretending to be `read'.
4582 EXPECTED is nonzero if the caller knows input is available.
4584 Some of these messages are reposted back to the message queue since the
4585 system calls the windows proc directly in a context where we cannot return
4586 the data nor can we guarantee the state we are in. So if we dispatch them
4587 we will get into an infinite loop. To prevent this from ever happening we
4588 will set a variable to indicate we are in the read_socket call and indicate
4589 which message we are processing since the windows proc gets called
4590 recursively with different messages by the system.
4594 w32_read_socket (sd
, expected
, hold_quit
)
4597 struct input_event
*hold_quit
;
4600 int check_visibility
= 0;
4603 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4605 if (interrupt_input_blocked
)
4607 interrupt_input_pending
= 1;
4611 interrupt_input_pending
= 0;
4614 /* So people can tell when we have read the available input. */
4615 input_signal_count
++;
4617 /* TODO: ghostscript integration. */
4618 while (get_next_msg (&msg
, FALSE
))
4620 struct input_event inev
;
4624 inev
.kind
= NO_EVENT
;
4627 switch (msg
.msg
.message
)
4630 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4634 if (msg
.rect
.right
== msg
.rect
.left
||
4635 msg
.rect
.bottom
== msg
.rect
.top
)
4637 /* We may get paint messages even though the client
4638 area is clipped - these are not expose events. */
4639 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4642 else if (f
->async_visible
!= 1)
4644 /* Definitely not obscured, so mark as visible. */
4645 f
->async_visible
= 1;
4646 f
->async_iconified
= 0;
4647 SET_FRAME_GARBAGED (f
);
4648 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4651 /* WM_PAINT serves as MapNotify as well, so report
4652 visibility changes properly. */
4655 inev
.kind
= DEICONIFY_EVENT
;
4656 XSETFRAME (inev
.frame_or_window
, f
);
4658 else if (! NILP (Vframe_list
)
4659 && ! NILP (XCDR (Vframe_list
)))
4660 /* Force a redisplay sooner or later to update the
4661 frame titles in case this is the second frame. */
4662 record_asynch_buffer_change ();
4666 HDC hdc
= get_frame_dc (f
);
4668 /* Erase background again for safety. */
4669 w32_clear_rect (f
, hdc
, &msg
.rect
);
4670 release_frame_dc (f
, hdc
);
4674 msg
.rect
.right
- msg
.rect
.left
,
4675 msg
.rect
.bottom
- msg
.rect
.top
);
4680 case WM_INPUTLANGCHANGE
:
4681 /* Generate a language change event. */
4682 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4686 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4687 XSETFRAME (inev
.frame_or_window
, f
);
4688 inev
.code
= msg
.msg
.wParam
;
4689 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4695 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4697 if (f
&& !f
->iconified
)
4699 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4700 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4702 clear_mouse_face (dpyinfo
);
4703 dpyinfo
->mouse_face_hidden
= 1;
4706 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4708 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4709 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4710 inev
.code
= msg
.msg
.wParam
;
4711 inev
.modifiers
= msg
.dwModifiers
;
4712 XSETFRAME (inev
.frame_or_window
, f
);
4713 inev
.timestamp
= msg
.msg
.time
;
4720 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4722 if (f
&& !f
->iconified
)
4724 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4725 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4727 clear_mouse_face (dpyinfo
);
4728 dpyinfo
->mouse_face_hidden
= 1;
4731 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4733 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4735 inev
.modifiers
= msg
.dwModifiers
;
4736 XSETFRAME (inev
.frame_or_window
, f
);
4737 inev
.timestamp
= msg
.msg
.time
;
4739 if (msg
.msg
.message
== WM_UNICHAR
)
4741 inev
.code
= msg
.msg
.wParam
;
4743 else if (msg
.msg
.wParam
< 256)
4748 dbcs
[1] = (char) msg
.msg
.wParam
;
4752 dbcs
[0] = dbcs_lead
;
4754 if (!MultiByteToWideChar (CP_ACP
, 0, dbcs
, 2, &code
, 1))
4757 DebPrint (("Invalid DBCS sequence: %d %d\n",
4759 inev
.kind
= NO_EVENT
;
4763 else if (IsDBCSLeadByteEx (CP_ACP
, (BYTE
) msg
.msg
.wParam
))
4765 dbcs_lead
= (char) msg
.msg
.wParam
;
4766 inev
.kind
= NO_EVENT
;
4771 if (!MultiByteToWideChar (CP_ACP
, 0, &dbcs
[1], 1,
4774 /* What to do with garbage? */
4775 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4776 inev
.kind
= NO_EVENT
;
4784 /* Windows shouldn't generate WM_CHAR events above 0xFF
4785 in non-Unicode message handlers. */
4786 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4787 inev
.kind
= NO_EVENT
;
4790 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4791 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4796 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4798 if (f
&& !f
->iconified
)
4800 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4801 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4803 clear_mouse_face (dpyinfo
);
4804 dpyinfo
->mouse_face_hidden
= 1;
4807 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4809 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4810 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4811 inev
.code
= GET_APPCOMMAND_LPARAM(msg
.msg
.lParam
);
4812 inev
.modifiers
= msg
.dwModifiers
;
4813 XSETFRAME (inev
.frame_or_window
, f
);
4814 inev
.timestamp
= msg
.msg
.time
;
4819 /* Ignore non-movement. */
4821 int x
= LOWORD (msg
.msg
.lParam
);
4822 int y
= HIWORD (msg
.msg
.lParam
);
4823 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4825 last_mousemove_x
= x
;
4826 last_mousemove_y
= y
;
4829 previous_help_echo_string
= help_echo_string
;
4830 help_echo_string
= Qnil
;
4832 if (dpyinfo
->grabbed
&& last_mouse_frame
4833 && FRAME_LIVE_P (last_mouse_frame
))
4834 f
= last_mouse_frame
;
4836 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4838 if (dpyinfo
->mouse_face_hidden
)
4840 dpyinfo
->mouse_face_hidden
= 0;
4841 clear_mouse_face (dpyinfo
);
4846 /* Generate SELECT_WINDOW_EVENTs when needed. */
4847 if (!NILP (Vmouse_autoselect_window
))
4850 int x
= LOWORD (msg
.msg
.lParam
);
4851 int y
= HIWORD (msg
.msg
.lParam
);
4853 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 0);
4855 /* Window will be selected only when it is not
4856 selected now and last mouse movement event was
4857 not in it. Minibuffer window will be selected
4858 only when it is active. */
4860 && !EQ (window
, last_window
)
4861 && !EQ (window
, selected_window
)
4862 /* For click-to-focus window managers
4863 create event iff we don't leave the
4865 && (focus_follows_mouse
4866 || (EQ (XWINDOW (window
)->frame
,
4867 XWINDOW (selected_window
)->frame
))))
4869 inev
.kind
= SELECT_WINDOW_EVENT
;
4870 inev
.frame_or_window
= window
;
4875 if (!note_mouse_movement (f
, &msg
.msg
))
4876 help_echo_string
= previous_help_echo_string
;
4880 /* If we move outside the frame, then we're
4881 certainly no longer on any text in the frame. */
4882 clear_mouse_face (dpyinfo
);
4885 /* If the contents of the global variable help_echo_string
4886 has changed, generate a HELP_EVENT. */
4887 #if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE.
4888 But it was originally changed to this to fix a bug, so I have
4889 not removed it completely in case the bug is still there. */
4890 if (help_echo_string
!= previous_help_echo_string
||
4891 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4892 #else /* This is what xterm.c does. */
4893 if (!NILP (help_echo_string
)
4894 || !NILP (previous_help_echo_string
))
4899 case WM_LBUTTONDOWN
:
4901 case WM_MBUTTONDOWN
:
4903 case WM_RBUTTONDOWN
:
4905 case WM_XBUTTONDOWN
:
4908 /* If we decide we want to generate an event to be seen
4909 by the rest of Emacs, we put it here. */
4914 if (dpyinfo
->grabbed
&& last_mouse_frame
4915 && FRAME_LIVE_P (last_mouse_frame
))
4916 f
= last_mouse_frame
;
4918 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4922 construct_mouse_click (&inev
, &msg
, f
);
4924 /* Is this in the tool-bar? */
4925 if (WINDOWP (f
->tool_bar_window
)
4926 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4929 int x
= XFASTINT (inev
.x
);
4930 int y
= XFASTINT (inev
.y
);
4932 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
4934 if (EQ (window
, f
->tool_bar_window
))
4936 w32_handle_tool_bar_click (f
, &inev
);
4942 || (dpyinfo
->w32_focus_frame
4943 && f
!= dpyinfo
->w32_focus_frame
))
4944 inev
.kind
= NO_EVENT
;
4947 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4952 dpyinfo
->grabbed
&= ~ (1 << button
);
4956 dpyinfo
->grabbed
|= (1 << button
);
4957 last_mouse_frame
= f
;
4958 /* Ignore any mouse motion that happened
4959 before this event; any subsequent mouse-movement
4960 Emacs events should reflect only motion after
4966 last_tool_bar_item
= -1;
4972 case WM_MOUSEHWHEEL
:
4974 if (dpyinfo
->grabbed
&& last_mouse_frame
4975 && FRAME_LIVE_P (last_mouse_frame
))
4976 f
= last_mouse_frame
;
4978 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4983 if (!dpyinfo
->w32_focus_frame
4984 || f
== dpyinfo
->w32_focus_frame
)
4986 /* Emit an Emacs wheel-up/down event. */
4987 construct_mouse_wheel (&inev
, &msg
, f
);
4989 /* Ignore any mouse motion that happened before this
4990 event; any subsequent mouse-movement Emacs events
4991 should reflect only motion after the
4995 last_mouse_frame
= f
;
4996 last_tool_bar_item
= -1;
5001 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5004 construct_drag_n_drop (&inev
, &msg
, f
);
5009 struct scroll_bar
*bar
=
5010 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
5013 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
5017 case WM_WINDOWPOSCHANGED
:
5018 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5021 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
5022 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
5024 check_visibility
= 1;
5028 case WM_ACTIVATEAPP
:
5029 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5031 x_check_fullscreen (f
);
5032 check_visibility
= 1;
5036 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5038 if (f
&& !f
->async_iconified
)
5042 x_real_positions (f
, &x
, &y
);
5047 check_visibility
= 1;
5051 /* wParam non-zero means Window is about to be shown, 0 means
5052 about to be hidden. */
5053 /* Redo the mouse-highlight after the tooltip has gone. */
5054 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
5057 redo_mouse_highlight ();
5060 /* If window has been obscured or exposed by another window
5061 being maximised or minimised/restored, then recheck
5062 visibility of all frames. Direct changes to our own
5063 windows get handled by WM_SIZE. */
5065 if (msg
.msg
.lParam
!= 0)
5066 check_visibility
= 1;
5069 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5070 f
->async_visible
= msg
.msg
.wParam
;
5074 check_visibility
= 1;
5078 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5080 /* Inform lisp of whether frame has been iconified etc. */
5083 switch (msg
.msg
.wParam
)
5085 case SIZE_MINIMIZED
:
5086 f
->async_visible
= 0;
5087 f
->async_iconified
= 1;
5089 inev
.kind
= ICONIFY_EVENT
;
5090 XSETFRAME (inev
.frame_or_window
, f
);
5093 case SIZE_MAXIMIZED
:
5095 f
->async_visible
= 1;
5096 f
->async_iconified
= 0;
5098 /* wait_reading_process_output will notice this and update
5099 the frame's display structures. */
5100 SET_FRAME_GARBAGED (f
);
5106 /* Reset top and left positions of the Window
5107 here since Windows sends a WM_MOVE message
5108 BEFORE telling us the Window is minimized
5109 when the Window is iconified, with 3000,3000
5111 x_real_positions (f
, &x
, &y
);
5115 inev
.kind
= DEICONIFY_EVENT
;
5116 XSETFRAME (inev
.frame_or_window
, f
);
5118 else if (! NILP (Vframe_list
)
5119 && ! NILP (XCDR (Vframe_list
)))
5120 /* Force a redisplay sooner or later
5121 to update the frame titles
5122 in case this is the second frame. */
5123 record_asynch_buffer_change ();
5128 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
5136 GetClientRect (msg
.msg
.hwnd
, &rect
);
5138 height
= rect
.bottom
- rect
.top
;
5139 width
= rect
.right
- rect
.left
;
5141 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
5142 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
5144 /* TODO: Clip size to the screen dimensions. */
5146 /* Even if the number of character rows and columns has
5147 not changed, the font size may have changed, so we need
5148 to check the pixel dimensions as well. */
5150 if (columns
!= FRAME_COLS (f
)
5151 || rows
!= FRAME_LINES (f
)
5152 || width
!= FRAME_PIXEL_WIDTH (f
)
5153 || height
!= FRAME_PIXEL_HEIGHT (f
))
5155 change_frame_size (f
, rows
, columns
, 0, 1, 0);
5156 SET_FRAME_GARBAGED (f
);
5157 cancel_mouse_face (f
);
5158 FRAME_PIXEL_WIDTH (f
) = width
;
5159 FRAME_PIXEL_HEIGHT (f
) = height
;
5160 f
->win_gravity
= NorthWestGravity
;
5164 check_visibility
= 1;
5168 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5171 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5173 /* If we move outside the frame, then we're
5174 certainly no longer on any text in the frame. */
5175 clear_mouse_face (dpyinfo
);
5176 dpyinfo
->mouse_face_mouse_frame
= 0;
5179 /* Generate a nil HELP_EVENT to cancel a help-echo.
5180 Do it only if there's something to cancel.
5181 Otherwise, the startup message is cleared when
5182 the mouse leaves the frame. */
5183 if (any_help_event_p
)
5189 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5191 dpyinfo
->grabbed
= 0;
5192 check_visibility
= 1;
5196 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5200 if (f
== dpyinfo
->w32_focus_event_frame
)
5201 dpyinfo
->w32_focus_event_frame
= 0;
5203 if (f
== dpyinfo
->w32_focus_frame
)
5204 x_new_focus_frame (dpyinfo
, 0);
5206 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5208 /* If we move outside the frame, then we're
5209 certainly no longer on any text in the frame. */
5210 clear_mouse_face (dpyinfo
);
5211 dpyinfo
->mouse_face_mouse_frame
= 0;
5214 /* Generate a nil HELP_EVENT to cancel a help-echo.
5215 Do it only if there's something to cancel.
5216 Otherwise, the startup message is cleared when
5217 the mouse leaves the frame. */
5218 if (any_help_event_p
)
5222 dpyinfo
->grabbed
= 0;
5223 check_visibility
= 1;
5227 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5231 inev
.kind
= DELETE_WINDOW_EVENT
;
5232 XSETFRAME (inev
.frame_or_window
, f
);
5237 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5241 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
5242 XSETFRAME (inev
.frame_or_window
, f
);
5247 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5251 extern void menubar_selection_callback
5252 (FRAME_PTR f
, void * client_data
);
5253 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
5256 check_visibility
= 1;
5259 case WM_DISPLAYCHANGE
:
5260 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5264 dpyinfo
->width
= (short) LOWORD (msg
.msg
.lParam
);
5265 dpyinfo
->height
= (short) HIWORD (msg
.msg
.lParam
);
5266 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
5267 DebPrint (("display change: %d %d\n", dpyinfo
->width
,
5271 check_visibility
= 1;
5275 /* Check for messages registered at runtime. */
5276 if (msg
.msg
.message
== msh_mousewheel
)
5278 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5279 msg
.msg
.message
= WM_MOUSEWHEEL
;
5285 if (inev
.kind
!= NO_EVENT
)
5287 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5292 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5297 XSETFRAME (frame
, f
);
5303 if (NILP (help_echo_string
))
5305 help_echo_object
= help_echo_window
= Qnil
;
5309 any_help_event_p
= 1;
5310 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5311 help_echo_object
, help_echo_pos
);
5315 help_echo_string
= Qnil
;
5316 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5322 /* If the focus was just given to an autoraising frame,
5324 /* ??? This ought to be able to handle more than one such frame. */
5325 if (pending_autoraise_frame
)
5327 x_raise_frame (pending_autoraise_frame
);
5328 pending_autoraise_frame
= 0;
5331 /* Check which frames are still visisble, if we have enqueued any user
5332 events or been notified of events that may affect visibility. We
5333 do this here because there doesn't seem to be any direct
5334 notification from Windows that the visibility of a window has
5335 changed (at least, not in all cases). */
5336 if (count
> 0 || check_visibility
)
5338 Lisp_Object tail
, frame
;
5340 FOR_EACH_FRAME (tail
, frame
)
5342 FRAME_PTR f
= XFRAME (frame
);
5343 /* The tooltip has been drawn already. Avoid the
5344 SET_FRAME_GARBAGED below. */
5345 if (EQ (frame
, tip_frame
))
5348 /* Check "visible" frames and mark each as obscured or not.
5349 Note that async_visible is nonzero for unobscured and
5350 obscured frames, but zero for hidden and iconified frames. */
5351 if (FRAME_W32_P (f
) && f
->async_visible
)
5357 /* Query clipping rectangle for the entire window area
5358 (GetWindowDC), not just the client portion (GetDC).
5359 Otherwise, the scrollbars and menubar aren't counted as
5360 part of the visible area of the frame, and we may think
5361 the frame is obscured when really a scrollbar is still
5362 visible and gets WM_PAINT messages above. */
5363 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5364 GetClipBox (hdc
, &clipbox
);
5365 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5368 if (clipbox
.right
== clipbox
.left
5369 || clipbox
.bottom
== clipbox
.top
)
5371 /* Frame has become completely obscured so mark as
5372 such (we do this by setting async_visible to 2 so
5373 that FRAME_VISIBLE_P is still true, but redisplay
5375 f
->async_visible
= 2;
5377 if (!FRAME_OBSCURED_P (f
))
5379 DebPrint (("frame %p (%s) obscured\n", f
,
5385 /* Frame is not obscured, so mark it as such. */
5386 f
->async_visible
= 1;
5388 if (FRAME_OBSCURED_P (f
))
5390 SET_FRAME_GARBAGED (f
);
5391 DebPrint (("obscured frame %p (%s) found to be visible\n", f
,
5394 /* Force a redisplay sooner or later. */
5395 record_asynch_buffer_change ();
5408 /***********************************************************************
5410 ***********************************************************************/
5412 /* Set clipping for output in glyph row ROW. W is the window in which
5413 we operate. GC is the graphics context to set clipping in.
5415 ROW may be a text row or, e.g., a mode line. Text rows must be
5416 clipped to the interior of the window dedicated to text display,
5417 mode lines must be clipped to the whole window. */
5420 w32_clip_to_row (w
, row
, area
, hdc
)
5422 struct glyph_row
*row
;
5426 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5428 int window_x
, window_y
, window_width
;
5430 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5432 clip_rect
.left
= window_x
;
5433 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5434 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5435 clip_rect
.right
= clip_rect
.left
+ window_width
;
5436 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5438 w32_set_clip_rectangle (hdc
, &clip_rect
);
5442 /* Draw a hollow box cursor on window W in glyph row ROW. */
5445 x_draw_hollow_cursor (w
, row
)
5447 struct glyph_row
*row
;
5449 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5453 struct glyph
*cursor_glyph
;
5454 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5456 /* Get the glyph the cursor is on. If we can't tell because
5457 the current matrix is invalid or such, give up. */
5458 cursor_glyph
= get_phys_cursor_glyph (w
);
5459 if (cursor_glyph
== NULL
)
5462 /* Compute frame-relative coordinates for phys cursor. */
5463 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5466 rect
.bottom
= rect
.top
+ h
;
5467 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5469 hdc
= get_frame_dc (f
);
5470 /* Set clipping, draw the rectangle, and reset clipping again. */
5471 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5472 FrameRect (hdc
, &rect
, hb
);
5474 w32_set_clip_rectangle (hdc
, NULL
);
5475 release_frame_dc (f
, hdc
);
5479 /* Draw a bar cursor on window W in glyph row ROW.
5481 Implementation note: One would like to draw a bar cursor with an
5482 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5483 Unfortunately, I didn't find a font yet that has this property set.
5487 x_draw_bar_cursor (w
, row
, width
, kind
)
5489 struct glyph_row
*row
;
5491 enum text_cursor_kinds kind
;
5493 struct frame
*f
= XFRAME (w
->frame
);
5494 struct glyph
*cursor_glyph
;
5498 /* If cursor is out of bounds, don't draw garbage. This can happen
5499 in mini-buffer windows when switching between echo area glyphs
5501 cursor_glyph
= get_phys_cursor_glyph (w
);
5502 if (cursor_glyph
== NULL
)
5505 /* If on an image, draw like a normal cursor. That's usually better
5506 visible than drawing a bar, esp. if the image is large so that
5507 the bar might not be in the window. */
5508 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5510 struct glyph_row
*row
;
5511 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5512 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5516 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5517 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5519 /* If the glyph's background equals the color we normally draw
5520 the bar cursor in, the bar cursor in its normal color is
5521 invisible. Use the glyph's foreground color instead in this
5522 case, on the assumption that the glyph's colors are chosen so
5523 that the glyph is legible. */
5524 if (face
->background
== cursor_color
)
5525 cursor_color
= face
->foreground
;
5527 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5530 width
= FRAME_CURSOR_WIDTH (f
);
5531 width
= min (cursor_glyph
->pixel_width
, width
);
5533 w
->phys_cursor_width
= width
;
5536 hdc
= get_frame_dc (f
);
5537 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5539 if (kind
== BAR_CURSOR
)
5541 w32_fill_area (f
, hdc
, cursor_color
, x
,
5542 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5543 width
, row
->height
);
5547 w32_fill_area (f
, hdc
, cursor_color
, x
,
5548 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5549 row
->height
- width
),
5550 cursor_glyph
->pixel_width
, width
);
5553 w32_set_clip_rectangle (hdc
, NULL
);
5554 release_frame_dc (f
, hdc
);
5559 /* RIF: Define cursor CURSOR on frame F. */
5562 w32_define_frame_cursor (f
, cursor
)
5566 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5570 /* RIF: Clear area on frame F. */
5573 w32_clear_frame_area (f
, x
, y
, width
, height
)
5575 int x
, y
, width
, height
;
5579 hdc
= get_frame_dc (f
);
5580 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5581 release_frame_dc (f
, hdc
);
5584 /* RIF: Draw or clear cursor on window W. */
5587 w32_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
5589 struct glyph_row
*glyph_row
;
5591 int cursor_type
, cursor_width
;
5596 /* If the user wants to use the system caret, make sure our own
5597 cursor remains invisible. */
5598 if (w32_use_visible_system_caret
)
5600 /* Call to erase_phys_cursor here seems to use the
5601 wrong values of w->phys_cursor, as they have been
5602 overwritten before this function was called. */
5603 if (w
->phys_cursor_type
!= NO_CURSOR
)
5604 erase_phys_cursor (w
);
5606 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5607 w
->phys_cursor_width
= -1;
5611 w
->phys_cursor_type
= cursor_type
;
5614 w
->phys_cursor_on_p
= 1;
5616 /* If this is the active cursor, we need to track it with the
5617 system caret, so third party software like screen magnifiers
5618 and speech synthesizers can follow the cursor. */
5621 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5622 HWND hwnd
= FRAME_W32_WINDOW (f
);
5625 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5627 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5628 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5630 /* If the size of the active cursor changed, destroy the old
5632 if (w32_system_caret_hwnd
5633 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5634 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5636 w32_system_caret_height
= w
->phys_cursor_height
;
5638 /* Move the system caret. */
5639 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5642 if (glyph_row
->exact_window_width_line_p
5643 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
5645 glyph_row
->cursor_in_fringe_p
= 1;
5646 draw_fringe_bitmap (w
, glyph_row
, 0);
5650 switch (cursor_type
)
5652 case HOLLOW_BOX_CURSOR
:
5653 x_draw_hollow_cursor (w
, glyph_row
);
5656 case FILLED_BOX_CURSOR
:
5657 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5661 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5665 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5669 w
->phys_cursor_width
= 0;
5683 x_bitmap_icon (f
, icon
)
5688 HANDLE small_icon
= NULL
;
5690 if (FRAME_W32_WINDOW (f
) == 0)
5694 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5695 else if (STRINGP (icon
))
5697 /* Load the main icon from the named file. */
5698 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5699 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5700 /* Try to load a small icon to go with it. */
5701 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5702 GetSystemMetrics (SM_CXSMICON
),
5703 GetSystemMetrics (SM_CYSMICON
),
5706 else if (SYMBOLP (icon
))
5710 if (EQ (icon
, intern ("application")))
5711 name
= (LPCTSTR
) IDI_APPLICATION
;
5712 else if (EQ (icon
, intern ("hand")))
5713 name
= (LPCTSTR
) IDI_HAND
;
5714 else if (EQ (icon
, intern ("question")))
5715 name
= (LPCTSTR
) IDI_QUESTION
;
5716 else if (EQ (icon
, intern ("exclamation")))
5717 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5718 else if (EQ (icon
, intern ("asterisk")))
5719 name
= (LPCTSTR
) IDI_ASTERISK
;
5720 else if (EQ (icon
, intern ("winlogo")))
5721 name
= (LPCTSTR
) IDI_WINLOGO
;
5725 main_icon
= LoadIcon (NULL
, name
);
5730 if (main_icon
== NULL
)
5733 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5734 (LPARAM
) main_icon
);
5736 /* If there is a small icon that goes with it, set that too. */
5738 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5739 (LPARAM
) small_icon
);
5745 /************************************************************************
5747 ************************************************************************/
5749 /* Display Error Handling functions not used on W32. Listing them here
5750 helps diff stay in step when comparing w32term.c with xterm.c.
5752 x_error_catcher (display, error)
5753 x_catch_errors (dpy)
5754 x_catch_errors_unwind (old_val)
5755 x_check_errors (dpy, format)
5756 x_fully_uncatch_errors ()
5757 x_catching_errors ()
5758 x_had_errors_p (dpy)
5759 x_clear_errors (dpy)
5760 x_uncatch_errors (dpy, count)
5762 x_connection_signal (signalnum)
5763 x_connection_closed (dpy, error_message)
5764 x_error_quitter (display, error)
5765 x_error_handler (display, error)
5766 x_io_error_quitter (display)
5771 /* Changing the font of the frame. */
5775 /* Give frame F the font named FONTNAME as its default font, and
5776 return the full name of that font. FONTNAME may be a wildcard
5777 pattern; in that case, we choose some font that fits the pattern.
5778 The return value shows which font we chose. */
5781 x_new_font (f
, fontname
)
5783 register char *fontname
;
5785 struct font_info
*fontp
5786 = FS_LOAD_FONT (f
, fontname
);
5791 if (FRAME_FONT (f
) == (XFontStruct
*) (fontp
->font
))
5792 /* This font is already set in frame F. There's nothing more to
5794 return build_string (fontp
->full_name
);
5796 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
5797 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
5798 FRAME_FONTSET (f
) = -1;
5800 FRAME_COLUMN_WIDTH (f
) = fontp
->average_width
;
5801 FRAME_SPACE_WIDTH (f
) = fontp
->space_width
;
5802 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
5804 compute_fringe_widths (f
, 1);
5806 /* Compute the scroll bar width in character columns. */
5807 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5809 int wid
= FRAME_COLUMN_WIDTH (f
);
5810 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5811 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
5815 int wid
= FRAME_COLUMN_WIDTH (f
);
5816 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5819 /* Now make the frame display the given font. */
5820 if (FRAME_W32_WINDOW (f
) != 0)
5822 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5823 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5826 return build_string (fontp
->full_name
);
5829 /* Give frame F the fontset named FONTSETNAME as its default fontset,
5830 and return the full name of that fontset. FONTSETNAME may be a
5831 wildcard pattern; in that case, we choose some fontset that fits
5832 the pattern. FONTSETNAME may be a font name for ASCII characters;
5833 in that case, we create a fontset from that font name.
5835 The return value shows which fontset we chose.
5836 If FONTSETNAME specifies the default fontset, return Qt.
5837 If an ASCII font in the specified fontset can't be loaded, return
5841 x_new_fontset (f
, fontsetname
)
5843 Lisp_Object fontsetname
;
5845 int fontset
= fs_query_fontset (fontsetname
, 0);
5848 if (fontset
> 0 && FRAME_FONTSET(f
) == fontset
)
5849 /* This fontset is already set in frame F. There's nothing more
5851 return fontset_name (fontset
);
5852 else if (fontset
== 0)
5853 /* The default fontset can't be the default font. */
5857 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
5859 result
= x_new_font (f
, SDATA (fontsetname
));
5861 if (!STRINGP (result
))
5862 /* Can't load ASCII font. */
5866 fontset
= new_fontset_from_font_name (result
);
5868 /* Since x_new_font doesn't update any fontset information, do it now. */
5869 FRAME_FONTSET(f
) = fontset
;
5871 return fontset_name (fontset
);
5873 #endif /* OLD_FONT */
5877 x_new_font (f
, font_object
, fontset
)
5879 Lisp_Object font_object
;
5882 struct font
*font
= XFONT_OBJECT (font_object
);
5885 fontset
= fontset_from_font (font_object
);
5886 FRAME_FONTSET (f
) = fontset
;
5887 if (FRAME_FONT (f
) == font
)
5888 /* This font is already set in frame F. There's nothing more to
5890 return fontset_name (fontset
);
5894 FRAME_FONT (f
) = font
;
5895 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5896 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
5897 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
5898 FRAME_LINE_HEIGHT (f
) = font
->height
;
5900 compute_fringe_widths (f
, 1);
5902 /* Compute the scroll bar width in character columns. */
5903 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5905 int wid
= FRAME_COLUMN_WIDTH (f
);
5906 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5907 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
- 1) / wid
;
5911 int wid
= FRAME_COLUMN_WIDTH (f
);
5912 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5915 /* Now make the frame display the given font. */
5916 if (FRAME_X_WINDOW (f
) != 0)
5918 /* Don't change the size of a tip frame; there's no point in
5919 doing it because it's done in Fx_show_tip, and it leads to
5920 problems because the tip frame has no widget. */
5921 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5922 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5927 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
5928 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
5933 return fontset_name (fontset
);
5937 /***********************************************************************
5938 TODO: W32 Input Methods
5939 ***********************************************************************/
5940 /* Listing missing functions from xterm.c helps diff stay in step.
5942 xim_destroy_callback (xim, client_data, call_data)
5943 xim_open_dpy (dpyinfo, resource_name)
5945 xim_instantiate_callback (display, client_data, call_data)
5946 xim_initialize (dpyinfo, resource_name)
5947 xim_close_dpy (dpyinfo)
5952 /* Calculate the absolute position in frame F
5953 from its current recorded position values and gravity. */
5956 x_calc_absolute_position (f
)
5959 int flags
= f
->size_hint_flags
;
5961 /* The sum of the widths of the frame's left and right borders, and
5962 the sum of the heights of the frame's top and bottom borders (in
5963 pixels) drawn by Windows. */
5964 unsigned int left_right_borders_width
, top_bottom_borders_height
;
5966 /* Try to get the actual values of these two variables. We compute
5967 the border width (height) by subtracting the width (height) of
5968 the frame's client area from the width (height) of the frame's
5970 WINDOWPLACEMENT wp
= { 0 };
5971 RECT client_rect
= { 0 };
5973 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
5974 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
5976 left_right_borders_width
=
5977 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
5978 (client_rect
.right
- client_rect
.left
);
5980 top_bottom_borders_height
=
5981 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
5982 (client_rect
.bottom
- client_rect
.top
);
5986 /* Use sensible default values. */
5987 left_right_borders_width
= 8;
5988 top_bottom_borders_height
= 32;
5991 /* Treat negative positions as relative to the rightmost bottommost
5992 position that fits on the screen. */
5993 if (flags
& XNegative
)
5994 f
->left_pos
= (FRAME_W32_DISPLAY_INFO (f
)->width
5995 - FRAME_PIXEL_WIDTH (f
)
5997 - (left_right_borders_width
- 1));
5999 if (flags
& YNegative
)
6000 f
->top_pos
= (FRAME_W32_DISPLAY_INFO (f
)->height
6001 - FRAME_PIXEL_HEIGHT (f
)
6003 - (top_bottom_borders_height
- 1));
6005 /* The left_pos and top_pos are now relative to the top and left
6006 screen edges, so the flags should correspond. */
6007 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6010 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
6011 to really change the position, and 0 when calling from
6012 x_make_frame_visible (in that case, XOFF and YOFF are the current
6013 position values). It is -1 when calling from x_set_frame_parameters,
6014 which means, do adjust for borders but don't change the gravity. */
6017 x_set_offset (f
, xoff
, yoff
, change_gravity
)
6019 register int xoff
, yoff
;
6022 int modified_top
, modified_left
;
6024 if (change_gravity
> 0)
6028 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6030 f
->size_hint_flags
|= XNegative
;
6032 f
->size_hint_flags
|= YNegative
;
6033 f
->win_gravity
= NorthWestGravity
;
6035 x_calc_absolute_position (f
);
6038 x_wm_set_size_hint (f
, (long) 0, 0);
6040 modified_left
= f
->left_pos
;
6041 modified_top
= f
->top_pos
;
6043 my_set_window_pos (FRAME_W32_WINDOW (f
),
6045 modified_left
, modified_top
,
6047 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6052 /* Check if we need to resize the frame due to a fullscreen request.
6053 If so needed, resize the frame. */
6055 x_check_fullscreen (f
)
6058 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
6060 int width
, height
, ign
;
6062 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6064 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
6066 /* We do not need to move the window, it shall be taken care of
6067 when setting WM manager hints. */
6068 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
6070 change_frame_size (f
, height
, width
, 0, 1, 0);
6071 SET_FRAME_GARBAGED (f
);
6072 cancel_mouse_face (f
);
6074 /* Wait for the change of frame size to occur */
6075 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
6080 /* Call this to change the size of frame F's x-window.
6081 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
6082 for this size change and subsequent size changes.
6083 Otherwise we leave the window gravity unchanged. */
6086 x_set_window_size (f
, change_gravity
, cols
, rows
)
6091 int pixelwidth
, pixelheight
;
6095 check_frame_size (f
, &rows
, &cols
);
6096 f
->scroll_bar_actual_width
6097 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
6099 compute_fringe_widths (f
, 0);
6101 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
6102 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
6104 f
->win_gravity
= NorthWestGravity
;
6105 x_wm_set_size_hint (f
, (long) 0, 0);
6110 rect
.left
= rect
.top
= 0;
6111 rect
.right
= pixelwidth
;
6112 rect
.bottom
= pixelheight
;
6114 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
6115 FRAME_EXTERNAL_MENU_BAR (f
));
6117 my_set_window_pos (FRAME_W32_WINDOW (f
),
6120 rect
.right
- rect
.left
,
6121 rect
.bottom
- rect
.top
,
6122 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6126 /* The following mirrors what is done in xterm.c. It appears to be
6127 for informing lisp of the new size immediately, while the actual
6128 resize will happen asynchronously. But on Windows, the menu bar
6129 automatically wraps when the frame is too narrow to contain it,
6130 and that causes any calculations made here to come out wrong. The
6131 end is some nasty buggy behaviour, including the potential loss
6134 Disabling this code is either not sufficient to fix the problems
6135 completely, or it causes fresh problems, but at least it removes
6136 the most problematic symptom of the minibuffer becoming unusable.
6138 -----------------------------------------------------------------
6140 Now, strictly speaking, we can't be sure that this is accurate,
6141 but the window manager will get around to dealing with the size
6142 change request eventually, and we'll hear how it went when the
6143 ConfigureNotify event gets here.
6145 We could just not bother storing any of this information here,
6146 and let the ConfigureNotify event set everything up, but that
6147 might be kind of confusing to the Lisp code, since size changes
6148 wouldn't be reported in the frame parameters until some random
6149 point in the future when the ConfigureNotify event arrives.
6151 We pass 1 for DELAY since we can't run Lisp code inside of
6153 change_frame_size (f
, rows
, cols
, 0, 1, 0);
6154 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
6155 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
6157 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
6158 receive in the ConfigureNotify event; if we get what we asked
6159 for, then the event won't cause the screen to become garbaged, so
6160 we have to make sure to do it here. */
6161 SET_FRAME_GARBAGED (f
);
6163 /* If cursor was outside the new size, mark it as off. */
6164 mark_window_cursors_off (XWINDOW (f
->root_window
));
6166 /* Clear out any recollection of where the mouse highlighting was,
6167 since it might be in a place that's outside the new frame size.
6168 Actually checking whether it is outside is a pain in the neck,
6169 so don't try--just let the highlighting be done afresh with new size. */
6170 cancel_mouse_face (f
);
6176 /* Mouse warping. */
6178 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
6181 x_set_mouse_position (f
, x
, y
)
6187 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
6188 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
6190 if (pix_x
< 0) pix_x
= 0;
6191 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
6193 if (pix_y
< 0) pix_y
= 0;
6194 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
6196 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
6200 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
6209 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
6210 pt
.x
= rect
.left
+ pix_x
;
6211 pt
.y
= rect
.top
+ pix_y
;
6212 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
6214 SetCursorPos (pt
.x
, pt
.y
);
6220 /* focus shifting, raising and lowering. */
6223 x_focus_on_frame (f
)
6226 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6228 /* Give input focus to frame. */
6231 /* Try not to change its Z-order if possible. */
6232 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
6233 my_set_focus (f
, FRAME_W32_WINDOW (f
));
6236 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6246 /* Raise frame F. */
6253 /* Strictly speaking, raise-frame should only change the frame's Z
6254 order, leaving input focus unchanged. This is reasonable behaviour
6255 on X where the usual policy is point-to-focus. However, this
6256 behaviour would be very odd on Windows where the usual policy is
6259 On X, if the mouse happens to be over the raised frame, it gets
6260 input focus anyway (so the window with focus will never be
6261 completely obscured) - if not, then just moving the mouse over it
6262 is sufficient to give it focus. On Windows, the user must actually
6263 click on the frame (preferrably the title bar so as not to move
6264 point), which is more awkward. Also, no other Windows program
6265 raises a window to the top but leaves another window (possibly now
6266 completely obscured) with input focus.
6268 Because there is a system setting on Windows that allows the user
6269 to choose the point to focus policy, we make the strict semantics
6270 optional, but by default we grab focus when raising. */
6272 if (NILP (Vw32_grab_focus_on_raise
))
6274 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6275 not already the foreground application: the frame is raised
6276 above all other frames belonging to us, but not above the
6277 current top window. To achieve that, we have to resort to this
6278 more cumbersome method. */
6280 HDWP handle
= BeginDeferWindowPos (2);
6283 DeferWindowPos (handle
,
6284 FRAME_W32_WINDOW (f
),
6287 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6289 DeferWindowPos (handle
,
6290 GetForegroundWindow (),
6291 FRAME_W32_WINDOW (f
),
6293 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6295 EndDeferWindowPos (handle
);
6300 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6306 /* Lower frame F. */
6312 my_set_window_pos (FRAME_W32_WINDOW (f
),
6315 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6320 w32_frame_raise_lower (f
, raise_flag
)
6324 if (! FRAME_W32_P (f
))
6333 /* Change of visibility. */
6335 /* This tries to wait until the frame is really visible.
6336 However, if the window manager asks the user where to position
6337 the frame, this will return before the user finishes doing that.
6338 The frame will not actually be visible at that time,
6339 but it will become visible later when the window manager
6340 finishes with it. */
6343 x_make_frame_visible (f
)
6350 type
= x_icon_type (f
);
6352 x_bitmap_icon (f
, type
);
6354 if (! FRAME_VISIBLE_P (f
))
6356 /* We test FRAME_GARBAGED_P here to make sure we don't
6357 call x_set_offset a second time
6358 if we get to x_make_frame_visible a second time
6359 before the window gets really visible. */
6360 if (! FRAME_ICONIFIED_P (f
)
6361 && ! f
->output_data
.w32
->asked_for_visible
)
6366 /* Adjust vertical window position in order to avoid being
6367 covered by a task bar placed at the bottom of the desktop. */
6368 SystemParametersInfo(SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6369 GetWindowRect(FRAME_W32_WINDOW(f
), &window_rect
);
6370 if (window_rect
.bottom
> workarea_rect
.bottom
6371 && window_rect
.top
> workarea_rect
.top
)
6372 f
->top_pos
= max (window_rect
.top
6373 - window_rect
.bottom
+ workarea_rect
.bottom
,
6376 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6379 f
->output_data
.w32
->asked_for_visible
= 1;
6381 /* The first of these seems to give more expected behavior, but
6382 was added as a commented out line in Sept 1997, with the
6383 second version remaining uncommented. There may have been
6384 some problem with it that led to it not being enabled,
6385 so the old version remains commented out below in case we
6386 decide we need to go back to it [23.0.60 2008-06-09]. */
6387 my_show_window (f
, FRAME_W32_WINDOW (f
),
6388 f
->async_iconified
? SW_RESTORE
: SW_SHOW
);
6389 /* my_show_window (f, FRAME_W32_WINDOW (f), SW_SHOWNORMAL); */
6392 /* Synchronize to ensure Emacs knows the frame is visible
6393 before we do anything else. We do this loop with input not blocked
6394 so that incoming events are handled. */
6399 /* This must come after we set COUNT. */
6402 XSETFRAME (frame
, f
);
6404 /* Wait until the frame is visible. Process X events until a
6405 MapNotify event has been seen, or until we think we won't get a
6406 MapNotify at all.. */
6407 for (count
= input_signal_count
+ 10;
6408 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6410 /* Force processing of queued events. */
6411 /* TODO: x_sync equivalent? */
6413 /* Machines that do polling rather than SIGIO have been observed
6414 to go into a busy-wait here. So we'll fake an alarm signal
6415 to let the handler know that there's something to be read.
6416 We used to raise a real alarm, but it seems that the handler
6417 isn't always enabled here. This is probably a bug. */
6418 if (input_polling_used ())
6420 /* It could be confusing if a real alarm arrives while processing
6421 the fake one. Turn it off and let the handler reset it. */
6422 int old_poll_suppress_count
= poll_suppress_count
;
6423 poll_suppress_count
= 1;
6424 poll_for_input_1 ();
6425 poll_suppress_count
= old_poll_suppress_count
;
6428 FRAME_SAMPLE_VISIBILITY (f
);
6432 /* Change from mapped state to withdrawn state. */
6434 /* Make the frame visible (mapped and not iconified). */
6436 x_make_frame_invisible (f
)
6439 /* Don't keep the highlight on an invisible frame. */
6440 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6441 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6445 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6447 /* We can't distinguish this from iconification
6448 just by the event that we get from the server.
6449 So we can't win using the usual strategy of letting
6450 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6451 and synchronize with the server to make sure we agree. */
6453 FRAME_ICONIFIED_P (f
) = 0;
6454 f
->async_visible
= 0;
6455 f
->async_iconified
= 0;
6460 /* Change window state from mapped to iconified. */
6468 /* Don't keep the highlight on an invisible frame. */
6469 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6470 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6472 if (f
->async_iconified
)
6477 type
= x_icon_type (f
);
6479 x_bitmap_icon (f
, type
);
6481 /* Simulate the user minimizing the frame. */
6482 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
6488 /* Free X resources of frame F. */
6491 x_free_frame_resources (f
)
6494 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6498 /* We must free faces before destroying windows because some
6499 font-driver (e.g. xft) access a window while finishing a
6501 if (FRAME_FACE_CACHE (f
))
6502 free_frame_faces (f
);
6504 if (FRAME_W32_WINDOW (f
))
6505 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6507 free_frame_menubar (f
);
6509 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
6510 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
6511 unload_color (f
, f
->output_data
.w32
->cursor_pixel
);
6512 unload_color (f
, f
->output_data
.w32
->cursor_foreground_pixel
);
6513 unload_color (f
, f
->output_data
.w32
->border_pixel
);
6514 unload_color (f
, f
->output_data
.w32
->mouse_pixel
);
6515 if (f
->output_data
.w32
->white_relief
.allocated_p
)
6516 unload_color (f
, f
->output_data
.w32
->white_relief
.pixel
);
6517 if (f
->output_data
.w32
->black_relief
.allocated_p
)
6518 unload_color (f
, f
->output_data
.w32
->black_relief
.pixel
);
6520 if (FRAME_FACE_CACHE (f
))
6521 free_frame_faces (f
);
6523 xfree (f
->output_data
.w32
);
6524 f
->output_data
.w32
= NULL
;
6526 if (f
== dpyinfo
->w32_focus_frame
)
6527 dpyinfo
->w32_focus_frame
= 0;
6528 if (f
== dpyinfo
->w32_focus_event_frame
)
6529 dpyinfo
->w32_focus_event_frame
= 0;
6530 if (f
== dpyinfo
->x_highlight_frame
)
6531 dpyinfo
->x_highlight_frame
= 0;
6533 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6535 dpyinfo
->mouse_face_beg_row
6536 = dpyinfo
->mouse_face_beg_col
= -1;
6537 dpyinfo
->mouse_face_end_row
6538 = dpyinfo
->mouse_face_end_col
= -1;
6539 dpyinfo
->mouse_face_window
= Qnil
;
6540 dpyinfo
->mouse_face_deferred_gc
= 0;
6541 dpyinfo
->mouse_face_mouse_frame
= 0;
6548 /* Destroy the window of frame F. */
6550 x_destroy_window (f
)
6553 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6555 x_free_frame_resources (f
);
6556 dpyinfo
->reference_count
--;
6560 /* Setting window manager hints. */
6562 /* Set the normal size hints for the window manager, for frame F.
6563 FLAGS is the flags word to use--or 0 meaning preserve the flags
6564 that the window now has.
6565 If USER_POSITION is nonzero, we set the USPosition
6566 flag (this is useful when FLAGS is 0). */
6568 x_wm_set_size_hint (f
, flags
, user_position
)
6573 Window window
= FRAME_W32_WINDOW (f
);
6577 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6578 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6579 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6580 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
6585 /* Window manager things */
6587 x_wm_set_icon_position (f
, icon_x
, icon_y
)
6592 Window window
= FRAME_W32_WINDOW (f
);
6594 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
6595 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
6596 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
6598 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
6603 /***********************************************************************
6605 ***********************************************************************/
6609 /* The following functions are listed here to help diff stay in step
6610 with xterm.c. See w32fns.c for definitions.
6612 x_get_font_info (f, font_idx)
6613 x_list_fonts (f, pattern, size, maxnames)
6619 /* Check that FONT is valid on frame F. It is if it can be found in F's
6623 x_check_font (f
, font
)
6628 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6630 xassert (font
!= NULL
);
6632 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
6633 if (dpyinfo
->font_table
[i
].name
6634 && font
== dpyinfo
->font_table
[i
].font
)
6637 xassert (i
< dpyinfo
->n_fonts
);
6640 #endif /* GLYPH_DEBUG != 0 */
6642 /* Set *W to the minimum width, *H to the minimum font height of FONT.
6643 Note: There are (broken) X fonts out there with invalid XFontStruct
6644 min_bounds contents. For example, handa@etl.go.jp reports that
6645 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
6646 have font->min_bounds.width == 0. */
6649 x_font_min_bounds (font
, w
, h
)
6654 * TODO: Windows does not appear to offer min bound, only
6655 * average and maximum width, and maximum height.
6657 *h
= FONT_HEIGHT (font
);
6658 *w
= FONT_AVG_WIDTH (font
);
6662 /* Compute the smallest character width and smallest font height over
6663 all fonts available on frame F. Set the members smallest_char_width
6664 and smallest_font_height in F's x_display_info structure to
6665 the values computed. Value is non-zero if smallest_font_height or
6666 smallest_char_width become smaller than they were before. */
6669 x_compute_min_glyph_bounds (f
)
6673 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6675 int old_width
= dpyinfo
->smallest_char_width
;
6676 int old_height
= dpyinfo
->smallest_font_height
;
6678 dpyinfo
->smallest_font_height
= 100000;
6679 dpyinfo
->smallest_char_width
= 100000;
6681 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
6682 if (dpyinfo
->font_table
[i
].name
)
6684 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
6687 font
= (XFontStruct
*) fontp
->font
;
6688 xassert (font
!= (XFontStruct
*) ~0);
6689 x_font_min_bounds (font
, &w
, &h
);
6691 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
6692 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
6695 xassert (dpyinfo
->smallest_char_width
> 0
6696 && dpyinfo
->smallest_font_height
> 0);
6698 return (dpyinfo
->n_fonts
== 1
6699 || dpyinfo
->smallest_char_width
< old_width
6700 || dpyinfo
->smallest_font_height
< old_height
);
6703 /* The following functions are listed here to help diff stay in step
6704 with xterm.c. See w32fns.c for definitions.
6706 x_load_font (f, fontname, size)
6707 x_query_font (f, fontname)
6708 x_find_ccl_program (fontp)
6712 #endif /* OLD_FONT */
6715 /***********************************************************************
6717 ***********************************************************************/
6719 static int w32_initialized
= 0;
6722 w32_initialize_display_info (display_name
)
6723 Lisp_Object display_name
;
6725 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6727 bzero (dpyinfo
, sizeof (*dpyinfo
));
6729 /* Put it on w32_display_name_list. */
6730 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
6731 w32_display_name_list
);
6732 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
6734 dpyinfo
->w32_id_name
6735 = (char *) xmalloc (SCHARS (Vinvocation_name
)
6736 + SCHARS (Vsystem_name
)
6738 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6739 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6741 /* Default Console mode values - overridden when running in GUI mode
6742 with values obtained from system metrics. */
6745 dpyinfo
->height_in
= 1;
6746 dpyinfo
->width_in
= 1;
6747 dpyinfo
->n_planes
= 1;
6748 dpyinfo
->n_cbits
= 4;
6749 dpyinfo
->n_fonts
= 0;
6750 dpyinfo
->smallest_font_height
= 1;
6751 dpyinfo
->smallest_char_width
= 1;
6753 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6754 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6755 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
6756 dpyinfo
->mouse_face_window
= Qnil
;
6757 dpyinfo
->mouse_face_overlay
= Qnil
;
6758 dpyinfo
->mouse_face_hidden
= 0;
6760 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6761 /* TODO: dpyinfo->gray */
6765 /* Create an xrdb-style database of resources to supercede registry settings.
6766 The database is just a concatenation of C strings, finished by an additional
6767 \0. The strings are submitted to some basic normalization, so
6769 [ *]option[ *]:[ *]value...
6775 but any whitespace following value is not removed. */
6778 w32_make_rdb (xrm_option
)
6781 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6782 char *current
= buffer
;
6785 int before_value
= 0;
6799 if (in_option
&& (ch
== ':'))
6804 else if (before_value
)
6809 else if (!(in_option
|| before_value
))
6821 x_flush (struct frame
* f
)
6822 { /* Nothing to do */ }
6825 extern frame_parm_handler w32_frame_parm_handlers
[];
6827 static struct redisplay_interface w32_redisplay_interface
=
6829 w32_frame_parm_handlers
,
6833 x_clear_end_of_line
,
6835 x_after_update_window_line
,
6836 x_update_window_begin
,
6837 x_update_window_end
,
6840 0, /* flush_display_optional */
6841 x_clear_window_mouse_face
,
6842 x_get_glyph_overhangs
,
6843 x_fix_overlapping_area
,
6844 w32_draw_fringe_bitmap
,
6845 w32_define_fringe_bitmap
,
6846 w32_destroy_fringe_bitmap
,
6848 w32_per_char_metric
,
6851 w32_compute_glyph_string_overhangs
,
6852 x_draw_glyph_string
,
6853 w32_define_frame_cursor
,
6854 w32_clear_frame_area
,
6855 w32_draw_window_cursor
,
6856 w32_draw_vertical_window_border
,
6857 w32_shift_glyphs_for_insert
6860 static void x_delete_terminal (struct terminal
*term
);
6862 static struct terminal
*
6863 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6865 struct terminal
*terminal
;
6867 terminal
= create_terminal ();
6869 terminal
->type
= output_w32
;
6870 terminal
->display_info
.w32
= dpyinfo
;
6871 dpyinfo
->terminal
= terminal
;
6873 /* MSVC does not type K&R functions with no arguments correctly, and
6874 so we must explicitly cast them. */
6875 terminal
->clear_frame_hook
= x_clear_frame
;
6876 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6877 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6878 terminal
->ring_bell_hook
= w32_ring_bell
;
6879 terminal
->reset_terminal_modes_hook
= w32_reset_terminal_modes
;
6880 terminal
->set_terminal_modes_hook
= w32_set_terminal_modes
;
6881 terminal
->update_begin_hook
= x_update_begin
;
6882 terminal
->update_end_hook
= x_update_end
;
6883 terminal
->set_terminal_window_hook
= w32_set_terminal_window
;
6884 terminal
->read_socket_hook
= w32_read_socket
;
6885 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6886 terminal
->mouse_position_hook
= w32_mouse_position
;
6887 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6888 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6889 // terminal->fullscreen_hook = XTfullscreen_hook;
6890 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6891 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6892 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6893 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6895 terminal
->delete_frame_hook
= x_destroy_window
;
6896 terminal
->delete_terminal_hook
= x_delete_terminal
;
6898 terminal
->rif
= &w32_redisplay_interface
;
6899 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
6900 terminal
->char_ins_del_ok
= 1;
6901 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
6902 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
6903 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
6907 /* We don't yet support separate terminals on W32, so don't try to share
6908 keyboards between virtual terminals that are on the same physical
6909 terminal like X does. */
6910 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
6911 init_kboard (terminal
->kboard
);
6912 terminal
->kboard
->Vwindow_system
= intern ("w32");
6913 terminal
->kboard
->next_kboard
= all_kboards
;
6914 all_kboards
= terminal
->kboard
;
6915 /* Don't let the initial kboard remain current longer than necessary.
6916 That would cause problems if a file loaded on startup tries to
6917 prompt in the mini-buffer. */
6918 if (current_kboard
== initial_kboard
)
6919 current_kboard
= terminal
->kboard
;
6920 terminal
->kboard
->reference_count
++;
6927 x_delete_terminal (struct terminal
*terminal
)
6929 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
6932 /* Protect against recursive calls. Fdelete_frame in
6933 delete_terminal calls us back when it deletes our last frame. */
6934 if (!terminal
->name
)
6939 /* Free the fonts in the font table. */
6940 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
6941 if (dpyinfo
->font_table
[i
].name
)
6943 DeleteObject (((XFontStruct
*)(dpyinfo
->font_table
[i
].font
))->hfont
);
6947 x_delete_display (dpyinfo
);
6951 struct w32_display_info
*
6952 w32_term_init (display_name
, xrm_option
, resource_name
)
6953 Lisp_Object display_name
;
6955 char *resource_name
;
6957 struct w32_display_info
*dpyinfo
;
6958 struct terminal
*terminal
;
6963 if (!w32_initialized
)
6966 w32_initialized
= 1;
6969 w32_initialize_display_info (display_name
);
6971 dpyinfo
= &one_w32_display_info
;
6972 terminal
= w32_create_terminal (dpyinfo
);
6974 /* Set the name of the terminal. */
6975 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
6976 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
6977 terminal
->name
[SBYTES (display_name
)] = 0;
6979 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6981 /* Put this display on the chain. */
6982 dpyinfo
->next
= x_display_list
;
6983 x_display_list
= dpyinfo
;
6985 hdc
= GetDC (GetDesktopWindow ());
6987 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
6988 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
6989 dpyinfo
->root_window
= GetDesktopWindow ();
6990 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6991 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6992 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6993 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6994 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6995 dpyinfo
->terminal
->image_cache
= make_image_cache ();
6996 dpyinfo
->height_in
= dpyinfo
->height
/ dpyinfo
->resx
;
6997 dpyinfo
->width_in
= dpyinfo
->width
/ dpyinfo
->resy
;
6998 ReleaseDC (GetDesktopWindow (), hdc
);
7000 /* initialise palette with white and black */
7003 w32_defined_color (0, "white", &color
, 1);
7004 w32_defined_color (0, "black", &color
, 1);
7007 /* Add the default keyboard. */
7008 add_keyboard_wait_descriptor (0);
7010 /* Create Fringe Bitmaps and store them for later use.
7012 On W32, bitmaps are all unsigned short, as Windows requires
7013 bitmap data to be Word aligned. For some reason they are
7014 horizontally reflected compared to how they appear on X, so we
7015 need to bitswap and convert to unsigned shorts before creating
7017 w32_init_fringe (terminal
->rif
);
7020 fcntl (connection
, F_SETOWN
, getpid ());
7021 #endif /* ! defined (F_SETOWN) */
7024 if (interrupt_input
)
7025 init_sigio (connection
);
7026 #endif /* ! defined (SIGIO) */
7033 /* Get rid of display DPYINFO, assuming all frames are already gone. */
7035 x_delete_display (dpyinfo
)
7036 struct w32_display_info
*dpyinfo
;
7038 /* Discard this display from w32_display_name_list and w32_display_list.
7039 We can't use Fdelq because that can quit. */
7040 if (! NILP (w32_display_name_list
)
7041 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
7042 w32_display_name_list
= XCDR (w32_display_name_list
);
7047 tail
= w32_display_name_list
;
7048 while (CONSP (tail
) && CONSP (XCDR (tail
)))
7050 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
7052 XSETCDR (tail
, XCDR (XCDR (tail
)));
7059 /* free palette table */
7061 struct w32_palette_entry
* plist
;
7063 plist
= dpyinfo
->color_list
;
7066 struct w32_palette_entry
* pentry
= plist
;
7067 plist
= plist
->next
;
7070 dpyinfo
->color_list
= NULL
;
7071 if (dpyinfo
->palette
)
7072 DeleteObject(dpyinfo
->palette
);
7075 xfree (dpyinfo
->font_table
);
7077 xfree (dpyinfo
->w32_id_name
);
7079 w32_reset_fringes ();
7082 /* Set up use of W32. */
7084 DWORD WINAPI
w32_msg_worker (void * arg
);
7091 w32_system_caret_hwnd
= NULL
;
7092 w32_system_caret_height
= 0;
7093 w32_system_caret_x
= 0;
7094 w32_system_caret_y
= 0;
7096 /* Initialize w32_use_visible_system_caret based on whether a screen
7097 reader is in use. */
7098 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
7099 &w32_use_visible_system_caret
, 0))
7100 w32_use_visible_system_caret
= 0;
7102 last_tool_bar_item
= -1;
7103 any_help_event_p
= 0;
7105 /* Initialize input mode: interrupt_input off, no flow control, allow
7106 8 bit character input, standard quit char. */
7107 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
7109 /* Create the window thread - it will terminate itself or when the app terminates */
7113 dwMainThreadId
= GetCurrentThreadId ();
7114 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
7115 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
7117 /* Wait for thread to start */
7122 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
7124 hWindowsThread
= CreateThread (NULL
, 0,
7126 0, 0, &dwWindowsThreadId
);
7128 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
7131 /* It is desirable that mainThread should have the same notion of
7132 focus window and active window as windowsThread. Unfortunately, the
7133 following call to AttachThreadInput, which should do precisely what
7134 we need, causes major problems when Emacs is linked as a console
7135 program. Unfortunately, we have good reasons for doing that, so
7136 instead we need to send messages to windowsThread to make some API
7137 calls for us (ones that affect, or depend on, the active/focus
7139 #ifdef ATTACH_THREADS
7140 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
7143 /* Dynamically link to optional system components. */
7145 UINT smoothing_type
;
7146 BOOL smoothing_enabled
;
7148 HANDLE gdi_lib
= LoadLibrary ("gdi32.dll");
7150 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7152 LOAD_PROC (gdi_lib
, GetFontUnicodeRanges
);
7156 FreeLibrary (gdi_lib
);
7158 /* Ensure scrollbar handle is at least 5 pixels. */
7159 vertical_scroll_bar_min_handle
= 5;
7161 /* For either kind of scroll bar, take account of the arrows; these
7162 effectively form the border of the main scroll bar range. */
7163 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
7164 = GetSystemMetrics (SM_CYVSCROLL
);
7166 /* Constants that are not always defined by the system headers
7167 since they only exist on certain versions of Windows. */
7168 #ifndef SPI_GETFONTSMOOTHING
7169 #define SPI_GETFONTSMOOTHING 0x4A
7171 #ifndef SPI_GETFONTSMOOTHINGTYPE
7172 #define SPI_GETFONTSMOOTHINGTYPE 0x0200A
7174 #ifndef FE_FONTSMOOTHINGCLEARTYPE
7175 #define FE_FONTSMOOTHINGCLEARTYPE 0x2
7178 /* Determine if Cleartype is in use. Used to enable a hack in
7179 the char metric calculations which adds extra pixels to
7180 compensate for the "sub-pixels" that are not counted by the
7183 SystemParametersInfo (SPI_GETFONTSMOOTHING
, 0, &smoothing_enabled
, 0)
7184 && smoothing_enabled
7185 && SystemParametersInfo (SPI_GETFONTSMOOTHINGTYPE
, 0, &smoothing_type
, 0)
7186 && smoothing_type
== FE_FONTSMOOTHINGCLEARTYPE
;
7193 staticpro (&w32_display_name_list
);
7194 w32_display_name_list
= Qnil
;
7196 staticpro (&last_mouse_scroll_bar
);
7197 last_mouse_scroll_bar
= Qnil
;
7199 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
7201 DEFVAR_INT ("w32-num-mouse-buttons",
7202 &w32_num_mouse_buttons
,
7203 doc
: /* Number of physical mouse buttons. */);
7204 w32_num_mouse_buttons
= 2;
7206 DEFVAR_LISP ("w32-swap-mouse-buttons",
7207 &Vw32_swap_mouse_buttons
,
7208 doc
: /* Swap the mapping of middle and right mouse buttons.
7209 When nil, middle button is mouse-2 and right button is mouse-3. */);
7210 Vw32_swap_mouse_buttons
= Qnil
;
7212 DEFVAR_LISP ("w32-grab-focus-on-raise",
7213 &Vw32_grab_focus_on_raise
,
7214 doc
: /* Raised frame grabs input focus.
7215 When t, `raise-frame' grabs input focus as well. This fits well
7216 with the normal Windows click-to-focus policy, but might not be
7217 desirable when using a point-to-focus policy. */);
7218 Vw32_grab_focus_on_raise
= Qt
;
7220 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7221 &Vw32_capslock_is_shiftlock
,
7222 doc
: /* Apply CapsLock state to non character input keys.
7223 When nil, CapsLock only affects normal character input keys. */);
7224 Vw32_capslock_is_shiftlock
= Qnil
;
7226 DEFVAR_LISP ("w32-recognize-altgr",
7227 &Vw32_recognize_altgr
,
7228 doc
: /* Recognize right-alt and left-ctrl as AltGr.
7229 When nil, the right-alt and left-ctrl key combination is
7230 interpreted normally. */);
7231 Vw32_recognize_altgr
= Qt
;
7233 DEFVAR_BOOL ("w32-enable-unicode-output",
7234 &w32_enable_unicode_output
,
7235 doc
: /* Enable the use of Unicode for text output if non-nil.
7236 Unicode output may prevent some third party applications for displaying
7237 Far-East Languages on Windows 95/98 from working properly.
7238 NT uses Unicode internally anyway, so this flag will probably have no
7239 effect on NT machines. */);
7240 w32_enable_unicode_output
= 1;
7242 DEFVAR_BOOL ("w32-use-visible-system-caret",
7243 &w32_use_visible_system_caret
,
7244 doc
: /* Flag to make the system caret visible.
7245 When this is non-nil, Emacs will indicate the position of point by
7246 using the system caret instead of drawing its own cursor. Some screen
7247 reader software does not track the system cursor properly when it is
7248 invisible, and gets confused by Emacs drawing its own cursor, so this
7249 variable is initialized to t when Emacs detects that screen reader
7250 software is running as it starts up.
7252 When this variable is set, other variables affecting the appearance of
7253 the cursor have no effect. */);
7255 w32_use_visible_system_caret
= 0;
7257 /* We don't yet support this, but defining this here avoids whining
7258 from cus-start.el and other places, like "M-x set-variable". */
7259 DEFVAR_BOOL ("x-use-underline-position-properties",
7260 &x_use_underline_position_properties
,
7261 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
7262 A value of nil means ignore them. If you encounter fonts with bogus
7263 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7264 to 4.1, set this to nil.
7266 NOTE: Not supported on MS-Windows yet. */);
7267 x_use_underline_position_properties
= 0;
7269 DEFVAR_BOOL ("x-underline-at-descent-line",
7270 &x_underline_at_descent_line
,
7271 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
7272 A value of nil means to draw the underline according to the value of the
7273 variable `x-use-underline-position-properties', which is usually at the
7274 baseline level. The default value is nil. */);
7275 x_underline_at_descent_line
= 0;
7277 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
7278 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
7279 Vx_toolkit_scroll_bars
= Qt
;
7281 staticpro (&last_mouse_motion_frame
);
7282 last_mouse_motion_frame
= Qnil
;
7285 /* arch-tag: 5fa70624-ab86-499c-8a85-473958ee4646
7286 (do not change this comment) */