Fix last ChangeLog entry.
[emacs.git] / src / w32term.c
blob4c426aca921fcd1451d3020dd809c8506b17e492
1 /* Implementation of GUI terminal on the Microsoft Windows API.
3 Copyright (C) 1989, 1993-2014 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 3 of the License, or
10 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
20 #include <config.h>
21 #include <signal.h>
22 #include <stdio.h>
23 #include "lisp.h"
24 #include "blockinput.h"
25 #include "w32term.h"
27 #include "systty.h"
28 #include "systime.h"
30 #include <ctype.h>
31 #include <errno.h>
32 #include <sys/stat.h>
33 #include <imm.h>
35 #include "charset.h"
36 #include "character.h"
37 #include "coding.h"
38 #include "ccl.h"
39 #include "frame.h"
40 #include "dispextern.h"
41 #include "fontset.h"
42 #include "termhooks.h"
43 #include "termopts.h"
44 #include "termchar.h"
45 #include "disptab.h"
46 #include "buffer.h"
47 #include "window.h"
48 #include "keyboard.h"
49 #include "intervals.h"
50 #include "process.h"
51 #include "atimer.h"
52 #include "keymap.h"
54 #ifdef WINDOWSNT
55 #include "w32.h" /* for filename_from_utf16, filename_from_ansi */
56 #include "w32heap.h"
57 #endif
59 #ifndef WINDOWSNT
60 #include <io.h> /* for get_osfhandle */
61 #endif
63 #include <shellapi.h>
65 #include "font.h"
66 #include "w32font.h"
68 /* Fringe bitmaps. */
70 static int max_fringe_bmp = 0;
71 static HBITMAP *fringe_bmp = 0;
73 /* Temporary variables for w32_read_socket. */
75 static int last_mousemove_x = 0;
76 static int last_mousemove_y = 0;
78 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
79 #ifndef GET_WHEEL_DELTA_WPARAM
80 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
81 #endif
83 /* Non-zero means that a HELP_EVENT has been generated since Emacs
84 start. */
86 static int any_help_event_p;
88 extern unsigned int msh_mousewheel;
90 extern void free_frame_menubar (struct frame *);
92 extern int w32_codepage_for_font (char *fontname);
93 extern Cursor w32_load_cursor (LPCTSTR name);
95 #define x_any_window_to_frame x_window_to_frame
96 #define x_top_window_to_frame x_window_to_frame
99 /* This is display since w32 does not support multiple ones. */
100 struct w32_display_info one_w32_display_info;
101 struct w32_display_info *x_display_list;
103 #if _WIN32_WINNT < 0x0500 && !defined(_W64)
104 /* Pre Windows 2000, this was not available, but define it here so
105 that Emacs compiled on such a platform will run on newer versions.
106 MinGW64 (_W64) defines these unconditionally, so avoid redefining. */
108 typedef struct tagWCRANGE
110 WCHAR wcLow;
111 USHORT cGlyphs;
112 } WCRANGE;
114 typedef struct tagGLYPHSET
116 DWORD cbThis;
117 DWORD flAccel;
118 DWORD cGlyphsSupported;
119 DWORD cRanges;
120 WCRANGE ranges[1];
121 } GLYPHSET;
123 #endif /* compiling for pre-Win2k */
125 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
126 BOOL (WINAPI *pfnSetLayeredWindowAttributes) (HWND, COLORREF, BYTE, DWORD);
128 #ifndef LWA_ALPHA
129 #define LWA_ALPHA 0x02
130 #endif
131 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
132 later targets by MSVC headers. */
133 #ifndef WS_EX_LAYERED
134 #define WS_EX_LAYERED 0x80000
135 #endif
137 /* SM_CXVIRTUALSCREEN and SM_CYVIRTUALSCREEN are not defined on 95 and
138 NT4. */
139 #ifndef SM_CXVIRTUALSCREEN
140 #define SM_CXVIRTUALSCREEN 78
141 #endif
142 #ifndef SM_CYVIRTUALSCREEN
143 #define SM_CYVIRTUALSCREEN 79
144 #endif
146 /* The handle of the frame that currently owns the system caret. */
147 HWND w32_system_caret_hwnd;
148 int w32_system_caret_height;
149 int w32_system_caret_x;
150 int w32_system_caret_y;
151 struct window *w32_system_caret_window;
152 int w32_system_caret_hdr_height;
153 int w32_system_caret_mode_height;
154 DWORD dwWindowsThreadId = 0;
155 HANDLE hWindowsThread = NULL;
156 DWORD dwMainThreadId = 0;
157 HANDLE hMainThread = NULL;
159 int vertical_scroll_bar_min_handle;
160 int vertical_scroll_bar_top_border;
161 int vertical_scroll_bar_bottom_border;
163 int last_scroll_bar_drag_pos;
165 /* Keyboard code page - may be changed by language-change events. */
166 int w32_keyboard_codepage;
168 /* Incremented by w32_read_socket whenever it really tries to read
169 events. */
170 static int volatile input_signal_count;
172 #ifdef CYGWIN
173 int w32_message_fd = -1;
174 #endif /* CYGWIN */
176 static void w32_handle_tool_bar_click (struct frame *,
177 struct input_event *);
178 static void w32_define_cursor (Window, Cursor);
180 void x_lower_frame (struct frame *);
181 void x_scroll_bar_clear (struct frame *);
182 void x_wm_set_size_hint (struct frame *, long, bool);
183 void x_raise_frame (struct frame *);
184 void x_set_window_size (struct frame *, int, int, int, bool);
185 void x_wm_set_window_state (struct frame *, int);
186 void x_wm_set_icon_pixmap (struct frame *, int);
187 static void w32_initialize (void);
188 static void x_update_end (struct frame *);
189 static void w32_frame_up_to_date (struct frame *);
190 static void x_clear_frame (struct frame *);
191 static void frame_highlight (struct frame *);
192 static void frame_unhighlight (struct frame *);
193 static void x_new_focus_frame (struct w32_display_info *,
194 struct frame *);
195 static void x_focus_changed (int, int, struct w32_display_info *,
196 struct frame *, struct input_event *);
197 static void w32_detect_focus_change (struct w32_display_info *,
198 W32Msg *, struct input_event *);
199 static void w32_frame_rehighlight (struct frame *);
200 static void x_frame_rehighlight (struct w32_display_info *);
201 static void x_draw_hollow_cursor (struct window *, struct glyph_row *);
202 static void x_draw_bar_cursor (struct window *, struct glyph_row *, int,
203 enum text_cursor_kinds);
204 static void w32_clip_to_row (struct window *, struct glyph_row *,
205 enum glyph_row_area, HDC);
206 static BOOL my_show_window (struct frame *, HWND, int);
207 static void my_set_window_pos (HWND, HWND, int, int, int, int, UINT);
208 #if 0
209 static void my_set_focus (struct frame *, HWND);
210 #endif
211 static void my_set_foreground_window (HWND);
212 static void my_destroy_window (struct frame *, HWND);
213 static void w32fullscreen_hook (struct frame *);
215 #ifdef GLYPH_DEBUG
216 static void x_check_font (struct frame *, struct font *);
217 #endif
219 static Lisp_Object Qvendor_specific_keysyms;
220 static Lisp_Object Qadded, Qremoved, Qmodified;
221 static Lisp_Object Qrenamed_from, Qrenamed_to;
224 /***********************************************************************
225 Debugging
226 ***********************************************************************/
228 #if 0
230 /* This is a function useful for recording debugging information about
231 the sequence of occurrences in this file. */
233 struct record
235 char *locus;
236 int type;
239 struct record event_record[100];
241 int event_record_index;
243 record_event (char *locus, int type)
245 if (event_record_index == sizeof (event_record) / sizeof (struct record))
246 event_record_index = 0;
248 event_record[event_record_index].locus = locus;
249 event_record[event_record_index].type = type;
250 event_record_index++;
253 #endif /* 0 */
256 void
257 XChangeGC (void *ignore, XGCValues *gc, unsigned long mask,
258 XGCValues *xgcv)
260 if (mask & GCForeground)
261 gc->foreground = xgcv->foreground;
262 if (mask & GCBackground)
263 gc->background = xgcv->background;
264 if (mask & GCFont)
265 gc->font = xgcv->font;
268 XGCValues *
269 XCreateGC (void *ignore, Window window, unsigned long mask, XGCValues *xgcv)
271 XGCValues *gc = xzalloc (sizeof (XGCValues));
273 XChangeGC (ignore, gc, mask, xgcv);
275 return gc;
278 void
279 XGetGCValues (void *ignore, XGCValues *gc,
280 unsigned long mask, XGCValues *xgcv)
282 XChangeGC (ignore, xgcv, mask, gc);
285 static void
286 w32_set_clip_rectangle (HDC hdc, RECT *rect)
288 if (rect)
290 HRGN clip_region = CreateRectRgnIndirect (rect);
291 SelectClipRgn (hdc, clip_region);
292 DeleteObject (clip_region);
294 else
295 SelectClipRgn (hdc, NULL);
298 /* Restore clipping rectangle in S */
299 static void
300 w32_restore_glyph_string_clip (struct glyph_string *s)
302 RECT *r = s->clip;
303 int n = s->num_clips;
305 if (n == 1)
306 w32_set_clip_rectangle (s->hdc, r);
307 else if (n > 1)
309 HRGN clip1 = CreateRectRgnIndirect (r);
310 HRGN clip2 = CreateRectRgnIndirect (r + 1);
311 if (CombineRgn (clip1, clip1, clip2, RGN_OR) != ERROR)
312 SelectClipRgn (s->hdc, clip1);
313 DeleteObject (clip1);
314 DeleteObject (clip2);
319 Draw a wavy line under S. The wave fills wave_height pixels from y0.
321 x0 wave_length = 2
323 y0 * * * * *
324 |* * * * * * * * *
325 wave_height = 3 | * * * *
329 void
330 w32_draw_underwave (struct glyph_string *s, COLORREF color)
332 int wave_height = 3, wave_length = 2;
333 int dx, dy, x0, y0, width, x1, y1, x2, y2, odd, xmax;
334 XRectangle wave_clip, string_clip, final_clip;
335 RECT w32_final_clip, w32_string_clip;
336 HPEN hp, oldhp;
338 dx = wave_length;
339 dy = wave_height - 1;
340 x0 = s->x;
341 y0 = s->ybase - wave_height + 3;
342 width = s->width;
343 xmax = x0 + width;
345 /* Find and set clipping rectangle */
347 wave_clip.x = x0;
348 wave_clip.y = y0;
349 wave_clip.width = width;
350 wave_clip.height = wave_height;
352 get_glyph_string_clip_rect (s, &w32_string_clip);
353 CONVERT_TO_XRECT (string_clip, w32_string_clip);
355 if (!x_intersect_rectangles (&wave_clip, &string_clip, &final_clip))
356 return;
358 hp = CreatePen (PS_SOLID, 0, color);
359 oldhp = SelectObject (s->hdc, hp);
360 CONVERT_FROM_XRECT (final_clip, w32_final_clip);
361 w32_set_clip_rectangle (s->hdc, &w32_final_clip);
363 /* Draw the waves */
365 x1 = x0 - (x0 % dx);
366 x2 = x1 + dx;
367 odd = (x1/dx) % 2;
368 y1 = y2 = y0;
370 if (odd)
371 y1 += dy;
372 else
373 y2 += dy;
375 MoveToEx (s->hdc, x1, y1, NULL);
377 while (x1 <= xmax)
379 LineTo (s->hdc, x2, y2);
380 x1 = x2, y1 = y2;
381 x2 += dx, y2 = y0 + odd*dy;
382 odd = !odd;
385 /* Restore previous pen and clipping rectangle(s) */
386 w32_restore_glyph_string_clip (s);
387 SelectObject (s->hdc, oldhp);
388 DeleteObject (hp);
391 /* Draw a hollow rectangle at the specified position. */
392 void
393 w32_draw_rectangle (HDC hdc, XGCValues *gc, int x, int y,
394 int width, int height)
396 HBRUSH hb, oldhb;
397 HPEN hp, oldhp;
399 hb = CreateSolidBrush (gc->background);
400 hp = CreatePen (PS_SOLID, 0, gc->foreground);
401 oldhb = SelectObject (hdc, hb);
402 oldhp = SelectObject (hdc, hp);
404 Rectangle (hdc, x, y, x + width, y + height);
406 SelectObject (hdc, oldhb);
407 SelectObject (hdc, oldhp);
408 DeleteObject (hb);
409 DeleteObject (hp);
412 /* Draw a filled rectangle at the specified position. */
413 void
414 w32_fill_rect (struct frame *f, HDC hdc, COLORREF pix, RECT *lprect)
416 HBRUSH hb;
418 hb = CreateSolidBrush (pix);
419 FillRect (hdc, lprect, hb);
420 DeleteObject (hb);
423 void
424 w32_clear_window (struct frame *f)
426 RECT rect;
427 HDC hdc = get_frame_dc (f);
429 /* Under certain conditions, this can be called at startup with
430 a console frame pointer before the GUI frame is created. An HDC
431 of 0 indicates this. */
432 if (hdc)
434 GetClientRect (FRAME_W32_WINDOW (f), &rect);
435 w32_clear_rect (f, hdc, &rect);
438 release_frame_dc (f, hdc);
441 #define OPAQUE_FRAME 255
443 void
444 x_set_frame_alpha (struct frame *f)
446 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
447 double alpha = 1.0;
448 double alpha_min = 1.0;
449 BYTE opac;
450 LONG ex_style;
451 HWND window = FRAME_W32_WINDOW (f);
453 /* Older versions of Windows do not support transparency. */
454 if (!pfnSetLayeredWindowAttributes)
455 return;
457 if (dpyinfo->x_highlight_frame == f)
458 alpha = f->alpha[0];
459 else
460 alpha = f->alpha[1];
462 if (FLOATP (Vframe_alpha_lower_limit))
463 alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
464 else if (INTEGERP (Vframe_alpha_lower_limit))
465 alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
467 if (alpha < 0.0)
468 return;
469 else if (alpha > 1.0)
470 alpha = 1.0;
471 else if (alpha < alpha_min && alpha_min <= 1.0)
472 alpha = alpha_min;
474 opac = alpha * OPAQUE_FRAME;
476 ex_style = GetWindowLong (window, GWL_EXSTYLE);
478 if (opac == OPAQUE_FRAME)
479 ex_style &= ~WS_EX_LAYERED;
480 else
481 ex_style |= WS_EX_LAYERED;
483 SetWindowLong (window, GWL_EXSTYLE, ex_style);
485 if (opac != OPAQUE_FRAME)
486 pfnSetLayeredWindowAttributes (window, 0, opac, LWA_ALPHA);
490 x_display_pixel_height (struct w32_display_info *dpyinfo)
492 int pixels = GetSystemMetrics (SM_CYVIRTUALSCREEN);
494 if (pixels == 0)
495 /* Fallback for Windows 95 or NT 4.0. */
496 pixels = GetSystemMetrics (SM_CYSCREEN);
498 return pixels;
502 x_display_pixel_width (struct w32_display_info *dpyinfo)
504 int pixels = GetSystemMetrics (SM_CXVIRTUALSCREEN);
506 if (pixels == 0)
507 /* Fallback for Windows 95 or NT 4.0. */
508 pixels = GetSystemMetrics (SM_CXSCREEN);
510 return pixels;
514 /***********************************************************************
515 Starting and ending an update
516 ***********************************************************************/
518 /* Start an update of frame F. This function is installed as a hook
519 for update_begin, i.e. it is called when update_begin is called.
520 This function is called prior to calls to x_update_window_begin for
521 each window being updated. */
523 static void
524 x_update_begin (struct frame *f)
526 struct w32_display_info *display_info = FRAME_DISPLAY_INFO (f);
528 if (! FRAME_W32_P (f))
529 return;
531 /* Regenerate display palette before drawing if list of requested
532 colors has changed. */
533 if (display_info->regen_palette)
535 w32_regenerate_palette (f);
536 display_info->regen_palette = FALSE;
541 /* Start update of window W. */
543 static void
544 x_update_window_begin (struct window *w)
546 struct frame *f = XFRAME (WINDOW_FRAME (w));
547 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
549 /* Hide the system caret during an update. */
550 if (w32_use_visible_system_caret && w32_system_caret_hwnd)
552 SendMessage (w32_system_caret_hwnd, WM_EMACS_HIDE_CARET, 0, 0);
555 w->output_cursor = w->cursor;
557 block_input ();
559 if (f == hlinfo->mouse_face_mouse_frame)
561 /* Don't do highlighting for mouse motion during the update. */
562 hlinfo->mouse_face_defer = 1;
564 /* If F needs to be redrawn, simply forget about any prior mouse
565 highlighting. */
566 if (FRAME_GARBAGED_P (f))
567 hlinfo->mouse_face_window = Qnil;
569 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
570 their mouse_face_p flag set, which means that they are always
571 unequal to rows in a desired matrix which never have that
572 flag set. So, rows containing mouse-face glyphs are never
573 scrolled, and we don't have to switch the mouse highlight off
574 here to prevent it from being scrolled. */
576 /* Can we tell that this update does not affect the window
577 where the mouse highlight is? If so, no need to turn off.
578 Likewise, don't do anything if the frame is garbaged;
579 in that case, the frame's current matrix that we would use
580 is all wrong, and we will redisplay that line anyway. */
581 if (!NILP (hlinfo->mouse_face_window)
582 && w == XWINDOW (hlinfo->mouse_face_window))
584 int i;
586 for (i = 0; i < w->desired_matrix->nrows; ++i)
587 if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
588 break;
590 if (i < w->desired_matrix->nrows)
591 clear_mouse_face (hlinfo);
593 #endif /* 0 */
596 unblock_input ();
599 /* Draw a vertical window border from (x,y0) to (x,y1) */
601 static void
602 w32_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
604 struct frame *f = XFRAME (WINDOW_FRAME (w));
605 RECT r;
606 HDC hdc;
607 struct face *face;
609 r.left = x;
610 r.right = x + 1;
611 r.top = y0;
612 r.bottom = y1;
614 hdc = get_frame_dc (f);
615 face = FACE_FROM_ID (f, VERTICAL_BORDER_FACE_ID);
616 if (face)
617 w32_fill_rect (f, hdc, face->foreground, &r);
618 else
619 w32_fill_rect (f, hdc, FRAME_FOREGROUND_PIXEL (f), &r);
621 release_frame_dc (f, hdc);
625 /* Draw a window divider from (x0, y0) to (x1, y1) */
627 static void
628 w32_draw_window_divider (struct window *w, int x0, int x1, int y0, int y1)
630 struct frame *f = XFRAME (WINDOW_FRAME (w));
631 HDC hdc = get_frame_dc (f);
632 struct face *face = FACE_FROM_ID (f, WINDOW_DIVIDER_FACE_ID);
633 struct face *face_first = FACE_FROM_ID (f, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID);
634 struct face *face_last = FACE_FROM_ID (f, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID);
635 unsigned long color = face ? face->foreground : FRAME_FOREGROUND_PIXEL (f);
636 unsigned long color_first = (face_first
637 ? face_first->foreground
638 : FRAME_FOREGROUND_PIXEL (f));
639 unsigned long color_last = (face_last
640 ? face_last->foreground
641 : FRAME_FOREGROUND_PIXEL (f));
643 if (y1 - y0 > x1 - x0 && x1 - x0 > 2)
644 /* Vertical. */
646 w32_fill_area_abs (f, hdc, color_first, x0, y0, x0 + 1, y1);
647 w32_fill_area_abs (f, hdc, color, x0 + 1, y0, x1 - 1, y1);
648 w32_fill_area_abs (f, hdc, color_last, x1 - 1, y0, x1, y1);
650 else if (x1 - x0 > y1 - y0 && y1 - y0 > 3)
651 /* Horizontal. */
653 w32_fill_area_abs (f, hdc, color_first, x0, y0, x1, y0 + 1);
654 w32_fill_area_abs (f, hdc, color, x0, y0 + 1, x1, y1 - 1);
655 w32_fill_area_abs (f, hdc, color_last, x0, y1 - 1, x1, y1);
657 else
658 w32_fill_area_abs (f, hdc, color, x0, y0, x1, y1);
660 release_frame_dc (f, hdc);
663 /* End update of window W.
665 Draw vertical borders between horizontally adjacent windows, and
666 display W's cursor if CURSOR_ON_P is non-zero.
668 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
669 glyphs in mouse-face were overwritten. In that case we have to
670 make sure that the mouse-highlight is properly redrawn.
672 W may be a menu bar pseudo-window in case we don't have X toolkit
673 support. Such windows don't have a cursor, so don't display it
674 here. */
676 static void
677 x_update_window_end (struct window *w, bool cursor_on_p,
678 bool mouse_face_overwritten_p)
680 if (!w->pseudo_window_p)
682 block_input ();
684 if (cursor_on_p)
685 display_and_set_cursor (w, 1,
686 w->output_cursor.hpos, w->output_cursor.vpos,
687 w->output_cursor.x, w->output_cursor.y);
689 if (draw_window_fringes (w, 1))
691 if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
692 x_draw_right_divider (w);
693 else
694 x_draw_vertical_border (w);
697 unblock_input ();
700 /* If a row with mouse-face was overwritten, arrange for
701 XTframe_up_to_date to redisplay the mouse highlight. */
702 if (mouse_face_overwritten_p)
704 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
706 hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
707 hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
708 hlinfo->mouse_face_window = Qnil;
711 /* Unhide the caret. This won't actually show the cursor, unless it
712 was visible before the corresponding call to HideCaret in
713 x_update_window_begin. */
714 if (w32_use_visible_system_caret && w32_system_caret_hwnd)
716 SendMessage (w32_system_caret_hwnd, WM_EMACS_SHOW_CARET, 0, 0);
721 /* End update of frame F. This function is installed as a hook in
722 update_end. */
724 static void
725 x_update_end (struct frame *f)
727 if (! FRAME_W32_P (f))
728 return;
730 /* Mouse highlight may be displayed again. */
731 MOUSE_HL_INFO (f)->mouse_face_defer = 0;
735 /* This function is called from various places in xdisp.c
736 whenever a complete update has been performed. */
738 static void
739 w32_frame_up_to_date (struct frame *f)
741 if (FRAME_W32_P (f))
742 FRAME_MOUSE_UPDATE (f);
746 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
747 arrow bitmaps, or clear the fringes if no bitmaps are required
748 before DESIRED_ROW is made current. This function is called from
749 update_window_line only if it is known that there are differences
750 between bitmaps to be drawn between current row and DESIRED_ROW. */
752 static void
753 x_after_update_window_line (struct window *w, struct glyph_row *desired_row)
755 struct frame *f;
756 int width, height;
758 eassert (w);
760 if (!desired_row->mode_line_p && !w->pseudo_window_p)
761 desired_row->redraw_fringe_bitmaps_p = 1;
763 /* When a window has disappeared, make sure that no rest of
764 full-width rows stays visible in the internal border. Could
765 check here if updated window is the leftmost/rightmost window,
766 but I guess it's not worth doing since vertically split windows
767 are almost never used, internal border is rarely set, and the
768 overhead is very small. */
769 if (windows_or_buffers_changed
770 && desired_row->full_width_p
771 && (f = XFRAME (w->frame),
772 width = FRAME_INTERNAL_BORDER_WIDTH (f),
773 width != 0)
774 && (height = desired_row->visible_height,
775 height > 0))
777 int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
779 block_input ();
781 HDC hdc = get_frame_dc (f);
782 w32_clear_area (f, hdc, 0, y, width, height);
783 w32_clear_area (f, hdc, FRAME_PIXEL_WIDTH (f) - width,
784 y, width, height);
785 release_frame_dc (f, hdc);
787 unblock_input ();
792 /* Draw the bitmap WHICH in one of the left or right fringes of
793 window W. ROW is the glyph row for which to display the bitmap; it
794 determines the vertical position at which the bitmap has to be
795 drawn. */
797 static void
798 w32_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
799 struct draw_fringe_bitmap_params *p)
801 struct frame *f = XFRAME (WINDOW_FRAME (w));
802 HDC hdc;
803 struct face *face = p->face;
805 hdc = get_frame_dc (f);
807 /* Must clip because of partially visible lines. */
808 w32_clip_to_row (w, row, ANY_AREA, hdc);
810 if (p->bx >= 0 && !p->overlay_p)
811 w32_fill_area (f, hdc, face->background,
812 p->bx, p->by, p->nx, p->ny);
814 if (p->which && p->which < max_fringe_bmp)
816 HBITMAP pixmap = fringe_bmp[p->which];
817 HDC compat_hdc;
818 HANDLE horig_obj;
820 compat_hdc = CreateCompatibleDC (hdc);
822 SaveDC (hdc);
824 horig_obj = SelectObject (compat_hdc, pixmap);
826 /* Paint overlays transparently. */
827 if (p->overlay_p)
829 HBRUSH h_brush, h_orig_brush;
831 SetTextColor (hdc, BLACK_PIX_DEFAULT (f));
832 SetBkColor (hdc, WHITE_PIX_DEFAULT (f));
833 h_brush = CreateSolidBrush (face->foreground);
834 h_orig_brush = SelectObject (hdc, h_brush);
836 BitBlt (hdc, p->x, p->y, p->wd, p->h,
837 compat_hdc, 0, p->dh,
838 DSTINVERT);
839 BitBlt (hdc, p->x, p->y, p->wd, p->h,
840 compat_hdc, 0, p->dh,
841 0x2E064A);
842 BitBlt (hdc, p->x, p->y, p->wd, p->h,
843 compat_hdc, 0, p->dh,
844 DSTINVERT);
846 SelectObject (hdc, h_orig_brush);
847 DeleteObject (h_brush);
849 else
851 SetTextColor (hdc, face->background);
852 SetBkColor (hdc, (p->cursor_p
853 ? f->output_data.w32->cursor_pixel
854 : face->foreground));
856 BitBlt (hdc, p->x, p->y, p->wd, p->h,
857 compat_hdc, 0, p->dh,
858 SRCCOPY);
861 SelectObject (compat_hdc, horig_obj);
862 DeleteDC (compat_hdc);
863 RestoreDC (hdc, -1);
866 w32_set_clip_rectangle (hdc, NULL);
868 release_frame_dc (f, hdc);
871 static void
872 w32_define_fringe_bitmap (int which, unsigned short *bits, int h, int wd)
874 if (which >= max_fringe_bmp)
876 int i = max_fringe_bmp;
877 max_fringe_bmp = which + 20;
878 fringe_bmp = (HBITMAP *) xrealloc (fringe_bmp, max_fringe_bmp * sizeof (HBITMAP));
879 while (i < max_fringe_bmp)
880 fringe_bmp[i++] = 0;
883 fringe_bmp[which] = CreateBitmap (wd, h, 1, 1, bits);
886 static void
887 w32_destroy_fringe_bitmap (int which)
889 if (which >= max_fringe_bmp)
890 return;
892 if (fringe_bmp[which])
893 DeleteObject (fringe_bmp[which]);
894 fringe_bmp[which] = 0;
897 /***********************************************************************
898 Display Iterator
899 ***********************************************************************/
901 /* Function prototypes of this page. */
903 static void x_set_glyph_string_clipping (struct glyph_string *);
904 static void x_set_glyph_string_gc (struct glyph_string *);
905 static void x_draw_glyph_string_background (struct glyph_string *,
906 int);
907 static void x_draw_glyph_string_foreground (struct glyph_string *);
908 static void x_draw_composite_glyph_string_foreground (struct glyph_string *);
909 static void x_draw_glyph_string_box (struct glyph_string *);
910 static void x_draw_glyph_string (struct glyph_string *);
911 static void x_set_cursor_gc (struct glyph_string *);
912 static void x_set_mode_line_face_gc (struct glyph_string *);
913 static void x_set_mouse_face_gc (struct glyph_string *);
914 static int w32_alloc_lighter_color (struct frame *, COLORREF *, double, int);
915 static void w32_setup_relief_color (struct frame *, struct relief *,
916 double, int, COLORREF);
917 static void x_setup_relief_colors (struct glyph_string *);
918 static void x_draw_image_glyph_string (struct glyph_string *);
919 static void x_draw_image_relief (struct glyph_string *);
920 static void x_draw_image_foreground (struct glyph_string *);
921 static void w32_draw_image_foreground_1 (struct glyph_string *, HBITMAP);
922 static void x_clear_glyph_string_rect (struct glyph_string *, int,
923 int, int, int);
924 static void w32_draw_relief_rect (struct frame *, int, int, int, int,
925 int, int, int, int, int, int,
926 RECT *);
927 static void w32_draw_box_rect (struct glyph_string *, int, int, int, int,
928 int, int, int, RECT *);
931 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
932 face. */
934 static void
935 x_set_cursor_gc (struct glyph_string *s)
937 if (s->font == FRAME_FONT (s->f)
938 && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
939 && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
940 && !s->cmp)
941 s->gc = s->f->output_data.w32->cursor_gc;
942 else
944 /* Cursor on non-default face: must merge. */
945 XGCValues xgcv;
946 unsigned long mask;
948 xgcv.background = s->f->output_data.w32->cursor_pixel;
949 xgcv.foreground = s->face->background;
951 /* If the glyph would be invisible, try a different foreground. */
952 if (xgcv.foreground == xgcv.background)
953 xgcv.foreground = s->face->foreground;
954 if (xgcv.foreground == xgcv.background)
955 xgcv.foreground = s->f->output_data.w32->cursor_foreground_pixel;
956 if (xgcv.foreground == xgcv.background)
957 xgcv.foreground = s->face->foreground;
959 /* Make sure the cursor is distinct from text in this face. */
960 if (xgcv.background == s->face->background
961 && xgcv.foreground == s->face->foreground)
963 xgcv.background = s->face->foreground;
964 xgcv.foreground = s->face->background;
967 IF_DEBUG (x_check_font (s->f, s->font));
968 xgcv.font = s->font;
969 mask = GCForeground | GCBackground | GCFont;
971 if (FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc)
972 XChangeGC (NULL, FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc,
973 mask, &xgcv);
974 else
975 FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc
976 = XCreateGC (NULL, s->window, mask, &xgcv);
978 s->gc = FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc;
983 /* Set up S->gc of glyph string S for drawing text in mouse face. */
985 static void
986 x_set_mouse_face_gc (struct glyph_string *s)
988 int face_id;
989 struct face *face;
991 /* What face has to be used last for the mouse face? */
992 face_id = MOUSE_HL_INFO (s->f)->mouse_face_face_id;
993 face = FACE_FROM_ID (s->f, face_id);
994 if (face == NULL)
995 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
997 if (s->first_glyph->type == CHAR_GLYPH)
998 face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch, -1, Qnil);
999 else
1000 face_id = FACE_FOR_CHAR (s->f, face, 0, -1, Qnil);
1001 s->face = FACE_FROM_ID (s->f, face_id);
1002 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
1004 /* If font in this face is same as S->font, use it. */
1005 if (s->font == s->face->font)
1006 s->gc = s->face->gc;
1007 else
1009 /* Otherwise construct scratch_cursor_gc with values from FACE
1010 but font FONT. */
1011 XGCValues xgcv;
1012 unsigned long mask;
1014 xgcv.background = s->face->background;
1015 xgcv.foreground = s->face->foreground;
1016 IF_DEBUG (x_check_font (s->f, s->font));
1017 xgcv.font = s->font;
1018 mask = GCForeground | GCBackground | GCFont;
1020 if (FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc)
1021 XChangeGC (NULL, FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc,
1022 mask, &xgcv);
1023 else
1024 FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc
1025 = XCreateGC (NULL, s->window, mask, &xgcv);
1027 s->gc = FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc;
1030 eassert (s->gc != 0);
1034 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1035 Faces to use in the mode line have already been computed when the
1036 matrix was built, so there isn't much to do, here. */
1038 static inline void
1039 x_set_mode_line_face_gc (struct glyph_string *s)
1041 s->gc = s->face->gc;
1045 /* Set S->gc of glyph string S for drawing that glyph string. Set
1046 S->stippled_p to a non-zero value if the face of S has a stipple
1047 pattern. */
1049 static inline void
1050 x_set_glyph_string_gc (struct glyph_string *s)
1052 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
1054 if (s->hl == DRAW_NORMAL_TEXT)
1056 s->gc = s->face->gc;
1057 s->stippled_p = s->face->stipple != 0;
1059 else if (s->hl == DRAW_INVERSE_VIDEO)
1061 x_set_mode_line_face_gc (s);
1062 s->stippled_p = s->face->stipple != 0;
1064 else if (s->hl == DRAW_CURSOR)
1066 x_set_cursor_gc (s);
1067 s->stippled_p = 0;
1069 else if (s->hl == DRAW_MOUSE_FACE)
1071 x_set_mouse_face_gc (s);
1072 s->stippled_p = s->face->stipple != 0;
1074 else if (s->hl == DRAW_IMAGE_RAISED
1075 || s->hl == DRAW_IMAGE_SUNKEN)
1077 s->gc = s->face->gc;
1078 s->stippled_p = s->face->stipple != 0;
1080 else
1082 s->gc = s->face->gc;
1083 s->stippled_p = s->face->stipple != 0;
1086 /* GC must have been set. */
1087 eassert (s->gc != 0);
1091 /* Set clipping for output of glyph string S. S may be part of a mode
1092 line or menu if we don't have X toolkit support. */
1094 static inline void
1095 x_set_glyph_string_clipping (struct glyph_string *s)
1097 RECT *r = s->clip;
1098 int n = get_glyph_string_clip_rects (s, r, 2);
1100 if (n == 1)
1101 w32_set_clip_rectangle (s->hdc, r);
1102 else if (n > 1)
1104 HRGN clip1 = CreateRectRgnIndirect (r);
1105 HRGN clip2 = CreateRectRgnIndirect (r + 1);
1106 if (CombineRgn (clip1, clip1, clip2, RGN_OR) != ERROR)
1107 SelectClipRgn (s->hdc, clip1);
1108 DeleteObject (clip1);
1109 DeleteObject (clip2);
1111 s->num_clips = n;
1114 /* Set SRC's clipping for output of glyph string DST. This is called
1115 when we are drawing DST's left_overhang or right_overhang only in
1116 the area of SRC. */
1118 static void
1119 x_set_glyph_string_clipping_exactly (struct glyph_string *src,
1120 struct glyph_string *dst)
1122 RECT r;
1124 r.left = src->x;
1125 r.right = r.left + src->width;
1126 r.top = src->y;
1127 r.bottom = r.top + src->height;
1128 dst->clip[0] = r;
1129 dst->num_clips = 1;
1130 w32_set_clip_rectangle (dst->hdc, &r);
1133 /* RIF:
1134 Compute left and right overhang of glyph string S. */
1136 static void
1137 w32_compute_glyph_string_overhangs (struct glyph_string *s)
1139 if (s->cmp == NULL
1140 && s->first_glyph->type == CHAR_GLYPH
1141 && !s->font_not_found_p)
1143 unsigned *code = alloca (sizeof (unsigned) * s->nchars);
1144 struct font *font = s->font;
1145 struct font_metrics metrics;
1146 int i;
1148 for (i = 0; i < s->nchars; i++)
1149 code[i] = s->char2b[i];
1150 font->driver->text_extents (font, code, s->nchars, &metrics);
1151 s->right_overhang = (metrics.rbearing > metrics.width
1152 ? metrics.rbearing - metrics.width : 0);
1153 s->left_overhang = metrics.lbearing < 0 ? -metrics.lbearing : 0;
1155 else if (s->cmp)
1157 s->right_overhang = s->cmp->rbearing - s->cmp->pixel_width;
1158 s->left_overhang = -s->cmp->lbearing;
1162 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1164 static inline void
1165 x_clear_glyph_string_rect (struct glyph_string *s,
1166 int x, int y, int w, int h)
1168 int real_x = x;
1169 int real_y = y;
1170 int real_w = w;
1171 int real_h = h;
1172 #if 0
1173 /* Take clipping into account. */
1174 if (s->gc->clip_mask == Rect)
1176 real_x = max (real_x, s->gc->clip_rectangle.left);
1177 real_y = max (real_y, s->gc->clip_rectangle.top);
1178 real_w = min (real_w, s->gc->clip_rectangle.right
1179 - s->gc->clip_rectangle.left);
1180 real_h = min (real_h, s->gc->clip_rectangle.bottom
1181 - s->gc->clip_rectangle.top);
1183 #endif
1184 w32_fill_area (s->f, s->hdc, s->gc->background, real_x, real_y,
1185 real_w, real_h);
1189 /* Draw the background of glyph_string S. If S->background_filled_p
1190 is non-zero don't draw it. FORCE_P non-zero means draw the
1191 background even if it wouldn't be drawn normally. This is used
1192 when a string preceding S draws into the background of S, or S
1193 contains the first component of a composition. */
1195 static void
1196 x_draw_glyph_string_background (struct glyph_string *s, int force_p)
1198 /* Nothing to do if background has already been drawn or if it
1199 shouldn't be drawn in the first place. */
1200 if (!s->background_filled_p)
1202 int box_line_width = max (s->face->box_line_width, 0);
1204 #if 0 /* TODO: stipple */
1205 if (s->stippled_p)
1207 /* Fill background with a stipple pattern. */
1208 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
1209 XFillRectangle (s->display, s->window, s->gc, s->x,
1210 s->y + box_line_width,
1211 s->background_width,
1212 s->height - 2 * box_line_width);
1213 XSetFillStyle (s->display, s->gc, FillSolid);
1214 s->background_filled_p = 1;
1216 else
1217 #endif
1218 if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
1219 || s->font_not_found_p
1220 || s->extends_to_end_of_line_p
1221 || force_p)
1223 x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
1224 s->background_width,
1225 s->height - 2 * box_line_width);
1226 s->background_filled_p = 1;
1232 /* Draw the foreground of glyph string S. */
1234 static void
1235 x_draw_glyph_string_foreground (struct glyph_string *s)
1237 int i, x;
1239 /* If first glyph of S has a left box line, start drawing the text
1240 of S to the right of that box line. */
1241 if (s->face->box != FACE_NO_BOX
1242 && s->first_glyph->left_box_line_p)
1243 x = s->x + eabs (s->face->box_line_width);
1244 else
1245 x = s->x;
1247 SetTextColor (s->hdc, s->gc->foreground);
1248 SetBkColor (s->hdc, s->gc->background);
1249 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1251 /* Draw characters of S as rectangles if S's font could not be
1252 loaded. */
1253 if (s->font_not_found_p)
1255 for (i = 0; i < s->nchars; ++i)
1257 struct glyph *g = s->first_glyph + i;
1259 w32_draw_rectangle (s->hdc, s->gc, x, s->y, g->pixel_width - 1,
1260 s->height - 1);
1261 x += g->pixel_width;
1264 else
1266 struct font *font = s->font;
1267 int boff = font->baseline_offset;
1268 int y;
1269 HFONT old_font;
1271 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1273 if (font->vertical_centering)
1274 boff = VCENTER_BASELINE_OFFSET (font, s->f) - boff;
1276 y = s->ybase - boff;
1277 if (s->for_overlaps
1278 || (s->background_filled_p && s->hl != DRAW_CURSOR))
1279 font->driver->draw (s, 0, s->nchars, x, y, 0);
1280 else
1281 font->driver->draw (s, 0, s->nchars, x, y, 1);
1282 if (s->face->overstrike)
1283 font->driver->draw (s, 0, s->nchars, x + 1, y, 0);
1285 SelectObject (s->hdc, old_font);
1289 /* Draw the foreground of composite glyph string S. */
1291 static void
1292 x_draw_composite_glyph_string_foreground (struct glyph_string *s)
1294 int i, j, x;
1295 struct font *font = s->font;
1297 /* If first glyph of S has a left box line, start drawing the text
1298 of S to the right of that box line. */
1299 if (s->face && s->face->box != FACE_NO_BOX
1300 && s->first_glyph->left_box_line_p)
1301 x = s->x + eabs (s->face->box_line_width);
1302 else
1303 x = s->x;
1305 /* S is a glyph string for a composition. S->cmp_from is the index
1306 of the first character drawn for glyphs of this composition.
1307 S->cmp_from == 0 means we are drawing the very first character of
1308 this composition. */
1310 SetTextColor (s->hdc, s->gc->foreground);
1311 SetBkColor (s->hdc, s->gc->background);
1312 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1314 /* Draw a rectangle for the composition if the font for the very
1315 first character of the composition could not be loaded. */
1316 if (s->font_not_found_p)
1318 if (s->cmp_from == 0)
1319 w32_draw_rectangle (s->hdc, s->gc, x, s->y, s->width - 1,
1320 s->height - 1);
1322 else if (! s->first_glyph->u.cmp.automatic)
1324 int y = s->ybase;
1325 HFONT old_font;
1327 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1329 for (i = 0, j = s->cmp_from; i < s->nchars; i++, j++)
1330 /* TAB in a composition means display glyphs with padding
1331 space on the left or right. */
1332 if (COMPOSITION_GLYPH (s->cmp, j) != '\t')
1334 int xx = x + s->cmp->offsets[j * 2];
1335 int yy = y - s->cmp->offsets[j * 2 + 1];
1337 font->driver->draw (s, j, j + 1, xx, yy, 0);
1338 if (s->face->overstrike)
1339 font->driver->draw (s, j, j + 1, xx + 1, yy, 0);
1341 SelectObject (s->hdc, old_font);
1343 else
1345 Lisp_Object gstring = composition_gstring_from_id (s->cmp_id);
1346 Lisp_Object glyph;
1347 int y = s->ybase;
1348 int width = 0;
1349 HFONT old_font;
1351 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1353 for (i = j = s->cmp_from; i < s->cmp_to; i++)
1355 glyph = LGSTRING_GLYPH (gstring, i);
1356 if (NILP (LGLYPH_ADJUSTMENT (glyph)))
1357 width += LGLYPH_WIDTH (glyph);
1358 else
1360 int xoff, yoff, wadjust;
1362 if (j < i)
1364 font->driver->draw (s, j, i, x, y, 0);
1365 x += width;
1367 xoff = LGLYPH_XOFF (glyph);
1368 yoff = LGLYPH_YOFF (glyph);
1369 wadjust = LGLYPH_WADJUST (glyph);
1370 font->driver->draw (s, i, i + 1, x + xoff, y + yoff, 0);
1371 x += wadjust;
1372 j = i + 1;
1373 width = 0;
1376 if (j < i)
1377 font->driver->draw (s, j, i, x, y, 0);
1379 SelectObject (s->hdc, old_font);
1384 /* Draw the foreground of glyph string S for glyphless characters. */
1386 static void
1387 x_draw_glyphless_glyph_string_foreground (struct glyph_string *s)
1389 struct glyph *glyph = s->first_glyph;
1390 XChar2b char2b[8];
1391 int x, i, j;
1392 int with_background;
1394 /* If first glyph of S has a left box line, start drawing the text
1395 of S to the right of that box line. */
1396 if (s->face->box != FACE_NO_BOX
1397 && s->first_glyph->left_box_line_p)
1398 x = s->x + eabs (s->face->box_line_width);
1399 else
1400 x = s->x;
1402 SetTextColor (s->hdc, s->gc->foreground);
1403 SetBkColor (s->hdc, s->gc->background);
1404 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1406 s->char2b = char2b;
1407 with_background = ! (s->for_overlaps
1408 || (s->background_filled_p && s->hl != DRAW_CURSOR));
1409 for (i = 0; i < s->nchars; i++, glyph++)
1411 char buf[7], *str = NULL;
1412 int len = glyph->u.glyphless.len;
1414 if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_ACRONYM)
1416 if (len > 1
1417 && CHAR_TABLE_P (Vglyphless_char_display)
1418 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display))
1419 >= 1))
1421 Lisp_Object acronym
1422 = (! glyph->u.glyphless.for_no_font
1423 ? CHAR_TABLE_REF (Vglyphless_char_display,
1424 glyph->u.glyphless.ch)
1425 : XCHAR_TABLE (Vglyphless_char_display)->extras[0]);
1426 if (STRINGP (acronym))
1427 str = SSDATA (acronym);
1430 else if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_HEX_CODE)
1432 sprintf ((char *) buf, "%0*X",
1433 glyph->u.glyphless.ch < 0x10000 ? 4 : 6,
1434 glyph->u.glyphless.ch);
1435 str = buf;
1438 if (glyph->u.glyphless.method != GLYPHLESS_DISPLAY_THIN_SPACE)
1439 w32_draw_rectangle (s->hdc, s->gc,
1440 x, s->ybase - glyph->ascent,
1441 glyph->pixel_width - 1,
1442 glyph->ascent + glyph->descent - 1);
1443 if (str)
1445 struct font *font = s->font;
1446 int upper_len = (len + 1) / 2;
1447 unsigned code;
1448 HFONT old_font;
1450 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1451 /* It is certain that all LEN characters in STR are ASCII. */
1452 for (j = 0; j < len; j++)
1454 code = font->driver->encode_char (font, str[j]);
1455 STORE_XCHAR2B (char2b + j, code >> 8, code & 0xFF);
1457 font->driver->draw (s, 0, upper_len,
1458 x + glyph->slice.glyphless.upper_xoff,
1459 s->ybase + glyph->slice.glyphless.upper_yoff,
1460 with_background);
1461 font->driver->draw (s, upper_len, len,
1462 x + glyph->slice.glyphless.lower_xoff,
1463 s->ybase + glyph->slice.glyphless.lower_yoff,
1464 with_background);
1465 SelectObject (s->hdc, old_font);
1467 x += glyph->pixel_width;
1472 /* Brightness beyond which a color won't have its highlight brightness
1473 boosted.
1475 Nominally, highlight colors for `3d' faces are calculated by
1476 brightening an object's color by a constant scale factor, but this
1477 doesn't yield good results for dark colors, so for colors whose
1478 brightness is less than this value (on a scale of 0-255) have to
1479 use an additional additive factor.
1481 The value here is set so that the default menu-bar/mode-line color
1482 (grey75) will not have its highlights changed at all. */
1483 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1486 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1487 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1488 If this produces the same color as COLOR, try a color where all RGB
1489 values have DELTA added. Return the allocated color in *COLOR.
1490 DISPLAY is the X display, CMAP is the colormap to operate on.
1491 Value is non-zero if successful. */
1493 static int
1494 w32_alloc_lighter_color (struct frame *f, COLORREF *color,
1495 double factor, int delta)
1497 COLORREF new;
1498 long bright;
1500 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1501 delta /= 256;
1503 /* Change RGB values by specified FACTOR. Avoid overflow! */
1504 eassert (factor >= 0);
1505 new = PALETTERGB (min (0xff, factor * GetRValue (*color)),
1506 min (0xff, factor * GetGValue (*color)),
1507 min (0xff, factor * GetBValue (*color)));
1509 /* Calculate brightness of COLOR. */
1510 bright = (2 * GetRValue (*color) + 3 * GetGValue (*color)
1511 + GetBValue (*color)) / 6;
1513 /* We only boost colors that are darker than
1514 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1515 if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
1516 /* Make an additive adjustment to NEW, because it's dark enough so
1517 that scaling by FACTOR alone isn't enough. */
1519 /* How far below the limit this color is (0 - 1, 1 being darker). */
1520 double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
1521 /* The additive adjustment. */
1522 int min_delta = delta * dimness * factor / 2;
1524 if (factor < 1)
1525 new = PALETTERGB (max (0, min (0xff, min_delta - GetRValue (*color))),
1526 max (0, min (0xff, min_delta - GetGValue (*color))),
1527 max (0, min (0xff, min_delta - GetBValue (*color))));
1528 else
1529 new = PALETTERGB (max (0, min (0xff, min_delta + GetRValue (*color))),
1530 max (0, min (0xff, min_delta + GetGValue (*color))),
1531 max (0, min (0xff, min_delta + GetBValue (*color))));
1534 if (new == *color)
1535 new = PALETTERGB (max (0, min (0xff, delta + GetRValue (*color))),
1536 max (0, min (0xff, delta + GetGValue (*color))),
1537 max (0, min (0xff, delta + GetBValue (*color))));
1539 /* TODO: Map to palette and retry with delta if same? */
1540 /* TODO: Free colors (if using palette)? */
1542 if (new == *color)
1543 return 0;
1545 *color = new;
1547 return 1;
1550 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1551 colors in COLORS. On W32, we no longer try to map colors to
1552 a palette. */
1553 void
1554 x_query_colors (struct frame *f, XColor *colors, int ncolors)
1556 int i;
1558 for (i = 0; i < ncolors; i++)
1560 DWORD pixel = colors[i].pixel;
1561 /* Convert to a 16 bit value in range 0 - 0xffff. */
1562 colors[i].red = GetRValue (pixel) * 257;
1563 colors[i].green = GetGValue (pixel) * 257;
1564 colors[i].blue = GetBValue (pixel) * 257;
1568 void
1569 x_query_color (struct frame *f, XColor *color)
1571 x_query_colors (f, color, 1);
1575 /* Set up the foreground color for drawing relief lines of glyph
1576 string S. RELIEF is a pointer to a struct relief containing the GC
1577 with which lines will be drawn. Use a color that is FACTOR or
1578 DELTA lighter or darker than the relief's background which is found
1579 in S->f->output_data.x->relief_background. If such a color cannot
1580 be allocated, use DEFAULT_PIXEL, instead. */
1582 static void
1583 w32_setup_relief_color (struct frame *f, struct relief *relief, double factor,
1584 int delta, COLORREF default_pixel)
1586 XGCValues xgcv;
1587 struct w32_output *di = f->output_data.w32;
1588 unsigned long mask = GCForeground;
1589 COLORREF pixel;
1590 COLORREF background = di->relief_background;
1591 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
1593 /* TODO: Free colors (if using palette)? */
1595 /* Allocate new color. */
1596 xgcv.foreground = default_pixel;
1597 pixel = background;
1598 if (w32_alloc_lighter_color (f, &pixel, factor, delta))
1599 xgcv.foreground = relief->pixel = pixel;
1601 if (relief->gc == 0)
1603 #if 0 /* TODO: stipple */
1604 xgcv.stipple = dpyinfo->gray;
1605 mask |= GCStipple;
1606 #endif
1607 relief->gc = XCreateGC (NULL, FRAME_W32_WINDOW (f), mask, &xgcv);
1609 else
1610 XChangeGC (NULL, relief->gc, mask, &xgcv);
1614 /* Set up colors for the relief lines around glyph string S. */
1616 static void
1617 x_setup_relief_colors (struct glyph_string *s)
1619 struct w32_output *di = s->f->output_data.w32;
1620 COLORREF color;
1622 if (s->face->use_box_color_for_shadows_p)
1623 color = s->face->box_color;
1624 else if (s->first_glyph->type == IMAGE_GLYPH
1625 && s->img->pixmap
1626 && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
1627 color = IMAGE_BACKGROUND (s->img, s->f, 0);
1628 else
1629 color = s->gc->background;
1631 if (di->white_relief.gc == 0
1632 || color != di->relief_background)
1634 di->relief_background = color;
1635 w32_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
1636 WHITE_PIX_DEFAULT (s->f));
1637 w32_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
1638 BLACK_PIX_DEFAULT (s->f));
1643 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1644 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1645 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1646 relief. LEFT_P non-zero means draw a relief on the left side of
1647 the rectangle. RIGHT_P non-zero means draw a relief on the right
1648 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1649 when drawing. */
1651 static void
1652 w32_draw_relief_rect (struct frame *f,
1653 int left_x, int top_y, int right_x, int bottom_y,
1654 int width, int raised_p,
1655 int top_p, int bot_p, int left_p, int right_p,
1656 RECT *clip_rect)
1658 int i;
1659 XGCValues gc;
1660 HDC hdc = get_frame_dc (f);
1662 if (raised_p)
1663 gc.foreground = f->output_data.w32->white_relief.gc->foreground;
1664 else
1665 gc.foreground = f->output_data.w32->black_relief.gc->foreground;
1667 w32_set_clip_rectangle (hdc, clip_rect);
1669 /* Top. */
1670 if (top_p)
1671 for (i = 0; i < width; ++i)
1672 w32_fill_area (f, hdc, gc.foreground,
1673 left_x + i * left_p, top_y + i,
1674 right_x - left_x - i * (left_p + right_p ) + 1, 1);
1676 /* Left. */
1677 if (left_p)
1678 for (i = 0; i < width; ++i)
1679 w32_fill_area (f, hdc, gc.foreground,
1680 left_x + i, top_y + (i + 1) * top_p, 1,
1681 bottom_y - top_y - (i + 1) * (bot_p + top_p) + 1);
1683 if (raised_p)
1684 gc.foreground = f->output_data.w32->black_relief.gc->foreground;
1685 else
1686 gc.foreground = f->output_data.w32->white_relief.gc->foreground;
1688 /* Bottom. */
1689 if (bot_p)
1690 for (i = 0; i < width; ++i)
1691 w32_fill_area (f, hdc, gc.foreground,
1692 left_x + i * left_p, bottom_y - i,
1693 right_x - left_x - i * (left_p + right_p) + 1, 1);
1695 /* Right. */
1696 if (right_p)
1697 for (i = 0; i < width; ++i)
1698 w32_fill_area (f, hdc, gc.foreground,
1699 right_x - i, top_y + (i + 1) * top_p, 1,
1700 bottom_y - top_y - (i + 1) * (bot_p + top_p) + 1);
1702 w32_set_clip_rectangle (hdc, NULL);
1704 release_frame_dc (f, hdc);
1708 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1709 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1710 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1711 left side of the rectangle. RIGHT_P non-zero means draw a line
1712 on the right side of the rectangle. CLIP_RECT is the clipping
1713 rectangle to use when drawing. */
1715 static void
1716 w32_draw_box_rect (struct glyph_string *s,
1717 int left_x, int top_y, int right_x, int bottom_y, int width,
1718 int left_p, int right_p, RECT *clip_rect)
1720 w32_set_clip_rectangle (s->hdc, clip_rect);
1722 /* Top. */
1723 w32_fill_area (s->f, s->hdc, s->face->box_color,
1724 left_x, top_y, right_x - left_x + 1, width);
1726 /* Left. */
1727 if (left_p)
1729 w32_fill_area (s->f, s->hdc, s->face->box_color,
1730 left_x, top_y, width, bottom_y - top_y + 1);
1733 /* Bottom. */
1734 w32_fill_area (s->f, s->hdc, s->face->box_color,
1735 left_x, bottom_y - width + 1, right_x - left_x + 1, width);
1737 /* Right. */
1738 if (right_p)
1740 w32_fill_area (s->f, s->hdc, s->face->box_color,
1741 right_x - width + 1, top_y, width, bottom_y - top_y + 1);
1744 w32_set_clip_rectangle (s->hdc, NULL);
1748 /* Draw a box around glyph string S. */
1750 static void
1751 x_draw_glyph_string_box (struct glyph_string *s)
1753 int width, left_x, right_x, top_y, bottom_y, last_x, raised_p;
1754 int left_p, right_p;
1755 struct glyph *last_glyph;
1756 RECT clip_rect;
1758 last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
1759 ? WINDOW_RIGHT_EDGE_X (s->w)
1760 : window_box_right (s->w, s->area));
1762 /* The glyph that may have a right box line. */
1763 last_glyph = (s->cmp || s->img
1764 ? s->first_glyph
1765 : s->first_glyph + s->nchars - 1);
1767 width = eabs (s->face->box_line_width);
1768 raised_p = s->face->box == FACE_RAISED_BOX;
1769 left_x = s->x;
1770 right_x = ((s->row->full_width_p && s->extends_to_end_of_line_p
1771 ? last_x - 1
1772 : min (last_x, s->x + s->background_width) - 1));
1773 top_y = s->y;
1774 bottom_y = top_y + s->height - 1;
1776 left_p = (s->first_glyph->left_box_line_p
1777 || (s->hl == DRAW_MOUSE_FACE
1778 && (s->prev == NULL
1779 || s->prev->hl != s->hl)));
1780 right_p = (last_glyph->right_box_line_p
1781 || (s->hl == DRAW_MOUSE_FACE
1782 && (s->next == NULL
1783 || s->next->hl != s->hl)));
1785 get_glyph_string_clip_rect (s, &clip_rect);
1787 if (s->face->box == FACE_SIMPLE_BOX)
1788 w32_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
1789 left_p, right_p, &clip_rect);
1790 else
1792 x_setup_relief_colors (s);
1793 w32_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
1794 width, raised_p, 1, 1, left_p, right_p, &clip_rect);
1799 /* Draw foreground of image glyph string S. */
1801 static void
1802 x_draw_image_foreground (struct glyph_string *s)
1804 int x = s->x;
1805 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
1807 /* If first glyph of S has a left box line, start drawing it to the
1808 right of that line. */
1809 if (s->face->box != FACE_NO_BOX
1810 && s->first_glyph->left_box_line_p
1811 && s->slice.x == 0)
1812 x += eabs (s->face->box_line_width);
1814 /* If there is a margin around the image, adjust x- and y-position
1815 by that margin. */
1816 if (s->slice.x == 0)
1817 x += s->img->hmargin;
1818 if (s->slice.y == 0)
1819 y += s->img->vmargin;
1821 SaveDC (s->hdc);
1823 if (s->img->pixmap)
1825 HDC compat_hdc = CreateCompatibleDC (s->hdc);
1826 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
1827 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
1828 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
1829 SetBkColor (compat_hdc, RGB (255, 255, 255));
1830 SetTextColor (s->hdc, RGB (0, 0, 0));
1831 x_set_glyph_string_clipping (s);
1833 if (s->img->mask)
1835 HDC mask_dc = CreateCompatibleDC (s->hdc);
1836 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask);
1838 SetTextColor (s->hdc, RGB (255, 255, 255));
1839 SetBkColor (s->hdc, RGB (0, 0, 0));
1841 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1842 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
1843 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1844 mask_dc, s->slice.x, s->slice.y, SRCAND);
1845 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1846 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
1848 SelectObject (mask_dc, mask_orig_obj);
1849 DeleteDC (mask_dc);
1851 else
1853 SetTextColor (s->hdc, s->gc->foreground);
1854 SetBkColor (s->hdc, s->gc->background);
1856 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1857 compat_hdc, s->slice.x, s->slice.y, SRCCOPY);
1859 /* When the image has a mask, we can expect that at
1860 least part of a mouse highlight or a block cursor will
1861 be visible. If the image doesn't have a mask, make
1862 a block cursor visible by drawing a rectangle around
1863 the image. I believe it's looking better if we do
1864 nothing here for mouse-face. */
1865 if (s->hl == DRAW_CURSOR)
1867 int r = s->img->relief;
1868 if (r < 0) r = -r;
1869 w32_draw_rectangle (s->hdc, s->gc, x - r, y - r ,
1870 s->slice.width + r*2 - 1,
1871 s->slice.height + r*2 - 1);
1875 w32_set_clip_rectangle (s->hdc, NULL);
1876 SelectObject (s->hdc, orig_brush);
1877 DeleteObject (fg_brush);
1878 SelectObject (compat_hdc, orig_obj);
1879 DeleteDC (compat_hdc);
1881 else
1882 w32_draw_rectangle (s->hdc, s->gc, x, y,
1883 s->slice.width - 1, s->slice.height - 1);
1885 RestoreDC (s->hdc ,-1);
1889 /* Draw a relief around the image glyph string S. */
1891 static void
1892 x_draw_image_relief (struct glyph_string *s)
1894 int x1, y1, thick, raised_p, top_p, bot_p, left_p, right_p;
1895 int extra_x, extra_y;
1896 RECT r;
1897 int x = s->x;
1898 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
1900 /* If first glyph of S has a left box line, start drawing it to the
1901 right of that line. */
1902 if (s->face->box != FACE_NO_BOX
1903 && s->first_glyph->left_box_line_p
1904 && s->slice.x == 0)
1905 x += eabs (s->face->box_line_width);
1907 /* If there is a margin around the image, adjust x- and y-position
1908 by that margin. */
1909 if (s->slice.x == 0)
1910 x += s->img->hmargin;
1911 if (s->slice.y == 0)
1912 y += s->img->vmargin;
1914 if (s->hl == DRAW_IMAGE_SUNKEN
1915 || s->hl == DRAW_IMAGE_RAISED)
1917 thick = tool_bar_button_relief >= 0 ? tool_bar_button_relief
1918 : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
1919 raised_p = s->hl == DRAW_IMAGE_RAISED;
1921 else
1923 thick = eabs (s->img->relief);
1924 raised_p = s->img->relief > 0;
1927 x1 = x + s->slice.width - 1;
1928 y1 = y + s->slice.height - 1;
1930 extra_x = extra_y = 0;
1931 if (s->face->id == TOOL_BAR_FACE_ID)
1933 if (CONSP (Vtool_bar_button_margin)
1934 && INTEGERP (XCAR (Vtool_bar_button_margin))
1935 && INTEGERP (XCDR (Vtool_bar_button_margin)))
1937 extra_x = XINT (XCAR (Vtool_bar_button_margin));
1938 extra_y = XINT (XCDR (Vtool_bar_button_margin));
1940 else if (INTEGERP (Vtool_bar_button_margin))
1941 extra_x = extra_y = XINT (Vtool_bar_button_margin);
1944 top_p = bot_p = left_p = right_p = 0;
1946 if (s->slice.x == 0)
1947 x -= thick + extra_x, left_p = 1;
1948 if (s->slice.y == 0)
1949 y -= thick + extra_y, top_p = 1;
1950 if (s->slice.x + s->slice.width == s->img->width)
1951 x1 += thick + extra_x, right_p = 1;
1952 if (s->slice.y + s->slice.height == s->img->height)
1953 y1 += thick + extra_y, bot_p = 1;
1955 x_setup_relief_colors (s);
1956 get_glyph_string_clip_rect (s, &r);
1957 w32_draw_relief_rect (s->f, x, y, x1, y1, thick, raised_p,
1958 top_p, bot_p, left_p, right_p, &r);
1962 /* Draw the foreground of image glyph string S to PIXMAP. */
1964 static void
1965 w32_draw_image_foreground_1 (struct glyph_string *s, HBITMAP pixmap)
1967 HDC hdc = CreateCompatibleDC (s->hdc);
1968 HGDIOBJ orig_hdc_obj = SelectObject (hdc, pixmap);
1969 int x = 0;
1970 int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
1972 /* If first glyph of S has a left box line, start drawing it to the
1973 right of that line. */
1974 if (s->face->box != FACE_NO_BOX
1975 && s->first_glyph->left_box_line_p
1976 && s->slice.x == 0)
1977 x += eabs (s->face->box_line_width);
1979 /* If there is a margin around the image, adjust x- and y-position
1980 by that margin. */
1981 if (s->slice.x == 0)
1982 x += s->img->hmargin;
1983 if (s->slice.y == 0)
1984 y += s->img->vmargin;
1986 if (s->img->pixmap)
1988 HDC compat_hdc = CreateCompatibleDC (hdc);
1989 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
1990 HBRUSH orig_brush = SelectObject (hdc, fg_brush);
1991 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
1993 if (s->img->mask)
1995 HDC mask_dc = CreateCompatibleDC (hdc);
1996 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask);
1998 SetTextColor (hdc, RGB (0, 0, 0));
1999 SetBkColor (hdc, RGB (255, 255, 255));
2000 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2001 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
2002 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2003 mask_dc, s->slice.x, s->slice.y, SRCAND);
2004 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2005 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
2007 SelectObject (mask_dc, mask_orig_obj);
2008 DeleteDC (mask_dc);
2010 else
2012 SetTextColor (hdc, s->gc->foreground);
2013 SetBkColor (hdc, s->gc->background);
2015 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2016 compat_hdc, s->slice.x, s->slice.y, SRCCOPY);
2018 /* When the image has a mask, we can expect that at
2019 least part of a mouse highlight or a block cursor will
2020 be visible. If the image doesn't have a mask, make
2021 a block cursor visible by drawing a rectangle around
2022 the image. I believe it's looking better if we do
2023 nothing here for mouse-face. */
2024 if (s->hl == DRAW_CURSOR)
2026 int r = s->img->relief;
2027 if (r < 0) r = -r;
2028 w32_draw_rectangle (hdc, s->gc, x - r, y - r,
2029 s->slice.width + r*2 - 1,
2030 s->slice.height + r*2 - 1);
2034 SelectObject (hdc, orig_brush);
2035 DeleteObject (fg_brush);
2036 SelectObject (compat_hdc, orig_obj);
2037 DeleteDC (compat_hdc);
2039 else
2040 w32_draw_rectangle (hdc, s->gc, x, y,
2041 s->slice.width - 1, s->slice.height - 1);
2043 SelectObject (hdc, orig_hdc_obj);
2044 DeleteDC (hdc);
2048 /* Draw part of the background of glyph string S. X, Y, W, and H
2049 give the rectangle to draw. */
2051 static void
2052 x_draw_glyph_string_bg_rect (struct glyph_string *s, int x, int y, int w, int h)
2054 #if 0 /* TODO: stipple */
2055 if (s->stippled_p)
2057 /* Fill background with a stipple pattern. */
2058 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2059 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
2060 XSetFillStyle (s->display, s->gc, FillSolid);
2062 else
2063 #endif
2064 x_clear_glyph_string_rect (s, x, y, w, h);
2068 /* Draw image glyph string S.
2070 s->y
2071 s->x +-------------------------
2072 | s->face->box
2074 | +-------------------------
2075 | | s->img->vmargin
2077 | | +-------------------
2078 | | | the image
2082 static void
2083 x_draw_image_glyph_string (struct glyph_string *s)
2085 int x, y;
2086 int box_line_hwidth = eabs (s->face->box_line_width);
2087 int box_line_vwidth = max (s->face->box_line_width, 0);
2088 int height;
2089 HBITMAP pixmap = 0;
2091 height = s->height - 2 * box_line_vwidth;
2093 /* Fill background with face under the image. Do it only if row is
2094 taller than image or if image has a clip mask to reduce
2095 flickering. */
2096 s->stippled_p = s->face->stipple != 0;
2097 if (height > s->slice.height
2098 || s->img->hmargin
2099 || s->img->vmargin
2100 || s->img->mask
2101 || s->img->pixmap == 0
2102 || s->width != s->background_width)
2104 x = s->x;
2105 if (s->first_glyph->left_box_line_p
2106 && s->slice.x == 0)
2107 x += box_line_hwidth;
2109 y = s->y;
2110 if (s->slice.y == 0)
2111 y += box_line_vwidth;
2113 #if 0 /* TODO: figure out if we need to do this on Windows. */
2114 if (s->img->mask)
2116 /* Create a pixmap as large as the glyph string. Fill it
2117 with the background color. Copy the image to it, using
2118 its mask. Copy the temporary pixmap to the display. */
2119 Screen *screen = FRAME_X_SCREEN (s->f);
2120 int depth = DefaultDepthOfScreen (screen);
2122 /* Create a pixmap as large as the glyph string. */
2123 pixmap = XCreatePixmap (s->display, s->window,
2124 s->background_width,
2125 s->height, depth);
2127 /* Don't clip in the following because we're working on the
2128 pixmap. */
2129 XSetClipMask (s->display, s->gc, None);
2131 /* Fill the pixmap with the background color/stipple. */
2132 if (s->stippled_p)
2134 /* Fill background with a stipple pattern. */
2135 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2136 XFillRectangle (s->display, pixmap, s->gc,
2137 0, 0, s->background_width, s->height);
2138 XSetFillStyle (s->display, s->gc, FillSolid);
2140 else
2142 XGCValues xgcv;
2143 XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
2144 &xgcv);
2145 XSetForeground (s->display, s->gc, xgcv.background);
2146 XFillRectangle (s->display, pixmap, s->gc,
2147 0, 0, s->background_width, s->height);
2148 XSetForeground (s->display, s->gc, xgcv.foreground);
2151 else
2152 #endif
2153 x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
2155 s->background_filled_p = 1;
2158 /* Draw the foreground. */
2159 if (pixmap != 0)
2161 w32_draw_image_foreground_1 (s, pixmap);
2162 x_set_glyph_string_clipping (s);
2164 HDC compat_hdc = CreateCompatibleDC (s->hdc);
2165 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
2166 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
2167 HGDIOBJ orig_obj = SelectObject (compat_hdc, pixmap);
2169 SetTextColor (s->hdc, s->gc->foreground);
2170 SetBkColor (s->hdc, s->gc->background);
2171 BitBlt (s->hdc, s->x, s->y, s->background_width, s->height,
2172 compat_hdc, 0, 0, SRCCOPY);
2174 SelectObject (s->hdc, orig_brush);
2175 DeleteObject (fg_brush);
2176 SelectObject (compat_hdc, orig_obj);
2177 DeleteDC (compat_hdc);
2179 DeleteObject (pixmap);
2180 pixmap = 0;
2182 else
2183 x_draw_image_foreground (s);
2185 /* If we must draw a relief around the image, do it. */
2186 if (s->img->relief
2187 || s->hl == DRAW_IMAGE_RAISED
2188 || s->hl == DRAW_IMAGE_SUNKEN)
2189 x_draw_image_relief (s);
2193 /* Draw stretch glyph string S. */
2195 static void
2196 x_draw_stretch_glyph_string (struct glyph_string *s)
2198 eassert (s->first_glyph->type == STRETCH_GLYPH);
2200 if (s->hl == DRAW_CURSOR
2201 && !x_stretch_cursor_p)
2203 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2204 wide as the stretch glyph. */
2205 int width, background_width = s->background_width;
2206 int x = s->x;
2208 if (!s->row->reversed_p)
2210 int left_x = window_box_left_offset (s->w, TEXT_AREA);
2212 if (x < left_x)
2214 background_width -= left_x - x;
2215 x = left_x;
2218 else
2220 /* In R2L rows, draw the cursor on the right edge of the
2221 stretch glyph. */
2222 int right_x = window_box_right_offset (s->w, TEXT_AREA);
2224 if (x + background_width > right_x)
2225 background_width -= x - right_x;
2226 x += background_width;
2228 width = min (FRAME_COLUMN_WIDTH (s->f), background_width);
2229 if (s->row->reversed_p)
2230 x -= width;
2232 /* Draw cursor. */
2233 x_draw_glyph_string_bg_rect (s, x, s->y, width, s->height);
2235 /* Clear rest using the GC of the original non-cursor face. */
2236 if (width < background_width)
2238 XGCValues *gc = s->face->gc;
2239 int y = s->y;
2240 int w = background_width - width, h = s->height;
2241 RECT r;
2242 HDC hdc = s->hdc;
2244 if (!s->row->reversed_p)
2245 x += width;
2246 else
2247 x = s->x;
2248 if (s->row->mouse_face_p
2249 && cursor_in_mouse_face_p (s->w))
2251 x_set_mouse_face_gc (s);
2252 gc = s->gc;
2254 else
2255 gc = s->face->gc;
2257 get_glyph_string_clip_rect (s, &r);
2258 w32_set_clip_rectangle (hdc, &r);
2260 #if 0 /* TODO: stipple */
2261 if (s->face->stipple)
2263 /* Fill background with a stipple pattern. */
2264 XSetFillStyle (s->display, gc, FillOpaqueStippled);
2265 XFillRectangle (s->display, s->window, gc, x, y, w, h);
2266 XSetFillStyle (s->display, gc, FillSolid);
2268 else
2269 #endif
2271 w32_fill_area (s->f, s->hdc, gc->background, x, y, w, h);
2275 else if (!s->background_filled_p)
2277 int background_width = s->background_width;
2278 int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
2280 /* Don't draw into left margin, fringe or scrollbar area
2281 except for header line and mode line. */
2282 if (x < left_x && !s->row->mode_line_p)
2284 background_width -= left_x - x;
2285 x = left_x;
2287 if (background_width > 0)
2288 x_draw_glyph_string_bg_rect (s, x, s->y, background_width, s->height);
2291 s->background_filled_p = 1;
2295 /* Draw glyph string S. */
2297 static void
2298 x_draw_glyph_string (struct glyph_string *s)
2300 bool relief_drawn_p = 0;
2302 /* If S draws into the background of its successor, draw the
2303 background of the successor first so that S can draw into it.
2304 This makes S->next use XDrawString instead of XDrawImageString. */
2305 if (s->next && s->right_overhang && !s->for_overlaps)
2307 int width;
2308 struct glyph_string *next;
2309 for (width = 0, next = s->next;
2310 next && width < s->right_overhang;
2311 width += next->width, next = next->next)
2312 if (next->first_glyph->type != IMAGE_GLYPH)
2314 x_set_glyph_string_gc (next);
2315 x_set_glyph_string_clipping (next);
2316 if (next->first_glyph->type == STRETCH_GLYPH)
2317 x_draw_stretch_glyph_string (next);
2318 else
2319 x_draw_glyph_string_background (next, 1);
2320 next->num_clips = 0;
2324 /* Set up S->gc, set clipping and draw S. */
2325 x_set_glyph_string_gc (s);
2327 /* Draw relief (if any) in advance for char/composition so that the
2328 glyph string can be drawn over it. */
2329 if (!s->for_overlaps
2330 && s->face->box != FACE_NO_BOX
2331 && (s->first_glyph->type == CHAR_GLYPH
2332 || s->first_glyph->type == COMPOSITE_GLYPH))
2335 x_set_glyph_string_clipping (s);
2336 x_draw_glyph_string_background (s, 1);
2337 x_draw_glyph_string_box (s);
2338 x_set_glyph_string_clipping (s);
2339 relief_drawn_p = 1;
2341 else if (!s->clip_head /* draw_glyphs didn't specify a clip mask. */
2342 && !s->clip_tail
2343 && ((s->prev && s->prev->hl != s->hl && s->left_overhang)
2344 || (s->next && s->next->hl != s->hl && s->right_overhang)))
2345 /* We must clip just this glyph. left_overhang part has already
2346 drawn when s->prev was drawn, and right_overhang part will be
2347 drawn later when s->next is drawn. */
2348 x_set_glyph_string_clipping_exactly (s, s);
2349 else
2350 x_set_glyph_string_clipping (s);
2352 switch (s->first_glyph->type)
2354 case IMAGE_GLYPH:
2355 x_draw_image_glyph_string (s);
2356 break;
2358 case STRETCH_GLYPH:
2359 x_draw_stretch_glyph_string (s);
2360 break;
2362 case CHAR_GLYPH:
2363 if (s->for_overlaps)
2364 s->background_filled_p = 1;
2365 else
2366 x_draw_glyph_string_background (s, 0);
2367 x_draw_glyph_string_foreground (s);
2368 break;
2370 case COMPOSITE_GLYPH:
2371 if (s->for_overlaps || (s->cmp_from > 0
2372 && ! s->first_glyph->u.cmp.automatic))
2373 s->background_filled_p = 1;
2374 else
2375 x_draw_glyph_string_background (s, 1);
2376 x_draw_composite_glyph_string_foreground (s);
2377 break;
2379 case GLYPHLESS_GLYPH:
2380 if (s->for_overlaps)
2381 s->background_filled_p = 1;
2382 else
2383 x_draw_glyph_string_background (s, 0);
2384 x_draw_glyphless_glyph_string_foreground (s);
2385 break;
2387 default:
2388 emacs_abort ();
2391 if (!s->for_overlaps)
2393 /* Draw underline. */
2394 if (s->face->underline_p)
2396 if (s->face->underline_type == FACE_UNDER_WAVE)
2398 COLORREF color;
2400 if (s->face->underline_defaulted_p)
2401 color = s->gc->foreground;
2402 else
2403 color = s->face->underline_color;
2405 w32_draw_underwave (s, color);
2407 else if (s->face->underline_type == FACE_UNDER_LINE)
2409 unsigned long thickness, position;
2410 int y;
2412 if (s->prev && s->prev->face->underline_p
2413 && s->prev->face->underline_type == FACE_UNDER_LINE)
2415 /* We use the same underline style as the previous one. */
2416 thickness = s->prev->underline_thickness;
2417 position = s->prev->underline_position;
2419 else
2421 /* Get the underline thickness. Default is 1 pixel. */
2422 if (s->font && s->font->underline_thickness > 0)
2423 thickness = s->font->underline_thickness;
2424 else
2425 thickness = 1;
2426 if (x_underline_at_descent_line)
2427 position = (s->height - thickness) - (s->ybase - s->y);
2428 else
2430 /* Get the underline position. This is the recommended
2431 vertical offset in pixels from the baseline to the top of
2432 the underline. This is a signed value according to the
2433 specs, and its default is
2435 ROUND ((maximum_descent) / 2), with
2436 ROUND (x) = floor (x + 0.5) */
2438 if (x_use_underline_position_properties
2439 && s->font && s->font->underline_position >= 0)
2440 position = s->font->underline_position;
2441 else if (s->font)
2442 position = (s->font->descent + 1) / 2;
2444 position = max (position, underline_minimum_offset);
2446 /* Check the sanity of thickness and position. We should
2447 avoid drawing underline out of the current line area. */
2448 if (s->y + s->height <= s->ybase + position)
2449 position = (s->height - 1) - (s->ybase - s->y);
2450 if (s->y + s->height < s->ybase + position + thickness)
2451 thickness = (s->y + s->height) - (s->ybase + position);
2452 s->underline_thickness = thickness;
2453 s->underline_position =position;
2454 y = s->ybase + position;
2455 if (s->face->underline_defaulted_p)
2457 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
2458 y, s->width, 1);
2460 else
2462 w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x,
2463 y, s->width, 1);
2467 /* Draw overline. */
2468 if (s->face->overline_p)
2470 unsigned long dy = 0, h = 1;
2472 if (s->face->overline_color_defaulted_p)
2474 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
2475 s->y + dy, s->width, h);
2477 else
2479 w32_fill_area (s->f, s->hdc, s->face->overline_color, s->x,
2480 s->y + dy, s->width, h);
2484 /* Draw strike-through. */
2485 if (s->face->strike_through_p
2486 && !FONT_TEXTMETRIC (s->font).tmStruckOut)
2488 unsigned long h = 1;
2489 unsigned long dy = (s->height - h) / 2;
2491 if (s->face->strike_through_color_defaulted_p)
2493 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x, s->y + dy,
2494 s->width, h);
2496 else
2498 w32_fill_area (s->f, s->hdc, s->face->strike_through_color, s->x,
2499 s->y + dy, s->width, h);
2503 /* Draw relief if not yet drawn. */
2504 if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
2505 x_draw_glyph_string_box (s);
2507 if (s->prev)
2509 struct glyph_string *prev;
2511 for (prev = s->prev; prev; prev = prev->prev)
2512 if (prev->hl != s->hl
2513 && prev->x + prev->width + prev->right_overhang > s->x)
2515 /* As prev was drawn while clipped to its own area, we
2516 must draw the right_overhang part using s->hl now. */
2517 enum draw_glyphs_face save = prev->hl;
2519 prev->hl = s->hl;
2520 x_set_glyph_string_gc (prev);
2521 x_set_glyph_string_clipping_exactly (s, prev);
2522 if (prev->first_glyph->type == CHAR_GLYPH)
2523 x_draw_glyph_string_foreground (prev);
2524 else
2525 x_draw_composite_glyph_string_foreground (prev);
2526 w32_set_clip_rectangle (prev->hdc, NULL);
2527 prev->hl = save;
2528 prev->num_clips = 0;
2532 if (s->next)
2534 struct glyph_string *next;
2536 for (next = s->next; next; next = next->next)
2537 if (next->hl != s->hl
2538 && next->x - next->left_overhang < s->x + s->width)
2540 /* As next will be drawn while clipped to its own area,
2541 we must draw the left_overhang part using s->hl now. */
2542 enum draw_glyphs_face save = next->hl;
2544 next->hl = s->hl;
2545 x_set_glyph_string_gc (next);
2546 x_set_glyph_string_clipping_exactly (s, next);
2547 if (next->first_glyph->type == CHAR_GLYPH)
2548 x_draw_glyph_string_foreground (next);
2549 else
2550 x_draw_composite_glyph_string_foreground (next);
2551 w32_set_clip_rectangle (next->hdc, NULL);
2552 next->hl = save;
2553 next->num_clips = 0;
2554 next->clip_head = s->next;
2559 /* Reset clipping. */
2560 w32_set_clip_rectangle (s->hdc, NULL);
2561 s->num_clips = 0;
2565 /* Shift display to make room for inserted glyphs. */
2567 void
2568 w32_shift_glyphs_for_insert (struct frame *f, int x, int y,
2569 int width, int height, int shift_by)
2571 HDC hdc;
2573 hdc = get_frame_dc (f);
2574 BitBlt (hdc, x + shift_by, y, width, height,
2575 hdc, x, y, SRCCOPY);
2577 release_frame_dc (f, hdc);
2581 /* Delete N glyphs at the nominal cursor position. Not implemented
2582 for X frames. */
2584 static void
2585 x_delete_glyphs (struct frame *f, register int n)
2587 if (! FRAME_W32_P (f))
2588 return;
2590 emacs_abort ();
2594 /* Clear entire frame. */
2596 static void
2597 x_clear_frame (struct frame *f)
2599 if (! FRAME_W32_P (f))
2600 return;
2602 /* Clearing the frame will erase any cursor, so mark them all as no
2603 longer visible. */
2604 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
2606 block_input ();
2608 w32_clear_window (f);
2610 /* We have to clear the scroll bars, too. If we have changed
2611 colors or something like that, then they should be notified. */
2612 x_scroll_bar_clear (f);
2614 unblock_input ();
2618 /* Make audible bell. */
2620 static void
2621 w32_ring_bell (struct frame *f)
2623 block_input ();
2625 if (FRAME_W32_P (f) && visible_bell)
2627 int i;
2628 HWND hwnd = FRAME_W32_WINDOW (f);
2630 for (i = 0; i < 5; i++)
2632 FlashWindow (hwnd, TRUE);
2633 Sleep (10);
2635 FlashWindow (hwnd, FALSE);
2637 else
2638 w32_sys_ring_bell (f);
2640 unblock_input ();
2643 /***********************************************************************
2644 Line Dance
2645 ***********************************************************************/
2647 /* Perform an insert-lines or delete-lines operation, inserting N
2648 lines or deleting -N lines at vertical position VPOS. */
2650 static void
2651 x_ins_del_lines (struct frame *f, int vpos, int n)
2653 if (! FRAME_W32_P (f))
2654 return;
2656 emacs_abort ();
2660 /* Scroll part of the display as described by RUN. */
2662 static void
2663 x_scroll_run (struct window *w, struct run *run)
2665 struct frame *f = XFRAME (w->frame);
2666 int x, y, width, height, from_y, to_y, bottom_y;
2667 HWND hwnd = FRAME_W32_WINDOW (f);
2668 HRGN expect_dirty;
2670 /* Get frame-relative bounding box of the text display area of W,
2671 without mode lines. Include in this box the left and right
2672 fringes of W. */
2673 window_box (w, ANY_AREA, &x, &y, &width, &height);
2675 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
2676 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
2677 bottom_y = y + height;
2679 if (to_y < from_y)
2681 /* Scrolling up. Make sure we don't copy part of the mode
2682 line at the bottom. */
2683 if (from_y + run->height > bottom_y)
2684 height = bottom_y - from_y;
2685 else
2686 height = run->height;
2687 expect_dirty = CreateRectRgn (x, y + height, x + width, bottom_y);
2689 else
2691 /* Scrolling down. Make sure we don't copy over the mode line.
2692 at the bottom. */
2693 if (to_y + run->height > bottom_y)
2694 height = bottom_y - to_y;
2695 else
2696 height = run->height;
2697 expect_dirty = CreateRectRgn (x, y, x + width, to_y);
2700 block_input ();
2702 /* Cursor off. Will be switched on again in x_update_window_end. */
2703 x_clear_cursor (w);
2706 RECT from;
2707 RECT to;
2708 HRGN dirty = CreateRectRgn (0, 0, 0, 0);
2709 HRGN combined = CreateRectRgn (0, 0, 0, 0);
2711 from.left = to.left = x;
2712 from.right = to.right = x + width;
2713 from.top = from_y;
2714 from.bottom = from_y + height;
2715 to.top = y;
2716 to.bottom = bottom_y;
2718 ScrollWindowEx (hwnd, 0, to_y - from_y, &from, &to, dirty,
2719 NULL, SW_INVALIDATE);
2721 /* Combine this with what we expect to be dirty. This covers the
2722 case where not all of the region we expect is actually dirty. */
2723 CombineRgn (combined, dirty, expect_dirty, RGN_OR);
2725 /* If the dirty region is not what we expected, redraw the entire frame. */
2726 if (!EqualRgn (combined, expect_dirty))
2727 SET_FRAME_GARBAGED (f);
2729 DeleteObject (dirty);
2730 DeleteObject (combined);
2733 unblock_input ();
2734 DeleteObject (expect_dirty);
2739 /***********************************************************************
2740 Exposure Events
2741 ***********************************************************************/
2743 static void
2744 frame_highlight (struct frame *f)
2746 x_update_cursor (f, 1);
2747 x_set_frame_alpha (f);
2750 static void
2751 frame_unhighlight (struct frame *f)
2753 x_update_cursor (f, 1);
2754 x_set_frame_alpha (f);
2757 /* The focus has changed. Update the frames as necessary to reflect
2758 the new situation. Note that we can't change the selected frame
2759 here, because the Lisp code we are interrupting might become confused.
2760 Each event gets marked with the frame in which it occurred, so the
2761 Lisp code can tell when the switch took place by examining the events. */
2763 static void
2764 x_new_focus_frame (struct w32_display_info *dpyinfo, struct frame *frame)
2766 struct frame *old_focus = dpyinfo->w32_focus_frame;
2768 if (frame != dpyinfo->w32_focus_frame)
2770 /* Set this before calling other routines, so that they see
2771 the correct value of w32_focus_frame. */
2772 dpyinfo->w32_focus_frame = frame;
2774 if (old_focus && old_focus->auto_lower)
2775 x_lower_frame (old_focus);
2777 if (dpyinfo->w32_focus_frame && dpyinfo->w32_focus_frame->auto_raise)
2778 dpyinfo->w32_pending_autoraise_frame = dpyinfo->w32_focus_frame;
2779 else
2780 dpyinfo->w32_pending_autoraise_frame = NULL;
2783 x_frame_rehighlight (dpyinfo);
2787 /* Handle FocusIn and FocusOut state changes for FRAME.
2788 If FRAME has focus and there exists more than one frame, puts
2789 a FOCUS_IN_EVENT into *BUFP. */
2791 static void
2792 x_focus_changed (int type, int state, struct w32_display_info *dpyinfo,
2793 struct frame *frame, struct input_event *bufp)
2795 if (type == WM_SETFOCUS)
2797 if (dpyinfo->w32_focus_event_frame != frame)
2799 x_new_focus_frame (dpyinfo, frame);
2800 dpyinfo->w32_focus_event_frame = frame;
2802 /* Don't stop displaying the initial startup message
2803 for a switch-frame event we don't need. */
2804 if (NILP (Vterminal_frame)
2805 && CONSP (Vframe_list)
2806 && !NILP (XCDR (Vframe_list)))
2808 bufp->arg = Qt;
2810 else
2812 bufp->arg = Qnil;
2815 bufp->kind = FOCUS_IN_EVENT;
2816 XSETFRAME (bufp->frame_or_window, frame);
2819 frame->output_data.x->focus_state |= state;
2821 /* TODO: IME focus? */
2823 else if (type == WM_KILLFOCUS)
2825 frame->output_data.x->focus_state &= ~state;
2827 if (dpyinfo->w32_focus_event_frame == frame)
2829 dpyinfo->w32_focus_event_frame = 0;
2830 x_new_focus_frame (dpyinfo, 0);
2832 bufp->kind = FOCUS_OUT_EVENT;
2833 XSETFRAME (bufp->frame_or_window, frame);
2836 /* TODO: IME focus? */
2841 /* The focus may have changed. Figure out if it is a real focus change,
2842 by checking both FocusIn/Out and Enter/LeaveNotify events.
2844 Returns FOCUS_IN_EVENT event in *BUFP. */
2846 static void
2847 w32_detect_focus_change (struct w32_display_info *dpyinfo, W32Msg *event,
2848 struct input_event *bufp)
2850 struct frame *frame;
2852 frame = x_any_window_to_frame (dpyinfo, event->msg.hwnd);
2853 if (! frame)
2854 return;
2856 /* On w32, this is only called from focus events, so no switch needed. */
2857 x_focus_changed (event->msg.message,
2858 (event->msg.message == WM_KILLFOCUS ?
2859 FOCUS_IMPLICIT : FOCUS_EXPLICIT),
2860 dpyinfo, frame, bufp);
2864 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2866 void
2867 x_mouse_leave (struct w32_display_info *dpyinfo)
2869 x_new_focus_frame (dpyinfo, dpyinfo->w32_focus_event_frame);
2872 /* The focus has changed, or we have redirected a frame's focus to
2873 another frame (this happens when a frame uses a surrogate
2874 mini-buffer frame). Shift the highlight as appropriate.
2876 The FRAME argument doesn't necessarily have anything to do with which
2877 frame is being highlighted or un-highlighted; we only use it to find
2878 the appropriate X display info. */
2880 static void
2881 w32_frame_rehighlight (struct frame *frame)
2883 if (! FRAME_W32_P (frame))
2884 return;
2885 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame));
2888 static void
2889 x_frame_rehighlight (struct w32_display_info *dpyinfo)
2891 struct frame *old_highlight = dpyinfo->x_highlight_frame;
2893 if (dpyinfo->w32_focus_frame)
2895 dpyinfo->x_highlight_frame
2896 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame)))
2897 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame))
2898 : dpyinfo->w32_focus_frame);
2899 if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
2901 fset_focus_frame (dpyinfo->w32_focus_frame, Qnil);
2902 dpyinfo->x_highlight_frame = dpyinfo->w32_focus_frame;
2905 else
2906 dpyinfo->x_highlight_frame = 0;
2908 if (dpyinfo->x_highlight_frame != old_highlight)
2910 if (old_highlight)
2911 frame_unhighlight (old_highlight);
2912 if (dpyinfo->x_highlight_frame)
2913 frame_highlight (dpyinfo->x_highlight_frame);
2917 /* Keyboard processing - modifier keys, etc. */
2919 /* Convert a keysym to its name. */
2921 char *
2922 x_get_keysym_name (int keysym)
2924 /* Make static so we can always return it */
2925 static char value[100];
2927 block_input ();
2928 GetKeyNameText (keysym, value, 100);
2929 unblock_input ();
2931 return value;
2934 static int
2935 codepage_for_locale (LCID locale)
2937 char cp[20];
2939 if (GetLocaleInfo (locale, LOCALE_IDEFAULTANSICODEPAGE, cp, 20) > 0)
2940 return atoi (cp);
2941 else
2942 return CP_ACP;
2946 /* Mouse clicks and mouse movement. Rah. */
2948 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2949 the state in PUP. XBUTTON provides extra information for extended mouse
2950 button messages. Returns FALSE if unable to parse the message. */
2951 BOOL
2952 parse_button (int message, int xbutton, int * pbutton, int * pup)
2954 int button = 0;
2955 int up = 0;
2957 switch (message)
2959 case WM_LBUTTONDOWN:
2960 button = 0;
2961 up = 0;
2962 break;
2963 case WM_LBUTTONUP:
2964 button = 0;
2965 up = 1;
2966 break;
2967 case WM_MBUTTONDOWN:
2968 if (NILP (Vw32_swap_mouse_buttons))
2969 button = 1;
2970 else
2971 button = 2;
2972 up = 0;
2973 break;
2974 case WM_MBUTTONUP:
2975 if (NILP (Vw32_swap_mouse_buttons))
2976 button = 1;
2977 else
2978 button = 2;
2979 up = 1;
2980 break;
2981 case WM_RBUTTONDOWN:
2982 if (NILP (Vw32_swap_mouse_buttons))
2983 button = 2;
2984 else
2985 button = 1;
2986 up = 0;
2987 break;
2988 case WM_RBUTTONUP:
2989 if (NILP (Vw32_swap_mouse_buttons))
2990 button = 2;
2991 else
2992 button = 1;
2993 up = 1;
2994 break;
2995 case WM_XBUTTONDOWN:
2996 button = xbutton + 2;
2997 up = 0;
2998 break;
2999 case WM_XBUTTONUP:
3000 button = xbutton + 2;
3001 up = 1;
3002 break;
3003 default:
3004 return (FALSE);
3007 if (pup) *pup = up;
3008 if (pbutton) *pbutton = button;
3010 return (TRUE);
3014 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3016 If the event is a button press, then note that we have grabbed
3017 the mouse. */
3019 static Lisp_Object
3020 construct_mouse_click (struct input_event *result, W32Msg *msg, struct frame *f)
3022 int button;
3023 int up;
3025 parse_button (msg->msg.message, HIWORD (msg->msg.wParam),
3026 &button, &up);
3028 /* Make the event type NO_EVENT; we'll change that when we decide
3029 otherwise. */
3030 result->kind = MOUSE_CLICK_EVENT;
3031 result->code = button;
3032 result->timestamp = msg->msg.time;
3033 result->modifiers = (msg->dwModifiers
3034 | (up
3035 ? up_modifier
3036 : down_modifier));
3038 XSETINT (result->x, LOWORD (msg->msg.lParam));
3039 XSETINT (result->y, HIWORD (msg->msg.lParam));
3040 XSETFRAME (result->frame_or_window, f);
3041 result->arg = Qnil;
3042 return Qnil;
3045 static Lisp_Object
3046 construct_mouse_wheel (struct input_event *result, W32Msg *msg, struct frame *f)
3048 POINT p;
3049 int delta;
3051 result->kind = msg->msg.message == WM_MOUSEHWHEEL ? HORIZ_WHEEL_EVENT
3052 : WHEEL_EVENT;
3053 result->code = 0;
3054 result->timestamp = msg->msg.time;
3056 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3057 forward, away from the user (up); a negative value indicates that
3058 the wheel was rotated backward, toward the user (down). */
3059 delta = GET_WHEEL_DELTA_WPARAM (msg->msg.wParam);
3061 /* The up and down modifiers indicate if the wheel was rotated up or
3062 down based on WHEEL_DELTA value. */
3063 result->modifiers = (msg->dwModifiers
3064 | ((delta < 0 ) ? down_modifier : up_modifier));
3066 /* With multiple monitors, we can legitimately get negative
3067 coordinates, so cast to short to interpret them correctly. */
3068 p.x = (short) LOWORD (msg->msg.lParam);
3069 p.y = (short) HIWORD (msg->msg.lParam);
3070 ScreenToClient (msg->msg.hwnd, &p);
3071 XSETINT (result->x, p.x);
3072 XSETINT (result->y, p.y);
3073 XSETFRAME (result->frame_or_window, f);
3074 result->arg = Qnil;
3075 return Qnil;
3078 static Lisp_Object
3079 construct_drag_n_drop (struct input_event *result, W32Msg *msg, struct frame *f)
3081 Lisp_Object files;
3082 Lisp_Object frame;
3083 HDROP hdrop;
3084 POINT p;
3085 WORD num_files;
3086 wchar_t name_w[MAX_PATH];
3087 #ifdef NTGUI_UNICODE
3088 const int use_unicode = 1;
3089 #else
3090 int use_unicode = w32_unicode_filenames;
3091 char name_a[MAX_PATH];
3092 char file[MAX_UTF8_PATH];
3093 #endif
3094 int i;
3096 result->kind = DRAG_N_DROP_EVENT;
3097 result->code = 0;
3098 result->timestamp = msg->msg.time;
3099 result->modifiers = msg->dwModifiers;
3101 hdrop = (HDROP) msg->msg.wParam;
3102 DragQueryPoint (hdrop, &p);
3104 #if 0
3105 p.x = LOWORD (msg->msg.lParam);
3106 p.y = HIWORD (msg->msg.lParam);
3107 ScreenToClient (msg->msg.hwnd, &p);
3108 #endif
3110 XSETINT (result->x, p.x);
3111 XSETINT (result->y, p.y);
3113 num_files = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0);
3114 files = Qnil;
3116 for (i = 0; i < num_files; i++)
3118 if (use_unicode)
3120 eassert (DragQueryFileW (hdrop, i, NULL, 0) < MAX_PATH);
3121 /* If DragQueryFile returns zero, it failed to fetch a file
3122 name. */
3123 if (DragQueryFileW (hdrop, i, name_w, MAX_PATH) == 0)
3124 continue;
3125 #ifdef NTGUI_UNICODE
3126 files = Fcons (from_unicode_buffer (name_w), files);
3127 #else
3128 filename_from_utf16 (name_w, file);
3129 files = Fcons (DECODE_FILE (build_unibyte_string (file)), files);
3130 #endif /* NTGUI_UNICODE */
3132 #ifndef NTGUI_UNICODE
3133 else
3135 eassert (DragQueryFileA (hdrop, i, NULL, 0) < MAX_PATH);
3136 if (DragQueryFileA (hdrop, i, name_a, MAX_PATH) == 0)
3137 continue;
3138 filename_from_ansi (name_a, file);
3139 files = Fcons (DECODE_FILE (build_unibyte_string (file)), files);
3141 #endif
3144 DragFinish (hdrop);
3146 XSETFRAME (frame, f);
3147 result->frame_or_window = frame;
3148 result->arg = files;
3149 return Qnil;
3153 #if HAVE_W32NOTIFY
3155 /* File event notifications (see w32notify.c). */
3157 Lisp_Object
3158 lispy_file_action (DWORD action)
3160 static char unknown_fmt[] = "unknown-action(%d)";
3161 Lisp_Object retval;
3163 switch (action)
3165 case FILE_ACTION_ADDED:
3166 retval = Qadded;
3167 break;
3168 case FILE_ACTION_REMOVED:
3169 retval = Qremoved;
3170 break;
3171 case FILE_ACTION_MODIFIED:
3172 retval = Qmodified;
3173 break;
3174 case FILE_ACTION_RENAMED_OLD_NAME:
3175 retval = Qrenamed_from;
3176 break;
3177 case FILE_ACTION_RENAMED_NEW_NAME:
3178 retval = Qrenamed_to;
3179 break;
3180 default:
3182 char buf[sizeof(unknown_fmt) - 1 + INT_STRLEN_BOUND (DWORD)];
3184 sprintf (buf, unknown_fmt, action);
3185 retval = intern (buf);
3187 break;
3190 return retval;
3193 #ifdef WINDOWSNT
3194 /* Put file notifications into the Emacs input event queue. This
3195 function runs when the WM_EMACS_FILENOTIFY message arrives from a
3196 watcher thread. */
3197 static void
3198 queue_notifications (struct input_event *event, W32Msg *msg, struct frame *f,
3199 int *evcount)
3201 BYTE *p = file_notifications;
3202 FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
3203 const DWORD min_size
3204 = offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
3205 Lisp_Object frame;
3207 /* We cannot process notification before Emacs is fully initialized,
3208 since we need the UTF-16LE coding-system to be set up. */
3209 if (!initialized)
3211 notification_buffer_in_use = 0;
3212 return;
3215 XSETFRAME (frame, f);
3217 enter_crit ();
3218 if (notification_buffer_in_use)
3220 DWORD info_size = notifications_size;
3221 Lisp_Object cs = intern ("utf-16le");
3222 Lisp_Object obj = w32_get_watch_object (notifications_desc);
3224 /* notifications_size could be zero when the buffer of
3225 notifications overflowed on the OS level, or when the
3226 directory being watched was itself deleted. Do nothing in
3227 that case. */
3228 if (info_size
3229 && !NILP (obj) && CONSP (obj))
3231 Lisp_Object callback = XCDR (obj);
3233 while (info_size >= min_size)
3235 Lisp_Object utf_16_fn
3236 = make_unibyte_string ((char *)fni->FileName,
3237 fni->FileNameLength);
3238 /* Note: mule-conf is preloaded, so utf-16le must
3239 already be defined at this point. */
3240 Lisp_Object fname
3241 = code_convert_string_norecord (utf_16_fn, cs, 0);
3242 Lisp_Object action = lispy_file_action (fni->Action);
3244 event->kind = FILE_NOTIFY_EVENT;
3245 event->code
3246 = (ptrdiff_t)XINT (XIL ((EMACS_INT)notifications_desc));
3247 event->timestamp = msg->msg.time;
3248 event->modifiers = 0;
3249 event->frame_or_window = callback;
3250 event->arg = Fcons (action, fname);
3251 kbd_buffer_store_event (event);
3252 (*evcount)++;
3254 if (!fni->NextEntryOffset)
3255 break;
3256 p += fni->NextEntryOffset;
3257 fni = (PFILE_NOTIFY_INFORMATION)p;
3258 info_size -= fni->NextEntryOffset;
3261 notification_buffer_in_use = 0;
3263 else
3264 DebPrint (("We were promised notifications, but in-use flag is zero!\n"));
3265 leave_crit ();
3267 /* We've stuffed all the events ourselves, so w32_read_socket shouldn't. */
3268 event->kind = NO_EVENT;
3270 #endif /* WINDOWSNT */
3271 #endif /* HAVE_W32NOTIFY */
3274 /* Function to report a mouse movement to the mainstream Emacs code.
3275 The input handler calls this.
3277 We have received a mouse movement event, which is given in *event.
3278 If the mouse is over a different glyph than it was last time, tell
3279 the mainstream emacs code by setting mouse_moved. If not, ask for
3280 another motion event, so we can check again the next time it moves. */
3282 static int
3283 note_mouse_movement (struct frame *frame, MSG *msg)
3285 struct w32_display_info *dpyinfo;
3286 int mouse_x = LOWORD (msg->lParam);
3287 int mouse_y = HIWORD (msg->lParam);
3288 RECT *r;
3290 if (!FRAME_X_OUTPUT (frame))
3291 return 0;
3293 dpyinfo = FRAME_DISPLAY_INFO (frame);
3294 dpyinfo->last_mouse_movement_time = msg->time;
3295 dpyinfo->last_mouse_motion_frame = frame;
3296 dpyinfo->last_mouse_motion_x = mouse_x;
3297 dpyinfo->last_mouse_motion_y = mouse_y;
3299 if (msg->hwnd != FRAME_W32_WINDOW (frame))
3301 frame->mouse_moved = 1;
3302 dpyinfo->last_mouse_scroll_bar = NULL;
3303 note_mouse_highlight (frame, -1, -1);
3304 dpyinfo->last_mouse_glyph_frame = NULL;
3305 return 1;
3308 /* Has the mouse moved off the glyph it was on at the last sighting? */
3309 r = &dpyinfo->last_mouse_glyph;
3310 if (frame != dpyinfo->last_mouse_glyph_frame
3311 || mouse_x < r->left || mouse_x >= r->right
3312 || mouse_y < r->top || mouse_y >= r->bottom)
3314 frame->mouse_moved = 1;
3315 dpyinfo->last_mouse_scroll_bar = NULL;
3316 note_mouse_highlight (frame, mouse_x, mouse_y);
3317 /* Remember the mouse position here, as w32_mouse_position only
3318 gets called when mouse tracking is enabled but we also need
3319 to keep track of the mouse for help_echo and highlighting at
3320 other times. */
3321 remember_mouse_glyph (frame, mouse_x, mouse_y, r);
3322 dpyinfo->last_mouse_glyph_frame = frame;
3323 return 1;
3326 return 0;
3330 /************************************************************************
3331 Mouse Face
3332 ************************************************************************/
3334 static struct scroll_bar *x_window_to_scroll_bar (Window);
3335 static void x_scroll_bar_report_motion (struct frame **, Lisp_Object *,
3336 enum scroll_bar_part *,
3337 Lisp_Object *, Lisp_Object *,
3338 unsigned long *);
3339 static void x_check_fullscreen (struct frame *);
3341 static void
3342 w32_define_cursor (Window window, Cursor cursor)
3344 PostMessage (window, WM_EMACS_SETCURSOR, (WPARAM) cursor, 0);
3346 /* Return the current position of the mouse.
3347 *fp should be a frame which indicates which display to ask about.
3349 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3350 and *part to the frame, window, and scroll bar part that the mouse
3351 is over. Set *x and *y to the portion and whole of the mouse's
3352 position on the scroll bar.
3354 If the mouse movement started elsewhere, set *fp to the frame the
3355 mouse is on, *bar_window to nil, and *x and *y to the character cell
3356 the mouse is over.
3358 Set *time to the server time-stamp for the time at which the mouse
3359 was at this position.
3361 Don't store anything if we don't have a valid set of values to report.
3363 This clears the mouse_moved flag, so we can wait for the next mouse
3364 movement. */
3366 static void
3367 w32_mouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
3368 enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
3369 unsigned long *time)
3371 struct frame *f1;
3372 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
3374 block_input ();
3376 if (dpyinfo->last_mouse_scroll_bar && insist == 0)
3377 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
3378 else
3380 POINT pt;
3382 Lisp_Object frame, tail;
3384 /* Clear the mouse-moved flag for every frame on this display. */
3385 FOR_EACH_FRAME (tail, frame)
3386 XFRAME (frame)->mouse_moved = 0;
3388 dpyinfo->last_mouse_scroll_bar = NULL;
3390 GetCursorPos (&pt);
3392 /* Now we have a position on the root; find the innermost window
3393 containing the pointer. */
3395 /* If mouse was grabbed on a frame, give coords for that
3396 frame even if the mouse is now outside it. Otherwise
3397 check for window under mouse on one of our frames. */
3398 f1 = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
3399 : x_any_window_to_frame (dpyinfo, WindowFromPoint (pt)));
3401 /* If not, is it one of our scroll bars? */
3402 if (! f1)
3404 struct scroll_bar *bar
3405 = x_window_to_scroll_bar (WindowFromPoint (pt));
3407 if (bar)
3408 f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3411 if (f1 == 0 && insist > 0)
3412 f1 = SELECTED_FRAME ();
3414 if (f1)
3416 /* Ok, we found a frame. Store all the values.
3417 last_mouse_glyph is a rectangle used to reduce the
3418 generation of mouse events. To not miss any motion
3419 events, we must divide the frame into rectangles of the
3420 size of the smallest character that could be displayed
3421 on it, i.e. into the same rectangles that matrices on
3422 the frame are divided into. */
3424 dpyinfo = FRAME_DISPLAY_INFO (f1);
3425 ScreenToClient (FRAME_W32_WINDOW (f1), &pt);
3426 remember_mouse_glyph (f1, pt.x, pt.y, &dpyinfo->last_mouse_glyph);
3427 dpyinfo->last_mouse_glyph_frame = f1;
3429 *bar_window = Qnil;
3430 *part = 0;
3431 *fp = f1;
3432 XSETINT (*x, pt.x);
3433 XSETINT (*y, pt.y);
3434 *time = dpyinfo->last_mouse_movement_time;
3439 unblock_input ();
3443 /***********************************************************************
3444 Tool-bars
3445 ***********************************************************************/
3447 /* Handle mouse button event on the tool-bar of frame F, at
3448 frame-relative coordinates X/Y. EVENT_TYPE is either ButtonPress
3449 or ButtonRelease. */
3451 static void
3452 w32_handle_tool_bar_click (struct frame *f, struct input_event *button_event)
3454 int x = XFASTINT (button_event->x);
3455 int y = XFASTINT (button_event->y);
3457 if (button_event->modifiers & down_modifier)
3458 handle_tool_bar_click (f, x, y, 1, 0);
3459 else
3460 handle_tool_bar_click (f, x, y, 0,
3461 button_event->modifiers & ~up_modifier);
3466 /***********************************************************************
3467 Scroll bars
3468 ***********************************************************************/
3470 /* Scroll bar support. */
3472 /* Given a window ID, find the struct scroll_bar which manages it.
3473 This can be called in GC, so we have to make sure to strip off mark
3474 bits. */
3476 static struct scroll_bar *
3477 x_window_to_scroll_bar (Window window_id)
3479 Lisp_Object tail, frame;
3481 FOR_EACH_FRAME (tail, frame)
3483 Lisp_Object bar, condemned;
3485 /* Scan this frame's scroll bar list for a scroll bar with the
3486 right window ID. */
3487 condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
3488 for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
3489 /* This trick allows us to search both the ordinary and
3490 condemned scroll bar lists with one loop. */
3491 ! NILP (bar) || (bar = condemned,
3492 condemned = Qnil,
3493 ! NILP (bar));
3494 bar = XSCROLL_BAR (bar)->next)
3495 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar)) == window_id)
3496 return XSCROLL_BAR (bar);
3499 return 0;
3504 /* Set the thumb size and position of scroll bar BAR. We are currently
3505 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3507 static void
3508 w32_set_scroll_bar_thumb (struct scroll_bar *bar,
3509 int portion, int position, int whole)
3511 Window w = SCROLL_BAR_W32_WINDOW (bar);
3512 /* We use the whole scroll-bar height in the calculations below, to
3513 avoid strange effects like scrolling backwards when just clicking
3514 on the handle (without moving it). */
3515 double range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height)
3516 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3517 int sb_page, sb_pos;
3518 BOOL draggingp = bar->dragging ? TRUE : FALSE;
3519 SCROLLINFO si;
3521 /* We used to change the nPage setting while dragging the handle,
3522 but that had very strange effects (such as scrolling backwards
3523 while dragging downwards).
3525 Now, we don't change the nPage setting while dragging unless we
3526 get near to the end of the buffer, in which case we often have to
3527 resize the handle to "go all the way". */
3529 if (draggingp)
3531 int near_bottom_p;
3532 block_input ();
3533 si.cbSize = sizeof (si);
3534 si.fMask = SIF_POS | SIF_PAGE;
3535 GetScrollInfo (w, SB_CTL, &si);
3536 near_bottom_p = si.nPos + si.nPage >= range;
3537 unblock_input ();
3538 if (!near_bottom_p)
3539 return;
3542 if (whole)
3544 /* Position scroll bar at rock bottom if the bottom of the
3545 buffer is visible. This avoids shrinking the thumb away
3546 to nothing if it is held at the bottom of the buffer. */
3547 if (position + portion >= whole && !draggingp)
3549 sb_page = range * (whole - position) / whole;
3550 sb_pos = range;
3552 else
3554 sb_pos = position * range / whole;
3555 sb_page = (min (portion, (whole - position)) * range) / whole;
3558 else
3560 sb_page = range;
3561 sb_pos = 0;
3564 sb_page = max (sb_page, VERTICAL_SCROLL_BAR_MIN_HANDLE);
3566 block_input ();
3568 si.cbSize = sizeof (si);
3569 si.fMask = SIF_PAGE | SIF_POS;
3570 si.nPage = sb_page;
3571 si.nPos = sb_pos;
3573 SetScrollInfo (w, SB_CTL, &si, TRUE);
3575 unblock_input ();
3579 /************************************************************************
3580 Scroll bars, general
3581 ************************************************************************/
3583 static HWND
3584 my_create_scrollbar (struct frame * f, struct scroll_bar * bar)
3586 return (HWND) SendMessage (FRAME_W32_WINDOW (f),
3587 WM_EMACS_CREATESCROLLBAR, (WPARAM) f,
3588 (LPARAM) bar);
3591 /*#define ATTACH_THREADS*/
3593 static BOOL
3594 my_show_window (struct frame *f, HWND hwnd, int how)
3596 #ifndef ATTACH_THREADS
3597 return SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SHOWWINDOW,
3598 (WPARAM) hwnd, (LPARAM) how);
3599 #else
3600 return ShowWindow (hwnd, how);
3601 #endif
3604 static void
3605 my_set_window_pos (HWND hwnd, HWND hwndAfter,
3606 int x, int y, int cx, int cy, UINT flags)
3608 #ifndef ATTACH_THREADS
3609 WINDOWPOS pos;
3610 pos.hwndInsertAfter = hwndAfter;
3611 pos.x = x;
3612 pos.y = y;
3613 pos.cx = cx;
3614 pos.cy = cy;
3615 pos.flags = flags;
3616 SendMessage (hwnd, WM_EMACS_SETWINDOWPOS, (WPARAM) &pos, 0);
3617 #else
3618 SetWindowPos (hwnd, hwndAfter, x, y, cx, cy, flags);
3619 #endif
3622 #if 0
3623 static void
3624 my_set_focus (struct frame * f, HWND hwnd)
3626 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SETFOCUS,
3627 (WPARAM) hwnd, 0);
3629 #endif
3631 static void
3632 my_set_foreground_window (HWND hwnd)
3634 SendMessage (hwnd, WM_EMACS_SETFOREGROUND, (WPARAM) hwnd, 0);
3638 static void
3639 my_destroy_window (struct frame * f, HWND hwnd)
3641 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_DESTROYWINDOW,
3642 (WPARAM) hwnd, 0);
3645 static void
3646 my_bring_window_to_top (HWND hwnd)
3648 SendMessage (hwnd, WM_EMACS_BRINGTOTOP, (WPARAM) hwnd, 0);
3651 /* Create a scroll bar and return the scroll bar vector for it. W is
3652 the Emacs window on which to create the scroll bar. TOP, LEFT,
3653 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
3654 scroll bar. */
3656 static struct scroll_bar *
3657 x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
3659 struct frame *f = XFRAME (WINDOW_FRAME (w));
3660 HWND hwnd;
3661 SCROLLINFO si;
3662 struct scroll_bar *bar
3663 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar, top, PVEC_OTHER);
3664 Lisp_Object barobj;
3666 block_input ();
3668 XSETWINDOW (bar->window, w);
3669 bar->top = top;
3670 bar->left = left;
3671 bar->width = width;
3672 bar->height = height;
3673 bar->start = 0;
3674 bar->end = 0;
3675 bar->dragging = 0;
3677 /* Requires geometry to be set before call to create the real window */
3679 hwnd = my_create_scrollbar (f, bar);
3681 si.cbSize = sizeof (si);
3682 si.fMask = SIF_ALL;
3683 si.nMin = 0;
3684 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
3685 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3686 si.nPage = si.nMax;
3687 si.nPos = 0;
3689 SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3691 SET_SCROLL_BAR_W32_WINDOW (bar, hwnd);
3693 /* Add bar to its frame's list of scroll bars. */
3694 bar->next = FRAME_SCROLL_BARS (f);
3695 bar->prev = Qnil;
3696 XSETVECTOR (barobj, bar);
3697 fset_scroll_bars (f, barobj);
3698 if (! NILP (bar->next))
3699 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
3701 unblock_input ();
3703 return bar;
3707 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3708 nil. */
3710 static void
3711 x_scroll_bar_remove (struct scroll_bar *bar)
3713 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3715 block_input ();
3717 /* Destroy the window. */
3718 my_destroy_window (f, SCROLL_BAR_W32_WINDOW (bar));
3720 /* Dissociate this scroll bar from its window. */
3721 wset_vertical_scroll_bar (XWINDOW (bar->window), Qnil);
3723 unblock_input ();
3726 /* Set the handle of the vertical scroll bar for WINDOW to indicate
3727 that we are displaying PORTION characters out of a total of WHOLE
3728 characters, starting at POSITION. If WINDOW has no scroll bar,
3729 create one. */
3730 static void
3731 w32_set_vertical_scroll_bar (struct window *w,
3732 int portion, int whole, int position)
3734 struct frame *f = XFRAME (w->frame);
3735 Lisp_Object barobj;
3736 struct scroll_bar *bar;
3737 int top, height, left, width;
3738 int window_y, window_height;
3740 /* Get window dimensions. */
3741 window_box (w, ANY_AREA, 0, &window_y, 0, &window_height);
3742 top = window_y;
3743 height = window_height;
3745 /* Compute the left edge and the width of the scroll bar area. */
3746 left = WINDOW_SCROLL_BAR_AREA_X (w);
3747 width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
3749 /* Does the scroll bar exist yet? */
3750 if (NILP (w->vertical_scroll_bar))
3752 HDC hdc;
3753 block_input ();
3754 if (width > 0 && height > 0)
3756 hdc = get_frame_dc (f);
3757 w32_clear_area (f, hdc, left, top, width, height);
3758 release_frame_dc (f, hdc);
3760 unblock_input ();
3762 bar = x_scroll_bar_create (w, top, left, width, height);
3764 else
3766 /* It may just need to be moved and resized. */
3767 HWND hwnd;
3769 bar = XSCROLL_BAR (w->vertical_scroll_bar);
3770 hwnd = SCROLL_BAR_W32_WINDOW (bar);
3772 /* If already correctly positioned, do nothing. */
3773 if (bar->left == left
3774 && bar->top == top
3775 && bar->width == width
3776 && bar->height == height)
3778 /* Redraw after clear_frame. */
3779 if (!my_show_window (f, hwnd, SW_NORMAL))
3780 InvalidateRect (hwnd, NULL, FALSE);
3782 else
3784 HDC hdc;
3785 SCROLLINFO si;
3787 block_input ();
3788 if (width && height)
3790 hdc = get_frame_dc (f);
3791 /* Since Windows scroll bars are smaller than the space reserved
3792 for them on the frame, we have to clear "under" them. */
3793 w32_clear_area (f, hdc, left, top, width, height);
3794 release_frame_dc (f, hdc);
3796 /* Make sure scroll bar is "visible" before moving, to ensure the
3797 area of the parent window now exposed will be refreshed. */
3798 my_show_window (f, hwnd, SW_HIDE);
3799 MoveWindow (hwnd, left, top, width, max (height, 1), TRUE);
3801 si.cbSize = sizeof (si);
3802 si.fMask = SIF_RANGE;
3803 si.nMin = 0;
3804 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
3805 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3807 SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3809 my_show_window (f, hwnd, SW_NORMAL);
3810 /* InvalidateRect (w, NULL, FALSE); */
3812 /* Remember new settings. */
3813 bar->left = left;
3814 bar->top = top;
3815 bar->width = width;
3816 bar->height = height;
3818 unblock_input ();
3821 w32_set_scroll_bar_thumb (bar, portion, position, whole);
3822 XSETVECTOR (barobj, bar);
3823 wset_vertical_scroll_bar (w, barobj);
3827 /* The following three hooks are used when we're doing a thorough
3828 redisplay of the frame. We don't explicitly know which scroll bars
3829 are going to be deleted, because keeping track of when windows go
3830 away is a real pain - "Can you say set-window-configuration, boys
3831 and girls?" Instead, we just assert at the beginning of redisplay
3832 that *all* scroll bars are to be removed, and then save a scroll bar
3833 from the fiery pit when we actually redisplay its window. */
3835 /* Arrange for all scroll bars on FRAME to be removed at the next call
3836 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
3837 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
3839 static void
3840 w32_condemn_scroll_bars (struct frame *frame)
3842 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
3843 while (! NILP (FRAME_SCROLL_BARS (frame)))
3845 Lisp_Object bar;
3846 bar = FRAME_SCROLL_BARS (frame);
3847 fset_scroll_bars (frame, XSCROLL_BAR (bar)->next);
3848 XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
3849 XSCROLL_BAR (bar)->prev = Qnil;
3850 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
3851 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
3852 fset_condemned_scroll_bars (frame, bar);
3857 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
3858 Note that WINDOW isn't necessarily condemned at all. */
3860 static void
3861 w32_redeem_scroll_bar (struct window *window)
3863 struct scroll_bar *bar;
3864 Lisp_Object barobj;
3865 struct frame *f;
3867 /* We can't redeem this window's scroll bar if it doesn't have one. */
3868 if (NILP (window->vertical_scroll_bar))
3869 emacs_abort ();
3871 bar = XSCROLL_BAR (window->vertical_scroll_bar);
3873 /* Unlink it from the condemned list. */
3874 f = XFRAME (WINDOW_FRAME (window));
3875 if (NILP (bar->prev))
3877 /* If the prev pointer is nil, it must be the first in one of
3878 the lists. */
3879 if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
3880 /* It's not condemned. Everything's fine. */
3881 return;
3882 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
3883 window->vertical_scroll_bar))
3884 fset_condemned_scroll_bars (f, bar->next);
3885 else
3886 /* If its prev pointer is nil, it must be at the front of
3887 one or the other! */
3888 emacs_abort ();
3890 else
3891 XSCROLL_BAR (bar->prev)->next = bar->next;
3893 if (! NILP (bar->next))
3894 XSCROLL_BAR (bar->next)->prev = bar->prev;
3896 bar->next = FRAME_SCROLL_BARS (f);
3897 bar->prev = Qnil;
3898 XSETVECTOR (barobj, bar);
3899 fset_scroll_bars (f, barobj);
3900 if (! NILP (bar->next))
3901 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
3904 /* Remove all scroll bars on FRAME that haven't been saved since the
3905 last call to `*condemn_scroll_bars_hook'. */
3907 static void
3908 w32_judge_scroll_bars (struct frame *f)
3910 Lisp_Object bar, next;
3912 bar = FRAME_CONDEMNED_SCROLL_BARS (f);
3914 /* Clear out the condemned list now so we won't try to process any
3915 more events on the hapless scroll bars. */
3916 fset_condemned_scroll_bars (f, Qnil);
3918 for (; ! NILP (bar); bar = next)
3920 struct scroll_bar *b = XSCROLL_BAR (bar);
3922 x_scroll_bar_remove (b);
3924 next = b->next;
3925 b->next = b->prev = Qnil;
3928 /* Now there should be no references to the condemned scroll bars,
3929 and they should get garbage-collected. */
3932 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
3933 is set to something other than NO_EVENT, it is enqueued.
3935 This may be called from a signal handler, so we have to ignore GC
3936 mark bits. */
3938 static int
3939 w32_scroll_bar_handle_click (struct scroll_bar *bar, W32Msg *msg,
3940 struct input_event *emacs_event)
3942 if (! WINDOWP (bar->window))
3943 emacs_abort ();
3945 emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
3946 emacs_event->code = 0;
3947 /* not really meaningful to distinguish up/down */
3948 emacs_event->modifiers = msg->dwModifiers;
3949 emacs_event->frame_or_window = bar->window;
3950 emacs_event->arg = Qnil;
3951 emacs_event->timestamp = msg->msg.time;
3954 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height);
3955 int y;
3956 int dragging = bar->dragging;
3957 SCROLLINFO si;
3959 si.cbSize = sizeof (si);
3960 si.fMask = SIF_POS;
3962 GetScrollInfo ((HWND) msg->msg.lParam, SB_CTL, &si);
3963 y = si.nPos;
3965 bar->dragging = 0;
3966 FRAME_DISPLAY_INFO (f)->last_mouse_scroll_bar_pos = msg->msg.wParam;
3968 switch (LOWORD (msg->msg.wParam))
3970 case SB_LINEDOWN:
3971 emacs_event->part = scroll_bar_down_arrow;
3972 break;
3973 case SB_LINEUP:
3974 emacs_event->part = scroll_bar_up_arrow;
3975 break;
3976 case SB_PAGEUP:
3977 emacs_event->part = scroll_bar_above_handle;
3978 break;
3979 case SB_PAGEDOWN:
3980 emacs_event->part = scroll_bar_below_handle;
3981 break;
3982 case SB_TOP:
3983 emacs_event->part = scroll_bar_handle;
3984 y = 0;
3985 break;
3986 case SB_BOTTOM:
3987 emacs_event->part = scroll_bar_handle;
3988 y = top_range;
3989 break;
3990 case SB_THUMBTRACK:
3991 case SB_THUMBPOSITION:
3992 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height) <= 0xffff)
3993 y = HIWORD (msg->msg.wParam);
3994 bar->dragging = 1; /* ??????? */
3995 emacs_event->part = scroll_bar_handle;
3997 /* "Silently" update current position. */
3999 SCROLLINFO si;
4001 si.cbSize = sizeof (si);
4002 si.fMask = SIF_POS;
4003 si.nPos = y;
4004 /* Remember apparent position (we actually lag behind the real
4005 position, so don't set that directly). */
4006 last_scroll_bar_drag_pos = y;
4008 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, FALSE);
4010 break;
4011 case SB_ENDSCROLL:
4012 /* If this is the end of a drag sequence, then reset the scroll
4013 handle size to normal and do a final redraw. Otherwise do
4014 nothing. */
4015 if (dragging)
4017 SCROLLINFO si;
4018 int start = bar->start;
4019 int end = bar->end;
4021 si.cbSize = sizeof (si);
4022 si.fMask = SIF_PAGE | SIF_POS;
4023 si.nPage = end - start + VERTICAL_SCROLL_BAR_MIN_HANDLE;
4024 si.nPos = last_scroll_bar_drag_pos;
4025 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE);
4027 /* fall through */
4028 default:
4029 emacs_event->kind = NO_EVENT;
4030 return FALSE;
4033 XSETINT (emacs_event->x, y);
4034 XSETINT (emacs_event->y, top_range);
4036 return TRUE;
4040 /* Return information to the user about the current position of the mouse
4041 on the scroll bar. */
4043 static void
4044 x_scroll_bar_report_motion (struct frame **fp, Lisp_Object *bar_window,
4045 enum scroll_bar_part *part,
4046 Lisp_Object *x, Lisp_Object *y,
4047 unsigned long *time)
4049 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
4050 struct scroll_bar *bar = dpyinfo->last_mouse_scroll_bar;
4051 Window w = SCROLL_BAR_W32_WINDOW (bar);
4052 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
4053 int pos;
4054 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height);
4055 SCROLLINFO si;
4057 block_input ();
4059 *fp = f;
4060 *bar_window = bar->window;
4062 si.cbSize = sizeof (si);
4063 si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
4065 GetScrollInfo (w, SB_CTL, &si);
4066 pos = si.nPos;
4067 top_range = si.nMax - si.nPage + 1;
4069 switch (LOWORD (dpyinfo->last_mouse_scroll_bar_pos))
4071 case SB_THUMBPOSITION:
4072 case SB_THUMBTRACK:
4073 *part = scroll_bar_handle;
4074 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, bar->height) <= 0xffff)
4075 pos = HIWORD (dpyinfo->last_mouse_scroll_bar_pos);
4076 break;
4077 case SB_LINEDOWN:
4078 *part = scroll_bar_handle;
4079 pos++;
4080 break;
4081 default:
4082 *part = scroll_bar_handle;
4083 break;
4086 XSETINT (*x, pos);
4087 XSETINT (*y, top_range);
4089 f->mouse_moved = 0;
4090 dpyinfo->last_mouse_scroll_bar = NULL;
4092 *time = dpyinfo->last_mouse_movement_time;
4094 unblock_input ();
4098 /* The screen has been cleared so we may have changed foreground or
4099 background colors, and the scroll bars may need to be redrawn.
4100 Clear out the scroll bars, and ask for expose events, so we can
4101 redraw them. */
4103 void
4104 x_scroll_bar_clear (struct frame *f)
4106 Lisp_Object bar;
4108 /* We can have scroll bars even if this is 0,
4109 if we just turned off scroll bar mode.
4110 But in that case we should not clear them. */
4111 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
4112 for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
4113 bar = XSCROLL_BAR (bar)->next)
4115 HWND window = SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar));
4116 HDC hdc = GetDC (window);
4117 RECT rect;
4119 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4120 arranges to refresh the scroll bar if hidden. */
4121 my_show_window (f, window, SW_HIDE);
4123 GetClientRect (window, &rect);
4124 select_palette (f, hdc);
4125 w32_clear_rect (f, hdc, &rect);
4126 deselect_palette (f, hdc);
4128 ReleaseDC (window, hdc);
4133 /* The main W32 event-reading loop - w32_read_socket. */
4135 /* Record the last 100 characters stored
4136 to help debug the loss-of-chars-during-GC problem. */
4138 static int temp_index;
4139 static short temp_buffer[100];
4141 /* Temporarily store lead byte of DBCS input sequences. */
4142 static char dbcs_lead = 0;
4144 /* Read events coming from the W32 shell.
4145 This routine is called by the SIGIO handler.
4146 We return as soon as there are no more events to be read.
4148 For an overview of how Emacs input works on MS-Windows, see the
4149 commentary before w32_msg_pump in w32fns.c.
4151 We return the number of characters stored into the buffer,
4152 thus pretending to be `read'.
4154 Some of these messages are reposted back to the message queue since the
4155 system calls the windows proc directly in a context where we cannot return
4156 the data nor can we guarantee the state we are in. So if we dispatch them
4157 we will get into an infinite loop. To prevent this from ever happening we
4158 will set a variable to indicate we are in the read_socket call and indicate
4159 which message we are processing since the windows proc gets called
4160 recursively with different messages by the system.
4163 static int
4164 w32_read_socket (struct terminal *terminal,
4165 struct input_event *hold_quit)
4167 int count = 0;
4168 int check_visibility = 0;
4169 W32Msg msg;
4170 struct frame *f;
4171 struct w32_display_info *dpyinfo = &one_w32_display_info;
4172 Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
4174 block_input ();
4176 /* So people can tell when we have read the available input. */
4177 input_signal_count++;
4179 /* Process any incoming thread messages. */
4180 drain_message_queue ();
4182 /* TODO: ghostscript integration. */
4183 while (get_next_msg (&msg, FALSE))
4185 struct input_event inev;
4186 int do_help = 0;
4188 /* DebPrint (("w32_read_socket: %s time:%u\n", */
4189 /* w32_name_of_message (msg.msg.message), */
4190 /* msg.msg.time)); */
4192 EVENT_INIT (inev);
4193 inev.kind = NO_EVENT;
4194 inev.arg = Qnil;
4196 switch (msg.msg.message)
4198 case WM_EMACS_PAINT:
4199 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4201 if (f)
4203 if (msg.rect.right == msg.rect.left ||
4204 msg.rect.bottom == msg.rect.top)
4206 /* We may get paint messages even though the client
4207 area is clipped - these are not expose events. */
4208 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f,
4209 SDATA (f->name)));
4211 else if (FRAME_VISIBLE_P (f) != 1)
4213 bool iconified = FRAME_ICONIFIED_P (f);
4215 /* Definitely not obscured, so mark as visible. */
4216 SET_FRAME_VISIBLE (f, 1);
4217 SET_FRAME_ICONIFIED (f, 0);
4218 SET_FRAME_GARBAGED (f);
4219 if (!f->output_data.w32->asked_for_visible)
4220 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f,
4221 SDATA (f->name)));
4223 /* WM_PAINT serves as MapNotify as well, so report
4224 visibility changes properly. */
4225 if (iconified)
4227 inev.kind = DEICONIFY_EVENT;
4228 XSETFRAME (inev.frame_or_window, f);
4230 else if (!NILP (Vframe_list) && !NILP (XCDR (Vframe_list)))
4231 /* Force a redisplay sooner or later to update the
4232 frame titles in case this is the second frame. */
4233 record_asynch_buffer_change ();
4235 else
4237 HDC hdc = get_frame_dc (f);
4239 /* Erase background again for safety. */
4240 w32_clear_rect (f, hdc, &msg.rect);
4241 release_frame_dc (f, hdc);
4242 expose_frame (f,
4243 msg.rect.left,
4244 msg.rect.top,
4245 msg.rect.right - msg.rect.left,
4246 msg.rect.bottom - msg.rect.top);
4249 break;
4251 case WM_INPUTLANGCHANGE:
4252 /* Generate a language change event. */
4253 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4255 /* lParam contains the input language ID in its low 16 bits.
4256 Use it to update our record of the keyboard codepage. */
4257 w32_keyboard_codepage = codepage_for_locale ((LCID)(msg.msg.lParam
4258 & 0xffff));
4260 if (f)
4262 inev.kind = LANGUAGE_CHANGE_EVENT;
4263 XSETFRAME (inev.frame_or_window, f);
4264 inev.code = w32_keyboard_codepage;
4265 inev.modifiers = msg.msg.lParam & 0xffff;
4267 break;
4269 case WM_KEYDOWN:
4270 case WM_SYSKEYDOWN:
4271 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4273 if (f && !FRAME_ICONIFIED_P (f))
4275 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4276 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4278 clear_mouse_face (hlinfo);
4279 hlinfo->mouse_face_hidden = 1;
4282 if (temp_index == sizeof temp_buffer / sizeof (short))
4283 temp_index = 0;
4284 temp_buffer[temp_index++] = msg.msg.wParam;
4285 inev.kind = NON_ASCII_KEYSTROKE_EVENT;
4286 inev.code = msg.msg.wParam;
4287 inev.modifiers = msg.dwModifiers;
4288 XSETFRAME (inev.frame_or_window, f);
4289 inev.timestamp = msg.msg.time;
4291 break;
4293 case WM_UNICHAR:
4294 case WM_SYSCHAR:
4295 case WM_CHAR:
4296 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4298 if (f && !FRAME_ICONIFIED_P (f))
4300 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4301 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4303 clear_mouse_face (hlinfo);
4304 hlinfo->mouse_face_hidden = 1;
4307 if (temp_index == sizeof temp_buffer / sizeof (short))
4308 temp_index = 0;
4309 temp_buffer[temp_index++] = msg.msg.wParam;
4311 inev.modifiers = msg.dwModifiers;
4312 XSETFRAME (inev.frame_or_window, f);
4313 inev.timestamp = msg.msg.time;
4315 if (msg.msg.message == WM_UNICHAR)
4317 inev.code = msg.msg.wParam;
4319 else if (msg.msg.wParam < 256)
4321 wchar_t code;
4322 char dbcs[2];
4323 dbcs[0] = 0;
4324 dbcs[1] = (char) msg.msg.wParam;
4326 if (dbcs_lead)
4328 dbcs[0] = dbcs_lead;
4329 dbcs_lead = 0;
4330 if (!MultiByteToWideChar (w32_keyboard_codepage, 0,
4331 dbcs, 2, &code, 1))
4333 /* Garbage */
4334 DebPrint (("Invalid DBCS sequence: %d %d\n",
4335 dbcs[0], dbcs[1]));
4336 inev.kind = NO_EVENT;
4337 break;
4340 else if (IsDBCSLeadByteEx (w32_keyboard_codepage,
4341 (BYTE) msg.msg.wParam))
4343 dbcs_lead = (char) msg.msg.wParam;
4344 inev.kind = NO_EVENT;
4345 break;
4347 else
4349 if (!MultiByteToWideChar (w32_keyboard_codepage, 0,
4350 &dbcs[1], 1, &code, 1))
4352 /* What to do with garbage? */
4353 DebPrint (("Invalid character: %d\n", dbcs[1]));
4354 inev.kind = NO_EVENT;
4355 break;
4358 inev.code = code;
4360 else
4362 /* Windows shouldn't generate WM_CHAR events above 0xFF
4363 in non-Unicode message handlers. */
4364 DebPrint (("Non-byte WM_CHAR: %d\n", msg.msg.wParam));
4365 inev.kind = NO_EVENT;
4366 break;
4368 inev.kind = inev.code < 128 ? ASCII_KEYSTROKE_EVENT
4369 : MULTIBYTE_CHAR_KEYSTROKE_EVENT;
4371 break;
4373 case WM_APPCOMMAND:
4374 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4376 if (f && !FRAME_ICONIFIED_P (f))
4378 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4379 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4381 clear_mouse_face (hlinfo);
4382 hlinfo->mouse_face_hidden = 1;
4385 if (temp_index == sizeof temp_buffer / sizeof (short))
4386 temp_index = 0;
4387 temp_buffer[temp_index++] = msg.msg.wParam;
4388 inev.kind = MULTIMEDIA_KEY_EVENT;
4389 inev.code = GET_APPCOMMAND_LPARAM (msg.msg.lParam);
4390 inev.modifiers = msg.dwModifiers;
4391 XSETFRAME (inev.frame_or_window, f);
4392 inev.timestamp = msg.msg.time;
4394 break;
4396 case WM_MOUSEMOVE:
4397 /* Ignore non-movement. */
4399 int x = LOWORD (msg.msg.lParam);
4400 int y = HIWORD (msg.msg.lParam);
4401 if (x == last_mousemove_x && y == last_mousemove_y)
4402 break;
4403 last_mousemove_x = x;
4404 last_mousemove_y = y;
4407 previous_help_echo_string = help_echo_string;
4408 help_echo_string = Qnil;
4410 f = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
4411 : x_window_to_frame (dpyinfo, msg.msg.hwnd));
4413 if (hlinfo->mouse_face_hidden)
4415 hlinfo->mouse_face_hidden = 0;
4416 clear_mouse_face (hlinfo);
4419 if (f)
4421 /* Generate SELECT_WINDOW_EVENTs when needed. */
4422 if (!NILP (Vmouse_autoselect_window))
4424 static Lisp_Object last_mouse_window;
4425 Lisp_Object window = window_from_coordinates
4426 (f, LOWORD (msg.msg.lParam), HIWORD (msg.msg.lParam), 0, 0);
4428 /* Window will be selected only when it is not
4429 selected now and last mouse movement event was
4430 not in it. Minibuffer window will be selected
4431 only when it is active. */
4432 if (WINDOWP (window)
4433 && !EQ (window, last_mouse_window)
4434 && !EQ (window, selected_window)
4435 /* For click-to-focus window managers
4436 create event iff we don't leave the
4437 selected frame. */
4438 && (focus_follows_mouse
4439 || (EQ (XWINDOW (window)->frame,
4440 XWINDOW (selected_window)->frame))))
4442 inev.kind = SELECT_WINDOW_EVENT;
4443 inev.frame_or_window = window;
4445 /* Remember the last window where we saw the mouse. */
4446 last_mouse_window = window;
4448 if (!note_mouse_movement (f, &msg.msg))
4449 help_echo_string = previous_help_echo_string;
4451 else
4453 /* If we move outside the frame, then we're
4454 certainly no longer on any text in the frame. */
4455 clear_mouse_face (hlinfo);
4458 /* If the contents of the global variable help_echo_string
4459 has changed, generate a HELP_EVENT. */
4460 #if 0 /* The below is an invalid comparison when CHECK_LISP_OBJECT_TYPE.
4461 But it was originally changed to this to fix a bug, so I have
4462 not removed it completely in case the bug is still there. */
4463 if (help_echo_string != previous_help_echo_string ||
4464 (!NILP (help_echo_string) && !STRINGP (help_echo_string) && f->mouse_moved))
4465 #else /* This is what xterm.c does. */
4466 if (!NILP (help_echo_string)
4467 || !NILP (previous_help_echo_string))
4468 do_help = 1;
4469 #endif
4470 break;
4472 case WM_LBUTTONDOWN:
4473 case WM_LBUTTONUP:
4474 case WM_MBUTTONDOWN:
4475 case WM_MBUTTONUP:
4476 case WM_RBUTTONDOWN:
4477 case WM_RBUTTONUP:
4478 case WM_XBUTTONDOWN:
4479 case WM_XBUTTONUP:
4481 /* If we decide we want to generate an event to be seen
4482 by the rest of Emacs, we put it here. */
4483 bool tool_bar_p = 0;
4484 int button;
4485 int up;
4487 f = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
4488 : x_window_to_frame (dpyinfo, msg.msg.hwnd));
4490 if (f)
4492 construct_mouse_click (&inev, &msg, f);
4494 /* Is this in the tool-bar? */
4495 if (WINDOWP (f->tool_bar_window)
4496 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)))
4498 Lisp_Object window;
4499 int x = XFASTINT (inev.x);
4500 int y = XFASTINT (inev.y);
4502 window = window_from_coordinates (f, x, y, 0, 1);
4504 if (EQ (window, f->tool_bar_window))
4506 w32_handle_tool_bar_click (f, &inev);
4507 tool_bar_p = 1;
4511 if (tool_bar_p
4512 || (dpyinfo->w32_focus_frame
4513 && f != dpyinfo->w32_focus_frame))
4514 inev.kind = NO_EVENT;
4517 parse_button (msg.msg.message, HIWORD (msg.msg.wParam),
4518 &button, &up);
4520 if (up)
4522 dpyinfo->grabbed &= ~ (1 << button);
4524 else
4526 dpyinfo->grabbed |= (1 << button);
4527 dpyinfo->last_mouse_frame = f;
4528 /* Ignore any mouse motion that happened
4529 before this event; any subsequent mouse-movement
4530 Emacs events should reflect only motion after
4531 the ButtonPress. */
4532 if (f != 0)
4533 f->mouse_moved = 0;
4535 if (!tool_bar_p)
4536 last_tool_bar_item = -1;
4538 break;
4541 case WM_MOUSEWHEEL:
4542 case WM_MOUSEHWHEEL:
4544 f = (x_mouse_grabbed (dpyinfo) ? dpyinfo->last_mouse_frame
4545 : x_window_to_frame (dpyinfo, msg.msg.hwnd));
4547 if (f)
4550 if (!dpyinfo->w32_focus_frame
4551 || f == dpyinfo->w32_focus_frame)
4553 /* Emit an Emacs wheel-up/down event. */
4554 construct_mouse_wheel (&inev, &msg, f);
4556 /* Ignore any mouse motion that happened before this
4557 event; any subsequent mouse-movement Emacs events
4558 should reflect only motion after the
4559 ButtonPress. */
4560 f->mouse_moved = 0;
4562 dpyinfo->last_mouse_frame = f;
4563 last_tool_bar_item = -1;
4565 break;
4567 case WM_DROPFILES:
4568 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4570 if (f)
4571 construct_drag_n_drop (&inev, &msg, f);
4572 break;
4574 case WM_VSCROLL:
4576 struct scroll_bar *bar =
4577 x_window_to_scroll_bar ((HWND)msg.msg.lParam);
4579 if (bar)
4580 w32_scroll_bar_handle_click (bar, &msg, &inev);
4581 break;
4584 case WM_WINDOWPOSCHANGED:
4585 case WM_ACTIVATE:
4586 case WM_ACTIVATEAPP:
4587 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4588 if (f)
4590 /* Run the full-screen hook function also when we are
4591 being activated, to actually install the required
4592 size in effect, if the WAIT flag is set. This is
4593 because when the hook is run from x_set_fullscreen,
4594 the frame might not yet be visible, if that call is a
4595 result of make-frame, and in that case the hook just
4596 sets the WAIT flag. */
4597 if ((msg.msg.message == WM_WINDOWPOSCHANGED || msg.msg.wParam)
4598 && (f->want_fullscreen & FULLSCREEN_WAIT))
4599 w32fullscreen_hook (f);
4600 x_check_fullscreen (f);
4602 check_visibility = 1;
4603 break;
4605 case WM_MOVE:
4606 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4608 if (f && !FRAME_ICONIFIED_P (f))
4609 x_real_positions (f, &f->left_pos, &f->top_pos);
4611 check_visibility = 1;
4612 break;
4614 case WM_SHOWWINDOW:
4615 /* wParam non-zero means Window is about to be shown, 0 means
4616 about to be hidden. */
4617 /* Redo the mouse-highlight after the tooltip has gone. */
4618 if (!msg.msg.wParam && msg.msg.hwnd == tip_window)
4620 tip_window = NULL;
4621 x_redo_mouse_highlight (dpyinfo);
4624 /* If window has been obscured or exposed by another window
4625 being maximized or minimized/restored, then recheck
4626 visibility of all frames. Direct changes to our own
4627 windows get handled by WM_SIZE. */
4628 #if 0
4629 if (msg.msg.lParam != 0)
4630 check_visibility = 1;
4631 else
4633 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4634 f->async_visible = msg.msg.wParam;
4636 #endif
4638 check_visibility = 1;
4639 break;
4641 case WM_SIZE:
4642 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4644 /* Inform lisp of whether frame has been iconified etc. */
4645 if (f)
4647 switch (msg.msg.wParam)
4649 case SIZE_MINIMIZED:
4650 SET_FRAME_VISIBLE (f, 0);
4651 SET_FRAME_ICONIFIED (f, 1);
4653 inev.kind = ICONIFY_EVENT;
4654 XSETFRAME (inev.frame_or_window, f);
4655 break;
4657 case SIZE_MAXIMIZED:
4659 bool iconified = FRAME_ICONIFIED_P (f);
4661 SET_FRAME_VISIBLE (f, 1);
4662 SET_FRAME_ICONIFIED (f, 0);
4664 /* wait_reading_process_output will notice this
4665 and update the frame's display structures. */
4666 SET_FRAME_GARBAGED (f);
4668 if (iconified)
4670 int x, y;
4672 /* Reset top and left positions of the Window
4673 here since Windows sends a WM_MOVE message
4674 BEFORE telling us the Window is minimized
4675 when the Window is iconified, with 3000,3000
4676 as the co-ords. */
4677 x_real_positions (f, &x, &y);
4678 f->left_pos = x;
4679 f->top_pos = y;
4681 inev.kind = DEICONIFY_EVENT;
4682 XSETFRAME (inev.frame_or_window, f);
4684 else if (! NILP (Vframe_list)
4685 && ! NILP (XCDR (Vframe_list)))
4686 /* Force a redisplay sooner or later
4687 to update the frame titles
4688 in case this is the second frame. */
4689 record_asynch_buffer_change ();
4692 if (EQ (get_frame_param (f, Qfullscreen), Qnil))
4693 set_frame_param (f, Qfullscreen, Qmaximized);
4694 else if (! EQ (get_frame_param (f, Qfullscreen), Qmaximized))
4695 set_frame_param (f, Qmaximized, Qmaximized);
4697 break;
4699 case SIZE_RESTORED:
4701 bool iconified = FRAME_ICONIFIED_P (f);
4703 /* The following was made unconditional in a
4704 pathetic attempt to fix bug#16967 in revision
4705 116716 but, considered counterproductive was made
4706 conditional again in revision 116727. martin */
4707 if (iconified)
4708 SET_FRAME_VISIBLE (f, 1);
4709 SET_FRAME_ICONIFIED (f, 0);
4711 /* wait_reading_process_output will notice this
4712 and update the frame's display structures. */
4713 SET_FRAME_GARBAGED (f);
4715 if (iconified)
4717 /* Reset top and left positions of the Window
4718 here since Windows sends a WM_MOVE message
4719 BEFORE telling us the Window is minimized
4720 when the Window is iconified, with 3000,3000
4721 as the co-ords. */
4722 x_real_positions (f, &f->left_pos, &f->top_pos);
4724 inev.kind = DEICONIFY_EVENT;
4725 XSETFRAME (inev.frame_or_window, f);
4727 else if (! NILP (Vframe_list)
4728 && ! NILP (XCDR (Vframe_list)))
4729 /* Force a redisplay sooner or later
4730 to update the frame titles
4731 in case this is the second frame. */
4732 record_asynch_buffer_change ();
4735 if (EQ (get_frame_param (f, Qfullscreen), Qmaximized))
4736 set_frame_param (f, Qfullscreen, Qnil);
4737 else if (! EQ (get_frame_param (f, Qmaximized), Qnil))
4738 set_frame_param (f, Qmaximized, Qnil);
4740 break;
4744 if (f && !FRAME_ICONIFIED_P (f) && msg.msg.wParam != SIZE_MINIMIZED)
4746 RECT rect;
4747 int rows, columns, width, height, text_width, text_height;
4749 GetClientRect (msg.msg.hwnd, &rect);
4751 height = rect.bottom - rect.top;
4752 width = rect.right - rect.left;
4753 text_width = FRAME_PIXEL_TO_TEXT_WIDTH (f, width);
4754 text_height = FRAME_PIXEL_TO_TEXT_HEIGHT (f, height);
4755 rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height);
4756 columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width);
4758 /* TODO: Clip size to the screen dimensions. */
4760 /* Even if the number of character rows and columns has
4761 not changed, the font size may have changed, so we need
4762 to check the pixel dimensions as well. */
4764 if (width != FRAME_PIXEL_WIDTH (f)
4765 || height != FRAME_PIXEL_HEIGHT (f)
4766 || text_width != FRAME_TEXT_WIDTH (f)
4767 || text_height != FRAME_TEXT_HEIGHT (f))
4769 change_frame_size (f, text_width, text_height, 0, 1, 0, 1);
4770 SET_FRAME_GARBAGED (f);
4771 cancel_mouse_face (f);
4772 /* Do we want to set these here ???? */
4773 /** FRAME_PIXEL_WIDTH (f) = width; **/
4774 /** FRAME_TEXT_WIDTH (f) = text_width; **/
4775 /** FRAME_PIXEL_HEIGHT (f) = height; **/
4776 f->win_gravity = NorthWestGravity;
4780 check_visibility = 1;
4781 break;
4783 case WM_MOUSELEAVE:
4784 f = x_any_window_to_frame (dpyinfo, msg.msg.hwnd);
4785 if (f)
4787 if (f == hlinfo->mouse_face_mouse_frame)
4789 /* If we move outside the frame, then we're
4790 certainly no longer on any text in the frame. */
4791 clear_mouse_face (hlinfo);
4792 hlinfo->mouse_face_mouse_frame = 0;
4795 /* Generate a nil HELP_EVENT to cancel a help-echo.
4796 Do it only if there's something to cancel.
4797 Otherwise, the startup message is cleared when
4798 the mouse leaves the frame. */
4799 if (any_help_event_p)
4800 do_help = -1;
4802 break;
4804 case WM_SETFOCUS:
4805 w32_detect_focus_change (dpyinfo, &msg, &inev);
4807 dpyinfo->grabbed = 0;
4808 check_visibility = 1;
4809 break;
4811 case WM_KILLFOCUS:
4812 w32_detect_focus_change (dpyinfo, &msg, &inev);
4813 f = x_top_window_to_frame (dpyinfo, msg.msg.hwnd);
4815 if (f)
4817 if (f == hlinfo->mouse_face_mouse_frame)
4819 /* If we move outside the frame, then we're
4820 certainly no longer on any text in the frame. */
4821 clear_mouse_face (hlinfo);
4822 hlinfo->mouse_face_mouse_frame = 0;
4825 /* Generate a nil HELP_EVENT to cancel a help-echo.
4826 Do it only if there's something to cancel.
4827 Otherwise, the startup message is cleared when
4828 the mouse leaves the frame. */
4829 if (any_help_event_p)
4830 do_help = -1;
4833 dpyinfo->grabbed = 0;
4834 check_visibility = 1;
4835 break;
4837 case WM_CLOSE:
4838 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4840 if (f)
4842 inev.kind = DELETE_WINDOW_EVENT;
4843 XSETFRAME (inev.frame_or_window, f);
4845 break;
4847 case WM_INITMENU:
4848 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4850 if (f)
4852 inev.kind = MENU_BAR_ACTIVATE_EVENT;
4853 XSETFRAME (inev.frame_or_window, f);
4855 break;
4857 case WM_COMMAND:
4858 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4860 if (f)
4862 extern void menubar_selection_callback
4863 (struct frame *f, void * client_data);
4864 menubar_selection_callback (f, (void *)msg.msg.wParam);
4867 check_visibility = 1;
4868 break;
4870 case WM_DISPLAYCHANGE:
4871 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4873 if (f)
4875 dpyinfo->n_cbits = msg.msg.wParam;
4876 /* The new display could have a different resolution, in
4877 which case we must reconsider what fullscreen
4878 means. */
4879 x_check_fullscreen (f);
4880 DebPrint (("display change: %d %d\n",
4881 (short) LOWORD (msg.msg.lParam),
4882 (short) HIWORD (msg.msg.lParam)));
4885 check_visibility = 1;
4886 break;
4888 #if HAVE_W32NOTIFY
4889 case WM_EMACS_FILENOTIFY:
4890 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4891 if (f)
4892 queue_notifications (&inev, &msg, f, &count);
4893 break;
4894 #endif
4896 default:
4897 /* Check for messages registered at runtime. */
4898 if (msg.msg.message == msh_mousewheel)
4900 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
4901 msg.msg.message = WM_MOUSEWHEEL;
4902 prepend_msg (&msg);
4904 break;
4907 if (inev.kind != NO_EVENT)
4909 kbd_buffer_store_event_hold (&inev, hold_quit);
4910 count++;
4913 if (do_help
4914 && !(hold_quit && hold_quit->kind != NO_EVENT))
4916 Lisp_Object frame;
4918 if (f)
4919 XSETFRAME (frame, f);
4920 else
4921 frame = Qnil;
4923 if (do_help > 0)
4925 if (NILP (help_echo_string))
4927 help_echo_object = help_echo_window = Qnil;
4928 help_echo_pos = -1;
4931 any_help_event_p = 1;
4932 gen_help_event (help_echo_string, frame, help_echo_window,
4933 help_echo_object, help_echo_pos);
4935 else
4937 help_echo_string = Qnil;
4938 gen_help_event (Qnil, frame, Qnil, Qnil, 0);
4940 count++;
4944 /* If the focus was just given to an autoraising frame,
4945 raise it now. FIXME: handle more than one such frame. */
4946 if (dpyinfo->w32_pending_autoraise_frame)
4948 x_raise_frame (dpyinfo->w32_pending_autoraise_frame);
4949 dpyinfo->w32_pending_autoraise_frame = NULL;
4952 /* Check which frames are still visible, if we have enqueued any user
4953 events or been notified of events that may affect visibility. We
4954 do this here because there doesn't seem to be any direct
4955 notification from Windows that the visibility of a window has
4956 changed (at least, not in all cases). */
4957 if (count > 0 || check_visibility)
4959 Lisp_Object tail, frame;
4961 FOR_EACH_FRAME (tail, frame)
4963 struct frame *f = XFRAME (frame);
4964 /* The tooltip has been drawn already. Avoid the
4965 SET_FRAME_GARBAGED below. */
4966 if (EQ (frame, tip_frame))
4967 continue;
4969 /* Check "visible" frames and mark each as obscured or not.
4970 Note that visible is nonzero for unobscured and obscured
4971 frames, but zero for hidden and iconified frames. */
4972 if (FRAME_W32_P (f) && FRAME_VISIBLE_P (f))
4974 RECT clipbox;
4975 HDC hdc;
4976 bool obscured;
4978 enter_crit ();
4979 /* Query clipping rectangle for the entire window area
4980 (GetWindowDC), not just the client portion (GetDC).
4981 Otherwise, the scrollbars and menubar aren't counted as
4982 part of the visible area of the frame, and we may think
4983 the frame is obscured when really a scrollbar is still
4984 visible and gets WM_PAINT messages above. */
4985 hdc = GetWindowDC (FRAME_W32_WINDOW (f));
4986 GetClipBox (hdc, &clipbox);
4987 ReleaseDC (FRAME_W32_WINDOW (f), hdc);
4988 leave_crit ();
4990 obscured = FRAME_OBSCURED_P (f);
4992 if (clipbox.right == clipbox.left || clipbox.bottom == clipbox.top)
4994 /* Frame has become completely obscured so mark as such (we
4995 do this by setting visible to 2 so that FRAME_VISIBLE_P
4996 is still true, but redisplay will skip it). */
4997 SET_FRAME_VISIBLE (f, 2);
4999 if (!obscured)
5000 DebPrint (("frame %p (%s) obscured\n", f, SDATA (f->name)));
5002 else
5004 /* Frame is not obscured, so mark it as such. */
5005 SET_FRAME_VISIBLE (f, 1);
5007 if (obscured)
5009 SET_FRAME_GARBAGED (f);
5010 DebPrint (("obscured frame %p (%s) found to be visible\n",
5011 f, SDATA (f->name)));
5013 /* Force a redisplay sooner or later. */
5014 record_asynch_buffer_change ();
5021 unblock_input ();
5022 return count;
5027 /***********************************************************************
5028 Text Cursor
5029 ***********************************************************************/
5031 /* Set clipping for output in glyph row ROW. W is the window in which
5032 we operate. GC is the graphics context to set clipping in.
5034 ROW may be a text row or, e.g., a mode line. Text rows must be
5035 clipped to the interior of the window dedicated to text display,
5036 mode lines must be clipped to the whole window. */
5038 static void
5039 w32_clip_to_row (struct window *w, struct glyph_row *row,
5040 enum glyph_row_area area, HDC hdc)
5042 RECT clip_rect;
5043 int window_x, window_y, window_width;
5045 window_box (w, area, &window_x, &window_y, &window_width, 0);
5047 clip_rect.left = window_x;
5048 clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
5049 clip_rect.top = max (clip_rect.top, window_y);
5050 clip_rect.right = clip_rect.left + window_width;
5051 clip_rect.bottom = clip_rect.top + row->visible_height;
5053 w32_set_clip_rectangle (hdc, &clip_rect);
5057 /* Draw a hollow box cursor on window W in glyph row ROW. */
5059 static void
5060 x_draw_hollow_cursor (struct window *w, struct glyph_row *row)
5062 struct frame *f = XFRAME (WINDOW_FRAME (w));
5063 HDC hdc;
5064 RECT rect;
5065 int left, top, h;
5066 struct glyph *cursor_glyph;
5067 HBRUSH hb = CreateSolidBrush (f->output_data.w32->cursor_pixel);
5069 /* Get the glyph the cursor is on. If we can't tell because
5070 the current matrix is invalid or such, give up. */
5071 cursor_glyph = get_phys_cursor_glyph (w);
5072 if (cursor_glyph == NULL)
5074 DeleteObject (hb);
5075 return;
5078 /* Compute frame-relative coordinates for phys cursor. */
5079 get_phys_cursor_geometry (w, row, cursor_glyph, &left, &top, &h);
5080 rect.left = left;
5081 rect.top = top;
5082 rect.bottom = rect.top + h;
5083 rect.right = rect.left + w->phys_cursor_width;
5085 hdc = get_frame_dc (f);
5086 /* Set clipping, draw the rectangle, and reset clipping again. */
5087 w32_clip_to_row (w, row, TEXT_AREA, hdc);
5088 FrameRect (hdc, &rect, hb);
5089 DeleteObject (hb);
5090 w32_set_clip_rectangle (hdc, NULL);
5091 release_frame_dc (f, hdc);
5095 /* Draw a bar cursor on window W in glyph row ROW.
5097 Implementation note: One would like to draw a bar cursor with an
5098 angle equal to the one given by the font property XA_ITALIC_ANGLE.
5099 Unfortunately, I didn't find a font yet that has this property set.
5100 --gerd. */
5102 static void
5103 x_draw_bar_cursor (struct window *w, struct glyph_row *row,
5104 int width, enum text_cursor_kinds kind)
5106 struct frame *f = XFRAME (w->frame);
5107 struct glyph *cursor_glyph;
5109 /* If cursor is out of bounds, don't draw garbage. This can happen
5110 in mini-buffer windows when switching between echo area glyphs
5111 and mini-buffer. */
5112 cursor_glyph = get_phys_cursor_glyph (w);
5113 if (cursor_glyph == NULL)
5114 return;
5116 /* If on an image, draw like a normal cursor. That's usually better
5117 visible than drawing a bar, esp. if the image is large so that
5118 the bar might not be in the window. */
5119 if (cursor_glyph->type == IMAGE_GLYPH)
5121 struct glyph_row *row;
5122 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
5123 draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
5125 else
5127 COLORREF cursor_color = f->output_data.w32->cursor_pixel;
5128 struct face *face = FACE_FROM_ID (f, cursor_glyph->face_id);
5129 int x;
5130 HDC hdc;
5132 /* If the glyph's background equals the color we normally draw
5133 the bar cursor in, the bar cursor in its normal color is
5134 invisible. Use the glyph's foreground color instead in this
5135 case, on the assumption that the glyph's colors are chosen so
5136 that the glyph is legible. */
5137 if (face->background == cursor_color)
5138 cursor_color = face->foreground;
5140 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
5142 hdc = get_frame_dc (f);
5143 w32_clip_to_row (w, row, TEXT_AREA, hdc);
5145 if (kind == BAR_CURSOR)
5147 if (width < 0)
5148 width = FRAME_CURSOR_WIDTH (f);
5149 width = min (cursor_glyph->pixel_width, width);
5151 w->phys_cursor_width = width;
5153 /* If the character under cursor is R2L, draw the bar cursor
5154 on the right of its glyph, rather than on the left. */
5155 if ((cursor_glyph->resolved_level & 1) != 0)
5156 x += cursor_glyph->pixel_width - width;
5158 w32_fill_area (f, hdc, cursor_color, x,
5159 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
5160 width, row->height);
5162 else
5164 int dummy_x, dummy_y, dummy_h;
5166 if (width < 0)
5167 width = row->height;
5169 width = min (row->height, width);
5171 get_phys_cursor_geometry (w, row, cursor_glyph, &dummy_x,
5172 &dummy_y, &dummy_h);
5173 w32_fill_area (f, hdc, cursor_color, x,
5174 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
5175 row->height - width),
5176 w->phys_cursor_width, width);
5179 w32_set_clip_rectangle (hdc, NULL);
5180 release_frame_dc (f, hdc);
5185 /* RIF: Define cursor CURSOR on frame F. */
5187 static void
5188 w32_define_frame_cursor (struct frame *f, Cursor cursor)
5190 w32_define_cursor (FRAME_W32_WINDOW (f), cursor);
5194 /* RIF: Clear area on frame F. */
5196 static void
5197 w32_clear_frame_area (struct frame *f, int x, int y, int width, int height)
5199 HDC hdc;
5201 hdc = get_frame_dc (f);
5202 w32_clear_area (f, hdc, x, y, width, height);
5203 release_frame_dc (f, hdc);
5206 /* RIF: Draw or clear cursor on window W. */
5208 static void
5209 w32_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
5210 int x, int y, enum text_cursor_kinds cursor_type,
5211 int cursor_width, bool on_p, bool active_p)
5213 if (on_p)
5215 /* If the user wants to use the system caret, make sure our own
5216 cursor remains invisible. */
5217 if (w32_use_visible_system_caret)
5219 /* Call to erase_phys_cursor here seems to use the
5220 wrong values of w->phys_cursor, as they have been
5221 overwritten before this function was called. */
5222 if (w->phys_cursor_type != NO_CURSOR)
5223 erase_phys_cursor (w);
5225 cursor_type = w->phys_cursor_type = NO_CURSOR;
5226 w->phys_cursor_width = -1;
5228 else
5230 w->phys_cursor_type = cursor_type;
5233 w->phys_cursor_on_p = 1;
5235 /* If this is the active cursor, we need to track it with the
5236 system caret, so third party software like screen magnifiers
5237 and speech synthesizers can follow the cursor. */
5238 if (active_p)
5240 struct frame *f = XFRAME (WINDOW_FRAME (w));
5241 HWND hwnd = FRAME_W32_WINDOW (f);
5243 w32_system_caret_x
5244 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
5245 w32_system_caret_y
5246 = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y)
5247 + glyph_row->ascent - w->phys_cursor_ascent);
5248 w32_system_caret_window = w;
5249 w32_system_caret_hdr_height = WINDOW_HEADER_LINE_HEIGHT (w);
5250 w32_system_caret_mode_height = WINDOW_MODE_LINE_HEIGHT (w);
5252 PostMessage (hwnd, WM_IME_STARTCOMPOSITION, 0, 0);
5254 /* If the size of the active cursor changed, destroy the old
5255 system caret. */
5256 if (w32_system_caret_hwnd
5257 && (w32_system_caret_height != w->phys_cursor_height))
5258 PostMessage (hwnd, WM_EMACS_DESTROY_CARET, 0, 0);
5260 w32_system_caret_height = w->phys_cursor_height;
5262 /* Move the system caret. */
5263 PostMessage (hwnd, WM_EMACS_TRACK_CARET, 0, 0);
5266 if (glyph_row->exact_window_width_line_p
5267 && (glyph_row->reversed_p
5268 ? (w->phys_cursor.hpos < 0)
5269 : (w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])))
5271 glyph_row->cursor_in_fringe_p = 1;
5272 draw_fringe_bitmap (w, glyph_row, glyph_row->reversed_p);
5273 return;
5276 switch (cursor_type)
5278 case HOLLOW_BOX_CURSOR:
5279 x_draw_hollow_cursor (w, glyph_row);
5280 break;
5282 case FILLED_BOX_CURSOR:
5283 draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
5284 break;
5286 case BAR_CURSOR:
5287 x_draw_bar_cursor (w, glyph_row, cursor_width, BAR_CURSOR);
5288 break;
5290 case HBAR_CURSOR:
5291 x_draw_bar_cursor (w, glyph_row, cursor_width, HBAR_CURSOR);
5292 break;
5294 case NO_CURSOR:
5295 w->phys_cursor_width = 0;
5296 break;
5298 default:
5299 emacs_abort ();
5306 /* Icons. */
5309 x_bitmap_icon (struct frame *f, Lisp_Object icon)
5311 HANDLE main_icon;
5312 HANDLE small_icon = NULL;
5314 if (FRAME_W32_WINDOW (f) == 0)
5315 return 1;
5317 if (NILP (icon))
5318 main_icon = LoadIcon (hinst, EMACS_CLASS);
5319 else if (STRINGP (icon))
5321 /* Load the main icon from the named file. */
5322 main_icon = LoadImage (NULL, (LPCTSTR) SDATA (icon), IMAGE_ICON, 0, 0,
5323 LR_DEFAULTSIZE | LR_LOADFROMFILE);
5324 /* Try to load a small icon to go with it. */
5325 small_icon = LoadImage (NULL, (LPCSTR) SDATA (icon), IMAGE_ICON,
5326 GetSystemMetrics (SM_CXSMICON),
5327 GetSystemMetrics (SM_CYSMICON),
5328 LR_LOADFROMFILE);
5330 else if (SYMBOLP (icon))
5332 LPCTSTR name;
5334 if (EQ (icon, intern ("application")))
5335 name = (LPCTSTR) IDI_APPLICATION;
5336 else if (EQ (icon, intern ("hand")))
5337 name = (LPCTSTR) IDI_HAND;
5338 else if (EQ (icon, intern ("question")))
5339 name = (LPCTSTR) IDI_QUESTION;
5340 else if (EQ (icon, intern ("exclamation")))
5341 name = (LPCTSTR) IDI_EXCLAMATION;
5342 else if (EQ (icon, intern ("asterisk")))
5343 name = (LPCTSTR) IDI_ASTERISK;
5344 else if (EQ (icon, intern ("winlogo")))
5345 name = (LPCTSTR) IDI_WINLOGO;
5346 else
5347 return 1;
5349 main_icon = LoadIcon (NULL, name);
5351 else
5352 return 1;
5354 if (main_icon == NULL)
5355 return 1;
5357 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_BIG,
5358 (LPARAM) main_icon);
5360 /* If there is a small icon that goes with it, set that too. */
5361 if (small_icon)
5362 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_SMALL,
5363 (LPARAM) small_icon);
5365 return 0;
5369 /************************************************************************
5370 Handling X errors
5371 ************************************************************************/
5373 /* Display Error Handling functions not used on W32. Listing them here
5374 helps diff stay in step when comparing w32term.c with xterm.c.
5376 x_error_catcher (display, error)
5377 x_catch_errors (dpy)
5378 x_catch_errors_unwind (old_val)
5379 x_check_errors (dpy, format)
5380 x_fully_uncatch_errors ()
5381 x_had_errors_p (dpy)
5382 x_clear_errors (dpy)
5383 x_uncatch_errors (dpy, count)
5384 x_trace_wire ()
5385 x_connection_signal (signalnum)
5386 x_connection_closed (dpy, error_message)
5387 x_error_quitter (display, error)
5388 x_error_handler (display, error)
5389 x_io_error_quitter (display)
5394 /* Changing the font of the frame. */
5396 Lisp_Object
5397 x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
5399 struct font *font = XFONT_OBJECT (font_object);
5400 int unit;
5402 if (fontset < 0)
5403 fontset = fontset_from_font (font_object);
5404 FRAME_FONTSET (f) = fontset;
5405 if (FRAME_FONT (f) == font)
5406 /* This font is already set in frame F. There's nothing more to
5407 do. */
5408 return font_object;
5410 FRAME_FONT (f) = font;
5411 FRAME_BASELINE_OFFSET (f) = font->baseline_offset;
5412 FRAME_COLUMN_WIDTH (f) = unit = font->average_width;
5413 FRAME_LINE_HEIGHT (f) = font->height;
5415 compute_fringe_widths (f, 1);
5417 /* Compute number of scrollbar columns. */
5418 unit = FRAME_COLUMN_WIDTH (f);
5419 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
5420 FRAME_CONFIG_SCROLL_BAR_COLS (f)
5421 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + unit - 1) / unit;
5422 else
5424 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + unit - 1) / unit;
5425 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) =
5426 FRAME_CONFIG_SCROLL_BAR_COLS (f) * unit;
5429 /* Now make the frame display the given font. */
5430 if (FRAME_X_WINDOW (f) != 0)
5432 /* Don't change the size of a tip frame; there's no point in
5433 doing it because it's done in Fx_show_tip, and it leads to
5434 problems because the tip frame has no widget. */
5435 if (NILP (tip_frame) || XFRAME (tip_frame) != f)
5436 x_set_window_size (f, 0, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
5437 FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 1);
5440 /* X version sets font of input methods here also. */
5442 return font_object;
5446 /***********************************************************************
5447 TODO: W32 Input Methods
5448 ***********************************************************************/
5449 /* Listing missing functions from xterm.c helps diff stay in step.
5451 xim_destroy_callback (xim, client_data, call_data)
5452 xim_open_dpy (dpyinfo, resource_name)
5453 struct xim_inst_t
5454 xim_instantiate_callback (display, client_data, call_data)
5455 xim_initialize (dpyinfo, resource_name)
5456 xim_close_dpy (dpyinfo)
5461 /* Calculate the absolute position in frame F
5462 from its current recorded position values and gravity. */
5464 void
5465 x_calc_absolute_position (struct frame *f)
5467 int flags = f->size_hint_flags;
5469 /* The sum of the widths of the frame's left and right borders, and
5470 the sum of the heights of the frame's top and bottom borders (in
5471 pixels) drawn by Windows. */
5472 unsigned int left_right_borders_width, top_bottom_borders_height;
5474 /* Try to get the actual values of these two variables. We compute
5475 the border width (height) by subtracting the width (height) of
5476 the frame's client area from the width (height) of the frame's
5477 entire window. */
5478 WINDOWPLACEMENT wp = { 0 };
5479 RECT client_rect = { 0 };
5481 if (GetWindowPlacement (FRAME_W32_WINDOW (f), &wp)
5482 && GetClientRect (FRAME_W32_WINDOW (f), &client_rect))
5484 left_right_borders_width =
5485 (wp.rcNormalPosition.right - wp.rcNormalPosition.left) -
5486 (client_rect.right - client_rect.left);
5488 top_bottom_borders_height =
5489 (wp.rcNormalPosition.bottom - wp.rcNormalPosition.top) -
5490 (client_rect.bottom - client_rect.top);
5492 else
5494 /* Use sensible default values. */
5495 left_right_borders_width = 8;
5496 top_bottom_borders_height = 32;
5499 /* Treat negative positions as relative to the rightmost bottommost
5500 position that fits on the screen. */
5501 if (flags & XNegative)
5502 f->left_pos = (x_display_pixel_width (FRAME_DISPLAY_INFO (f))
5503 - FRAME_PIXEL_WIDTH (f)
5504 + f->left_pos
5505 - (left_right_borders_width - 1));
5507 if (flags & YNegative)
5508 f->top_pos = (x_display_pixel_height (FRAME_DISPLAY_INFO (f))
5509 - FRAME_PIXEL_HEIGHT (f)
5510 + f->top_pos
5511 - (top_bottom_borders_height - 1));
5513 /* The left_pos and top_pos are now relative to the top and left
5514 screen edges, so the flags should correspond. */
5515 f->size_hint_flags &= ~ (XNegative | YNegative);
5518 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5519 to really change the position, and 0 when calling from
5520 x_make_frame_visible (in that case, XOFF and YOFF are the current
5521 position values). It is -1 when calling from x_set_frame_parameters,
5522 which means, do adjust for borders but don't change the gravity. */
5524 void
5525 x_set_offset (struct frame *f, register int xoff, register int yoff,
5526 int change_gravity)
5528 int modified_top, modified_left;
5530 if (change_gravity > 0)
5532 f->top_pos = yoff;
5533 f->left_pos = xoff;
5534 f->size_hint_flags &= ~ (XNegative | YNegative);
5535 if (xoff < 0)
5536 f->size_hint_flags |= XNegative;
5537 if (yoff < 0)
5538 f->size_hint_flags |= YNegative;
5539 f->win_gravity = NorthWestGravity;
5541 x_calc_absolute_position (f);
5543 block_input ();
5544 x_wm_set_size_hint (f, (long) 0, 0);
5546 modified_left = f->left_pos;
5547 modified_top = f->top_pos;
5549 my_set_window_pos (FRAME_W32_WINDOW (f),
5550 NULL,
5551 modified_left, modified_top,
5552 0, 0,
5553 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
5554 unblock_input ();
5558 /* Check if we need to resize the frame due to a fullscreen request.
5559 If so needed, resize the frame. */
5560 static void
5561 x_check_fullscreen (struct frame *f)
5563 if (f->want_fullscreen & FULLSCREEN_BOTH)
5565 int width, height, ign;
5567 x_real_positions (f, &f->left_pos, &f->top_pos);
5569 x_fullscreen_adjust (f, &width, &height, &ign, &ign);
5571 /* We do not need to move the window, it shall be taken care of
5572 when setting WM manager hints. */
5573 if (FRAME_COLS (f) != width || FRAME_LINES (f) != height)
5575 change_frame_size (f, width, height, 0, 1, 0, 0);
5576 SET_FRAME_GARBAGED (f);
5577 cancel_mouse_face (f);
5579 /* Wait for the change of frame size to occur. */
5580 f->want_fullscreen |= FULLSCREEN_WAIT;
5585 static void
5586 w32fullscreen_hook (struct frame *f)
5588 if (FRAME_VISIBLE_P (f))
5590 HWND hwnd = FRAME_W32_WINDOW(f);
5591 DWORD dwStyle = GetWindowLong (hwnd, GWL_STYLE);
5592 RECT rect;
5594 block_input();
5595 f->want_fullscreen &= ~FULLSCREEN_WAIT;
5597 if (FRAME_PREV_FSMODE (f) == FULLSCREEN_NONE)
5598 GetWindowPlacement (hwnd, &FRAME_NORMAL_PLACEMENT (f));
5600 if (FRAME_PREV_FSMODE (f) == FULLSCREEN_BOTH)
5602 SetWindowLong (hwnd, GWL_STYLE, dwStyle | WS_OVERLAPPEDWINDOW);
5603 SetWindowPlacement (hwnd, &FRAME_NORMAL_PLACEMENT (f));
5605 else if (FRAME_PREV_FSMODE (f) == FULLSCREEN_HEIGHT
5606 || FRAME_PREV_FSMODE (f) == FULLSCREEN_WIDTH)
5607 SetWindowPlacement (hwnd, &FRAME_NORMAL_PLACEMENT (f));
5609 FRAME_PREV_FSMODE (f) = f->want_fullscreen;
5611 if (f->want_fullscreen == FULLSCREEN_NONE)
5612 ShowWindow (hwnd, SW_SHOWNORMAL);
5613 else if (f->want_fullscreen == FULLSCREEN_MAXIMIZED)
5614 ShowWindow (hwnd, SW_MAXIMIZE);
5615 else if (f->want_fullscreen == FULLSCREEN_BOTH)
5617 w32_fullscreen_rect (hwnd, f->want_fullscreen,
5618 FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
5619 SetWindowLong (hwnd, GWL_STYLE, dwStyle & ~WS_OVERLAPPEDWINDOW);
5620 SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
5621 rect.right - rect.left, rect.bottom - rect.top,
5622 SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
5624 else
5626 ShowWindow (hwnd, SW_SHOWNORMAL);
5627 w32_fullscreen_rect (hwnd, f->want_fullscreen,
5628 FRAME_NORMAL_PLACEMENT (f).rcNormalPosition, &rect);
5629 SetWindowPos (hwnd, HWND_TOP, rect.left, rect.top,
5630 rect.right - rect.left, rect.bottom - rect.top, 0);
5633 f->want_fullscreen = FULLSCREEN_NONE;
5634 unblock_input ();
5636 else
5637 f->want_fullscreen |= FULLSCREEN_WAIT;
5640 /* Call this to change the size of frame F's x-window.
5641 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5642 for this size change and subsequent size changes.
5643 Otherwise we leave the window gravity unchanged. */
5645 void
5646 x_set_window_size (struct frame *f, int change_gravity, int width, int height, bool pixelwise)
5648 int pixelwidth, pixelheight;
5650 block_input ();
5652 check_frame_size (f, &width, &height, pixelwise);
5654 compute_fringe_widths (f, 0);
5656 if (frame_resize_pixelwise)
5658 if (pixelwise)
5660 pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width);
5661 pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height);
5663 else
5665 pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width);
5666 pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height);
5669 else
5671 /* If we don't resize frames pixelwise, round sizes to multiples
5672 of character sizes here. Otherwise, when enforcing size hints
5673 while processing WM_WINDOWPOSCHANGING in w32_wnd_proc, we might
5674 clip our frame rectangle to a multiple of the frame's character
5675 size and subsequently lose our mode line or scroll bar.
5676 Bug#16923 could be one possible consequence of this. Carefully
5677 reverse-engineer what WM_WINDOWPOSCHANGING does here since
5678 otherwise we might make our frame too small, see Bug#17077. */
5679 int unit_width = FRAME_COLUMN_WIDTH (f);
5680 int unit_height = FRAME_LINE_HEIGHT (f);
5682 pixelwidth = (((((pixelwise ? width : (width * FRAME_COLUMN_WIDTH (f)))
5683 + FRAME_TOTAL_FRINGE_WIDTH (f))
5684 / unit_width) * unit_width)
5685 + FRAME_SCROLL_BAR_AREA_WIDTH (f)
5686 + 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
5688 pixelheight = ((((pixelwise ? height : (height * FRAME_LINE_HEIGHT (f)))
5689 / unit_height) * unit_height)
5690 + 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
5693 f->win_gravity = NorthWestGravity;
5694 x_wm_set_size_hint (f, (long) 0, 0);
5697 RECT rect;
5699 rect.left = rect.top = 0;
5700 rect.right = pixelwidth;
5701 rect.bottom = pixelheight;
5703 AdjustWindowRect (&rect, f->output_data.w32->dwStyle,
5704 FRAME_EXTERNAL_MENU_BAR (f));
5706 my_set_window_pos (FRAME_W32_WINDOW (f),
5707 NULL,
5708 0, 0,
5709 rect.right - rect.left,
5710 rect.bottom - rect.top,
5711 SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
5714 /* If w32_enable_frame_resize_hack is non-nil, immediately apply the
5715 new pixel sizes to the frame and its subwindows.
5717 Jason Rumney earlier refused to call change_frame_size right here
5718 with the following argument:
5720 The following mirrors what is done in xterm.c. It appears to be for
5721 informing lisp of the new size immediately, while the actual resize
5722 will happen asynchronously. But on Windows, the menu bar
5723 automatically wraps when the frame is too narrow to contain it, and
5724 that causes any calculations made here to come out wrong. The end
5725 is some nasty buggy behavior, including the potential loss of the
5726 minibuffer.
5728 Disabling this code is either not sufficient to fix the problems
5729 completely, or it causes fresh problems, but at least it removes
5730 the most problematic symptom of the minibuffer becoming unusable.
5732 However, as the discussion about how to handle frame size
5733 parameters on Windows (Bug#1348, Bug#16028) shows, that cure seems
5734 worse than the disease. In particular, menu bar wrapping looks
5735 like a non-issue - maybe so because Windows eventually gets back to
5736 us with the correct client rectangle anyway. But we have to avoid
5737 calling change_frame_size with a delta of less than one canoncial
5738 character size when frame_resize_pixelwise is nil, as explained in
5739 the comment above. */
5741 if (w32_enable_frame_resize_hack)
5744 change_frame_size (f, FRAME_PIXEL_TO_TEXT_WIDTH (f, pixelwidth),
5745 FRAME_PIXEL_TO_TEXT_HEIGHT (f, pixelheight),
5746 0, 1, 0, 1);
5747 SET_FRAME_GARBAGED (f);
5749 /* If cursor was outside the new size, mark it as off. */
5750 mark_window_cursors_off (XWINDOW (f->root_window));
5752 /* Clear out any recollection of where the mouse highlighting was,
5753 since it might be in a place that's outside the new frame size.
5754 Actually checking whether it is outside is a pain in the neck,
5755 so don't try--just let the highlighting be done afresh with new
5756 size. */
5757 cancel_mouse_face (f);
5760 unblock_input ();
5763 /* Mouse warping. */
5765 void x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y);
5767 void
5768 x_set_mouse_position (struct frame *f, int x, int y)
5770 int pix_x, pix_y;
5772 pix_x = FRAME_COL_TO_PIXEL_X (f, x) + FRAME_COLUMN_WIDTH (f) / 2;
5773 pix_y = FRAME_LINE_TO_PIXEL_Y (f, y) + FRAME_LINE_HEIGHT (f) / 2;
5775 if (pix_x < 0) pix_x = 0;
5776 if (pix_x > FRAME_PIXEL_WIDTH (f)) pix_x = FRAME_PIXEL_WIDTH (f);
5778 if (pix_y < 0) pix_y = 0;
5779 if (pix_y > FRAME_PIXEL_HEIGHT (f)) pix_y = FRAME_PIXEL_HEIGHT (f);
5781 x_set_mouse_pixel_position (f, pix_x, pix_y);
5784 void
5785 x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y)
5787 RECT rect;
5788 POINT pt;
5790 block_input ();
5792 GetClientRect (FRAME_W32_WINDOW (f), &rect);
5793 pt.x = rect.left + pix_x;
5794 pt.y = rect.top + pix_y;
5795 ClientToScreen (FRAME_W32_WINDOW (f), &pt);
5797 SetCursorPos (pt.x, pt.y);
5799 unblock_input ();
5803 /* focus shifting, raising and lowering. */
5805 void
5806 x_focus_frame (struct frame *f)
5808 struct w32_display_info *dpyinfo = &one_w32_display_info;
5810 /* Give input focus to frame. */
5811 block_input ();
5812 #if 0
5813 /* Try not to change its Z-order if possible. */
5814 if (x_window_to_frame (dpyinfo, GetForegroundWindow ()))
5815 my_set_focus (f, FRAME_W32_WINDOW (f));
5816 else
5817 #endif
5818 my_set_foreground_window (FRAME_W32_WINDOW (f));
5819 unblock_input ();
5822 /* Raise frame F. */
5823 void
5824 x_raise_frame (struct frame *f)
5826 block_input ();
5828 /* Strictly speaking, raise-frame should only change the frame's Z
5829 order, leaving input focus unchanged. This is reasonable behavior
5830 on X where the usual policy is point-to-focus. However, this
5831 behavior would be very odd on Windows where the usual policy is
5832 click-to-focus.
5834 On X, if the mouse happens to be over the raised frame, it gets
5835 input focus anyway (so the window with focus will never be
5836 completely obscured) - if not, then just moving the mouse over it
5837 is sufficient to give it focus. On Windows, the user must actually
5838 click on the frame (preferably the title bar so as not to move
5839 point), which is more awkward. Also, no other Windows program
5840 raises a window to the top but leaves another window (possibly now
5841 completely obscured) with input focus.
5843 Because there is a system setting on Windows that allows the user
5844 to choose the point to focus policy, we make the strict semantics
5845 optional, but by default we grab focus when raising. */
5847 if (NILP (Vw32_grab_focus_on_raise))
5849 /* The obvious call to my_set_window_pos doesn't work if Emacs is
5850 not already the foreground application: the frame is raised
5851 above all other frames belonging to us, but not above the
5852 current top window. To achieve that, we have to resort to this
5853 more cumbersome method. */
5855 HDWP handle = BeginDeferWindowPos (2);
5856 if (handle)
5858 handle = DeferWindowPos (handle,
5859 FRAME_W32_WINDOW (f),
5860 HWND_TOP,
5861 0, 0, 0, 0,
5862 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
5863 if (handle)
5865 handle = DeferWindowPos (handle,
5866 GetForegroundWindow (),
5867 FRAME_W32_WINDOW (f),
5868 0, 0, 0, 0,
5869 SWP_NOSIZE | SWP_NOMOVE |
5870 SWP_NOACTIVATE);
5871 if (handle)
5872 EndDeferWindowPos (handle);
5876 else
5878 my_bring_window_to_top (FRAME_W32_WINDOW (f));
5881 unblock_input ();
5884 /* Lower frame F. */
5885 void
5886 x_lower_frame (struct frame *f)
5888 block_input ();
5889 my_set_window_pos (FRAME_W32_WINDOW (f),
5890 HWND_BOTTOM,
5891 0, 0, 0, 0,
5892 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
5893 unblock_input ();
5896 static void
5897 w32_frame_raise_lower (struct frame *f, int raise_flag)
5899 if (! FRAME_W32_P (f))
5900 return;
5902 if (raise_flag)
5903 x_raise_frame (f);
5904 else
5905 x_lower_frame (f);
5908 /* Change of visibility. */
5910 /* This tries to wait until the frame is really visible.
5911 However, if the window manager asks the user where to position
5912 the frame, this will return before the user finishes doing that.
5913 The frame will not actually be visible at that time,
5914 but it will become visible later when the window manager
5915 finishes with it. */
5917 void
5918 x_make_frame_visible (struct frame *f)
5920 block_input ();
5922 x_set_bitmap_icon (f);
5924 if (! FRAME_VISIBLE_P (f))
5926 /* We test FRAME_GARBAGED_P here to make sure we don't
5927 call x_set_offset a second time
5928 if we get to x_make_frame_visible a second time
5929 before the window gets really visible. */
5930 if (! FRAME_ICONIFIED_P (f)
5931 && ! f->output_data.w32->asked_for_visible)
5933 RECT workarea_rect;
5934 RECT window_rect;
5936 /* Adjust vertical window position in order to avoid being
5937 covered by a task bar placed at the bottom of the desktop. */
5938 SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0);
5939 GetWindowRect (FRAME_W32_WINDOW (f), &window_rect);
5940 if (window_rect.bottom > workarea_rect.bottom
5941 && window_rect.top > workarea_rect.top)
5942 f->top_pos = max (window_rect.top
5943 - window_rect.bottom + workarea_rect.bottom,
5944 workarea_rect.top);
5946 x_set_offset (f, f->left_pos, f->top_pos, 0);
5949 f->output_data.w32->asked_for_visible = 1;
5951 /* According to a report in emacs-devel 2008-06-03, SW_SHOWNORMAL
5952 causes unexpected behavior when unminimizing frames that were
5953 previously maximized. But only SW_SHOWNORMAL works properly for
5954 frames that were truely hidden (using make-frame-invisible), so
5955 we need it to avoid Bug#5482. It seems that iconified is only
5956 set for minimized windows that are still visible, so use that to
5957 determine the appropriate flag to pass ShowWindow. */
5958 my_show_window (f, FRAME_W32_WINDOW (f),
5959 FRAME_ICONIFIED_P (f) ? SW_RESTORE : SW_SHOWNORMAL);
5962 /* Synchronize to ensure Emacs knows the frame is visible
5963 before we do anything else. We do this loop with input not blocked
5964 so that incoming events are handled. */
5966 Lisp_Object frame;
5967 int count;
5969 /* This must come after we set COUNT. */
5970 unblock_input ();
5972 XSETFRAME (frame, f);
5974 /* Wait until the frame is visible. Process X events until a
5975 MapNotify event has been seen, or until we think we won't get a
5976 MapNotify at all.. */
5977 for (count = input_signal_count + 10;
5978 input_signal_count < count && !FRAME_VISIBLE_P (f);)
5980 /* Force processing of queued events. */
5981 /* TODO: x_sync equivalent? */
5983 /* Machines that do polling rather than SIGIO have been observed
5984 to go into a busy-wait here. So we'll fake an alarm signal
5985 to let the handler know that there's something to be read.
5986 We used to raise a real alarm, but it seems that the handler
5987 isn't always enabled here. This is probably a bug. */
5988 if (input_polling_used ())
5990 /* It could be confusing if a real alarm arrives while processing
5991 the fake one. Turn it off and let the handler reset it. */
5992 int old_poll_suppress_count = poll_suppress_count;
5993 poll_suppress_count = 1;
5994 poll_for_input_1 ();
5995 poll_suppress_count = old_poll_suppress_count;
6001 /* Change from mapped state to withdrawn state. */
6003 /* Make the frame visible (mapped and not iconified). */
6005 void
6006 x_make_frame_invisible (struct frame *f)
6008 /* Don't keep the highlight on an invisible frame. */
6009 if (FRAME_DISPLAY_INFO (f)->x_highlight_frame == f)
6010 FRAME_DISPLAY_INFO (f)->x_highlight_frame = 0;
6012 block_input ();
6014 my_show_window (f, FRAME_W32_WINDOW (f), SW_HIDE);
6016 /* We can't distinguish this from iconification
6017 just by the event that we get from the server.
6018 So we can't win using the usual strategy of letting
6019 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
6020 and synchronize with the server to make sure we agree. */
6021 SET_FRAME_VISIBLE (f, 0);
6022 SET_FRAME_ICONIFIED (f, 0);
6024 unblock_input ();
6027 /* Change window state from mapped to iconified. */
6029 void
6030 x_iconify_frame (struct frame *f)
6032 /* Don't keep the highlight on an invisible frame. */
6033 if (FRAME_DISPLAY_INFO (f)->x_highlight_frame == f)
6034 FRAME_DISPLAY_INFO (f)->x_highlight_frame = 0;
6036 if (FRAME_ICONIFIED_P (f))
6037 return;
6039 block_input ();
6041 x_set_bitmap_icon (f);
6043 /* Simulate the user minimizing the frame. */
6044 SendMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, SC_MINIMIZE, 0);
6046 SET_FRAME_VISIBLE (f, 0);
6047 SET_FRAME_ICONIFIED (f, 1);
6049 unblock_input ();
6053 /* Free X resources of frame F. */
6055 void
6056 x_free_frame_resources (struct frame *f)
6058 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
6059 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
6061 block_input ();
6063 /* We must free faces before destroying windows because some
6064 font-driver (e.g. xft) access a window while finishing a
6065 face. */
6066 free_frame_faces (f);
6068 if (FRAME_W32_WINDOW (f))
6069 my_destroy_window (f, FRAME_W32_WINDOW (f));
6071 free_frame_menubar (f);
6073 xfree (f->output_data.w32);
6074 f->output_data.w32 = NULL;
6076 if (f == dpyinfo->w32_focus_frame)
6077 dpyinfo->w32_focus_frame = 0;
6078 if (f == dpyinfo->w32_focus_event_frame)
6079 dpyinfo->w32_focus_event_frame = 0;
6080 if (f == dpyinfo->x_highlight_frame)
6081 dpyinfo->x_highlight_frame = 0;
6082 if (f == hlinfo->mouse_face_mouse_frame)
6083 reset_mouse_highlight (hlinfo);
6085 unblock_input ();
6089 /* Destroy the window of frame F. */
6090 void
6091 x_destroy_window (struct frame *f)
6093 struct w32_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
6095 x_free_frame_resources (f);
6096 dpyinfo->reference_count--;
6100 /* Setting window manager hints. */
6102 /* Set the normal size hints for the window manager, for frame F.
6103 FLAGS is the flags word to use--or 0 meaning preserve the flags
6104 that the window now has.
6105 If USER_POSITION, set the USPosition
6106 flag (this is useful when FLAGS is 0). */
6107 void
6108 x_wm_set_size_hint (struct frame *f, long flags, bool user_position)
6110 Window window = FRAME_W32_WINDOW (f);
6112 enter_crit ();
6114 SetWindowLong (window, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
6115 SetWindowLong (window, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
6116 SetWindowLong (window, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
6117 SetWindowLong (window, WND_SCROLLBAR_INDEX, FRAME_SCROLL_BAR_AREA_WIDTH (f));
6119 leave_crit ();
6122 /***********************************************************************
6123 Fonts
6124 ***********************************************************************/
6126 #ifdef GLYPH_DEBUG
6128 /* Check that FONT is valid on frame F. It is if it can be found in F's
6129 font table. */
6131 static void
6132 x_check_font (struct frame *f, struct font *font)
6134 eassert (font != NULL && ! NILP (font->props[FONT_TYPE_INDEX]));
6135 if (font->driver->check)
6136 eassert (font->driver->check (f, font) == 0);
6139 #endif /* GLYPH_DEBUG */
6143 /***********************************************************************
6144 Initialization
6145 ***********************************************************************/
6147 static int w32_initialized = 0;
6149 void
6150 w32_initialize_display_info (Lisp_Object display_name)
6152 struct w32_display_info *dpyinfo = &one_w32_display_info;
6154 memset (dpyinfo, 0, sizeof (*dpyinfo));
6156 dpyinfo->name_list_element = Fcons (display_name, Qnil);
6157 dpyinfo->w32_id_name = xmalloc (SCHARS (Vinvocation_name)
6158 + SCHARS (Vsystem_name) + 2);
6159 sprintf (dpyinfo->w32_id_name, "%s@%s",
6160 SDATA (Vinvocation_name), SDATA (Vsystem_name));
6162 /* Default Console mode values - overridden when running in GUI mode
6163 with values obtained from system metrics. */
6164 dpyinfo->resx = 1;
6165 dpyinfo->resy = 1;
6166 dpyinfo->n_planes = 1;
6167 dpyinfo->n_cbits = 4;
6168 dpyinfo->n_fonts = 0;
6169 dpyinfo->smallest_font_height = 1;
6170 dpyinfo->smallest_char_width = 1;
6171 dpyinfo->vertical_scroll_bar_cursor = w32_load_cursor (IDC_ARROW);
6172 /* TODO: dpyinfo->gray */
6174 reset_mouse_highlight (&dpyinfo->mouse_highlight);
6177 /* Create an xrdb-style database of resources to supersede registry settings.
6178 The database is just a concatenation of C strings, finished by an additional
6179 \0. The strings are submitted to some basic normalization, so
6181 [ *]option[ *]:[ *]value...
6183 becomes
6185 option:value...
6187 but any whitespace following value is not removed. */
6189 static char *
6190 w32_make_rdb (char *xrm_option)
6192 char *buffer = xmalloc (strlen (xrm_option) + 2);
6193 char *current = buffer;
6194 char ch;
6195 int in_option = 1;
6196 int before_value = 0;
6198 do {
6199 ch = *xrm_option++;
6201 if (ch == '\n')
6203 *current++ = '\0';
6204 in_option = 1;
6205 before_value = 0;
6207 else if (ch != ' ')
6209 *current++ = ch;
6210 if (in_option && (ch == ':'))
6212 in_option = 0;
6213 before_value = 1;
6215 else if (before_value)
6217 before_value = 0;
6220 else if (!(in_option || before_value))
6222 *current++ = ch;
6224 } while (ch);
6226 *current = '\0';
6228 return buffer;
6231 extern frame_parm_handler w32_frame_parm_handlers[];
6233 static struct redisplay_interface w32_redisplay_interface =
6235 w32_frame_parm_handlers,
6236 x_produce_glyphs,
6237 x_write_glyphs,
6238 x_insert_glyphs,
6239 x_clear_end_of_line,
6240 x_scroll_run,
6241 x_after_update_window_line,
6242 x_update_window_begin,
6243 x_update_window_end,
6244 0, /* flush_display */
6245 x_clear_window_mouse_face,
6246 x_get_glyph_overhangs,
6247 x_fix_overlapping_area,
6248 w32_draw_fringe_bitmap,
6249 w32_define_fringe_bitmap,
6250 w32_destroy_fringe_bitmap,
6251 w32_compute_glyph_string_overhangs,
6252 x_draw_glyph_string,
6253 w32_define_frame_cursor,
6254 w32_clear_frame_area,
6255 w32_draw_window_cursor,
6256 w32_draw_vertical_window_border,
6257 w32_draw_window_divider,
6258 w32_shift_glyphs_for_insert
6261 static void x_delete_terminal (struct terminal *term);
6263 static struct terminal *
6264 w32_create_terminal (struct w32_display_info *dpyinfo)
6266 struct terminal *terminal;
6268 terminal = create_terminal ();
6270 terminal->type = output_w32;
6271 terminal->display_info.w32 = dpyinfo;
6272 dpyinfo->terminal = terminal;
6274 /* MSVC does not type K&R functions with no arguments correctly, and
6275 so we must explicitly cast them. */
6276 terminal->clear_frame_hook = x_clear_frame;
6277 terminal->ins_del_lines_hook = x_ins_del_lines;
6278 terminal->delete_glyphs_hook = x_delete_glyphs;
6279 terminal->ring_bell_hook = w32_ring_bell;
6280 terminal->reset_terminal_modes_hook = NULL;
6281 terminal->set_terminal_modes_hook = NULL;
6282 terminal->update_begin_hook = x_update_begin;
6283 terminal->update_end_hook = x_update_end;
6284 terminal->set_terminal_window_hook = NULL;
6285 terminal->read_socket_hook = w32_read_socket;
6286 terminal->frame_up_to_date_hook = w32_frame_up_to_date;
6287 terminal->mouse_position_hook = w32_mouse_position;
6288 terminal->frame_rehighlight_hook = w32_frame_rehighlight;
6289 terminal->frame_raise_lower_hook = w32_frame_raise_lower;
6290 terminal->fullscreen_hook = w32fullscreen_hook;
6291 terminal->set_vertical_scroll_bar_hook = w32_set_vertical_scroll_bar;
6292 terminal->condemn_scroll_bars_hook = w32_condemn_scroll_bars;
6293 terminal->redeem_scroll_bar_hook = w32_redeem_scroll_bar;
6294 terminal->judge_scroll_bars_hook = w32_judge_scroll_bars;
6296 terminal->delete_frame_hook = x_destroy_window;
6297 terminal->delete_terminal_hook = x_delete_terminal;
6299 terminal->rif = &w32_redisplay_interface;
6301 /* We don't yet support separate terminals on W32, so don't try to share
6302 keyboards between virtual terminals that are on the same physical
6303 terminal like X does. */
6304 terminal->kboard = allocate_kboard (Qw32);
6305 /* Don't let the initial kboard remain current longer than necessary.
6306 That would cause problems if a file loaded on startup tries to
6307 prompt in the mini-buffer. */
6308 if (current_kboard == initial_kboard)
6309 current_kboard = terminal->kboard;
6310 terminal->kboard->reference_count++;
6312 return terminal;
6315 static void
6316 x_delete_terminal (struct terminal *terminal)
6318 struct w32_display_info *dpyinfo = terminal->display_info.w32;
6320 /* Protect against recursive calls. delete_frame in
6321 delete_terminal calls us back when it deletes our last frame. */
6322 if (!terminal->name)
6323 return;
6325 block_input ();
6327 x_delete_display (dpyinfo);
6328 unblock_input ();
6331 struct w32_display_info *
6332 w32_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
6334 struct w32_display_info *dpyinfo;
6335 struct terminal *terminal;
6336 HDC hdc;
6338 block_input ();
6340 if (!w32_initialized)
6342 w32_initialize ();
6343 w32_initialized = 1;
6346 w32_initialize_display_info (display_name);
6348 dpyinfo = &one_w32_display_info;
6349 terminal = w32_create_terminal (dpyinfo);
6351 /* Set the name of the terminal. */
6352 terminal->name = xlispstrdup (display_name);
6354 dpyinfo->xrdb = xrm_option ? w32_make_rdb (xrm_option) : NULL;
6356 /* Put this display on the chain. */
6357 dpyinfo->next = x_display_list;
6358 x_display_list = dpyinfo;
6360 hdc = GetDC (NULL);
6362 dpyinfo->root_window = GetDesktopWindow ();
6363 dpyinfo->n_planes = GetDeviceCaps (hdc, PLANES);
6364 dpyinfo->n_cbits = GetDeviceCaps (hdc, BITSPIXEL);
6365 dpyinfo->resx = GetDeviceCaps (hdc, LOGPIXELSX);
6366 dpyinfo->resy = GetDeviceCaps (hdc, LOGPIXELSY);
6367 dpyinfo->has_palette = GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE;
6368 ReleaseDC (NULL, hdc);
6370 /* initialize palette with white and black */
6372 XColor color;
6373 w32_defined_color (0, "white", &color, 1);
6374 w32_defined_color (0, "black", &color, 1);
6377 #ifdef WINDOWSNT
6378 /* Add the default keyboard. When !WINDOWSNT, we're using the
6379 standard Emacs console handling machinery and don't need an
6380 explicit FD here. */
6381 add_keyboard_wait_descriptor (0);
6382 #elif CYGWIN
6383 /* /dev/windows wakes us up when we have a thread message pending. */
6384 add_keyboard_wait_descriptor (w32_message_fd);
6385 #endif
6387 /* Create Fringe Bitmaps and store them for later use.
6389 On W32, bitmaps are all unsigned short, as Windows requires
6390 bitmap data to be Word aligned. For some reason they are
6391 horizontally reflected compared to how they appear on X, so we
6392 need to bitswap and convert to unsigned shorts before creating
6393 the bitmaps. */
6394 w32_init_fringe (terminal->rif);
6396 unblock_input ();
6398 return dpyinfo;
6401 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6402 void
6403 x_delete_display (struct w32_display_info *dpyinfo)
6405 /* FIXME: the only display info apparently can't be deleted. */
6406 /* free palette table */
6408 struct w32_palette_entry * plist;
6410 plist = dpyinfo->color_list;
6411 while (plist)
6413 struct w32_palette_entry * pentry = plist;
6414 plist = plist->next;
6415 xfree (pentry);
6417 dpyinfo->color_list = NULL;
6418 if (dpyinfo->palette)
6419 DeleteObject (dpyinfo->palette);
6421 xfree (dpyinfo->w32_id_name);
6423 w32_reset_fringes ();
6427 /* Set up use of W32. */
6429 DWORD WINAPI w32_msg_worker (void * arg);
6431 static void
6432 w32_initialize (void)
6434 HANDLE shell;
6435 HRESULT (WINAPI * set_user_model) (const wchar_t * id);
6437 baud_rate = 19200;
6439 w32_system_caret_hwnd = NULL;
6440 w32_system_caret_height = 0;
6441 w32_system_caret_x = 0;
6442 w32_system_caret_y = 0;
6444 /* On Windows 7 and later, we need to set the user model ID
6445 to associate emacsclient launched files with Emacs frames
6446 in the UI. */
6447 shell = GetModuleHandle ("shell32.dll");
6448 if (shell)
6450 set_user_model
6451 = (void *) GetProcAddress (shell,
6452 "SetCurrentProcessExplicitAppUserModelID");
6454 /* If the function is defined, then we are running on Windows 7
6455 or newer, and the UI uses this to group related windows
6456 together. Since emacs, runemacs, emacsclient are related, we
6457 want them grouped even though the executables are different,
6458 so we need to set a consistent ID between them. */
6459 if (set_user_model)
6460 set_user_model (L"GNU.Emacs");
6463 #ifdef CYGWIN
6464 if ((w32_message_fd = emacs_open ("/dev/windows", O_RDWR, 0)) == -1)
6465 fatal ("opening /dev/windows: %s", strerror (errno));
6466 #endif /* CYGWIN */
6468 /* Initialize w32_use_visible_system_caret based on whether a screen
6469 reader is in use. */
6470 if (!SystemParametersInfo (SPI_GETSCREENREADER, 0,
6471 &w32_use_visible_system_caret, 0))
6472 w32_use_visible_system_caret = 0;
6474 last_tool_bar_item = -1;
6475 any_help_event_p = 0;
6477 /* Initialize input mode: interrupt_input off, no flow control, allow
6478 8 bit character input, standard quit char. */
6479 Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
6482 LCID input_locale_id = LOWORD (GetKeyboardLayout (0));
6483 w32_keyboard_codepage = codepage_for_locale (input_locale_id);
6486 /* Create the window thread - it will terminate itself when the app
6487 terminates */
6488 init_crit ();
6490 dwMainThreadId = GetCurrentThreadId ();
6491 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6492 GetCurrentProcess (), &hMainThread, 0, TRUE, DUPLICATE_SAME_ACCESS);
6494 /* Wait for thread to start */
6496 MSG msg;
6498 PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
6500 hWindowsThread = CreateThread (NULL, 0,
6501 w32_msg_worker,
6502 0, 0, &dwWindowsThreadId);
6504 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
6507 /* It is desirable that mainThread should have the same notion of
6508 focus window and active window as windowsThread. Unfortunately, the
6509 following call to AttachThreadInput, which should do precisely what
6510 we need, causes major problems when Emacs is linked as a console
6511 program. Unfortunately, we have good reasons for doing that, so
6512 instead we need to send messages to windowsThread to make some API
6513 calls for us (ones that affect, or depend on, the active/focus
6514 window state.) */
6515 #ifdef ATTACH_THREADS
6516 AttachThreadInput (dwMainThreadId, dwWindowsThreadId, TRUE);
6517 #endif
6519 /* Dynamically link to optional system components. */
6521 HMODULE user_lib = GetModuleHandle ("user32.dll");
6523 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
6525 LOAD_PROC (user_lib, SetLayeredWindowAttributes);
6527 #undef LOAD_PROC
6529 /* Ensure scrollbar handle is at least 5 pixels. */
6530 vertical_scroll_bar_min_handle = 5;
6532 /* For either kind of scroll bar, take account of the arrows; these
6533 effectively form the border of the main scroll bar range. */
6534 vertical_scroll_bar_top_border = vertical_scroll_bar_bottom_border
6535 = GetSystemMetrics (SM_CYVSCROLL);
6539 void
6540 syms_of_w32term (void)
6542 DEFSYM (Qvendor_specific_keysyms, "vendor-specific-keysyms");
6544 DEFSYM (Qadded, "added");
6545 DEFSYM (Qremoved, "removed");
6546 DEFSYM (Qmodified, "modified");
6547 DEFSYM (Qrenamed_from, "renamed-from");
6548 DEFSYM (Qrenamed_to, "renamed-to");
6550 DEFVAR_INT ("w32-num-mouse-buttons",
6551 w32_num_mouse_buttons,
6552 doc: /* Number of physical mouse buttons. */);
6553 w32_num_mouse_buttons = 2;
6555 DEFVAR_LISP ("w32-swap-mouse-buttons",
6556 Vw32_swap_mouse_buttons,
6557 doc: /* Swap the mapping of middle and right mouse buttons.
6558 When nil, middle button is mouse-2 and right button is mouse-3. */);
6559 Vw32_swap_mouse_buttons = Qnil;
6561 DEFVAR_LISP ("w32-grab-focus-on-raise",
6562 Vw32_grab_focus_on_raise,
6563 doc: /* Raised frame grabs input focus.
6564 When t, `raise-frame' grabs input focus as well. This fits well
6565 with the normal Windows click-to-focus policy, but might not be
6566 desirable when using a point-to-focus policy. */);
6567 Vw32_grab_focus_on_raise = Qt;
6569 DEFVAR_LISP ("w32-capslock-is-shiftlock",
6570 Vw32_capslock_is_shiftlock,
6571 doc: /* Apply CapsLock state to non character input keys.
6572 When nil, CapsLock only affects normal character input keys. */);
6573 Vw32_capslock_is_shiftlock = Qnil;
6575 DEFVAR_LISP ("w32-recognize-altgr",
6576 Vw32_recognize_altgr,
6577 doc: /* Recognize right-alt and left-ctrl as AltGr.
6578 When nil, the right-alt and left-ctrl key combination is
6579 interpreted normally. */);
6580 Vw32_recognize_altgr = Qt;
6582 DEFVAR_BOOL ("w32-use-visible-system-caret",
6583 w32_use_visible_system_caret,
6584 doc: /* Flag to make the system caret visible.
6585 When this is non-nil, Emacs will indicate the position of point by
6586 using the system caret instead of drawing its own cursor. Some screen
6587 reader software does not track the system cursor properly when it is
6588 invisible, and gets confused by Emacs drawing its own cursor, so this
6589 variable is initialized to t when Emacs detects that screen reader
6590 software is running as it starts up.
6592 When this variable is set, other variables affecting the appearance of
6593 the cursor have no effect. */);
6595 w32_use_visible_system_caret = 0;
6597 /* We don't yet support this, but defining this here avoids whining
6598 from cus-start.el and other places, like "M-x set-variable". */
6599 DEFVAR_BOOL ("x-use-underline-position-properties",
6600 x_use_underline_position_properties,
6601 doc: /* Non-nil means make use of UNDERLINE_POSITION font properties.
6602 A value of nil means ignore them. If you encounter fonts with bogus
6603 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
6604 to 4.1, set this to nil. You can also use `underline-minimum-offset'
6605 to override the font's UNDERLINE_POSITION for small font display
6606 sizes. */);
6607 x_use_underline_position_properties = 0;
6609 DEFVAR_BOOL ("x-underline-at-descent-line",
6610 x_underline_at_descent_line,
6611 doc: /* Non-nil means to draw the underline at the same place as the descent line.
6612 A value of nil means to draw the underline according to the value of the
6613 variable `x-use-underline-position-properties', which is usually at the
6614 baseline level. The default value is nil. */);
6615 x_underline_at_descent_line = 0;
6617 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars,
6618 doc: /* Which toolkit scroll bars Emacs uses, if any.
6619 A value of nil means Emacs doesn't use toolkit scroll bars.
6620 With the X Window system, the value is a symbol describing the
6621 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
6622 With MS Windows or Nextstep, the value is t. */);
6623 Vx_toolkit_scroll_bars = Qt;
6625 DEFVAR_BOOL ("w32-unicode-filenames",
6626 w32_unicode_filenames,
6627 doc: /* Non-nil means use Unicode APIs when passing file names to the OS.
6628 A value of nil means file names passed to the OS APIs and returned
6629 from those APIs are encoded/decoded using the ANSI codepage
6630 specified by `file-name-coding-system'.
6632 This variable is set to non-nil by default when Emacs runs on Windows
6633 systems of the NT family, including W2K, XP, Vista, Windows 7 and
6634 Windows 8. It is set to nil on Windows 9X. */);
6635 w32_unicode_filenames = 0;
6637 DEFVAR_BOOL ("w32-enable-frame-resize-hack",
6638 w32_enable_frame_resize_hack,
6639 doc: /* Non-nil means enable hack for frame resizing on Windows.
6640 A value of nil means to resize frames by sending a corresponding request
6641 to the Windows API and changing the pixel sizes of the frame and its
6642 windows after the latter calls back. If this is non-nil, Emacs changes
6643 the pixel sizes of the frame and its windows at the time it sends the
6644 resize request to the API. */);
6645 w32_enable_frame_resize_hack = 1;
6647 /* Tell Emacs about this window system. */
6648 Fprovide (Qw32, Qnil);