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
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2834 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
))
2835 /* We must clip just this glyph. left_overhang part has already
2836 drawn when s->prev was drawn, and right_overhang part will be
2837 drawn later when s->next is drawn. */
2838 x_set_glyph_string_clipping_exactly (s
, s
);
2840 x_set_glyph_string_clipping (s
);
2842 switch (s
->first_glyph
->type
)
2845 x_draw_image_glyph_string (s
);
2849 x_draw_stretch_glyph_string (s
);
2853 if (s
->for_overlaps
)
2854 s
->background_filled_p
= 1;
2856 x_draw_glyph_string_background (s
, 0);
2857 x_draw_glyph_string_foreground (s
);
2860 case COMPOSITE_GLYPH
:
2861 if (s
->for_overlaps
|| s
->gidx
> 0)
2862 s
->background_filled_p
= 1;
2864 x_draw_glyph_string_background (s
, 1);
2865 x_draw_composite_glyph_string_foreground (s
);
2872 if (!s
->for_overlaps
)
2874 /* Draw underline. */
2875 if (s
->face
->underline_p
)
2877 unsigned long thickness
, position
;
2880 if (s
->prev
&& s
->prev
->face
->underline_p
)
2882 /* We use the same underline style as the previous one. */
2883 thickness
= s
->prev
->underline_thickness
;
2884 position
= s
->prev
->underline_position
;
2888 /* Get the underline thickness. Default is 1 pixel. */
2889 if (s
->font
&& s
->font
->underline_thickness
> 0)
2890 thickness
= s
->font
->underline_thickness
;
2893 if (x_underline_at_descent_line
)
2894 position
= (s
->height
- thickness
) - s
->ybase
;
2897 /* Get the underline position. This is the recommended
2898 vertical offset in pixels from the baseline to the top of
2899 the underline. This is a signed value according to the
2900 specs, and its default is
2902 ROUND ((maximum_descent) / 2), with
2903 ROUND (x) = floor (x + 0.5) */
2905 if (x_use_underline_position_properties
2906 && s
->font
&& s
->font
->underline_position
>= 0)
2907 position
= s
->font
->underline_position
;
2909 position
= (s
->font
->descent
+ 1) / 2;
2911 s
->underline_thickness
= thickness
;
2912 s
->underline_position
=position
;
2914 y
= s
->ybase
+ position
;
2915 if (s
->face
->underline_defaulted_p
)
2917 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2918 y
, s
->background_width
, 1);
2922 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2923 y
, s
->background_width
, 1);
2926 /* Draw overline. */
2927 if (s
->face
->overline_p
)
2929 unsigned long dy
= 0, h
= 1;
2931 if (s
->face
->overline_color_defaulted_p
)
2933 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2934 s
->y
+ dy
, s
->background_width
, h
);
2938 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2939 s
->y
+ dy
, s
->background_width
, h
);
2943 /* Draw strike-through. */
2944 if (s
->face
->strike_through_p
2945 && (FONT_COMPAT (s
->font
)->bdf
2946 || !FONT_COMPAT (s
->font
)->tm
.tmStruckOut
))
2948 unsigned long h
= 1;
2949 unsigned long dy
= (s
->height
- h
) / 2;
2951 if (s
->face
->strike_through_color_defaulted_p
)
2953 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2958 w32_fill_area (s
->f
, s
->hdc
, s
->face
->strike_through_color
, s
->x
,
2959 s
->y
+ dy
, s
->width
, h
);
2963 /* Draw relief if not yet drawn. */
2964 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2965 x_draw_glyph_string_box (s
);
2969 struct glyph_string
*prev
;
2971 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2972 if (prev
->hl
!= s
->hl
2973 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2975 /* As prev was drawn while clipped to its own area, we
2976 must draw the right_overhang part using s->hl now. */
2977 enum draw_glyphs_face save
= prev
->hl
;
2980 x_set_glyph_string_gc (prev
);
2981 x_set_glyph_string_clipping_exactly (s
, prev
);
2982 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2983 x_draw_glyph_string_foreground (prev
);
2985 x_draw_composite_glyph_string_foreground (prev
);
2986 w32_set_clip_rectangle (prev
->hdc
, NULL
);
2988 prev
->num_clips
= 0;
2994 struct glyph_string
*next
;
2996 for (next
= s
->next
; next
; next
= next
->next
)
2997 if (next
->hl
!= s
->hl
2998 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
3000 /* As next will be drawn while clipped to its own area,
3001 we must draw the left_overhang part using s->hl now. */
3002 enum draw_glyphs_face save
= next
->hl
;
3005 x_set_glyph_string_gc (next
);
3006 x_set_glyph_string_clipping_exactly (s
, next
);
3007 if (next
->first_glyph
->type
== CHAR_GLYPH
)
3008 x_draw_glyph_string_foreground (next
);
3010 x_draw_composite_glyph_string_foreground (next
);
3011 w32_set_clip_rectangle (next
->hdc
, NULL
);
3013 next
->num_clips
= 0;
3018 /* Reset clipping. */
3019 w32_set_clip_rectangle (s
->hdc
, NULL
);
3024 /* Shift display to make room for inserted glyphs. */
3027 w32_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
3029 int x
, y
, width
, height
, shift_by
;
3033 hdc
= get_frame_dc (f
);
3034 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
3035 hdc
, x
, y
, SRCCOPY
);
3037 release_frame_dc (f
, hdc
);
3041 /* Delete N glyphs at the nominal cursor position. Not implemented
3045 x_delete_glyphs (f
, n
)
3049 if (! FRAME_W32_P (f
))
3056 /* Clear entire frame. If updating_frame is non-null, clear that
3057 frame. Otherwise clear the selected frame. */
3060 x_clear_frame (struct frame
*f
)
3062 if (! FRAME_W32_P (f
))
3065 /* Clearing the frame will erase any cursor, so mark them all as no
3067 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3068 output_cursor
.hpos
= output_cursor
.vpos
= 0;
3069 output_cursor
.x
= -1;
3071 /* We don't set the output cursor here because there will always
3072 follow an explicit cursor_to. */
3075 w32_clear_window (f
);
3077 /* We have to clear the scroll bars, too. If we have changed
3078 colors or something like that, then they should be notified. */
3079 x_scroll_bar_clear (f
);
3085 /* Make audible bell. */
3088 w32_ring_bell (struct frame
*f
)
3092 if (FRAME_W32_P (f
) && visible_bell
)
3095 HWND hwnd
= FRAME_W32_WINDOW (f
);
3097 for (i
= 0; i
< 5; i
++)
3099 FlashWindow (hwnd
, TRUE
);
3102 FlashWindow (hwnd
, FALSE
);
3105 w32_sys_ring_bell (f
);
3111 /* Specify how many text lines, from the top of the window,
3112 should be affected by insert-lines and delete-lines operations.
3113 This, and those operations, are used only within an update
3114 that is bounded by calls to x_update_begin and x_update_end. */
3117 w32_set_terminal_window (n
)
3120 /* This function intentionally left blank. */
3124 /***********************************************************************
3126 ***********************************************************************/
3128 /* Perform an insert-lines or delete-lines operation, inserting N
3129 lines or deleting -N lines at vertical position VPOS. */
3132 x_ins_del_lines (f
, vpos
, n
)
3136 if (! FRAME_W32_P (f
))
3143 /* Scroll part of the display as described by RUN. */
3146 x_scroll_run (w
, run
)
3150 struct frame
*f
= XFRAME (w
->frame
);
3151 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3152 HWND hwnd
= FRAME_W32_WINDOW (f
);
3155 /* Get frame-relative bounding box of the text display area of W,
3156 without mode lines. Include in this box the left and right
3158 window_box (w
, -1, &x
, &y
, &width
, &height
);
3160 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3161 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3162 bottom_y
= y
+ height
;
3166 /* Scrolling up. Make sure we don't copy part of the mode
3167 line at the bottom. */
3168 if (from_y
+ run
->height
> bottom_y
)
3169 height
= bottom_y
- from_y
;
3171 height
= run
->height
;
3172 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
3176 /* Scolling down. Make sure we don't copy over the mode line.
3178 if (to_y
+ run
->height
> bottom_y
)
3179 height
= bottom_y
- to_y
;
3181 height
= run
->height
;
3182 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
3187 /* Cursor off. Will be switched on again in x_update_window_end. */
3194 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
3195 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
3197 from
.left
= to
.left
= x
;
3198 from
.right
= to
.right
= x
+ width
;
3200 from
.bottom
= from_y
+ height
;
3202 to
.bottom
= bottom_y
;
3204 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
3205 NULL
, SW_INVALIDATE
);
3207 /* Combine this with what we expect to be dirty. This covers the
3208 case where not all of the region we expect is actually dirty. */
3209 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
3211 /* If the dirty region is not what we expected, redraw the entire frame. */
3212 if (!EqualRgn (combined
, expect_dirty
))
3213 SET_FRAME_GARBAGED (f
);
3215 DeleteObject (dirty
);
3216 DeleteObject (combined
);
3220 DeleteObject (expect_dirty
);
3225 /***********************************************************************
3227 ***********************************************************************/
3233 x_update_cursor (f
, 1);
3237 frame_unhighlight (f
)
3240 x_update_cursor (f
, 1);
3243 /* The focus has changed. Update the frames as necessary to reflect
3244 the new situation. Note that we can't change the selected frame
3245 here, because the Lisp code we are interrupting might become confused.
3246 Each event gets marked with the frame in which it occurred, so the
3247 Lisp code can tell when the switch took place by examining the events. */
3250 x_new_focus_frame (dpyinfo
, frame
)
3251 struct w32_display_info
*dpyinfo
;
3252 struct frame
*frame
;
3254 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
3256 if (frame
!= dpyinfo
->w32_focus_frame
)
3258 /* Set this before calling other routines, so that they see
3259 the correct value of w32_focus_frame. */
3260 dpyinfo
->w32_focus_frame
= frame
;
3262 if (old_focus
&& old_focus
->auto_lower
)
3263 x_lower_frame (old_focus
);
3265 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
3266 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
3268 pending_autoraise_frame
= 0;
3271 x_frame_rehighlight (dpyinfo
);
3275 /* Handle FocusIn and FocusOut state changes for FRAME.
3276 If FRAME has focus and there exists more than one frame, puts
3277 a FOCUS_IN_EVENT into *BUFP. */
3280 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
)
3283 struct w32_display_info
*dpyinfo
;
3284 struct frame
*frame
;
3285 struct input_event
*bufp
;
3287 if (type
== WM_SETFOCUS
)
3289 if (dpyinfo
->w32_focus_event_frame
!= frame
)
3291 x_new_focus_frame (dpyinfo
, frame
);
3292 dpyinfo
->w32_focus_event_frame
= frame
;
3294 /* Don't stop displaying the initial startup message
3295 for a switch-frame event we don't need. */
3296 if (NILP (Vterminal_frame
)
3297 && CONSP (Vframe_list
)
3298 && !NILP (XCDR (Vframe_list
)))
3300 bufp
->kind
= FOCUS_IN_EVENT
;
3301 XSETFRAME (bufp
->frame_or_window
, frame
);
3305 frame
->output_data
.x
->focus_state
|= state
;
3307 /* TODO: IME focus? */
3309 else if (type
== WM_KILLFOCUS
)
3311 frame
->output_data
.x
->focus_state
&= ~state
;
3313 if (dpyinfo
->w32_focus_event_frame
== frame
)
3315 dpyinfo
->w32_focus_event_frame
= 0;
3316 x_new_focus_frame (dpyinfo
, 0);
3319 /* TODO: IME focus? */
3324 /* The focus may have changed. Figure out if it is a real focus change,
3325 by checking both FocusIn/Out and Enter/LeaveNotify events.
3327 Returns FOCUS_IN_EVENT event in *BUFP. */
3330 w32_detect_focus_change (dpyinfo
, event
, bufp
)
3331 struct w32_display_info
*dpyinfo
;
3333 struct input_event
*bufp
;
3335 struct frame
*frame
;
3337 frame
= x_any_window_to_frame (dpyinfo
, event
->msg
.hwnd
);
3341 /* On w32, this is only called from focus events, so no switch needed. */
3342 x_focus_changed (event
->msg
.message
,
3343 (event
->msg
.message
== WM_KILLFOCUS
?
3344 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3345 dpyinfo
, frame
, bufp
);
3349 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3352 x_mouse_leave (dpyinfo
)
3353 struct w32_display_info
*dpyinfo
;
3355 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
3358 /* The focus has changed, or we have redirected a frame's focus to
3359 another frame (this happens when a frame uses a surrogate
3360 mini-buffer frame). Shift the highlight as appropriate.
3362 The FRAME argument doesn't necessarily have anything to do with which
3363 frame is being highlighted or un-highlighted; we only use it to find
3364 the appropriate X display info. */
3367 w32_frame_rehighlight (frame
)
3368 struct frame
*frame
;
3370 if (! FRAME_W32_P (frame
))
3372 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
3376 x_frame_rehighlight (dpyinfo
)
3377 struct w32_display_info
*dpyinfo
;
3379 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3381 if (dpyinfo
->w32_focus_frame
)
3383 dpyinfo
->x_highlight_frame
3384 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
3385 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
3386 : dpyinfo
->w32_focus_frame
);
3387 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3389 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
3390 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
3394 dpyinfo
->x_highlight_frame
= 0;
3396 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3399 frame_unhighlight (old_highlight
);
3400 if (dpyinfo
->x_highlight_frame
)
3401 frame_highlight (dpyinfo
->x_highlight_frame
);
3405 /* Keyboard processing - modifier keys, etc. */
3407 /* Convert a keysym to its name. */
3410 x_get_keysym_name (keysym
)
3413 /* Make static so we can always return it */
3414 static char value
[100];
3417 GetKeyNameText (keysym
, value
, 100);
3425 /* Mouse clicks and mouse movement. Rah. */
3427 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
3428 the state in PUP. XBUTTON provides extra information for extended mouse
3429 button messages. Returns FALSE if unable to parse the message. */
3431 parse_button (message
, xbutton
, pbutton
, pup
)
3442 case WM_LBUTTONDOWN
:
3450 case WM_MBUTTONDOWN
:
3451 if (NILP (Vw32_swap_mouse_buttons
))
3458 if (NILP (Vw32_swap_mouse_buttons
))
3464 case WM_RBUTTONDOWN
:
3465 if (NILP (Vw32_swap_mouse_buttons
))
3472 if (NILP (Vw32_swap_mouse_buttons
))
3478 case WM_XBUTTONDOWN
:
3479 button
= xbutton
+ 2;
3483 button
= xbutton
+ 2;
3491 if (pbutton
) *pbutton
= button
;
3497 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3499 If the event is a button press, then note that we have grabbed
3503 construct_mouse_click (result
, msg
, f
)
3504 struct input_event
*result
;
3511 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
3514 /* Make the event type NO_EVENT; we'll change that when we decide
3516 result
->kind
= MOUSE_CLICK_EVENT
;
3517 result
->code
= button
;
3518 result
->timestamp
= msg
->msg
.time
;
3519 result
->modifiers
= (msg
->dwModifiers
3524 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3525 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3526 XSETFRAME (result
->frame_or_window
, f
);
3532 construct_mouse_wheel (result
, msg
, f
)
3533 struct input_event
*result
;
3540 result
->kind
= msg
->msg
.message
== WM_MOUSEHWHEEL
? HORIZ_WHEEL_EVENT
3543 result
->timestamp
= msg
->msg
.time
;
3545 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3546 forward, away from the user (up); a negative value indicates that
3547 the wheel was rotated backward, toward the user (down). */
3548 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3550 /* The up and down modifiers indicate if the wheel was rotated up or
3551 down based on WHEEL_DELTA value. */
3552 result
->modifiers
= (msg
->dwModifiers
3553 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3555 /* With multiple monitors, we can legitimately get negative
3556 coordinates, so cast to short to interpret them correctly. */
3557 p
.x
= (short) LOWORD (msg
->msg
.lParam
);
3558 p
.y
= (short) HIWORD (msg
->msg
.lParam
);
3559 ScreenToClient (msg
->msg
.hwnd
, &p
);
3560 XSETINT (result
->x
, p
.x
);
3561 XSETINT (result
->y
, p
.y
);
3562 XSETFRAME (result
->frame_or_window
, f
);
3568 construct_drag_n_drop (result
, msg
, f
)
3569 struct input_event
*result
;
3581 result
->kind
= DRAG_N_DROP_EVENT
;
3583 result
->timestamp
= msg
->msg
.time
;
3584 result
->modifiers
= msg
->dwModifiers
;
3586 hdrop
= (HDROP
) msg
->msg
.wParam
;
3587 DragQueryPoint (hdrop
, &p
);
3590 p
.x
= LOWORD (msg
->msg
.lParam
);
3591 p
.y
= HIWORD (msg
->msg
.lParam
);
3592 ScreenToClient (msg
->msg
.hwnd
, &p
);
3595 XSETINT (result
->x
, p
.x
);
3596 XSETINT (result
->y
, p
.y
);
3598 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3601 for (i
= 0; i
< num_files
; i
++)
3603 len
= DragQueryFile (hdrop
, i
, NULL
, 0);
3606 name
= alloca (len
+ 1);
3607 DragQueryFile (hdrop
, i
, name
, len
+ 1);
3608 files
= Fcons (DECODE_FILE (build_string (name
)), files
);
3613 XSETFRAME (frame
, f
);
3614 result
->frame_or_window
= frame
;
3615 result
->arg
= files
;
3620 /* Function to report a mouse movement to the mainstream Emacs code.
3621 The input handler calls this.
3623 We have received a mouse movement event, which is given in *event.
3624 If the mouse is over a different glyph than it was last time, tell
3625 the mainstream emacs code by setting mouse_moved. If not, ask for
3626 another motion event, so we can check again the next time it moves. */
3628 static MSG last_mouse_motion_event
;
3629 static Lisp_Object last_mouse_motion_frame
;
3632 note_mouse_movement (frame
, msg
)
3636 int mouse_x
= LOWORD (msg
->lParam
);
3637 int mouse_y
= HIWORD (msg
->lParam
);
3639 last_mouse_movement_time
= msg
->time
;
3640 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
3641 XSETFRAME (last_mouse_motion_frame
, frame
);
3643 if (!FRAME_X_OUTPUT (frame
))
3646 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3648 frame
->mouse_moved
= 1;
3649 last_mouse_scroll_bar
= Qnil
;
3650 note_mouse_highlight (frame
, -1, -1);
3651 last_mouse_glyph_frame
= 0;
3655 /* Has the mouse moved off the glyph it was on at the last sighting? */
3656 if (frame
!= last_mouse_glyph_frame
3657 || mouse_x
< last_mouse_glyph
.left
3658 || mouse_x
>= last_mouse_glyph
.right
3659 || mouse_y
< last_mouse_glyph
.top
3660 || mouse_y
>= last_mouse_glyph
.bottom
)
3662 frame
->mouse_moved
= 1;
3663 last_mouse_scroll_bar
= Qnil
;
3664 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3665 /* Remember the mouse position here, as w32_mouse_position only
3666 gets called when mouse tracking is enabled but we also need
3667 to keep track of the mouse for help_echo and highlighting at
3669 remember_mouse_glyph (frame
, mouse_x
, mouse_y
, &last_mouse_glyph
);
3670 last_mouse_glyph_frame
= frame
;
3678 /************************************************************************
3680 ************************************************************************/
3682 static struct scroll_bar
*x_window_to_scroll_bar ();
3683 static void x_scroll_bar_report_motion ();
3684 static void x_check_fullscreen
P_ ((struct frame
*));
3687 redo_mouse_highlight ()
3689 if (!NILP (last_mouse_motion_frame
)
3690 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3691 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3692 LOWORD (last_mouse_motion_event
.lParam
),
3693 HIWORD (last_mouse_motion_event
.lParam
));
3697 w32_define_cursor (window
, cursor
)
3701 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3703 /* Return the current position of the mouse.
3704 *fp should be a frame which indicates which display to ask about.
3706 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3707 and *part to the frame, window, and scroll bar part that the mouse
3708 is over. Set *x and *y to the portion and whole of the mouse's
3709 position on the scroll bar.
3711 If the mouse movement started elsewhere, set *fp to the frame the
3712 mouse is on, *bar_window to nil, and *x and *y to the character cell
3715 Set *time to the server time-stamp for the time at which the mouse
3716 was at this position.
3718 Don't store anything if we don't have a valid set of values to report.
3720 This clears the mouse_moved flag, so we can wait for the next mouse
3724 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3727 Lisp_Object
*bar_window
;
3728 enum scroll_bar_part
*part
;
3730 unsigned long *time
;
3736 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3737 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3742 Lisp_Object frame
, tail
;
3744 /* Clear the mouse-moved flag for every frame on this display. */
3745 FOR_EACH_FRAME (tail
, frame
)
3746 XFRAME (frame
)->mouse_moved
= 0;
3748 last_mouse_scroll_bar
= Qnil
;
3752 /* Now we have a position on the root; find the innermost window
3753 containing the pointer. */
3755 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3756 && FRAME_LIVE_P (last_mouse_frame
))
3758 /* If mouse was grabbed on a frame, give coords for that frame
3759 even if the mouse is now outside it. */
3760 f1
= last_mouse_frame
;
3764 /* Is window under mouse one of our frames? */
3765 f1
= x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
3766 WindowFromPoint (pt
));
3769 /* If not, is it one of our scroll bars? */
3772 struct scroll_bar
*bar
3773 = x_window_to_scroll_bar (WindowFromPoint (pt
));
3777 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3781 if (f1
== 0 && insist
> 0)
3782 f1
= SELECTED_FRAME ();
3786 /* Ok, we found a frame. Store all the values.
3787 last_mouse_glyph is a rectangle used to reduce the
3788 generation of mouse events. To not miss any motion
3789 events, we must divide the frame into rectangles of the
3790 size of the smallest character that could be displayed
3791 on it, i.e. into the same rectangles that matrices on
3792 the frame are divided into. */
3794 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3795 remember_mouse_glyph (f1
, pt
.x
, pt
.y
, &last_mouse_glyph
);
3796 last_mouse_glyph_frame
= f1
;
3803 *time
= last_mouse_movement_time
;
3812 /***********************************************************************
3814 ***********************************************************************/
3816 /* Handle mouse button event on the tool-bar of frame F, at
3817 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
3821 w32_handle_tool_bar_click (f
, button_event
)
3823 struct input_event
*button_event
;
3825 int x
= XFASTINT (button_event
->x
);
3826 int y
= XFASTINT (button_event
->y
);
3828 if (button_event
->modifiers
& down_modifier
)
3829 handle_tool_bar_click (f
, x
, y
, 1, 0);
3831 handle_tool_bar_click (f
, x
, y
, 0,
3832 button_event
->modifiers
& ~up_modifier
);
3837 /***********************************************************************
3839 ***********************************************************************/
3841 /* Scroll bar support. */
3843 /* Given a window ID, find the struct scroll_bar which manages it.
3844 This can be called in GC, so we have to make sure to strip off mark
3847 static struct scroll_bar
*
3848 x_window_to_scroll_bar (window_id
)
3853 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3855 Lisp_Object frame
, bar
, condemned
;
3857 frame
= XCAR (tail
);
3858 /* All elements of Vframe_list should be frames. */
3859 if (! FRAMEP (frame
))
3862 /* Scan this frame's scroll bar list for a scroll bar with the
3864 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3865 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3866 /* This trick allows us to search both the ordinary and
3867 condemned scroll bar lists with one loop. */
3868 ! NILP (bar
) || (bar
= condemned
,
3871 bar
= XSCROLL_BAR (bar
)->next
)
3872 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
3873 return XSCROLL_BAR (bar
);
3881 /* Set the thumb size and position of scroll bar BAR. We are currently
3882 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3885 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
)
3886 struct scroll_bar
*bar
;
3887 int portion
, position
, whole
;
3889 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3890 /* We use the whole scroll-bar height in the calculations below, to
3891 avoid strange effects like scrolling backwards when just clicking
3892 on the handle (without moving it). */
3893 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
))
3894 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3895 int sb_page
, sb_pos
;
3896 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
3899 /* We used to change the nPage setting while dragging the handle,
3900 but that had very strange effects (such as scrolling backwards
3901 while dragging downwards).
3903 Now, we don't change the nPage setting while dragging unless we
3904 get near to the end of the buffer, in which case we often have to
3905 resize the handle to "go all the way". */
3911 si
.cbSize
= sizeof (si
);
3912 si
.fMask
= SIF_POS
| SIF_PAGE
;
3913 GetScrollInfo(w
, SB_CTL
, &si
);
3914 near_bottom_p
= si
.nPos
+ si
.nPage
>= range
;
3922 /* Position scroll bar at rock bottom if the bottom of the
3923 buffer is visible. This avoids shinking the thumb away
3924 to nothing if it is held at the bottom of the buffer. */
3925 if (position
+ portion
>= whole
&& !draggingp
)
3927 sb_page
= range
* (whole
- position
) / whole
;
3932 sb_pos
= position
* range
/ whole
;
3933 sb_page
= (min (portion
, (whole
- position
)) * range
) / whole
;
3942 sb_page
= max (sb_page
, VERTICAL_SCROLL_BAR_MIN_HANDLE
);
3946 si
.cbSize
= sizeof (si
);
3947 si
.fMask
= SIF_PAGE
| SIF_POS
;
3951 SetScrollInfo (w
, SB_CTL
, &si
, TRUE
);
3957 /************************************************************************
3958 Scroll bars, general
3959 ************************************************************************/
3962 my_create_scrollbar (f
, bar
)
3964 struct scroll_bar
* bar
;
3966 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3967 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
3971 /*#define ATTACH_THREADS*/
3974 my_show_window (FRAME_PTR f
, HWND hwnd
, int how
)
3976 #ifndef ATTACH_THREADS
3977 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3978 (WPARAM
) hwnd
, (LPARAM
) how
);
3980 return ShowWindow (hwnd
, how
);
3985 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3986 int x
, int y
, int cx
, int cy
, UINT flags
)
3988 #ifndef ATTACH_THREADS
3990 pos
.hwndInsertAfter
= hwndAfter
;
3996 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
3998 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
4003 my_set_focus (f
, hwnd
)
4007 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
4012 my_set_foreground_window (hwnd
)
4015 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
4020 my_destroy_window (f
, hwnd
)
4024 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
4028 /* Create a scroll bar and return the scroll bar vector for it. W is
4029 the Emacs window on which to create the scroll bar. TOP, LEFT,
4030 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
4033 static struct scroll_bar
*
4034 x_scroll_bar_create (w
, top
, left
, width
, height
)
4036 int top
, left
, width
, height
;
4038 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4041 struct scroll_bar
*bar
4042 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
4046 XSETWINDOW (bar
->window
, w
);
4047 XSETINT (bar
->top
, top
);
4048 XSETINT (bar
->left
, left
);
4049 XSETINT (bar
->width
, width
);
4050 XSETINT (bar
->height
, height
);
4051 XSETINT (bar
->start
, 0);
4052 XSETINT (bar
->end
, 0);
4053 bar
->dragging
= Qnil
;
4054 bar
->fringe_extended_p
= Qnil
;
4056 /* Requires geometry to be set before call to create the real window */
4058 hwnd
= my_create_scrollbar (f
, bar
);
4060 si
.cbSize
= sizeof (si
);
4063 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
4064 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4068 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
4070 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
4072 /* Add bar to its frame's list of scroll bars. */
4073 bar
->next
= FRAME_SCROLL_BARS (f
);
4075 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4076 if (! NILP (bar
->next
))
4077 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4085 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
4089 x_scroll_bar_remove (bar
)
4090 struct scroll_bar
*bar
;
4092 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4096 /* Destroy the window. */
4097 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
4099 /* Disassociate this scroll bar from its window. */
4100 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
4105 /* Set the handle of the vertical scroll bar for WINDOW to indicate
4106 that we are displaying PORTION characters out of a total of WHOLE
4107 characters, starting at POSITION. If WINDOW has no scroll bar,
4110 w32_set_vertical_scroll_bar (w
, portion
, whole
, position
)
4112 int portion
, whole
, position
;
4114 struct frame
*f
= XFRAME (w
->frame
);
4115 struct scroll_bar
*bar
;
4116 int top
, height
, left
, sb_left
, width
, sb_width
;
4117 int window_y
, window_height
;
4118 int fringe_extended_p
;
4120 /* Get window dimensions. */
4121 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
4123 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
4124 height
= window_height
;
4126 /* Compute the left edge of the scroll bar area. */
4127 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
4129 /* Compute the width of the scroll bar which might be less than
4130 the width of the area reserved for the scroll bar. */
4131 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
4132 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
4136 /* Compute the left edge of the scroll bar. */
4137 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
4138 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
4140 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
4142 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
4143 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
4144 && WINDOW_LEFT_FRINGE_WIDTH (w
)
4145 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
4146 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
4148 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
4149 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
4150 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
4151 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
4153 /* Does the scroll bar exist yet? */
4154 if (NILP (w
->vertical_scroll_bar
))
4158 if (width
> 0 && height
> 0)
4160 hdc
= get_frame_dc (f
);
4161 if (fringe_extended_p
)
4162 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
4164 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
4165 release_frame_dc (f
, hdc
);
4169 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
4173 /* It may just need to be moved and resized. */
4176 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4177 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
4179 /* If already correctly positioned, do nothing. */
4180 if ( XINT (bar
->left
) == sb_left
4181 && XINT (bar
->top
) == top
4182 && XINT (bar
->width
) == sb_width
4183 && XINT (bar
->height
) == height
4184 && !NILP (bar
->fringe_extended_p
) == fringe_extended_p
)
4186 /* Redraw after clear_frame. */
4187 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
4188 InvalidateRect (hwnd
, NULL
, FALSE
);
4196 if (width
&& height
)
4198 hdc
= get_frame_dc (f
);
4199 /* Since Windows scroll bars are smaller than the space reserved
4200 for them on the frame, we have to clear "under" them. */
4201 if (fringe_extended_p
)
4202 w32_clear_area (f
, hdc
, sb_left
, top
, sb_width
, height
);
4204 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
4205 release_frame_dc (f
, hdc
);
4207 /* Make sure scroll bar is "visible" before moving, to ensure the
4208 area of the parent window now exposed will be refreshed. */
4209 my_show_window (f
, hwnd
, SW_HIDE
);
4210 MoveWindow (hwnd
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4211 top
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4212 max (height
, 1), TRUE
);
4214 si
.cbSize
= sizeof (si
);
4215 si
.fMask
= SIF_RANGE
;
4217 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
4218 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4220 SetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
4222 my_show_window (f
, hwnd
, SW_NORMAL
);
4223 /* InvalidateRect (w, NULL, FALSE); */
4225 /* Remember new settings. */
4226 XSETINT (bar
->left
, sb_left
);
4227 XSETINT (bar
->top
, top
);
4228 XSETINT (bar
->width
, sb_width
);
4229 XSETINT (bar
->height
, height
);
4234 bar
->fringe_extended_p
= fringe_extended_p
? Qt
: Qnil
;
4236 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
4238 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
4242 /* The following three hooks are used when we're doing a thorough
4243 redisplay of the frame. We don't explicitly know which scroll bars
4244 are going to be deleted, because keeping track of when windows go
4245 away is a real pain - "Can you say set-window-configuration, boys
4246 and girls?" Instead, we just assert at the beginning of redisplay
4247 that *all* scroll bars are to be removed, and then save a scroll bar
4248 from the fiery pit when we actually redisplay its window. */
4250 /* Arrange for all scroll bars on FRAME to be removed at the next call
4251 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
4252 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
4255 w32_condemn_scroll_bars (frame
)
4258 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
4259 while (! NILP (FRAME_SCROLL_BARS (frame
)))
4262 bar
= FRAME_SCROLL_BARS (frame
);
4263 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
4264 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
4265 XSCROLL_BAR (bar
)->prev
= Qnil
;
4266 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
4267 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
4268 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
4273 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
4274 Note that WINDOW isn't necessarily condemned at all. */
4277 w32_redeem_scroll_bar (window
)
4278 struct window
*window
;
4280 struct scroll_bar
*bar
;
4283 /* We can't redeem this window's scroll bar if it doesn't have one. */
4284 if (NILP (window
->vertical_scroll_bar
))
4287 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
4289 /* Unlink it from the condemned list. */
4290 f
= XFRAME (WINDOW_FRAME (window
));
4291 if (NILP (bar
->prev
))
4293 /* If the prev pointer is nil, it must be the first in one of
4295 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
4296 /* It's not condemned. Everything's fine. */
4298 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
4299 window
->vertical_scroll_bar
))
4300 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
4302 /* If its prev pointer is nil, it must be at the front of
4303 one or the other! */
4307 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
4309 if (! NILP (bar
->next
))
4310 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
4312 bar
->next
= FRAME_SCROLL_BARS (f
);
4314 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4315 if (! NILP (bar
->next
))
4316 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4319 /* Remove all scroll bars on FRAME that haven't been saved since the
4320 last call to `*condemn_scroll_bars_hook'. */
4323 w32_judge_scroll_bars (f
)
4326 Lisp_Object bar
, next
;
4328 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
4330 /* Clear out the condemned list now so we won't try to process any
4331 more events on the hapless scroll bars. */
4332 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
4334 for (; ! NILP (bar
); bar
= next
)
4336 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
4338 x_scroll_bar_remove (b
);
4341 b
->next
= b
->prev
= Qnil
;
4344 /* Now there should be no references to the condemned scroll bars,
4345 and they should get garbage-collected. */
4348 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
4349 is set to something other than NO_EVENT, it is enqueued.
4351 This may be called from a signal handler, so we have to ignore GC
4355 w32_scroll_bar_handle_click (bar
, msg
, emacs_event
)
4356 struct scroll_bar
*bar
;
4358 struct input_event
*emacs_event
;
4360 if (! WINDOWP (bar
->window
))
4363 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
4364 emacs_event
->code
= 0;
4365 /* not really meaningful to distinguish up/down */
4366 emacs_event
->modifiers
= msg
->dwModifiers
;
4367 emacs_event
->frame_or_window
= bar
->window
;
4368 emacs_event
->arg
= Qnil
;
4369 emacs_event
->timestamp
= msg
->msg
.time
;
4372 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4374 int dragging
= !NILP (bar
->dragging
);
4377 si
.cbSize
= sizeof (si
);
4380 GetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
4383 bar
->dragging
= Qnil
;
4386 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
4388 switch (LOWORD (msg
->msg
.wParam
))
4391 emacs_event
->part
= scroll_bar_down_arrow
;
4394 emacs_event
->part
= scroll_bar_up_arrow
;
4397 emacs_event
->part
= scroll_bar_above_handle
;
4400 emacs_event
->part
= scroll_bar_below_handle
;
4403 emacs_event
->part
= scroll_bar_handle
;
4407 emacs_event
->part
= scroll_bar_handle
;
4411 case SB_THUMBPOSITION
:
4412 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
4413 y
= HIWORD (msg
->msg
.wParam
);
4415 emacs_event
->part
= scroll_bar_handle
;
4417 /* "Silently" update current position. */
4421 si
.cbSize
= sizeof (si
);
4424 /* Remember apparent position (we actually lag behind the real
4425 position, so don't set that directly. */
4426 last_scroll_bar_drag_pos
= y
;
4428 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4432 /* If this is the end of a drag sequence, then reset the scroll
4433 handle size to normal and do a final redraw. Otherwise do
4438 int start
= XINT (bar
->start
);
4439 int end
= XINT (bar
->end
);
4441 si
.cbSize
= sizeof (si
);
4442 si
.fMask
= SIF_PAGE
| SIF_POS
;
4443 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4444 si
.nPos
= last_scroll_bar_drag_pos
;
4445 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4449 emacs_event
->kind
= NO_EVENT
;
4453 XSETINT (emacs_event
->x
, y
);
4454 XSETINT (emacs_event
->y
, top_range
);
4460 /* Return information to the user about the current position of the mouse
4461 on the scroll bar. */
4464 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
4466 Lisp_Object
*bar_window
;
4467 enum scroll_bar_part
*part
;
4469 unsigned long *time
;
4471 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
4472 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4473 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4475 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4481 *bar_window
= bar
->window
;
4483 si
.cbSize
= sizeof (si
);
4484 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4486 GetScrollInfo (w
, SB_CTL
, &si
);
4488 top_range
= si
.nMax
- si
.nPage
+ 1;
4490 switch (LOWORD (last_mouse_scroll_bar_pos
))
4492 case SB_THUMBPOSITION
:
4494 *part
= scroll_bar_handle
;
4495 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
4496 pos
= HIWORD (last_mouse_scroll_bar_pos
);
4499 *part
= scroll_bar_handle
;
4503 *part
= scroll_bar_handle
;
4508 XSETINT (*y
, top_range
);
4511 last_mouse_scroll_bar
= Qnil
;
4513 *time
= last_mouse_movement_time
;
4519 /* The screen has been cleared so we may have changed foreground or
4520 background colors, and the scroll bars may need to be redrawn.
4521 Clear out the scroll bars, and ask for expose events, so we can
4525 x_scroll_bar_clear (f
)
4530 /* We can have scroll bars even if this is 0,
4531 if we just turned off scroll bar mode.
4532 But in that case we should not clear them. */
4533 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4534 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4535 bar
= XSCROLL_BAR (bar
)->next
)
4537 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4538 HDC hdc
= GetDC (window
);
4541 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4542 arranges to refresh the scroll bar if hidden. */
4543 my_show_window (f
, window
, SW_HIDE
);
4545 GetClientRect (window
, &rect
);
4546 select_palette (f
, hdc
);
4547 w32_clear_rect (f
, hdc
, &rect
);
4548 deselect_palette (f
, hdc
);
4550 ReleaseDC (window
, hdc
);
4555 /* The main W32 event-reading loop - w32_read_socket. */
4557 /* Record the last 100 characters stored
4558 to help debug the loss-of-chars-during-GC problem. */
4560 static int temp_index
;
4561 static short temp_buffer
[100];
4563 /* Temporarily store lead byte of DBCS input sequences. */
4564 static char dbcs_lead
= 0;
4566 /* Read events coming from the W32 shell.
4567 This routine is called by the SIGIO handler.
4568 We return as soon as there are no more events to be read.
4570 We return the number of characters stored into the buffer,
4571 thus pretending to be `read'.
4573 EXPECTED is nonzero if the caller knows input is available.
4575 Some of these messages are reposted back to the message queue since the
4576 system calls the windows proc directly in a context where we cannot return
4577 the data nor can we guarantee the state we are in. So if we dispatch them
4578 we will get into an infinite loop. To prevent this from ever happening we
4579 will set a variable to indicate we are in the read_socket call and indicate
4580 which message we are processing since the windows proc gets called
4581 recursively with different messages by the system.
4585 w32_read_socket (sd
, expected
, hold_quit
)
4588 struct input_event
*hold_quit
;
4591 int check_visibility
= 0;
4594 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4596 if (interrupt_input_blocked
)
4598 interrupt_input_pending
= 1;
4602 interrupt_input_pending
= 0;
4605 /* So people can tell when we have read the available input. */
4606 input_signal_count
++;
4608 /* TODO: ghostscript integration. */
4609 while (get_next_msg (&msg
, FALSE
))
4611 struct input_event inev
;
4615 inev
.kind
= NO_EVENT
;
4618 switch (msg
.msg
.message
)
4621 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4625 if (msg
.rect
.right
== msg
.rect
.left
||
4626 msg
.rect
.bottom
== msg
.rect
.top
)
4628 /* We may get paint messages even though the client
4629 area is clipped - these are not expose events. */
4630 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4633 else if (f
->async_visible
!= 1)
4635 /* Definitely not obscured, so mark as visible. */
4636 f
->async_visible
= 1;
4637 f
->async_iconified
= 0;
4638 SET_FRAME_GARBAGED (f
);
4639 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4642 /* WM_PAINT serves as MapNotify as well, so report
4643 visibility changes properly. */
4646 inev
.kind
= DEICONIFY_EVENT
;
4647 XSETFRAME (inev
.frame_or_window
, f
);
4649 else if (! NILP (Vframe_list
)
4650 && ! NILP (XCDR (Vframe_list
)))
4651 /* Force a redisplay sooner or later to update the
4652 frame titles in case this is the second frame. */
4653 record_asynch_buffer_change ();
4657 HDC hdc
= get_frame_dc (f
);
4659 /* Erase background again for safety. */
4660 w32_clear_rect (f
, hdc
, &msg
.rect
);
4661 release_frame_dc (f
, hdc
);
4665 msg
.rect
.right
- msg
.rect
.left
,
4666 msg
.rect
.bottom
- msg
.rect
.top
);
4671 case WM_INPUTLANGCHANGE
:
4672 /* Generate a language change event. */
4673 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4677 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4678 XSETFRAME (inev
.frame_or_window
, f
);
4679 inev
.code
= msg
.msg
.wParam
;
4680 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4686 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4688 if (f
&& !f
->iconified
)
4690 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4691 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4693 clear_mouse_face (dpyinfo
);
4694 dpyinfo
->mouse_face_hidden
= 1;
4697 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4699 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4700 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4701 inev
.code
= msg
.msg
.wParam
;
4702 inev
.modifiers
= msg
.dwModifiers
;
4703 XSETFRAME (inev
.frame_or_window
, f
);
4704 inev
.timestamp
= msg
.msg
.time
;
4711 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4713 if (f
&& !f
->iconified
)
4715 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4716 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4718 clear_mouse_face (dpyinfo
);
4719 dpyinfo
->mouse_face_hidden
= 1;
4722 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4724 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4726 inev
.modifiers
= msg
.dwModifiers
;
4727 XSETFRAME (inev
.frame_or_window
, f
);
4728 inev
.timestamp
= msg
.msg
.time
;
4730 if (msg
.msg
.message
== WM_UNICHAR
)
4732 inev
.code
= msg
.msg
.wParam
;
4734 else if (msg
.msg
.wParam
< 256)
4739 dbcs
[1] = (char) msg
.msg
.wParam
;
4743 dbcs
[0] = dbcs_lead
;
4745 if (!MultiByteToWideChar (CP_ACP
, 0, dbcs
, 2, &code
, 1))
4748 DebPrint (("Invalid DBCS sequence: %d %d\n",
4750 inev
.kind
= NO_EVENT
;
4754 else if (IsDBCSLeadByteEx (CP_ACP
, (BYTE
) msg
.msg
.wParam
))
4756 dbcs_lead
= (char) msg
.msg
.wParam
;
4757 inev
.kind
= NO_EVENT
;
4762 if (!MultiByteToWideChar (CP_ACP
, 0, &dbcs
[1], 1,
4765 /* What to do with garbage? */
4766 DebPrint (("Invalid character: %d\n", dbcs
[1]));
4767 inev
.kind
= NO_EVENT
;
4775 /* Windows shouldn't generate WM_CHAR events above 0xFF
4776 in non-Unicode message handlers. */
4777 DebPrint (("Non-byte WM_CHAR: %d\n", msg
.msg
.wParam
));
4778 inev
.kind
= NO_EVENT
;
4781 inev
.kind
= inev
.code
< 128 ? ASCII_KEYSTROKE_EVENT
4782 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
4787 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4789 if (f
&& !f
->iconified
)
4791 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
4792 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
4794 clear_mouse_face (dpyinfo
);
4795 dpyinfo
->mouse_face_hidden
= 1;
4798 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4800 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4801 inev
.kind
= MULTIMEDIA_KEY_EVENT
;
4802 inev
.code
= GET_APPCOMMAND_LPARAM(msg
.msg
.lParam
);
4803 inev
.modifiers
= msg
.dwModifiers
;
4804 XSETFRAME (inev
.frame_or_window
, f
);
4805 inev
.timestamp
= msg
.msg
.time
;
4810 /* Ignore non-movement. */
4812 int x
= LOWORD (msg
.msg
.lParam
);
4813 int y
= HIWORD (msg
.msg
.lParam
);
4814 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4816 last_mousemove_x
= x
;
4817 last_mousemove_y
= y
;
4820 previous_help_echo_string
= help_echo_string
;
4821 help_echo_string
= Qnil
;
4823 if (dpyinfo
->grabbed
&& last_mouse_frame
4824 && FRAME_LIVE_P (last_mouse_frame
))
4825 f
= last_mouse_frame
;
4827 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4829 if (dpyinfo
->mouse_face_hidden
)
4831 dpyinfo
->mouse_face_hidden
= 0;
4832 clear_mouse_face (dpyinfo
);
4837 /* Generate SELECT_WINDOW_EVENTs when needed. */
4838 if (!NILP (Vmouse_autoselect_window
))
4841 int x
= LOWORD (msg
.msg
.lParam
);
4842 int y
= HIWORD (msg
.msg
.lParam
);
4844 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 0);
4846 /* Window will be selected only when it is not
4847 selected now and last mouse movement event was
4848 not in it. Minibuffer window will be selected
4849 only when it is active. */
4851 && !EQ (window
, last_window
)
4852 && !EQ (window
, selected_window
)
4853 /* For click-to-focus window managers
4854 create event iff we don't leave the
4856 && (focus_follows_mouse
4857 || (EQ (XWINDOW (window
)->frame
,
4858 XWINDOW (selected_window
)->frame
))))
4860 inev
.kind
= SELECT_WINDOW_EVENT
;
4861 inev
.frame_or_window
= window
;
4866 if (!note_mouse_movement (f
, &msg
.msg
))
4867 help_echo_string
= previous_help_echo_string
;
4871 /* If we move outside the frame, then we're
4872 certainly no longer on any text in the frame. */
4873 clear_mouse_face (dpyinfo
);
4876 /* If the contents of the global variable help_echo_string
4877 has changed, generate a HELP_EVENT. */
4878 #if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE.
4879 But it was originally changed to this to fix a bug, so I have
4880 not removed it completely in case the bug is still there. */
4881 if (help_echo_string
!= previous_help_echo_string
||
4882 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4883 #else /* This is what xterm.c does. */
4884 if (!NILP (help_echo_string
)
4885 || !NILP (previous_help_echo_string
))
4890 case WM_LBUTTONDOWN
:
4892 case WM_MBUTTONDOWN
:
4894 case WM_RBUTTONDOWN
:
4896 case WM_XBUTTONDOWN
:
4899 /* If we decide we want to generate an event to be seen
4900 by the rest of Emacs, we put it here. */
4905 if (dpyinfo
->grabbed
&& last_mouse_frame
4906 && FRAME_LIVE_P (last_mouse_frame
))
4907 f
= last_mouse_frame
;
4909 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4913 construct_mouse_click (&inev
, &msg
, f
);
4915 /* Is this in the tool-bar? */
4916 if (WINDOWP (f
->tool_bar_window
)
4917 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4920 int x
= XFASTINT (inev
.x
);
4921 int y
= XFASTINT (inev
.y
);
4923 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
4925 if (EQ (window
, f
->tool_bar_window
))
4927 w32_handle_tool_bar_click (f
, &inev
);
4933 || (dpyinfo
->w32_focus_frame
4934 && f
!= dpyinfo
->w32_focus_frame
))
4935 inev
.kind
= NO_EVENT
;
4938 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4943 dpyinfo
->grabbed
&= ~ (1 << button
);
4947 dpyinfo
->grabbed
|= (1 << button
);
4948 last_mouse_frame
= f
;
4949 /* Ignore any mouse motion that happened
4950 before this event; any subsequent mouse-movement
4951 Emacs events should reflect only motion after
4957 last_tool_bar_item
= -1;
4963 case WM_MOUSEHWHEEL
:
4965 if (dpyinfo
->grabbed
&& last_mouse_frame
4966 && FRAME_LIVE_P (last_mouse_frame
))
4967 f
= last_mouse_frame
;
4969 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4974 if (!dpyinfo
->w32_focus_frame
4975 || f
== dpyinfo
->w32_focus_frame
)
4977 /* Emit an Emacs wheel-up/down event. */
4978 construct_mouse_wheel (&inev
, &msg
, f
);
4980 /* Ignore any mouse motion that happened before this
4981 event; any subsequent mouse-movement Emacs events
4982 should reflect only motion after the
4986 last_mouse_frame
= f
;
4987 last_tool_bar_item
= -1;
4992 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4995 construct_drag_n_drop (&inev
, &msg
, f
);
5000 struct scroll_bar
*bar
=
5001 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
5004 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
5008 case WM_WINDOWPOSCHANGED
:
5009 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5012 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
5013 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
5015 check_visibility
= 1;
5019 case WM_ACTIVATEAPP
:
5020 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5022 x_check_fullscreen (f
);
5023 check_visibility
= 1;
5027 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5029 if (f
&& !f
->async_iconified
)
5033 x_real_positions (f
, &x
, &y
);
5038 check_visibility
= 1;
5042 /* wParam non-zero means Window is about to be shown, 0 means
5043 about to be hidden. */
5044 /* Redo the mouse-highlight after the tooltip has gone. */
5045 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
5048 redo_mouse_highlight ();
5051 /* If window has been obscured or exposed by another window
5052 being maximised or minimised/restored, then recheck
5053 visibility of all frames. Direct changes to our own
5054 windows get handled by WM_SIZE. */
5056 if (msg
.msg
.lParam
!= 0)
5057 check_visibility
= 1;
5060 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5061 f
->async_visible
= msg
.msg
.wParam
;
5065 check_visibility
= 1;
5069 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5071 /* Inform lisp of whether frame has been iconified etc. */
5074 switch (msg
.msg
.wParam
)
5076 case SIZE_MINIMIZED
:
5077 f
->async_visible
= 0;
5078 f
->async_iconified
= 1;
5080 inev
.kind
= ICONIFY_EVENT
;
5081 XSETFRAME (inev
.frame_or_window
, f
);
5084 case SIZE_MAXIMIZED
:
5086 f
->async_visible
= 1;
5087 f
->async_iconified
= 0;
5089 /* wait_reading_process_output will notice this and update
5090 the frame's display structures. */
5091 SET_FRAME_GARBAGED (f
);
5097 /* Reset top and left positions of the Window
5098 here since Windows sends a WM_MOVE message
5099 BEFORE telling us the Window is minimized
5100 when the Window is iconified, with 3000,3000
5102 x_real_positions (f
, &x
, &y
);
5106 inev
.kind
= DEICONIFY_EVENT
;
5107 XSETFRAME (inev
.frame_or_window
, f
);
5109 else if (! NILP (Vframe_list
)
5110 && ! NILP (XCDR (Vframe_list
)))
5111 /* Force a redisplay sooner or later
5112 to update the frame titles
5113 in case this is the second frame. */
5114 record_asynch_buffer_change ();
5119 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
5127 GetClientRect (msg
.msg
.hwnd
, &rect
);
5129 height
= rect
.bottom
- rect
.top
;
5130 width
= rect
.right
- rect
.left
;
5132 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
5133 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
5135 /* TODO: Clip size to the screen dimensions. */
5137 /* Even if the number of character rows and columns has
5138 not changed, the font size may have changed, so we need
5139 to check the pixel dimensions as well. */
5141 if (columns
!= FRAME_COLS (f
)
5142 || rows
!= FRAME_LINES (f
)
5143 || width
!= FRAME_PIXEL_WIDTH (f
)
5144 || height
!= FRAME_PIXEL_HEIGHT (f
))
5146 change_frame_size (f
, rows
, columns
, 0, 1, 0);
5147 SET_FRAME_GARBAGED (f
);
5148 cancel_mouse_face (f
);
5149 FRAME_PIXEL_WIDTH (f
) = width
;
5150 FRAME_PIXEL_HEIGHT (f
) = height
;
5151 f
->win_gravity
= NorthWestGravity
;
5155 check_visibility
= 1;
5159 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5162 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5164 /* If we move outside the frame, then we're
5165 certainly no longer on any text in the frame. */
5166 clear_mouse_face (dpyinfo
);
5167 dpyinfo
->mouse_face_mouse_frame
= 0;
5170 /* Generate a nil HELP_EVENT to cancel a help-echo.
5171 Do it only if there's something to cancel.
5172 Otherwise, the startup message is cleared when
5173 the mouse leaves the frame. */
5174 if (any_help_event_p
)
5180 w32_detect_focus_change (dpyinfo
, &msg
, &inev
);
5182 dpyinfo
->grabbed
= 0;
5183 check_visibility
= 1;
5187 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5191 if (f
== dpyinfo
->w32_focus_event_frame
)
5192 dpyinfo
->w32_focus_event_frame
= 0;
5194 if (f
== dpyinfo
->w32_focus_frame
)
5195 x_new_focus_frame (dpyinfo
, 0);
5197 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5199 /* If we move outside the frame, then we're
5200 certainly no longer on any text in the frame. */
5201 clear_mouse_face (dpyinfo
);
5202 dpyinfo
->mouse_face_mouse_frame
= 0;
5205 /* Generate a nil HELP_EVENT to cancel a help-echo.
5206 Do it only if there's something to cancel.
5207 Otherwise, the startup message is cleared when
5208 the mouse leaves the frame. */
5209 if (any_help_event_p
)
5213 dpyinfo
->grabbed
= 0;
5214 check_visibility
= 1;
5218 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5222 inev
.kind
= DELETE_WINDOW_EVENT
;
5223 XSETFRAME (inev
.frame_or_window
, f
);
5228 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5232 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
5233 XSETFRAME (inev
.frame_or_window
, f
);
5238 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5242 extern void menubar_selection_callback
5243 (FRAME_PTR f
, void * client_data
);
5244 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
5247 check_visibility
= 1;
5250 case WM_DISPLAYCHANGE
:
5251 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
5255 dpyinfo
->width
= (short) LOWORD (msg
.msg
.lParam
);
5256 dpyinfo
->height
= (short) HIWORD (msg
.msg
.lParam
);
5257 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
5258 DebPrint (("display change: %d %d\n", dpyinfo
->width
,
5262 check_visibility
= 1;
5266 /* Check for messages registered at runtime. */
5267 if (msg
.msg
.message
== msh_mousewheel
)
5269 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
5270 msg
.msg
.message
= WM_MOUSEWHEEL
;
5276 if (inev
.kind
!= NO_EVENT
)
5278 kbd_buffer_store_event_hold (&inev
, hold_quit
);
5283 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
5288 XSETFRAME (frame
, f
);
5294 if (NILP (help_echo_string
))
5296 help_echo_object
= help_echo_window
= Qnil
;
5300 any_help_event_p
= 1;
5301 gen_help_event (help_echo_string
, frame
, help_echo_window
,
5302 help_echo_object
, help_echo_pos
);
5306 help_echo_string
= Qnil
;
5307 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
5313 /* If the focus was just given to an autoraising frame,
5315 /* ??? This ought to be able to handle more than one such frame. */
5316 if (pending_autoraise_frame
)
5318 x_raise_frame (pending_autoraise_frame
);
5319 pending_autoraise_frame
= 0;
5322 /* Check which frames are still visisble, if we have enqueued any user
5323 events or been notified of events that may affect visibility. We
5324 do this here because there doesn't seem to be any direct
5325 notification from Windows that the visibility of a window has
5326 changed (at least, not in all cases). */
5327 if (count
> 0 || check_visibility
)
5329 Lisp_Object tail
, frame
;
5331 FOR_EACH_FRAME (tail
, frame
)
5333 FRAME_PTR f
= XFRAME (frame
);
5334 /* The tooltip has been drawn already. Avoid the
5335 SET_FRAME_GARBAGED below. */
5336 if (EQ (frame
, tip_frame
))
5339 /* Check "visible" frames and mark each as obscured or not.
5340 Note that async_visible is nonzero for unobscured and
5341 obscured frames, but zero for hidden and iconified frames. */
5342 if (FRAME_W32_P (f
) && f
->async_visible
)
5348 /* Query clipping rectangle for the entire window area
5349 (GetWindowDC), not just the client portion (GetDC).
5350 Otherwise, the scrollbars and menubar aren't counted as
5351 part of the visible area of the frame, and we may think
5352 the frame is obscured when really a scrollbar is still
5353 visible and gets WM_PAINT messages above. */
5354 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
5355 GetClipBox (hdc
, &clipbox
);
5356 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
5359 if (clipbox
.right
== clipbox
.left
5360 || clipbox
.bottom
== clipbox
.top
)
5362 /* Frame has become completely obscured so mark as
5363 such (we do this by setting async_visible to 2 so
5364 that FRAME_VISIBLE_P is still true, but redisplay
5366 f
->async_visible
= 2;
5368 if (!FRAME_OBSCURED_P (f
))
5370 DebPrint (("frame %p (%s) obscured\n", f
,
5376 /* Frame is not obscured, so mark it as such. */
5377 f
->async_visible
= 1;
5379 if (FRAME_OBSCURED_P (f
))
5381 SET_FRAME_GARBAGED (f
);
5382 DebPrint (("obscured frame %p (%s) found to be visible\n", f
,
5385 /* Force a redisplay sooner or later. */
5386 record_asynch_buffer_change ();
5399 /***********************************************************************
5401 ***********************************************************************/
5403 /* Set clipping for output in glyph row ROW. W is the window in which
5404 we operate. GC is the graphics context to set clipping in.
5406 ROW may be a text row or, e.g., a mode line. Text rows must be
5407 clipped to the interior of the window dedicated to text display,
5408 mode lines must be clipped to the whole window. */
5411 w32_clip_to_row (w
, row
, area
, hdc
)
5413 struct glyph_row
*row
;
5417 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5419 int window_x
, window_y
, window_width
;
5421 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
5423 clip_rect
.left
= window_x
;
5424 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
5425 clip_rect
.top
= max (clip_rect
.top
, window_y
);
5426 clip_rect
.right
= clip_rect
.left
+ window_width
;
5427 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
5429 w32_set_clip_rectangle (hdc
, &clip_rect
);
5433 /* Draw a hollow box cursor on window W in glyph row ROW. */
5436 x_draw_hollow_cursor (w
, row
)
5438 struct glyph_row
*row
;
5440 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5444 struct glyph
*cursor_glyph
;
5445 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
5447 /* Get the glyph the cursor is on. If we can't tell because
5448 the current matrix is invalid or such, give up. */
5449 cursor_glyph
= get_phys_cursor_glyph (w
);
5450 if (cursor_glyph
== NULL
)
5453 /* Compute frame-relative coordinates for phys cursor. */
5454 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &left
, &top
, &h
);
5457 rect
.bottom
= rect
.top
+ h
;
5458 rect
.right
= rect
.left
+ w
->phys_cursor_width
;
5460 hdc
= get_frame_dc (f
);
5461 /* Set clipping, draw the rectangle, and reset clipping again. */
5462 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5463 FrameRect (hdc
, &rect
, hb
);
5465 w32_set_clip_rectangle (hdc
, NULL
);
5466 release_frame_dc (f
, hdc
);
5470 /* Draw a bar cursor on window W in glyph row ROW.
5472 Implementation note: One would like to draw a bar cursor with an
5473 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5474 Unfortunately, I didn't find a font yet that has this property set.
5478 x_draw_bar_cursor (w
, row
, width
, kind
)
5480 struct glyph_row
*row
;
5482 enum text_cursor_kinds kind
;
5484 struct frame
*f
= XFRAME (w
->frame
);
5485 struct glyph
*cursor_glyph
;
5489 /* If cursor is out of bounds, don't draw garbage. This can happen
5490 in mini-buffer windows when switching between echo area glyphs
5492 cursor_glyph
= get_phys_cursor_glyph (w
);
5493 if (cursor_glyph
== NULL
)
5496 /* If on an image, draw like a normal cursor. That's usually better
5497 visible than drawing a bar, esp. if the image is large so that
5498 the bar might not be in the window. */
5499 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5501 struct glyph_row
*row
;
5502 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5503 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5507 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5508 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5510 /* If the glyph's background equals the color we normally draw
5511 the bar cursor in, the bar cursor in its normal color is
5512 invisible. Use the glyph's foreground color instead in this
5513 case, on the assumption that the glyph's colors are chosen so
5514 that the glyph is legible. */
5515 if (face
->background
== cursor_color
)
5516 cursor_color
= face
->foreground
;
5518 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5521 width
= FRAME_CURSOR_WIDTH (f
);
5522 width
= min (cursor_glyph
->pixel_width
, width
);
5524 w
->phys_cursor_width
= width
;
5527 hdc
= get_frame_dc (f
);
5528 w32_clip_to_row (w
, row
, TEXT_AREA
, hdc
);
5530 if (kind
== BAR_CURSOR
)
5532 w32_fill_area (f
, hdc
, cursor_color
, x
,
5533 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5534 width
, row
->height
);
5538 w32_fill_area (f
, hdc
, cursor_color
, x
,
5539 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5540 row
->height
- width
),
5541 cursor_glyph
->pixel_width
, width
);
5544 w32_set_clip_rectangle (hdc
, NULL
);
5545 release_frame_dc (f
, hdc
);
5550 /* RIF: Define cursor CURSOR on frame F. */
5553 w32_define_frame_cursor (f
, cursor
)
5557 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5561 /* RIF: Clear area on frame F. */
5564 w32_clear_frame_area (f
, x
, y
, width
, height
)
5566 int x
, y
, width
, height
;
5570 hdc
= get_frame_dc (f
);
5571 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5572 release_frame_dc (f
, hdc
);
5575 /* RIF: Draw or clear cursor on window W. */
5578 w32_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
5580 struct glyph_row
*glyph_row
;
5582 int cursor_type
, cursor_width
;
5587 /* If the user wants to use the system caret, make sure our own
5588 cursor remains invisible. */
5589 if (w32_use_visible_system_caret
)
5591 /* Call to erase_phys_cursor here seems to use the
5592 wrong values of w->phys_cursor, as they have been
5593 overwritten before this function was called. */
5594 if (w
->phys_cursor_type
!= NO_CURSOR
)
5595 erase_phys_cursor (w
);
5597 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5598 w
->phys_cursor_width
= -1;
5602 w
->phys_cursor_type
= cursor_type
;
5605 w
->phys_cursor_on_p
= 1;
5607 /* If this is the active cursor, we need to track it with the
5608 system caret, so third party software like screen magnifiers
5609 and speech synthesizers can follow the cursor. */
5612 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5613 HWND hwnd
= FRAME_W32_WINDOW (f
);
5616 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5618 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5619 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5621 /* If the size of the active cursor changed, destroy the old
5623 if (w32_system_caret_hwnd
5624 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5625 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5627 w32_system_caret_height
= w
->phys_cursor_height
;
5629 /* Move the system caret. */
5630 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5633 if (glyph_row
->exact_window_width_line_p
5634 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
5636 glyph_row
->cursor_in_fringe_p
= 1;
5637 draw_fringe_bitmap (w
, glyph_row
, 0);
5641 switch (cursor_type
)
5643 case HOLLOW_BOX_CURSOR
:
5644 x_draw_hollow_cursor (w
, glyph_row
);
5647 case FILLED_BOX_CURSOR
:
5648 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5652 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5656 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5660 w
->phys_cursor_width
= 0;
5674 x_bitmap_icon (f
, icon
)
5679 HANDLE small_icon
= NULL
;
5681 if (FRAME_W32_WINDOW (f
) == 0)
5685 main_icon
= LoadIcon (hinst
, EMACS_CLASS
);
5686 else if (STRINGP (icon
))
5688 /* Load the main icon from the named file. */
5689 main_icon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5690 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5691 /* Try to load a small icon to go with it. */
5692 small_icon
= LoadImage (NULL
, (LPCSTR
) SDATA (icon
), IMAGE_ICON
,
5693 GetSystemMetrics (SM_CXSMICON
),
5694 GetSystemMetrics (SM_CYSMICON
),
5697 else if (SYMBOLP (icon
))
5701 if (EQ (icon
, intern ("application")))
5702 name
= (LPCTSTR
) IDI_APPLICATION
;
5703 else if (EQ (icon
, intern ("hand")))
5704 name
= (LPCTSTR
) IDI_HAND
;
5705 else if (EQ (icon
, intern ("question")))
5706 name
= (LPCTSTR
) IDI_QUESTION
;
5707 else if (EQ (icon
, intern ("exclamation")))
5708 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5709 else if (EQ (icon
, intern ("asterisk")))
5710 name
= (LPCTSTR
) IDI_ASTERISK
;
5711 else if (EQ (icon
, intern ("winlogo")))
5712 name
= (LPCTSTR
) IDI_WINLOGO
;
5716 main_icon
= LoadIcon (NULL
, name
);
5721 if (main_icon
== NULL
)
5724 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5725 (LPARAM
) main_icon
);
5727 /* If there is a small icon that goes with it, set that too. */
5729 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_SMALL
,
5730 (LPARAM
) small_icon
);
5736 /************************************************************************
5738 ************************************************************************/
5740 /* Display Error Handling functions not used on W32. Listing them here
5741 helps diff stay in step when comparing w32term.c with xterm.c.
5743 x_error_catcher (display, error)
5744 x_catch_errors (dpy)
5745 x_catch_errors_unwind (old_val)
5746 x_check_errors (dpy, format)
5747 x_fully_uncatch_errors ()
5748 x_catching_errors ()
5749 x_had_errors_p (dpy)
5750 x_clear_errors (dpy)
5751 x_uncatch_errors (dpy, count)
5753 x_connection_signal (signalnum)
5754 x_connection_closed (dpy, error_message)
5755 x_error_quitter (display, error)
5756 x_error_handler (display, error)
5757 x_io_error_quitter (display)
5762 /* Changing the font of the frame. */
5766 /* Give frame F the font named FONTNAME as its default font, and
5767 return the full name of that font. FONTNAME may be a wildcard
5768 pattern; in that case, we choose some font that fits the pattern.
5769 The return value shows which font we chose. */
5772 x_new_font (f
, fontname
)
5774 register char *fontname
;
5776 struct font_info
*fontp
5777 = FS_LOAD_FONT (f
, fontname
);
5782 if (FRAME_FONT (f
) == (XFontStruct
*) (fontp
->font
))
5783 /* This font is already set in frame F. There's nothing more to
5785 return build_string (fontp
->full_name
);
5787 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
5788 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
5789 FRAME_FONTSET (f
) = -1;
5791 FRAME_COLUMN_WIDTH (f
) = fontp
->average_width
;
5792 FRAME_SPACE_WIDTH (f
) = fontp
->space_width
;
5793 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
5795 compute_fringe_widths (f
, 1);
5797 /* Compute the scroll bar width in character columns. */
5798 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5800 int wid
= FRAME_COLUMN_WIDTH (f
);
5801 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5802 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
5806 int wid
= FRAME_COLUMN_WIDTH (f
);
5807 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5810 /* Now make the frame display the given font. */
5811 if (FRAME_W32_WINDOW (f
) != 0)
5813 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5814 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5817 return build_string (fontp
->full_name
);
5820 /* Give frame F the fontset named FONTSETNAME as its default fontset,
5821 and return the full name of that fontset. FONTSETNAME may be a
5822 wildcard pattern; in that case, we choose some fontset that fits
5823 the pattern. FONTSETNAME may be a font name for ASCII characters;
5824 in that case, we create a fontset from that font name.
5826 The return value shows which fontset we chose.
5827 If FONTSETNAME specifies the default fontset, return Qt.
5828 If an ASCII font in the specified fontset can't be loaded, return
5832 x_new_fontset (f
, fontsetname
)
5834 Lisp_Object fontsetname
;
5836 int fontset
= fs_query_fontset (fontsetname
, 0);
5839 if (fontset
> 0 && FRAME_FONTSET(f
) == fontset
)
5840 /* This fontset is already set in frame F. There's nothing more
5842 return fontset_name (fontset
);
5843 else if (fontset
== 0)
5844 /* The default fontset can't be the default font. */
5848 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
5850 result
= x_new_font (f
, SDATA (fontsetname
));
5852 if (!STRINGP (result
))
5853 /* Can't load ASCII font. */
5857 fontset
= new_fontset_from_font_name (result
);
5859 /* Since x_new_font doesn't update any fontset information, do it now. */
5860 FRAME_FONTSET(f
) = fontset
;
5862 return fontset_name (fontset
);
5864 #endif /* OLD_FONT */
5868 x_new_font (f
, font_object
, fontset
)
5870 Lisp_Object font_object
;
5873 struct font
*font
= XFONT_OBJECT (font_object
);
5876 fontset
= fontset_from_font (font_object
);
5877 FRAME_FONTSET (f
) = fontset
;
5878 if (FRAME_FONT (f
) == font
)
5879 /* This font is already set in frame F. There's nothing more to
5881 return fontset_name (fontset
);
5885 FRAME_FONT (f
) = font
;
5886 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
5887 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
5888 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
5889 FRAME_LINE_HEIGHT (f
) = font
->height
;
5891 compute_fringe_widths (f
, 1);
5893 /* Compute the scroll bar width in character columns. */
5894 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5896 int wid
= FRAME_COLUMN_WIDTH (f
);
5897 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5898 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
- 1) / wid
;
5902 int wid
= FRAME_COLUMN_WIDTH (f
);
5903 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5906 /* Now make the frame display the given font. */
5907 if (FRAME_X_WINDOW (f
) != 0)
5909 /* Don't change the size of a tip frame; there's no point in
5910 doing it because it's done in Fx_show_tip, and it leads to
5911 problems because the tip frame has no widget. */
5912 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5913 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5918 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
5919 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
5924 return fontset_name (fontset
);
5928 /***********************************************************************
5929 TODO: W32 Input Methods
5930 ***********************************************************************/
5931 /* Listing missing functions from xterm.c helps diff stay in step.
5933 xim_destroy_callback (xim, client_data, call_data)
5934 xim_open_dpy (dpyinfo, resource_name)
5936 xim_instantiate_callback (display, client_data, call_data)
5937 xim_initialize (dpyinfo, resource_name)
5938 xim_close_dpy (dpyinfo)
5943 /* Calculate the absolute position in frame F
5944 from its current recorded position values and gravity. */
5947 x_calc_absolute_position (f
)
5950 int flags
= f
->size_hint_flags
;
5952 /* The sum of the widths of the frame's left and right borders, and
5953 the sum of the heights of the frame's top and bottom borders (in
5954 pixels) drawn by Windows. */
5955 unsigned int left_right_borders_width
, top_bottom_borders_height
;
5957 /* Try to get the actual values of these two variables. We compute
5958 the border width (height) by subtracting the width (height) of
5959 the frame's client area from the width (height) of the frame's
5961 WINDOWPLACEMENT wp
= { 0 };
5962 RECT client_rect
= { 0 };
5964 if (GetWindowPlacement (FRAME_W32_WINDOW (f
), &wp
)
5965 && GetClientRect (FRAME_W32_WINDOW (f
), &client_rect
))
5967 left_right_borders_width
=
5968 (wp
.rcNormalPosition
.right
- wp
.rcNormalPosition
.left
) -
5969 (client_rect
.right
- client_rect
.left
);
5971 top_bottom_borders_height
=
5972 (wp
.rcNormalPosition
.bottom
- wp
.rcNormalPosition
.top
) -
5973 (client_rect
.bottom
- client_rect
.top
);
5977 /* Use sensible default values. */
5978 left_right_borders_width
= 8;
5979 top_bottom_borders_height
= 32;
5982 /* Treat negative positions as relative to the rightmost bottommost
5983 position that fits on the screen. */
5984 if (flags
& XNegative
)
5985 f
->left_pos
= (FRAME_W32_DISPLAY_INFO (f
)->width
5986 - FRAME_PIXEL_WIDTH (f
)
5988 - (left_right_borders_width
- 1));
5990 if (flags
& YNegative
)
5991 f
->top_pos
= (FRAME_W32_DISPLAY_INFO (f
)->height
5992 - FRAME_PIXEL_HEIGHT (f
)
5994 - (top_bottom_borders_height
- 1));
5996 /* The left_pos and top_pos are now relative to the top and left
5997 screen edges, so the flags should correspond. */
5998 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6001 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
6002 to really change the position, and 0 when calling from
6003 x_make_frame_visible (in that case, XOFF and YOFF are the current
6004 position values). It is -1 when calling from x_set_frame_parameters,
6005 which means, do adjust for borders but don't change the gravity. */
6008 x_set_offset (f
, xoff
, yoff
, change_gravity
)
6010 register int xoff
, yoff
;
6013 int modified_top
, modified_left
;
6015 if (change_gravity
> 0)
6019 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6021 f
->size_hint_flags
|= XNegative
;
6023 f
->size_hint_flags
|= YNegative
;
6024 f
->win_gravity
= NorthWestGravity
;
6026 x_calc_absolute_position (f
);
6029 x_wm_set_size_hint (f
, (long) 0, 0);
6031 modified_left
= f
->left_pos
;
6032 modified_top
= f
->top_pos
;
6034 my_set_window_pos (FRAME_W32_WINDOW (f
),
6036 modified_left
, modified_top
,
6038 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
6043 /* Check if we need to resize the frame due to a fullscreen request.
6044 If so needed, resize the frame. */
6046 x_check_fullscreen (f
)
6049 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
6051 int width
, height
, ign
;
6053 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6055 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
6057 /* We do not need to move the window, it shall be taken care of
6058 when setting WM manager hints. */
6059 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
6061 change_frame_size (f
, height
, width
, 0, 1, 0);
6062 SET_FRAME_GARBAGED (f
);
6063 cancel_mouse_face (f
);
6065 /* Wait for the change of frame size to occur */
6066 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
6071 /* Call this to change the size of frame F's x-window.
6072 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
6073 for this size change and subsequent size changes.
6074 Otherwise we leave the window gravity unchanged. */
6077 x_set_window_size (f
, change_gravity
, cols
, rows
)
6082 int pixelwidth
, pixelheight
;
6086 check_frame_size (f
, &rows
, &cols
);
6087 f
->scroll_bar_actual_width
6088 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
6090 compute_fringe_widths (f
, 0);
6092 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
6093 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
6095 f
->win_gravity
= NorthWestGravity
;
6096 x_wm_set_size_hint (f
, (long) 0, 0);
6101 rect
.left
= rect
.top
= 0;
6102 rect
.right
= pixelwidth
;
6103 rect
.bottom
= pixelheight
;
6105 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
6106 FRAME_EXTERNAL_MENU_BAR (f
));
6108 my_set_window_pos (FRAME_W32_WINDOW (f
),
6111 rect
.right
- rect
.left
,
6112 rect
.bottom
- rect
.top
,
6113 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6117 /* The following mirrors what is done in xterm.c. It appears to be
6118 for informing lisp of the new size immediately, while the actual
6119 resize will happen asynchronously. But on Windows, the menu bar
6120 automatically wraps when the frame is too narrow to contain it,
6121 and that causes any calculations made here to come out wrong. The
6122 end is some nasty buggy behaviour, including the potential loss
6125 Disabling this code is either not sufficient to fix the problems
6126 completely, or it causes fresh problems, but at least it removes
6127 the most problematic symptom of the minibuffer becoming unusable.
6129 -----------------------------------------------------------------
6131 Now, strictly speaking, we can't be sure that this is accurate,
6132 but the window manager will get around to dealing with the size
6133 change request eventually, and we'll hear how it went when the
6134 ConfigureNotify event gets here.
6136 We could just not bother storing any of this information here,
6137 and let the ConfigureNotify event set everything up, but that
6138 might be kind of confusing to the Lisp code, since size changes
6139 wouldn't be reported in the frame parameters until some random
6140 point in the future when the ConfigureNotify event arrives.
6142 We pass 1 for DELAY since we can't run Lisp code inside of
6144 change_frame_size (f
, rows
, cols
, 0, 1, 0);
6145 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
6146 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
6148 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
6149 receive in the ConfigureNotify event; if we get what we asked
6150 for, then the event won't cause the screen to become garbaged, so
6151 we have to make sure to do it here. */
6152 SET_FRAME_GARBAGED (f
);
6154 /* If cursor was outside the new size, mark it as off. */
6155 mark_window_cursors_off (XWINDOW (f
->root_window
));
6157 /* Clear out any recollection of where the mouse highlighting was,
6158 since it might be in a place that's outside the new frame size.
6159 Actually checking whether it is outside is a pain in the neck,
6160 so don't try--just let the highlighting be done afresh with new size. */
6161 cancel_mouse_face (f
);
6167 /* Mouse warping. */
6169 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
6172 x_set_mouse_position (f
, x
, y
)
6178 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
6179 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
6181 if (pix_x
< 0) pix_x
= 0;
6182 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
6184 if (pix_y
< 0) pix_y
= 0;
6185 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
6187 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
6191 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
6200 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
6201 pt
.x
= rect
.left
+ pix_x
;
6202 pt
.y
= rect
.top
+ pix_y
;
6203 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
6205 SetCursorPos (pt
.x
, pt
.y
);
6211 /* focus shifting, raising and lowering. */
6214 x_focus_on_frame (f
)
6217 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6219 /* Give input focus to frame. */
6222 /* Try not to change its Z-order if possible. */
6223 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
6224 my_set_focus (f
, FRAME_W32_WINDOW (f
));
6227 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6237 /* Raise frame F. */
6244 /* Strictly speaking, raise-frame should only change the frame's Z
6245 order, leaving input focus unchanged. This is reasonable behaviour
6246 on X where the usual policy is point-to-focus. However, this
6247 behaviour would be very odd on Windows where the usual policy is
6250 On X, if the mouse happens to be over the raised frame, it gets
6251 input focus anyway (so the window with focus will never be
6252 completely obscured) - if not, then just moving the mouse over it
6253 is sufficient to give it focus. On Windows, the user must actually
6254 click on the frame (preferrably the title bar so as not to move
6255 point), which is more awkward. Also, no other Windows program
6256 raises a window to the top but leaves another window (possibly now
6257 completely obscured) with input focus.
6259 Because there is a system setting on Windows that allows the user
6260 to choose the point to focus policy, we make the strict semantics
6261 optional, but by default we grab focus when raising. */
6263 if (NILP (Vw32_grab_focus_on_raise
))
6265 /* The obvious call to my_set_window_pos doesn't work if Emacs is
6266 not already the foreground application: the frame is raised
6267 above all other frames belonging to us, but not above the
6268 current top window. To achieve that, we have to resort to this
6269 more cumbersome method. */
6271 HDWP handle
= BeginDeferWindowPos (2);
6274 DeferWindowPos (handle
,
6275 FRAME_W32_WINDOW (f
),
6278 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6280 DeferWindowPos (handle
,
6281 GetForegroundWindow (),
6282 FRAME_W32_WINDOW (f
),
6284 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6286 EndDeferWindowPos (handle
);
6291 my_set_foreground_window (FRAME_W32_WINDOW (f
));
6297 /* Lower frame F. */
6303 my_set_window_pos (FRAME_W32_WINDOW (f
),
6306 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
6311 w32_frame_raise_lower (f
, raise_flag
)
6315 if (! FRAME_W32_P (f
))
6324 /* Change of visibility. */
6326 /* This tries to wait until the frame is really visible.
6327 However, if the window manager asks the user where to position
6328 the frame, this will return before the user finishes doing that.
6329 The frame will not actually be visible at that time,
6330 but it will become visible later when the window manager
6331 finishes with it. */
6334 x_make_frame_visible (f
)
6341 type
= x_icon_type (f
);
6343 x_bitmap_icon (f
, type
);
6345 if (! FRAME_VISIBLE_P (f
))
6347 /* We test FRAME_GARBAGED_P here to make sure we don't
6348 call x_set_offset a second time
6349 if we get to x_make_frame_visible a second time
6350 before the window gets really visible. */
6351 if (! FRAME_ICONIFIED_P (f
)
6352 && ! f
->output_data
.w32
->asked_for_visible
)
6357 /* Adjust vertical window position in order to avoid being
6358 covered by a task bar placed at the bottom of the desktop. */
6359 SystemParametersInfo(SPI_GETWORKAREA
, 0, &workarea_rect
, 0);
6360 GetWindowRect(FRAME_W32_WINDOW(f
), &window_rect
);
6361 if (window_rect
.bottom
> workarea_rect
.bottom
6362 && window_rect
.top
> workarea_rect
.top
)
6363 f
->top_pos
= max (window_rect
.top
6364 - window_rect
.bottom
+ workarea_rect
.bottom
,
6367 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
6370 f
->output_data
.w32
->asked_for_visible
= 1;
6372 /* my_show_window (f, FRAME_W32_WINDOW (f), f->async_iconified ? SW_RESTORE : SW_SHOW); */
6373 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_SHOWNORMAL
);
6376 /* Synchronize to ensure Emacs knows the frame is visible
6377 before we do anything else. We do this loop with input not blocked
6378 so that incoming events are handled. */
6383 /* This must come after we set COUNT. */
6386 XSETFRAME (frame
, f
);
6388 /* Wait until the frame is visible. Process X events until a
6389 MapNotify event has been seen, or until we think we won't get a
6390 MapNotify at all.. */
6391 for (count
= input_signal_count
+ 10;
6392 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
6394 /* Force processing of queued events. */
6395 /* TODO: x_sync equivalent? */
6397 /* Machines that do polling rather than SIGIO have been observed
6398 to go into a busy-wait here. So we'll fake an alarm signal
6399 to let the handler know that there's something to be read.
6400 We used to raise a real alarm, but it seems that the handler
6401 isn't always enabled here. This is probably a bug. */
6402 if (input_polling_used ())
6404 /* It could be confusing if a real alarm arrives while processing
6405 the fake one. Turn it off and let the handler reset it. */
6406 int old_poll_suppress_count
= poll_suppress_count
;
6407 poll_suppress_count
= 1;
6408 poll_for_input_1 ();
6409 poll_suppress_count
= old_poll_suppress_count
;
6412 FRAME_SAMPLE_VISIBILITY (f
);
6416 /* Change from mapped state to withdrawn state. */
6418 /* Make the frame visible (mapped and not iconified). */
6420 x_make_frame_invisible (f
)
6423 /* Don't keep the highlight on an invisible frame. */
6424 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6425 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6429 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
6431 /* We can't distinguish this from iconification
6432 just by the event that we get from the server.
6433 So we can't win using the usual strategy of letting
6434 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6435 and synchronize with the server to make sure we agree. */
6437 FRAME_ICONIFIED_P (f
) = 0;
6438 f
->async_visible
= 0;
6439 f
->async_iconified
= 0;
6444 /* Change window state from mapped to iconified. */
6452 /* Don't keep the highlight on an invisible frame. */
6453 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
6454 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
6456 if (f
->async_iconified
)
6461 type
= x_icon_type (f
);
6463 x_bitmap_icon (f
, type
);
6465 /* Simulate the user minimizing the frame. */
6466 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
6472 /* Free X resources of frame F. */
6475 x_free_frame_resources (f
)
6478 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6482 /* We must free faces before destroying windows because some
6483 font-driver (e.g. xft) access a window while finishing a
6485 if (FRAME_FACE_CACHE (f
))
6486 free_frame_faces (f
);
6488 if (FRAME_W32_WINDOW (f
))
6489 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
6491 free_frame_menubar (f
);
6493 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
6494 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
6495 unload_color (f
, f
->output_data
.w32
->cursor_pixel
);
6496 unload_color (f
, f
->output_data
.w32
->cursor_foreground_pixel
);
6497 unload_color (f
, f
->output_data
.w32
->border_pixel
);
6498 unload_color (f
, f
->output_data
.w32
->mouse_pixel
);
6499 if (f
->output_data
.w32
->white_relief
.allocated_p
)
6500 unload_color (f
, f
->output_data
.w32
->white_relief
.pixel
);
6501 if (f
->output_data
.w32
->black_relief
.allocated_p
)
6502 unload_color (f
, f
->output_data
.w32
->black_relief
.pixel
);
6504 if (FRAME_FACE_CACHE (f
))
6505 free_frame_faces (f
);
6507 xfree (f
->output_data
.w32
);
6508 f
->output_data
.w32
= NULL
;
6510 if (f
== dpyinfo
->w32_focus_frame
)
6511 dpyinfo
->w32_focus_frame
= 0;
6512 if (f
== dpyinfo
->w32_focus_event_frame
)
6513 dpyinfo
->w32_focus_event_frame
= 0;
6514 if (f
== dpyinfo
->x_highlight_frame
)
6515 dpyinfo
->x_highlight_frame
= 0;
6517 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6519 dpyinfo
->mouse_face_beg_row
6520 = dpyinfo
->mouse_face_beg_col
= -1;
6521 dpyinfo
->mouse_face_end_row
6522 = dpyinfo
->mouse_face_end_col
= -1;
6523 dpyinfo
->mouse_face_window
= Qnil
;
6524 dpyinfo
->mouse_face_deferred_gc
= 0;
6525 dpyinfo
->mouse_face_mouse_frame
= 0;
6532 /* Destroy the window of frame F. */
6534 x_destroy_window (f
)
6537 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6539 x_free_frame_resources (f
);
6540 dpyinfo
->reference_count
--;
6544 /* Setting window manager hints. */
6546 /* Set the normal size hints for the window manager, for frame F.
6547 FLAGS is the flags word to use--or 0 meaning preserve the flags
6548 that the window now has.
6549 If USER_POSITION is nonzero, we set the USPosition
6550 flag (this is useful when FLAGS is 0). */
6552 x_wm_set_size_hint (f
, flags
, user_position
)
6557 Window window
= FRAME_W32_WINDOW (f
);
6561 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
6562 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
6563 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
6564 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
6569 /* Window manager things */
6571 x_wm_set_icon_position (f
, icon_x
, icon_y
)
6576 Window window
= FRAME_W32_WINDOW (f
);
6578 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
6579 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
6580 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
6582 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
6587 /***********************************************************************
6589 ***********************************************************************/
6593 /* The following functions are listed here to help diff stay in step
6594 with xterm.c. See w32fns.c for definitions.
6596 x_get_font_info (f, font_idx)
6597 x_list_fonts (f, pattern, size, maxnames)
6603 /* Check that FONT is valid on frame F. It is if it can be found in F's
6607 x_check_font (f
, font
)
6612 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6614 xassert (font
!= NULL
);
6616 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
6617 if (dpyinfo
->font_table
[i
].name
6618 && font
== dpyinfo
->font_table
[i
].font
)
6621 xassert (i
< dpyinfo
->n_fonts
);
6624 #endif /* GLYPH_DEBUG != 0 */
6626 /* Set *W to the minimum width, *H to the minimum font height of FONT.
6627 Note: There are (broken) X fonts out there with invalid XFontStruct
6628 min_bounds contents. For example, handa@etl.go.jp reports that
6629 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
6630 have font->min_bounds.width == 0. */
6633 x_font_min_bounds (font
, w
, h
)
6638 * TODO: Windows does not appear to offer min bound, only
6639 * average and maximum width, and maximum height.
6641 *h
= FONT_HEIGHT (font
);
6642 *w
= FONT_AVG_WIDTH (font
);
6646 /* Compute the smallest character width and smallest font height over
6647 all fonts available on frame F. Set the members smallest_char_width
6648 and smallest_font_height in F's x_display_info structure to
6649 the values computed. Value is non-zero if smallest_font_height or
6650 smallest_char_width become smaller than they were before. */
6653 x_compute_min_glyph_bounds (f
)
6657 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6659 int old_width
= dpyinfo
->smallest_char_width
;
6660 int old_height
= dpyinfo
->smallest_font_height
;
6662 dpyinfo
->smallest_font_height
= 100000;
6663 dpyinfo
->smallest_char_width
= 100000;
6665 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
6666 if (dpyinfo
->font_table
[i
].name
)
6668 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
6671 font
= (XFontStruct
*) fontp
->font
;
6672 xassert (font
!= (XFontStruct
*) ~0);
6673 x_font_min_bounds (font
, &w
, &h
);
6675 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
6676 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
6679 xassert (dpyinfo
->smallest_char_width
> 0
6680 && dpyinfo
->smallest_font_height
> 0);
6682 return (dpyinfo
->n_fonts
== 1
6683 || dpyinfo
->smallest_char_width
< old_width
6684 || dpyinfo
->smallest_font_height
< old_height
);
6687 /* The following functions are listed here to help diff stay in step
6688 with xterm.c. See w32fns.c for definitions.
6690 x_load_font (f, fontname, size)
6691 x_query_font (f, fontname)
6692 x_find_ccl_program (fontp)
6696 #endif /* OLD_FONT */
6699 /***********************************************************************
6701 ***********************************************************************/
6703 static int w32_initialized
= 0;
6706 w32_initialize_display_info (display_name
)
6707 Lisp_Object display_name
;
6709 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6711 bzero (dpyinfo
, sizeof (*dpyinfo
));
6713 /* Put it on w32_display_name_list. */
6714 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
6715 w32_display_name_list
);
6716 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
6718 dpyinfo
->w32_id_name
6719 = (char *) xmalloc (SCHARS (Vinvocation_name
)
6720 + SCHARS (Vsystem_name
)
6722 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6723 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6725 /* Default Console mode values - overridden when running in GUI mode
6726 with values obtained from system metrics. */
6729 dpyinfo
->height_in
= 1;
6730 dpyinfo
->width_in
= 1;
6731 dpyinfo
->n_planes
= 1;
6732 dpyinfo
->n_cbits
= 4;
6733 dpyinfo
->n_fonts
= 0;
6734 dpyinfo
->smallest_font_height
= 1;
6735 dpyinfo
->smallest_char_width
= 1;
6737 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6738 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6739 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
6740 dpyinfo
->mouse_face_window
= Qnil
;
6741 dpyinfo
->mouse_face_overlay
= Qnil
;
6742 dpyinfo
->mouse_face_hidden
= 0;
6744 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6745 /* TODO: dpyinfo->gray */
6749 /* Create an xrdb-style database of resources to supercede registry settings.
6750 The database is just a concatenation of C strings, finished by an additional
6751 \0. The strings are submitted to some basic normalization, so
6753 [ *]option[ *]:[ *]value...
6759 but any whitespace following value is not removed. */
6762 w32_make_rdb (xrm_option
)
6765 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6766 char *current
= buffer
;
6769 int before_value
= 0;
6783 if (in_option
&& (ch
== ':'))
6788 else if (before_value
)
6793 else if (!(in_option
|| before_value
))
6805 x_flush (struct frame
* f
)
6806 { /* Nothing to do */ }
6809 extern frame_parm_handler w32_frame_parm_handlers
[];
6811 static struct redisplay_interface w32_redisplay_interface
=
6813 w32_frame_parm_handlers
,
6817 x_clear_end_of_line
,
6819 x_after_update_window_line
,
6820 x_update_window_begin
,
6821 x_update_window_end
,
6824 0, /* flush_display_optional */
6825 x_clear_window_mouse_face
,
6826 x_get_glyph_overhangs
,
6827 x_fix_overlapping_area
,
6828 w32_draw_fringe_bitmap
,
6829 w32_define_fringe_bitmap
,
6830 w32_destroy_fringe_bitmap
,
6832 w32_per_char_metric
,
6835 w32_compute_glyph_string_overhangs
,
6836 x_draw_glyph_string
,
6837 w32_define_frame_cursor
,
6838 w32_clear_frame_area
,
6839 w32_draw_window_cursor
,
6840 w32_draw_vertical_window_border
,
6841 w32_shift_glyphs_for_insert
6844 static void x_delete_terminal (struct terminal
*term
);
6846 static struct terminal
*
6847 w32_create_terminal (struct w32_display_info
*dpyinfo
)
6849 struct terminal
*terminal
;
6851 terminal
= create_terminal ();
6853 terminal
->type
= output_w32
;
6854 terminal
->display_info
.w32
= dpyinfo
;
6855 dpyinfo
->terminal
= terminal
;
6857 /* MSVC does not type K&R functions with no arguments correctly, and
6858 so we must explicitly cast them. */
6859 terminal
->clear_frame_hook
= x_clear_frame
;
6860 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
6861 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
6862 terminal
->ring_bell_hook
= w32_ring_bell
;
6863 terminal
->reset_terminal_modes_hook
= w32_reset_terminal_modes
;
6864 terminal
->set_terminal_modes_hook
= w32_set_terminal_modes
;
6865 terminal
->update_begin_hook
= x_update_begin
;
6866 terminal
->update_end_hook
= x_update_end
;
6867 terminal
->set_terminal_window_hook
= w32_set_terminal_window
;
6868 terminal
->read_socket_hook
= w32_read_socket
;
6869 terminal
->frame_up_to_date_hook
= w32_frame_up_to_date
;
6870 terminal
->mouse_position_hook
= w32_mouse_position
;
6871 terminal
->frame_rehighlight_hook
= w32_frame_rehighlight
;
6872 terminal
->frame_raise_lower_hook
= w32_frame_raise_lower
;
6873 // terminal->fullscreen_hook = XTfullscreen_hook;
6874 terminal
->set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6875 terminal
->condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6876 terminal
->redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6877 terminal
->judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6879 terminal
->delete_frame_hook
= x_destroy_window
;
6880 terminal
->delete_terminal_hook
= x_delete_terminal
;
6882 terminal
->rif
= &w32_redisplay_interface
;
6883 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
6884 terminal
->char_ins_del_ok
= 1;
6885 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
6886 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
6887 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
6891 /* We don't yet support separate terminals on W32, so don't try to share
6892 keyboards between virtual terminals that are on the same physical
6893 terminal like X does. */
6894 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
6895 init_kboard (terminal
->kboard
);
6896 terminal
->kboard
->Vwindow_system
= intern ("w32");
6897 terminal
->kboard
->next_kboard
= all_kboards
;
6898 all_kboards
= terminal
->kboard
;
6899 /* Don't let the initial kboard remain current longer than necessary.
6900 That would cause problems if a file loaded on startup tries to
6901 prompt in the mini-buffer. */
6902 if (current_kboard
== initial_kboard
)
6903 current_kboard
= terminal
->kboard
;
6904 terminal
->kboard
->reference_count
++;
6911 x_delete_terminal (struct terminal
*terminal
)
6913 struct w32_display_info
*dpyinfo
= terminal
->display_info
.w32
;
6916 /* Protect against recursive calls. Fdelete_frame in
6917 delete_terminal calls us back when it deletes our last frame. */
6918 if (!terminal
->name
)
6923 /* Free the fonts in the font table. */
6924 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
6925 if (dpyinfo
->font_table
[i
].name
)
6927 DeleteObject (((XFontStruct
*)(dpyinfo
->font_table
[i
].font
))->hfont
);
6931 x_delete_display (dpyinfo
);
6935 struct w32_display_info
*
6936 w32_term_init (display_name
, xrm_option
, resource_name
)
6937 Lisp_Object display_name
;
6939 char *resource_name
;
6941 struct w32_display_info
*dpyinfo
;
6942 struct terminal
*terminal
;
6947 if (!w32_initialized
)
6950 w32_initialized
= 1;
6953 w32_initialize_display_info (display_name
);
6955 dpyinfo
= &one_w32_display_info
;
6956 terminal
= w32_create_terminal (dpyinfo
);
6958 /* Set the name of the terminal. */
6959 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
6960 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
6961 terminal
->name
[SBYTES (display_name
)] = 0;
6963 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6965 /* Put this display on the chain. */
6966 dpyinfo
->next
= x_display_list
;
6967 x_display_list
= dpyinfo
;
6969 hdc
= GetDC (GetDesktopWindow ());
6971 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
6972 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
6973 dpyinfo
->root_window
= GetDesktopWindow ();
6974 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6975 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6976 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6977 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6978 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6979 dpyinfo
->terminal
->image_cache
= make_image_cache ();
6980 dpyinfo
->height_in
= dpyinfo
->height
/ dpyinfo
->resx
;
6981 dpyinfo
->width_in
= dpyinfo
->width
/ dpyinfo
->resy
;
6982 ReleaseDC (GetDesktopWindow (), hdc
);
6984 /* initialise palette with white and black */
6987 w32_defined_color (0, "white", &color
, 1);
6988 w32_defined_color (0, "black", &color
, 1);
6991 /* Add the default keyboard. */
6992 add_keyboard_wait_descriptor (0);
6994 /* Create Fringe Bitmaps and store them for later use.
6996 On W32, bitmaps are all unsigned short, as Windows requires
6997 bitmap data to be Word aligned. For some reason they are
6998 horizontally reflected compared to how they appear on X, so we
6999 need to bitswap and convert to unsigned shorts before creating
7001 w32_init_fringe (terminal
->rif
);
7004 fcntl (connection
, F_SETOWN
, getpid ());
7005 #endif /* ! defined (F_SETOWN) */
7008 if (interrupt_input
)
7009 init_sigio (connection
);
7010 #endif /* ! defined (SIGIO) */
7017 /* Get rid of display DPYINFO, assuming all frames are already gone. */
7019 x_delete_display (dpyinfo
)
7020 struct w32_display_info
*dpyinfo
;
7022 /* Discard this display from w32_display_name_list and w32_display_list.
7023 We can't use Fdelq because that can quit. */
7024 if (! NILP (w32_display_name_list
)
7025 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
7026 w32_display_name_list
= XCDR (w32_display_name_list
);
7031 tail
= w32_display_name_list
;
7032 while (CONSP (tail
) && CONSP (XCDR (tail
)))
7034 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
7036 XSETCDR (tail
, XCDR (XCDR (tail
)));
7043 /* free palette table */
7045 struct w32_palette_entry
* plist
;
7047 plist
= dpyinfo
->color_list
;
7050 struct w32_palette_entry
* pentry
= plist
;
7051 plist
= plist
->next
;
7054 dpyinfo
->color_list
= NULL
;
7055 if (dpyinfo
->palette
)
7056 DeleteObject(dpyinfo
->palette
);
7059 xfree (dpyinfo
->font_table
);
7061 xfree (dpyinfo
->w32_id_name
);
7063 w32_reset_fringes ();
7066 /* Set up use of W32. */
7068 DWORD WINAPI
w32_msg_worker (void * arg
);
7075 w32_system_caret_hwnd
= NULL
;
7076 w32_system_caret_height
= 0;
7077 w32_system_caret_x
= 0;
7078 w32_system_caret_y
= 0;
7080 /* Initialize w32_use_visible_system_caret based on whether a screen
7081 reader is in use. */
7082 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
7083 &w32_use_visible_system_caret
, 0))
7084 w32_use_visible_system_caret
= 0;
7086 last_tool_bar_item
= -1;
7087 any_help_event_p
= 0;
7089 /* Initialize input mode: interrupt_input off, no flow control, allow
7090 8 bit character input, standard quit char. */
7091 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
7093 /* Create the window thread - it will terminate itself or when the app terminates */
7097 dwMainThreadId
= GetCurrentThreadId ();
7098 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
7099 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
7101 /* Wait for thread to start */
7106 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
7108 hWindowsThread
= CreateThread (NULL
, 0,
7110 0, 0, &dwWindowsThreadId
);
7112 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
7115 /* It is desirable that mainThread should have the same notion of
7116 focus window and active window as windowsThread. Unfortunately, the
7117 following call to AttachThreadInput, which should do precisely what
7118 we need, causes major problems when Emacs is linked as a console
7119 program. Unfortunately, we have good reasons for doing that, so
7120 instead we need to send messages to windowsThread to make some API
7121 calls for us (ones that affect, or depend on, the active/focus
7123 #ifdef ATTACH_THREADS
7124 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
7127 /* Dynamically link to optional system components. */
7129 UINT smoothing_type
;
7130 BOOL smoothing_enabled
;
7132 HANDLE gdi_lib
= LoadLibrary ("gdi32.dll");
7134 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
7136 LOAD_PROC (gdi_lib
, GetFontUnicodeRanges
);
7140 FreeLibrary (gdi_lib
);
7142 /* Ensure scrollbar handle is at least 5 pixels. */
7143 vertical_scroll_bar_min_handle
= 5;
7145 /* For either kind of scroll bar, take account of the arrows; these
7146 effectively form the border of the main scroll bar range. */
7147 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
7148 = GetSystemMetrics (SM_CYVSCROLL
);
7150 /* Constants that are not always defined by the system headers
7151 since they only exist on certain versions of Windows. */
7152 #ifndef SPI_GETFONTSMOOTHING
7153 #define SPI_GETFONTSMOOTHING 0x4A
7155 #ifndef SPI_GETFONTSMOOTHINGTYPE
7156 #define SPI_GETFONTSMOOTHINGTYPE 0x0200A
7158 #ifndef FE_FONTSMOOTHINGCLEARTYPE
7159 #define FE_FONTSMOOTHINGCLEARTYPE 0x2
7162 /* Determine if Cleartype is in use. Used to enable a hack in
7163 the char metric calculations which adds extra pixels to
7164 compensate for the "sub-pixels" that are not counted by the
7167 SystemParametersInfo (SPI_GETFONTSMOOTHING
, 0, &smoothing_enabled
, 0)
7168 && smoothing_enabled
7169 && SystemParametersInfo (SPI_GETFONTSMOOTHINGTYPE
, 0, &smoothing_type
, 0)
7170 && smoothing_type
== FE_FONTSMOOTHINGCLEARTYPE
;
7177 staticpro (&w32_display_name_list
);
7178 w32_display_name_list
= Qnil
;
7180 staticpro (&last_mouse_scroll_bar
);
7181 last_mouse_scroll_bar
= Qnil
;
7183 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
7185 DEFVAR_INT ("w32-num-mouse-buttons",
7186 &w32_num_mouse_buttons
,
7187 doc
: /* Number of physical mouse buttons. */);
7188 w32_num_mouse_buttons
= 2;
7190 DEFVAR_LISP ("w32-swap-mouse-buttons",
7191 &Vw32_swap_mouse_buttons
,
7192 doc
: /* Swap the mapping of middle and right mouse buttons.
7193 When nil, middle button is mouse-2 and right button is mouse-3. */);
7194 Vw32_swap_mouse_buttons
= Qnil
;
7196 DEFVAR_LISP ("w32-grab-focus-on-raise",
7197 &Vw32_grab_focus_on_raise
,
7198 doc
: /* Raised frame grabs input focus.
7199 When t, `raise-frame' grabs input focus as well. This fits well
7200 with the normal Windows click-to-focus policy, but might not be
7201 desirable when using a point-to-focus policy. */);
7202 Vw32_grab_focus_on_raise
= Qt
;
7204 DEFVAR_LISP ("w32-capslock-is-shiftlock",
7205 &Vw32_capslock_is_shiftlock
,
7206 doc
: /* Apply CapsLock state to non character input keys.
7207 When nil, CapsLock only affects normal character input keys. */);
7208 Vw32_capslock_is_shiftlock
= Qnil
;
7210 DEFVAR_LISP ("w32-recognize-altgr",
7211 &Vw32_recognize_altgr
,
7212 doc
: /* Recognize right-alt and left-ctrl as AltGr.
7213 When nil, the right-alt and left-ctrl key combination is
7214 interpreted normally. */);
7215 Vw32_recognize_altgr
= Qt
;
7217 DEFVAR_BOOL ("w32-enable-unicode-output",
7218 &w32_enable_unicode_output
,
7219 doc
: /* Enable the use of Unicode for text output if non-nil.
7220 Unicode output may prevent some third party applications for displaying
7221 Far-East Languages on Windows 95/98 from working properly.
7222 NT uses Unicode internally anyway, so this flag will probably have no
7223 effect on NT machines. */);
7224 w32_enable_unicode_output
= 1;
7226 DEFVAR_BOOL ("w32-use-visible-system-caret",
7227 &w32_use_visible_system_caret
,
7228 doc
: /* Flag to make the system caret visible.
7229 When this is non-nil, Emacs will indicate the position of point by
7230 using the system caret instead of drawing its own cursor. Some screen
7231 reader software does not track the system cursor properly when it is
7232 invisible, and gets confused by Emacs drawing its own cursor, so this
7233 variable is initialized to t when Emacs detects that screen reader
7234 software is running as it starts up.
7236 When this variable is set, other variables affecting the appearance of
7237 the cursor have no effect. */);
7239 w32_use_visible_system_caret
= 0;
7241 /* We don't yet support this, but defining this here avoids whining
7242 from cus-start.el and other places, like "M-x set-variable". */
7243 DEFVAR_BOOL ("x-use-underline-position-properties",
7244 &x_use_underline_position_properties
,
7245 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
7246 A value of nil means ignore them. If you encounter fonts with bogus
7247 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
7248 to 4.1, set this to nil.
7250 NOTE: Not supported on MS-Windows yet. */);
7251 x_use_underline_position_properties
= 0;
7253 DEFVAR_BOOL ("x-underline-at-descent-line",
7254 &x_underline_at_descent_line
,
7255 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
7256 A value of nil means to draw the underline according to the value of the
7257 variable `x-use-underline-position-properties', which is usually at the
7258 baseline level. The default value is nil. */);
7259 x_underline_at_descent_line
= 0;
7261 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
7262 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
7263 Vx_toolkit_scroll_bars
= Qt
;
7265 staticpro (&last_mouse_motion_frame
);
7266 last_mouse_motion_frame
= Qnil
;
7269 /* arch-tag: 5fa70624-ab86-499c-8a85-473958ee4646
7270 (do not change this comment) */