1 /* Implementation of GUI terminal on the Microsoft W32 API.
2 Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
28 #include "blockinput.h"
47 #include "dispextern.h"
49 #include "termhooks.h"
56 #include "intervals.h"
57 #include "composite.h"
60 #define abs(x) ((x) < 0 ? -(x) : (x))
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 extern unsigned int msh_mousewheel
;
92 extern void free_frame_menubar ();
94 extern int w32_codepage_for_font (char *fontname
);
95 extern Cursor
w32_load_cursor (LPCTSTR name
);
97 extern glyph_metric
*w32_BDF_TextMetric(bdffont
*fontp
,
98 unsigned char *text
, int dim
);
99 extern Lisp_Object Vwindow_system
;
101 #define x_any_window_to_frame x_window_to_frame
102 #define x_top_window_to_frame x_window_to_frame
105 /* This is display since w32 does not support multiple ones. */
106 struct w32_display_info one_w32_display_info
;
107 struct w32_display_info
*x_display_list
;
109 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
110 one for each element of w32_display_list and in the same order.
111 NAME is the name of the frame.
112 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
113 Lisp_Object w32_display_name_list
;
115 /* Frame being updated by update_frame. This is declared in term.c.
116 This is set by update_begin and looked at by all the
117 w32 functions. It is zero while not inside an update.
118 In that case, the w32 functions assume that `SELECTED_FRAME ()'
119 is the frame to apply to. */
120 extern struct frame
*updating_frame
;
122 /* This is a frame waiting to be autoraised, within w32_read_socket. */
123 struct frame
*pending_autoraise_frame
;
125 /* The handle of the frame that currently owns the system caret. */
126 HWND w32_system_caret_hwnd
;
127 int w32_system_caret_height
;
128 int w32_system_caret_x
;
129 int w32_system_caret_y
;
130 int w32_use_visible_system_caret
;
132 /* Flag to enable Unicode output in case users wish to use programs
133 like Twinbridge on '95 rather than installed system level support
134 for Far East languages. */
135 int w32_enable_unicode_output
;
137 DWORD dwWindowsThreadId
= 0;
138 HANDLE hWindowsThread
= NULL
;
139 DWORD dwMainThreadId
= 0;
140 HANDLE hMainThread
= NULL
;
143 /* These definitions are new with Windows 95. */
144 #define SIF_RANGE 0x0001
145 #define SIF_PAGE 0x0002
146 #define SIF_POS 0x0004
147 #define SIF_DISABLENOSCROLL 0x0008
148 #define SIF_TRACKPOS 0x0010
149 #define SIF_ALL (SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS)
151 typedef struct tagSCROLLINFO
160 } SCROLLINFO
, FAR
*LPSCROLLINFO
;
161 typedef SCROLLINFO CONST FAR
*LPCSCROLLINFO
;
164 /* Dynamic linking to new proportional scroll bar functions. */
165 int (PASCAL
*pfnSetScrollInfo
) (HWND hwnd
, int fnBar
, LPSCROLLINFO lpsi
, BOOL fRedraw
);
166 BOOL (PASCAL
*pfnGetScrollInfo
) (HWND hwnd
, int fnBar
, LPSCROLLINFO lpsi
);
168 int vertical_scroll_bar_min_handle
;
169 int vertical_scroll_bar_top_border
;
170 int vertical_scroll_bar_bottom_border
;
172 int last_scroll_bar_drag_pos
;
174 /* Mouse movement. */
176 /* Where the mouse was last time we reported a mouse event. */
178 static RECT last_mouse_glyph
;
179 static Lisp_Object last_mouse_press_frame
;
181 int w32_num_mouse_buttons
;
183 Lisp_Object Vw32_swap_mouse_buttons
;
185 /* Control whether x_raise_frame also sets input focus. */
186 Lisp_Object Vw32_grab_focus_on_raise
;
188 /* Control whether Caps Lock affects non-ascii characters. */
189 Lisp_Object Vw32_capslock_is_shiftlock
;
191 /* Control whether right-alt and left-ctrl should be recognized as AltGr. */
192 Lisp_Object Vw32_recognize_altgr
;
194 /* The scroll bar in which the last motion event occurred.
196 If the last motion event occurred in a scroll bar, we set this
197 so w32_mouse_position can know whether to report a scroll bar motion or
200 If the last motion event didn't occur in a scroll bar, we set this
201 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
202 static Lisp_Object last_mouse_scroll_bar
;
203 static int last_mouse_scroll_bar_pos
;
205 /* This is a hack. We would really prefer that w32_mouse_position would
206 return the time associated with the position it returns, but there
207 doesn't seem to be any way to wrest the time-stamp from the server
208 along with the position query. So, we just keep track of the time
209 of the last movement we received, and return that in hopes that
210 it's somewhat accurate. */
212 static Time last_mouse_movement_time
;
214 /* Incremented by w32_read_socket whenever it really tries to read
218 static int volatile input_signal_count
;
220 static int input_signal_count
;
223 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
229 /* A mask of extra modifier bits to put into every keyboard char. */
231 extern EMACS_INT extra_keyboard_modifiers
;
233 static void x_update_window_end
P_ ((struct window
*, int, int));
234 void w32_delete_display
P_ ((struct w32_display_info
*));
235 static void w32_handle_tool_bar_click
P_ ((struct frame
*,
236 struct input_event
*));
237 void w32_define_cursor
P_ ((Window
, Cursor
));
239 void x_lower_frame
P_ ((struct frame
*));
240 void x_scroll_bar_clear
P_ ((struct frame
*));
241 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
242 void x_raise_frame
P_ ((struct frame
*));
243 void x_set_window_size
P_ ((struct frame
*, int, int, int));
244 void x_wm_set_window_state
P_ ((struct frame
*, int));
245 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
246 void w32_initialize
P_ ((void));
247 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
248 int x_compute_min_glyph_bounds
P_ ((struct frame
*));
249 static void x_update_end
P_ ((struct frame
*));
250 static void w32_frame_up_to_date
P_ ((struct frame
*));
251 static void w32_set_terminal_modes
P_ ((void));
252 static void w32_reset_terminal_modes
P_ ((void));
253 static void x_clear_frame
P_ ((void));
254 static void frame_highlight
P_ ((struct frame
*));
255 static void frame_unhighlight
P_ ((struct frame
*));
256 static void x_new_focus_frame
P_ ((struct w32_display_info
*,
258 static void w32_frame_rehighlight
P_ ((struct frame
*));
259 static void x_frame_rehighlight
P_ ((struct w32_display_info
*));
260 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
261 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
262 enum text_cursor_kinds
));
263 static void w32_clip_to_row
P_ ((struct window
*, struct glyph_row
*, HDC
));
265 static Lisp_Object Qvendor_specific_keysyms
;
268 /***********************************************************************
270 ***********************************************************************/
274 /* This is a function useful for recording debugging information about
275 the sequence of occurrences in this file. */
283 struct record event_record
[100];
285 int event_record_index
;
287 record_event (locus
, type
)
291 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
292 event_record_index
= 0;
294 event_record
[event_record_index
].locus
= locus
;
295 event_record
[event_record_index
].type
= type
;
296 event_record_index
++;
303 XChangeGC (void * ignore
, XGCValues
* gc
, unsigned long mask
,
306 if (mask
& GCForeground
)
307 gc
->foreground
= xgcv
->foreground
;
308 if (mask
& GCBackground
)
309 gc
->background
= xgcv
->background
;
311 gc
->font
= xgcv
->font
;
314 XGCValues
*XCreateGC (void * ignore
, Window window
, unsigned long mask
,
317 XGCValues
*gc
= (XGCValues
*) xmalloc (sizeof (XGCValues
));
318 bzero (gc
, sizeof (XGCValues
));
320 XChangeGC (ignore
, gc
, mask
, xgcv
);
326 XGetGCValues (void* ignore
, XGCValues
*gc
,
327 unsigned long mask
, XGCValues
*xgcv
)
329 XChangeGC (ignore
, xgcv
, mask
, gc
);
333 w32_set_clip_rectangle (HDC hdc
, RECT
*rect
)
337 HRGN clip_region
= CreateRectRgnIndirect (rect
);
338 SelectClipRgn (hdc
, clip_region
);
339 DeleteObject (clip_region
);
342 SelectClipRgn (hdc
, NULL
);
346 /* Draw a hollow rectangle at the specified position. */
348 w32_draw_rectangle (HDC hdc
, XGCValues
*gc
, int x
, int y
,
349 int width
, int height
)
354 hb
= CreateSolidBrush (gc
->background
);
355 hp
= CreatePen (PS_SOLID
, 0, gc
->foreground
);
356 oldhb
= SelectObject (hdc
, hb
);
357 oldhp
= SelectObject (hdc
, hp
);
359 Rectangle (hdc
, x
, y
, x
+ width
, y
+ height
);
361 SelectObject (hdc
, oldhb
);
362 SelectObject (hdc
, oldhp
);
367 /* Draw a filled rectangle at the specified position. */
369 w32_fill_rect (f
, hdc
, pix
, lprect
)
377 hb
= CreateSolidBrush (pix
);
378 FillRect (hdc
, lprect
, hb
);
387 HDC hdc
= get_frame_dc (f
);
389 /* Under certain conditions, this can be called at startup with
390 a console frame pointer before the GUI frame is created. An HDC
391 of 0 indicates this. */
394 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
395 w32_clear_rect (f
, hdc
, &rect
);
398 release_frame_dc (f
, hdc
);
402 /***********************************************************************
403 Starting and ending an update
404 ***********************************************************************/
406 /* Start an update of frame F. This function is installed as a hook
407 for update_begin, i.e. it is called when update_begin is called.
408 This function is called prior to calls to x_update_window_begin for
409 each window being updated. */
415 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
417 if (! FRAME_W32_P (f
))
420 /* Regenerate display palette before drawing if list of requested
421 colors has changed. */
422 if (display_info
->regen_palette
)
424 w32_regenerate_palette (f
);
425 display_info
->regen_palette
= FALSE
;
430 /* Start update of window W. Set the global variable updated_window
431 to the window being updated and set output_cursor to the cursor
435 x_update_window_begin (w
)
438 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
439 struct w32_display_info
*display_info
= FRAME_W32_DISPLAY_INFO (f
);
441 /* Hide the system caret during an update. */
442 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
444 SendMessage (w32_system_caret_hwnd
, WM_EMACS_HIDE_CARET
, 0, 0);
448 set_output_cursor (&w
->cursor
);
452 if (f
== display_info
->mouse_face_mouse_frame
)
454 /* Don't do highlighting for mouse motion during the update. */
455 display_info
->mouse_face_defer
= 1;
457 /* If F needs to be redrawn, simply forget about any prior mouse
459 if (FRAME_GARBAGED_P (f
))
460 display_info
->mouse_face_window
= Qnil
;
462 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
463 their mouse_face_p flag set, which means that they are always
464 unequal to rows in a desired matrix which never have that
465 flag set. So, rows containing mouse-face glyphs are never
466 scrolled, and we don't have to switch the mouse highlight off
467 here to prevent it from being scrolled. */
469 /* Can we tell that this update does not affect the window
470 where the mouse highlight is? If so, no need to turn off.
471 Likewise, don't do anything if the frame is garbaged;
472 in that case, the frame's current matrix that we would use
473 is all wrong, and we will redisplay that line anyway. */
474 if (!NILP (display_info
->mouse_face_window
)
475 && w
== XWINDOW (display_info
->mouse_face_window
))
479 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
480 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
483 if (i
< w
->desired_matrix
->nrows
)
484 clear_mouse_face (display_info
);
492 /* Draw a vertical window border from (x,y0) to (x,y1) */
495 w32_draw_vertical_window_border (w
, x
, y0
, y1
)
499 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
508 hdc
= get_frame_dc (f
);
509 w32_fill_rect (f
, hdc
, FRAME_FOREGROUND_PIXEL (f
), &r
);
510 release_frame_dc (f
, hdc
);
514 /* End update of window W (which is equal to updated_window).
516 Draw vertical borders between horizontally adjacent windows, and
517 display W's cursor if CURSOR_ON_P is non-zero.
519 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
520 glyphs in mouse-face were overwritten. In that case we have to
521 make sure that the mouse-highlight is properly redrawn.
523 W may be a menu bar pseudo-window in case we don't have X toolkit
524 support. Such windows don't have a cursor, so don't display it
528 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
530 int cursor_on_p
, mouse_face_overwritten_p
;
532 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (XFRAME (w
->frame
));
534 if (!w
->pseudo_window_p
)
539 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
541 output_cursor
.x
, output_cursor
.y
);
543 if (draw_window_fringes (w
, 1))
544 x_draw_vertical_border (w
);
549 /* If a row with mouse-face was overwritten, arrange for
550 XTframe_up_to_date to redisplay the mouse highlight. */
551 if (mouse_face_overwritten_p
)
553 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
554 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
555 dpyinfo
->mouse_face_window
= Qnil
;
558 /* Unhide the caret. This won't actually show the cursor, unless it
559 was visible before the corresponding call to HideCaret in
560 x_update_window_begin. */
561 if (w32_use_visible_system_caret
&& w32_system_caret_hwnd
)
563 SendMessage (w32_system_caret_hwnd
, WM_EMACS_SHOW_CARET
, 0, 0);
566 updated_window
= NULL
;
570 /* End update of frame F. This function is installed as a hook in
577 if (! FRAME_W32_P (f
))
580 /* Mouse highlight may be displayed again. */
581 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
585 /* This function is called from various places in xdisp.c whenever a
586 complete update has been performed. The global variable
587 updated_window is not available here. */
590 w32_frame_up_to_date (f
)
595 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
597 if (dpyinfo
->mouse_face_deferred_gc
598 || f
== dpyinfo
->mouse_face_mouse_frame
)
601 if (dpyinfo
->mouse_face_mouse_frame
)
602 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
603 dpyinfo
->mouse_face_mouse_x
,
604 dpyinfo
->mouse_face_mouse_y
);
605 dpyinfo
->mouse_face_deferred_gc
= 0;
612 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
613 arrow bitmaps, or clear the fringes if no bitmaps are required
614 before DESIRED_ROW is made current. The window being updated is
615 found in updated_window. This function is called from
616 update_window_line only if it is known that there are differences
617 between bitmaps to be drawn between current row and DESIRED_ROW. */
620 x_after_update_window_line (desired_row
)
621 struct glyph_row
*desired_row
;
623 struct window
*w
= updated_window
;
629 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
630 desired_row
->redraw_fringe_bitmaps_p
= 1;
632 /* When a window has disappeared, make sure that no rest of
633 full-width rows stays visible in the internal border. Could
634 check here if updated_window is the leftmost/rightmost window,
635 but I guess it's not worth doing since vertically split windows
636 are almost never used, internal border is rarely set, and the
637 overhead is very small. */
638 if (windows_or_buffers_changed
639 && desired_row
->full_width_p
640 && (f
= XFRAME (w
->frame
),
641 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
643 && (height
= desired_row
->visible_height
,
646 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
648 /* Internal border is drawn below the tool bar. */
649 if (WINDOWP (f
->tool_bar_window
)
650 && w
== XWINDOW (f
->tool_bar_window
))
655 HDC hdc
= get_frame_dc (f
);
656 w32_clear_area (f
, hdc
, 0, y
, width
, height
);
657 w32_clear_area (f
, hdc
, FRAME_PIXEL_WIDTH (f
) - width
,
659 release_frame_dc (f
, hdc
);
666 /* Draw the bitmap WHICH in one of the left or right fringes of
667 window W. ROW is the glyph row for which to display the bitmap; it
668 determines the vertical position at which the bitmap has to be
672 w32_draw_fringe_bitmap (w
, row
, p
)
674 struct glyph_row
*row
;
675 struct draw_fringe_bitmap_params
*p
;
677 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
679 struct face
*face
= p
->face
;
682 hdc
= get_frame_dc (f
);
684 /* Must clip because of partially visible lines. */
685 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
688 /* Adjust position of "bottom aligned" bitmap on partially
691 int oldVH
= row
->visible_height
;
692 row
->visible_height
= p
->h
;
693 row
->y
-= rowY
- p
->y
;
694 w32_clip_to_row (w
, row
, hdc
);
696 row
->visible_height
= oldVH
;
699 w32_clip_to_row (w
, row
, hdc
);
701 if (p
->bx
>= 0 && !p
->overlay_p
)
703 w32_fill_area (f
, hdc
, face
->background
,
704 p
->bx
, p
->by
, p
->nx
, p
->ny
);
707 if (p
->which
&& p
->which
< max_fringe_bmp
)
709 HBITMAP pixmap
= fringe_bmp
[p
->which
];
713 compat_hdc
= CreateCompatibleDC (hdc
);
717 horig_obj
= SelectObject (compat_hdc
, pixmap
);
719 /* Paint overlays transparently. */
722 HBRUSH h_brush
, h_orig_brush
;
724 SetTextColor (hdc
, BLACK_PIX_DEFAULT (f
));
725 SetBkColor (hdc
, WHITE_PIX_DEFAULT (f
));
726 h_brush
= CreateSolidBrush (face
->foreground
);
727 h_orig_brush
= SelectObject (hdc
, h_brush
);
729 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
730 compat_hdc
, 0, p
->dh
,
732 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
733 compat_hdc
, 0, p
->dh
,
735 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
736 compat_hdc
, 0, p
->dh
,
739 SelectObject (hdc
, h_orig_brush
);
740 DeleteObject (h_brush
);
744 SetTextColor (hdc
, face
->background
);
745 SetBkColor (hdc
, (p
->cursor_p
746 ? f
->output_data
.w32
->cursor_pixel
747 : face
->foreground
));
749 BitBlt (hdc
, p
->x
, p
->y
, p
->wd
, p
->h
,
750 compat_hdc
, 0, p
->dh
,
754 SelectObject (compat_hdc
, horig_obj
);
755 DeleteDC (compat_hdc
);
759 w32_set_clip_rectangle (hdc
, NULL
);
761 release_frame_dc (f
, hdc
);
765 w32_define_fringe_bitmap (which
, bits
, h
, wd
)
767 unsigned short *bits
;
770 if (which
>= max_fringe_bmp
)
772 int i
= max_fringe_bmp
;
773 max_fringe_bmp
= which
+ 20;
774 fringe_bmp
= (HBITMAP
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (HBITMAP
));
775 while (i
< max_fringe_bmp
)
779 fringe_bmp
[which
] = CreateBitmap (wd
, h
, 1, 1, bits
);
783 w32_destroy_fringe_bitmap (which
)
786 if (which
>= max_fringe_bmp
)
789 if (fringe_bmp
[which
])
790 DeleteObject (fringe_bmp
[which
]);
791 fringe_bmp
[which
] = 0;
796 /* This is called when starting Emacs and when restarting after
797 suspend. When starting Emacs, no window is mapped. And nothing
798 must be done to Emacs's own window if it is suspended (though that
802 w32_set_terminal_modes (void)
806 /* This is called when exiting or suspending Emacs. Exiting will make
807 the W32 windows go away, and suspending requires no action. */
810 w32_reset_terminal_modes (void)
816 /***********************************************************************
818 ***********************************************************************/
820 /* Function prototypes of this page. */
822 static XCharStruct
*w32_per_char_metric
P_ ((XFontStruct
*,
824 static int w32_encode_char
P_ ((int, wchar_t *, struct font_info
*, int *));
827 /* Get metrics of character CHAR2B in FONT. Value is always non-null.
828 If CHAR2B is not contained in FONT, the font's default character
829 metric is returned. */
832 w32_bdf_per_char_metric (font
, char2b
, dim
, pcm
)
838 glyph_metric
* bdf_metric
;
842 buf
[0] = (char)(*char2b
);
845 buf
[0] = XCHAR2B_BYTE1 (char2b
);
846 buf
[1] = XCHAR2B_BYTE2 (char2b
);
849 bdf_metric
= w32_BDF_TextMetric (font
->bdf
, buf
, dim
);
853 pcm
->width
= bdf_metric
->dwidth
;
854 pcm
->lbearing
= bdf_metric
->bbox
;
855 pcm
->rbearing
= bdf_metric
->dwidth
856 - (bdf_metric
->bbox
+ bdf_metric
->bbw
);
857 pcm
->ascent
= bdf_metric
->bboy
+ bdf_metric
->bbh
;
858 pcm
->descent
= -bdf_metric
->bboy
;
867 w32_native_per_char_metric (font
, char2b
, font_type
, pcm
)
870 enum w32_char_font_type font_type
;
873 HDC hdc
= GetDC (NULL
);
877 xassert (font
&& char2b
);
878 xassert (font
->hfont
);
879 xassert (font_type
== UNICODE_FONT
|| font_type
== ANSI_FONT
);
881 old_font
= SelectObject (hdc
, font
->hfont
);
883 if ((font
->tm
.tmPitchAndFamily
& TMPF_TRUETYPE
) != 0)
887 if (font_type
== UNICODE_FONT
)
888 retval
= GetCharABCWidthsW (hdc
, *char2b
, *char2b
, &char_widths
);
890 retval
= GetCharABCWidthsA (hdc
, *char2b
, *char2b
, &char_widths
);
895 /* Disabled until we can find a way to get the right results
896 on all versions of Windows. */
898 /* Don't trust the ABC widths. For synthesized fonts they are
899 wrong, and so is the result of GetCharWidth()! */
901 GetCharWidth (hdc
, *char2b
, *char2b
, &real_width
);
903 pcm
->width
= char_widths
.abcA
+ char_widths
.abcB
+ char_widths
.abcC
;
905 /* As far as I can tell, this is the best way to determine what
906 ExtTextOut will do with the broken font. */
907 if (pcm
->width
!= real_width
)
908 pcm
->width
= (pcm
->width
+ real_width
) / 2;
910 pcm
->lbearing
= char_widths
.abcA
;
911 pcm
->rbearing
= char_widths
.abcA
+ char_widths
.abcB
;
912 pcm
->ascent
= FONT_BASE (font
);
913 pcm
->descent
= FONT_DESCENT (font
);
919 /* Either font is not a True-type font, or GetCharABCWidthsW
920 failed (it is not supported on Windows 9x for instance), so we
921 can't determine the full info we would like. All is not lost
922 though - we can call GetTextExtentPoint32 to get rbearing and
923 deduce width based on the font's per-string overhang. lbearing
924 is assumed to be zero. */
926 /* TODO: Some Thai characters (and other composites if Windows
927 supports them) do have lbearing, and report their total width
928 as zero. Need some way of handling them when
929 GetCharABCWidthsW fails. */
932 if (font_type
== UNICODE_FONT
)
933 retval
= GetTextExtentPoint32W (hdc
, char2b
, 1, &sz
);
935 retval
= GetTextExtentPoint32A (hdc
, (char*)char2b
, 1, &sz
);
939 pcm
->width
= sz
.cx
- font
->tm
.tmOverhang
;
940 pcm
->rbearing
= sz
.cx
;
942 pcm
->ascent
= FONT_BASE (font
);
943 pcm
->descent
= FONT_DESCENT (font
);
948 if (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0)
953 SelectObject (hdc
, old_font
);
954 ReleaseDC (NULL
, hdc
);
961 w32_per_char_metric (font
, char2b
, font_type
)
964 int /* enum w32_char_font_type */ font_type
;
966 /* The result metric information. */
970 xassert (font
&& char2b
);
972 /* TODO: This function is currently called through the RIF, and in
973 some cases font_type is UNKNOWN_FONT. We currently allow the
974 cached metrics to be used, which seems to work, but in cases
975 where font_type is UNKNOWN_FONT, we probably haven't encoded
976 char2b appropriately. All callers need checking to see what they
977 are passing. This is most likely to affect variable width fonts
978 outside the Latin-1 range, particularly in languages like Thai
979 that rely on rbearing and lbearing to provide composition. I
980 don't think that is working currently anyway, but we don't seem
981 to have anyone testing such languages on Windows. */
983 /* Handle the common cases quickly. */
984 if (!font
->bdf
&& font
->per_char
== NULL
)
985 /* TODO: determine whether char2b exists in font? */
986 return &font
->max_bounds
;
987 else if (!font
->bdf
&& *char2b
< 128)
988 return &font
->per_char
[*char2b
];
990 xassert (font_type
!= UNKNOWN_FONT
);
992 pcm
= &font
->scratch
;
994 if (font_type
== BDF_1D_FONT
)
995 retval
= w32_bdf_per_char_metric (font
, char2b
, 1, pcm
);
996 else if (font_type
== BDF_2D_FONT
)
997 retval
= w32_bdf_per_char_metric (font
, char2b
, 2, pcm
);
999 retval
= w32_native_per_char_metric (font
, char2b
, font_type
, pcm
);
1008 w32_cache_char_metrics (font
)
1011 wchar_t char2b
= L
'x';
1013 /* Cache char metrics for the common cases. */
1016 /* TODO: determine whether font is fixed-pitch. */
1017 if (!w32_bdf_per_char_metric (font
, &char2b
, 1, &font
->max_bounds
))
1019 /* Use the font width and height as max bounds, as not all BDF
1020 fonts contain the letter 'x'. */
1021 font
->max_bounds
.width
= FONT_MAX_WIDTH (font
);
1022 font
->max_bounds
.lbearing
= -font
->bdf
->llx
;
1023 font
->max_bounds
.rbearing
= FONT_MAX_WIDTH (font
) - font
->bdf
->urx
;
1024 font
->max_bounds
.ascent
= FONT_BASE (font
);
1025 font
->max_bounds
.descent
= FONT_DESCENT (font
);
1030 if (((font
->tm
.tmPitchAndFamily
& TMPF_FIXED_PITCH
) != 0)
1031 /* Some fonts (eg DBCS fonts) are marked as fixed width even
1032 though they contain characters of different widths. */
1033 || (font
->tm
.tmMaxCharWidth
!= font
->tm
.tmAveCharWidth
))
1035 /* Font is not fixed pitch, so cache per_char info for the
1036 ASCII characters. It would be much more work, and probably
1037 not worth it, to cache other chars, since we may change
1038 between using Unicode and ANSI text drawing functions at
1042 font
->per_char
= xmalloc (128 * sizeof(XCharStruct
));
1043 for (i
= 0; i
< 128; i
++)
1046 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1047 &font
->per_char
[i
]);
1051 w32_native_per_char_metric (font
, &char2b
, ANSI_FONT
,
1057 /* Determine if a font is double byte. */
1058 int w32_font_is_double_byte (XFontStruct
*font
)
1060 return font
->double_byte_p
;
1065 w32_use_unicode_for_codepage (codepage
)
1068 /* If the current codepage is supported, use Unicode for output. */
1069 return (w32_enable_unicode_output
1070 && codepage
!= CP_8BIT
1071 && (codepage
== CP_UNICODE
|| IsValidCodePage (codepage
)));
1074 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1075 the two-byte form of C. Encoding is returned in *CHAR2B. */
1077 static int /* enum w32_char_font_type */
1078 w32_encode_char (c
, char2b
, font_info
, two_byte_p
)
1081 struct font_info
*font_info
;
1084 int charset
= CHAR_CHARSET (c
);
1087 int internal_two_byte_p
= 0;
1089 XFontStruct
*font
= font_info
->font
;
1091 internal_two_byte_p
= w32_font_is_double_byte (font
);
1093 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1094 This may be either a program in a special encoder language or a
1096 if (font_info
->font_encoder
)
1098 /* It's a program. */
1099 struct ccl_program
*ccl
= font_info
->font_encoder
;
1101 if (CHARSET_DIMENSION (charset
) == 1)
1103 ccl
->reg
[0] = charset
;
1104 ccl
->reg
[1] = XCHAR2B_BYTE2 (char2b
);
1109 ccl
->reg
[0] = charset
;
1110 ccl
->reg
[1] = XCHAR2B_BYTE1 (char2b
);
1111 ccl
->reg
[2] = XCHAR2B_BYTE2 (char2b
);
1114 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
1116 /* We assume that MSBs are appropriately set/reset by CCL
1118 if (!internal_two_byte_p
) /* 1-byte font */
1119 STORE_XCHAR2B (char2b
, 0, ccl
->reg
[1]);
1121 STORE_XCHAR2B (char2b
, ccl
->reg
[1], ccl
->reg
[2]);
1123 else if (font_info
->encoding
[charset
])
1125 /* Fixed encoding scheme. See fontset.h for the meaning of the
1126 encoding numbers. */
1127 int enc
= font_info
->encoding
[charset
];
1129 if ((enc
== 1 || enc
== 2)
1130 && CHARSET_DIMENSION (charset
) == 2)
1131 STORE_XCHAR2B (char2b
, XCHAR2B_BYTE1 (char2b
) | 0x80, XCHAR2B_BYTE2 (char2b
));
1133 if (enc
== 1 || enc
== 3
1134 || (enc
== 4 && CHARSET_DIMENSION (charset
) == 1))
1135 STORE_XCHAR2B (char2b
, XCHAR2B_BYTE1 (char2b
), XCHAR2B_BYTE2 (char2b
) | 0x80);
1140 ENCODE_SJIS (XCHAR2B_BYTE1 (char2b
), XCHAR2B_BYTE2 (char2b
),
1142 STORE_XCHAR2B (char2b
, sjis1
, sjis2
);
1145 codepage
= font_info
->codepage
;
1147 /* If charset is not ASCII or Latin-1, may need to move it into
1149 if ( font
&& !font
->bdf
&& w32_use_unicode_for_codepage (codepage
)
1150 && charset
!= CHARSET_ASCII
&& charset
!= charset_latin_iso8859_1
1151 && charset
!= CHARSET_8_BIT_CONTROL
&& charset
!= CHARSET_8_BIT_GRAPHIC
)
1154 temp
[0] = XCHAR2B_BYTE1 (char2b
);
1155 temp
[1] = XCHAR2B_BYTE2 (char2b
);
1157 if (codepage
!= CP_UNICODE
)
1160 MultiByteToWideChar (codepage
, 0, temp
, 2, char2b
, 1);
1162 MultiByteToWideChar (codepage
, 0, temp
+1, 1, char2b
, 1);
1165 internal_two_byte_p
= 1;
1169 *two_byte_p
= internal_two_byte_p
;
1172 return UNKNOWN_FONT
;
1173 else if (font
->bdf
&& CHARSET_DIMENSION (charset
) == 1)
1178 return UNICODE_FONT
;
1185 /***********************************************************************
1187 ***********************************************************************/
1190 /* Encapsulate the different ways of displaying text under W32. */
1193 w32_text_out (s
, x
, y
,chars
,nchars
)
1194 struct glyph_string
* s
;
1199 int charset_dim
= w32_font_is_double_byte (s
->font
) ? 2 : 1;
1201 w32_BDF_TextOut (s
->font
->bdf
, s
->hdc
,
1202 x
, y
, (char *) chars
, charset_dim
,
1203 nchars
* charset_dim
, 0);
1204 else if (s
->first_glyph
->font_type
== UNICODE_FONT
)
1205 ExtTextOutW (s
->hdc
, x
, y
, 0, NULL
, chars
, nchars
, NULL
);
1207 ExtTextOutA (s
->hdc
, x
, y
, 0, NULL
, (char *) chars
,
1208 nchars
* charset_dim
, NULL
);
1213 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
1214 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
1215 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
1217 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
1218 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
1219 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
1220 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
1221 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
1222 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
1223 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
1224 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
1225 static void w32_setup_relief_color
P_ ((struct frame
*, struct relief
*,
1226 double, int, COLORREF
));
1227 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
1228 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
1229 static void x_draw_image_relief
P_ ((struct glyph_string
*));
1230 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
1231 static void w32_draw_image_foreground_1
P_ ((struct glyph_string
*, HBITMAP
));
1232 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
1234 static void w32_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
1235 int, int, int, int, int, int,
1237 static void w32_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
1238 int, int, int, RECT
*));
1241 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
1245 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1250 struct glyph_string
*s
;
1252 if (s
->font
== FRAME_FONT (s
->f
)
1253 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1254 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1256 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
1259 /* Cursor on non-default face: must merge. */
1263 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
1264 xgcv
.foreground
= s
->face
->background
;
1266 /* If the glyph would be invisible, try a different foreground. */
1267 if (xgcv
.foreground
== xgcv
.background
)
1268 xgcv
.foreground
= s
->face
->foreground
;
1269 if (xgcv
.foreground
== xgcv
.background
)
1270 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
1271 if (xgcv
.foreground
== xgcv
.background
)
1272 xgcv
.foreground
= s
->face
->foreground
;
1274 /* Make sure the cursor is distinct from text in this face. */
1275 if (xgcv
.background
== s
->face
->background
1276 && xgcv
.foreground
== s
->face
->foreground
)
1278 xgcv
.background
= s
->face
->foreground
;
1279 xgcv
.foreground
= s
->face
->background
;
1282 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1283 xgcv
.font
= s
->font
;
1284 mask
= GCForeground
| GCBackground
| GCFont
;
1286 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1287 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1290 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1291 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1293 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1298 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1301 x_set_mouse_face_gc (s
)
1302 struct glyph_string
*s
;
1307 /* What face has to be used last for the mouse face? */
1308 face_id
= FRAME_W32_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1309 face
= FACE_FROM_ID (s
->f
, face_id
);
1311 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1313 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1314 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
1316 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
1317 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1318 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1320 /* If font in this face is same as S->font, use it. */
1321 if (s
->font
== s
->face
->font
)
1322 s
->gc
= s
->face
->gc
;
1325 /* Otherwise construct scratch_cursor_gc with values from FACE
1330 xgcv
.background
= s
->face
->background
;
1331 xgcv
.foreground
= s
->face
->foreground
;
1332 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1333 xgcv
.font
= s
->font
;
1334 mask
= GCForeground
| GCBackground
| GCFont
;
1336 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1337 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1340 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1341 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1343 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1346 xassert (s
->gc
!= 0);
1350 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1351 Faces to use in the mode line have already been computed when the
1352 matrix was built, so there isn't much to do, here. */
1355 x_set_mode_line_face_gc (s
)
1356 struct glyph_string
*s
;
1358 s
->gc
= s
->face
->gc
;
1362 /* Set S->gc of glyph string S for drawing that glyph string. Set
1363 S->stippled_p to a non-zero value if the face of S has a stipple
1367 x_set_glyph_string_gc (s
)
1368 struct glyph_string
*s
;
1370 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1372 if (s
->hl
== DRAW_NORMAL_TEXT
)
1374 s
->gc
= s
->face
->gc
;
1375 s
->stippled_p
= s
->face
->stipple
!= 0;
1377 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1379 x_set_mode_line_face_gc (s
);
1380 s
->stippled_p
= s
->face
->stipple
!= 0;
1382 else if (s
->hl
== DRAW_CURSOR
)
1384 x_set_cursor_gc (s
);
1387 else if (s
->hl
== DRAW_MOUSE_FACE
)
1389 x_set_mouse_face_gc (s
);
1390 s
->stippled_p
= s
->face
->stipple
!= 0;
1392 else if (s
->hl
== DRAW_IMAGE_RAISED
1393 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1395 s
->gc
= s
->face
->gc
;
1396 s
->stippled_p
= s
->face
->stipple
!= 0;
1400 s
->gc
= s
->face
->gc
;
1401 s
->stippled_p
= s
->face
->stipple
!= 0;
1404 /* GC must have been set. */
1405 xassert (s
->gc
!= 0);
1409 /* Set clipping for output of glyph string S. S may be part of a mode
1410 line or menu if we don't have X toolkit support. */
1413 x_set_glyph_string_clipping (s
)
1414 struct glyph_string
*s
;
1417 get_glyph_string_clip_rect (s
, &r
);
1418 w32_set_clip_rectangle (s
->hdc
, &r
);
1423 Compute left and right overhang of glyph string S. If S is a glyph
1424 string for a composition, assume overhangs don't exist. */
1427 w32_compute_glyph_string_overhangs (s
)
1428 struct glyph_string
*s
;
1430 /* TODO: Windows does not appear to have a method for
1431 getting this info without getting the ABC widths for each
1432 individual character and working it out manually. */
1437 w32_get_glyph_overhangs (glyph
, f
, left
, right
)
1438 struct glyph
*glyph
;
1442 HDC hdc
= get_frame_dc (f
);
1443 /* Convert to unicode! */
1444 x_get_glyph_overhangs (glyph
, f
, left
, right
);
1445 release_frame_dc (f
, hdc
);
1449 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1452 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1453 struct glyph_string
*s
;
1461 /* Take clipping into account. */
1462 if (s
->gc
->clip_mask
== Rect
)
1464 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1465 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1466 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1467 - s
->gc
->clip_rectangle
.left
);
1468 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1469 - s
->gc
->clip_rectangle
.top
);
1472 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1477 /* Draw the background of glyph_string S. If S->background_filled_p
1478 is non-zero don't draw it. FORCE_P non-zero means draw the
1479 background even if it wouldn't be drawn normally. This is used
1480 when a string preceding S draws into the background of S, or S
1481 contains the first component of a composition. */
1484 x_draw_glyph_string_background (s
, force_p
)
1485 struct glyph_string
*s
;
1488 /* Nothing to do if background has already been drawn or if it
1489 shouldn't be drawn in the first place. */
1490 if (!s
->background_filled_p
)
1492 int box_line_width
= max (s
->face
->box_line_width
, 0);
1494 #if 0 /* TODO: stipple */
1497 /* Fill background with a stipple pattern. */
1498 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1499 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1500 s
->y
+ box_line_width
,
1501 s
->background_width
,
1502 s
->height
- 2 * box_line_width
);
1503 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1504 s
->background_filled_p
= 1;
1508 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1509 || s
->font_not_found_p
1510 || s
->extends_to_end_of_line_p
1514 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1515 s
->background_width
,
1516 s
->height
- 2 * box_line_width
);
1517 s
->background_filled_p
= 1;
1523 /* Draw the foreground of glyph string S. */
1526 x_draw_glyph_string_foreground (s
)
1527 struct glyph_string
*s
;
1532 /* If first glyph of S has a left box line, start drawing the text
1533 of S to the right of that box line. */
1534 if (s
->face
->box
!= FACE_NO_BOX
1535 && s
->first_glyph
->left_box_line_p
)
1536 x
= s
->x
+ abs (s
->face
->box_line_width
);
1540 if (s
->for_overlaps_p
|| (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1541 SetBkMode (s
->hdc
, TRANSPARENT
);
1543 SetBkMode (s
->hdc
, OPAQUE
);
1545 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1546 SetBkColor (s
->hdc
, s
->gc
->background
);
1547 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1549 if (s
->font
&& s
->font
->hfont
)
1550 old_font
= SelectObject (s
->hdc
, s
->font
->hfont
);
1552 /* Draw characters of S as rectangles if S's font could not be
1554 if (s
->font_not_found_p
)
1556 for (i
= 0; i
< s
->nchars
; ++i
)
1558 struct glyph
*g
= s
->first_glyph
+ i
;
1560 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1562 x
+= g
->pixel_width
;
1567 char *char1b
= (char *) s
->char2b
;
1568 int boff
= s
->font_info
->baseline_offset
;
1570 if (s
->font_info
->vertical_centering
)
1571 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
1573 /* If we can use 8-bit functions, condense S->char2b. */
1575 for (i
= 0; i
< s
->nchars
; ++i
)
1576 char1b
[i
] = XCHAR2B_BYTE2 (&s
->char2b
[i
]);
1578 /* Draw text with TextOut and friends. */
1579 w32_text_out (s
, x
, s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1581 if (s
->face
->overstrike
)
1583 /* For overstriking (to simulate bold-face), draw the
1584 characters again shifted to the right by one pixel. */
1585 w32_text_out (s
, x
+ 1, s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1588 if (s
->font
&& s
->font
->hfont
)
1589 SelectObject (s
->hdc
, old_font
);
1592 /* Draw the foreground of composite glyph string S. */
1595 x_draw_composite_glyph_string_foreground (s
)
1596 struct glyph_string
*s
;
1601 /* If first glyph of S has a left box line, start drawing the text
1602 of S to the right of that box line. */
1603 if (s
->face
->box
!= FACE_NO_BOX
1604 && s
->first_glyph
->left_box_line_p
)
1605 x
= s
->x
+ abs (s
->face
->box_line_width
);
1609 /* S is a glyph string for a composition. S->gidx is the index of
1610 the first character drawn for glyphs of this composition.
1611 S->gidx == 0 means we are drawing the very first character of
1612 this composition. */
1614 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1615 SetBkColor (s
->hdc
, s
->gc
->background
);
1616 SetBkMode (s
->hdc
, TRANSPARENT
);
1617 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1619 if (s
->font
&& s
->font
->hfont
)
1620 old_font
= SelectObject (s
->hdc
, s
->font
->hfont
);
1622 /* Draw a rectangle for the composition if the font for the very
1623 first character of the composition could not be loaded. */
1624 if (s
->font_not_found_p
)
1627 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1632 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
1634 w32_text_out (s
, x
+ s
->cmp
->offsets
[s
->gidx
* 2],
1635 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1637 if (s
->face
->overstrike
)
1638 w32_text_out (s
, x
+ s
->cmp
->offsets
[s
->gidx
* 2] + 1,
1639 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1644 if (s
->font
&& s
->font
->hfont
)
1645 SelectObject (s
->hdc
, old_font
);
1649 /* Brightness beyond which a color won't have its highlight brightness
1652 Nominally, highlight colors for `3d' faces are calculated by
1653 brightening an object's color by a constant scale factor, but this
1654 doesn't yield good results for dark colors, so for colors who's
1655 brightness is less than this value (on a scale of 0-255) have to
1656 use an additional additive factor.
1658 The value here is set so that the default menu-bar/mode-line color
1659 (grey75) will not have its highlights changed at all. */
1660 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1663 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1664 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1665 If this produces the same color as COLOR, try a color where all RGB
1666 values have DELTA added. Return the allocated color in *COLOR.
1667 DISPLAY is the X display, CMAP is the colormap to operate on.
1668 Value is non-zero if successful. */
1671 w32_alloc_lighter_color (f
, color
, factor
, delta
)
1680 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1683 /* Change RGB values by specified FACTOR. Avoid overflow! */
1684 xassert (factor
>= 0);
1685 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1686 min (0xff, factor
* GetGValue (*color
)),
1687 min (0xff, factor
* GetBValue (*color
)));
1689 /* Calculate brightness of COLOR. */
1690 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1691 + GetBValue (*color
)) / 6;
1693 /* We only boost colors that are darker than
1694 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1695 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1696 /* Make an additive adjustment to NEW, because it's dark enough so
1697 that scaling by FACTOR alone isn't enough. */
1699 /* How far below the limit this color is (0 - 1, 1 being darker). */
1700 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1701 /* The additive adjustment. */
1702 int min_delta
= delta
* dimness
* factor
/ 2;
1705 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1706 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1707 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1709 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1710 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1711 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1715 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1716 max (0, min (0xff, delta
+ GetGValue (*color
))),
1717 max (0, min (0xff, delta
+ GetBValue (*color
))));
1719 /* TODO: Map to palette and retry with delta if same? */
1720 /* TODO: Free colors (if using palette)? */
1731 /* Set up the foreground color for drawing relief lines of glyph
1732 string S. RELIEF is a pointer to a struct relief containing the GC
1733 with which lines will be drawn. Use a color that is FACTOR or
1734 DELTA lighter or darker than the relief's background which is found
1735 in S->f->output_data.x->relief_background. If such a color cannot
1736 be allocated, use DEFAULT_PIXEL, instead. */
1739 w32_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
1741 struct relief
*relief
;
1744 COLORREF default_pixel
;
1747 struct w32_output
*di
= f
->output_data
.w32
;
1748 unsigned long mask
= GCForeground
;
1750 COLORREF background
= di
->relief_background
;
1751 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
1753 /* TODO: Free colors (if using palette)? */
1755 /* Allocate new color. */
1756 xgcv
.foreground
= default_pixel
;
1758 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1760 relief
->allocated_p
= 1;
1761 xgcv
.foreground
= relief
->pixel
= pixel
;
1764 if (relief
->gc
== 0)
1766 #if 0 /* TODO: stipple */
1767 xgcv
.stipple
= dpyinfo
->gray
;
1770 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1773 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1777 /* Set up colors for the relief lines around glyph string S. */
1780 x_setup_relief_colors (s
)
1781 struct glyph_string
*s
;
1783 struct w32_output
*di
= s
->f
->output_data
.w32
;
1786 if (s
->face
->use_box_color_for_shadows_p
)
1787 color
= s
->face
->box_color
;
1788 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1790 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1791 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1793 color
= s
->gc
->background
;
1795 if (di
->white_relief
.gc
== 0
1796 || color
!= di
->relief_background
)
1798 di
->relief_background
= color
;
1799 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1800 WHITE_PIX_DEFAULT (s
->f
));
1801 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1802 BLACK_PIX_DEFAULT (s
->f
));
1807 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1808 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1809 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1810 relief. LEFT_P non-zero means draw a relief on the left side of
1811 the rectangle. RIGHT_P non-zero means draw a relief on the right
1812 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1816 w32_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
1817 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
1819 int left_x
, top_y
, right_x
, bottom_y
, width
;
1820 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
1825 HDC hdc
= get_frame_dc (f
);
1828 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1830 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1832 w32_set_clip_rectangle (hdc
, clip_rect
);
1836 for (i
= 0; i
< width
; ++i
)
1837 w32_fill_area (f
, hdc
, gc
.foreground
,
1838 left_x
+ i
* left_p
, top_y
+ i
,
1839 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1843 for (i
= 0; i
< width
; ++i
)
1844 w32_fill_area (f
, hdc
, gc
.foreground
,
1845 left_x
+ i
, top_y
+ i
, 1,
1846 bottom_y
- top_y
- 2 * i
+ 1);
1849 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1851 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1855 for (i
= 0; i
< width
; ++i
)
1856 w32_fill_area (f
, hdc
, gc
.foreground
,
1857 left_x
+ i
* left_p
, bottom_y
- i
,
1858 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1862 for (i
= 0; i
< width
; ++i
)
1863 w32_fill_area (f
, hdc
, gc
.foreground
,
1864 right_x
- i
, top_y
+ i
+ 1, 1,
1865 bottom_y
- top_y
- 2 * i
- 1);
1867 w32_set_clip_rectangle (hdc
, NULL
);
1869 release_frame_dc (f
, hdc
);
1873 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1874 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1875 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1876 left side of the rectangle. RIGHT_P non-zero means draw a line
1877 on the right side of the rectangle. CLIP_RECT is the clipping
1878 rectangle to use when drawing. */
1881 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1882 left_p
, right_p
, clip_rect
)
1883 struct glyph_string
*s
;
1884 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
1887 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1890 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1891 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1896 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1897 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1901 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1902 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1907 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1908 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1911 w32_set_clip_rectangle (s
->hdc
, NULL
);
1915 /* Draw a box around glyph string S. */
1918 x_draw_glyph_string_box (s
)
1919 struct glyph_string
*s
;
1921 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
1922 int left_p
, right_p
;
1923 struct glyph
*last_glyph
;
1926 last_x
= window_box_right (s
->w
, s
->area
);
1927 if (s
->row
->full_width_p
1928 && !s
->w
->pseudo_window_p
)
1930 last_x
+= WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH (s
->w
);
1931 if (s
->area
!= RIGHT_MARGIN_AREA
1932 || WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (s
->w
))
1933 last_x
+= WINDOW_RIGHT_FRINGE_WIDTH (s
->w
);
1936 /* The glyph that may have a right box line. */
1937 last_glyph
= (s
->cmp
|| s
->img
1939 : s
->first_glyph
+ s
->nchars
- 1);
1941 width
= abs (s
->face
->box_line_width
);
1942 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1944 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1946 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1948 bottom_y
= top_y
+ s
->height
- 1;
1950 left_p
= (s
->first_glyph
->left_box_line_p
1951 || (s
->hl
== DRAW_MOUSE_FACE
1953 || s
->prev
->hl
!= s
->hl
)));
1954 right_p
= (last_glyph
->right_box_line_p
1955 || (s
->hl
== DRAW_MOUSE_FACE
1957 || s
->next
->hl
!= s
->hl
)));
1959 get_glyph_string_clip_rect (s
, &clip_rect
);
1961 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1962 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1963 left_p
, right_p
, &clip_rect
);
1966 x_setup_relief_colors (s
);
1967 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1968 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1973 /* Draw foreground of image glyph string S. */
1976 x_draw_image_foreground (s
)
1977 struct glyph_string
*s
;
1980 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1982 /* If first glyph of S has a left box line, start drawing it to the
1983 right of that line. */
1984 if (s
->face
->box
!= FACE_NO_BOX
1985 && s
->first_glyph
->left_box_line_p
1987 x
+= abs (s
->face
->box_line_width
);
1989 /* If there is a margin around the image, adjust x- and y-position
1991 if (s
->slice
.x
== 0)
1992 x
+= s
->img
->hmargin
;
1993 if (s
->slice
.y
== 0)
1994 y
+= s
->img
->vmargin
;
2000 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2001 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2002 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2003 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2004 SetBkColor (compat_hdc
, RGB (255, 255, 255));
2005 SetTextColor (s
->hdc
, RGB (0, 0, 0));
2006 x_set_glyph_string_clipping (s
);
2010 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
2011 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2013 SetTextColor (s
->hdc
, RGB (255, 255, 255));
2014 SetBkColor (s
->hdc
, RGB (0, 0, 0));
2016 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2017 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2018 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2019 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2020 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2021 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2023 SelectObject (mask_dc
, mask_orig_obj
);
2028 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2029 SetBkColor (s
->hdc
, s
->gc
->background
);
2031 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2032 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2034 /* When the image has a mask, we can expect that at
2035 least part of a mouse highlight or a block cursor will
2036 be visible. If the image doesn't have a mask, make
2037 a block cursor visible by drawing a rectangle around
2038 the image. I believe it's looking better if we do
2039 nothing here for mouse-face. */
2040 if (s
->hl
== DRAW_CURSOR
)
2042 int r
= s
->img
->relief
;
2044 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
2045 s
->slice
.width
+ r
*2 - 1,
2046 s
->slice
.height
+ r
*2 - 1);
2050 w32_set_clip_rectangle (s
->hdc
, NULL
);
2051 SelectObject (s
->hdc
, orig_brush
);
2052 DeleteObject (fg_brush
);
2053 SelectObject (compat_hdc
, orig_obj
);
2054 DeleteDC (compat_hdc
);
2057 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
2058 s
->slice
.width
- 1, s
->slice
.height
- 1);
2060 RestoreDC (s
->hdc
,-1);
2065 /* Draw a relief around the image glyph string S. */
2068 x_draw_image_relief (s
)
2069 struct glyph_string
*s
;
2071 int x0
, y0
, x1
, y1
, thick
, raised_p
;
2074 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2076 /* If first glyph of S has a left box line, start drawing it to the
2077 right of that line. */
2078 if (s
->face
->box
!= FACE_NO_BOX
2079 && s
->first_glyph
->left_box_line_p
2081 x
+= abs (s
->face
->box_line_width
);
2083 /* If there is a margin around the image, adjust x- and y-position
2085 if (s
->slice
.x
== 0)
2086 x
+= s
->img
->hmargin
;
2087 if (s
->slice
.y
== 0)
2088 y
+= s
->img
->vmargin
;
2090 if (s
->hl
== DRAW_IMAGE_SUNKEN
2091 || s
->hl
== DRAW_IMAGE_RAISED
)
2093 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2094 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2098 thick
= abs (s
->img
->relief
);
2099 raised_p
= s
->img
->relief
> 0;
2104 x1
= x
+ s
->slice
.width
+ thick
- 1;
2105 y1
= y
+ s
->slice
.height
+ thick
- 1;
2107 x_setup_relief_colors (s
);
2108 get_glyph_string_clip_rect (s
, &r
);
2109 w32_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2111 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2113 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2118 /* Draw the foreground of image glyph string S to PIXMAP. */
2121 w32_draw_image_foreground_1 (s
, pixmap
)
2122 struct glyph_string
*s
;
2125 HDC hdc
= CreateCompatibleDC (s
->hdc
);
2126 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
2128 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2130 /* If first glyph of S has a left box line, start drawing it to the
2131 right of that line. */
2132 if (s
->face
->box
!= FACE_NO_BOX
2133 && s
->first_glyph
->left_box_line_p
2135 x
+= abs (s
->face
->box_line_width
);
2137 /* If there is a margin around the image, adjust x- and y-position
2139 if (s
->slice
.x
== 0)
2140 x
+= s
->img
->hmargin
;
2141 if (s
->slice
.y
== 0)
2142 y
+= s
->img
->vmargin
;
2146 HDC compat_hdc
= CreateCompatibleDC (hdc
);
2147 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2148 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
2149 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2153 HDC mask_dc
= CreateCompatibleDC (hdc
);
2154 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2156 SetTextColor (hdc
, RGB (0, 0, 0));
2157 SetBkColor (hdc
, RGB (255, 255, 255));
2158 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2159 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2160 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2161 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2162 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2163 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2165 SelectObject (mask_dc
, mask_orig_obj
);
2170 SetTextColor (hdc
, s
->gc
->foreground
);
2171 SetBkColor (hdc
, s
->gc
->background
);
2173 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2174 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2176 /* When the image has a mask, we can expect that at
2177 least part of a mouse highlight or a block cursor will
2178 be visible. If the image doesn't have a mask, make
2179 a block cursor visible by drawing a rectangle around
2180 the image. I believe it's looking better if we do
2181 nothing here for mouse-face. */
2182 if (s
->hl
== DRAW_CURSOR
)
2184 int r
= s
->img
->relief
;
2186 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2187 s
->slice
.width
+ r
*2 - 1,
2188 s
->slice
.height
+ r
*2 - 1);
2192 SelectObject (hdc
, orig_brush
);
2193 DeleteObject (fg_brush
);
2194 SelectObject (compat_hdc
, orig_obj
);
2195 DeleteDC (compat_hdc
);
2198 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2199 s
->slice
.width
- 1, s
->slice
.height
- 1);
2201 SelectObject (hdc
, orig_hdc_obj
);
2206 /* Draw part of the background of glyph string S. X, Y, W, and H
2207 give the rectangle to draw. */
2210 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
2211 struct glyph_string
*s
;
2214 #if 0 /* TODO: stipple */
2217 /* Fill background with a stipple pattern. */
2218 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2219 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2220 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2224 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2228 /* Draw image glyph string S.
2231 s->x +-------------------------
2234 | +-------------------------
2237 | | +-------------------
2243 x_draw_image_glyph_string (s
)
2244 struct glyph_string
*s
;
2247 int box_line_hwidth
= abs (s
->face
->box_line_width
);
2248 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2252 height
= s
->height
- 2 * box_line_vwidth
;
2254 /* Fill background with face under the image. Do it only if row is
2255 taller than image or if image has a clip mask to reduce
2257 s
->stippled_p
= s
->face
->stipple
!= 0;
2258 if (height
> s
->slice
.height
2262 || s
->img
->pixmap
== 0
2263 || s
->width
!= s
->background_width
)
2266 if (s
->first_glyph
->left_box_line_p
2268 x
+= box_line_hwidth
;
2271 if (s
->slice
.y
== 0)
2272 y
+= box_line_vwidth
;
2274 #if 0 /* TODO: figure out if we need to do this on Windows. */
2277 /* Create a pixmap as large as the glyph string. Fill it
2278 with the background color. Copy the image to it, using
2279 its mask. Copy the temporary pixmap to the display. */
2280 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2281 int depth
= DefaultDepthOfScreen (screen
);
2283 /* Create a pixmap as large as the glyph string. */
2284 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2285 s
->background_width
,
2288 /* Don't clip in the following because we're working on the
2290 XSetClipMask (s
->display
, s
->gc
, None
);
2292 /* Fill the pixmap with the background color/stipple. */
2295 /* Fill background with a stipple pattern. */
2296 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2297 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2298 0, 0, s
->background_width
, s
->height
);
2299 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2304 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2306 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2307 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2308 0, 0, s
->background_width
, s
->height
);
2309 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2314 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2316 s
->background_filled_p
= 1;
2319 /* Draw the foreground. */
2322 w32_draw_image_foreground_1 (s
, pixmap
);
2323 x_set_glyph_string_clipping (s
);
2325 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2326 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2327 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2328 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2330 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2331 SetBkColor (s
->hdc
, s
->gc
->background
);
2332 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2333 compat_hdc
, 0, 0, SRCCOPY
);
2335 SelectObject (s
->hdc
, orig_brush
);
2336 DeleteObject (fg_brush
);
2337 SelectObject (compat_hdc
, orig_obj
);
2338 DeleteDC (compat_hdc
);
2340 DeleteObject (pixmap
);
2344 x_draw_image_foreground (s
);
2346 /* If we must draw a relief around the image, do it. */
2348 || s
->hl
== DRAW_IMAGE_RAISED
2349 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2350 x_draw_image_relief (s
);
2354 /* Draw stretch glyph string S. */
2357 x_draw_stretch_glyph_string (s
)
2358 struct glyph_string
*s
;
2360 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2361 s
->stippled_p
= s
->face
->stipple
!= 0;
2363 if (s
->hl
== DRAW_CURSOR
2364 && !x_stretch_cursor_p
)
2366 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2367 as wide as the stretch glyph. */
2368 int width
= min (FRAME_COLUMN_WIDTH (s
->f
), s
->background_width
);
2371 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
2373 /* Clear rest using the GC of the original non-cursor face. */
2374 if (width
< s
->background_width
)
2376 XGCValues
*gc
= s
->face
->gc
;
2377 int x
= s
->x
+ width
, y
= s
->y
;
2378 int w
= s
->background_width
- width
, h
= s
->height
;
2382 if (s
->row
->mouse_face_p
2383 && cursor_in_mouse_face_p (s
->w
))
2385 x_set_mouse_face_gc (s
);
2391 get_glyph_string_clip_rect (s
, &r
);
2392 w32_set_clip_rectangle (hdc
, &r
);
2394 #if 0 /* TODO: stipple */
2395 if (s
->face
->stipple
)
2397 /* Fill background with a stipple pattern. */
2398 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2399 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2400 XSetFillStyle (s
->display
, gc
, FillSolid
);
2405 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2409 else if (!s
->background_filled_p
)
2410 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
2413 s
->background_filled_p
= 1;
2417 /* Draw glyph string S. */
2420 x_draw_glyph_string (s
)
2421 struct glyph_string
*s
;
2423 int relief_drawn_p
= 0;
2425 /* If S draws into the background of its successor, draw the
2426 background of the successor first so that S can draw into it.
2427 This makes S->next use XDrawString instead of XDrawImageString. */
2428 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
2430 xassert (s
->next
->img
== NULL
);
2431 x_set_glyph_string_gc (s
->next
);
2432 x_set_glyph_string_clipping (s
->next
);
2433 x_draw_glyph_string_background (s
->next
, 1);
2436 /* Set up S->gc, set clipping and draw S. */
2437 x_set_glyph_string_gc (s
);
2439 /* Draw relief (if any) in advance for char/composition so that the
2440 glyph string can be drawn over it. */
2441 if (!s
->for_overlaps_p
2442 && s
->face
->box
!= FACE_NO_BOX
2443 && (s
->first_glyph
->type
== CHAR_GLYPH
2444 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2447 x_set_glyph_string_clipping (s
);
2448 x_draw_glyph_string_background (s
, 1);
2449 x_draw_glyph_string_box (s
);
2450 x_set_glyph_string_clipping (s
);
2454 x_set_glyph_string_clipping (s
);
2456 switch (s
->first_glyph
->type
)
2459 x_draw_image_glyph_string (s
);
2463 x_draw_stretch_glyph_string (s
);
2467 if (s
->for_overlaps_p
)
2468 s
->background_filled_p
= 1;
2470 x_draw_glyph_string_background (s
, 0);
2471 x_draw_glyph_string_foreground (s
);
2474 case COMPOSITE_GLYPH
:
2475 if (s
->for_overlaps_p
|| s
->gidx
> 0)
2476 s
->background_filled_p
= 1;
2478 x_draw_glyph_string_background (s
, 1);
2479 x_draw_composite_glyph_string_foreground (s
);
2486 if (!s
->for_overlaps_p
)
2488 /* Draw underline. */
2489 if (s
->face
->underline_p
2490 && (s
->font
->bdf
|| !s
->font
->tm
.tmUnderlined
))
2492 unsigned long h
= 1;
2493 unsigned long dy
= s
->height
- h
;
2495 /* TODO: Use font information for positioning and thickness
2496 of underline. See OUTLINETEXTMETRIC, and xterm.c. */
2497 if (s
->face
->underline_defaulted_p
)
2499 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2500 s
->y
+ dy
, s
->width
, 1);
2504 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2505 s
->y
+ dy
, s
->width
, 1);
2509 /* Draw overline. */
2510 if (s
->face
->overline_p
)
2512 unsigned long dy
= 0, h
= 1;
2514 if (s
->face
->overline_color_defaulted_p
)
2516 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2517 s
->y
+ dy
, s
->width
, h
);
2521 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2522 s
->y
+ dy
, s
->width
, h
);
2526 /* Draw strike-through. */
2527 if (s
->face
->strike_through_p
2528 && (s
->font
->bdf
|| !s
->font
->tm
.tmStruckOut
))
2530 unsigned long h
= 1;
2531 unsigned long dy
= (s
->height
- h
) / 2;
2533 if (s
->face
->strike_through_color_defaulted_p
)
2535 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2540 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2541 s
->y
+ dy
, s
->width
, h
);
2546 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2547 x_draw_glyph_string_box (s
);
2550 /* Reset clipping. */
2551 w32_set_clip_rectangle (s
->hdc
, NULL
);
2555 /* Shift display to make room for inserted glyphs. */
2558 w32_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
2560 int x
, y
, width
, height
, shift_by
;
2564 hdc
= get_frame_dc (f
);
2565 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2566 hdc
, x
, y
, SRCCOPY
);
2568 release_frame_dc (f
, hdc
);
2572 /* Delete N glyphs at the nominal cursor position. Not implemented
2584 f
= SELECTED_FRAME ();
2586 if (! FRAME_W32_P (f
))
2593 /* Clear entire frame. If updating_frame is non-null, clear that
2594 frame. Otherwise clear the selected frame. */
2604 f
= SELECTED_FRAME ();
2606 if (! FRAME_W32_P (f
))
2609 /* Clearing the frame will erase any cursor, so mark them all as no
2611 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2612 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2613 output_cursor
.x
= -1;
2615 /* We don't set the output cursor here because there will always
2616 follow an explicit cursor_to. */
2619 w32_clear_window (f
);
2621 /* We have to clear the scroll bars, too. If we have changed
2622 colors or something like that, then they should be notified. */
2623 x_scroll_bar_clear (f
);
2629 /* Make audible bell. */
2632 w32_ring_bell (void)
2636 f
= SELECTED_FRAME ();
2640 if (FRAME_W32_P (f
) && visible_bell
)
2643 HWND hwnd
= FRAME_W32_WINDOW (SELECTED_FRAME ());
2645 for (i
= 0; i
< 5; i
++)
2647 FlashWindow (hwnd
, TRUE
);
2650 FlashWindow (hwnd
, FALSE
);
2653 w32_sys_ring_bell ();
2659 /* Specify how many text lines, from the top of the window,
2660 should be affected by insert-lines and delete-lines operations.
2661 This, and those operations, are used only within an update
2662 that is bounded by calls to x_update_begin and x_update_end. */
2665 w32_set_terminal_window (n
)
2668 /* This function intentionally left blank. */
2672 /***********************************************************************
2674 ***********************************************************************/
2676 /* Perform an insert-lines or delete-lines operation, inserting N
2677 lines or deleting -N lines at vertical position VPOS. */
2680 x_ins_del_lines (vpos
, n
)
2688 f
= SELECTED_FRAME ();
2690 if (! FRAME_W32_P (f
))
2697 /* Scroll part of the display as described by RUN. */
2700 x_scroll_run (w
, run
)
2704 struct frame
*f
= XFRAME (w
->frame
);
2705 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2706 HWND hwnd
= FRAME_W32_WINDOW (f
);
2709 /* Get frame-relative bounding box of the text display area of W,
2710 without mode lines. Include in this box the left and right
2712 window_box (w
, -1, &x
, &y
, &width
, &height
);
2714 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2715 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2716 bottom_y
= y
+ height
;
2720 /* Scrolling up. Make sure we don't copy part of the mode
2721 line at the bottom. */
2722 if (from_y
+ run
->height
> bottom_y
)
2723 height
= bottom_y
- from_y
;
2725 height
= run
->height
;
2726 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2730 /* Scolling down. Make sure we don't copy over the mode line.
2732 if (to_y
+ run
->height
> bottom_y
)
2733 height
= bottom_y
- to_y
;
2735 height
= run
->height
;
2736 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2741 /* Cursor off. Will be switched on again in x_update_window_end. */
2748 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2749 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2751 from
.left
= to
.left
= x
;
2752 from
.right
= to
.right
= x
+ width
;
2754 from
.bottom
= from_y
+ height
;
2756 to
.bottom
= bottom_y
;
2758 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2759 NULL
, SW_INVALIDATE
);
2761 /* Combine this with what we expect to be dirty. This covers the
2762 case where not all of the region we expect is actually dirty. */
2763 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2765 /* If the dirty region is not what we expected, redraw the entire frame. */
2766 if (!EqualRgn (combined
, expect_dirty
))
2767 SET_FRAME_GARBAGED (f
);
2775 /***********************************************************************
2777 ***********************************************************************/
2783 x_update_cursor (f
, 1);
2787 frame_unhighlight (f
)
2790 x_update_cursor (f
, 1);
2793 /* The focus has changed. Update the frames as necessary to reflect
2794 the new situation. Note that we can't change the selected frame
2795 here, because the Lisp code we are interrupting might become confused.
2796 Each event gets marked with the frame in which it occurred, so the
2797 Lisp code can tell when the switch took place by examining the events. */
2800 x_new_focus_frame (dpyinfo
, frame
)
2801 struct w32_display_info
*dpyinfo
;
2802 struct frame
*frame
;
2804 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2806 if (frame
!= dpyinfo
->w32_focus_frame
)
2808 /* Set this before calling other routines, so that they see
2809 the correct value of w32_focus_frame. */
2810 dpyinfo
->w32_focus_frame
= frame
;
2812 if (old_focus
&& old_focus
->auto_lower
)
2813 x_lower_frame (old_focus
);
2823 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2824 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2826 pending_autoraise_frame
= 0;
2829 x_frame_rehighlight (dpyinfo
);
2832 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2835 x_mouse_leave (dpyinfo
)
2836 struct w32_display_info
*dpyinfo
;
2838 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2841 /* The focus has changed, or we have redirected a frame's focus to
2842 another frame (this happens when a frame uses a surrogate
2843 mini-buffer frame). Shift the highlight as appropriate.
2845 The FRAME argument doesn't necessarily have anything to do with which
2846 frame is being highlighted or un-highlighted; we only use it to find
2847 the appropriate X display info. */
2850 w32_frame_rehighlight (frame
)
2851 struct frame
*frame
;
2853 if (! FRAME_W32_P (frame
))
2855 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
2859 x_frame_rehighlight (dpyinfo
)
2860 struct w32_display_info
*dpyinfo
;
2862 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2864 if (dpyinfo
->w32_focus_frame
)
2866 dpyinfo
->x_highlight_frame
2867 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2868 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2869 : dpyinfo
->w32_focus_frame
);
2870 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
2872 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
2873 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
2877 dpyinfo
->x_highlight_frame
= 0;
2879 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
2882 frame_unhighlight (old_highlight
);
2883 if (dpyinfo
->x_highlight_frame
)
2884 frame_highlight (dpyinfo
->x_highlight_frame
);
2888 /* Keyboard processing - modifier keys, etc. */
2890 /* Convert a keysym to its name. */
2893 x_get_keysym_name (keysym
)
2896 /* Make static so we can always return it */
2897 static char value
[100];
2900 GetKeyNameText (keysym
, value
, 100);
2908 /* Mouse clicks and mouse movement. Rah. */
2910 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2911 the state in PUP. XBUTTON provides extra information for extended mouse
2912 button messages. Returns FALSE if unable to parse the message. */
2914 parse_button (message
, xbutton
, pbutton
, pup
)
2925 case WM_LBUTTONDOWN
:
2933 case WM_MBUTTONDOWN
:
2934 if (NILP (Vw32_swap_mouse_buttons
))
2941 if (NILP (Vw32_swap_mouse_buttons
))
2947 case WM_RBUTTONDOWN
:
2948 if (NILP (Vw32_swap_mouse_buttons
))
2955 if (NILP (Vw32_swap_mouse_buttons
))
2961 case WM_XBUTTONDOWN
:
2962 button
= xbutton
+ 2;
2966 button
= xbutton
+ 2;
2974 if (pbutton
) *pbutton
= button
;
2980 /* Prepare a mouse-event in *RESULT for placement in the input queue.
2982 If the event is a button press, then note that we have grabbed
2986 construct_mouse_click (result
, msg
, f
)
2987 struct input_event
*result
;
2994 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
2997 /* Make the event type NO_EVENT; we'll change that when we decide
2999 result
->kind
= MOUSE_CLICK_EVENT
;
3000 result
->code
= button
;
3001 result
->timestamp
= msg
->msg
.time
;
3002 result
->modifiers
= (msg
->dwModifiers
3007 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
3008 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
3009 XSETFRAME (result
->frame_or_window
, f
);
3015 construct_mouse_wheel (result
, msg
, f
)
3016 struct input_event
*result
;
3023 result
->kind
= WHEEL_EVENT
;
3025 result
->timestamp
= msg
->msg
.time
;
3027 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3028 forward, away from the user (up); a negative value indicates that
3029 the wheel was rotated backward, toward the user (down). */
3030 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3032 /* The up and down modifiers indicate if the wheel was rotated up or
3033 down based on WHEEL_DELTA value. */
3034 result
->modifiers
= (msg
->dwModifiers
3035 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3037 p
.x
= LOWORD (msg
->msg
.lParam
);
3038 p
.y
= HIWORD (msg
->msg
.lParam
);
3039 ScreenToClient (msg
->msg
.hwnd
, &p
);
3040 XSETINT (result
->x
, p
.x
);
3041 XSETINT (result
->y
, p
.y
);
3042 XSETFRAME (result
->frame_or_window
, f
);
3048 construct_drag_n_drop (result
, msg
, f
)
3049 struct input_event
*result
;
3061 result
->kind
= DRAG_N_DROP_EVENT
;
3063 result
->timestamp
= msg
->msg
.time
;
3064 result
->modifiers
= msg
->dwModifiers
;
3066 hdrop
= (HDROP
) msg
->msg
.wParam
;
3067 DragQueryPoint (hdrop
, &p
);
3070 p
.x
= LOWORD (msg
->msg
.lParam
);
3071 p
.y
= HIWORD (msg
->msg
.lParam
);
3072 ScreenToClient (msg
->msg
.hwnd
, &p
);
3075 XSETINT (result
->x
, p
.x
);
3076 XSETINT (result
->y
, p
.y
);
3078 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3081 for (i
= 0; i
< num_files
; i
++)
3083 len
= DragQueryFile (hdrop
, i
, NULL
, 0);
3086 name
= alloca (len
+ 1);
3087 DragQueryFile (hdrop
, i
, name
, len
+ 1);
3088 files
= Fcons (DECODE_FILE (build_string (name
)), files
);
3093 XSETFRAME (frame
, f
);
3094 result
->frame_or_window
= Fcons (frame
, files
);
3100 /* Function to report a mouse movement to the mainstream Emacs code.
3101 The input handler calls this.
3103 We have received a mouse movement event, which is given in *event.
3104 If the mouse is over a different glyph than it was last time, tell
3105 the mainstream emacs code by setting mouse_moved. If not, ask for
3106 another motion event, so we can check again the next time it moves. */
3108 static MSG last_mouse_motion_event
;
3109 static Lisp_Object last_mouse_motion_frame
;
3111 static void remember_mouse_glyph
P_ ((struct frame
*, int, int));
3114 note_mouse_movement (frame
, msg
)
3118 int mouse_x
= LOWORD (msg
->lParam
);
3119 int mouse_y
= HIWORD (msg
->lParam
);
3121 last_mouse_movement_time
= msg
->time
;
3122 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
3123 XSETFRAME (last_mouse_motion_frame
, frame
);
3125 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3127 frame
->mouse_moved
= 1;
3128 last_mouse_scroll_bar
= Qnil
;
3129 note_mouse_highlight (frame
, -1, -1);
3132 /* Has the mouse moved off the glyph it was on at the last sighting? */
3133 else if (mouse_x
< last_mouse_glyph
.left
3134 || mouse_x
> last_mouse_glyph
.right
3135 || mouse_y
< last_mouse_glyph
.top
3136 || mouse_y
> last_mouse_glyph
.bottom
)
3138 frame
->mouse_moved
= 1;
3139 last_mouse_scroll_bar
= Qnil
;
3140 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3141 /* Remember the mouse position here, as w32_mouse_position only
3142 gets called when mouse tracking is enabled but we also need
3143 to keep track of the mouse for help_echo and highlighting at
3145 remember_mouse_glyph (frame
, mouse_x
, mouse_y
);
3150 /************************************************************************
3152 ************************************************************************/
3154 static struct scroll_bar
*x_window_to_scroll_bar ();
3155 static void x_scroll_bar_report_motion ();
3156 static void x_check_fullscreen
P_ ((struct frame
*));
3157 static int glyph_rect
P_ ((struct frame
*f
, int, int, RECT
*));
3161 redo_mouse_highlight ()
3163 if (!NILP (last_mouse_motion_frame
)
3164 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3165 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3166 LOWORD (last_mouse_motion_event
.lParam
),
3167 HIWORD (last_mouse_motion_event
.lParam
));
3171 w32_define_cursor (window
, cursor
)
3175 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3178 /* Try to determine frame pixel position and size of the glyph under
3179 frame pixel coordinates X/Y on frame F . Return the position and
3180 size in *RECT. Value is non-zero if we could compute these
3184 glyph_rect (f
, x
, y
, rect
)
3191 window
= window_from_coordinates (f
, x
, y
, 0, &x
, &y
, 0);
3195 struct window
*w
= XWINDOW (window
);
3196 struct glyph_row
*r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
3197 struct glyph_row
*end
= r
+ w
->current_matrix
->nrows
- 1;
3199 for (; r
< end
&& r
->enabled_p
; ++r
)
3200 if (r
->y
<= y
&& r
->y
+ r
->height
> y
)
3202 /* Found the row at y. */
3203 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
3204 struct glyph
*end
= g
+ r
->used
[TEXT_AREA
];
3207 rect
->top
= WINDOW_TO_FRAME_PIXEL_Y (w
, r
->y
);
3208 rect
->bottom
= rect
->top
+ r
->height
;
3212 /* x is to the left of the first glyph in the row. */
3213 /* Shouldn't this be a pixel value?
3214 WINDOW_LEFT_EDGE_X (w) seems to be the right value.
3216 rect
->left
= WINDOW_LEFT_EDGE_COL (w
);
3217 rect
->right
= WINDOW_TO_FRAME_PIXEL_X (w
, r
->x
);
3221 for (gx
= r
->x
; g
< end
; gx
+= g
->pixel_width
, ++g
)
3222 if (gx
<= x
&& gx
+ g
->pixel_width
> x
)
3224 /* x is on a glyph. */
3225 rect
->left
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
3226 rect
->right
= rect
->left
+ g
->pixel_width
;
3230 /* x is to the right of the last glyph in the row. */
3231 rect
->left
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
3232 /* Shouldn't this be a pixel value?
3233 WINDOW_RIGHT_EDGE_X (w) seems to be the right value.
3235 rect
->right
= WINDOW_RIGHT_EDGE_COL (w
);
3240 /* The y is not on any row. */
3244 /* Record the position of the mouse in last_mouse_glyph. */
3246 remember_mouse_glyph (f1
, gx
, gy
)
3250 if (!glyph_rect (f1
, gx
, gy
, &last_mouse_glyph
))
3252 int width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
3253 int height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
3255 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
3256 round down even for negative values. */
3262 /* This was the original code from XTmouse_position, but it seems
3263 to give the position of the glyph diagonally next to the one
3264 the mouse is over. */
3265 gx
= (gx
+ width
- 1) / width
* width
;
3266 gy
= (gy
+ height
- 1) / height
* height
;
3268 gx
= gx
/ width
* width
;
3269 gy
= gy
/ height
* height
;
3272 last_mouse_glyph
.left
= gx
;
3273 last_mouse_glyph
.top
= gy
;
3274 last_mouse_glyph
.right
= gx
+ width
;
3275 last_mouse_glyph
.bottom
= gy
+ height
;
3279 /* Return the current position of the mouse.
3280 *fp should be a frame which indicates which display to ask about.
3282 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3283 and *part to the frame, window, and scroll bar part that the mouse
3284 is over. Set *x and *y to the portion and whole of the mouse's
3285 position on the scroll bar.
3287 If the mouse movement started elsewhere, set *fp to the frame the
3288 mouse is on, *bar_window to nil, and *x and *y to the character cell
3291 Set *time to the server time-stamp for the time at which the mouse
3292 was at this position.
3294 Don't store anything if we don't have a valid set of values to report.
3296 This clears the mouse_moved flag, so we can wait for the next mouse
3300 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3303 Lisp_Object
*bar_window
;
3304 enum scroll_bar_part
*part
;
3306 unsigned long *time
;
3312 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3313 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3318 Lisp_Object frame
, tail
;
3320 /* Clear the mouse-moved flag for every frame on this display. */
3321 FOR_EACH_FRAME (tail
, frame
)
3322 XFRAME (frame
)->mouse_moved
= 0;
3324 last_mouse_scroll_bar
= Qnil
;
3328 /* Now we have a position on the root; find the innermost window
3329 containing the pointer. */
3331 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3332 && FRAME_LIVE_P (last_mouse_frame
))
3334 /* If mouse was grabbed on a frame, give coords for that frame
3335 even if the mouse is now outside it. */
3336 f1
= last_mouse_frame
;
3340 /* Is window under mouse one of our frames? */
3341 f1
= x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
3342 WindowFromPoint (pt
));
3345 /* If not, is it one of our scroll bars? */
3348 struct scroll_bar
*bar
3349 = x_window_to_scroll_bar (WindowFromPoint (pt
));
3353 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3357 if (f1
== 0 && insist
> 0)
3358 f1
= SELECTED_FRAME ();
3362 /* Ok, we found a frame. Store all the values.
3363 last_mouse_glyph is a rectangle used to reduce the
3364 generation of mouse events. To not miss any motion
3365 events, we must divide the frame into rectangles of the
3366 size of the smallest character that could be displayed
3367 on it, i.e. into the same rectangles that matrices on
3368 the frame are divided into. */
3370 #if OLD_REDISPLAY_CODE
3371 int ignore1
, ignore2
;
3373 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3375 pixel_to_glyph_coords (f1
, pt
.x
, pt
.y
, &ignore1
, &ignore2
,
3377 FRAME_W32_DISPLAY_INFO (f1
)->grabbed
3380 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3381 remember_mouse_glyph (f1
, pt
.x
, pt
.y
);
3389 *time
= last_mouse_movement_time
;
3398 /***********************************************************************
3400 ***********************************************************************/
3402 /* Handle mouse button event on the tool-bar of frame F, at
3403 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
3407 w32_handle_tool_bar_click (f
, button_event
)
3409 struct input_event
*button_event
;
3411 int x
= XFASTINT (button_event
->x
);
3412 int y
= XFASTINT (button_event
->y
);
3414 if (button_event
->modifiers
& down_modifier
)
3415 handle_tool_bar_click (f
, x
, y
, 1, 0);
3417 handle_tool_bar_click (f
, x
, y
, 0,
3418 button_event
->modifiers
& ~up_modifier
);
3423 /***********************************************************************
3425 ***********************************************************************/
3427 /* Scroll bar support. */
3429 /* Given a window ID, find the struct scroll_bar which manages it.
3430 This can be called in GC, so we have to make sure to strip off mark
3433 static struct scroll_bar
*
3434 x_window_to_scroll_bar (window_id
)
3439 for (tail
= Vframe_list
;
3440 XGCTYPE (tail
) == Lisp_Cons
;
3443 Lisp_Object frame
, bar
, condemned
;
3445 frame
= XCAR (tail
);
3446 /* All elements of Vframe_list should be frames. */
3447 if (! GC_FRAMEP (frame
))
3450 /* Scan this frame's scroll bar list for a scroll bar with the
3452 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3453 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3454 /* This trick allows us to search both the ordinary and
3455 condemned scroll bar lists with one loop. */
3456 ! GC_NILP (bar
) || (bar
= condemned
,
3459 bar
= XSCROLL_BAR (bar
)->next
)
3460 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
3461 return XSCROLL_BAR (bar
);
3469 /* Set the thumb size and position of scroll bar BAR. We are currently
3470 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3473 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
)
3474 struct scroll_bar
*bar
;
3475 int portion
, position
, whole
;
3477 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3478 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
3479 int sb_page
, sb_pos
;
3480 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
3484 /* Position scroll bar at rock bottom if the bottom of the
3485 buffer is visible. This avoids shinking the thumb away
3486 to nothing if it is held at the bottom of the buffer. */
3487 if (position
+ portion
>= whole
)
3489 sb_page
= range
* (whole
- position
) / whole
3490 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3494 sb_page
= portion
* range
/ whole
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3495 sb_pos
= position
* range
/ whole
;
3505 if (pfnSetScrollInfo
)
3509 si
.cbSize
= sizeof (si
);
3510 /* Only update page size if currently dragging, to reduce
3513 si
.fMask
= SIF_PAGE
;
3515 si
.fMask
= SIF_PAGE
| SIF_POS
;
3519 pfnSetScrollInfo (w
, SB_CTL
, &si
, !draggingp
);
3522 SetScrollPos (w
, SB_CTL
, sb_pos
, !draggingp
);
3528 /************************************************************************
3529 Scroll bars, general
3530 ************************************************************************/
3533 my_create_scrollbar (f
, bar
)
3535 struct scroll_bar
* bar
;
3537 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3538 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
3542 /*#define ATTACH_THREADS*/
3545 my_show_window (FRAME_PTR f
, HWND hwnd
, int how
)
3547 #ifndef ATTACH_THREADS
3548 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3549 (WPARAM
) hwnd
, (LPARAM
) how
);
3551 return ShowWindow (hwnd
, how
);
3556 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3557 int x
, int y
, int cx
, int cy
, UINT flags
)
3559 #ifndef ATTACH_THREADS
3561 pos
.hwndInsertAfter
= hwndAfter
;
3567 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
3569 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3574 my_set_focus (f
, hwnd
)
3578 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3583 my_set_foreground_window (hwnd
)
3586 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
3590 my_destroy_window (f
, hwnd
)
3594 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3598 /* Create a scroll bar and return the scroll bar vector for it. W is
3599 the Emacs window on which to create the scroll bar. TOP, LEFT,
3600 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
3603 static struct scroll_bar
*
3604 x_scroll_bar_create (w
, top
, left
, width
, height
)
3606 int top
, left
, width
, height
;
3608 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3610 struct scroll_bar
*bar
3611 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
3615 XSETWINDOW (bar
->window
, w
);
3616 XSETINT (bar
->top
, top
);
3617 XSETINT (bar
->left
, left
);
3618 XSETINT (bar
->width
, width
);
3619 XSETINT (bar
->height
, height
);
3620 XSETINT (bar
->start
, 0);
3621 XSETINT (bar
->end
, 0);
3622 bar
->dragging
= Qnil
;
3624 /* Requires geometry to be set before call to create the real window */
3626 hwnd
= my_create_scrollbar (f
, bar
);
3628 if (pfnSetScrollInfo
)
3632 si
.cbSize
= sizeof (si
);
3635 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3636 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3640 pfnSetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3644 SetScrollRange (hwnd
, SB_CTL
, 0,
3645 VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
), FALSE
);
3646 SetScrollPos (hwnd
, SB_CTL
, 0, FALSE
);
3649 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3651 /* Add bar to its frame's list of scroll bars. */
3652 bar
->next
= FRAME_SCROLL_BARS (f
);
3654 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
3655 if (! NILP (bar
->next
))
3656 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3664 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3668 x_scroll_bar_remove (bar
)
3669 struct scroll_bar
*bar
;
3671 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3675 /* Destroy the window. */
3676 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3678 /* Disassociate this scroll bar from its window. */
3679 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
3684 /* Set the handle of the vertical scroll bar for WINDOW to indicate
3685 that we are displaying PORTION characters out of a total of WHOLE
3686 characters, starting at POSITION. If WINDOW has no scroll bar,
3689 w32_set_vertical_scroll_bar (w
, portion
, whole
, position
)
3691 int portion
, whole
, position
;
3693 struct frame
*f
= XFRAME (w
->frame
);
3694 struct scroll_bar
*bar
;
3695 int top
, height
, left
, sb_left
, width
, sb_width
;
3696 int window_y
, window_height
;
3698 /* Get window dimensions. */
3699 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
3701 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
3702 height
= window_height
;
3704 /* Compute the left edge of the scroll bar area. */
3705 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3707 /* Compute the width of the scroll bar which might be less than
3708 the width of the area reserved for the scroll bar. */
3709 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
3710 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
3714 /* Compute the left edge of the scroll bar. */
3715 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
3716 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
3718 sb_left
= left
+ (width
- sb_width
) / 2;
3720 /* Does the scroll bar exist yet? */
3721 if (NILP (w
->vertical_scroll_bar
))
3725 if (width
> 0 && height
> 0)
3727 hdc
= get_frame_dc (f
);
3728 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3729 release_frame_dc (f
, hdc
);
3733 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
3737 /* It may just need to be moved and resized. */
3740 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3741 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3743 /* If already correctly positioned, do nothing. */
3744 if ( XINT (bar
->left
) == sb_left
3745 && XINT (bar
->top
) == top
3746 && XINT (bar
->width
) == sb_width
3747 && XINT (bar
->height
) == height
)
3749 /* Redraw after clear_frame. */
3750 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3751 InvalidateRect (hwnd
, NULL
, FALSE
);
3757 if (width
&& height
)
3759 hdc
= get_frame_dc (f
);
3760 /* Since Windows scroll bars are smaller than the space reserved
3761 for them on the frame, we have to clear "under" them. */
3762 w32_clear_area (f
, hdc
,
3767 release_frame_dc (f
, hdc
);
3769 /* Make sure scroll bar is "visible" before moving, to ensure the
3770 area of the parent window now exposed will be refreshed. */
3771 my_show_window (f
, hwnd
, SW_HIDE
);
3772 MoveWindow (hwnd
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
3773 top
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
3774 max (height
, 1), TRUE
);
3775 if (pfnSetScrollInfo
)
3779 si
.cbSize
= sizeof (si
);
3780 si
.fMask
= SIF_RANGE
;
3782 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3783 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3785 pfnSetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3788 SetScrollRange (hwnd
, SB_CTL
, 0,
3789 VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
), FALSE
);
3790 my_show_window (f
, hwnd
, SW_NORMAL
);
3791 /* InvalidateRect (w, NULL, FALSE); */
3793 /* Remember new settings. */
3794 XSETINT (bar
->left
, sb_left
);
3795 XSETINT (bar
->top
, top
);
3796 XSETINT (bar
->width
, sb_width
);
3797 XSETINT (bar
->height
, height
);
3802 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3804 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
3808 /* The following three hooks are used when we're doing a thorough
3809 redisplay of the frame. We don't explicitly know which scroll bars
3810 are going to be deleted, because keeping track of when windows go
3811 away is a real pain - "Can you say set-window-configuration, boys
3812 and girls?" Instead, we just assert at the beginning of redisplay
3813 that *all* scroll bars are to be removed, and then save a scroll bar
3814 from the fiery pit when we actually redisplay its window. */
3816 /* Arrange for all scroll bars on FRAME to be removed at the next call
3817 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
3818 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
3821 w32_condemn_scroll_bars (frame
)
3824 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
3825 while (! NILP (FRAME_SCROLL_BARS (frame
)))
3828 bar
= FRAME_SCROLL_BARS (frame
);
3829 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
3830 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
3831 XSCROLL_BAR (bar
)->prev
= Qnil
;
3832 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
3833 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
3834 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
3839 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
3840 Note that WINDOW isn't necessarily condemned at all. */
3843 w32_redeem_scroll_bar (window
)
3844 struct window
*window
;
3846 struct scroll_bar
*bar
;
3849 /* We can't redeem this window's scroll bar if it doesn't have one. */
3850 if (NILP (window
->vertical_scroll_bar
))
3853 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
3855 /* Unlink it from the condemned list. */
3856 f
= XFRAME (WINDOW_FRAME (window
));
3857 if (NILP (bar
->prev
))
3859 /* If the prev pointer is nil, it must be the first in one of
3861 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
3862 /* It's not condemned. Everything's fine. */
3864 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
3865 window
->vertical_scroll_bar
))
3866 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
3868 /* If its prev pointer is nil, it must be at the front of
3869 one or the other! */
3873 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
3875 if (! NILP (bar
->next
))
3876 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
3878 bar
->next
= FRAME_SCROLL_BARS (f
);
3880 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
3881 if (! NILP (bar
->next
))
3882 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3885 /* Remove all scroll bars on FRAME that haven't been saved since the
3886 last call to `*condemn_scroll_bars_hook'. */
3889 w32_judge_scroll_bars (f
)
3892 Lisp_Object bar
, next
;
3894 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
3896 /* Clear out the condemned list now so we won't try to process any
3897 more events on the hapless scroll bars. */
3898 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
3900 for (; ! NILP (bar
); bar
= next
)
3902 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
3904 x_scroll_bar_remove (b
);
3907 b
->next
= b
->prev
= Qnil
;
3910 /* Now there should be no references to the condemned scroll bars,
3911 and they should get garbage-collected. */
3914 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
3915 is set to something other than NO_EVENT, it is enqueued.
3917 This may be called from a signal handler, so we have to ignore GC
3921 w32_scroll_bar_handle_click (bar
, msg
, emacs_event
)
3922 struct scroll_bar
*bar
;
3924 struct input_event
*emacs_event
;
3926 if (! GC_WINDOWP (bar
->window
))
3929 emacs_event
->kind
= W32_SCROLL_BAR_CLICK_EVENT
;
3930 emacs_event
->code
= 0;
3931 /* not really meaningful to distinguish up/down */
3932 emacs_event
->modifiers
= msg
->dwModifiers
;
3933 emacs_event
->frame_or_window
= bar
->window
;
3934 emacs_event
->arg
= Qnil
;
3935 emacs_event
->timestamp
= msg
->msg
.time
;
3938 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
3940 int dragging
= !NILP (bar
->dragging
);
3942 if (pfnGetScrollInfo
)
3946 si
.cbSize
= sizeof (si
);
3949 pfnGetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
3953 y
= GetScrollPos ((HWND
) msg
->msg
.lParam
, SB_CTL
);
3955 bar
->dragging
= Qnil
;
3958 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
3960 switch (LOWORD (msg
->msg
.wParam
))
3963 emacs_event
->part
= scroll_bar_down_arrow
;
3966 emacs_event
->part
= scroll_bar_up_arrow
;
3969 emacs_event
->part
= scroll_bar_above_handle
;
3972 emacs_event
->part
= scroll_bar_below_handle
;
3975 emacs_event
->part
= scroll_bar_handle
;
3979 emacs_event
->part
= scroll_bar_handle
;
3983 case SB_THUMBPOSITION
:
3984 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
3985 y
= HIWORD (msg
->msg
.wParam
);
3987 emacs_event
->part
= scroll_bar_handle
;
3989 /* "Silently" update current position. */
3990 if (pfnSetScrollInfo
)
3994 si
.cbSize
= sizeof (si
);
3997 /* Remember apparent position (we actually lag behind the real
3998 position, so don't set that directly. */
3999 last_scroll_bar_drag_pos
= y
;
4001 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
4004 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, FALSE
);
4007 /* If this is the end of a drag sequence, then reset the scroll
4008 handle size to normal and do a final redraw. Otherwise do
4012 if (pfnSetScrollInfo
)
4015 int start
= XINT (bar
->start
);
4016 int end
= XINT (bar
->end
);
4018 si
.cbSize
= sizeof (si
);
4019 si
.fMask
= SIF_PAGE
| SIF_POS
;
4020 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4021 si
.nPos
= last_scroll_bar_drag_pos
;
4022 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4025 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, TRUE
);
4029 emacs_event
->kind
= NO_EVENT
;
4033 XSETINT (emacs_event
->x
, y
);
4034 XSETINT (emacs_event
->y
, top_range
);
4040 /* Return information to the user about the current position of the mouse
4041 on the scroll bar. */
4044 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
4046 Lisp_Object
*bar_window
;
4047 enum scroll_bar_part
*part
;
4049 unsigned long *time
;
4051 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
4052 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4053 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4055 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4060 *bar_window
= bar
->window
;
4062 if (pfnGetScrollInfo
)
4066 si
.cbSize
= sizeof (si
);
4067 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4069 pfnGetScrollInfo (w
, SB_CTL
, &si
);
4071 top_range
= si
.nMax
- si
.nPage
+ 1;
4074 pos
= GetScrollPos (w
, SB_CTL
);
4076 switch (LOWORD (last_mouse_scroll_bar_pos
))
4078 case SB_THUMBPOSITION
:
4080 *part
= scroll_bar_handle
;
4081 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
4082 pos
= HIWORD (last_mouse_scroll_bar_pos
);
4085 *part
= scroll_bar_handle
;
4089 *part
= scroll_bar_handle
;
4094 XSETINT (*y
, top_range
);
4097 last_mouse_scroll_bar
= Qnil
;
4099 *time
= last_mouse_movement_time
;
4105 /* The screen has been cleared so we may have changed foreground or
4106 background colors, and the scroll bars may need to be redrawn.
4107 Clear out the scroll bars, and ask for expose events, so we can
4111 x_scroll_bar_clear (f
)
4116 /* We can have scroll bars even if this is 0,
4117 if we just turned off scroll bar mode.
4118 But in that case we should not clear them. */
4119 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4120 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4121 bar
= XSCROLL_BAR (bar
)->next
)
4123 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4124 HDC hdc
= GetDC (window
);
4127 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4128 arranges to refresh the scroll bar if hidden. */
4129 my_show_window (f
, window
, SW_HIDE
);
4131 GetClientRect (window
, &rect
);
4132 select_palette (f
, hdc
);
4133 w32_clear_rect (f
, hdc
, &rect
);
4134 deselect_palette (f
, hdc
);
4136 ReleaseDC (window
, hdc
);
4141 /* The main W32 event-reading loop - w32_read_socket. */
4143 /* Record the last 100 characters stored
4144 to help debug the loss-of-chars-during-GC problem. */
4146 static int temp_index
;
4147 static short temp_buffer
[100];
4150 /* Read events coming from the W32 shell.
4151 This routine is called by the SIGIO handler.
4152 We return as soon as there are no more events to be read.
4154 We return the number of characters stored into the buffer,
4155 thus pretending to be `read'.
4157 EXPECTED is nonzero if the caller knows input is available.
4159 Some of these messages are reposted back to the message queue since the
4160 system calls the windows proc directly in a context where we cannot return
4161 the data nor can we guarantee the state we are in. So if we dispatch them
4162 we will get into an infinite loop. To prevent this from ever happening we
4163 will set a variable to indicate we are in the read_socket call and indicate
4164 which message we are processing since the windows proc gets called
4165 recursively with different messages by the system.
4169 w32_read_socket (sd
, expected
, hold_quit
)
4172 struct input_event
*hold_quit
;
4175 int check_visibility
= 0;
4178 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4180 if (interrupt_input_blocked
)
4182 interrupt_input_pending
= 1;
4186 interrupt_input_pending
= 0;
4189 /* So people can tell when we have read the available input. */
4190 input_signal_count
++;
4192 /* TODO: ghostscript integration. */
4193 while (get_next_msg (&msg
, FALSE
))
4195 struct input_event inev
;
4199 inev
.kind
= NO_EVENT
;
4202 switch (msg
.msg
.message
)
4205 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4209 if (msg
.rect
.right
== msg
.rect
.left
||
4210 msg
.rect
.bottom
== msg
.rect
.top
)
4212 /* We may get paint messages even though the client
4213 area is clipped - these are not expose events. */
4214 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4217 else if (f
->async_visible
!= 1)
4219 /* Definitely not obscured, so mark as visible. */
4220 f
->async_visible
= 1;
4221 f
->async_iconified
= 0;
4222 SET_FRAME_GARBAGED (f
);
4223 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4226 /* WM_PAINT serves as MapNotify as well, so report
4227 visibility changes properly. */
4230 inev
.kind
= DEICONIFY_EVENT
;
4231 XSETFRAME (inev
.frame_or_window
, f
);
4233 else if (! NILP (Vframe_list
)
4234 && ! NILP (XCDR (Vframe_list
)))
4235 /* Force a redisplay sooner or later to update the
4236 frame titles in case this is the second frame. */
4237 record_asynch_buffer_change ();
4241 HDC hdc
= get_frame_dc (f
);
4243 /* Erase background again for safety. */
4244 w32_clear_rect (f
, hdc
, &msg
.rect
);
4245 release_frame_dc (f
, hdc
);
4249 msg
.rect
.right
- msg
.rect
.left
,
4250 msg
.rect
.bottom
- msg
.rect
.top
);
4255 case WM_INPUTLANGCHANGE
:
4256 /* Generate a language change event. */
4257 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4261 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4262 XSETFRAME (inev
.frame_or_window
, f
);
4263 inev
.code
= msg
.msg
.wParam
;
4264 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4270 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4272 if (f
&& !f
->iconified
)
4274 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
4276 clear_mouse_face (dpyinfo
);
4277 dpyinfo
->mouse_face_hidden
= 1;
4280 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4282 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4283 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4284 inev
.code
= msg
.msg
.wParam
;
4285 inev
.modifiers
= msg
.dwModifiers
;
4286 XSETFRAME (inev
.frame_or_window
, f
);
4287 inev
.timestamp
= msg
.msg
.time
;
4293 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4295 if (f
&& !f
->iconified
)
4297 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
4299 clear_mouse_face (dpyinfo
);
4300 dpyinfo
->mouse_face_hidden
= 1;
4303 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4305 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4306 inev
.kind
= ASCII_KEYSTROKE_EVENT
;
4307 inev
.code
= msg
.msg
.wParam
;
4308 inev
.modifiers
= msg
.dwModifiers
;
4309 XSETFRAME (inev
.frame_or_window
, f
);
4310 inev
.timestamp
= msg
.msg
.time
;
4315 /* Ignore non-movement. */
4317 int x
= LOWORD (msg
.msg
.lParam
);
4318 int y
= HIWORD (msg
.msg
.lParam
);
4319 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4321 last_mousemove_x
= x
;
4322 last_mousemove_y
= y
;
4325 previous_help_echo_string
= help_echo_string
;
4327 if (dpyinfo
->grabbed
&& last_mouse_frame
4328 && FRAME_LIVE_P (last_mouse_frame
))
4329 f
= last_mouse_frame
;
4331 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4333 if (dpyinfo
->mouse_face_hidden
)
4335 dpyinfo
->mouse_face_hidden
= 0;
4336 clear_mouse_face (dpyinfo
);
4341 /* Generate SELECT_WINDOW_EVENTs when needed. */
4342 if (mouse_autoselect_window
)
4345 int x
= LOWORD (msg
.msg
.lParam
);
4346 int y
= HIWORD (msg
.msg
.lParam
);
4348 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 0);
4350 /* Window will be selected only when it is not
4351 selected now and last mouse movement event was
4352 not in it. Minibuffer window will be selected
4353 iff it is active. */
4355 && !EQ (window
, last_window
)
4356 && !EQ (window
, selected_window
))
4358 inev
.kind
= SELECT_WINDOW_EVENT
;
4359 inev
.frame_or_window
= window
;
4364 note_mouse_movement (f
, &msg
.msg
);
4368 /* If we move outside the frame, then we're
4369 certainly no longer on any text in the frame. */
4370 clear_mouse_face (dpyinfo
);
4373 /* If the contents of the global variable help_echo_string
4374 has changed, generate a HELP_EVENT. */
4375 #if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE.
4376 But it was originally changed to this to fix a bug, so I have
4377 not removed it completely in case the bug is still there. */
4378 if (help_echo_string
!= previous_help_echo_string
||
4379 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4380 #else /* This is what xterm.c does. */
4381 if (!NILP (help_echo_string
)
4382 || !NILP (previous_help_echo_string
))
4387 case WM_LBUTTONDOWN
:
4389 case WM_MBUTTONDOWN
:
4391 case WM_RBUTTONDOWN
:
4393 case WM_XBUTTONDOWN
:
4396 /* If we decide we want to generate an event to be seen
4397 by the rest of Emacs, we put it here. */
4402 if (dpyinfo
->grabbed
&& last_mouse_frame
4403 && FRAME_LIVE_P (last_mouse_frame
))
4404 f
= last_mouse_frame
;
4406 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4410 construct_mouse_click (&inev
, &msg
, f
);
4412 /* Is this in the tool-bar? */
4413 if (WINDOWP (f
->tool_bar_window
)
4414 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4417 int x
= XFASTINT (inev
.x
);
4418 int y
= XFASTINT (inev
.y
);
4420 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
4422 if (EQ (window
, f
->tool_bar_window
))
4424 w32_handle_tool_bar_click (f
, &inev
);
4430 || (dpyinfo
->w32_focus_frame
4431 && f
!= dpyinfo
->w32_focus_frame
))
4432 inev
.kind
= NO_EVENT
;
4435 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4440 dpyinfo
->grabbed
&= ~ (1 << button
);
4444 dpyinfo
->grabbed
|= (1 << button
);
4445 last_mouse_frame
= f
;
4446 /* Ignore any mouse motion that happened
4447 before this event; any subsequent mouse-movement
4448 Emacs events should reflect only motion after
4454 last_tool_bar_item
= -1;
4461 if (dpyinfo
->grabbed
&& last_mouse_frame
4462 && FRAME_LIVE_P (last_mouse_frame
))
4463 f
= last_mouse_frame
;
4465 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4470 if (!dpyinfo
->w32_focus_frame
4471 || f
== dpyinfo
->w32_focus_frame
)
4473 /* Emit an Emacs wheel-up/down event. */
4474 construct_mouse_wheel (&inev
, &msg
, f
);
4476 /* Ignore any mouse motion that happened before this
4477 event; any subsequent mouse-movement Emacs events
4478 should reflect only motion after the
4482 last_mouse_frame
= f
;
4483 last_tool_bar_item
= -1;
4488 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4491 construct_drag_n_drop (&inev
, &msg
, f
);
4496 struct scroll_bar
*bar
=
4497 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
4500 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
4504 case WM_WINDOWPOSCHANGED
:
4505 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4508 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
4509 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
4511 check_visibility
= 1;
4515 case WM_ACTIVATEAPP
:
4516 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4518 x_check_fullscreen (f
);
4519 check_visibility
= 1;
4523 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4525 if (f
&& !f
->async_iconified
)
4529 x_real_positions (f
, &x
, &y
);
4534 check_visibility
= 1;
4538 /* wParam non-zero means Window is about to be shown, 0 means
4539 about to be hidden. */
4540 /* Redo the mouse-highlight after the tooltip has gone. */
4541 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
4544 redo_mouse_highlight ();
4547 /* If window has been obscured or exposed by another window
4548 being maximised or minimised/restored, then recheck
4549 visibility of all frames. Direct changes to our own
4550 windows get handled by WM_SIZE. */
4552 if (msg
.msg
.lParam
!= 0)
4553 check_visibility
= 1;
4556 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4557 f
->async_visible
= msg
.msg
.wParam
;
4561 check_visibility
= 1;
4565 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4567 /* Inform lisp of whether frame has been iconified etc. */
4570 switch (msg
.msg
.wParam
)
4572 case SIZE_MINIMIZED
:
4573 f
->async_visible
= 0;
4574 f
->async_iconified
= 1;
4576 inev
.kind
= ICONIFY_EVENT
;
4577 XSETFRAME (inev
.frame_or_window
, f
);
4580 case SIZE_MAXIMIZED
:
4582 f
->async_visible
= 1;
4583 f
->async_iconified
= 0;
4585 /* wait_reading_process_output will notice this and update
4586 the frame's display structures. */
4587 SET_FRAME_GARBAGED (f
);
4593 /* Reset top and left positions of the Window
4594 here since Windows sends a WM_MOVE message
4595 BEFORE telling us the Window is minimized
4596 when the Window is iconified, with 3000,3000
4598 x_real_positions (f
, &x
, &y
);
4602 inev
.kind
= DEICONIFY_EVENT
;
4603 XSETFRAME (inev
.frame_or_window
, f
);
4605 else if (! NILP (Vframe_list
)
4606 && ! NILP (XCDR (Vframe_list
)))
4607 /* Force a redisplay sooner or later
4608 to update the frame titles
4609 in case this is the second frame. */
4610 record_asynch_buffer_change ();
4615 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
4623 GetClientRect (msg
.msg
.hwnd
, &rect
);
4625 height
= rect
.bottom
- rect
.top
;
4626 width
= rect
.right
- rect
.left
;
4628 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
4629 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
4631 /* TODO: Clip size to the screen dimensions. */
4633 /* Even if the number of character rows and columns has
4634 not changed, the font size may have changed, so we need
4635 to check the pixel dimensions as well. */
4637 if (columns
!= FRAME_COLS (f
)
4638 || rows
!= FRAME_LINES (f
)
4639 || width
!= FRAME_PIXEL_WIDTH (f
)
4640 || height
!= FRAME_PIXEL_HEIGHT (f
))
4642 change_frame_size (f
, rows
, columns
, 0, 1, 0);
4643 SET_FRAME_GARBAGED (f
);
4644 cancel_mouse_face (f
);
4645 FRAME_PIXEL_WIDTH (f
) = width
;
4646 FRAME_PIXEL_HEIGHT (f
) = height
;
4647 f
->win_gravity
= NorthWestGravity
;
4651 check_visibility
= 1;
4655 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4658 if (f
== dpyinfo
->mouse_face_mouse_frame
)
4660 /* If we move outside the frame, then we're
4661 certainly no longer on any text in the frame. */
4662 clear_mouse_face (dpyinfo
);
4663 dpyinfo
->mouse_face_mouse_frame
= 0;
4666 /* Generate a nil HELP_EVENT to cancel a help-echo.
4667 Do it only if there's something to cancel.
4668 Otherwise, the startup message is cleared when
4669 the mouse leaves the frame. */
4670 if (any_help_event_p
)
4676 /* TODO: Port this change:
4677 2002-06-28 Jan D. <jan.h.d@swipnet.se>
4678 * xterm.h (struct x_output): Add focus_state.
4679 * xterm.c (x_focus_changed): New function.
4680 (x_detect_focus_change): New function.
4681 (XTread_socket): Call x_detect_focus_change for FocusIn/FocusOut
4682 EnterNotify and LeaveNotify to track X focus changes.
4684 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4686 dpyinfo
->w32_focus_event_frame
= f
;
4689 x_new_focus_frame (dpyinfo
, f
);
4692 dpyinfo
->grabbed
= 0;
4693 check_visibility
= 1;
4697 /* TODO: some of this belongs in MOUSE_LEAVE */
4698 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4702 if (f
== dpyinfo
->w32_focus_event_frame
)
4703 dpyinfo
->w32_focus_event_frame
= 0;
4705 if (f
== dpyinfo
->w32_focus_frame
)
4706 x_new_focus_frame (dpyinfo
, 0);
4708 if (f
== dpyinfo
->mouse_face_mouse_frame
)
4710 /* If we move outside the frame, then we're
4711 certainly no longer on any text in the frame. */
4712 clear_mouse_face (dpyinfo
);
4713 dpyinfo
->mouse_face_mouse_frame
= 0;
4716 /* Generate a nil HELP_EVENT to cancel a help-echo.
4717 Do it only if there's something to cancel.
4718 Otherwise, the startup message is cleared when
4719 the mouse leaves the frame. */
4720 if (any_help_event_p
)
4724 dpyinfo
->grabbed
= 0;
4725 check_visibility
= 1;
4729 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4733 inev
.kind
= DELETE_WINDOW_EVENT
;
4734 XSETFRAME (inev
.frame_or_window
, f
);
4739 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4743 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
4744 XSETFRAME (inev
.frame_or_window
, f
);
4749 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4753 extern void menubar_selection_callback
4754 (FRAME_PTR f
, void * client_data
);
4755 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
4758 check_visibility
= 1;
4761 case WM_DISPLAYCHANGE
:
4762 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4766 dpyinfo
->width
= (short) LOWORD (msg
.msg
.lParam
);
4767 dpyinfo
->height
= (short) HIWORD (msg
.msg
.lParam
);
4768 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
4769 DebPrint (("display change: %d %d\n", dpyinfo
->width
,
4773 check_visibility
= 1;
4777 /* Check for messages registered at runtime. */
4778 if (msg
.msg
.message
== msh_mousewheel
)
4780 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
4781 msg
.msg
.message
= WM_MOUSEWHEEL
;
4787 if (inev
.kind
!= NO_EVENT
)
4789 kbd_buffer_store_event_hold (&inev
, hold_quit
);
4794 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
4799 XSETFRAME (frame
, f
);
4805 if (NILP (help_echo_string
))
4807 help_echo_object
= help_echo_window
= Qnil
;
4811 any_help_event_p
= 1;
4812 gen_help_event (help_echo_string
, frame
, help_echo_window
,
4813 help_echo_object
, help_echo_pos
);
4817 help_echo_string
= Qnil
;
4818 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
4824 /* If the focus was just given to an autoraising frame,
4826 /* ??? This ought to be able to handle more than one such frame. */
4827 if (pending_autoraise_frame
)
4829 x_raise_frame (pending_autoraise_frame
);
4830 pending_autoraise_frame
= 0;
4833 /* Check which frames are still visisble, if we have enqueued any user
4834 events or been notified of events that may affect visibility. We
4835 do this here because there doesn't seem to be any direct
4836 notification from Windows that the visibility of a window has
4837 changed (at least, not in all cases). */
4838 if (count
> 0 || check_visibility
)
4840 Lisp_Object tail
, frame
;
4842 FOR_EACH_FRAME (tail
, frame
)
4844 FRAME_PTR f
= XFRAME (frame
);
4845 /* The tooltip has been drawn already. Avoid the
4846 SET_FRAME_GARBAGED below. */
4847 if (EQ (frame
, tip_frame
))
4850 /* Check "visible" frames and mark each as obscured or not.
4851 Note that async_visible is nonzero for unobscured and
4852 obscured frames, but zero for hidden and iconified frames. */
4853 if (FRAME_W32_P (f
) && f
->async_visible
)
4859 /* Query clipping rectangle for the entire window area
4860 (GetWindowDC), not just the client portion (GetDC).
4861 Otherwise, the scrollbars and menubar aren't counted as
4862 part of the visible area of the frame, and we may think
4863 the frame is obscured when really a scrollbar is still
4864 visible and gets WM_PAINT messages above. */
4865 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
4866 GetClipBox (hdc
, &clipbox
);
4867 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
4870 if (clipbox
.right
== clipbox
.left
4871 || clipbox
.bottom
== clipbox
.top
)
4873 /* Frame has become completely obscured so mark as
4874 such (we do this by setting async_visible to 2 so
4875 that FRAME_VISIBLE_P is still true, but redisplay
4877 f
->async_visible
= 2;
4879 if (!FRAME_OBSCURED_P (f
))
4881 DebPrint (("frame %p (%s) obscured\n", f
,
4887 /* Frame is not obscured, so mark it as such. */
4888 f
->async_visible
= 1;
4890 if (FRAME_OBSCURED_P (f
))
4892 SET_FRAME_GARBAGED (f
);
4893 DebPrint (("obscured frame %p (%s) found to be visible\n", f
,
4896 /* Force a redisplay sooner or later. */
4897 record_asynch_buffer_change ();
4911 /***********************************************************************
4913 ***********************************************************************/
4915 /* Set clipping for output in glyph row ROW. W is the window in which
4916 we operate. GC is the graphics context to set clipping in.
4918 ROW may be a text row or, e.g., a mode line. Text rows must be
4919 clipped to the interior of the window dedicated to text display,
4920 mode lines must be clipped to the whole window. */
4923 w32_clip_to_row (w
, row
, hdc
)
4925 struct glyph_row
*row
;
4928 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4930 int window_y
, window_width
;
4932 window_box (w
, -1, 0, &window_y
, &window_width
, 0);
4934 clip_rect
.left
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
4935 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4936 clip_rect
.top
= max (clip_rect
.top
, window_y
);
4937 clip_rect
.right
= clip_rect
.left
+ window_width
;
4938 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
4940 w32_set_clip_rectangle (hdc
, &clip_rect
);
4944 /* Draw a hollow box cursor on window W in glyph row ROW. */
4947 x_draw_hollow_cursor (w
, row
)
4949 struct glyph_row
*row
;
4951 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4955 struct glyph
*cursor_glyph
;
4956 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
4958 /* Get the glyph the cursor is on. If we can't tell because
4959 the current matrix is invalid or such, give up. */
4960 cursor_glyph
= get_phys_cursor_glyph (w
);
4961 if (cursor_glyph
== NULL
)
4964 /* Compute frame-relative coordinates from window-relative
4966 rect
.left
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
4967 rect
.top
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
4968 + row
->ascent
- w
->phys_cursor_ascent
);
4970 /* Compute the proper height and ascent of the rectangle, based
4971 on the actual glyph. Using the full height of the row looks
4972 bad when there are tall images on that row. */
4973 h
= max (min (FRAME_LINE_HEIGHT (f
), row
->height
),
4974 cursor_glyph
->ascent
+ cursor_glyph
->descent
);
4975 if (h
< row
->height
)
4976 rect
.top
+= row
->ascent
/* - w->phys_cursor_ascent */ + cursor_glyph
->descent
- h
;
4979 rect
.bottom
= rect
.top
+ h
;
4981 /* Compute the width of the rectangle to draw. If on a stretch
4982 glyph, and `x-stretch-block-cursor' is nil, don't draw a
4983 rectangle as wide as the glyph, but use a canonical character
4985 wd
= cursor_glyph
->pixel_width
; /* TODO: Why off by one compared with X? */
4986 if (cursor_glyph
->type
== STRETCH_GLYPH
4987 && !x_stretch_cursor_p
)
4988 wd
= min (FRAME_COLUMN_WIDTH (f
), wd
);
4989 w
->phys_cursor_width
= wd
;
4991 rect
.right
= rect
.left
+ wd
;
4992 hdc
= get_frame_dc (f
);
4993 /* Set clipping, draw the rectangle, and reset clipping again. */
4994 w32_clip_to_row (w
, row
, hdc
);
4995 FrameRect (hdc
, &rect
, hb
);
4997 w32_set_clip_rectangle (hdc
, NULL
);
4998 release_frame_dc (f
, hdc
);
5002 /* Draw a bar cursor on window W in glyph row ROW.
5004 Implementation note: One would like to draw a bar cursor with an
5005 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5006 Unfortunately, I didn't find a font yet that has this property set.
5010 x_draw_bar_cursor (w
, row
, width
, kind
)
5012 struct glyph_row
*row
;
5014 enum text_cursor_kinds kind
;
5016 struct frame
*f
= XFRAME (w
->frame
);
5017 struct glyph
*cursor_glyph
;
5021 /* If cursor is out of bounds, don't draw garbage. This can happen
5022 in mini-buffer windows when switching between echo area glyphs
5024 cursor_glyph
= get_phys_cursor_glyph (w
);
5025 if (cursor_glyph
== NULL
)
5028 /* If on an image, draw like a normal cursor. That's usually better
5029 visible than drawing a bar, esp. if the image is large so that
5030 the bar might not be in the window. */
5031 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5033 struct glyph_row
*row
;
5034 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5035 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5039 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5040 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5042 /* If the glyph's background equals the color we normally draw
5043 the bar cursor in, the bar cursor in its normal color is
5044 invisible. Use the glyph's foreground color instead in this
5045 case, on the assumption that the glyph's colors are chosen so
5046 that the glyph is legible. */
5047 if (face
->background
== cursor_color
)
5048 cursor_color
= face
->foreground
;
5050 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5053 width
= FRAME_CURSOR_WIDTH (f
);
5054 width
= min (cursor_glyph
->pixel_width
, width
);
5056 w
->phys_cursor_width
= width
;
5059 hdc
= get_frame_dc (f
);
5060 w32_clip_to_row (w
, row
, hdc
);
5062 if (kind
== BAR_CURSOR
)
5064 w32_fill_area (f
, hdc
, cursor_color
, x
,
5065 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5066 width
, row
->height
);
5070 w32_fill_area (f
, hdc
, cursor_color
, x
,
5071 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5072 row
->height
- width
),
5073 cursor_glyph
->pixel_width
, width
);
5076 w32_set_clip_rectangle (hdc
, NULL
);
5077 release_frame_dc (f
, hdc
);
5082 /* RIF: Define cursor CURSOR on frame F. */
5085 w32_define_frame_cursor (f
, cursor
)
5089 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5093 /* RIF: Clear area on frame F. */
5096 w32_clear_frame_area (f
, x
, y
, width
, height
)
5098 int x
, y
, width
, height
;
5102 hdc
= get_frame_dc (f
);
5103 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5104 release_frame_dc (f
, hdc
);
5107 /* RIF: Draw or clear cursor on window W. */
5110 w32_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
5112 struct glyph_row
*glyph_row
;
5114 int cursor_type
, cursor_width
;
5119 /* If the user wants to use the system caret, make sure our own
5120 cursor remains invisible. */
5121 if (w32_use_visible_system_caret
)
5123 /* Call to erase_phys_cursor here seems to use the
5124 wrong values of w->phys_cursor, as they have been
5125 overwritten before this function was called. */
5126 if (w
->phys_cursor_type
!= NO_CURSOR
)
5127 erase_phys_cursor (w
);
5129 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5130 w
->phys_cursor_width
= -1;
5134 w
->phys_cursor_type
= cursor_type
;
5137 w
->phys_cursor_on_p
= 1;
5139 /* If this is the active cursor, we need to track it with the
5140 system caret, so third party software like screen magnifiers
5141 and speech synthesizers can follow the cursor. */
5144 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5145 HWND hwnd
= FRAME_W32_WINDOW (f
);
5148 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5150 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5151 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5153 /* If the size of the active cursor changed, destroy the old
5155 if (w32_system_caret_hwnd
5156 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5157 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5159 w32_system_caret_height
= w
->phys_cursor_height
;
5161 /* Move the system caret. */
5162 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5165 if (glyph_row
->exact_window_width_line_p
5166 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
5168 glyph_row
->cursor_in_fringe_p
= 1;
5169 draw_fringe_bitmap (w
, glyph_row
, 0);
5173 switch (cursor_type
)
5175 case HOLLOW_BOX_CURSOR
:
5176 x_draw_hollow_cursor (w
, glyph_row
);
5179 case FILLED_BOX_CURSOR
:
5180 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5184 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5188 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5192 w
->phys_cursor_width
= 0;
5206 x_bitmap_icon (f
, icon
)
5212 if (FRAME_W32_WINDOW (f
) == 0)
5216 hicon
= LoadIcon (hinst
, EMACS_CLASS
);
5217 else if (STRINGP (icon
))
5218 hicon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5219 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5220 else if (SYMBOLP (icon
))
5224 if (EQ (icon
, intern ("application")))
5225 name
= (LPCTSTR
) IDI_APPLICATION
;
5226 else if (EQ (icon
, intern ("hand")))
5227 name
= (LPCTSTR
) IDI_HAND
;
5228 else if (EQ (icon
, intern ("question")))
5229 name
= (LPCTSTR
) IDI_QUESTION
;
5230 else if (EQ (icon
, intern ("exclamation")))
5231 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5232 else if (EQ (icon
, intern ("asterisk")))
5233 name
= (LPCTSTR
) IDI_ASTERISK
;
5234 else if (EQ (icon
, intern ("winlogo")))
5235 name
= (LPCTSTR
) IDI_WINLOGO
;
5239 hicon
= LoadIcon (NULL
, name
);
5247 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5254 /************************************************************************
5256 ************************************************************************/
5258 /* Display Error Handling functions not used on W32. Listing them here
5259 helps diff stay in step when comparing w32term.c with xterm.c.
5261 x_error_catcher (display, error)
5262 x_catch_errors (dpy)
5263 x_catch_errors_unwind (old_val)
5264 x_check_errors (dpy, format)
5265 x_had_errors_p (dpy)
5266 x_clear_errors (dpy)
5267 x_uncatch_errors (dpy, count)
5269 x_connection_signal (signalnum)
5270 x_connection_closed (dpy, error_message)
5271 x_error_quitter (display, error)
5272 x_error_handler (display, error)
5273 x_io_error_quitter (display)
5278 /* Changing the font of the frame. */
5280 /* Give frame F the font named FONTNAME as its default font, and
5281 return the full name of that font. FONTNAME may be a wildcard
5282 pattern; in that case, we choose some font that fits the pattern.
5283 The return value shows which font we chose. */
5286 x_new_font (f
, fontname
)
5288 register char *fontname
;
5290 struct font_info
*fontp
5291 = FS_LOAD_FONT (f
, 0, fontname
, -1);
5296 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
5297 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
5298 FRAME_FONTSET (f
) = -1;
5300 FRAME_COLUMN_WIDTH (f
) = FONT_WIDTH (FRAME_FONT (f
));
5301 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
5303 compute_fringe_widths (f
, 1);
5305 /* Compute the scroll bar width in character columns. */
5306 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5308 int wid
= FRAME_COLUMN_WIDTH (f
);
5309 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5310 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
5314 int wid
= FRAME_COLUMN_WIDTH (f
);
5315 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5318 /* Now make the frame display the given font. */
5319 if (FRAME_W32_WINDOW (f
) != 0)
5321 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5322 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5325 return build_string (fontp
->full_name
);
5328 /* Give frame F the fontset named FONTSETNAME as its default font, and
5329 return the full name of that fontset. FONTSETNAME may be a wildcard
5330 pattern; in that case, we choose some fontset that fits the pattern.
5331 The return value shows which fontset we chose. */
5334 x_new_fontset (f
, fontsetname
)
5338 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
5344 if (FRAME_FONTSET (f
) == fontset
)
5345 /* This fontset is already set in frame F. There's nothing more
5347 return fontset_name (fontset
);
5349 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
5351 if (!STRINGP (result
))
5352 /* Can't load ASCII font. */
5355 /* Since x_new_font doesn't update any fontset information, do it now. */
5356 FRAME_FONTSET(f
) = fontset
;
5358 return build_string (fontsetname
);
5362 /***********************************************************************
5363 TODO: W32 Input Methods
5364 ***********************************************************************/
5365 /* Listing missing functions from xterm.c helps diff stay in step.
5367 xim_destroy_callback (xim, client_data, call_data)
5368 xim_open_dpy (dpyinfo, resource_name)
5370 xim_instantiate_callback (display, client_data, call_data)
5371 xim_initialize (dpyinfo, resource_name)
5372 xim_close_dpy (dpyinfo)
5377 /* Calculate the absolute position in frame F
5378 from its current recorded position values and gravity. */
5381 x_calc_absolute_position (f
)
5385 int flags
= f
->size_hint_flags
;
5389 /* Find the position of the outside upper-left corner of
5390 the inner window, with respect to the outer window.
5391 But do this only if we will need the results. */
5392 if (f
->output_data
.w32
->parent_desc
!= FRAME_W32_DISPLAY_INFO (f
)->root_window
)
5395 MapWindowPoints (FRAME_W32_WINDOW (f
),
5396 f
->output_data
.w32
->parent_desc
,
5403 rt
.left
= rt
.right
= rt
.top
= rt
.bottom
= 0;
5406 AdjustWindowRect(&rt
, f
->output_data
.w32
->dwStyle
,
5407 FRAME_EXTERNAL_MENU_BAR (f
));
5410 pt
.x
+= (rt
.right
- rt
.left
);
5411 pt
.y
+= (rt
.bottom
- rt
.top
);
5414 /* Treat negative positions as relative to the leftmost bottommost
5415 position that fits on the screen. */
5416 if (flags
& XNegative
)
5417 f
->left_pos
= (FRAME_W32_DISPLAY_INFO (f
)->width
5418 - 2 * f
->border_width
- pt
.x
5419 - FRAME_PIXEL_WIDTH (f
)
5422 if (flags
& YNegative
)
5423 f
->top_pos
= (FRAME_W32_DISPLAY_INFO (f
)->height
5424 - 2 * f
->border_width
- pt
.y
5425 - FRAME_PIXEL_HEIGHT (f
)
5427 /* The left_pos and top_pos
5428 are now relative to the top and left screen edges,
5429 so the flags should correspond. */
5430 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5433 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5434 to really change the position, and 0 when calling from
5435 x_make_frame_visible (in that case, XOFF and YOFF are the current
5436 position values). It is -1 when calling from x_set_frame_parameters,
5437 which means, do adjust for borders but don't change the gravity. */
5440 x_set_offset (f
, xoff
, yoff
, change_gravity
)
5442 register int xoff
, yoff
;
5445 int modified_top
, modified_left
;
5447 if (change_gravity
> 0)
5451 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5453 f
->size_hint_flags
|= XNegative
;
5455 f
->size_hint_flags
|= YNegative
;
5456 f
->win_gravity
= NorthWestGravity
;
5458 x_calc_absolute_position (f
);
5461 x_wm_set_size_hint (f
, (long) 0, 0);
5463 modified_left
= f
->left_pos
;
5464 modified_top
= f
->top_pos
;
5466 my_set_window_pos (FRAME_W32_WINDOW (f
),
5468 modified_left
, modified_top
,
5470 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5475 /* Check if we need to resize the frame due to a fullscreen request.
5476 If so needed, resize the frame. */
5478 x_check_fullscreen (f
)
5481 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
5483 int width
, height
, ign
;
5485 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5487 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
5489 /* We do not need to move the window, it shall be taken care of
5490 when setting WM manager hints. */
5491 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
5493 change_frame_size (f
, height
, width
, 0, 1, 0);
5494 SET_FRAME_GARBAGED (f
);
5495 cancel_mouse_face (f
);
5497 /* Wait for the change of frame size to occur */
5498 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
5503 /* Call this to change the size of frame F's x-window.
5504 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5505 for this size change and subsequent size changes.
5506 Otherwise we leave the window gravity unchanged. */
5509 x_set_window_size (f
, change_gravity
, cols
, rows
)
5514 int pixelwidth
, pixelheight
;
5518 check_frame_size (f
, &rows
, &cols
);
5519 f
->scroll_bar_actual_width
5520 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
5522 compute_fringe_widths (f
, 0);
5524 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
5525 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
5527 f
->win_gravity
= NorthWestGravity
;
5528 x_wm_set_size_hint (f
, (long) 0, 0);
5533 rect
.left
= rect
.top
= 0;
5534 rect
.right
= pixelwidth
;
5535 rect
.bottom
= pixelheight
;
5537 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
5538 FRAME_EXTERNAL_MENU_BAR (f
));
5540 my_set_window_pos (FRAME_W32_WINDOW (f
),
5543 rect
.right
- rect
.left
,
5544 rect
.bottom
- rect
.top
,
5545 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5548 /* Now, strictly speaking, we can't be sure that this is accurate,
5549 but the window manager will get around to dealing with the size
5550 change request eventually, and we'll hear how it went when the
5551 ConfigureNotify event gets here.
5553 We could just not bother storing any of this information here,
5554 and let the ConfigureNotify event set everything up, but that
5555 might be kind of confusing to the Lisp code, since size changes
5556 wouldn't be reported in the frame parameters until some random
5557 point in the future when the ConfigureNotify event arrives.
5559 We pass 1 for DELAY since we can't run Lisp code inside of
5561 change_frame_size (f
, rows
, cols
, 0, 1, 0);
5562 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
5563 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
5565 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5566 receive in the ConfigureNotify event; if we get what we asked
5567 for, then the event won't cause the screen to become garbaged, so
5568 we have to make sure to do it here. */
5569 SET_FRAME_GARBAGED (f
);
5571 /* If cursor was outside the new size, mark it as off. */
5572 mark_window_cursors_off (XWINDOW (f
->root_window
));
5574 /* Clear out any recollection of where the mouse highlighting was,
5575 since it might be in a place that's outside the new frame size.
5576 Actually checking whether it is outside is a pain in the neck,
5577 so don't try--just let the highlighting be done afresh with new size. */
5578 cancel_mouse_face (f
);
5583 /* Mouse warping. */
5585 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
5588 x_set_mouse_position (f
, x
, y
)
5594 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
5595 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
5597 if (pix_x
< 0) pix_x
= 0;
5598 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
5600 if (pix_y
< 0) pix_y
= 0;
5601 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
5603 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
5607 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
5616 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
5617 pt
.x
= rect
.left
+ pix_x
;
5618 pt
.y
= rect
.top
+ pix_y
;
5619 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
5621 SetCursorPos (pt
.x
, pt
.y
);
5627 /* focus shifting, raising and lowering. */
5630 x_focus_on_frame (f
)
5633 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
5635 /* Give input focus to frame. */
5638 /* Try not to change its Z-order if possible. */
5639 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
5640 my_set_focus (f
, FRAME_W32_WINDOW (f
));
5643 my_set_foreground_window (FRAME_W32_WINDOW (f
));
5653 /* Raise frame F. */
5660 /* Strictly speaking, raise-frame should only change the frame's Z
5661 order, leaving input focus unchanged. This is reasonable behaviour
5662 on X where the usual policy is point-to-focus. However, this
5663 behaviour would be very odd on Windows where the usual policy is
5666 On X, if the mouse happens to be over the raised frame, it gets
5667 input focus anyway (so the window with focus will never be
5668 completely obscured) - if not, then just moving the mouse over it
5669 is sufficient to give it focus. On Windows, the user must actually
5670 click on the frame (preferrably the title bar so as not to move
5671 point), which is more awkward. Also, no other Windows program
5672 raises a window to the top but leaves another window (possibly now
5673 completely obscured) with input focus.
5675 Because there is a system setting on Windows that allows the user
5676 to choose the point to focus policy, we make the strict semantics
5677 optional, but by default we grab focus when raising. */
5679 if (NILP (Vw32_grab_focus_on_raise
))
5681 /* The obvious call to my_set_window_pos doesn't work if Emacs is
5682 not already the foreground application: the frame is raised
5683 above all other frames belonging to us, but not above the
5684 current top window. To achieve that, we have to resort to this
5685 more cumbersome method. */
5687 HDWP handle
= BeginDeferWindowPos (2);
5690 DeferWindowPos (handle
,
5691 FRAME_W32_WINDOW (f
),
5694 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5696 DeferWindowPos (handle
,
5697 GetForegroundWindow (),
5698 FRAME_W32_WINDOW (f
),
5700 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5702 EndDeferWindowPos (handle
);
5707 my_set_foreground_window (FRAME_W32_WINDOW (f
));
5713 /* Lower frame F. */
5719 my_set_window_pos (FRAME_W32_WINDOW (f
),
5722 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5727 w32_frame_raise_lower (f
, raise_flag
)
5731 if (! FRAME_W32_P (f
))
5740 /* Change of visibility. */
5742 /* This tries to wait until the frame is really visible.
5743 However, if the window manager asks the user where to position
5744 the frame, this will return before the user finishes doing that.
5745 The frame will not actually be visible at that time,
5746 but it will become visible later when the window manager
5747 finishes with it. */
5750 x_make_frame_visible (f
)
5757 type
= x_icon_type (f
);
5759 x_bitmap_icon (f
, type
);
5761 if (! FRAME_VISIBLE_P (f
))
5763 /* We test FRAME_GARBAGED_P here to make sure we don't
5764 call x_set_offset a second time
5765 if we get to x_make_frame_visible a second time
5766 before the window gets really visible. */
5767 if (! FRAME_ICONIFIED_P (f
)
5768 && ! f
->output_data
.w32
->asked_for_visible
)
5769 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
5771 f
->output_data
.w32
->asked_for_visible
= 1;
5773 /* my_show_window (f, FRAME_W32_WINDOW (f), f->async_iconified ? SW_RESTORE : SW_SHOW); */
5774 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_SHOWNORMAL
);
5777 /* Synchronize to ensure Emacs knows the frame is visible
5778 before we do anything else. We do this loop with input not blocked
5779 so that incoming events are handled. */
5784 /* This must come after we set COUNT. */
5787 XSETFRAME (frame
, f
);
5789 /* Wait until the frame is visible. Process X events until a
5790 MapNotify event has been seen, or until we think we won't get a
5791 MapNotify at all.. */
5792 for (count
= input_signal_count
+ 10;
5793 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
5795 /* Force processing of queued events. */
5796 /* TODO: x_sync equivalent? */
5798 /* Machines that do polling rather than SIGIO have been observed
5799 to go into a busy-wait here. So we'll fake an alarm signal
5800 to let the handler know that there's something to be read.
5801 We used to raise a real alarm, but it seems that the handler
5802 isn't always enabled here. This is probably a bug. */
5803 if (input_polling_used ())
5805 /* It could be confusing if a real alarm arrives while processing
5806 the fake one. Turn it off and let the handler reset it. */
5807 int old_poll_suppress_count
= poll_suppress_count
;
5808 poll_suppress_count
= 1;
5809 poll_for_input_1 ();
5810 poll_suppress_count
= old_poll_suppress_count
;
5813 FRAME_SAMPLE_VISIBILITY (f
);
5817 /* Change from mapped state to withdrawn state. */
5819 /* Make the frame visible (mapped and not iconified). */
5821 x_make_frame_invisible (f
)
5824 /* Don't keep the highlight on an invisible frame. */
5825 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5826 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5830 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
5832 /* We can't distinguish this from iconification
5833 just by the event that we get from the server.
5834 So we can't win using the usual strategy of letting
5835 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5836 and synchronize with the server to make sure we agree. */
5838 FRAME_ICONIFIED_P (f
) = 0;
5839 f
->async_visible
= 0;
5840 f
->async_iconified
= 0;
5845 /* Change window state from mapped to iconified. */
5853 /* Don't keep the highlight on an invisible frame. */
5854 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5855 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5857 if (f
->async_iconified
)
5862 type
= x_icon_type (f
);
5864 x_bitmap_icon (f
, type
);
5866 /* Simulate the user minimizing the frame. */
5867 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
5873 /* Free X resources of frame F. */
5876 x_free_frame_resources (f
)
5879 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5883 if (FRAME_W32_WINDOW (f
))
5884 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
5886 free_frame_menubar (f
);
5888 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
5889 unload_color (f
, f
->output_data
.x
->background_pixel
);
5890 unload_color (f
, f
->output_data
.w32
->cursor_pixel
);
5891 unload_color (f
, f
->output_data
.w32
->cursor_foreground_pixel
);
5892 unload_color (f
, f
->output_data
.w32
->border_pixel
);
5893 unload_color (f
, f
->output_data
.w32
->mouse_pixel
);
5894 if (f
->output_data
.w32
->white_relief
.allocated_p
)
5895 unload_color (f
, f
->output_data
.w32
->white_relief
.pixel
);
5896 if (f
->output_data
.w32
->black_relief
.allocated_p
)
5897 unload_color (f
, f
->output_data
.w32
->black_relief
.pixel
);
5899 if (FRAME_FACE_CACHE (f
))
5900 free_frame_faces (f
);
5902 xfree (f
->output_data
.w32
);
5903 f
->output_data
.w32
= NULL
;
5905 if (f
== dpyinfo
->w32_focus_frame
)
5906 dpyinfo
->w32_focus_frame
= 0;
5907 if (f
== dpyinfo
->w32_focus_event_frame
)
5908 dpyinfo
->w32_focus_event_frame
= 0;
5909 if (f
== dpyinfo
->x_highlight_frame
)
5910 dpyinfo
->x_highlight_frame
= 0;
5912 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5914 dpyinfo
->mouse_face_beg_row
5915 = dpyinfo
->mouse_face_beg_col
= -1;
5916 dpyinfo
->mouse_face_end_row
5917 = dpyinfo
->mouse_face_end_col
= -1;
5918 dpyinfo
->mouse_face_window
= Qnil
;
5919 dpyinfo
->mouse_face_deferred_gc
= 0;
5920 dpyinfo
->mouse_face_mouse_frame
= 0;
5927 /* Destroy the window of frame F. */
5929 x_destroy_window (f
)
5932 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5934 x_free_frame_resources (f
);
5936 dpyinfo
->reference_count
--;
5940 /* Setting window manager hints. */
5942 /* Set the normal size hints for the window manager, for frame F.
5943 FLAGS is the flags word to use--or 0 meaning preserve the flags
5944 that the window now has.
5945 If USER_POSITION is nonzero, we set the USPosition
5946 flag (this is useful when FLAGS is 0). */
5948 x_wm_set_size_hint (f
, flags
, user_position
)
5953 Window window
= FRAME_W32_WINDOW (f
);
5957 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
5958 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
5959 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
5960 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
5965 /* Window manager things */
5967 x_wm_set_icon_position (f
, icon_x
, icon_y
)
5972 Window window
= FRAME_W32_WINDOW (f
);
5974 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
5975 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
5976 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
5978 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
5983 /***********************************************************************
5985 ***********************************************************************/
5987 /* The following functions are listed here to help diff stay in step
5988 with xterm.c. See w32fns.c for definitions.
5990 x_get_font_info (f, font_idx)
5991 x_list_fonts (f, pattern, size, maxnames)
5997 /* Check that FONT is valid on frame F. It is if it can be found in F's
6001 x_check_font (f
, font
)
6006 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6008 xassert (font
!= NULL
);
6010 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
6011 if (dpyinfo
->font_table
[i
].name
6012 && font
== dpyinfo
->font_table
[i
].font
)
6015 xassert (i
< dpyinfo
->n_fonts
);
6018 #endif /* GLYPH_DEBUG != 0 */
6020 /* Set *W to the minimum width, *H to the minimum font height of FONT.
6021 Note: There are (broken) X fonts out there with invalid XFontStruct
6022 min_bounds contents. For example, handa@etl.go.jp reports that
6023 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
6024 have font->min_bounds.width == 0. */
6027 x_font_min_bounds (font
, w
, h
)
6032 * TODO: Windows does not appear to offer min bound, only
6033 * average and maximum width, and maximum height.
6035 *h
= FONT_HEIGHT (font
);
6036 *w
= FONT_WIDTH (font
);
6040 /* Compute the smallest character width and smallest font height over
6041 all fonts available on frame F. Set the members smallest_char_width
6042 and smallest_font_height in F's x_display_info structure to
6043 the values computed. Value is non-zero if smallest_font_height or
6044 smallest_char_width become smaller than they were before. */
6047 x_compute_min_glyph_bounds (f
)
6051 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6053 int old_width
= dpyinfo
->smallest_char_width
;
6054 int old_height
= dpyinfo
->smallest_font_height
;
6056 dpyinfo
->smallest_font_height
= 100000;
6057 dpyinfo
->smallest_char_width
= 100000;
6059 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
6060 if (dpyinfo
->font_table
[i
].name
)
6062 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
6065 font
= (XFontStruct
*) fontp
->font
;
6066 xassert (font
!= (XFontStruct
*) ~0);
6067 x_font_min_bounds (font
, &w
, &h
);
6069 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
6070 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
6073 xassert (dpyinfo
->smallest_char_width
> 0
6074 && dpyinfo
->smallest_font_height
> 0);
6076 return (dpyinfo
->n_fonts
== 1
6077 || dpyinfo
->smallest_char_width
< old_width
6078 || dpyinfo
->smallest_font_height
< old_height
);
6081 /* The following functions are listed here to help diff stay in step
6082 with xterm.c. See w32fns.c for definitions.
6084 x_load_font (f, fontname, size)
6085 x_query_font (f, fontname)
6086 x_find_ccl_program (fontp)
6090 /***********************************************************************
6092 ***********************************************************************/
6094 static int w32_initialized
= 0;
6097 w32_initialize_display_info (display_name
)
6098 Lisp_Object display_name
;
6100 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6102 bzero (dpyinfo
, sizeof (*dpyinfo
));
6104 /* Put it on w32_display_name_list. */
6105 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
6106 w32_display_name_list
);
6107 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
6109 dpyinfo
->w32_id_name
6110 = (char *) xmalloc (SCHARS (Vinvocation_name
)
6111 + SCHARS (Vsystem_name
)
6113 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6114 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6116 /* Default Console mode values - overridden when running in GUI mode
6117 with values obtained from system metrics. */
6120 dpyinfo
->height_in
= 1;
6121 dpyinfo
->width_in
= 1;
6122 dpyinfo
->n_planes
= 1;
6123 dpyinfo
->n_cbits
= 4;
6124 dpyinfo
->n_fonts
= 0;
6125 dpyinfo
->smallest_font_height
= 1;
6126 dpyinfo
->smallest_char_width
= 1;
6128 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6129 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6130 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
6131 dpyinfo
->mouse_face_window
= Qnil
;
6132 dpyinfo
->mouse_face_overlay
= Qnil
;
6133 dpyinfo
->mouse_face_hidden
= 0;
6135 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6136 /* TODO: dpyinfo->gray */
6140 /* Create an xrdb-style database of resources to supercede registry settings.
6141 The database is just a concatenation of C strings, finished by an additional
6142 \0. The string are submitted to some basic normalization, so
6144 [ *]option[ *]:[ *]value...
6150 but any whitespace following value is not removed. */
6153 w32_make_rdb (xrm_option
)
6156 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6157 char *current
= buffer
;
6160 int before_value
= 0;
6174 if (in_option
&& (ch
== ':'))
6179 else if (before_value
)
6184 else if (!(in_option
|| before_value
))
6195 struct w32_display_info
*
6196 w32_term_init (display_name
, xrm_option
, resource_name
)
6197 Lisp_Object display_name
;
6199 char *resource_name
;
6201 struct w32_display_info
*dpyinfo
;
6206 if (!w32_initialized
)
6209 w32_initialized
= 1;
6212 w32_initialize_display_info (display_name
);
6214 dpyinfo
= &one_w32_display_info
;
6216 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6218 /* Put this display on the chain. */
6219 dpyinfo
->next
= x_display_list
;
6220 x_display_list
= dpyinfo
;
6222 hdc
= GetDC (GetDesktopWindow ());
6224 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
6225 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
6226 dpyinfo
->root_window
= GetDesktopWindow ();
6227 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6228 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6229 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6230 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6231 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6232 dpyinfo
->image_cache
= make_image_cache ();
6233 dpyinfo
->height_in
= dpyinfo
->height
/ dpyinfo
->resx
;
6234 dpyinfo
->width_in
= dpyinfo
->width
/ dpyinfo
->resy
;
6235 ReleaseDC (GetDesktopWindow (), hdc
);
6237 /* initialise palette with white and black */
6240 w32_defined_color (0, "white", &color
, 1);
6241 w32_defined_color (0, "black", &color
, 1);
6244 /* Create Fringe Bitmaps and store them for later use.
6246 On W32, bitmaps are all unsigned short, as Windows requires
6247 bitmap data to be Word aligned. For some reason they are
6248 horizontally reflected compared to how they appear on X, so we
6249 need to bitswap and convert to unsigned shorts before creating
6253 #ifndef F_SETOWN_BUG
6255 #ifdef F_SETOWN_SOCK_NEG
6256 /* stdin is a socket here */
6257 fcntl (connection
, F_SETOWN
, -getpid ());
6258 #else /* ! defined (F_SETOWN_SOCK_NEG) */
6259 fcntl (connection
, F_SETOWN
, getpid ());
6260 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
6261 #endif /* ! defined (F_SETOWN) */
6262 #endif /* F_SETOWN_BUG */
6265 if (interrupt_input
)
6266 init_sigio (connection
);
6267 #endif /* ! defined (SIGIO) */
6274 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6277 x_delete_display (dpyinfo
)
6278 struct w32_display_info
*dpyinfo
;
6280 /* Discard this display from w32_display_name_list and w32_display_list.
6281 We can't use Fdelq because that can quit. */
6282 if (! NILP (w32_display_name_list
)
6283 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
6284 w32_display_name_list
= XCDR (w32_display_name_list
);
6289 tail
= w32_display_name_list
;
6290 while (CONSP (tail
) && CONSP (XCDR (tail
)))
6292 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
6294 XSETCDR (tail
, XCDR (XCDR (tail
)));
6301 /* free palette table */
6303 struct w32_palette_entry
* plist
;
6305 plist
= dpyinfo
->color_list
;
6308 struct w32_palette_entry
* pentry
= plist
;
6309 plist
= plist
->next
;
6312 dpyinfo
->color_list
= NULL
;
6313 if (dpyinfo
->palette
)
6314 DeleteObject(dpyinfo
->palette
);
6316 xfree (dpyinfo
->font_table
);
6317 xfree (dpyinfo
->w32_id_name
);
6319 w32_reset_fringes ();
6322 /* Set up use of W32. */
6324 DWORD
w32_msg_worker ();
6327 x_flush (struct frame
* f
)
6328 { /* Nothing to do */ }
6330 extern frame_parm_handler w32_frame_parm_handlers
[];
6332 static struct redisplay_interface w32_redisplay_interface
=
6334 w32_frame_parm_handlers
,
6338 x_clear_end_of_line
,
6340 x_after_update_window_line
,
6341 x_update_window_begin
,
6342 x_update_window_end
,
6345 0, /* flush_display_optional */
6346 x_clear_window_mouse_face
,
6347 w32_get_glyph_overhangs
,
6348 x_fix_overlapping_area
,
6349 w32_draw_fringe_bitmap
,
6350 w32_define_fringe_bitmap
,
6351 w32_destroy_fringe_bitmap
,
6352 w32_per_char_metric
,
6354 NULL
, /* w32_compute_glyph_string_overhangs */
6355 x_draw_glyph_string
,
6356 w32_define_frame_cursor
,
6357 w32_clear_frame_area
,
6358 w32_draw_window_cursor
,
6359 w32_draw_vertical_window_border
,
6360 w32_shift_glyphs_for_insert
6366 rif
= &w32_redisplay_interface
;
6368 /* MSVC does not type K&R functions with no arguments correctly, and
6369 so we must explicitly cast them. */
6370 clear_frame_hook
= (void (*)(void)) x_clear_frame
;
6371 ring_bell_hook
= (void (*)(void)) w32_ring_bell
;
6372 update_begin_hook
= x_update_begin
;
6373 update_end_hook
= x_update_end
;
6375 read_socket_hook
= w32_read_socket
;
6377 frame_up_to_date_hook
= w32_frame_up_to_date
;
6379 mouse_position_hook
= w32_mouse_position
;
6380 frame_rehighlight_hook
= w32_frame_rehighlight
;
6381 frame_raise_lower_hook
= w32_frame_raise_lower
;
6382 set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6383 condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6384 redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6385 judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6387 scroll_region_ok
= 1; /* we'll scroll partial frames */
6388 char_ins_del_ok
= 1;
6389 line_ins_del_ok
= 1; /* we'll just blt 'em */
6390 fast_clear_end_of_line
= 1; /* X does this well */
6391 memory_below_frame
= 0; /* we don't remember what scrolls
6395 w32_system_caret_hwnd
= NULL
;
6396 w32_system_caret_height
= 0;
6397 w32_system_caret_x
= 0;
6398 w32_system_caret_y
= 0;
6400 last_tool_bar_item
= -1;
6401 any_help_event_p
= 0;
6403 /* Initialize input mode: interrupt_input off, no flow control, allow
6404 8 bit character input, standard quit char. */
6405 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
6407 /* Create the window thread - it will terminate itself or when the app terminates */
6411 dwMainThreadId
= GetCurrentThreadId ();
6412 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6413 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
6415 /* Wait for thread to start */
6420 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
6422 hWindowsThread
= CreateThread (NULL
, 0,
6423 (LPTHREAD_START_ROUTINE
) w32_msg_worker
,
6424 0, 0, &dwWindowsThreadId
);
6426 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6429 /* It is desirable that mainThread should have the same notion of
6430 focus window and active window as windowsThread. Unfortunately, the
6431 following call to AttachThreadInput, which should do precisely what
6432 we need, causes major problems when Emacs is linked as a console
6433 program. Unfortunately, we have good reasons for doing that, so
6434 instead we need to send messages to windowsThread to make some API
6435 calls for us (ones that affect, or depend on, the active/focus
6437 #ifdef ATTACH_THREADS
6438 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
6441 /* Dynamically link to optional system components. */
6443 HANDLE user_lib
= LoadLibrary ("user32.dll");
6445 #define LOAD_PROC(fn) pfn##fn = (void *) GetProcAddress (user_lib, #fn)
6447 /* New proportional scroll bar functions. */
6448 LOAD_PROC (SetScrollInfo
);
6449 LOAD_PROC (GetScrollInfo
);
6453 FreeLibrary (user_lib
);
6455 /* If using proportional scroll bars, ensure handle is at least 5 pixels;
6456 otherwise use the fixed height. */
6457 vertical_scroll_bar_min_handle
= (pfnSetScrollInfo
!= NULL
) ? 5 :
6458 GetSystemMetrics (SM_CYVTHUMB
);
6460 /* For either kind of scroll bar, take account of the arrows; these
6461 effectively form the border of the main scroll bar range. */
6462 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
6463 = GetSystemMetrics (SM_CYVSCROLL
);
6470 staticpro (&w32_display_name_list
);
6471 w32_display_name_list
= Qnil
;
6473 staticpro (&last_mouse_scroll_bar
);
6474 last_mouse_scroll_bar
= Qnil
;
6476 staticpro (&Qvendor_specific_keysyms
);
6477 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
6479 DEFVAR_INT ("w32-num-mouse-buttons",
6480 &w32_num_mouse_buttons
,
6481 doc
: /* Number of physical mouse buttons. */);
6482 w32_num_mouse_buttons
= 2;
6484 DEFVAR_LISP ("w32-swap-mouse-buttons",
6485 &Vw32_swap_mouse_buttons
,
6486 doc
: /* Swap the mapping of middle and right mouse buttons.
6487 When nil, middle button is mouse-2 and right button is mouse-3. */);
6488 Vw32_swap_mouse_buttons
= Qnil
;
6490 DEFVAR_LISP ("w32-grab-focus-on-raise",
6491 &Vw32_grab_focus_on_raise
,
6492 doc
: /* Raised frame grabs input focus.
6493 When t, `raise-frame' grabs input focus as well. This fits well
6494 with the normal Windows click-to-focus policy, but might not be
6495 desirable when using a point-to-focus policy. */);
6496 Vw32_grab_focus_on_raise
= Qt
;
6498 DEFVAR_LISP ("w32-capslock-is-shiftlock",
6499 &Vw32_capslock_is_shiftlock
,
6500 doc
: /* Apply CapsLock state to non character input keys.
6501 When nil, CapsLock only affects normal character input keys. */);
6502 Vw32_capslock_is_shiftlock
= Qnil
;
6504 DEFVAR_LISP ("w32-recognize-altgr",
6505 &Vw32_recognize_altgr
,
6506 doc
: /* Recognize right-alt and left-ctrl as AltGr.
6507 When nil, the right-alt and left-ctrl key combination is
6508 interpreted normally. */);
6509 Vw32_recognize_altgr
= Qt
;
6511 DEFVAR_BOOL ("w32-enable-unicode-output",
6512 &w32_enable_unicode_output
,
6513 doc
: /* Enable the use of Unicode for text output if non-nil.
6514 Unicode output may prevent some third party applications for displaying
6515 Far-East Languages on Windows 95/98 from working properly.
6516 NT uses Unicode internally anyway, so this flag will probably have no
6517 affect on NT machines. */);
6518 w32_enable_unicode_output
= 1;
6520 DEFVAR_BOOL ("w32-use-visible-system-caret",
6521 &w32_use_visible_system_caret
,
6522 doc
: /* Flag to make the system caret visible.
6523 When this is non-nil, Emacs will indicate the position of point by
6524 using the system caret instead of drawing its own cursor. Some screen
6525 reader software does not track the system cursor properly when it is
6526 invisible, and gets confused by Emacs drawing its own cursor, so this
6527 variable is initialized to t when Emacs detects that screen reader
6528 software is running as it starts up.
6530 When this variable is set, other variables affecting the appearance of
6531 the cursor have no effect. */);
6533 /* Initialize w32_use_visible_system_caret based on whether a screen
6534 reader is in use. */
6535 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
6536 &w32_use_visible_system_caret
, 0))
6537 w32_use_visible_system_caret
= 0;
6539 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
6540 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
6541 Vx_toolkit_scroll_bars
= Qt
;
6543 staticpro (&last_mouse_motion_frame
);
6544 last_mouse_motion_frame
= Qnil
;
6547 /* arch-tag: 5fa70624-ab86-499c-8a85-473958ee4646
6548 (do not change this comment) */