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
);
1212 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
1213 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
1214 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
1216 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
1217 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
1218 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
1219 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
1220 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
1221 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
1222 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
1223 static int w32_alloc_lighter_color (struct frame
*, COLORREF
*, double, int);
1224 static void w32_setup_relief_color
P_ ((struct frame
*, struct relief
*,
1225 double, int, COLORREF
));
1226 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
1227 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
1228 static void x_draw_image_relief
P_ ((struct glyph_string
*));
1229 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
1230 static void w32_draw_image_foreground_1
P_ ((struct glyph_string
*, HBITMAP
));
1231 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
1233 static void w32_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
1234 int, int, int, int, int, int,
1236 static void w32_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
1237 int, int, int, RECT
*));
1240 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
1244 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1249 struct glyph_string
*s
;
1251 if (s
->font
== FRAME_FONT (s
->f
)
1252 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1253 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1255 s
->gc
= s
->f
->output_data
.w32
->cursor_gc
;
1258 /* Cursor on non-default face: must merge. */
1262 xgcv
.background
= s
->f
->output_data
.w32
->cursor_pixel
;
1263 xgcv
.foreground
= s
->face
->background
;
1265 /* If the glyph would be invisible, try a different foreground. */
1266 if (xgcv
.foreground
== xgcv
.background
)
1267 xgcv
.foreground
= s
->face
->foreground
;
1268 if (xgcv
.foreground
== xgcv
.background
)
1269 xgcv
.foreground
= s
->f
->output_data
.w32
->cursor_foreground_pixel
;
1270 if (xgcv
.foreground
== xgcv
.background
)
1271 xgcv
.foreground
= s
->face
->foreground
;
1273 /* Make sure the cursor is distinct from text in this face. */
1274 if (xgcv
.background
== s
->face
->background
1275 && xgcv
.foreground
== s
->face
->foreground
)
1277 xgcv
.background
= s
->face
->foreground
;
1278 xgcv
.foreground
= s
->face
->background
;
1281 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1282 xgcv
.font
= s
->font
;
1283 mask
= GCForeground
| GCBackground
| GCFont
;
1285 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1286 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1289 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1290 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1292 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1297 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1300 x_set_mouse_face_gc (s
)
1301 struct glyph_string
*s
;
1306 /* What face has to be used last for the mouse face? */
1307 face_id
= FRAME_W32_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1308 face
= FACE_FROM_ID (s
->f
, face_id
);
1310 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1312 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1313 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
1315 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
1316 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1317 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1319 /* If font in this face is same as S->font, use it. */
1320 if (s
->font
== s
->face
->font
)
1321 s
->gc
= s
->face
->gc
;
1324 /* Otherwise construct scratch_cursor_gc with values from FACE
1329 xgcv
.background
= s
->face
->background
;
1330 xgcv
.foreground
= s
->face
->foreground
;
1331 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1332 xgcv
.font
= s
->font
;
1333 mask
= GCForeground
| GCBackground
| GCFont
;
1335 if (FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1336 XChangeGC (NULL
, FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1339 FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1340 = XCreateGC (NULL
, s
->window
, mask
, &xgcv
);
1342 s
->gc
= FRAME_W32_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1345 xassert (s
->gc
!= 0);
1349 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1350 Faces to use in the mode line have already been computed when the
1351 matrix was built, so there isn't much to do, here. */
1354 x_set_mode_line_face_gc (s
)
1355 struct glyph_string
*s
;
1357 s
->gc
= s
->face
->gc
;
1361 /* Set S->gc of glyph string S for drawing that glyph string. Set
1362 S->stippled_p to a non-zero value if the face of S has a stipple
1366 x_set_glyph_string_gc (s
)
1367 struct glyph_string
*s
;
1369 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1371 if (s
->hl
== DRAW_NORMAL_TEXT
)
1373 s
->gc
= s
->face
->gc
;
1374 s
->stippled_p
= s
->face
->stipple
!= 0;
1376 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1378 x_set_mode_line_face_gc (s
);
1379 s
->stippled_p
= s
->face
->stipple
!= 0;
1381 else if (s
->hl
== DRAW_CURSOR
)
1383 x_set_cursor_gc (s
);
1386 else if (s
->hl
== DRAW_MOUSE_FACE
)
1388 x_set_mouse_face_gc (s
);
1389 s
->stippled_p
= s
->face
->stipple
!= 0;
1391 else if (s
->hl
== DRAW_IMAGE_RAISED
1392 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1394 s
->gc
= s
->face
->gc
;
1395 s
->stippled_p
= s
->face
->stipple
!= 0;
1399 s
->gc
= s
->face
->gc
;
1400 s
->stippled_p
= s
->face
->stipple
!= 0;
1403 /* GC must have been set. */
1404 xassert (s
->gc
!= 0);
1408 /* Set clipping for output of glyph string S. S may be part of a mode
1409 line or menu if we don't have X toolkit support. */
1412 x_set_glyph_string_clipping (s
)
1413 struct glyph_string
*s
;
1416 get_glyph_string_clip_rect (s
, &r
);
1417 w32_set_clip_rectangle (s
->hdc
, &r
);
1422 Compute left and right overhang of glyph string S. If S is a glyph
1423 string for a composition, assume overhangs don't exist. */
1426 w32_compute_glyph_string_overhangs (s
)
1427 struct glyph_string
*s
;
1429 /* TODO: Windows does not appear to have a method for
1430 getting this info without getting the ABC widths for each
1431 individual character and working it out manually. */
1436 w32_get_glyph_overhangs (glyph
, f
, left
, right
)
1437 struct glyph
*glyph
;
1441 HDC hdc
= get_frame_dc (f
);
1442 /* Convert to unicode! */
1443 x_get_glyph_overhangs (glyph
, f
, left
, right
);
1444 release_frame_dc (f
, hdc
);
1448 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1451 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1452 struct glyph_string
*s
;
1460 /* Take clipping into account. */
1461 if (s
->gc
->clip_mask
== Rect
)
1463 real_x
= max (real_x
, s
->gc
->clip_rectangle
.left
);
1464 real_y
= max (real_y
, s
->gc
->clip_rectangle
.top
);
1465 real_w
= min (real_w
, s
->gc
->clip_rectangle
.right
1466 - s
->gc
->clip_rectangle
.left
);
1467 real_h
= min (real_h
, s
->gc
->clip_rectangle
.bottom
1468 - s
->gc
->clip_rectangle
.top
);
1471 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->background
, real_x
, real_y
,
1476 /* Draw the background of glyph_string S. If S->background_filled_p
1477 is non-zero don't draw it. FORCE_P non-zero means draw the
1478 background even if it wouldn't be drawn normally. This is used
1479 when a string preceding S draws into the background of S, or S
1480 contains the first component of a composition. */
1483 x_draw_glyph_string_background (s
, force_p
)
1484 struct glyph_string
*s
;
1487 /* Nothing to do if background has already been drawn or if it
1488 shouldn't be drawn in the first place. */
1489 if (!s
->background_filled_p
)
1491 int box_line_width
= max (s
->face
->box_line_width
, 0);
1493 #if 0 /* TODO: stipple */
1496 /* Fill background with a stipple pattern. */
1497 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1498 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1499 s
->y
+ box_line_width
,
1500 s
->background_width
,
1501 s
->height
- 2 * box_line_width
);
1502 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1503 s
->background_filled_p
= 1;
1507 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1508 || s
->font_not_found_p
1509 || s
->extends_to_end_of_line_p
1513 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1514 s
->background_width
,
1515 s
->height
- 2 * box_line_width
);
1516 s
->background_filled_p
= 1;
1522 /* Draw the foreground of glyph string S. */
1525 x_draw_glyph_string_foreground (s
)
1526 struct glyph_string
*s
;
1531 /* If first glyph of S has a left box line, start drawing the text
1532 of S to the right of that box line. */
1533 if (s
->face
->box
!= FACE_NO_BOX
1534 && s
->first_glyph
->left_box_line_p
)
1535 x
= s
->x
+ abs (s
->face
->box_line_width
);
1539 if (s
->for_overlaps_p
|| (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1540 SetBkMode (s
->hdc
, TRANSPARENT
);
1542 SetBkMode (s
->hdc
, OPAQUE
);
1544 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1545 SetBkColor (s
->hdc
, s
->gc
->background
);
1546 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1548 if (s
->font
&& s
->font
->hfont
)
1549 old_font
= SelectObject (s
->hdc
, s
->font
->hfont
);
1551 /* Draw characters of S as rectangles if S's font could not be
1553 if (s
->font_not_found_p
)
1555 for (i
= 0; i
< s
->nchars
; ++i
)
1557 struct glyph
*g
= s
->first_glyph
+ i
;
1559 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1561 x
+= g
->pixel_width
;
1566 char *char1b
= (char *) s
->char2b
;
1567 int boff
= s
->font_info
->baseline_offset
;
1569 if (s
->font_info
->vertical_centering
)
1570 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
1572 /* If we can use 8-bit functions, condense S->char2b. */
1574 for (i
= 0; i
< s
->nchars
; ++i
)
1575 char1b
[i
] = XCHAR2B_BYTE2 (&s
->char2b
[i
]);
1577 /* Draw text with TextOut and friends. */
1578 w32_text_out (s
, x
, s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1580 if (s
->face
->overstrike
)
1582 /* For overstriking (to simulate bold-face), draw the
1583 characters again shifted to the right by one pixel. */
1584 w32_text_out (s
, x
+ 1, s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1587 if (s
->font
&& s
->font
->hfont
)
1588 SelectObject (s
->hdc
, old_font
);
1591 /* Draw the foreground of composite glyph string S. */
1594 x_draw_composite_glyph_string_foreground (s
)
1595 struct glyph_string
*s
;
1600 /* If first glyph of S has a left box line, start drawing the text
1601 of S to the right of that box line. */
1602 if (s
->face
->box
!= FACE_NO_BOX
1603 && s
->first_glyph
->left_box_line_p
)
1604 x
= s
->x
+ abs (s
->face
->box_line_width
);
1608 /* S is a glyph string for a composition. S->gidx is the index of
1609 the first character drawn for glyphs of this composition.
1610 S->gidx == 0 means we are drawing the very first character of
1611 this composition. */
1613 SetTextColor (s
->hdc
, s
->gc
->foreground
);
1614 SetBkColor (s
->hdc
, s
->gc
->background
);
1615 SetBkMode (s
->hdc
, TRANSPARENT
);
1616 SetTextAlign (s
->hdc
, TA_BASELINE
| TA_LEFT
);
1618 if (s
->font
&& s
->font
->hfont
)
1619 old_font
= SelectObject (s
->hdc
, s
->font
->hfont
);
1621 /* Draw a rectangle for the composition if the font for the very
1622 first character of the composition could not be loaded. */
1623 if (s
->font_not_found_p
)
1626 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, s
->y
, s
->width
- 1,
1631 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
1633 w32_text_out (s
, x
+ s
->cmp
->offsets
[s
->gidx
* 2],
1634 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1636 if (s
->face
->overstrike
)
1637 w32_text_out (s
, x
+ s
->cmp
->offsets
[s
->gidx
* 2] + 1,
1638 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1643 if (s
->font
&& s
->font
->hfont
)
1644 SelectObject (s
->hdc
, old_font
);
1648 /* Brightness beyond which a color won't have its highlight brightness
1651 Nominally, highlight colors for `3d' faces are calculated by
1652 brightening an object's color by a constant scale factor, but this
1653 doesn't yield good results for dark colors, so for colors who's
1654 brightness is less than this value (on a scale of 0-255) have to
1655 use an additional additive factor.
1657 The value here is set so that the default menu-bar/mode-line color
1658 (grey75) will not have its highlights changed at all. */
1659 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1662 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1663 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1664 If this produces the same color as COLOR, try a color where all RGB
1665 values have DELTA added. Return the allocated color in *COLOR.
1666 DISPLAY is the X display, CMAP is the colormap to operate on.
1667 Value is non-zero if successful. */
1670 w32_alloc_lighter_color (f
, color
, factor
, delta
)
1679 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1682 /* Change RGB values by specified FACTOR. Avoid overflow! */
1683 xassert (factor
>= 0);
1684 new = PALETTERGB (min (0xff, factor
* GetRValue (*color
)),
1685 min (0xff, factor
* GetGValue (*color
)),
1686 min (0xff, factor
* GetBValue (*color
)));
1688 /* Calculate brightness of COLOR. */
1689 bright
= (2 * GetRValue (*color
) + 3 * GetGValue (*color
)
1690 + GetBValue (*color
)) / 6;
1692 /* We only boost colors that are darker than
1693 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1694 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1695 /* Make an additive adjustment to NEW, because it's dark enough so
1696 that scaling by FACTOR alone isn't enough. */
1698 /* How far below the limit this color is (0 - 1, 1 being darker). */
1699 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1700 /* The additive adjustment. */
1701 int min_delta
= delta
* dimness
* factor
/ 2;
1704 new = PALETTERGB (max (0, min (0xff, min_delta
- GetRValue (*color
))),
1705 max (0, min (0xff, min_delta
- GetGValue (*color
))),
1706 max (0, min (0xff, min_delta
- GetBValue (*color
))));
1708 new = PALETTERGB (max (0, min (0xff, min_delta
+ GetRValue (*color
))),
1709 max (0, min (0xff, min_delta
+ GetGValue (*color
))),
1710 max (0, min (0xff, min_delta
+ GetBValue (*color
))));
1714 new = PALETTERGB (max (0, min (0xff, delta
+ GetRValue (*color
))),
1715 max (0, min (0xff, delta
+ GetGValue (*color
))),
1716 max (0, min (0xff, delta
+ GetBValue (*color
))));
1718 /* TODO: Map to palette and retry with delta if same? */
1719 /* TODO: Free colors (if using palette)? */
1730 /* Set up the foreground color for drawing relief lines of glyph
1731 string S. RELIEF is a pointer to a struct relief containing the GC
1732 with which lines will be drawn. Use a color that is FACTOR or
1733 DELTA lighter or darker than the relief's background which is found
1734 in S->f->output_data.x->relief_background. If such a color cannot
1735 be allocated, use DEFAULT_PIXEL, instead. */
1738 w32_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
1740 struct relief
*relief
;
1743 COLORREF default_pixel
;
1746 struct w32_output
*di
= f
->output_data
.w32
;
1747 unsigned long mask
= GCForeground
;
1749 COLORREF background
= di
->relief_background
;
1750 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
1752 /* TODO: Free colors (if using palette)? */
1754 /* Allocate new color. */
1755 xgcv
.foreground
= default_pixel
;
1757 if (w32_alloc_lighter_color (f
, &pixel
, factor
, delta
))
1759 relief
->allocated_p
= 1;
1760 xgcv
.foreground
= relief
->pixel
= pixel
;
1763 if (relief
->gc
== 0)
1765 #if 0 /* TODO: stipple */
1766 xgcv
.stipple
= dpyinfo
->gray
;
1769 relief
->gc
= XCreateGC (NULL
, FRAME_W32_WINDOW (f
), mask
, &xgcv
);
1772 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
1776 /* Set up colors for the relief lines around glyph string S. */
1779 x_setup_relief_colors (s
)
1780 struct glyph_string
*s
;
1782 struct w32_output
*di
= s
->f
->output_data
.w32
;
1785 if (s
->face
->use_box_color_for_shadows_p
)
1786 color
= s
->face
->box_color
;
1787 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1789 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1790 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1792 color
= s
->gc
->background
;
1794 if (di
->white_relief
.gc
== 0
1795 || color
!= di
->relief_background
)
1797 di
->relief_background
= color
;
1798 w32_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1799 WHITE_PIX_DEFAULT (s
->f
));
1800 w32_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1801 BLACK_PIX_DEFAULT (s
->f
));
1806 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1807 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1808 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1809 relief. LEFT_P non-zero means draw a relief on the left side of
1810 the rectangle. RIGHT_P non-zero means draw a relief on the right
1811 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1815 w32_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
1816 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
1818 int left_x
, top_y
, right_x
, bottom_y
, width
;
1819 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
1824 HDC hdc
= get_frame_dc (f
);
1827 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1829 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1831 w32_set_clip_rectangle (hdc
, clip_rect
);
1835 for (i
= 0; i
< width
; ++i
)
1836 w32_fill_area (f
, hdc
, gc
.foreground
,
1837 left_x
+ i
* left_p
, top_y
+ i
,
1838 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1842 for (i
= 0; i
< width
; ++i
)
1843 w32_fill_area (f
, hdc
, gc
.foreground
,
1844 left_x
+ i
, top_y
+ i
, 1,
1845 bottom_y
- top_y
- 2 * i
+ 1);
1848 gc
.foreground
= f
->output_data
.w32
->black_relief
.gc
->foreground
;
1850 gc
.foreground
= f
->output_data
.w32
->white_relief
.gc
->foreground
;
1854 for (i
= 0; i
< width
; ++i
)
1855 w32_fill_area (f
, hdc
, gc
.foreground
,
1856 left_x
+ i
* left_p
, bottom_y
- i
,
1857 right_x
- left_x
- i
* (left_p
+ right_p
) + 1, 1);
1861 for (i
= 0; i
< width
; ++i
)
1862 w32_fill_area (f
, hdc
, gc
.foreground
,
1863 right_x
- i
, top_y
+ i
+ 1, 1,
1864 bottom_y
- top_y
- 2 * i
- 1);
1866 w32_set_clip_rectangle (hdc
, NULL
);
1868 release_frame_dc (f
, hdc
);
1872 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1873 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1874 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1875 left side of the rectangle. RIGHT_P non-zero means draw a line
1876 on the right side of the rectangle. CLIP_RECT is the clipping
1877 rectangle to use when drawing. */
1880 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1881 left_p
, right_p
, clip_rect
)
1882 struct glyph_string
*s
;
1883 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
1886 w32_set_clip_rectangle (s
->hdc
, clip_rect
);
1889 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1890 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1895 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1896 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1900 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1901 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1906 w32_fill_area (s
->f
, s
->hdc
, s
->face
->box_color
,
1907 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1910 w32_set_clip_rectangle (s
->hdc
, NULL
);
1914 /* Draw a box around glyph string S. */
1917 x_draw_glyph_string_box (s
)
1918 struct glyph_string
*s
;
1920 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
1921 int left_p
, right_p
;
1922 struct glyph
*last_glyph
;
1925 last_x
= window_box_right (s
->w
, s
->area
);
1926 if (s
->row
->full_width_p
1927 && !s
->w
->pseudo_window_p
)
1929 last_x
+= WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH (s
->w
);
1930 if (s
->area
!= RIGHT_MARGIN_AREA
1931 || WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (s
->w
))
1932 last_x
+= WINDOW_RIGHT_FRINGE_WIDTH (s
->w
);
1935 /* The glyph that may have a right box line. */
1936 last_glyph
= (s
->cmp
|| s
->img
1938 : s
->first_glyph
+ s
->nchars
- 1);
1940 width
= abs (s
->face
->box_line_width
);
1941 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
1943 right_x
= ((s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
1945 : min (last_x
, s
->x
+ s
->background_width
) - 1));
1947 bottom_y
= top_y
+ s
->height
- 1;
1949 left_p
= (s
->first_glyph
->left_box_line_p
1950 || (s
->hl
== DRAW_MOUSE_FACE
1952 || s
->prev
->hl
!= s
->hl
)));
1953 right_p
= (last_glyph
->right_box_line_p
1954 || (s
->hl
== DRAW_MOUSE_FACE
1956 || s
->next
->hl
!= s
->hl
)));
1958 get_glyph_string_clip_rect (s
, &clip_rect
);
1960 if (s
->face
->box
== FACE_SIMPLE_BOX
)
1961 w32_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
1962 left_p
, right_p
, &clip_rect
);
1965 x_setup_relief_colors (s
);
1966 w32_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
1967 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
1972 /* Draw foreground of image glyph string S. */
1975 x_draw_image_foreground (s
)
1976 struct glyph_string
*s
;
1979 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
1981 /* If first glyph of S has a left box line, start drawing it to the
1982 right of that line. */
1983 if (s
->face
->box
!= FACE_NO_BOX
1984 && s
->first_glyph
->left_box_line_p
1986 x
+= abs (s
->face
->box_line_width
);
1988 /* If there is a margin around the image, adjust x- and y-position
1990 if (s
->slice
.x
== 0)
1991 x
+= s
->img
->hmargin
;
1992 if (s
->slice
.y
== 0)
1993 y
+= s
->img
->vmargin
;
1999 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2000 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2001 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2002 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2003 SetBkColor (compat_hdc
, RGB (255, 255, 255));
2004 SetTextColor (s
->hdc
, RGB (0, 0, 0));
2005 x_set_glyph_string_clipping (s
);
2009 HDC mask_dc
= CreateCompatibleDC (s
->hdc
);
2010 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2012 SetTextColor (s
->hdc
, RGB (255, 255, 255));
2013 SetBkColor (s
->hdc
, RGB (0, 0, 0));
2015 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2016 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2017 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2018 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2019 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2020 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2022 SelectObject (mask_dc
, mask_orig_obj
);
2027 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2028 SetBkColor (s
->hdc
, s
->gc
->background
);
2030 BitBlt (s
->hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2031 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2033 /* When the image has a mask, we can expect that at
2034 least part of a mouse highlight or a block cursor will
2035 be visible. If the image doesn't have a mask, make
2036 a block cursor visible by drawing a rectangle around
2037 the image. I believe it's looking better if we do
2038 nothing here for mouse-face. */
2039 if (s
->hl
== DRAW_CURSOR
)
2041 int r
= s
->img
->relief
;
2043 w32_draw_rectangle (s
->hdc
, s
->gc
, x
- r
, y
- r
,
2044 s
->slice
.width
+ r
*2 - 1,
2045 s
->slice
.height
+ r
*2 - 1);
2049 w32_set_clip_rectangle (s
->hdc
, NULL
);
2050 SelectObject (s
->hdc
, orig_brush
);
2051 DeleteObject (fg_brush
);
2052 SelectObject (compat_hdc
, orig_obj
);
2053 DeleteDC (compat_hdc
);
2056 w32_draw_rectangle (s
->hdc
, s
->gc
, x
, y
,
2057 s
->slice
.width
- 1, s
->slice
.height
- 1);
2059 RestoreDC (s
->hdc
,-1);
2063 /* Draw a relief around the image glyph string S. */
2066 x_draw_image_relief (s
)
2067 struct glyph_string
*s
;
2069 int x0
, y0
, x1
, y1
, thick
, raised_p
;
2072 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2074 /* If first glyph of S has a left box line, start drawing it to the
2075 right of that line. */
2076 if (s
->face
->box
!= FACE_NO_BOX
2077 && s
->first_glyph
->left_box_line_p
2079 x
+= abs (s
->face
->box_line_width
);
2081 /* If there is a margin around the image, adjust x- and y-position
2083 if (s
->slice
.x
== 0)
2084 x
+= s
->img
->hmargin
;
2085 if (s
->slice
.y
== 0)
2086 y
+= s
->img
->vmargin
;
2088 if (s
->hl
== DRAW_IMAGE_SUNKEN
2089 || s
->hl
== DRAW_IMAGE_RAISED
)
2091 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2092 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2096 thick
= abs (s
->img
->relief
);
2097 raised_p
= s
->img
->relief
> 0;
2102 x1
= x
+ s
->slice
.width
+ thick
- 1;
2103 y1
= y
+ s
->slice
.height
+ thick
- 1;
2105 x_setup_relief_colors (s
);
2106 get_glyph_string_clip_rect (s
, &r
);
2107 w32_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2109 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2111 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2116 /* Draw the foreground of image glyph string S to PIXMAP. */
2119 w32_draw_image_foreground_1 (s
, pixmap
)
2120 struct glyph_string
*s
;
2123 HDC hdc
= CreateCompatibleDC (s
->hdc
);
2124 HGDIOBJ orig_hdc_obj
= SelectObject (hdc
, pixmap
);
2126 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2128 /* If first glyph of S has a left box line, start drawing it to the
2129 right of that line. */
2130 if (s
->face
->box
!= FACE_NO_BOX
2131 && s
->first_glyph
->left_box_line_p
2133 x
+= abs (s
->face
->box_line_width
);
2135 /* If there is a margin around the image, adjust x- and y-position
2137 if (s
->slice
.x
== 0)
2138 x
+= s
->img
->hmargin
;
2139 if (s
->slice
.y
== 0)
2140 y
+= s
->img
->vmargin
;
2144 HDC compat_hdc
= CreateCompatibleDC (hdc
);
2145 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2146 HBRUSH orig_brush
= SelectObject (hdc
, fg_brush
);
2147 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, s
->img
->pixmap
);
2151 HDC mask_dc
= CreateCompatibleDC (hdc
);
2152 HGDIOBJ mask_orig_obj
= SelectObject (mask_dc
, s
->img
->mask
);
2154 SetTextColor (hdc
, RGB (0, 0, 0));
2155 SetBkColor (hdc
, RGB (255, 255, 255));
2156 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2157 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2158 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2159 mask_dc
, s
->slice
.x
, s
->slice
.y
, SRCAND
);
2160 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2161 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCINVERT
);
2163 SelectObject (mask_dc
, mask_orig_obj
);
2168 SetTextColor (hdc
, s
->gc
->foreground
);
2169 SetBkColor (hdc
, s
->gc
->background
);
2171 BitBlt (hdc
, x
, y
, s
->slice
.width
, s
->slice
.height
,
2172 compat_hdc
, s
->slice
.x
, s
->slice
.y
, SRCCOPY
);
2174 /* When the image has a mask, we can expect that at
2175 least part of a mouse highlight or a block cursor will
2176 be visible. If the image doesn't have a mask, make
2177 a block cursor visible by drawing a rectangle around
2178 the image. I believe it's looking better if we do
2179 nothing here for mouse-face. */
2180 if (s
->hl
== DRAW_CURSOR
)
2182 int r
= s
->img
->relief
;
2184 w32_draw_rectangle (hdc
, s
->gc
, x
- r
, y
- r
,
2185 s
->slice
.width
+ r
*2 - 1,
2186 s
->slice
.height
+ r
*2 - 1);
2190 SelectObject (hdc
, orig_brush
);
2191 DeleteObject (fg_brush
);
2192 SelectObject (compat_hdc
, orig_obj
);
2193 DeleteDC (compat_hdc
);
2196 w32_draw_rectangle (hdc
, s
->gc
, x
, y
,
2197 s
->slice
.width
- 1, s
->slice
.height
- 1);
2199 SelectObject (hdc
, orig_hdc_obj
);
2204 /* Draw part of the background of glyph string S. X, Y, W, and H
2205 give the rectangle to draw. */
2208 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
2209 struct glyph_string
*s
;
2212 #if 0 /* TODO: stipple */
2215 /* Fill background with a stipple pattern. */
2216 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2217 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2218 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2222 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2226 /* Draw image glyph string S.
2229 s->x +-------------------------
2232 | +-------------------------
2235 | | +-------------------
2241 x_draw_image_glyph_string (s
)
2242 struct glyph_string
*s
;
2245 int box_line_hwidth
= abs (s
->face
->box_line_width
);
2246 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2250 height
= s
->height
- 2 * box_line_vwidth
;
2252 /* Fill background with face under the image. Do it only if row is
2253 taller than image or if image has a clip mask to reduce
2255 s
->stippled_p
= s
->face
->stipple
!= 0;
2256 if (height
> s
->slice
.height
2260 || s
->img
->pixmap
== 0
2261 || s
->width
!= s
->background_width
)
2264 if (s
->first_glyph
->left_box_line_p
2266 x
+= box_line_hwidth
;
2269 if (s
->slice
.y
== 0)
2270 y
+= box_line_vwidth
;
2272 #if 0 /* TODO: figure out if we need to do this on Windows. */
2275 /* Create a pixmap as large as the glyph string. Fill it
2276 with the background color. Copy the image to it, using
2277 its mask. Copy the temporary pixmap to the display. */
2278 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2279 int depth
= DefaultDepthOfScreen (screen
);
2281 /* Create a pixmap as large as the glyph string. */
2282 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2283 s
->background_width
,
2286 /* Don't clip in the following because we're working on the
2288 XSetClipMask (s
->display
, s
->gc
, None
);
2290 /* Fill the pixmap with the background color/stipple. */
2293 /* Fill background with a stipple pattern. */
2294 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2295 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2296 0, 0, s
->background_width
, s
->height
);
2297 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2302 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2304 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2305 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2306 0, 0, s
->background_width
, s
->height
);
2307 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2312 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2314 s
->background_filled_p
= 1;
2317 /* Draw the foreground. */
2320 w32_draw_image_foreground_1 (s
, pixmap
);
2321 x_set_glyph_string_clipping (s
);
2323 HDC compat_hdc
= CreateCompatibleDC (s
->hdc
);
2324 HBRUSH fg_brush
= CreateSolidBrush (s
->gc
->foreground
);
2325 HBRUSH orig_brush
= SelectObject (s
->hdc
, fg_brush
);
2326 HGDIOBJ orig_obj
= SelectObject (compat_hdc
, pixmap
);
2328 SetTextColor (s
->hdc
, s
->gc
->foreground
);
2329 SetBkColor (s
->hdc
, s
->gc
->background
);
2330 BitBlt (s
->hdc
, s
->x
, s
->y
, s
->background_width
, s
->height
,
2331 compat_hdc
, 0, 0, SRCCOPY
);
2333 SelectObject (s
->hdc
, orig_brush
);
2334 DeleteObject (fg_brush
);
2335 SelectObject (compat_hdc
, orig_obj
);
2336 DeleteDC (compat_hdc
);
2338 DeleteObject (pixmap
);
2342 x_draw_image_foreground (s
);
2344 /* If we must draw a relief around the image, do it. */
2346 || s
->hl
== DRAW_IMAGE_RAISED
2347 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2348 x_draw_image_relief (s
);
2352 /* Draw stretch glyph string S. */
2355 x_draw_stretch_glyph_string (s
)
2356 struct glyph_string
*s
;
2358 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2359 s
->stippled_p
= s
->face
->stipple
!= 0;
2361 if (s
->hl
== DRAW_CURSOR
2362 && !x_stretch_cursor_p
)
2364 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2365 as wide as the stretch glyph. */
2366 int width
= min (FRAME_COLUMN_WIDTH (s
->f
), s
->background_width
);
2369 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
2371 /* Clear rest using the GC of the original non-cursor face. */
2372 if (width
< s
->background_width
)
2374 XGCValues
*gc
= s
->face
->gc
;
2375 int x
= s
->x
+ width
, y
= s
->y
;
2376 int w
= s
->background_width
- width
, h
= s
->height
;
2380 if (s
->row
->mouse_face_p
2381 && cursor_in_mouse_face_p (s
->w
))
2383 x_set_mouse_face_gc (s
);
2389 get_glyph_string_clip_rect (s
, &r
);
2390 w32_set_clip_rectangle (hdc
, &r
);
2392 #if 0 /* TODO: stipple */
2393 if (s
->face
->stipple
)
2395 /* Fill background with a stipple pattern. */
2396 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2397 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2398 XSetFillStyle (s
->display
, gc
, FillSolid
);
2403 w32_fill_area (s
->f
, s
->hdc
, gc
->background
, x
, y
, w
, h
);
2407 else if (!s
->background_filled_p
)
2408 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
2411 s
->background_filled_p
= 1;
2415 /* Draw glyph string S. */
2418 x_draw_glyph_string (s
)
2419 struct glyph_string
*s
;
2421 int relief_drawn_p
= 0;
2423 /* If S draws into the background of its successor, draw the
2424 background of the successor first so that S can draw into it.
2425 This makes S->next use XDrawString instead of XDrawImageString. */
2426 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
2428 xassert (s
->next
->img
== NULL
);
2429 x_set_glyph_string_gc (s
->next
);
2430 x_set_glyph_string_clipping (s
->next
);
2431 x_draw_glyph_string_background (s
->next
, 1);
2434 /* Set up S->gc, set clipping and draw S. */
2435 x_set_glyph_string_gc (s
);
2437 /* Draw relief (if any) in advance for char/composition so that the
2438 glyph string can be drawn over it. */
2439 if (!s
->for_overlaps_p
2440 && s
->face
->box
!= FACE_NO_BOX
2441 && (s
->first_glyph
->type
== CHAR_GLYPH
2442 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2445 x_set_glyph_string_clipping (s
);
2446 x_draw_glyph_string_background (s
, 1);
2447 x_draw_glyph_string_box (s
);
2448 x_set_glyph_string_clipping (s
);
2452 x_set_glyph_string_clipping (s
);
2454 switch (s
->first_glyph
->type
)
2457 x_draw_image_glyph_string (s
);
2461 x_draw_stretch_glyph_string (s
);
2465 if (s
->for_overlaps_p
)
2466 s
->background_filled_p
= 1;
2468 x_draw_glyph_string_background (s
, 0);
2469 x_draw_glyph_string_foreground (s
);
2472 case COMPOSITE_GLYPH
:
2473 if (s
->for_overlaps_p
|| s
->gidx
> 0)
2474 s
->background_filled_p
= 1;
2476 x_draw_glyph_string_background (s
, 1);
2477 x_draw_composite_glyph_string_foreground (s
);
2484 if (!s
->for_overlaps_p
)
2486 /* Draw underline. */
2487 if (s
->face
->underline_p
2488 && (s
->font
->bdf
|| !s
->font
->tm
.tmUnderlined
))
2490 unsigned long h
= 1;
2491 unsigned long dy
= s
->height
- h
;
2493 /* TODO: Use font information for positioning and thickness
2494 of underline. See OUTLINETEXTMETRIC, and xterm.c. */
2495 if (s
->face
->underline_defaulted_p
)
2497 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2498 s
->y
+ dy
, s
->width
, 1);
2502 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2503 s
->y
+ dy
, s
->width
, 1);
2507 /* Draw overline. */
2508 if (s
->face
->overline_p
)
2510 unsigned long dy
= 0, h
= 1;
2512 if (s
->face
->overline_color_defaulted_p
)
2514 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
,
2515 s
->y
+ dy
, s
->width
, h
);
2519 w32_fill_area (s
->f
, s
->hdc
, s
->face
->overline_color
, s
->x
,
2520 s
->y
+ dy
, s
->width
, h
);
2524 /* Draw strike-through. */
2525 if (s
->face
->strike_through_p
2526 && (s
->font
->bdf
|| !s
->font
->tm
.tmStruckOut
))
2528 unsigned long h
= 1;
2529 unsigned long dy
= (s
->height
- h
) / 2;
2531 if (s
->face
->strike_through_color_defaulted_p
)
2533 w32_fill_area (s
->f
, s
->hdc
, s
->gc
->foreground
, s
->x
, s
->y
+ dy
,
2538 w32_fill_area (s
->f
, s
->hdc
, s
->face
->underline_color
, s
->x
,
2539 s
->y
+ dy
, s
->width
, h
);
2544 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2545 x_draw_glyph_string_box (s
);
2548 /* Reset clipping. */
2549 w32_set_clip_rectangle (s
->hdc
, NULL
);
2553 /* Shift display to make room for inserted glyphs. */
2556 w32_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
2558 int x
, y
, width
, height
, shift_by
;
2562 hdc
= get_frame_dc (f
);
2563 BitBlt (hdc
, x
+ shift_by
, y
, width
, height
,
2564 hdc
, x
, y
, SRCCOPY
);
2566 release_frame_dc (f
, hdc
);
2570 /* Delete N glyphs at the nominal cursor position. Not implemented
2582 f
= SELECTED_FRAME ();
2584 if (! FRAME_W32_P (f
))
2591 /* Clear entire frame. If updating_frame is non-null, clear that
2592 frame. Otherwise clear the selected frame. */
2602 f
= SELECTED_FRAME ();
2604 if (! FRAME_W32_P (f
))
2607 /* Clearing the frame will erase any cursor, so mark them all as no
2609 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2610 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2611 output_cursor
.x
= -1;
2613 /* We don't set the output cursor here because there will always
2614 follow an explicit cursor_to. */
2617 w32_clear_window (f
);
2619 /* We have to clear the scroll bars, too. If we have changed
2620 colors or something like that, then they should be notified. */
2621 x_scroll_bar_clear (f
);
2627 /* Make audible bell. */
2630 w32_ring_bell (void)
2634 f
= SELECTED_FRAME ();
2638 if (FRAME_W32_P (f
) && visible_bell
)
2641 HWND hwnd
= FRAME_W32_WINDOW (SELECTED_FRAME ());
2643 for (i
= 0; i
< 5; i
++)
2645 FlashWindow (hwnd
, TRUE
);
2648 FlashWindow (hwnd
, FALSE
);
2651 w32_sys_ring_bell ();
2657 /* Specify how many text lines, from the top of the window,
2658 should be affected by insert-lines and delete-lines operations.
2659 This, and those operations, are used only within an update
2660 that is bounded by calls to x_update_begin and x_update_end. */
2663 w32_set_terminal_window (n
)
2666 /* This function intentionally left blank. */
2670 /***********************************************************************
2672 ***********************************************************************/
2674 /* Perform an insert-lines or delete-lines operation, inserting N
2675 lines or deleting -N lines at vertical position VPOS. */
2678 x_ins_del_lines (vpos
, n
)
2686 f
= SELECTED_FRAME ();
2688 if (! FRAME_W32_P (f
))
2695 /* Scroll part of the display as described by RUN. */
2698 x_scroll_run (w
, run
)
2702 struct frame
*f
= XFRAME (w
->frame
);
2703 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
2704 HWND hwnd
= FRAME_W32_WINDOW (f
);
2707 /* Get frame-relative bounding box of the text display area of W,
2708 without mode lines. Include in this box the left and right
2710 window_box (w
, -1, &x
, &y
, &width
, &height
);
2712 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
2713 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
2714 bottom_y
= y
+ height
;
2718 /* Scrolling up. Make sure we don't copy part of the mode
2719 line at the bottom. */
2720 if (from_y
+ run
->height
> bottom_y
)
2721 height
= bottom_y
- from_y
;
2723 height
= run
->height
;
2724 expect_dirty
= CreateRectRgn (x
, y
+ height
, x
+ width
, bottom_y
);
2728 /* Scolling down. Make sure we don't copy over the mode line.
2730 if (to_y
+ run
->height
> bottom_y
)
2731 height
= bottom_y
- to_y
;
2733 height
= run
->height
;
2734 expect_dirty
= CreateRectRgn (x
, y
, x
+ width
, to_y
);
2739 /* Cursor off. Will be switched on again in x_update_window_end. */
2746 HRGN dirty
= CreateRectRgn (0, 0, 0, 0);
2747 HRGN combined
= CreateRectRgn (0, 0, 0, 0);
2749 from
.left
= to
.left
= x
;
2750 from
.right
= to
.right
= x
+ width
;
2752 from
.bottom
= from_y
+ height
;
2754 to
.bottom
= bottom_y
;
2756 ScrollWindowEx (hwnd
, 0, to_y
- from_y
, &from
, &to
, dirty
,
2757 NULL
, SW_INVALIDATE
);
2759 /* Combine this with what we expect to be dirty. This covers the
2760 case where not all of the region we expect is actually dirty. */
2761 CombineRgn (combined
, dirty
, expect_dirty
, RGN_OR
);
2763 /* If the dirty region is not what we expected, redraw the entire frame. */
2764 if (!EqualRgn (combined
, expect_dirty
))
2765 SET_FRAME_GARBAGED (f
);
2773 /***********************************************************************
2775 ***********************************************************************/
2781 x_update_cursor (f
, 1);
2785 frame_unhighlight (f
)
2788 x_update_cursor (f
, 1);
2791 /* The focus has changed. Update the frames as necessary to reflect
2792 the new situation. Note that we can't change the selected frame
2793 here, because the Lisp code we are interrupting might become confused.
2794 Each event gets marked with the frame in which it occurred, so the
2795 Lisp code can tell when the switch took place by examining the events. */
2798 x_new_focus_frame (dpyinfo
, frame
)
2799 struct w32_display_info
*dpyinfo
;
2800 struct frame
*frame
;
2802 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
2804 if (frame
!= dpyinfo
->w32_focus_frame
)
2806 /* Set this before calling other routines, so that they see
2807 the correct value of w32_focus_frame. */
2808 dpyinfo
->w32_focus_frame
= frame
;
2810 if (old_focus
&& old_focus
->auto_lower
)
2811 x_lower_frame (old_focus
);
2813 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
2814 pending_autoraise_frame
= dpyinfo
->w32_focus_frame
;
2816 pending_autoraise_frame
= 0;
2819 x_frame_rehighlight (dpyinfo
);
2822 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2825 x_mouse_leave (dpyinfo
)
2826 struct w32_display_info
*dpyinfo
;
2828 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_focus_event_frame
);
2831 /* The focus has changed, or we have redirected a frame's focus to
2832 another frame (this happens when a frame uses a surrogate
2833 mini-buffer frame). Shift the highlight as appropriate.
2835 The FRAME argument doesn't necessarily have anything to do with which
2836 frame is being highlighted or un-highlighted; we only use it to find
2837 the appropriate X display info. */
2840 w32_frame_rehighlight (frame
)
2841 struct frame
*frame
;
2843 if (! FRAME_W32_P (frame
))
2845 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
2849 x_frame_rehighlight (dpyinfo
)
2850 struct w32_display_info
*dpyinfo
;
2852 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
2854 if (dpyinfo
->w32_focus_frame
)
2856 dpyinfo
->x_highlight_frame
2857 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
2858 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
2859 : dpyinfo
->w32_focus_frame
);
2860 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
2862 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
2863 dpyinfo
->x_highlight_frame
= dpyinfo
->w32_focus_frame
;
2867 dpyinfo
->x_highlight_frame
= 0;
2869 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
2872 frame_unhighlight (old_highlight
);
2873 if (dpyinfo
->x_highlight_frame
)
2874 frame_highlight (dpyinfo
->x_highlight_frame
);
2878 /* Keyboard processing - modifier keys, etc. */
2880 /* Convert a keysym to its name. */
2883 x_get_keysym_name (keysym
)
2886 /* Make static so we can always return it */
2887 static char value
[100];
2890 GetKeyNameText (keysym
, value
, 100);
2898 /* Mouse clicks and mouse movement. Rah. */
2900 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2901 the state in PUP. XBUTTON provides extra information for extended mouse
2902 button messages. Returns FALSE if unable to parse the message. */
2904 parse_button (message
, xbutton
, pbutton
, pup
)
2915 case WM_LBUTTONDOWN
:
2923 case WM_MBUTTONDOWN
:
2924 if (NILP (Vw32_swap_mouse_buttons
))
2931 if (NILP (Vw32_swap_mouse_buttons
))
2937 case WM_RBUTTONDOWN
:
2938 if (NILP (Vw32_swap_mouse_buttons
))
2945 if (NILP (Vw32_swap_mouse_buttons
))
2951 case WM_XBUTTONDOWN
:
2952 button
= xbutton
+ 2;
2956 button
= xbutton
+ 2;
2964 if (pbutton
) *pbutton
= button
;
2970 /* Prepare a mouse-event in *RESULT for placement in the input queue.
2972 If the event is a button press, then note that we have grabbed
2976 construct_mouse_click (result
, msg
, f
)
2977 struct input_event
*result
;
2984 parse_button (msg
->msg
.message
, HIWORD (msg
->msg
.wParam
),
2987 /* Make the event type NO_EVENT; we'll change that when we decide
2989 result
->kind
= MOUSE_CLICK_EVENT
;
2990 result
->code
= button
;
2991 result
->timestamp
= msg
->msg
.time
;
2992 result
->modifiers
= (msg
->dwModifiers
2997 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
2998 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
2999 XSETFRAME (result
->frame_or_window
, f
);
3005 construct_mouse_wheel (result
, msg
, f
)
3006 struct input_event
*result
;
3013 result
->kind
= WHEEL_EVENT
;
3015 result
->timestamp
= msg
->msg
.time
;
3017 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3018 forward, away from the user (up); a negative value indicates that
3019 the wheel was rotated backward, toward the user (down). */
3020 delta
= GET_WHEEL_DELTA_WPARAM (msg
->msg
.wParam
);
3022 /* The up and down modifiers indicate if the wheel was rotated up or
3023 down based on WHEEL_DELTA value. */
3024 result
->modifiers
= (msg
->dwModifiers
3025 | ((delta
< 0 ) ? down_modifier
: up_modifier
));
3027 p
.x
= LOWORD (msg
->msg
.lParam
);
3028 p
.y
= HIWORD (msg
->msg
.lParam
);
3029 ScreenToClient (msg
->msg
.hwnd
, &p
);
3030 XSETINT (result
->x
, p
.x
);
3031 XSETINT (result
->y
, p
.y
);
3032 XSETFRAME (result
->frame_or_window
, f
);
3038 construct_drag_n_drop (result
, msg
, f
)
3039 struct input_event
*result
;
3051 result
->kind
= DRAG_N_DROP_EVENT
;
3053 result
->timestamp
= msg
->msg
.time
;
3054 result
->modifiers
= msg
->dwModifiers
;
3056 hdrop
= (HDROP
) msg
->msg
.wParam
;
3057 DragQueryPoint (hdrop
, &p
);
3060 p
.x
= LOWORD (msg
->msg
.lParam
);
3061 p
.y
= HIWORD (msg
->msg
.lParam
);
3062 ScreenToClient (msg
->msg
.hwnd
, &p
);
3065 XSETINT (result
->x
, p
.x
);
3066 XSETINT (result
->y
, p
.y
);
3068 num_files
= DragQueryFile (hdrop
, 0xFFFFFFFF, NULL
, 0);
3071 for (i
= 0; i
< num_files
; i
++)
3073 len
= DragQueryFile (hdrop
, i
, NULL
, 0);
3076 name
= alloca (len
+ 1);
3077 DragQueryFile (hdrop
, i
, name
, len
+ 1);
3078 files
= Fcons (DECODE_FILE (build_string (name
)), files
);
3083 XSETFRAME (frame
, f
);
3084 result
->frame_or_window
= Fcons (frame
, files
);
3090 /* Function to report a mouse movement to the mainstream Emacs code.
3091 The input handler calls this.
3093 We have received a mouse movement event, which is given in *event.
3094 If the mouse is over a different glyph than it was last time, tell
3095 the mainstream emacs code by setting mouse_moved. If not, ask for
3096 another motion event, so we can check again the next time it moves. */
3098 static MSG last_mouse_motion_event
;
3099 static Lisp_Object last_mouse_motion_frame
;
3101 static void remember_mouse_glyph
P_ ((struct frame
*, int, int));
3104 note_mouse_movement (frame
, msg
)
3108 int mouse_x
= LOWORD (msg
->lParam
);
3109 int mouse_y
= HIWORD (msg
->lParam
);
3111 last_mouse_movement_time
= msg
->time
;
3112 memcpy (&last_mouse_motion_event
, msg
, sizeof (last_mouse_motion_event
));
3113 XSETFRAME (last_mouse_motion_frame
, frame
);
3115 if (msg
->hwnd
!= FRAME_W32_WINDOW (frame
))
3117 frame
->mouse_moved
= 1;
3118 last_mouse_scroll_bar
= Qnil
;
3119 note_mouse_highlight (frame
, -1, -1);
3122 /* Has the mouse moved off the glyph it was on at the last sighting? */
3123 else if (mouse_x
< last_mouse_glyph
.left
3124 || mouse_x
> last_mouse_glyph
.right
3125 || mouse_y
< last_mouse_glyph
.top
3126 || mouse_y
> last_mouse_glyph
.bottom
)
3128 frame
->mouse_moved
= 1;
3129 last_mouse_scroll_bar
= Qnil
;
3130 note_mouse_highlight (frame
, mouse_x
, mouse_y
);
3131 /* Remember the mouse position here, as w32_mouse_position only
3132 gets called when mouse tracking is enabled but we also need
3133 to keep track of the mouse for help_echo and highlighting at
3135 remember_mouse_glyph (frame
, mouse_x
, mouse_y
);
3140 /************************************************************************
3142 ************************************************************************/
3144 static struct scroll_bar
*x_window_to_scroll_bar ();
3145 static void x_scroll_bar_report_motion ();
3146 static void x_check_fullscreen
P_ ((struct frame
*));
3147 static int glyph_rect
P_ ((struct frame
*f
, int, int, RECT
*));
3151 redo_mouse_highlight ()
3153 if (!NILP (last_mouse_motion_frame
)
3154 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3155 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3156 LOWORD (last_mouse_motion_event
.lParam
),
3157 HIWORD (last_mouse_motion_event
.lParam
));
3161 w32_define_cursor (window
, cursor
)
3165 PostMessage (window
, WM_EMACS_SETCURSOR
, (WPARAM
) cursor
, 0);
3168 /* Try to determine frame pixel position and size of the glyph under
3169 frame pixel coordinates X/Y on frame F . Return the position and
3170 size in *RECT. Value is non-zero if we could compute these
3174 glyph_rect (f
, x
, y
, rect
)
3181 window
= window_from_coordinates (f
, x
, y
, 0, &x
, &y
, 0);
3185 struct window
*w
= XWINDOW (window
);
3186 struct glyph_row
*r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
3187 struct glyph_row
*end
= r
+ w
->current_matrix
->nrows
- 1;
3189 for (; r
< end
&& r
->enabled_p
; ++r
)
3190 if (r
->y
<= y
&& r
->y
+ r
->height
> y
)
3192 /* Found the row at y. */
3193 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
3194 struct glyph
*end
= g
+ r
->used
[TEXT_AREA
];
3197 rect
->top
= WINDOW_TO_FRAME_PIXEL_Y (w
, r
->y
);
3198 rect
->bottom
= rect
->top
+ r
->height
;
3202 /* x is to the left of the first glyph in the row. */
3203 /* Shouldn't this be a pixel value?
3204 WINDOW_LEFT_EDGE_X (w) seems to be the right value.
3206 rect
->left
= WINDOW_LEFT_EDGE_COL (w
);
3207 rect
->right
= WINDOW_TO_FRAME_PIXEL_X (w
, r
->x
);
3211 for (gx
= r
->x
; g
< end
; gx
+= g
->pixel_width
, ++g
)
3212 if (gx
<= x
&& gx
+ g
->pixel_width
> x
)
3214 /* x is on a glyph. */
3215 rect
->left
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
3216 rect
->right
= rect
->left
+ g
->pixel_width
;
3220 /* x is to the right of the last glyph in the row. */
3221 rect
->left
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
3222 /* Shouldn't this be a pixel value?
3223 WINDOW_RIGHT_EDGE_X (w) seems to be the right value.
3225 rect
->right
= WINDOW_RIGHT_EDGE_COL (w
);
3230 /* The y is not on any row. */
3234 /* Record the position of the mouse in last_mouse_glyph. */
3236 remember_mouse_glyph (f1
, gx
, gy
)
3240 if (!glyph_rect (f1
, gx
, gy
, &last_mouse_glyph
))
3242 int width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
3243 int height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
3245 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
3246 round down even for negative values. */
3252 /* This was the original code from XTmouse_position, but it seems
3253 to give the position of the glyph diagonally next to the one
3254 the mouse is over. */
3255 gx
= (gx
+ width
- 1) / width
* width
;
3256 gy
= (gy
+ height
- 1) / height
* height
;
3258 gx
= gx
/ width
* width
;
3259 gy
= gy
/ height
* height
;
3262 last_mouse_glyph
.left
= gx
;
3263 last_mouse_glyph
.top
= gy
;
3264 last_mouse_glyph
.right
= gx
+ width
;
3265 last_mouse_glyph
.bottom
= gy
+ height
;
3269 /* Return the current position of the mouse.
3270 *fp should be a frame which indicates which display to ask about.
3272 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3273 and *part to the frame, window, and scroll bar part that the mouse
3274 is over. Set *x and *y to the portion and whole of the mouse's
3275 position on the scroll bar.
3277 If the mouse movement started elsewhere, set *fp to the frame the
3278 mouse is on, *bar_window to nil, and *x and *y to the character cell
3281 Set *time to the server time-stamp for the time at which the mouse
3282 was at this position.
3284 Don't store anything if we don't have a valid set of values to report.
3286 This clears the mouse_moved flag, so we can wait for the next mouse
3290 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3293 Lisp_Object
*bar_window
;
3294 enum scroll_bar_part
*part
;
3296 unsigned long *time
;
3302 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3303 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3308 Lisp_Object frame
, tail
;
3310 /* Clear the mouse-moved flag for every frame on this display. */
3311 FOR_EACH_FRAME (tail
, frame
)
3312 XFRAME (frame
)->mouse_moved
= 0;
3314 last_mouse_scroll_bar
= Qnil
;
3318 /* Now we have a position on the root; find the innermost window
3319 containing the pointer. */
3321 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3322 && FRAME_LIVE_P (last_mouse_frame
))
3324 /* If mouse was grabbed on a frame, give coords for that frame
3325 even if the mouse is now outside it. */
3326 f1
= last_mouse_frame
;
3330 /* Is window under mouse one of our frames? */
3331 f1
= x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
),
3332 WindowFromPoint (pt
));
3335 /* If not, is it one of our scroll bars? */
3338 struct scroll_bar
*bar
3339 = x_window_to_scroll_bar (WindowFromPoint (pt
));
3343 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3347 if (f1
== 0 && insist
> 0)
3348 f1
= SELECTED_FRAME ();
3352 /* Ok, we found a frame. Store all the values.
3353 last_mouse_glyph is a rectangle used to reduce the
3354 generation of mouse events. To not miss any motion
3355 events, we must divide the frame into rectangles of the
3356 size of the smallest character that could be displayed
3357 on it, i.e. into the same rectangles that matrices on
3358 the frame are divided into. */
3360 #if OLD_REDISPLAY_CODE
3361 int ignore1
, ignore2
;
3363 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3365 pixel_to_glyph_coords (f1
, pt
.x
, pt
.y
, &ignore1
, &ignore2
,
3367 FRAME_W32_DISPLAY_INFO (f1
)->grabbed
3370 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
3371 remember_mouse_glyph (f1
, pt
.x
, pt
.y
);
3379 *time
= last_mouse_movement_time
;
3388 /***********************************************************************
3390 ***********************************************************************/
3392 /* Handle mouse button event on the tool-bar of frame F, at
3393 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
3397 w32_handle_tool_bar_click (f
, button_event
)
3399 struct input_event
*button_event
;
3401 int x
= XFASTINT (button_event
->x
);
3402 int y
= XFASTINT (button_event
->y
);
3404 if (button_event
->modifiers
& down_modifier
)
3405 handle_tool_bar_click (f
, x
, y
, 1, 0);
3407 handle_tool_bar_click (f
, x
, y
, 0,
3408 button_event
->modifiers
& ~up_modifier
);
3413 /***********************************************************************
3415 ***********************************************************************/
3417 /* Scroll bar support. */
3419 /* Given a window ID, find the struct scroll_bar which manages it.
3420 This can be called in GC, so we have to make sure to strip off mark
3423 static struct scroll_bar
*
3424 x_window_to_scroll_bar (window_id
)
3429 for (tail
= Vframe_list
;
3430 XGCTYPE (tail
) == Lisp_Cons
;
3433 Lisp_Object frame
, bar
, condemned
;
3435 frame
= XCAR (tail
);
3436 /* All elements of Vframe_list should be frames. */
3437 if (! GC_FRAMEP (frame
))
3440 /* Scan this frame's scroll bar list for a scroll bar with the
3442 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3443 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3444 /* This trick allows us to search both the ordinary and
3445 condemned scroll bar lists with one loop. */
3446 ! GC_NILP (bar
) || (bar
= condemned
,
3449 bar
= XSCROLL_BAR (bar
)->next
)
3450 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
3451 return XSCROLL_BAR (bar
);
3459 /* Set the thumb size and position of scroll bar BAR. We are currently
3460 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3463 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
)
3464 struct scroll_bar
*bar
;
3465 int portion
, position
, whole
;
3467 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
3468 double range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
3469 int sb_page
, sb_pos
;
3470 BOOL draggingp
= !NILP (bar
->dragging
) ? TRUE
: FALSE
;
3474 /* Position scroll bar at rock bottom if the bottom of the
3475 buffer is visible. This avoids shinking the thumb away
3476 to nothing if it is held at the bottom of the buffer. */
3477 if (position
+ portion
>= whole
)
3479 sb_page
= range
* (whole
- position
) / whole
3480 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3484 sb_page
= portion
* range
/ whole
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3485 sb_pos
= position
* range
/ whole
;
3495 if (pfnSetScrollInfo
)
3499 si
.cbSize
= sizeof (si
);
3500 /* Only update page size if currently dragging, to reduce
3503 si
.fMask
= SIF_PAGE
;
3505 si
.fMask
= SIF_PAGE
| SIF_POS
;
3509 pfnSetScrollInfo (w
, SB_CTL
, &si
, !draggingp
);
3512 SetScrollPos (w
, SB_CTL
, sb_pos
, !draggingp
);
3518 /************************************************************************
3519 Scroll bars, general
3520 ************************************************************************/
3523 my_create_scrollbar (f
, bar
)
3525 struct scroll_bar
* bar
;
3527 return (HWND
) SendMessage (FRAME_W32_WINDOW (f
),
3528 WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
3532 /*#define ATTACH_THREADS*/
3535 my_show_window (FRAME_PTR f
, HWND hwnd
, int how
)
3537 #ifndef ATTACH_THREADS
3538 return SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SHOWWINDOW
,
3539 (WPARAM
) hwnd
, (LPARAM
) how
);
3541 return ShowWindow (hwnd
, how
);
3546 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
3547 int x
, int y
, int cx
, int cy
, UINT flags
)
3549 #ifndef ATTACH_THREADS
3551 pos
.hwndInsertAfter
= hwndAfter
;
3557 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
3559 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
3564 my_set_focus (f
, hwnd
)
3568 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_SETFOCUS
,
3573 my_set_foreground_window (hwnd
)
3576 SendMessage (hwnd
, WM_EMACS_SETFOREGROUND
, (WPARAM
) hwnd
, 0);
3580 my_destroy_window (f
, hwnd
)
3584 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
3588 /* Create a scroll bar and return the scroll bar vector for it. W is
3589 the Emacs window on which to create the scroll bar. TOP, LEFT,
3590 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
3593 static struct scroll_bar
*
3594 x_scroll_bar_create (w
, top
, left
, width
, height
)
3596 int top
, left
, width
, height
;
3598 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
3600 struct scroll_bar
*bar
3601 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
3605 XSETWINDOW (bar
->window
, w
);
3606 XSETINT (bar
->top
, top
);
3607 XSETINT (bar
->left
, left
);
3608 XSETINT (bar
->width
, width
);
3609 XSETINT (bar
->height
, height
);
3610 XSETINT (bar
->start
, 0);
3611 XSETINT (bar
->end
, 0);
3612 bar
->dragging
= Qnil
;
3614 /* Requires geometry to be set before call to create the real window */
3616 hwnd
= my_create_scrollbar (f
, bar
);
3618 if (pfnSetScrollInfo
)
3622 si
.cbSize
= sizeof (si
);
3625 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3626 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3630 pfnSetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3634 SetScrollRange (hwnd
, SB_CTL
, 0,
3635 VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
), FALSE
);
3636 SetScrollPos (hwnd
, SB_CTL
, 0, FALSE
);
3639 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
3641 /* Add bar to its frame's list of scroll bars. */
3642 bar
->next
= FRAME_SCROLL_BARS (f
);
3644 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
3645 if (! NILP (bar
->next
))
3646 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3654 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3658 x_scroll_bar_remove (bar
)
3659 struct scroll_bar
*bar
;
3661 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3665 /* Destroy the window. */
3666 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
3668 /* Disassociate this scroll bar from its window. */
3669 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
3674 /* Set the handle of the vertical scroll bar for WINDOW to indicate
3675 that we are displaying PORTION characters out of a total of WHOLE
3676 characters, starting at POSITION. If WINDOW has no scroll bar,
3679 w32_set_vertical_scroll_bar (w
, portion
, whole
, position
)
3681 int portion
, whole
, position
;
3683 struct frame
*f
= XFRAME (w
->frame
);
3684 struct scroll_bar
*bar
;
3685 int top
, height
, left
, sb_left
, width
, sb_width
;
3686 int window_y
, window_height
;
3688 /* Get window dimensions. */
3689 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
3691 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
3692 height
= window_height
;
3694 /* Compute the left edge of the scroll bar area. */
3695 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
3697 /* Compute the width of the scroll bar which might be less than
3698 the width of the area reserved for the scroll bar. */
3699 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
3700 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
3704 /* Compute the left edge of the scroll bar. */
3705 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
3706 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
3708 sb_left
= left
+ (width
- sb_width
) / 2;
3710 /* Does the scroll bar exist yet? */
3711 if (NILP (w
->vertical_scroll_bar
))
3715 if (width
> 0 && height
> 0)
3717 hdc
= get_frame_dc (f
);
3718 w32_clear_area (f
, hdc
, left
, top
, width
, height
);
3719 release_frame_dc (f
, hdc
);
3723 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
3727 /* It may just need to be moved and resized. */
3730 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
3731 hwnd
= SCROLL_BAR_W32_WINDOW (bar
);
3733 /* If already correctly positioned, do nothing. */
3734 if ( XINT (bar
->left
) == sb_left
3735 && XINT (bar
->top
) == top
3736 && XINT (bar
->width
) == sb_width
3737 && XINT (bar
->height
) == height
)
3739 /* Redraw after clear_frame. */
3740 if (!my_show_window (f
, hwnd
, SW_NORMAL
))
3741 InvalidateRect (hwnd
, NULL
, FALSE
);
3747 if (width
&& height
)
3749 hdc
= get_frame_dc (f
);
3750 /* Since Windows scroll bars are smaller than the space reserved
3751 for them on the frame, we have to clear "under" them. */
3752 w32_clear_area (f
, hdc
,
3757 release_frame_dc (f
, hdc
);
3759 /* Make sure scroll bar is "visible" before moving, to ensure the
3760 area of the parent window now exposed will be refreshed. */
3761 my_show_window (f
, hwnd
, SW_HIDE
);
3762 MoveWindow (hwnd
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
3763 top
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
3764 max (height
, 1), TRUE
);
3765 if (pfnSetScrollInfo
)
3769 si
.cbSize
= sizeof (si
);
3770 si
.fMask
= SIF_RANGE
;
3772 si
.nMax
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
)
3773 + VERTICAL_SCROLL_BAR_MIN_HANDLE
;
3775 pfnSetScrollInfo (hwnd
, SB_CTL
, &si
, FALSE
);
3778 SetScrollRange (hwnd
, SB_CTL
, 0,
3779 VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
), FALSE
);
3780 my_show_window (f
, hwnd
, SW_NORMAL
);
3781 /* InvalidateRect (w, NULL, FALSE); */
3783 /* Remember new settings. */
3784 XSETINT (bar
->left
, sb_left
);
3785 XSETINT (bar
->top
, top
);
3786 XSETINT (bar
->width
, sb_width
);
3787 XSETINT (bar
->height
, height
);
3792 w32_set_scroll_bar_thumb (bar
, portion
, position
, whole
);
3794 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
3798 /* The following three hooks are used when we're doing a thorough
3799 redisplay of the frame. We don't explicitly know which scroll bars
3800 are going to be deleted, because keeping track of when windows go
3801 away is a real pain - "Can you say set-window-configuration, boys
3802 and girls?" Instead, we just assert at the beginning of redisplay
3803 that *all* scroll bars are to be removed, and then save a scroll bar
3804 from the fiery pit when we actually redisplay its window. */
3806 /* Arrange for all scroll bars on FRAME to be removed at the next call
3807 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
3808 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
3811 w32_condemn_scroll_bars (frame
)
3814 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
3815 while (! NILP (FRAME_SCROLL_BARS (frame
)))
3818 bar
= FRAME_SCROLL_BARS (frame
);
3819 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
3820 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
3821 XSCROLL_BAR (bar
)->prev
= Qnil
;
3822 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
3823 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
3824 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
3829 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
3830 Note that WINDOW isn't necessarily condemned at all. */
3833 w32_redeem_scroll_bar (window
)
3834 struct window
*window
;
3836 struct scroll_bar
*bar
;
3839 /* We can't redeem this window's scroll bar if it doesn't have one. */
3840 if (NILP (window
->vertical_scroll_bar
))
3843 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
3845 /* Unlink it from the condemned list. */
3846 f
= XFRAME (WINDOW_FRAME (window
));
3847 if (NILP (bar
->prev
))
3849 /* If the prev pointer is nil, it must be the first in one of
3851 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
3852 /* It's not condemned. Everything's fine. */
3854 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
3855 window
->vertical_scroll_bar
))
3856 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
3858 /* If its prev pointer is nil, it must be at the front of
3859 one or the other! */
3863 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
3865 if (! NILP (bar
->next
))
3866 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
3868 bar
->next
= FRAME_SCROLL_BARS (f
);
3870 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
3871 if (! NILP (bar
->next
))
3872 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
3875 /* Remove all scroll bars on FRAME that haven't been saved since the
3876 last call to `*condemn_scroll_bars_hook'. */
3879 w32_judge_scroll_bars (f
)
3882 Lisp_Object bar
, next
;
3884 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
3886 /* Clear out the condemned list now so we won't try to process any
3887 more events on the hapless scroll bars. */
3888 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
3890 for (; ! NILP (bar
); bar
= next
)
3892 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
3894 x_scroll_bar_remove (b
);
3897 b
->next
= b
->prev
= Qnil
;
3900 /* Now there should be no references to the condemned scroll bars,
3901 and they should get garbage-collected. */
3904 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
3905 is set to something other than NO_EVENT, it is enqueued.
3907 This may be called from a signal handler, so we have to ignore GC
3911 w32_scroll_bar_handle_click (bar
, msg
, emacs_event
)
3912 struct scroll_bar
*bar
;
3914 struct input_event
*emacs_event
;
3916 if (! GC_WINDOWP (bar
->window
))
3919 emacs_event
->kind
= W32_SCROLL_BAR_CLICK_EVENT
;
3920 emacs_event
->code
= 0;
3921 /* not really meaningful to distinguish up/down */
3922 emacs_event
->modifiers
= msg
->dwModifiers
;
3923 emacs_event
->frame_or_window
= bar
->window
;
3924 emacs_event
->arg
= Qnil
;
3925 emacs_event
->timestamp
= msg
->msg
.time
;
3928 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
3930 int dragging
= !NILP (bar
->dragging
);
3932 if (pfnGetScrollInfo
)
3936 si
.cbSize
= sizeof (si
);
3939 pfnGetScrollInfo ((HWND
) msg
->msg
.lParam
, SB_CTL
, &si
);
3943 y
= GetScrollPos ((HWND
) msg
->msg
.lParam
, SB_CTL
);
3945 bar
->dragging
= Qnil
;
3948 last_mouse_scroll_bar_pos
= msg
->msg
.wParam
;
3950 switch (LOWORD (msg
->msg
.wParam
))
3953 emacs_event
->part
= scroll_bar_down_arrow
;
3956 emacs_event
->part
= scroll_bar_up_arrow
;
3959 emacs_event
->part
= scroll_bar_above_handle
;
3962 emacs_event
->part
= scroll_bar_below_handle
;
3965 emacs_event
->part
= scroll_bar_handle
;
3969 emacs_event
->part
= scroll_bar_handle
;
3973 case SB_THUMBPOSITION
:
3974 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
3975 y
= HIWORD (msg
->msg
.wParam
);
3977 emacs_event
->part
= scroll_bar_handle
;
3979 /* "Silently" update current position. */
3980 if (pfnSetScrollInfo
)
3984 si
.cbSize
= sizeof (si
);
3987 /* Remember apparent position (we actually lag behind the real
3988 position, so don't set that directly. */
3989 last_scroll_bar_drag_pos
= y
;
3991 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, FALSE
);
3994 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, FALSE
);
3997 /* If this is the end of a drag sequence, then reset the scroll
3998 handle size to normal and do a final redraw. Otherwise do
4002 if (pfnSetScrollInfo
)
4005 int start
= XINT (bar
->start
);
4006 int end
= XINT (bar
->end
);
4008 si
.cbSize
= sizeof (si
);
4009 si
.fMask
= SIF_PAGE
| SIF_POS
;
4010 si
.nPage
= end
- start
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4011 si
.nPos
= last_scroll_bar_drag_pos
;
4012 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, &si
, TRUE
);
4015 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, TRUE
);
4019 emacs_event
->kind
= NO_EVENT
;
4023 XSETINT (emacs_event
->x
, y
);
4024 XSETINT (emacs_event
->y
, top_range
);
4030 /* Return information to the user about the current position of the mouse
4031 on the scroll bar. */
4034 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
4036 Lisp_Object
*bar_window
;
4037 enum scroll_bar_part
*part
;
4039 unsigned long *time
;
4041 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
4042 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
4043 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4045 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4050 *bar_window
= bar
->window
;
4052 if (pfnGetScrollInfo
)
4056 si
.cbSize
= sizeof (si
);
4057 si
.fMask
= SIF_POS
| SIF_PAGE
| SIF_RANGE
;
4059 pfnGetScrollInfo (w
, SB_CTL
, &si
);
4061 top_range
= si
.nMax
- si
.nPage
+ 1;
4064 pos
= GetScrollPos (w
, SB_CTL
);
4066 switch (LOWORD (last_mouse_scroll_bar_pos
))
4068 case SB_THUMBPOSITION
:
4070 *part
= scroll_bar_handle
;
4071 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
)) <= 0xffff)
4072 pos
= HIWORD (last_mouse_scroll_bar_pos
);
4075 *part
= scroll_bar_handle
;
4079 *part
= scroll_bar_handle
;
4084 XSETINT (*y
, top_range
);
4087 last_mouse_scroll_bar
= Qnil
;
4089 *time
= last_mouse_movement_time
;
4095 /* The screen has been cleared so we may have changed foreground or
4096 background colors, and the scroll bars may need to be redrawn.
4097 Clear out the scroll bars, and ask for expose events, so we can
4101 x_scroll_bar_clear (f
)
4106 /* We can have scroll bars even if this is 0,
4107 if we just turned off scroll bar mode.
4108 But in that case we should not clear them. */
4109 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
4110 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
4111 bar
= XSCROLL_BAR (bar
)->next
)
4113 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
4114 HDC hdc
= GetDC (window
);
4117 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4118 arranges to refresh the scroll bar if hidden. */
4119 my_show_window (f
, window
, SW_HIDE
);
4121 GetClientRect (window
, &rect
);
4122 select_palette (f
, hdc
);
4123 w32_clear_rect (f
, hdc
, &rect
);
4124 deselect_palette (f
, hdc
);
4126 ReleaseDC (window
, hdc
);
4131 /* The main W32 event-reading loop - w32_read_socket. */
4133 /* Record the last 100 characters stored
4134 to help debug the loss-of-chars-during-GC problem. */
4136 static int temp_index
;
4137 static short temp_buffer
[100];
4140 /* Read events coming from the W32 shell.
4141 This routine is called by the SIGIO handler.
4142 We return as soon as there are no more events to be read.
4144 We return the number of characters stored into the buffer,
4145 thus pretending to be `read'.
4147 EXPECTED is nonzero if the caller knows input is available.
4149 Some of these messages are reposted back to the message queue since the
4150 system calls the windows proc directly in a context where we cannot return
4151 the data nor can we guarantee the state we are in. So if we dispatch them
4152 we will get into an infinite loop. To prevent this from ever happening we
4153 will set a variable to indicate we are in the read_socket call and indicate
4154 which message we are processing since the windows proc gets called
4155 recursively with different messages by the system.
4159 w32_read_socket (sd
, expected
, hold_quit
)
4162 struct input_event
*hold_quit
;
4165 int check_visibility
= 0;
4168 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
4170 if (interrupt_input_blocked
)
4172 interrupt_input_pending
= 1;
4176 interrupt_input_pending
= 0;
4179 /* So people can tell when we have read the available input. */
4180 input_signal_count
++;
4182 /* TODO: ghostscript integration. */
4183 while (get_next_msg (&msg
, FALSE
))
4185 struct input_event inev
;
4189 inev
.kind
= NO_EVENT
;
4192 switch (msg
.msg
.message
)
4195 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4199 if (msg
.rect
.right
== msg
.rect
.left
||
4200 msg
.rect
.bottom
== msg
.rect
.top
)
4202 /* We may get paint messages even though the client
4203 area is clipped - these are not expose events. */
4204 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f
,
4207 else if (f
->async_visible
!= 1)
4209 /* Definitely not obscured, so mark as visible. */
4210 f
->async_visible
= 1;
4211 f
->async_iconified
= 0;
4212 SET_FRAME_GARBAGED (f
);
4213 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f
,
4216 /* WM_PAINT serves as MapNotify as well, so report
4217 visibility changes properly. */
4220 inev
.kind
= DEICONIFY_EVENT
;
4221 XSETFRAME (inev
.frame_or_window
, f
);
4223 else if (! NILP (Vframe_list
)
4224 && ! NILP (XCDR (Vframe_list
)))
4225 /* Force a redisplay sooner or later to update the
4226 frame titles in case this is the second frame. */
4227 record_asynch_buffer_change ();
4231 HDC hdc
= get_frame_dc (f
);
4233 /* Erase background again for safety. */
4234 w32_clear_rect (f
, hdc
, &msg
.rect
);
4235 release_frame_dc (f
, hdc
);
4239 msg
.rect
.right
- msg
.rect
.left
,
4240 msg
.rect
.bottom
- msg
.rect
.top
);
4245 case WM_INPUTLANGCHANGE
:
4246 /* Generate a language change event. */
4247 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4251 inev
.kind
= LANGUAGE_CHANGE_EVENT
;
4252 XSETFRAME (inev
.frame_or_window
, f
);
4253 inev
.code
= msg
.msg
.wParam
;
4254 inev
.modifiers
= msg
.msg
.lParam
& 0xffff;
4260 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4262 if (f
&& !f
->iconified
)
4264 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
4266 clear_mouse_face (dpyinfo
);
4267 dpyinfo
->mouse_face_hidden
= 1;
4270 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4272 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4273 inev
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
4274 inev
.code
= msg
.msg
.wParam
;
4275 inev
.modifiers
= msg
.dwModifiers
;
4276 XSETFRAME (inev
.frame_or_window
, f
);
4277 inev
.timestamp
= msg
.msg
.time
;
4283 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4285 if (f
&& !f
->iconified
)
4287 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
4289 clear_mouse_face (dpyinfo
);
4290 dpyinfo
->mouse_face_hidden
= 1;
4293 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
4295 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
4296 inev
.kind
= ASCII_KEYSTROKE_EVENT
;
4297 inev
.code
= msg
.msg
.wParam
;
4298 inev
.modifiers
= msg
.dwModifiers
;
4299 XSETFRAME (inev
.frame_or_window
, f
);
4300 inev
.timestamp
= msg
.msg
.time
;
4305 /* Ignore non-movement. */
4307 int x
= LOWORD (msg
.msg
.lParam
);
4308 int y
= HIWORD (msg
.msg
.lParam
);
4309 if (x
== last_mousemove_x
&& y
== last_mousemove_y
)
4311 last_mousemove_x
= x
;
4312 last_mousemove_y
= y
;
4315 previous_help_echo_string
= help_echo_string
;
4317 if (dpyinfo
->grabbed
&& last_mouse_frame
4318 && FRAME_LIVE_P (last_mouse_frame
))
4319 f
= last_mouse_frame
;
4321 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4323 if (dpyinfo
->mouse_face_hidden
)
4325 dpyinfo
->mouse_face_hidden
= 0;
4326 clear_mouse_face (dpyinfo
);
4331 /* Generate SELECT_WINDOW_EVENTs when needed. */
4332 if (mouse_autoselect_window
)
4335 int x
= LOWORD (msg
.msg
.lParam
);
4336 int y
= HIWORD (msg
.msg
.lParam
);
4338 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 0);
4340 /* Window will be selected only when it is not
4341 selected now and last mouse movement event was
4342 not in it. Minibuffer window will be selected
4343 iff it is active. */
4345 && !EQ (window
, last_window
)
4346 && !EQ (window
, selected_window
))
4348 inev
.kind
= SELECT_WINDOW_EVENT
;
4349 inev
.frame_or_window
= window
;
4354 note_mouse_movement (f
, &msg
.msg
);
4358 /* If we move outside the frame, then we're
4359 certainly no longer on any text in the frame. */
4360 clear_mouse_face (dpyinfo
);
4363 /* If the contents of the global variable help_echo_string
4364 has changed, generate a HELP_EVENT. */
4365 #if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE.
4366 But it was originally changed to this to fix a bug, so I have
4367 not removed it completely in case the bug is still there. */
4368 if (help_echo_string
!= previous_help_echo_string
||
4369 (!NILP (help_echo_string
) && !STRINGP (help_echo_string
) && f
->mouse_moved
))
4370 #else /* This is what xterm.c does. */
4371 if (!NILP (help_echo_string
)
4372 || !NILP (previous_help_echo_string
))
4377 case WM_LBUTTONDOWN
:
4379 case WM_MBUTTONDOWN
:
4381 case WM_RBUTTONDOWN
:
4383 case WM_XBUTTONDOWN
:
4386 /* If we decide we want to generate an event to be seen
4387 by the rest of Emacs, we put it here. */
4392 if (dpyinfo
->grabbed
&& last_mouse_frame
4393 && FRAME_LIVE_P (last_mouse_frame
))
4394 f
= last_mouse_frame
;
4396 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4400 construct_mouse_click (&inev
, &msg
, f
);
4402 /* Is this in the tool-bar? */
4403 if (WINDOWP (f
->tool_bar_window
)
4404 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
4407 int x
= XFASTINT (inev
.x
);
4408 int y
= XFASTINT (inev
.y
);
4410 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
4412 if (EQ (window
, f
->tool_bar_window
))
4414 w32_handle_tool_bar_click (f
, &inev
);
4420 || (dpyinfo
->w32_focus_frame
4421 && f
!= dpyinfo
->w32_focus_frame
))
4422 inev
.kind
= NO_EVENT
;
4425 parse_button (msg
.msg
.message
, HIWORD (msg
.msg
.wParam
),
4430 dpyinfo
->grabbed
&= ~ (1 << button
);
4434 dpyinfo
->grabbed
|= (1 << button
);
4435 last_mouse_frame
= f
;
4436 /* Ignore any mouse motion that happened
4437 before this event; any subsequent mouse-movement
4438 Emacs events should reflect only motion after
4444 last_tool_bar_item
= -1;
4451 if (dpyinfo
->grabbed
&& last_mouse_frame
4452 && FRAME_LIVE_P (last_mouse_frame
))
4453 f
= last_mouse_frame
;
4455 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4460 if (!dpyinfo
->w32_focus_frame
4461 || f
== dpyinfo
->w32_focus_frame
)
4463 /* Emit an Emacs wheel-up/down event. */
4464 construct_mouse_wheel (&inev
, &msg
, f
);
4466 /* Ignore any mouse motion that happened before this
4467 event; any subsequent mouse-movement Emacs events
4468 should reflect only motion after the
4472 last_mouse_frame
= f
;
4473 last_tool_bar_item
= -1;
4478 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4481 construct_drag_n_drop (&inev
, &msg
, f
);
4486 struct scroll_bar
*bar
=
4487 x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
4490 w32_scroll_bar_handle_click (bar
, &msg
, &inev
);
4494 case WM_WINDOWPOSCHANGED
:
4495 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4498 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
4499 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
4501 check_visibility
= 1;
4505 case WM_ACTIVATEAPP
:
4506 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4508 x_check_fullscreen (f
);
4509 check_visibility
= 1;
4513 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4515 if (f
&& !f
->async_iconified
)
4519 x_real_positions (f
, &x
, &y
);
4524 check_visibility
= 1;
4528 /* wParam non-zero means Window is about to be shown, 0 means
4529 about to be hidden. */
4530 /* Redo the mouse-highlight after the tooltip has gone. */
4531 if (!msg
.msg
.wParam
&& msg
.msg
.hwnd
== tip_window
)
4534 redo_mouse_highlight ();
4537 /* If window has been obscured or exposed by another window
4538 being maximised or minimised/restored, then recheck
4539 visibility of all frames. Direct changes to our own
4540 windows get handled by WM_SIZE. */
4542 if (msg
.msg
.lParam
!= 0)
4543 check_visibility
= 1;
4546 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4547 f
->async_visible
= msg
.msg
.wParam
;
4551 check_visibility
= 1;
4555 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4557 /* Inform lisp of whether frame has been iconified etc. */
4560 switch (msg
.msg
.wParam
)
4562 case SIZE_MINIMIZED
:
4563 f
->async_visible
= 0;
4564 f
->async_iconified
= 1;
4566 inev
.kind
= ICONIFY_EVENT
;
4567 XSETFRAME (inev
.frame_or_window
, f
);
4570 case SIZE_MAXIMIZED
:
4572 f
->async_visible
= 1;
4573 f
->async_iconified
= 0;
4575 /* wait_reading_process_output will notice this and update
4576 the frame's display structures. */
4577 SET_FRAME_GARBAGED (f
);
4583 /* Reset top and left positions of the Window
4584 here since Windows sends a WM_MOVE message
4585 BEFORE telling us the Window is minimized
4586 when the Window is iconified, with 3000,3000
4588 x_real_positions (f
, &x
, &y
);
4592 inev
.kind
= DEICONIFY_EVENT
;
4593 XSETFRAME (inev
.frame_or_window
, f
);
4595 else if (! NILP (Vframe_list
)
4596 && ! NILP (XCDR (Vframe_list
)))
4597 /* Force a redisplay sooner or later
4598 to update the frame titles
4599 in case this is the second frame. */
4600 record_asynch_buffer_change ();
4605 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
4613 GetClientRect (msg
.msg
.hwnd
, &rect
);
4615 height
= rect
.bottom
- rect
.top
;
4616 width
= rect
.right
- rect
.left
;
4618 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
4619 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
4621 /* TODO: Clip size to the screen dimensions. */
4623 /* Even if the number of character rows and columns has
4624 not changed, the font size may have changed, so we need
4625 to check the pixel dimensions as well. */
4627 if (columns
!= FRAME_COLS (f
)
4628 || rows
!= FRAME_LINES (f
)
4629 || width
!= FRAME_PIXEL_WIDTH (f
)
4630 || height
!= FRAME_PIXEL_HEIGHT (f
))
4632 change_frame_size (f
, rows
, columns
, 0, 1, 0);
4633 SET_FRAME_GARBAGED (f
);
4634 cancel_mouse_face (f
);
4635 FRAME_PIXEL_WIDTH (f
) = width
;
4636 FRAME_PIXEL_HEIGHT (f
) = height
;
4637 f
->win_gravity
= NorthWestGravity
;
4641 check_visibility
= 1;
4645 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4648 if (f
== dpyinfo
->mouse_face_mouse_frame
)
4650 /* If we move outside the frame, then we're
4651 certainly no longer on any text in the frame. */
4652 clear_mouse_face (dpyinfo
);
4653 dpyinfo
->mouse_face_mouse_frame
= 0;
4656 /* Generate a nil HELP_EVENT to cancel a help-echo.
4657 Do it only if there's something to cancel.
4658 Otherwise, the startup message is cleared when
4659 the mouse leaves the frame. */
4660 if (any_help_event_p
)
4666 /* TODO: Port this change:
4667 2002-06-28 Jan D. <jan.h.d@swipnet.se>
4668 * xterm.h (struct x_output): Add focus_state.
4669 * xterm.c (x_focus_changed): New function.
4670 (x_detect_focus_change): New function.
4671 (XTread_socket): Call x_detect_focus_change for FocusIn/FocusOut
4672 EnterNotify and LeaveNotify to track X focus changes.
4674 f
= x_any_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4676 dpyinfo
->w32_focus_event_frame
= f
;
4679 x_new_focus_frame (dpyinfo
, f
);
4681 dpyinfo
->grabbed
= 0;
4682 check_visibility
= 1;
4686 /* TODO: some of this belongs in MOUSE_LEAVE */
4687 f
= x_top_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4691 if (f
== dpyinfo
->w32_focus_event_frame
)
4692 dpyinfo
->w32_focus_event_frame
= 0;
4694 if (f
== dpyinfo
->w32_focus_frame
)
4695 x_new_focus_frame (dpyinfo
, 0);
4697 if (f
== dpyinfo
->mouse_face_mouse_frame
)
4699 /* If we move outside the frame, then we're
4700 certainly no longer on any text in the frame. */
4701 clear_mouse_face (dpyinfo
);
4702 dpyinfo
->mouse_face_mouse_frame
= 0;
4705 /* Generate a nil HELP_EVENT to cancel a help-echo.
4706 Do it only if there's something to cancel.
4707 Otherwise, the startup message is cleared when
4708 the mouse leaves the frame. */
4709 if (any_help_event_p
)
4713 dpyinfo
->grabbed
= 0;
4714 check_visibility
= 1;
4718 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4722 inev
.kind
= DELETE_WINDOW_EVENT
;
4723 XSETFRAME (inev
.frame_or_window
, f
);
4728 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4732 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
4733 XSETFRAME (inev
.frame_or_window
, f
);
4738 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4742 extern void menubar_selection_callback
4743 (FRAME_PTR f
, void * client_data
);
4744 menubar_selection_callback (f
, (void *)msg
.msg
.wParam
);
4747 check_visibility
= 1;
4750 case WM_DISPLAYCHANGE
:
4751 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
4755 dpyinfo
->width
= (short) LOWORD (msg
.msg
.lParam
);
4756 dpyinfo
->height
= (short) HIWORD (msg
.msg
.lParam
);
4757 dpyinfo
->n_cbits
= msg
.msg
.wParam
;
4758 DebPrint (("display change: %d %d\n", dpyinfo
->width
,
4762 check_visibility
= 1;
4766 /* Check for messages registered at runtime. */
4767 if (msg
.msg
.message
== msh_mousewheel
)
4769 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
4770 msg
.msg
.message
= WM_MOUSEWHEEL
;
4776 if (inev
.kind
!= NO_EVENT
)
4778 kbd_buffer_store_event_hold (&inev
, hold_quit
);
4783 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
4788 XSETFRAME (frame
, f
);
4794 if (NILP (help_echo_string
))
4796 help_echo_object
= help_echo_window
= Qnil
;
4800 any_help_event_p
= 1;
4801 gen_help_event (help_echo_string
, frame
, help_echo_window
,
4802 help_echo_object
, help_echo_pos
);
4806 help_echo_string
= Qnil
;
4807 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
4813 /* If the focus was just given to an autoraising frame,
4815 /* ??? This ought to be able to handle more than one such frame. */
4816 if (pending_autoraise_frame
)
4818 x_raise_frame (pending_autoraise_frame
);
4819 pending_autoraise_frame
= 0;
4822 /* Check which frames are still visisble, if we have enqueued any user
4823 events or been notified of events that may affect visibility. We
4824 do this here because there doesn't seem to be any direct
4825 notification from Windows that the visibility of a window has
4826 changed (at least, not in all cases). */
4827 if (count
> 0 || check_visibility
)
4829 Lisp_Object tail
, frame
;
4831 FOR_EACH_FRAME (tail
, frame
)
4833 FRAME_PTR f
= XFRAME (frame
);
4834 /* The tooltip has been drawn already. Avoid the
4835 SET_FRAME_GARBAGED below. */
4836 if (EQ (frame
, tip_frame
))
4839 /* Check "visible" frames and mark each as obscured or not.
4840 Note that async_visible is nonzero for unobscured and
4841 obscured frames, but zero for hidden and iconified frames. */
4842 if (FRAME_W32_P (f
) && f
->async_visible
)
4848 /* Query clipping rectangle for the entire window area
4849 (GetWindowDC), not just the client portion (GetDC).
4850 Otherwise, the scrollbars and menubar aren't counted as
4851 part of the visible area of the frame, and we may think
4852 the frame is obscured when really a scrollbar is still
4853 visible and gets WM_PAINT messages above. */
4854 hdc
= GetWindowDC (FRAME_W32_WINDOW (f
));
4855 GetClipBox (hdc
, &clipbox
);
4856 ReleaseDC (FRAME_W32_WINDOW (f
), hdc
);
4859 if (clipbox
.right
== clipbox
.left
4860 || clipbox
.bottom
== clipbox
.top
)
4862 /* Frame has become completely obscured so mark as
4863 such (we do this by setting async_visible to 2 so
4864 that FRAME_VISIBLE_P is still true, but redisplay
4866 f
->async_visible
= 2;
4868 if (!FRAME_OBSCURED_P (f
))
4870 DebPrint (("frame %p (%s) obscured\n", f
,
4876 /* Frame is not obscured, so mark it as such. */
4877 f
->async_visible
= 1;
4879 if (FRAME_OBSCURED_P (f
))
4881 SET_FRAME_GARBAGED (f
);
4882 DebPrint (("obscured frame %p (%s) found to be visible\n", f
,
4885 /* Force a redisplay sooner or later. */
4886 record_asynch_buffer_change ();
4899 /***********************************************************************
4901 ***********************************************************************/
4903 /* Set clipping for output in glyph row ROW. W is the window in which
4904 we operate. GC is the graphics context to set clipping in.
4906 ROW may be a text row or, e.g., a mode line. Text rows must be
4907 clipped to the interior of the window dedicated to text display,
4908 mode lines must be clipped to the whole window. */
4911 w32_clip_to_row (w
, row
, hdc
)
4913 struct glyph_row
*row
;
4916 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4918 int window_y
, window_width
;
4920 window_box (w
, -1, 0, &window_y
, &window_width
, 0);
4922 clip_rect
.left
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
4923 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4924 clip_rect
.top
= max (clip_rect
.top
, window_y
);
4925 clip_rect
.right
= clip_rect
.left
+ window_width
;
4926 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
4928 w32_set_clip_rectangle (hdc
, &clip_rect
);
4932 /* Draw a hollow box cursor on window W in glyph row ROW. */
4935 x_draw_hollow_cursor (w
, row
)
4937 struct glyph_row
*row
;
4939 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
4943 struct glyph
*cursor_glyph
;
4944 HBRUSH hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
4946 /* Get the glyph the cursor is on. If we can't tell because
4947 the current matrix is invalid or such, give up. */
4948 cursor_glyph
= get_phys_cursor_glyph (w
);
4949 if (cursor_glyph
== NULL
)
4952 /* Compute frame-relative coordinates from window-relative
4954 rect
.left
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
4955 rect
.top
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
4956 + row
->ascent
- w
->phys_cursor_ascent
);
4958 /* Compute the proper height and ascent of the rectangle, based
4959 on the actual glyph. Using the full height of the row looks
4960 bad when there are tall images on that row. */
4961 h
= max (min (FRAME_LINE_HEIGHT (f
), row
->height
),
4962 cursor_glyph
->ascent
+ cursor_glyph
->descent
);
4963 if (h
< row
->height
)
4964 rect
.top
+= row
->ascent
/* - w->phys_cursor_ascent */ + cursor_glyph
->descent
- h
;
4967 rect
.bottom
= rect
.top
+ h
;
4969 /* Compute the width of the rectangle to draw. If on a stretch
4970 glyph, and `x-stretch-block-cursor' is nil, don't draw a
4971 rectangle as wide as the glyph, but use a canonical character
4973 wd
= cursor_glyph
->pixel_width
; /* TODO: Why off by one compared with X? */
4974 if (cursor_glyph
->type
== STRETCH_GLYPH
4975 && !x_stretch_cursor_p
)
4976 wd
= min (FRAME_COLUMN_WIDTH (f
), wd
);
4977 w
->phys_cursor_width
= wd
;
4979 rect
.right
= rect
.left
+ wd
;
4980 hdc
= get_frame_dc (f
);
4981 /* Set clipping, draw the rectangle, and reset clipping again. */
4982 w32_clip_to_row (w
, row
, hdc
);
4983 FrameRect (hdc
, &rect
, hb
);
4985 w32_set_clip_rectangle (hdc
, NULL
);
4986 release_frame_dc (f
, hdc
);
4990 /* Draw a bar cursor on window W in glyph row ROW.
4992 Implementation note: One would like to draw a bar cursor with an
4993 angle equal to the one given by the font property XA_ITALIC_ANGLE.
4994 Unfortunately, I didn't find a font yet that has this property set.
4998 x_draw_bar_cursor (w
, row
, width
, kind
)
5000 struct glyph_row
*row
;
5002 enum text_cursor_kinds kind
;
5004 struct frame
*f
= XFRAME (w
->frame
);
5005 struct glyph
*cursor_glyph
;
5009 /* If cursor is out of bounds, don't draw garbage. This can happen
5010 in mini-buffer windows when switching between echo area glyphs
5012 cursor_glyph
= get_phys_cursor_glyph (w
);
5013 if (cursor_glyph
== NULL
)
5016 /* If on an image, draw like a normal cursor. That's usually better
5017 visible than drawing a bar, esp. if the image is large so that
5018 the bar might not be in the window. */
5019 if (cursor_glyph
->type
== IMAGE_GLYPH
)
5021 struct glyph_row
*row
;
5022 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
5023 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
5027 COLORREF cursor_color
= f
->output_data
.w32
->cursor_pixel
;
5028 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
5030 /* If the glyph's background equals the color we normally draw
5031 the bar cursor in, the bar cursor in its normal color is
5032 invisible. Use the glyph's foreground color instead in this
5033 case, on the assumption that the glyph's colors are chosen so
5034 that the glyph is legible. */
5035 if (face
->background
== cursor_color
)
5036 cursor_color
= face
->foreground
;
5038 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5041 width
= FRAME_CURSOR_WIDTH (f
);
5042 width
= min (cursor_glyph
->pixel_width
, width
);
5044 w
->phys_cursor_width
= width
;
5047 hdc
= get_frame_dc (f
);
5048 w32_clip_to_row (w
, row
, hdc
);
5050 if (kind
== BAR_CURSOR
)
5052 w32_fill_area (f
, hdc
, cursor_color
, x
,
5053 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
5054 width
, row
->height
);
5058 w32_fill_area (f
, hdc
, cursor_color
, x
,
5059 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
5060 row
->height
- width
),
5061 cursor_glyph
->pixel_width
, width
);
5064 w32_set_clip_rectangle (hdc
, NULL
);
5065 release_frame_dc (f
, hdc
);
5070 /* RIF: Define cursor CURSOR on frame F. */
5073 w32_define_frame_cursor (f
, cursor
)
5077 w32_define_cursor (FRAME_W32_WINDOW (f
), cursor
);
5081 /* RIF: Clear area on frame F. */
5084 w32_clear_frame_area (f
, x
, y
, width
, height
)
5086 int x
, y
, width
, height
;
5090 hdc
= get_frame_dc (f
);
5091 w32_clear_area (f
, hdc
, x
, y
, width
, height
);
5092 release_frame_dc (f
, hdc
);
5095 /* RIF: Draw or clear cursor on window W. */
5098 w32_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
5100 struct glyph_row
*glyph_row
;
5102 int cursor_type
, cursor_width
;
5107 /* If the user wants to use the system caret, make sure our own
5108 cursor remains invisible. */
5109 if (w32_use_visible_system_caret
)
5111 /* Call to erase_phys_cursor here seems to use the
5112 wrong values of w->phys_cursor, as they have been
5113 overwritten before this function was called. */
5114 if (w
->phys_cursor_type
!= NO_CURSOR
)
5115 erase_phys_cursor (w
);
5117 cursor_type
= w
->phys_cursor_type
= NO_CURSOR
;
5118 w
->phys_cursor_width
= -1;
5122 w
->phys_cursor_type
= cursor_type
;
5125 w
->phys_cursor_on_p
= 1;
5127 /* If this is the active cursor, we need to track it with the
5128 system caret, so third party software like screen magnifiers
5129 and speech synthesizers can follow the cursor. */
5132 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
5133 HWND hwnd
= FRAME_W32_WINDOW (f
);
5136 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
5138 = (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
5139 + glyph_row
->ascent
- w
->phys_cursor_ascent
);
5141 /* If the size of the active cursor changed, destroy the old
5143 if (w32_system_caret_hwnd
5144 && (w32_system_caret_height
!= w
->phys_cursor_height
))
5145 PostMessage (hwnd
, WM_EMACS_DESTROY_CARET
, 0, 0);
5147 w32_system_caret_height
= w
->phys_cursor_height
;
5149 /* Move the system caret. */
5150 PostMessage (hwnd
, WM_EMACS_TRACK_CARET
, 0, 0);
5153 if (glyph_row
->exact_window_width_line_p
5154 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
5156 glyph_row
->cursor_in_fringe_p
= 1;
5157 draw_fringe_bitmap (w
, glyph_row
, 0);
5161 switch (cursor_type
)
5163 case HOLLOW_BOX_CURSOR
:
5164 x_draw_hollow_cursor (w
, glyph_row
);
5167 case FILLED_BOX_CURSOR
:
5168 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
5172 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
5176 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
5180 w
->phys_cursor_width
= 0;
5194 x_bitmap_icon (f
, icon
)
5200 if (FRAME_W32_WINDOW (f
) == 0)
5204 hicon
= LoadIcon (hinst
, EMACS_CLASS
);
5205 else if (STRINGP (icon
))
5206 hicon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
5207 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
5208 else if (SYMBOLP (icon
))
5212 if (EQ (icon
, intern ("application")))
5213 name
= (LPCTSTR
) IDI_APPLICATION
;
5214 else if (EQ (icon
, intern ("hand")))
5215 name
= (LPCTSTR
) IDI_HAND
;
5216 else if (EQ (icon
, intern ("question")))
5217 name
= (LPCTSTR
) IDI_QUESTION
;
5218 else if (EQ (icon
, intern ("exclamation")))
5219 name
= (LPCTSTR
) IDI_EXCLAMATION
;
5220 else if (EQ (icon
, intern ("asterisk")))
5221 name
= (LPCTSTR
) IDI_ASTERISK
;
5222 else if (EQ (icon
, intern ("winlogo")))
5223 name
= (LPCTSTR
) IDI_WINLOGO
;
5227 hicon
= LoadIcon (NULL
, name
);
5235 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
5242 /************************************************************************
5244 ************************************************************************/
5246 /* Display Error Handling functions not used on W32. Listing them here
5247 helps diff stay in step when comparing w32term.c with xterm.c.
5249 x_error_catcher (display, error)
5250 x_catch_errors (dpy)
5251 x_catch_errors_unwind (old_val)
5252 x_check_errors (dpy, format)
5253 x_had_errors_p (dpy)
5254 x_clear_errors (dpy)
5255 x_uncatch_errors (dpy, count)
5257 x_connection_signal (signalnum)
5258 x_connection_closed (dpy, error_message)
5259 x_error_quitter (display, error)
5260 x_error_handler (display, error)
5261 x_io_error_quitter (display)
5266 /* Changing the font of the frame. */
5268 /* Give frame F the font named FONTNAME as its default font, and
5269 return the full name of that font. FONTNAME may be a wildcard
5270 pattern; in that case, we choose some font that fits the pattern.
5271 The return value shows which font we chose. */
5274 x_new_font (f
, fontname
)
5276 register char *fontname
;
5278 struct font_info
*fontp
5279 = FS_LOAD_FONT (f
, 0, fontname
, -1);
5284 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
5285 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
5286 FRAME_FONTSET (f
) = -1;
5288 FRAME_COLUMN_WIDTH (f
) = FONT_WIDTH (FRAME_FONT (f
));
5289 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
5291 compute_fringe_widths (f
, 1);
5293 /* Compute the scroll bar width in character columns. */
5294 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
5296 int wid
= FRAME_COLUMN_WIDTH (f
);
5297 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
5298 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
5302 int wid
= FRAME_COLUMN_WIDTH (f
);
5303 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
5306 /* Now make the frame display the given font. */
5307 if (FRAME_W32_WINDOW (f
) != 0)
5309 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
5310 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
5313 return build_string (fontp
->full_name
);
5316 /* Give frame F the fontset named FONTSETNAME as its default font, and
5317 return the full name of that fontset. FONTSETNAME may be a wildcard
5318 pattern; in that case, we choose some fontset that fits the pattern.
5319 The return value shows which fontset we chose. */
5322 x_new_fontset (f
, fontsetname
)
5326 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
5332 if (FRAME_FONTSET (f
) == fontset
)
5333 /* This fontset is already set in frame F. There's nothing more
5335 return fontset_name (fontset
);
5337 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
5339 if (!STRINGP (result
))
5340 /* Can't load ASCII font. */
5343 /* Since x_new_font doesn't update any fontset information, do it now. */
5344 FRAME_FONTSET(f
) = fontset
;
5346 return build_string (fontsetname
);
5350 /***********************************************************************
5351 TODO: W32 Input Methods
5352 ***********************************************************************/
5353 /* Listing missing functions from xterm.c helps diff stay in step.
5355 xim_destroy_callback (xim, client_data, call_data)
5356 xim_open_dpy (dpyinfo, resource_name)
5358 xim_instantiate_callback (display, client_data, call_data)
5359 xim_initialize (dpyinfo, resource_name)
5360 xim_close_dpy (dpyinfo)
5365 /* Calculate the absolute position in frame F
5366 from its current recorded position values and gravity. */
5369 x_calc_absolute_position (f
)
5373 int flags
= f
->size_hint_flags
;
5377 /* Find the position of the outside upper-left corner of
5378 the inner window, with respect to the outer window.
5379 But do this only if we will need the results. */
5380 if (f
->output_data
.w32
->parent_desc
!= FRAME_W32_DISPLAY_INFO (f
)->root_window
)
5383 MapWindowPoints (FRAME_W32_WINDOW (f
),
5384 f
->output_data
.w32
->parent_desc
,
5391 rt
.left
= rt
.right
= rt
.top
= rt
.bottom
= 0;
5394 AdjustWindowRect(&rt
, f
->output_data
.w32
->dwStyle
,
5395 FRAME_EXTERNAL_MENU_BAR (f
));
5398 pt
.x
+= (rt
.right
- rt
.left
);
5399 pt
.y
+= (rt
.bottom
- rt
.top
);
5402 /* Treat negative positions as relative to the leftmost bottommost
5403 position that fits on the screen. */
5404 if (flags
& XNegative
)
5405 f
->left_pos
= (FRAME_W32_DISPLAY_INFO (f
)->width
5406 - 2 * f
->border_width
- pt
.x
5407 - FRAME_PIXEL_WIDTH (f
)
5410 if (flags
& YNegative
)
5411 f
->top_pos
= (FRAME_W32_DISPLAY_INFO (f
)->height
5412 - 2 * f
->border_width
- pt
.y
5413 - FRAME_PIXEL_HEIGHT (f
)
5415 /* The left_pos and top_pos
5416 are now relative to the top and left screen edges,
5417 so the flags should correspond. */
5418 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5421 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5422 to really change the position, and 0 when calling from
5423 x_make_frame_visible (in that case, XOFF and YOFF are the current
5424 position values). It is -1 when calling from x_set_frame_parameters,
5425 which means, do adjust for borders but don't change the gravity. */
5428 x_set_offset (f
, xoff
, yoff
, change_gravity
)
5430 register int xoff
, yoff
;
5433 int modified_top
, modified_left
;
5435 if (change_gravity
> 0)
5439 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
5441 f
->size_hint_flags
|= XNegative
;
5443 f
->size_hint_flags
|= YNegative
;
5444 f
->win_gravity
= NorthWestGravity
;
5446 x_calc_absolute_position (f
);
5449 x_wm_set_size_hint (f
, (long) 0, 0);
5451 modified_left
= f
->left_pos
;
5452 modified_top
= f
->top_pos
;
5454 my_set_window_pos (FRAME_W32_WINDOW (f
),
5456 modified_left
, modified_top
,
5458 SWP_NOZORDER
| SWP_NOSIZE
| SWP_NOACTIVATE
);
5463 /* Check if we need to resize the frame due to a fullscreen request.
5464 If so needed, resize the frame. */
5466 x_check_fullscreen (f
)
5469 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
5471 int width
, height
, ign
;
5473 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5475 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
5477 /* We do not need to move the window, it shall be taken care of
5478 when setting WM manager hints. */
5479 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
5481 change_frame_size (f
, height
, width
, 0, 1, 0);
5482 SET_FRAME_GARBAGED (f
);
5483 cancel_mouse_face (f
);
5485 /* Wait for the change of frame size to occur */
5486 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
5491 /* Call this to change the size of frame F's x-window.
5492 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5493 for this size change and subsequent size changes.
5494 Otherwise we leave the window gravity unchanged. */
5497 x_set_window_size (f
, change_gravity
, cols
, rows
)
5502 int pixelwidth
, pixelheight
;
5506 check_frame_size (f
, &rows
, &cols
);
5507 f
->scroll_bar_actual_width
5508 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
5510 compute_fringe_widths (f
, 0);
5512 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
5513 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
5515 f
->win_gravity
= NorthWestGravity
;
5516 x_wm_set_size_hint (f
, (long) 0, 0);
5521 rect
.left
= rect
.top
= 0;
5522 rect
.right
= pixelwidth
;
5523 rect
.bottom
= pixelheight
;
5525 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
5526 FRAME_EXTERNAL_MENU_BAR (f
));
5528 my_set_window_pos (FRAME_W32_WINDOW (f
),
5531 rect
.right
- rect
.left
,
5532 rect
.bottom
- rect
.top
,
5533 SWP_NOZORDER
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5536 /* Now, strictly speaking, we can't be sure that this is accurate,
5537 but the window manager will get around to dealing with the size
5538 change request eventually, and we'll hear how it went when the
5539 ConfigureNotify event gets here.
5541 We could just not bother storing any of this information here,
5542 and let the ConfigureNotify event set everything up, but that
5543 might be kind of confusing to the Lisp code, since size changes
5544 wouldn't be reported in the frame parameters until some random
5545 point in the future when the ConfigureNotify event arrives.
5547 We pass 1 for DELAY since we can't run Lisp code inside of
5549 change_frame_size (f
, rows
, cols
, 0, 1, 0);
5550 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
5551 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
5553 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5554 receive in the ConfigureNotify event; if we get what we asked
5555 for, then the event won't cause the screen to become garbaged, so
5556 we have to make sure to do it here. */
5557 SET_FRAME_GARBAGED (f
);
5559 /* If cursor was outside the new size, mark it as off. */
5560 mark_window_cursors_off (XWINDOW (f
->root_window
));
5562 /* Clear out any recollection of where the mouse highlighting was,
5563 since it might be in a place that's outside the new frame size.
5564 Actually checking whether it is outside is a pain in the neck,
5565 so don't try--just let the highlighting be done afresh with new size. */
5566 cancel_mouse_face (f
);
5571 /* Mouse warping. */
5573 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
5576 x_set_mouse_position (f
, x
, y
)
5582 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
5583 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
5585 if (pix_x
< 0) pix_x
= 0;
5586 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
5588 if (pix_y
< 0) pix_y
= 0;
5589 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
5591 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
5595 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
5604 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
5605 pt
.x
= rect
.left
+ pix_x
;
5606 pt
.y
= rect
.top
+ pix_y
;
5607 ClientToScreen (FRAME_W32_WINDOW (f
), &pt
);
5609 SetCursorPos (pt
.x
, pt
.y
);
5615 /* focus shifting, raising and lowering. */
5618 x_focus_on_frame (f
)
5621 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
5623 /* Give input focus to frame. */
5626 /* Try not to change its Z-order if possible. */
5627 if (x_window_to_frame (dpyinfo
, GetForegroundWindow ()))
5628 my_set_focus (f
, FRAME_W32_WINDOW (f
));
5631 my_set_foreground_window (FRAME_W32_WINDOW (f
));
5641 /* Raise frame F. */
5648 /* Strictly speaking, raise-frame should only change the frame's Z
5649 order, leaving input focus unchanged. This is reasonable behaviour
5650 on X where the usual policy is point-to-focus. However, this
5651 behaviour would be very odd on Windows where the usual policy is
5654 On X, if the mouse happens to be over the raised frame, it gets
5655 input focus anyway (so the window with focus will never be
5656 completely obscured) - if not, then just moving the mouse over it
5657 is sufficient to give it focus. On Windows, the user must actually
5658 click on the frame (preferrably the title bar so as not to move
5659 point), which is more awkward. Also, no other Windows program
5660 raises a window to the top but leaves another window (possibly now
5661 completely obscured) with input focus.
5663 Because there is a system setting on Windows that allows the user
5664 to choose the point to focus policy, we make the strict semantics
5665 optional, but by default we grab focus when raising. */
5667 if (NILP (Vw32_grab_focus_on_raise
))
5669 /* The obvious call to my_set_window_pos doesn't work if Emacs is
5670 not already the foreground application: the frame is raised
5671 above all other frames belonging to us, but not above the
5672 current top window. To achieve that, we have to resort to this
5673 more cumbersome method. */
5675 HDWP handle
= BeginDeferWindowPos (2);
5678 DeferWindowPos (handle
,
5679 FRAME_W32_WINDOW (f
),
5682 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5684 DeferWindowPos (handle
,
5685 GetForegroundWindow (),
5686 FRAME_W32_WINDOW (f
),
5688 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5690 EndDeferWindowPos (handle
);
5695 my_set_foreground_window (FRAME_W32_WINDOW (f
));
5701 /* Lower frame F. */
5707 my_set_window_pos (FRAME_W32_WINDOW (f
),
5710 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
5715 w32_frame_raise_lower (f
, raise_flag
)
5719 if (! FRAME_W32_P (f
))
5728 /* Change of visibility. */
5730 /* This tries to wait until the frame is really visible.
5731 However, if the window manager asks the user where to position
5732 the frame, this will return before the user finishes doing that.
5733 The frame will not actually be visible at that time,
5734 but it will become visible later when the window manager
5735 finishes with it. */
5738 x_make_frame_visible (f
)
5745 type
= x_icon_type (f
);
5747 x_bitmap_icon (f
, type
);
5749 if (! FRAME_VISIBLE_P (f
))
5751 /* We test FRAME_GARBAGED_P here to make sure we don't
5752 call x_set_offset a second time
5753 if we get to x_make_frame_visible a second time
5754 before the window gets really visible. */
5755 if (! FRAME_ICONIFIED_P (f
)
5756 && ! f
->output_data
.w32
->asked_for_visible
)
5757 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
5759 f
->output_data
.w32
->asked_for_visible
= 1;
5761 /* my_show_window (f, FRAME_W32_WINDOW (f), f->async_iconified ? SW_RESTORE : SW_SHOW); */
5762 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_SHOWNORMAL
);
5765 /* Synchronize to ensure Emacs knows the frame is visible
5766 before we do anything else. We do this loop with input not blocked
5767 so that incoming events are handled. */
5772 /* This must come after we set COUNT. */
5775 XSETFRAME (frame
, f
);
5777 /* Wait until the frame is visible. Process X events until a
5778 MapNotify event has been seen, or until we think we won't get a
5779 MapNotify at all.. */
5780 for (count
= input_signal_count
+ 10;
5781 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
5783 /* Force processing of queued events. */
5784 /* TODO: x_sync equivalent? */
5786 /* Machines that do polling rather than SIGIO have been observed
5787 to go into a busy-wait here. So we'll fake an alarm signal
5788 to let the handler know that there's something to be read.
5789 We used to raise a real alarm, but it seems that the handler
5790 isn't always enabled here. This is probably a bug. */
5791 if (input_polling_used ())
5793 /* It could be confusing if a real alarm arrives while processing
5794 the fake one. Turn it off and let the handler reset it. */
5795 int old_poll_suppress_count
= poll_suppress_count
;
5796 poll_suppress_count
= 1;
5797 poll_for_input_1 ();
5798 poll_suppress_count
= old_poll_suppress_count
;
5801 FRAME_SAMPLE_VISIBILITY (f
);
5805 /* Change from mapped state to withdrawn state. */
5807 /* Make the frame visible (mapped and not iconified). */
5809 x_make_frame_invisible (f
)
5812 /* Don't keep the highlight on an invisible frame. */
5813 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5814 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5818 my_show_window (f
, FRAME_W32_WINDOW (f
), SW_HIDE
);
5820 /* We can't distinguish this from iconification
5821 just by the event that we get from the server.
5822 So we can't win using the usual strategy of letting
5823 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5824 and synchronize with the server to make sure we agree. */
5826 FRAME_ICONIFIED_P (f
) = 0;
5827 f
->async_visible
= 0;
5828 f
->async_iconified
= 0;
5833 /* Change window state from mapped to iconified. */
5841 /* Don't keep the highlight on an invisible frame. */
5842 if (FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
5843 FRAME_W32_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
5845 if (f
->async_iconified
)
5850 type
= x_icon_type (f
);
5852 x_bitmap_icon (f
, type
);
5854 /* Simulate the user minimizing the frame. */
5855 SendMessage (FRAME_W32_WINDOW (f
), WM_SYSCOMMAND
, SC_MINIMIZE
, 0);
5861 /* Free X resources of frame F. */
5864 x_free_frame_resources (f
)
5867 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5871 if (FRAME_W32_WINDOW (f
))
5872 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
5874 free_frame_menubar (f
);
5876 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
5877 unload_color (f
, f
->output_data
.x
->background_pixel
);
5878 unload_color (f
, f
->output_data
.w32
->cursor_pixel
);
5879 unload_color (f
, f
->output_data
.w32
->cursor_foreground_pixel
);
5880 unload_color (f
, f
->output_data
.w32
->border_pixel
);
5881 unload_color (f
, f
->output_data
.w32
->mouse_pixel
);
5882 if (f
->output_data
.w32
->white_relief
.allocated_p
)
5883 unload_color (f
, f
->output_data
.w32
->white_relief
.pixel
);
5884 if (f
->output_data
.w32
->black_relief
.allocated_p
)
5885 unload_color (f
, f
->output_data
.w32
->black_relief
.pixel
);
5887 if (FRAME_FACE_CACHE (f
))
5888 free_frame_faces (f
);
5890 xfree (f
->output_data
.w32
);
5891 f
->output_data
.w32
= NULL
;
5893 if (f
== dpyinfo
->w32_focus_frame
)
5894 dpyinfo
->w32_focus_frame
= 0;
5895 if (f
== dpyinfo
->w32_focus_event_frame
)
5896 dpyinfo
->w32_focus_event_frame
= 0;
5897 if (f
== dpyinfo
->x_highlight_frame
)
5898 dpyinfo
->x_highlight_frame
= 0;
5900 if (f
== dpyinfo
->mouse_face_mouse_frame
)
5902 dpyinfo
->mouse_face_beg_row
5903 = dpyinfo
->mouse_face_beg_col
= -1;
5904 dpyinfo
->mouse_face_end_row
5905 = dpyinfo
->mouse_face_end_col
= -1;
5906 dpyinfo
->mouse_face_window
= Qnil
;
5907 dpyinfo
->mouse_face_deferred_gc
= 0;
5908 dpyinfo
->mouse_face_mouse_frame
= 0;
5915 /* Destroy the window of frame F. */
5917 x_destroy_window (f
)
5920 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5922 x_free_frame_resources (f
);
5924 dpyinfo
->reference_count
--;
5928 /* Setting window manager hints. */
5930 /* Set the normal size hints for the window manager, for frame F.
5931 FLAGS is the flags word to use--or 0 meaning preserve the flags
5932 that the window now has.
5933 If USER_POSITION is nonzero, we set the USPosition
5934 flag (this is useful when FLAGS is 0). */
5936 x_wm_set_size_hint (f
, flags
, user_position
)
5941 Window window
= FRAME_W32_WINDOW (f
);
5945 SetWindowLong (window
, WND_FONTWIDTH_INDEX
, FRAME_COLUMN_WIDTH (f
));
5946 SetWindowLong (window
, WND_LINEHEIGHT_INDEX
, FRAME_LINE_HEIGHT (f
));
5947 SetWindowLong (window
, WND_BORDER_INDEX
, FRAME_INTERNAL_BORDER_WIDTH (f
));
5948 SetWindowLong (window
, WND_SCROLLBAR_INDEX
, f
->scroll_bar_actual_width
);
5953 /* Window manager things */
5955 x_wm_set_icon_position (f
, icon_x
, icon_y
)
5960 Window window
= FRAME_W32_WINDOW (f
);
5962 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
5963 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
5964 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
5966 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
5971 /***********************************************************************
5973 ***********************************************************************/
5975 /* The following functions are listed here to help diff stay in step
5976 with xterm.c. See w32fns.c for definitions.
5978 x_get_font_info (f, font_idx)
5979 x_list_fonts (f, pattern, size, maxnames)
5985 /* Check that FONT is valid on frame F. It is if it can be found in F's
5989 x_check_font (f
, font
)
5994 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
5996 xassert (font
!= NULL
);
5998 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
5999 if (dpyinfo
->font_table
[i
].name
6000 && font
== dpyinfo
->font_table
[i
].font
)
6003 xassert (i
< dpyinfo
->n_fonts
);
6006 #endif /* GLYPH_DEBUG != 0 */
6008 /* Set *W to the minimum width, *H to the minimum font height of FONT.
6009 Note: There are (broken) X fonts out there with invalid XFontStruct
6010 min_bounds contents. For example, handa@etl.go.jp reports that
6011 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
6012 have font->min_bounds.width == 0. */
6015 x_font_min_bounds (font
, w
, h
)
6020 * TODO: Windows does not appear to offer min bound, only
6021 * average and maximum width, and maximum height.
6023 *h
= FONT_HEIGHT (font
);
6024 *w
= FONT_WIDTH (font
);
6028 /* Compute the smallest character width and smallest font height over
6029 all fonts available on frame F. Set the members smallest_char_width
6030 and smallest_font_height in F's x_display_info structure to
6031 the values computed. Value is non-zero if smallest_font_height or
6032 smallest_char_width become smaller than they were before. */
6035 x_compute_min_glyph_bounds (f
)
6039 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
6041 int old_width
= dpyinfo
->smallest_char_width
;
6042 int old_height
= dpyinfo
->smallest_font_height
;
6044 dpyinfo
->smallest_font_height
= 100000;
6045 dpyinfo
->smallest_char_width
= 100000;
6047 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
6048 if (dpyinfo
->font_table
[i
].name
)
6050 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
6053 font
= (XFontStruct
*) fontp
->font
;
6054 xassert (font
!= (XFontStruct
*) ~0);
6055 x_font_min_bounds (font
, &w
, &h
);
6057 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
6058 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
6061 xassert (dpyinfo
->smallest_char_width
> 0
6062 && dpyinfo
->smallest_font_height
> 0);
6064 return (dpyinfo
->n_fonts
== 1
6065 || dpyinfo
->smallest_char_width
< old_width
6066 || dpyinfo
->smallest_font_height
< old_height
);
6069 /* The following functions are listed here to help diff stay in step
6070 with xterm.c. See w32fns.c for definitions.
6072 x_load_font (f, fontname, size)
6073 x_query_font (f, fontname)
6074 x_find_ccl_program (fontp)
6078 /***********************************************************************
6080 ***********************************************************************/
6082 static int w32_initialized
= 0;
6085 w32_initialize_display_info (display_name
)
6086 Lisp_Object display_name
;
6088 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
6090 bzero (dpyinfo
, sizeof (*dpyinfo
));
6092 /* Put it on w32_display_name_list. */
6093 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
6094 w32_display_name_list
);
6095 dpyinfo
->name_list_element
= XCAR (w32_display_name_list
);
6097 dpyinfo
->w32_id_name
6098 = (char *) xmalloc (SCHARS (Vinvocation_name
)
6099 + SCHARS (Vsystem_name
)
6101 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
6102 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
6104 /* Default Console mode values - overridden when running in GUI mode
6105 with values obtained from system metrics. */
6108 dpyinfo
->height_in
= 1;
6109 dpyinfo
->width_in
= 1;
6110 dpyinfo
->n_planes
= 1;
6111 dpyinfo
->n_cbits
= 4;
6112 dpyinfo
->n_fonts
= 0;
6113 dpyinfo
->smallest_font_height
= 1;
6114 dpyinfo
->smallest_char_width
= 1;
6116 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
6117 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
6118 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
6119 dpyinfo
->mouse_face_window
= Qnil
;
6120 dpyinfo
->mouse_face_overlay
= Qnil
;
6121 dpyinfo
->mouse_face_hidden
= 0;
6123 dpyinfo
->vertical_scroll_bar_cursor
= w32_load_cursor (IDC_ARROW
);
6124 /* TODO: dpyinfo->gray */
6128 /* Create an xrdb-style database of resources to supercede registry settings.
6129 The database is just a concatenation of C strings, finished by an additional
6130 \0. The string are submitted to some basic normalization, so
6132 [ *]option[ *]:[ *]value...
6138 but any whitespace following value is not removed. */
6141 w32_make_rdb (xrm_option
)
6144 char *buffer
= xmalloc (strlen (xrm_option
) + 2);
6145 char *current
= buffer
;
6148 int before_value
= 0;
6162 if (in_option
&& (ch
== ':'))
6167 else if (before_value
)
6172 else if (!(in_option
|| before_value
))
6183 struct w32_display_info
*
6184 w32_term_init (display_name
, xrm_option
, resource_name
)
6185 Lisp_Object display_name
;
6187 char *resource_name
;
6189 struct w32_display_info
*dpyinfo
;
6194 if (!w32_initialized
)
6197 w32_initialized
= 1;
6200 w32_initialize_display_info (display_name
);
6202 dpyinfo
= &one_w32_display_info
;
6204 dpyinfo
->xrdb
= xrm_option
? w32_make_rdb (xrm_option
) : NULL
;
6206 /* Put this display on the chain. */
6207 dpyinfo
->next
= x_display_list
;
6208 x_display_list
= dpyinfo
;
6210 hdc
= GetDC (GetDesktopWindow ());
6212 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
6213 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
6214 dpyinfo
->root_window
= GetDesktopWindow ();
6215 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
6216 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
6217 dpyinfo
->resx
= GetDeviceCaps (hdc
, LOGPIXELSX
);
6218 dpyinfo
->resy
= GetDeviceCaps (hdc
, LOGPIXELSY
);
6219 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
6220 dpyinfo
->image_cache
= make_image_cache ();
6221 dpyinfo
->height_in
= dpyinfo
->height
/ dpyinfo
->resx
;
6222 dpyinfo
->width_in
= dpyinfo
->width
/ dpyinfo
->resy
;
6223 ReleaseDC (GetDesktopWindow (), hdc
);
6225 /* initialise palette with white and black */
6228 w32_defined_color (0, "white", &color
, 1);
6229 w32_defined_color (0, "black", &color
, 1);
6232 /* Create Fringe Bitmaps and store them for later use.
6234 On W32, bitmaps are all unsigned short, as Windows requires
6235 bitmap data to be Word aligned. For some reason they are
6236 horizontally reflected compared to how they appear on X, so we
6237 need to bitswap and convert to unsigned shorts before creating
6241 #ifndef F_SETOWN_BUG
6243 #ifdef F_SETOWN_SOCK_NEG
6244 /* stdin is a socket here */
6245 fcntl (connection
, F_SETOWN
, -getpid ());
6246 #else /* ! defined (F_SETOWN_SOCK_NEG) */
6247 fcntl (connection
, F_SETOWN
, getpid ());
6248 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
6249 #endif /* ! defined (F_SETOWN) */
6250 #endif /* F_SETOWN_BUG */
6253 if (interrupt_input
)
6254 init_sigio (connection
);
6255 #endif /* ! defined (SIGIO) */
6262 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6265 x_delete_display (dpyinfo
)
6266 struct w32_display_info
*dpyinfo
;
6268 /* Discard this display from w32_display_name_list and w32_display_list.
6269 We can't use Fdelq because that can quit. */
6270 if (! NILP (w32_display_name_list
)
6271 && EQ (XCAR (w32_display_name_list
), dpyinfo
->name_list_element
))
6272 w32_display_name_list
= XCDR (w32_display_name_list
);
6277 tail
= w32_display_name_list
;
6278 while (CONSP (tail
) && CONSP (XCDR (tail
)))
6280 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
6282 XSETCDR (tail
, XCDR (XCDR (tail
)));
6289 /* free palette table */
6291 struct w32_palette_entry
* plist
;
6293 plist
= dpyinfo
->color_list
;
6296 struct w32_palette_entry
* pentry
= plist
;
6297 plist
= plist
->next
;
6300 dpyinfo
->color_list
= NULL
;
6301 if (dpyinfo
->palette
)
6302 DeleteObject(dpyinfo
->palette
);
6304 xfree (dpyinfo
->font_table
);
6305 xfree (dpyinfo
->w32_id_name
);
6307 w32_reset_fringes ();
6310 /* Set up use of W32. */
6312 DWORD
w32_msg_worker ();
6315 x_flush (struct frame
* f
)
6316 { /* Nothing to do */ }
6318 extern frame_parm_handler w32_frame_parm_handlers
[];
6320 static struct redisplay_interface w32_redisplay_interface
=
6322 w32_frame_parm_handlers
,
6326 x_clear_end_of_line
,
6328 x_after_update_window_line
,
6329 x_update_window_begin
,
6330 x_update_window_end
,
6333 0, /* flush_display_optional */
6334 x_clear_window_mouse_face
,
6335 w32_get_glyph_overhangs
,
6336 x_fix_overlapping_area
,
6337 w32_draw_fringe_bitmap
,
6338 w32_define_fringe_bitmap
,
6339 w32_destroy_fringe_bitmap
,
6340 w32_per_char_metric
,
6342 NULL
, /* w32_compute_glyph_string_overhangs */
6343 x_draw_glyph_string
,
6344 w32_define_frame_cursor
,
6345 w32_clear_frame_area
,
6346 w32_draw_window_cursor
,
6347 w32_draw_vertical_window_border
,
6348 w32_shift_glyphs_for_insert
6354 rif
= &w32_redisplay_interface
;
6356 /* MSVC does not type K&R functions with no arguments correctly, and
6357 so we must explicitly cast them. */
6358 clear_frame_hook
= (void (*)(void)) x_clear_frame
;
6359 ring_bell_hook
= (void (*)(void)) w32_ring_bell
;
6360 update_begin_hook
= x_update_begin
;
6361 update_end_hook
= x_update_end
;
6363 read_socket_hook
= w32_read_socket
;
6365 frame_up_to_date_hook
= w32_frame_up_to_date
;
6367 mouse_position_hook
= w32_mouse_position
;
6368 frame_rehighlight_hook
= w32_frame_rehighlight
;
6369 frame_raise_lower_hook
= w32_frame_raise_lower
;
6370 set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
6371 condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
6372 redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
6373 judge_scroll_bars_hook
= w32_judge_scroll_bars
;
6375 scroll_region_ok
= 1; /* we'll scroll partial frames */
6376 char_ins_del_ok
= 1;
6377 line_ins_del_ok
= 1; /* we'll just blt 'em */
6378 fast_clear_end_of_line
= 1; /* X does this well */
6379 memory_below_frame
= 0; /* we don't remember what scrolls
6383 w32_system_caret_hwnd
= NULL
;
6384 w32_system_caret_height
= 0;
6385 w32_system_caret_x
= 0;
6386 w32_system_caret_y
= 0;
6388 last_tool_bar_item
= -1;
6389 any_help_event_p
= 0;
6391 /* Initialize input mode: interrupt_input off, no flow control, allow
6392 8 bit character input, standard quit char. */
6393 Fset_input_mode (Qnil
, Qnil
, make_number (2), Qnil
);
6395 /* Create the window thread - it will terminate itself or when the app terminates */
6399 dwMainThreadId
= GetCurrentThreadId ();
6400 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6401 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
6403 /* Wait for thread to start */
6408 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
6410 hWindowsThread
= CreateThread (NULL
, 0,
6411 (LPTHREAD_START_ROUTINE
) w32_msg_worker
,
6412 0, 0, &dwWindowsThreadId
);
6414 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
6417 /* It is desirable that mainThread should have the same notion of
6418 focus window and active window as windowsThread. Unfortunately, the
6419 following call to AttachThreadInput, which should do precisely what
6420 we need, causes major problems when Emacs is linked as a console
6421 program. Unfortunately, we have good reasons for doing that, so
6422 instead we need to send messages to windowsThread to make some API
6423 calls for us (ones that affect, or depend on, the active/focus
6425 #ifdef ATTACH_THREADS
6426 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
6429 /* Dynamically link to optional system components. */
6431 HANDLE user_lib
= LoadLibrary ("user32.dll");
6433 #define LOAD_PROC(fn) pfn##fn = (void *) GetProcAddress (user_lib, #fn)
6435 /* New proportional scroll bar functions. */
6436 LOAD_PROC (SetScrollInfo
);
6437 LOAD_PROC (GetScrollInfo
);
6441 FreeLibrary (user_lib
);
6443 /* If using proportional scroll bars, ensure handle is at least 5 pixels;
6444 otherwise use the fixed height. */
6445 vertical_scroll_bar_min_handle
= (pfnSetScrollInfo
!= NULL
) ? 5 :
6446 GetSystemMetrics (SM_CYVTHUMB
);
6448 /* For either kind of scroll bar, take account of the arrows; these
6449 effectively form the border of the main scroll bar range. */
6450 vertical_scroll_bar_top_border
= vertical_scroll_bar_bottom_border
6451 = GetSystemMetrics (SM_CYVSCROLL
);
6458 staticpro (&w32_display_name_list
);
6459 w32_display_name_list
= Qnil
;
6461 staticpro (&last_mouse_scroll_bar
);
6462 last_mouse_scroll_bar
= Qnil
;
6464 staticpro (&Qvendor_specific_keysyms
);
6465 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
6467 DEFVAR_INT ("w32-num-mouse-buttons",
6468 &w32_num_mouse_buttons
,
6469 doc
: /* Number of physical mouse buttons. */);
6470 w32_num_mouse_buttons
= 2;
6472 DEFVAR_LISP ("w32-swap-mouse-buttons",
6473 &Vw32_swap_mouse_buttons
,
6474 doc
: /* Swap the mapping of middle and right mouse buttons.
6475 When nil, middle button is mouse-2 and right button is mouse-3. */);
6476 Vw32_swap_mouse_buttons
= Qnil
;
6478 DEFVAR_LISP ("w32-grab-focus-on-raise",
6479 &Vw32_grab_focus_on_raise
,
6480 doc
: /* Raised frame grabs input focus.
6481 When t, `raise-frame' grabs input focus as well. This fits well
6482 with the normal Windows click-to-focus policy, but might not be
6483 desirable when using a point-to-focus policy. */);
6484 Vw32_grab_focus_on_raise
= Qt
;
6486 DEFVAR_LISP ("w32-capslock-is-shiftlock",
6487 &Vw32_capslock_is_shiftlock
,
6488 doc
: /* Apply CapsLock state to non character input keys.
6489 When nil, CapsLock only affects normal character input keys. */);
6490 Vw32_capslock_is_shiftlock
= Qnil
;
6492 DEFVAR_LISP ("w32-recognize-altgr",
6493 &Vw32_recognize_altgr
,
6494 doc
: /* Recognize right-alt and left-ctrl as AltGr.
6495 When nil, the right-alt and left-ctrl key combination is
6496 interpreted normally. */);
6497 Vw32_recognize_altgr
= Qt
;
6499 DEFVAR_BOOL ("w32-enable-unicode-output",
6500 &w32_enable_unicode_output
,
6501 doc
: /* Enable the use of Unicode for text output if non-nil.
6502 Unicode output may prevent some third party applications for displaying
6503 Far-East Languages on Windows 95/98 from working properly.
6504 NT uses Unicode internally anyway, so this flag will probably have no
6505 affect on NT machines. */);
6506 w32_enable_unicode_output
= 1;
6508 DEFVAR_BOOL ("w32-use-visible-system-caret",
6509 &w32_use_visible_system_caret
,
6510 doc
: /* Flag to make the system caret visible.
6511 When this is non-nil, Emacs will indicate the position of point by
6512 using the system caret instead of drawing its own cursor. Some screen
6513 reader software does not track the system cursor properly when it is
6514 invisible, and gets confused by Emacs drawing its own cursor, so this
6515 variable is initialized to t when Emacs detects that screen reader
6516 software is running as it starts up.
6518 When this variable is set, other variables affecting the appearance of
6519 the cursor have no effect. */);
6521 /* Initialize w32_use_visible_system_caret based on whether a screen
6522 reader is in use. */
6523 if (!SystemParametersInfo (SPI_GETSCREENREADER
, 0,
6524 &w32_use_visible_system_caret
, 0))
6525 w32_use_visible_system_caret
= 0;
6527 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
6528 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
6529 Vx_toolkit_scroll_bars
= Qt
;
6531 staticpro (&last_mouse_motion_frame
);
6532 last_mouse_motion_frame
= Qnil
;
6535 /* arch-tag: 5fa70624-ab86-499c-8a85-473958ee4646
6536 (do not change this comment) */