(c-guess-basic-syntax): Move CASE 19 to a different place, correctly to
[emacs.git] / src / w32term.c
blob67e853f21f05db65931316995d79e86d3c7cc3a0
1 /* Implementation of GUI terminal on the Microsoft W32 API.
3 Copyright (C) 1989, 1993-2011 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 <setjmp.h>
24 #include "lisp.h"
25 #include "blockinput.h"
26 #include "w32term.h"
28 #include "systty.h"
29 #include "systime.h"
31 #include <ctype.h>
32 #include <errno.h>
33 #include <sys/stat.h>
34 #include <imm.h>
36 #include "charset.h"
37 #include "character.h"
38 #include "coding.h"
39 #include "ccl.h"
40 #include "frame.h"
41 #include "dispextern.h"
42 #include "fontset.h"
43 #include "termhooks.h"
44 #include "termopts.h"
45 #include "termchar.h"
46 #include "disptab.h"
47 #include "buffer.h"
48 #include "window.h"
49 #include "keyboard.h"
50 #include "intervals.h"
51 #include "process.h"
52 #include "atimer.h"
53 #include "keymap.h"
55 #include "w32heap.h"
56 #include <shellapi.h>
58 #include "font.h"
59 #include "w32font.h"
61 /* Fringe bitmaps. */
63 static int max_fringe_bmp = 0;
64 static HBITMAP *fringe_bmp = 0;
66 /* Temporary variables for w32_read_socket. */
68 static int last_mousemove_x = 0;
69 static int last_mousemove_y = 0;
71 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
72 #ifndef GET_WHEEL_DELTA_WPARAM
73 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
74 #endif
76 /* Non-zero means that a HELP_EVENT has been generated since Emacs
77 start. */
79 static int any_help_event_p;
81 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
82 static Lisp_Object last_window;
84 extern unsigned int msh_mousewheel;
86 extern void free_frame_menubar (struct frame *);
88 extern int w32_codepage_for_font (char *fontname);
89 extern Cursor w32_load_cursor (LPCTSTR name);
91 extern Lisp_Object Vwindow_system;
93 #define x_any_window_to_frame x_window_to_frame
94 #define x_top_window_to_frame x_window_to_frame
97 /* This is display since w32 does not support multiple ones. */
98 struct w32_display_info one_w32_display_info;
99 struct w32_display_info *x_display_list;
101 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
102 one for each element of w32_display_list and in the same order.
103 NAME is the name of the frame.
104 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
105 Lisp_Object w32_display_name_list;
108 #ifndef GLYPHSET
109 /* Pre Windows 2000, this was not available, but define it here so
110 that Emacs compiled on such a platform will run on newer versions. */
112 typedef struct tagWCRANGE
114 WCHAR wcLow;
115 USHORT cGlyphs;
116 } WCRANGE;
118 typedef struct tagGLYPHSET
120 DWORD cbThis;
121 DWORD flAccel;
122 DWORD cGlyphsSupported;
123 DWORD cRanges;
124 WCRANGE ranges[1];
125 } GLYPHSET;
127 #endif
129 /* Dynamic linking to SetLayeredWindowAttribute (only since 2000). */
130 BOOL (WINAPI *pfnSetLayeredWindowAttributes) (HWND, COLORREF, BYTE, DWORD);
132 #ifndef LWA_ALPHA
133 #define LWA_ALPHA 0x02
134 #endif
135 /* WS_EX_LAYERED is defined unconditionally by MingW, but only for W2K and
136 later targets by MSVC headers. */
137 #ifndef WS_EX_LAYERED
138 #define WS_EX_LAYERED 0x80000
139 #endif
141 /* Frame being updated by update_frame. This is declared in term.c.
142 This is set by update_begin and looked at by all the
143 w32 functions. It is zero while not inside an update.
144 In that case, the w32 functions assume that `SELECTED_FRAME ()'
145 is the frame to apply to. */
146 extern struct frame *updating_frame;
148 /* This is a frame waiting to be autoraised, within w32_read_socket. */
149 struct frame *pending_autoraise_frame;
151 /* The handle of the frame that currently owns the system caret. */
152 HWND w32_system_caret_hwnd;
153 int w32_system_caret_height;
154 int w32_system_caret_x;
155 int w32_system_caret_y;
156 DWORD dwWindowsThreadId = 0;
157 HANDLE hWindowsThread = NULL;
158 DWORD dwMainThreadId = 0;
159 HANDLE hMainThread = NULL;
161 int vertical_scroll_bar_min_handle;
162 int vertical_scroll_bar_top_border;
163 int vertical_scroll_bar_bottom_border;
165 int last_scroll_bar_drag_pos;
167 /* Mouse movement. */
169 /* Where the mouse was last time we reported a mouse event. */
170 static RECT last_mouse_glyph;
171 static FRAME_PTR last_mouse_glyph_frame;
172 static Lisp_Object last_mouse_press_frame;
174 /* The scroll bar in which the last motion event occurred.
176 If the last motion event occurred in a scroll bar, we set this
177 so w32_mouse_position can know whether to report a scroll bar motion or
178 an ordinary motion.
180 If the last motion event didn't occur in a scroll bar, we set this
181 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
182 static Lisp_Object last_mouse_scroll_bar;
183 static int last_mouse_scroll_bar_pos;
185 /* This is a hack. We would really prefer that w32_mouse_position would
186 return the time associated with the position it returns, but there
187 doesn't seem to be any way to wrest the time-stamp from the server
188 along with the position query. So, we just keep track of the time
189 of the last movement we received, and return that in hopes that
190 it's somewhat accurate. */
191 static Time last_mouse_movement_time;
193 /* Incremented by w32_read_socket whenever it really tries to read
194 events. */
195 #ifdef __STDC__
196 static int volatile input_signal_count;
197 #else
198 static int input_signal_count;
199 #endif
201 /* Keyboard code page - may be changed by language-change events. */
202 static int keyboard_codepage;
204 static void x_update_window_end (struct window *, int, int);
205 static void w32_handle_tool_bar_click (struct frame *,
206 struct input_event *);
207 static void w32_define_cursor (Window, Cursor);
209 void x_lower_frame (struct frame *);
210 void x_scroll_bar_clear (struct frame *);
211 void x_wm_set_size_hint (struct frame *, long, int);
212 void x_raise_frame (struct frame *);
213 void x_set_window_size (struct frame *, int, int, int);
214 void x_wm_set_window_state (struct frame *, int);
215 void x_wm_set_icon_pixmap (struct frame *, int);
216 static void w32_initialize (void);
217 static void x_update_end (struct frame *);
218 static void w32_frame_up_to_date (struct frame *);
219 static void w32_set_terminal_modes (struct terminal *);
220 static void w32_reset_terminal_modes (struct terminal *);
221 static void x_clear_frame (struct frame *);
222 static void frame_highlight (struct frame *);
223 static void frame_unhighlight (struct frame *);
224 static void x_new_focus_frame (struct w32_display_info *,
225 struct frame *);
226 static void x_focus_changed (int, int, struct w32_display_info *,
227 struct frame *, struct input_event *);
228 static void w32_detect_focus_change (struct w32_display_info *,
229 W32Msg *, struct input_event *);
230 static void w32_frame_rehighlight (struct frame *);
231 static void x_frame_rehighlight (struct w32_display_info *);
232 static void x_draw_hollow_cursor (struct window *, struct glyph_row *);
233 static void x_draw_bar_cursor (struct window *, struct glyph_row *, int,
234 enum text_cursor_kinds);
235 static void w32_clip_to_row (struct window *, struct glyph_row *, int, HDC);
236 static BOOL my_show_window (struct frame *, HWND, int);
237 static void my_set_window_pos (HWND, HWND, int, int, int, int, UINT);
238 #if 0
239 static void my_set_focus (struct frame *, HWND);
240 #endif
241 static void my_set_foreground_window (HWND);
242 static void my_destroy_window (struct frame *, HWND);
244 static Lisp_Object Qvendor_specific_keysyms;
247 /***********************************************************************
248 Debugging
249 ***********************************************************************/
251 #if 0
253 /* This is a function useful for recording debugging information about
254 the sequence of occurrences in this file. */
256 struct record
258 char *locus;
259 int type;
262 struct record event_record[100];
264 int event_record_index;
266 record_event (char *locus, int type)
268 if (event_record_index == sizeof (event_record) / sizeof (struct record))
269 event_record_index = 0;
271 event_record[event_record_index].locus = locus;
272 event_record[event_record_index].type = type;
273 event_record_index++;
276 #endif /* 0 */
279 void
280 XChangeGC (void *ignore, XGCValues *gc, unsigned long mask,
281 XGCValues *xgcv)
283 if (mask & GCForeground)
284 gc->foreground = xgcv->foreground;
285 if (mask & GCBackground)
286 gc->background = xgcv->background;
287 if (mask & GCFont)
288 gc->font = xgcv->font;
291 XGCValues *
292 XCreateGC (void *ignore, Window window, unsigned long mask, XGCValues *xgcv)
294 XGCValues *gc = (XGCValues *) xmalloc (sizeof (XGCValues));
295 memset (gc, 0, sizeof (XGCValues));
297 XChangeGC (ignore, gc, mask, xgcv);
299 return gc;
302 void
303 XGetGCValues (void *ignore, XGCValues *gc,
304 unsigned long mask, XGCValues *xgcv)
306 XChangeGC (ignore, xgcv, mask, gc);
309 static void
310 w32_set_clip_rectangle (HDC hdc, RECT *rect)
312 if (rect)
314 HRGN clip_region = CreateRectRgnIndirect (rect);
315 SelectClipRgn (hdc, clip_region);
316 DeleteObject (clip_region);
318 else
319 SelectClipRgn (hdc, NULL);
323 /* Draw a hollow rectangle at the specified position. */
324 void
325 w32_draw_rectangle (HDC hdc, XGCValues *gc, int x, int y,
326 int width, int height)
328 HBRUSH hb, oldhb;
329 HPEN hp, oldhp;
331 hb = CreateSolidBrush (gc->background);
332 hp = CreatePen (PS_SOLID, 0, gc->foreground);
333 oldhb = SelectObject (hdc, hb);
334 oldhp = SelectObject (hdc, hp);
336 Rectangle (hdc, x, y, x + width, y + height);
338 SelectObject (hdc, oldhb);
339 SelectObject (hdc, oldhp);
340 DeleteObject (hb);
341 DeleteObject (hp);
344 /* Draw a filled rectangle at the specified position. */
345 void
346 w32_fill_rect (FRAME_PTR f, HDC hdc, COLORREF pix, RECT *lprect)
348 HBRUSH hb;
350 hb = CreateSolidBrush (pix);
351 FillRect (hdc, lprect, hb);
352 DeleteObject (hb);
355 void
356 w32_clear_window (FRAME_PTR f)
358 RECT rect;
359 HDC hdc = get_frame_dc (f);
361 /* Under certain conditions, this can be called at startup with
362 a console frame pointer before the GUI frame is created. An HDC
363 of 0 indicates this. */
364 if (hdc)
366 GetClientRect (FRAME_W32_WINDOW (f), &rect);
367 w32_clear_rect (f, hdc, &rect);
370 release_frame_dc (f, hdc);
373 #define OPAQUE_FRAME 255
375 void
376 x_set_frame_alpha (struct frame *f)
378 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
379 double alpha = 1.0;
380 double alpha_min = 1.0;
381 BYTE opac;
382 LONG ex_style;
383 HWND window = FRAME_W32_WINDOW (f);
385 /* Older versions of Windows do not support transparency. */
386 if (!pfnSetLayeredWindowAttributes)
387 return;
389 if (dpyinfo->x_highlight_frame == f)
390 alpha = f->alpha[0];
391 else
392 alpha = f->alpha[1];
394 if (FLOATP (Vframe_alpha_lower_limit))
395 alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
396 else if (INTEGERP (Vframe_alpha_lower_limit))
397 alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
399 if (alpha < 0.0)
400 return;
401 else if (alpha > 1.0)
402 alpha = 1.0;
403 else if (alpha < alpha_min && alpha_min <= 1.0)
404 alpha = alpha_min;
406 opac = alpha * OPAQUE_FRAME;
408 ex_style = GetWindowLong (window, GWL_EXSTYLE);
410 if (opac == OPAQUE_FRAME)
411 ex_style &= ~WS_EX_LAYERED;
412 else
413 ex_style |= WS_EX_LAYERED;
415 SetWindowLong (window, GWL_EXSTYLE, ex_style);
417 if (opac != OPAQUE_FRAME)
418 pfnSetLayeredWindowAttributes (window, 0, opac, LWA_ALPHA);
422 x_display_pixel_height (struct w32_display_info *dpyinfo)
424 HDC dc = GetDC (NULL);
425 int pixels = GetDeviceCaps (dc, VERTRES);
426 ReleaseDC (NULL, dc);
427 return pixels;
431 x_display_pixel_width (struct w32_display_info *dpyinfo)
433 HDC dc = GetDC (NULL);
434 int pixels = GetDeviceCaps (dc, HORZRES);
435 ReleaseDC (NULL, dc);
436 return pixels;
440 /***********************************************************************
441 Starting and ending an update
442 ***********************************************************************/
444 /* Start an update of frame F. This function is installed as a hook
445 for update_begin, i.e. it is called when update_begin is called.
446 This function is called prior to calls to x_update_window_begin for
447 each window being updated. */
449 static void
450 x_update_begin (struct frame *f)
452 struct w32_display_info *display_info = FRAME_W32_DISPLAY_INFO (f);
454 if (! FRAME_W32_P (f))
455 return;
457 /* Regenerate display palette before drawing if list of requested
458 colors has changed. */
459 if (display_info->regen_palette)
461 w32_regenerate_palette (f);
462 display_info->regen_palette = FALSE;
467 /* Start update of window W. Set the global variable updated_window
468 to the window being updated and set output_cursor to the cursor
469 position of W. */
471 static void
472 x_update_window_begin (struct window *w)
474 struct frame *f = XFRAME (WINDOW_FRAME (w));
475 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
477 /* Hide the system caret during an update. */
478 if (w32_use_visible_system_caret && w32_system_caret_hwnd)
480 SendMessage (w32_system_caret_hwnd, WM_EMACS_HIDE_CARET, 0, 0);
483 updated_window = w;
484 set_output_cursor (&w->cursor);
486 BLOCK_INPUT;
488 if (f == hlinfo->mouse_face_mouse_frame)
490 /* Don't do highlighting for mouse motion during the update. */
491 hlinfo->mouse_face_defer = 1;
493 /* If F needs to be redrawn, simply forget about any prior mouse
494 highlighting. */
495 if (FRAME_GARBAGED_P (f))
496 hlinfo->mouse_face_window = Qnil;
498 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
499 their mouse_face_p flag set, which means that they are always
500 unequal to rows in a desired matrix which never have that
501 flag set. So, rows containing mouse-face glyphs are never
502 scrolled, and we don't have to switch the mouse highlight off
503 here to prevent it from being scrolled. */
505 /* Can we tell that this update does not affect the window
506 where the mouse highlight is? If so, no need to turn off.
507 Likewise, don't do anything if the frame is garbaged;
508 in that case, the frame's current matrix that we would use
509 is all wrong, and we will redisplay that line anyway. */
510 if (!NILP (hlinfo->mouse_face_window)
511 && w == XWINDOW (hlinfo->mouse_face_window))
513 int i;
515 for (i = 0; i < w->desired_matrix->nrows; ++i)
516 if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
517 break;
519 if (i < w->desired_matrix->nrows)
520 clear_mouse_face (hlinfo);
522 #endif /* 0 */
525 UNBLOCK_INPUT;
528 /* Draw a vertical window border from (x,y0) to (x,y1) */
530 static void
531 w32_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
533 struct frame *f = XFRAME (WINDOW_FRAME (w));
534 RECT r;
535 HDC hdc;
536 struct face *face;
538 r.left = x;
539 r.right = x + 1;
540 r.top = y0;
541 r.bottom = y1;
543 hdc = get_frame_dc (f);
544 face = FACE_FROM_ID (f, VERTICAL_BORDER_FACE_ID);
545 if (face)
546 w32_fill_rect (f, hdc, face->foreground, &r);
547 else
548 w32_fill_rect (f, hdc, FRAME_FOREGROUND_PIXEL (f), &r);
550 release_frame_dc (f, hdc);
554 /* End update of window W (which is equal to updated_window).
556 Draw vertical borders between horizontally adjacent windows, and
557 display W's cursor if CURSOR_ON_P is non-zero.
559 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
560 glyphs in mouse-face were overwritten. In that case we have to
561 make sure that the mouse-highlight is properly redrawn.
563 W may be a menu bar pseudo-window in case we don't have X toolkit
564 support. Such windows don't have a cursor, so don't display it
565 here. */
567 static void
568 x_update_window_end (struct window *w, int cursor_on_p,
569 int mouse_face_overwritten_p)
571 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
573 if (!w->pseudo_window_p)
575 BLOCK_INPUT;
577 if (cursor_on_p)
578 display_and_set_cursor (w, 1, output_cursor.hpos,
579 output_cursor.vpos,
580 output_cursor.x, output_cursor.y);
582 if (draw_window_fringes (w, 1))
583 x_draw_vertical_border (w);
585 UNBLOCK_INPUT;
588 /* If a row with mouse-face was overwritten, arrange for
589 XTframe_up_to_date to redisplay the mouse highlight. */
590 if (mouse_face_overwritten_p)
592 hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
593 hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
594 hlinfo->mouse_face_window = Qnil;
597 /* Unhide the caret. This won't actually show the cursor, unless it
598 was visible before the corresponding call to HideCaret in
599 x_update_window_begin. */
600 if (w32_use_visible_system_caret && w32_system_caret_hwnd)
602 SendMessage (w32_system_caret_hwnd, WM_EMACS_SHOW_CARET, 0, 0);
605 updated_window = NULL;
609 /* End update of frame F. This function is installed as a hook in
610 update_end. */
612 static void
613 x_update_end (struct frame *f)
615 if (! FRAME_W32_P (f))
616 return;
618 /* Mouse highlight may be displayed again. */
619 MOUSE_HL_INFO (f)->mouse_face_defer = 0;
623 /* This function is called from various places in xdisp.c whenever a
624 complete update has been performed. The global variable
625 updated_window is not available here. */
627 static void
628 w32_frame_up_to_date (struct frame *f)
630 if (FRAME_W32_P (f))
632 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
634 if (hlinfo->mouse_face_deferred_gc
635 || f == hlinfo->mouse_face_mouse_frame)
637 BLOCK_INPUT;
638 if (hlinfo->mouse_face_mouse_frame)
639 note_mouse_highlight (hlinfo->mouse_face_mouse_frame,
640 hlinfo->mouse_face_mouse_x,
641 hlinfo->mouse_face_mouse_y);
642 hlinfo->mouse_face_deferred_gc = 0;
643 UNBLOCK_INPUT;
649 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
650 arrow bitmaps, or clear the fringes if no bitmaps are required
651 before DESIRED_ROW is made current. The window being updated is
652 found in updated_window. This function is called from
653 update_window_line only if it is known that there are differences
654 between bitmaps to be drawn between current row and DESIRED_ROW. */
656 static void
657 x_after_update_window_line (struct glyph_row *desired_row)
659 struct window *w = updated_window;
660 struct frame *f;
661 int width, height;
663 xassert (w);
665 if (!desired_row->mode_line_p && !w->pseudo_window_p)
666 desired_row->redraw_fringe_bitmaps_p = 1;
668 /* When a window has disappeared, make sure that no rest of
669 full-width rows stays visible in the internal border. Could
670 check here if updated_window is the leftmost/rightmost window,
671 but I guess it's not worth doing since vertically split windows
672 are almost never used, internal border is rarely set, and the
673 overhead is very small. */
674 if (windows_or_buffers_changed
675 && desired_row->full_width_p
676 && (f = XFRAME (w->frame),
677 width = FRAME_INTERNAL_BORDER_WIDTH (f),
678 width != 0)
679 && (height = desired_row->visible_height,
680 height > 0))
682 int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
684 BLOCK_INPUT;
686 HDC hdc = get_frame_dc (f);
687 w32_clear_area (f, hdc, 0, y, width, height);
688 w32_clear_area (f, hdc, FRAME_PIXEL_WIDTH (f) - width,
689 y, width, height);
690 release_frame_dc (f, hdc);
692 UNBLOCK_INPUT;
697 /* Draw the bitmap WHICH in one of the left or right fringes of
698 window W. ROW is the glyph row for which to display the bitmap; it
699 determines the vertical position at which the bitmap has to be
700 drawn. */
702 static void
703 w32_draw_fringe_bitmap (struct window *w, struct glyph_row *row,
704 struct draw_fringe_bitmap_params *p)
706 struct frame *f = XFRAME (WINDOW_FRAME (w));
707 HDC hdc;
708 struct face *face = p->face;
710 hdc = get_frame_dc (f);
712 if (!p->overlay_p)
714 int bx = p->bx, by = p->by, nx = p->nx, ny = p->ny;
716 /* If the fringe is adjacent to the left (right) scroll bar of a
717 leftmost (rightmost, respectively) window, then extend its
718 background to the gap between the fringe and the bar. */
719 if ((WINDOW_LEFTMOST_P (w)
720 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
721 || (WINDOW_RIGHTMOST_P (w)
722 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w)))
724 int sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
726 if (sb_width > 0)
728 int left = WINDOW_SCROLL_BAR_AREA_X (w);
729 int width = (WINDOW_CONFIG_SCROLL_BAR_COLS (w)
730 * FRAME_COLUMN_WIDTH (f));
732 if (bx < 0)
734 /* Bitmap fills the fringe. */
735 if (left + width == p->x)
736 bx = left + sb_width;
737 else if (p->x + p->wd == left)
738 bx = left;
739 if (bx >= 0)
741 int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
743 nx = width - sb_width;
744 by = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
745 row->y));
746 ny = row->visible_height;
749 else
751 if (left + width == bx)
753 bx = left + sb_width;
754 nx += width - sb_width;
756 else if (bx + nx == left)
757 nx += width - sb_width;
762 if (bx >= 0 && nx > 0)
763 w32_fill_area (f, hdc, face->background, bx, by, nx, ny);
766 /* Must clip because of partially visible lines. */
767 w32_clip_to_row (w, row, -1, hdc);
769 if (p->which && p->which < max_fringe_bmp)
771 HBITMAP pixmap = fringe_bmp[p->which];
772 HDC compat_hdc;
773 HANDLE horig_obj;
775 compat_hdc = CreateCompatibleDC (hdc);
777 SaveDC (hdc);
779 horig_obj = SelectObject (compat_hdc, pixmap);
781 /* Paint overlays transparently. */
782 if (p->overlay_p)
784 HBRUSH h_brush, h_orig_brush;
786 SetTextColor (hdc, BLACK_PIX_DEFAULT (f));
787 SetBkColor (hdc, WHITE_PIX_DEFAULT (f));
788 h_brush = CreateSolidBrush (face->foreground);
789 h_orig_brush = SelectObject (hdc, h_brush);
791 BitBlt (hdc, p->x, p->y, p->wd, p->h,
792 compat_hdc, 0, p->dh,
793 DSTINVERT);
794 BitBlt (hdc, p->x, p->y, p->wd, p->h,
795 compat_hdc, 0, p->dh,
796 0x2E064A);
797 BitBlt (hdc, p->x, p->y, p->wd, p->h,
798 compat_hdc, 0, p->dh,
799 DSTINVERT);
801 SelectObject (hdc, h_orig_brush);
802 DeleteObject (h_brush);
804 else
806 SetTextColor (hdc, face->background);
807 SetBkColor (hdc, (p->cursor_p
808 ? f->output_data.w32->cursor_pixel
809 : face->foreground));
811 BitBlt (hdc, p->x, p->y, p->wd, p->h,
812 compat_hdc, 0, p->dh,
813 SRCCOPY);
816 SelectObject (compat_hdc, horig_obj);
817 DeleteDC (compat_hdc);
818 RestoreDC (hdc, -1);
821 w32_set_clip_rectangle (hdc, NULL);
823 release_frame_dc (f, hdc);
826 static void
827 w32_define_fringe_bitmap (int which, unsigned short *bits, int h, int wd)
829 if (which >= max_fringe_bmp)
831 int i = max_fringe_bmp;
832 max_fringe_bmp = which + 20;
833 fringe_bmp = (HBITMAP *) xrealloc (fringe_bmp, max_fringe_bmp * sizeof (HBITMAP));
834 while (i < max_fringe_bmp)
835 fringe_bmp[i++] = 0;
838 fringe_bmp[which] = CreateBitmap (wd, h, 1, 1, bits);
841 static void
842 w32_destroy_fringe_bitmap (int which)
844 if (which >= max_fringe_bmp)
845 return;
847 if (fringe_bmp[which])
848 DeleteObject (fringe_bmp[which]);
849 fringe_bmp[which] = 0;
854 /* This is called when starting Emacs and when restarting after
855 suspend. When starting Emacs, no window is mapped. And nothing
856 must be done to Emacs's own window if it is suspended (though that
857 rarely happens). */
859 static void
860 w32_set_terminal_modes (struct terminal *term)
864 /* This is called when exiting or suspending Emacs. Exiting will make
865 the W32 windows go away, and suspending requires no action. */
867 static void
868 w32_reset_terminal_modes (struct terminal *term)
874 /***********************************************************************
875 Display Iterator
876 ***********************************************************************/
878 /* Function prototypes of this page. */
880 static void x_set_glyph_string_clipping (struct glyph_string *);
881 static void x_set_glyph_string_gc (struct glyph_string *);
882 static void x_draw_glyph_string_background (struct glyph_string *,
883 int);
884 static void x_draw_glyph_string_foreground (struct glyph_string *);
885 static void x_draw_composite_glyph_string_foreground (struct glyph_string *);
886 static void x_draw_glyph_string_box (struct glyph_string *);
887 static void x_draw_glyph_string (struct glyph_string *);
888 static void x_set_cursor_gc (struct glyph_string *);
889 static void x_set_mode_line_face_gc (struct glyph_string *);
890 static void x_set_mouse_face_gc (struct glyph_string *);
891 static int w32_alloc_lighter_color (struct frame *, COLORREF *, double, int);
892 static void w32_setup_relief_color (struct frame *, struct relief *,
893 double, int, COLORREF);
894 static void x_setup_relief_colors (struct glyph_string *);
895 static void x_draw_image_glyph_string (struct glyph_string *);
896 static void x_draw_image_relief (struct glyph_string *);
897 static void x_draw_image_foreground (struct glyph_string *);
898 static void w32_draw_image_foreground_1 (struct glyph_string *, HBITMAP);
899 static void x_clear_glyph_string_rect (struct glyph_string *, int,
900 int, int, int);
901 static void w32_draw_relief_rect (struct frame *, int, int, int, int,
902 int, int, int, int, int, int,
903 RECT *);
904 static void w32_draw_box_rect (struct glyph_string *, int, int, int, int,
905 int, int, int, RECT *);
908 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
909 face. */
911 static void
912 x_set_cursor_gc (struct glyph_string *s)
914 if (s->font == FRAME_FONT (s->f)
915 && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
916 && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
917 && !s->cmp)
918 s->gc = s->f->output_data.w32->cursor_gc;
919 else
921 /* Cursor on non-default face: must merge. */
922 XGCValues xgcv;
923 unsigned long mask;
925 xgcv.background = s->f->output_data.w32->cursor_pixel;
926 xgcv.foreground = s->face->background;
928 /* If the glyph would be invisible, try a different foreground. */
929 if (xgcv.foreground == xgcv.background)
930 xgcv.foreground = s->face->foreground;
931 if (xgcv.foreground == xgcv.background)
932 xgcv.foreground = s->f->output_data.w32->cursor_foreground_pixel;
933 if (xgcv.foreground == xgcv.background)
934 xgcv.foreground = s->face->foreground;
936 /* Make sure the cursor is distinct from text in this face. */
937 if (xgcv.background == s->face->background
938 && xgcv.foreground == s->face->foreground)
940 xgcv.background = s->face->foreground;
941 xgcv.foreground = s->face->background;
944 IF_DEBUG (x_check_font (s->f, s->font));
945 xgcv.font = s->font;
946 mask = GCForeground | GCBackground | GCFont;
948 if (FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc)
949 XChangeGC (NULL, FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc,
950 mask, &xgcv);
951 else
952 FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc
953 = XCreateGC (NULL, s->window, mask, &xgcv);
955 s->gc = FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc;
960 /* Set up S->gc of glyph string S for drawing text in mouse face. */
962 static void
963 x_set_mouse_face_gc (struct glyph_string *s)
965 int face_id;
966 struct face *face;
968 /* What face has to be used last for the mouse face? */
969 face_id = MOUSE_HL_INFO (s->f)->mouse_face_face_id;
970 face = FACE_FROM_ID (s->f, face_id);
971 if (face == NULL)
972 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
974 if (s->first_glyph->type == CHAR_GLYPH)
975 face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch, -1, Qnil);
976 else
977 face_id = FACE_FOR_CHAR (s->f, face, 0, -1, Qnil);
978 s->face = FACE_FROM_ID (s->f, face_id);
979 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
981 /* If font in this face is same as S->font, use it. */
982 if (s->font == s->face->font)
983 s->gc = s->face->gc;
984 else
986 /* Otherwise construct scratch_cursor_gc with values from FACE
987 but font FONT. */
988 XGCValues xgcv;
989 unsigned long mask;
991 xgcv.background = s->face->background;
992 xgcv.foreground = s->face->foreground;
993 IF_DEBUG (x_check_font (s->f, s->font));
994 xgcv.font = s->font;
995 mask = GCForeground | GCBackground | GCFont;
997 if (FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc)
998 XChangeGC (NULL, FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc,
999 mask, &xgcv);
1000 else
1001 FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc
1002 = XCreateGC (NULL, s->window, mask, &xgcv);
1004 s->gc = FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc;
1007 xassert (s->gc != 0);
1011 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1012 Faces to use in the mode line have already been computed when the
1013 matrix was built, so there isn't much to do, here. */
1015 static INLINE void
1016 x_set_mode_line_face_gc (struct glyph_string *s)
1018 s->gc = s->face->gc;
1022 /* Set S->gc of glyph string S for drawing that glyph string. Set
1023 S->stippled_p to a non-zero value if the face of S has a stipple
1024 pattern. */
1026 static INLINE void
1027 x_set_glyph_string_gc (struct glyph_string *s)
1029 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
1031 if (s->hl == DRAW_NORMAL_TEXT)
1033 s->gc = s->face->gc;
1034 s->stippled_p = s->face->stipple != 0;
1036 else if (s->hl == DRAW_INVERSE_VIDEO)
1038 x_set_mode_line_face_gc (s);
1039 s->stippled_p = s->face->stipple != 0;
1041 else if (s->hl == DRAW_CURSOR)
1043 x_set_cursor_gc (s);
1044 s->stippled_p = 0;
1046 else if (s->hl == DRAW_MOUSE_FACE)
1048 x_set_mouse_face_gc (s);
1049 s->stippled_p = s->face->stipple != 0;
1051 else if (s->hl == DRAW_IMAGE_RAISED
1052 || s->hl == DRAW_IMAGE_SUNKEN)
1054 s->gc = s->face->gc;
1055 s->stippled_p = s->face->stipple != 0;
1057 else
1059 s->gc = s->face->gc;
1060 s->stippled_p = s->face->stipple != 0;
1063 /* GC must have been set. */
1064 xassert (s->gc != 0);
1068 /* Set clipping for output of glyph string S. S may be part of a mode
1069 line or menu if we don't have X toolkit support. */
1071 static INLINE void
1072 x_set_glyph_string_clipping (struct glyph_string *s)
1074 RECT *r = s->clip;
1075 int n = get_glyph_string_clip_rects (s, r, 2);
1077 if (n == 1)
1078 w32_set_clip_rectangle (s->hdc, r);
1079 else if (n > 1)
1081 HRGN full_clip, clip1, clip2;
1082 clip1 = CreateRectRgnIndirect (r);
1083 clip2 = CreateRectRgnIndirect (r + 1);
1084 if (CombineRgn (full_clip, clip1, clip2, RGN_OR) != ERROR)
1086 SelectClipRgn (s->hdc, full_clip);
1088 DeleteObject (clip1);
1089 DeleteObject (clip2);
1090 DeleteObject (full_clip);
1092 s->num_clips = n;
1095 /* Set SRC's clipping for output of glyph string DST. This is called
1096 when we are drawing DST's left_overhang or right_overhang only in
1097 the area of SRC. */
1099 static void
1100 x_set_glyph_string_clipping_exactly (struct glyph_string *src,
1101 struct glyph_string *dst)
1103 RECT r;
1105 r.left = src->x;
1106 r.right = r.left + src->width;
1107 r.top = src->y;
1108 r.bottom = r.top + src->height;
1109 dst->clip[0] = r;
1110 dst->num_clips = 1;
1111 w32_set_clip_rectangle (dst->hdc, &r);
1114 /* RIF:
1115 Compute left and right overhang of glyph string S. */
1117 static void
1118 w32_compute_glyph_string_overhangs (struct glyph_string *s)
1120 if (s->cmp == NULL
1121 && s->first_glyph->type == CHAR_GLYPH
1122 && !s->font_not_found_p)
1124 unsigned *code = alloca (sizeof (unsigned) * s->nchars);
1125 struct font *font = s->font;
1126 struct font_metrics metrics;
1127 int i;
1129 for (i = 0; i < s->nchars; i++)
1130 code[i] = s->char2b[i];
1131 font->driver->text_extents (font, code, s->nchars, &metrics);
1132 s->right_overhang = (metrics.rbearing > metrics.width
1133 ? metrics.rbearing - metrics.width : 0);
1134 s->left_overhang = metrics.lbearing < 0 ? -metrics.lbearing : 0;
1136 else if (s->cmp)
1138 s->right_overhang = s->cmp->rbearing - s->cmp->pixel_width;
1139 s->left_overhang = -s->cmp->lbearing;
1143 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1145 static INLINE void
1146 x_clear_glyph_string_rect (struct glyph_string *s,
1147 int x, int y, int w, int h)
1149 int real_x = x;
1150 int real_y = y;
1151 int real_w = w;
1152 int real_h = h;
1153 #if 0
1154 /* Take clipping into account. */
1155 if (s->gc->clip_mask == Rect)
1157 real_x = max (real_x, s->gc->clip_rectangle.left);
1158 real_y = max (real_y, s->gc->clip_rectangle.top);
1159 real_w = min (real_w, s->gc->clip_rectangle.right
1160 - s->gc->clip_rectangle.left);
1161 real_h = min (real_h, s->gc->clip_rectangle.bottom
1162 - s->gc->clip_rectangle.top);
1164 #endif
1165 w32_fill_area (s->f, s->hdc, s->gc->background, real_x, real_y,
1166 real_w, real_h);
1170 /* Draw the background of glyph_string S. If S->background_filled_p
1171 is non-zero don't draw it. FORCE_P non-zero means draw the
1172 background even if it wouldn't be drawn normally. This is used
1173 when a string preceding S draws into the background of S, or S
1174 contains the first component of a composition. */
1176 static void
1177 x_draw_glyph_string_background (struct glyph_string *s, int force_p)
1179 /* Nothing to do if background has already been drawn or if it
1180 shouldn't be drawn in the first place. */
1181 if (!s->background_filled_p)
1183 int box_line_width = max (s->face->box_line_width, 0);
1185 #if 0 /* TODO: stipple */
1186 if (s->stippled_p)
1188 /* Fill background with a stipple pattern. */
1189 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
1190 XFillRectangle (s->display, s->window, s->gc, s->x,
1191 s->y + box_line_width,
1192 s->background_width,
1193 s->height - 2 * box_line_width);
1194 XSetFillStyle (s->display, s->gc, FillSolid);
1195 s->background_filled_p = 1;
1197 else
1198 #endif
1199 if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
1200 || s->font_not_found_p
1201 || s->extends_to_end_of_line_p
1202 || force_p)
1204 x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
1205 s->background_width,
1206 s->height - 2 * box_line_width);
1207 s->background_filled_p = 1;
1213 /* Draw the foreground of glyph string S. */
1215 static void
1216 x_draw_glyph_string_foreground (struct glyph_string *s)
1218 int i, x;
1220 /* If first glyph of S has a left box line, start drawing the text
1221 of S to the right of that box line. */
1222 if (s->face->box != FACE_NO_BOX
1223 && s->first_glyph->left_box_line_p)
1224 x = s->x + eabs (s->face->box_line_width);
1225 else
1226 x = s->x;
1228 SetTextColor (s->hdc, s->gc->foreground);
1229 SetBkColor (s->hdc, s->gc->background);
1230 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1232 /* Draw characters of S as rectangles if S's font could not be
1233 loaded. */
1234 if (s->font_not_found_p)
1236 for (i = 0; i < s->nchars; ++i)
1238 struct glyph *g = s->first_glyph + i;
1240 w32_draw_rectangle (s->hdc, s->gc, x, s->y, g->pixel_width - 1,
1241 s->height - 1);
1242 x += g->pixel_width;
1245 else
1247 struct font *font = s->font;
1248 int boff = font->baseline_offset;
1249 int y;
1250 HFONT old_font;
1252 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1254 if (font->vertical_centering)
1255 boff = VCENTER_BASELINE_OFFSET (font, s->f) - boff;
1257 y = s->ybase - boff;
1258 if (s->for_overlaps
1259 || (s->background_filled_p && s->hl != DRAW_CURSOR))
1260 font->driver->draw (s, 0, s->nchars, x, y, 0);
1261 else
1262 font->driver->draw (s, 0, s->nchars, x, y, 1);
1263 if (s->face->overstrike)
1264 font->driver->draw (s, 0, s->nchars, x + 1, y, 0);
1266 SelectObject (s->hdc, old_font);
1270 /* Draw the foreground of composite glyph string S. */
1272 static void
1273 x_draw_composite_glyph_string_foreground (struct glyph_string *s)
1275 int i, j, x;
1276 struct font *font = s->font;
1278 /* If first glyph of S has a left box line, start drawing the text
1279 of S to the right of that box line. */
1280 if (s->face && s->face->box != FACE_NO_BOX
1281 && s->first_glyph->left_box_line_p)
1282 x = s->x + eabs (s->face->box_line_width);
1283 else
1284 x = s->x;
1286 /* S is a glyph string for a composition. S->cmp_from is the index
1287 of the first character drawn for glyphs of this composition.
1288 S->cmp_from == 0 means we are drawing the very first character of
1289 this composition. */
1291 SetTextColor (s->hdc, s->gc->foreground);
1292 SetBkColor (s->hdc, s->gc->background);
1293 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1295 /* Draw a rectangle for the composition if the font for the very
1296 first character of the composition could not be loaded. */
1297 if (s->font_not_found_p)
1299 if (s->cmp_from == 0)
1300 w32_draw_rectangle (s->hdc, s->gc, x, s->y, s->width - 1,
1301 s->height - 1);
1303 else if (! s->first_glyph->u.cmp.automatic)
1305 int y = s->ybase;
1306 int width = 0;
1307 HFONT old_font;
1309 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1311 for (i = 0, j = s->cmp_from; i < s->nchars; i++, j++)
1312 if (COMPOSITION_GLYPH (s->cmp, j) != '\t')
1314 int xx = x + s->cmp->offsets[j * 2];
1315 int yy = y - s->cmp->offsets[j * 2 + 1];
1317 font->driver->draw (s, j, j + 1, xx, yy, 0);
1318 if (s->face->overstrike)
1319 font->driver->draw (s, j, j + 1, xx + 1, yy, 0);
1321 SelectObject (s->hdc, old_font);
1323 else
1325 Lisp_Object gstring = composition_gstring_from_id (s->cmp_id);
1326 Lisp_Object glyph;
1327 int y = s->ybase;
1328 int width = 0;
1329 HFONT old_font;
1331 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1333 for (i = j = s->cmp_from; i < s->cmp_to; i++)
1335 glyph = LGSTRING_GLYPH (gstring, i);
1336 if (NILP (LGLYPH_ADJUSTMENT (glyph)))
1337 width += LGLYPH_WIDTH (glyph);
1338 else
1340 int xoff, yoff, wadjust;
1342 if (j < i)
1344 font->driver->draw (s, j, i, x, y, 0);
1345 x += width;
1347 xoff = LGLYPH_XOFF (glyph);
1348 yoff = LGLYPH_YOFF (glyph);
1349 wadjust = LGLYPH_WADJUST (glyph);
1350 font->driver->draw (s, i, i + 1, x + xoff, y + yoff, 0);
1351 x += wadjust;
1352 j = i + 1;
1353 width = 0;
1356 if (j < i)
1357 font->driver->draw (s, j, i, x, y, 0);
1359 SelectObject (s->hdc, old_font);
1364 /* Draw the foreground of glyph string S for glyphless characters. */
1366 static void
1367 x_draw_glyphless_glyph_string_foreground (struct glyph_string *s)
1369 struct glyph *glyph = s->first_glyph;
1370 XChar2b char2b[8];
1371 int x, i, j;
1372 int with_background;
1374 /* If first glyph of S has a left box line, start drawing the text
1375 of S to the right of that box line. */
1376 if (s->face->box != FACE_NO_BOX
1377 && s->first_glyph->left_box_line_p)
1378 x = s->x + eabs (s->face->box_line_width);
1379 else
1380 x = s->x;
1382 SetTextColor (s->hdc, s->gc->foreground);
1383 SetBkColor (s->hdc, s->gc->background);
1384 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1386 s->char2b = char2b;
1387 with_background = ! (s->for_overlaps
1388 || (s->background_filled_p && s->hl != DRAW_CURSOR));
1389 for (i = 0; i < s->nchars; i++, glyph++)
1391 char buf[7], *str = NULL;
1392 int len = glyph->u.glyphless.len;
1394 if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_ACRONYM)
1396 if (len > 1
1397 && CHAR_TABLE_P (Vglyphless_char_display)
1398 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display))
1399 >= 1))
1401 Lisp_Object acronym
1402 = (! glyph->u.glyphless.for_no_font
1403 ? CHAR_TABLE_REF (Vglyphless_char_display,
1404 glyph->u.glyphless.ch)
1405 : XCHAR_TABLE (Vglyphless_char_display)->extras[0]);
1406 if (STRINGP (acronym))
1407 str = SSDATA (acronym);
1410 else if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_HEX_CODE)
1412 sprintf ((char *) buf, "%0*X",
1413 glyph->u.glyphless.ch < 0x10000 ? 4 : 6,
1414 glyph->u.glyphless.ch);
1415 str = buf;
1418 if (glyph->u.glyphless.method != GLYPHLESS_DISPLAY_THIN_SPACE)
1419 w32_draw_rectangle (s->hdc, s->gc,
1420 x, s->ybase - glyph->ascent,
1421 glyph->pixel_width - 1,
1422 glyph->ascent + glyph->descent - 1);
1423 if (str)
1425 struct font *font = s->font;
1426 int upper_len = (len + 1) / 2;
1427 unsigned code;
1428 HFONT old_font;
1430 old_font = SelectObject (s->hdc, FONT_HANDLE (font));
1431 /* It is certain that all LEN characters in STR are ASCII. */
1432 for (j = 0; j < len; j++)
1434 code = font->driver->encode_char (font, str[j]);
1435 STORE_XCHAR2B (char2b + j, code >> 8, code & 0xFF);
1437 font->driver->draw (s, 0, upper_len,
1438 x + glyph->slice.glyphless.upper_xoff,
1439 s->ybase + glyph->slice.glyphless.upper_yoff,
1440 with_background);
1441 font->driver->draw (s, upper_len, len,
1442 x + glyph->slice.glyphless.lower_xoff,
1443 s->ybase + glyph->slice.glyphless.lower_yoff,
1444 with_background);
1445 SelectObject (s->hdc, old_font);
1447 x += glyph->pixel_width;
1452 /* Brightness beyond which a color won't have its highlight brightness
1453 boosted.
1455 Nominally, highlight colors for `3d' faces are calculated by
1456 brightening an object's color by a constant scale factor, but this
1457 doesn't yield good results for dark colors, so for colors who's
1458 brightness is less than this value (on a scale of 0-255) have to
1459 use an additional additive factor.
1461 The value here is set so that the default menu-bar/mode-line color
1462 (grey75) will not have its highlights changed at all. */
1463 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1466 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1467 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1468 If this produces the same color as COLOR, try a color where all RGB
1469 values have DELTA added. Return the allocated color in *COLOR.
1470 DISPLAY is the X display, CMAP is the colormap to operate on.
1471 Value is non-zero if successful. */
1473 static int
1474 w32_alloc_lighter_color (struct frame *f, COLORREF *color,
1475 double factor, int delta)
1477 COLORREF new;
1478 long bright;
1480 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1481 delta /= 256;
1483 /* Change RGB values by specified FACTOR. Avoid overflow! */
1484 xassert (factor >= 0);
1485 new = PALETTERGB (min (0xff, factor * GetRValue (*color)),
1486 min (0xff, factor * GetGValue (*color)),
1487 min (0xff, factor * GetBValue (*color)));
1489 /* Calculate brightness of COLOR. */
1490 bright = (2 * GetRValue (*color) + 3 * GetGValue (*color)
1491 + GetBValue (*color)) / 6;
1493 /* We only boost colors that are darker than
1494 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1495 if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
1496 /* Make an additive adjustment to NEW, because it's dark enough so
1497 that scaling by FACTOR alone isn't enough. */
1499 /* How far below the limit this color is (0 - 1, 1 being darker). */
1500 double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
1501 /* The additive adjustment. */
1502 int min_delta = delta * dimness * factor / 2;
1504 if (factor < 1)
1505 new = PALETTERGB (max (0, min (0xff, min_delta - GetRValue (*color))),
1506 max (0, min (0xff, min_delta - GetGValue (*color))),
1507 max (0, min (0xff, min_delta - GetBValue (*color))));
1508 else
1509 new = PALETTERGB (max (0, min (0xff, min_delta + GetRValue (*color))),
1510 max (0, min (0xff, min_delta + GetGValue (*color))),
1511 max (0, min (0xff, min_delta + GetBValue (*color))));
1514 if (new == *color)
1515 new = PALETTERGB (max (0, min (0xff, delta + GetRValue (*color))),
1516 max (0, min (0xff, delta + GetGValue (*color))),
1517 max (0, min (0xff, delta + GetBValue (*color))));
1519 /* TODO: Map to palette and retry with delta if same? */
1520 /* TODO: Free colors (if using palette)? */
1522 if (new == *color)
1523 return 0;
1525 *color = new;
1527 return 1;
1530 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1531 colors in COLORS. On W32, we no longer try to map colors to
1532 a palette. */
1533 void
1534 x_query_colors (struct frame *f, XColor *colors, int ncolors)
1536 int i;
1538 for (i = 0; i < ncolors; i++)
1540 DWORD pixel = colors[i].pixel;
1541 /* Convert to a 16 bit value in range 0 - 0xffff. */
1542 colors[i].red = GetRValue (pixel) * 257;
1543 colors[i].green = GetGValue (pixel) * 257;
1544 colors[i].blue = GetBValue (pixel) * 257;
1548 void
1549 x_query_color (struct frame *f, XColor *color)
1551 x_query_colors (f, color, 1);
1555 /* Set up the foreground color for drawing relief lines of glyph
1556 string S. RELIEF is a pointer to a struct relief containing the GC
1557 with which lines will be drawn. Use a color that is FACTOR or
1558 DELTA lighter or darker than the relief's background which is found
1559 in S->f->output_data.x->relief_background. If such a color cannot
1560 be allocated, use DEFAULT_PIXEL, instead. */
1562 static void
1563 w32_setup_relief_color (struct frame *f, struct relief *relief, double factor,
1564 int delta, COLORREF default_pixel)
1566 XGCValues xgcv;
1567 struct w32_output *di = f->output_data.w32;
1568 unsigned long mask = GCForeground;
1569 COLORREF pixel;
1570 COLORREF background = di->relief_background;
1571 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
1573 /* TODO: Free colors (if using palette)? */
1575 /* Allocate new color. */
1576 xgcv.foreground = default_pixel;
1577 pixel = background;
1578 if (w32_alloc_lighter_color (f, &pixel, factor, delta))
1580 relief->allocated_p = 1;
1581 xgcv.foreground = relief->pixel = pixel;
1584 if (relief->gc == 0)
1586 #if 0 /* TODO: stipple */
1587 xgcv.stipple = dpyinfo->gray;
1588 mask |= GCStipple;
1589 #endif
1590 relief->gc = XCreateGC (NULL, FRAME_W32_WINDOW (f), mask, &xgcv);
1592 else
1593 XChangeGC (NULL, relief->gc, mask, &xgcv);
1597 /* Set up colors for the relief lines around glyph string S. */
1599 static void
1600 x_setup_relief_colors (struct glyph_string *s)
1602 struct w32_output *di = s->f->output_data.w32;
1603 COLORREF color;
1605 if (s->face->use_box_color_for_shadows_p)
1606 color = s->face->box_color;
1607 else if (s->first_glyph->type == IMAGE_GLYPH
1608 && s->img->pixmap
1609 && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
1610 color = IMAGE_BACKGROUND (s->img, s->f, 0);
1611 else
1612 color = s->gc->background;
1614 if (di->white_relief.gc == 0
1615 || color != di->relief_background)
1617 di->relief_background = color;
1618 w32_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
1619 WHITE_PIX_DEFAULT (s->f));
1620 w32_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
1621 BLACK_PIX_DEFAULT (s->f));
1626 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1627 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1628 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1629 relief. LEFT_P non-zero means draw a relief on the left side of
1630 the rectangle. RIGHT_P non-zero means draw a relief on the right
1631 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1632 when drawing. */
1634 static void
1635 w32_draw_relief_rect (struct frame *f,
1636 int left_x, int top_y, int right_x, int bottom_y, int width,
1637 int raised_p, int top_p, int bot_p, int left_p, int right_p,
1638 RECT *clip_rect)
1640 int i;
1641 XGCValues gc;
1642 HDC hdc = get_frame_dc (f);
1644 if (raised_p)
1645 gc.foreground = f->output_data.w32->white_relief.gc->foreground;
1646 else
1647 gc.foreground = f->output_data.w32->black_relief.gc->foreground;
1649 w32_set_clip_rectangle (hdc, clip_rect);
1651 /* Top. */
1652 if (top_p)
1653 for (i = 0; i < width; ++i)
1654 w32_fill_area (f, hdc, gc.foreground,
1655 left_x + i * left_p, top_y + i,
1656 right_x - left_x - i * (left_p + right_p ) + 1, 1);
1658 /* Left. */
1659 if (left_p)
1660 for (i = 0; i < width; ++i)
1661 w32_fill_area (f, hdc, gc.foreground,
1662 left_x + i, top_y + i, 1,
1663 bottom_y - top_y - 2 * i + 1);
1665 if (raised_p)
1666 gc.foreground = f->output_data.w32->black_relief.gc->foreground;
1667 else
1668 gc.foreground = f->output_data.w32->white_relief.gc->foreground;
1670 /* Bottom. */
1671 if (bot_p)
1672 for (i = 0; i < width; ++i)
1673 w32_fill_area (f, hdc, gc.foreground,
1674 left_x + i * left_p, bottom_y - i,
1675 right_x - left_x - i * (left_p + right_p) + 1, 1);
1677 /* Right. */
1678 if (right_p)
1679 for (i = 0; i < width; ++i)
1680 w32_fill_area (f, hdc, gc.foreground,
1681 right_x - i, top_y + i + 1, 1,
1682 bottom_y - top_y - 2 * i - 1);
1684 w32_set_clip_rectangle (hdc, NULL);
1686 release_frame_dc (f, hdc);
1690 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1691 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1692 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1693 left side of the rectangle. RIGHT_P non-zero means draw a line
1694 on the right side of the rectangle. CLIP_RECT is the clipping
1695 rectangle to use when drawing. */
1697 static void
1698 w32_draw_box_rect (struct glyph_string *s,
1699 int left_x, int top_y, int right_x, int bottom_y, int width,
1700 int left_p, int right_p, RECT *clip_rect)
1702 w32_set_clip_rectangle (s->hdc, clip_rect);
1704 /* Top. */
1705 w32_fill_area (s->f, s->hdc, s->face->box_color,
1706 left_x, top_y, right_x - left_x + 1, width);
1708 /* Left. */
1709 if (left_p)
1711 w32_fill_area (s->f, s->hdc, s->face->box_color,
1712 left_x, top_y, width, bottom_y - top_y + 1);
1715 /* Bottom. */
1716 w32_fill_area (s->f, s->hdc, s->face->box_color,
1717 left_x, bottom_y - width + 1, right_x - left_x + 1, width);
1719 /* Right. */
1720 if (right_p)
1722 w32_fill_area (s->f, s->hdc, s->face->box_color,
1723 right_x - width + 1, top_y, width, bottom_y - top_y + 1);
1726 w32_set_clip_rectangle (s->hdc, NULL);
1730 /* Draw a box around glyph string S. */
1732 static void
1733 x_draw_glyph_string_box (struct glyph_string *s)
1735 int width, left_x, right_x, top_y, bottom_y, last_x, raised_p;
1736 int left_p, right_p;
1737 struct glyph *last_glyph;
1738 RECT clip_rect;
1740 last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
1741 ? WINDOW_RIGHT_EDGE_X (s->w)
1742 : window_box_right (s->w, s->area));
1744 /* The glyph that may have a right box line. */
1745 last_glyph = (s->cmp || s->img
1746 ? s->first_glyph
1747 : s->first_glyph + s->nchars - 1);
1749 width = eabs (s->face->box_line_width);
1750 raised_p = s->face->box == FACE_RAISED_BOX;
1751 left_x = s->x;
1752 right_x = ((s->row->full_width_p && s->extends_to_end_of_line_p
1753 ? last_x - 1
1754 : min (last_x, s->x + s->background_width) - 1));
1755 top_y = s->y;
1756 bottom_y = top_y + s->height - 1;
1758 left_p = (s->first_glyph->left_box_line_p
1759 || (s->hl == DRAW_MOUSE_FACE
1760 && (s->prev == NULL
1761 || s->prev->hl != s->hl)));
1762 right_p = (last_glyph->right_box_line_p
1763 || (s->hl == DRAW_MOUSE_FACE
1764 && (s->next == NULL
1765 || s->next->hl != s->hl)));
1767 get_glyph_string_clip_rect (s, &clip_rect);
1769 if (s->face->box == FACE_SIMPLE_BOX)
1770 w32_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
1771 left_p, right_p, &clip_rect);
1772 else
1774 x_setup_relief_colors (s);
1775 w32_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
1776 width, raised_p, 1, 1, left_p, right_p, &clip_rect);
1781 /* Draw foreground of image glyph string S. */
1783 static void
1784 x_draw_image_foreground (struct glyph_string *s)
1786 int x = s->x;
1787 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
1789 /* If first glyph of S has a left box line, start drawing it to the
1790 right of that line. */
1791 if (s->face->box != FACE_NO_BOX
1792 && s->first_glyph->left_box_line_p
1793 && s->slice.x == 0)
1794 x += eabs (s->face->box_line_width);
1796 /* If there is a margin around the image, adjust x- and y-position
1797 by that margin. */
1798 if (s->slice.x == 0)
1799 x += s->img->hmargin;
1800 if (s->slice.y == 0)
1801 y += s->img->vmargin;
1803 SaveDC (s->hdc);
1805 if (s->img->pixmap)
1807 HDC compat_hdc = CreateCompatibleDC (s->hdc);
1808 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
1809 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
1810 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
1811 SetBkColor (compat_hdc, RGB (255, 255, 255));
1812 SetTextColor (s->hdc, RGB (0, 0, 0));
1813 x_set_glyph_string_clipping (s);
1815 if (s->img->mask)
1817 HDC mask_dc = CreateCompatibleDC (s->hdc);
1818 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask);
1820 SetTextColor (s->hdc, RGB (255, 255, 255));
1821 SetBkColor (s->hdc, RGB (0, 0, 0));
1823 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1824 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
1825 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1826 mask_dc, s->slice.x, s->slice.y, SRCAND);
1827 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1828 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
1830 SelectObject (mask_dc, mask_orig_obj);
1831 DeleteDC (mask_dc);
1833 else
1835 SetTextColor (s->hdc, s->gc->foreground);
1836 SetBkColor (s->hdc, s->gc->background);
1838 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
1839 compat_hdc, s->slice.x, s->slice.y, SRCCOPY);
1841 /* When the image has a mask, we can expect that at
1842 least part of a mouse highlight or a block cursor will
1843 be visible. If the image doesn't have a mask, make
1844 a block cursor visible by drawing a rectangle around
1845 the image. I believe it's looking better if we do
1846 nothing here for mouse-face. */
1847 if (s->hl == DRAW_CURSOR)
1849 int r = s->img->relief;
1850 if (r < 0) r = -r;
1851 w32_draw_rectangle (s->hdc, s->gc, x - r, y - r ,
1852 s->slice.width + r*2 - 1,
1853 s->slice.height + r*2 - 1);
1857 w32_set_clip_rectangle (s->hdc, NULL);
1858 SelectObject (s->hdc, orig_brush);
1859 DeleteObject (fg_brush);
1860 SelectObject (compat_hdc, orig_obj);
1861 DeleteDC (compat_hdc);
1863 else
1864 w32_draw_rectangle (s->hdc, s->gc, x, y,
1865 s->slice.width - 1, s->slice.height - 1);
1867 RestoreDC (s->hdc ,-1);
1871 /* Draw a relief around the image glyph string S. */
1873 static void
1874 x_draw_image_relief (struct glyph_string *s)
1876 int x0, y0, x1, y1, thick, raised_p;
1877 RECT r;
1878 int x = s->x;
1879 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
1881 /* If first glyph of S has a left box line, start drawing it to the
1882 right of that line. */
1883 if (s->face->box != FACE_NO_BOX
1884 && s->first_glyph->left_box_line_p
1885 && s->slice.x == 0)
1886 x += eabs (s->face->box_line_width);
1888 /* If there is a margin around the image, adjust x- and y-position
1889 by that margin. */
1890 if (s->slice.x == 0)
1891 x += s->img->hmargin;
1892 if (s->slice.y == 0)
1893 y += s->img->vmargin;
1895 if (s->hl == DRAW_IMAGE_SUNKEN
1896 || s->hl == DRAW_IMAGE_RAISED)
1898 thick = tool_bar_button_relief >= 0 ? tool_bar_button_relief : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
1899 raised_p = s->hl == DRAW_IMAGE_RAISED;
1901 else
1903 thick = eabs (s->img->relief);
1904 raised_p = s->img->relief > 0;
1907 x0 = x - thick;
1908 y0 = y - thick;
1909 x1 = x + s->slice.width + thick - 1;
1910 y1 = y + s->slice.height + thick - 1;
1912 x_setup_relief_colors (s);
1913 get_glyph_string_clip_rect (s, &r);
1914 w32_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p,
1915 s->slice.y == 0,
1916 s->slice.y + s->slice.height == s->img->height,
1917 s->slice.x == 0,
1918 s->slice.x + s->slice.width == s->img->width,
1919 &r);
1923 /* Draw the foreground of image glyph string S to PIXMAP. */
1925 static void
1926 w32_draw_image_foreground_1 (struct glyph_string *s, HBITMAP pixmap)
1928 HDC hdc = CreateCompatibleDC (s->hdc);
1929 HGDIOBJ orig_hdc_obj = SelectObject (hdc, pixmap);
1930 int x = 0;
1931 int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
1933 /* If first glyph of S has a left box line, start drawing it to the
1934 right of that line. */
1935 if (s->face->box != FACE_NO_BOX
1936 && s->first_glyph->left_box_line_p
1937 && s->slice.x == 0)
1938 x += eabs (s->face->box_line_width);
1940 /* If there is a margin around the image, adjust x- and y-position
1941 by that margin. */
1942 if (s->slice.x == 0)
1943 x += s->img->hmargin;
1944 if (s->slice.y == 0)
1945 y += s->img->vmargin;
1947 if (s->img->pixmap)
1949 HDC compat_hdc = CreateCompatibleDC (hdc);
1950 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
1951 HBRUSH orig_brush = SelectObject (hdc, fg_brush);
1952 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
1954 if (s->img->mask)
1956 HDC mask_dc = CreateCompatibleDC (hdc);
1957 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask);
1959 SetTextColor (hdc, RGB (0, 0, 0));
1960 SetBkColor (hdc, RGB (255, 255, 255));
1961 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
1962 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
1963 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
1964 mask_dc, s->slice.x, s->slice.y, SRCAND);
1965 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
1966 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
1968 SelectObject (mask_dc, mask_orig_obj);
1969 DeleteDC (mask_dc);
1971 else
1973 SetTextColor (hdc, s->gc->foreground);
1974 SetBkColor (hdc, s->gc->background);
1976 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
1977 compat_hdc, s->slice.x, s->slice.y, SRCCOPY);
1979 /* When the image has a mask, we can expect that at
1980 least part of a mouse highlight or a block cursor will
1981 be visible. If the image doesn't have a mask, make
1982 a block cursor visible by drawing a rectangle around
1983 the image. I believe it's looking better if we do
1984 nothing here for mouse-face. */
1985 if (s->hl == DRAW_CURSOR)
1987 int r = s->img->relief;
1988 if (r < 0) r = -r;
1989 w32_draw_rectangle (hdc, s->gc, x - r, y - r,
1990 s->slice.width + r*2 - 1,
1991 s->slice.height + r*2 - 1);
1995 SelectObject (hdc, orig_brush);
1996 DeleteObject (fg_brush);
1997 SelectObject (compat_hdc, orig_obj);
1998 DeleteDC (compat_hdc);
2000 else
2001 w32_draw_rectangle (hdc, s->gc, x, y,
2002 s->slice.width - 1, s->slice.height - 1);
2004 SelectObject (hdc, orig_hdc_obj);
2005 DeleteDC (hdc);
2009 /* Draw part of the background of glyph string S. X, Y, W, and H
2010 give the rectangle to draw. */
2012 static void
2013 x_draw_glyph_string_bg_rect (struct glyph_string *s, int x, int y, int w, int h)
2015 #if 0 /* TODO: stipple */
2016 if (s->stippled_p)
2018 /* Fill background with a stipple pattern. */
2019 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2020 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
2021 XSetFillStyle (s->display, s->gc, FillSolid);
2023 else
2024 #endif
2025 x_clear_glyph_string_rect (s, x, y, w, h);
2029 /* Draw image glyph string S.
2031 s->y
2032 s->x +-------------------------
2033 | s->face->box
2035 | +-------------------------
2036 | | s->img->vmargin
2038 | | +-------------------
2039 | | | the image
2043 static void
2044 x_draw_image_glyph_string (struct glyph_string *s)
2046 int x, y;
2047 int box_line_hwidth = eabs (s->face->box_line_width);
2048 int box_line_vwidth = max (s->face->box_line_width, 0);
2049 int height;
2050 HBITMAP pixmap = 0;
2052 height = s->height - 2 * box_line_vwidth;
2054 /* Fill background with face under the image. Do it only if row is
2055 taller than image or if image has a clip mask to reduce
2056 flickering. */
2057 s->stippled_p = s->face->stipple != 0;
2058 if (height > s->slice.height
2059 || s->img->hmargin
2060 || s->img->vmargin
2061 || s->img->mask
2062 || s->img->pixmap == 0
2063 || s->width != s->background_width)
2065 x = s->x;
2066 if (s->first_glyph->left_box_line_p
2067 && s->slice.x == 0)
2068 x += box_line_hwidth;
2070 y = s->y;
2071 if (s->slice.y == 0)
2072 y += box_line_vwidth;
2074 #if 0 /* TODO: figure out if we need to do this on Windows. */
2075 if (s->img->mask)
2077 /* Create a pixmap as large as the glyph string. Fill it
2078 with the background color. Copy the image to it, using
2079 its mask. Copy the temporary pixmap to the display. */
2080 Screen *screen = FRAME_X_SCREEN (s->f);
2081 int depth = DefaultDepthOfScreen (screen);
2083 /* Create a pixmap as large as the glyph string. */
2084 pixmap = XCreatePixmap (s->display, s->window,
2085 s->background_width,
2086 s->height, depth);
2088 /* Don't clip in the following because we're working on the
2089 pixmap. */
2090 XSetClipMask (s->display, s->gc, None);
2092 /* Fill the pixmap with the background color/stipple. */
2093 if (s->stippled_p)
2095 /* Fill background with a stipple pattern. */
2096 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2097 XFillRectangle (s->display, pixmap, s->gc,
2098 0, 0, s->background_width, s->height);
2099 XSetFillStyle (s->display, s->gc, FillSolid);
2101 else
2103 XGCValues xgcv;
2104 XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
2105 &xgcv);
2106 XSetForeground (s->display, s->gc, xgcv.background);
2107 XFillRectangle (s->display, pixmap, s->gc,
2108 0, 0, s->background_width, s->height);
2109 XSetForeground (s->display, s->gc, xgcv.foreground);
2112 else
2113 #endif
2114 x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
2116 s->background_filled_p = 1;
2119 /* Draw the foreground. */
2120 if (pixmap != 0)
2122 w32_draw_image_foreground_1 (s, pixmap);
2123 x_set_glyph_string_clipping (s);
2125 HDC compat_hdc = CreateCompatibleDC (s->hdc);
2126 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
2127 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
2128 HGDIOBJ orig_obj = SelectObject (compat_hdc, pixmap);
2130 SetTextColor (s->hdc, s->gc->foreground);
2131 SetBkColor (s->hdc, s->gc->background);
2132 BitBlt (s->hdc, s->x, s->y, s->background_width, s->height,
2133 compat_hdc, 0, 0, SRCCOPY);
2135 SelectObject (s->hdc, orig_brush);
2136 DeleteObject (fg_brush);
2137 SelectObject (compat_hdc, orig_obj);
2138 DeleteDC (compat_hdc);
2140 DeleteObject (pixmap);
2141 pixmap = 0;
2143 else
2144 x_draw_image_foreground (s);
2146 /* If we must draw a relief around the image, do it. */
2147 if (s->img->relief
2148 || s->hl == DRAW_IMAGE_RAISED
2149 || s->hl == DRAW_IMAGE_SUNKEN)
2150 x_draw_image_relief (s);
2154 /* Draw stretch glyph string S. */
2156 static void
2157 x_draw_stretch_glyph_string (struct glyph_string *s)
2159 xassert (s->first_glyph->type == STRETCH_GLYPH);
2161 if (s->hl == DRAW_CURSOR
2162 && !x_stretch_cursor_p)
2164 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2165 wide as the stretch glyph. */
2166 int width, background_width = s->background_width;
2167 int x = s->x;
2169 if (!s->row->reversed_p)
2171 int left_x = window_box_left_offset (s->w, TEXT_AREA);
2173 if (x < left_x)
2175 background_width -= left_x - x;
2176 x = left_x;
2179 else
2181 /* In R2L rows, draw the cursor on the right edge of the
2182 stretch glyph. */
2183 int right_x = window_box_right_offset (s->w, TEXT_AREA);
2185 if (x + background_width > right_x)
2186 background_width -= x - right_x;
2187 x += background_width;
2189 width = min (FRAME_COLUMN_WIDTH (s->f), background_width);
2190 if (s->row->reversed_p)
2191 x -= width;
2193 /* Draw cursor. */
2194 x_draw_glyph_string_bg_rect (s, x, s->y, width, s->height);
2196 /* Clear rest using the GC of the original non-cursor face. */
2197 if (width < background_width)
2199 XGCValues *gc = s->face->gc;
2200 int y = s->y;
2201 int w = background_width - width, h = s->height;
2202 RECT r;
2203 HDC hdc = s->hdc;
2205 if (!s->row->reversed_p)
2206 x += width;
2207 else
2208 x = s->x;
2209 if (s->row->mouse_face_p
2210 && cursor_in_mouse_face_p (s->w))
2212 x_set_mouse_face_gc (s);
2213 gc = s->gc;
2215 else
2216 gc = s->face->gc;
2218 get_glyph_string_clip_rect (s, &r);
2219 w32_set_clip_rectangle (hdc, &r);
2221 #if 0 /* TODO: stipple */
2222 if (s->face->stipple)
2224 /* Fill background with a stipple pattern. */
2225 XSetFillStyle (s->display, gc, FillOpaqueStippled);
2226 XFillRectangle (s->display, s->window, gc, x, y, w, h);
2227 XSetFillStyle (s->display, gc, FillSolid);
2229 else
2230 #endif
2232 w32_fill_area (s->f, s->hdc, gc->background, x, y, w, h);
2236 else if (!s->background_filled_p)
2238 int background_width = s->background_width;
2239 int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
2241 /* Don't draw into left margin, fringe or scrollbar area
2242 except for header line and mode line. */
2243 if (x < left_x && !s->row->mode_line_p)
2245 background_width -= left_x - x;
2246 x = left_x;
2248 if (background_width > 0)
2249 x_draw_glyph_string_bg_rect (s, x, s->y, background_width, s->height);
2252 s->background_filled_p = 1;
2256 /* Draw glyph string S. */
2258 static void
2259 x_draw_glyph_string (struct glyph_string *s)
2261 int relief_drawn_p = 0;
2263 /* If S draws into the background of its successor, draw the
2264 background of the successor first so that S can draw into it.
2265 This makes S->next use XDrawString instead of XDrawImageString. */
2266 if (s->next && s->right_overhang && !s->for_overlaps)
2268 int width;
2269 struct glyph_string *next;
2270 for (width = 0, next = s->next;
2271 next && width < s->right_overhang;
2272 width += next->width, next = next->next)
2273 if (next->first_glyph->type != IMAGE_GLYPH)
2275 x_set_glyph_string_gc (next);
2276 x_set_glyph_string_clipping (next);
2277 if (next->first_glyph->type == STRETCH_GLYPH)
2278 x_draw_stretch_glyph_string (next);
2279 else
2280 x_draw_glyph_string_background (next, 1);
2281 next->num_clips = 0;
2285 /* Set up S->gc, set clipping and draw S. */
2286 x_set_glyph_string_gc (s);
2288 /* Draw relief (if any) in advance for char/composition so that the
2289 glyph string can be drawn over it. */
2290 if (!s->for_overlaps
2291 && s->face->box != FACE_NO_BOX
2292 && (s->first_glyph->type == CHAR_GLYPH
2293 || s->first_glyph->type == COMPOSITE_GLYPH))
2296 x_set_glyph_string_clipping (s);
2297 x_draw_glyph_string_background (s, 1);
2298 x_draw_glyph_string_box (s);
2299 x_set_glyph_string_clipping (s);
2300 relief_drawn_p = 1;
2302 else if (!s->clip_head /* draw_glyphs didn't specify a clip mask. */
2303 && !s->clip_tail
2304 && ((s->prev && s->prev->hl != s->hl && s->left_overhang)
2305 || (s->next && s->next->hl != s->hl && s->right_overhang)))
2306 /* We must clip just this glyph. left_overhang part has already
2307 drawn when s->prev was drawn, and right_overhang part will be
2308 drawn later when s->next is drawn. */
2309 x_set_glyph_string_clipping_exactly (s, s);
2310 else
2311 x_set_glyph_string_clipping (s);
2313 switch (s->first_glyph->type)
2315 case IMAGE_GLYPH:
2316 x_draw_image_glyph_string (s);
2317 break;
2319 case STRETCH_GLYPH:
2320 x_draw_stretch_glyph_string (s);
2321 break;
2323 case CHAR_GLYPH:
2324 if (s->for_overlaps)
2325 s->background_filled_p = 1;
2326 else
2327 x_draw_glyph_string_background (s, 0);
2328 x_draw_glyph_string_foreground (s);
2329 break;
2331 case COMPOSITE_GLYPH:
2332 if (s->for_overlaps || (s->cmp_from > 0
2333 && ! s->first_glyph->u.cmp.automatic))
2334 s->background_filled_p = 1;
2335 else
2336 x_draw_glyph_string_background (s, 1);
2337 x_draw_composite_glyph_string_foreground (s);
2338 break;
2340 case GLYPHLESS_GLYPH:
2341 if (s->for_overlaps)
2342 s->background_filled_p = 1;
2343 else
2344 x_draw_glyph_string_background (s, 0);
2345 x_draw_glyphless_glyph_string_foreground (s);
2346 break;
2348 default:
2349 abort ();
2352 if (!s->for_overlaps)
2354 /* Draw underline. */
2355 if (s->face->underline_p)
2357 unsigned long thickness, position;
2358 int y;
2360 if (s->prev && s->prev->face->underline_p)
2362 /* We use the same underline style as the previous one. */
2363 thickness = s->prev->underline_thickness;
2364 position = s->prev->underline_position;
2366 else
2368 /* Get the underline thickness. Default is 1 pixel. */
2369 if (s->font && s->font->underline_thickness > 0)
2370 thickness = s->font->underline_thickness;
2371 else
2372 thickness = 1;
2373 if (x_underline_at_descent_line)
2374 position = (s->height - thickness) - (s->ybase - s->y);
2375 else
2377 /* Get the underline position. This is the recommended
2378 vertical offset in pixels from the baseline to the top of
2379 the underline. This is a signed value according to the
2380 specs, and its default is
2382 ROUND ((maximum_descent) / 2), with
2383 ROUND (x) = floor (x + 0.5) */
2385 if (x_use_underline_position_properties
2386 && s->font && s->font->underline_position >= 0)
2387 position = s->font->underline_position;
2388 else if (s->font)
2389 position = (s->font->descent + 1) / 2;
2391 position = max (position, underline_minimum_offset);
2393 /* Check the sanity of thickness and position. We should
2394 avoid drawing underline out of the current line area. */
2395 if (s->y + s->height <= s->ybase + position)
2396 position = (s->height - 1) - (s->ybase - s->y);
2397 if (s->y + s->height < s->ybase + position + thickness)
2398 thickness = (s->y + s->height) - (s->ybase + position);
2399 s->underline_thickness = thickness;
2400 s->underline_position =position;
2401 y = s->ybase + position;
2402 if (s->face->underline_defaulted_p)
2404 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
2405 y, s->width, 1);
2407 else
2409 w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x,
2410 y, s->width, 1);
2413 /* Draw overline. */
2414 if (s->face->overline_p)
2416 unsigned long dy = 0, h = 1;
2418 if (s->face->overline_color_defaulted_p)
2420 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
2421 s->y + dy, s->width, h);
2423 else
2425 w32_fill_area (s->f, s->hdc, s->face->overline_color, s->x,
2426 s->y + dy, s->width, h);
2430 /* Draw strike-through. */
2431 if (s->face->strike_through_p
2432 && !FONT_TEXTMETRIC (s->font).tmStruckOut)
2434 unsigned long h = 1;
2435 unsigned long dy = (s->height - h) / 2;
2437 if (s->face->strike_through_color_defaulted_p)
2439 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x, s->y + dy,
2440 s->width, h);
2442 else
2444 w32_fill_area (s->f, s->hdc, s->face->strike_through_color, s->x,
2445 s->y + dy, s->width, h);
2449 /* Draw relief if not yet drawn. */
2450 if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
2451 x_draw_glyph_string_box (s);
2453 if (s->prev)
2455 struct glyph_string *prev;
2457 for (prev = s->prev; prev; prev = prev->prev)
2458 if (prev->hl != s->hl
2459 && prev->x + prev->width + prev->right_overhang > s->x)
2461 /* As prev was drawn while clipped to its own area, we
2462 must draw the right_overhang part using s->hl now. */
2463 enum draw_glyphs_face save = prev->hl;
2465 prev->hl = s->hl;
2466 x_set_glyph_string_gc (prev);
2467 x_set_glyph_string_clipping_exactly (s, prev);
2468 if (prev->first_glyph->type == CHAR_GLYPH)
2469 x_draw_glyph_string_foreground (prev);
2470 else
2471 x_draw_composite_glyph_string_foreground (prev);
2472 w32_set_clip_rectangle (prev->hdc, NULL);
2473 prev->hl = save;
2474 prev->num_clips = 0;
2478 if (s->next)
2480 struct glyph_string *next;
2482 for (next = s->next; next; next = next->next)
2483 if (next->hl != s->hl
2484 && next->x - next->left_overhang < s->x + s->width)
2486 /* As next will be drawn while clipped to its own area,
2487 we must draw the left_overhang part using s->hl now. */
2488 enum draw_glyphs_face save = next->hl;
2490 next->hl = s->hl;
2491 x_set_glyph_string_gc (next);
2492 x_set_glyph_string_clipping_exactly (s, next);
2493 if (next->first_glyph->type == CHAR_GLYPH)
2494 x_draw_glyph_string_foreground (next);
2495 else
2496 x_draw_composite_glyph_string_foreground (next);
2497 w32_set_clip_rectangle (next->hdc, NULL);
2498 next->hl = save;
2499 next->num_clips = 0;
2504 /* Reset clipping. */
2505 w32_set_clip_rectangle (s->hdc, NULL);
2506 s->num_clips = 0;
2510 /* Shift display to make room for inserted glyphs. */
2512 void
2513 w32_shift_glyphs_for_insert (struct frame *f, int x, int y,
2514 int width, int height, int shift_by)
2516 HDC hdc;
2518 hdc = get_frame_dc (f);
2519 BitBlt (hdc, x + shift_by, y, width, height,
2520 hdc, x, y, SRCCOPY);
2522 release_frame_dc (f, hdc);
2526 /* Delete N glyphs at the nominal cursor position. Not implemented
2527 for X frames. */
2529 static void
2530 x_delete_glyphs (struct frame *f, register int n)
2532 if (! FRAME_W32_P (f))
2533 return;
2535 abort ();
2539 /* Clear entire frame. If updating_frame is non-null, clear that
2540 frame. Otherwise clear the selected frame. */
2542 static void
2543 x_clear_frame (struct frame *f)
2545 if (! FRAME_W32_P (f))
2546 return;
2548 /* Clearing the frame will erase any cursor, so mark them all as no
2549 longer visible. */
2550 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
2551 output_cursor.hpos = output_cursor.vpos = 0;
2552 output_cursor.x = -1;
2554 /* We don't set the output cursor here because there will always
2555 follow an explicit cursor_to. */
2556 BLOCK_INPUT;
2558 w32_clear_window (f);
2560 /* We have to clear the scroll bars, too. If we have changed
2561 colors or something like that, then they should be notified. */
2562 x_scroll_bar_clear (f);
2564 UNBLOCK_INPUT;
2568 /* Make audible bell. */
2570 static void
2571 w32_ring_bell (struct frame *f)
2573 BLOCK_INPUT;
2575 if (FRAME_W32_P (f) && visible_bell)
2577 int i;
2578 HWND hwnd = FRAME_W32_WINDOW (f);
2580 for (i = 0; i < 5; i++)
2582 FlashWindow (hwnd, TRUE);
2583 Sleep (10);
2585 FlashWindow (hwnd, FALSE);
2587 else
2588 w32_sys_ring_bell (f);
2590 UNBLOCK_INPUT;
2594 /* Specify how many text lines, from the top of the window,
2595 should be affected by insert-lines and delete-lines operations.
2596 This, and those operations, are used only within an update
2597 that is bounded by calls to x_update_begin and x_update_end. */
2599 static void
2600 w32_set_terminal_window (struct frame *f, int n)
2602 /* This function intentionally left blank. */
2606 /***********************************************************************
2607 Line Dance
2608 ***********************************************************************/
2610 /* Perform an insert-lines or delete-lines operation, inserting N
2611 lines or deleting -N lines at vertical position VPOS. */
2613 static void
2614 x_ins_del_lines (struct frame *f, int vpos, int n)
2616 if (! FRAME_W32_P (f))
2617 return;
2619 abort ();
2623 /* Scroll part of the display as described by RUN. */
2625 static void
2626 x_scroll_run (struct window *w, struct run *run)
2628 struct frame *f = XFRAME (w->frame);
2629 int x, y, width, height, from_y, to_y, bottom_y;
2630 HWND hwnd = FRAME_W32_WINDOW (f);
2631 HRGN expect_dirty;
2633 /* Get frame-relative bounding box of the text display area of W,
2634 without mode lines. Include in this box the left and right
2635 fringes of W. */
2636 window_box (w, -1, &x, &y, &width, &height);
2638 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
2639 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
2640 bottom_y = y + height;
2642 if (to_y < from_y)
2644 /* Scrolling up. Make sure we don't copy part of the mode
2645 line at the bottom. */
2646 if (from_y + run->height > bottom_y)
2647 height = bottom_y - from_y;
2648 else
2649 height = run->height;
2650 expect_dirty = CreateRectRgn (x, y + height, x + width, bottom_y);
2652 else
2654 /* Scolling down. Make sure we don't copy over the mode line.
2655 at the bottom. */
2656 if (to_y + run->height > bottom_y)
2657 height = bottom_y - to_y;
2658 else
2659 height = run->height;
2660 expect_dirty = CreateRectRgn (x, y, x + width, to_y);
2663 BLOCK_INPUT;
2665 /* Cursor off. Will be switched on again in x_update_window_end. */
2666 updated_window = w;
2667 x_clear_cursor (w);
2670 RECT from;
2671 RECT to;
2672 HRGN dirty = CreateRectRgn (0, 0, 0, 0);
2673 HRGN combined = CreateRectRgn (0, 0, 0, 0);
2675 from.left = to.left = x;
2676 from.right = to.right = x + width;
2677 from.top = from_y;
2678 from.bottom = from_y + height;
2679 to.top = y;
2680 to.bottom = bottom_y;
2682 ScrollWindowEx (hwnd, 0, to_y - from_y, &from, &to, dirty,
2683 NULL, SW_INVALIDATE);
2685 /* Combine this with what we expect to be dirty. This covers the
2686 case where not all of the region we expect is actually dirty. */
2687 CombineRgn (combined, dirty, expect_dirty, RGN_OR);
2689 /* If the dirty region is not what we expected, redraw the entire frame. */
2690 if (!EqualRgn (combined, expect_dirty))
2691 SET_FRAME_GARBAGED (f);
2693 DeleteObject (dirty);
2694 DeleteObject (combined);
2697 UNBLOCK_INPUT;
2698 DeleteObject (expect_dirty);
2703 /***********************************************************************
2704 Exposure Events
2705 ***********************************************************************/
2707 static void
2708 frame_highlight (struct frame *f)
2710 x_update_cursor (f, 1);
2711 x_set_frame_alpha (f);
2714 static void
2715 frame_unhighlight (struct frame *f)
2717 x_update_cursor (f, 1);
2718 x_set_frame_alpha (f);
2721 /* The focus has changed. Update the frames as necessary to reflect
2722 the new situation. Note that we can't change the selected frame
2723 here, because the Lisp code we are interrupting might become confused.
2724 Each event gets marked with the frame in which it occurred, so the
2725 Lisp code can tell when the switch took place by examining the events. */
2727 static void
2728 x_new_focus_frame (struct w32_display_info *dpyinfo, struct frame *frame)
2730 struct frame *old_focus = dpyinfo->w32_focus_frame;
2732 if (frame != dpyinfo->w32_focus_frame)
2734 /* Set this before calling other routines, so that they see
2735 the correct value of w32_focus_frame. */
2736 dpyinfo->w32_focus_frame = frame;
2738 if (old_focus && old_focus->auto_lower)
2739 x_lower_frame (old_focus);
2741 if (dpyinfo->w32_focus_frame && dpyinfo->w32_focus_frame->auto_raise)
2742 pending_autoraise_frame = dpyinfo->w32_focus_frame;
2743 else
2744 pending_autoraise_frame = 0;
2747 x_frame_rehighlight (dpyinfo);
2751 /* Handle FocusIn and FocusOut state changes for FRAME.
2752 If FRAME has focus and there exists more than one frame, puts
2753 a FOCUS_IN_EVENT into *BUFP. */
2755 static void
2756 x_focus_changed (int type, int state, struct w32_display_info *dpyinfo,
2757 struct frame *frame, struct input_event *bufp)
2759 if (type == WM_SETFOCUS)
2761 if (dpyinfo->w32_focus_event_frame != frame)
2763 x_new_focus_frame (dpyinfo, frame);
2764 dpyinfo->w32_focus_event_frame = frame;
2766 /* Don't stop displaying the initial startup message
2767 for a switch-frame event we don't need. */
2768 if (NILP (Vterminal_frame)
2769 && CONSP (Vframe_list)
2770 && !NILP (XCDR (Vframe_list)))
2772 bufp->kind = FOCUS_IN_EVENT;
2773 XSETFRAME (bufp->frame_or_window, frame);
2777 frame->output_data.x->focus_state |= state;
2779 /* TODO: IME focus? */
2781 else if (type == WM_KILLFOCUS)
2783 frame->output_data.x->focus_state &= ~state;
2785 if (dpyinfo->w32_focus_event_frame == frame)
2787 dpyinfo->w32_focus_event_frame = 0;
2788 x_new_focus_frame (dpyinfo, 0);
2791 /* TODO: IME focus? */
2796 /* The focus may have changed. Figure out if it is a real focus change,
2797 by checking both FocusIn/Out and Enter/LeaveNotify events.
2799 Returns FOCUS_IN_EVENT event in *BUFP. */
2801 static void
2802 w32_detect_focus_change (struct w32_display_info *dpyinfo, W32Msg *event,
2803 struct input_event *bufp)
2805 struct frame *frame;
2807 frame = x_any_window_to_frame (dpyinfo, event->msg.hwnd);
2808 if (! frame)
2809 return;
2811 /* On w32, this is only called from focus events, so no switch needed. */
2812 x_focus_changed (event->msg.message,
2813 (event->msg.message == WM_KILLFOCUS ?
2814 FOCUS_IMPLICIT : FOCUS_EXPLICIT),
2815 dpyinfo, frame, bufp);
2819 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2821 void
2822 x_mouse_leave (struct w32_display_info *dpyinfo)
2824 x_new_focus_frame (dpyinfo, dpyinfo->w32_focus_event_frame);
2827 /* The focus has changed, or we have redirected a frame's focus to
2828 another frame (this happens when a frame uses a surrogate
2829 mini-buffer frame). Shift the highlight as appropriate.
2831 The FRAME argument doesn't necessarily have anything to do with which
2832 frame is being highlighted or un-highlighted; we only use it to find
2833 the appropriate X display info. */
2835 static void
2836 w32_frame_rehighlight (struct frame *frame)
2838 if (! FRAME_W32_P (frame))
2839 return;
2840 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame));
2843 static void
2844 x_frame_rehighlight (struct w32_display_info *dpyinfo)
2846 struct frame *old_highlight = dpyinfo->x_highlight_frame;
2848 if (dpyinfo->w32_focus_frame)
2850 dpyinfo->x_highlight_frame
2851 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame)))
2852 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame))
2853 : dpyinfo->w32_focus_frame);
2854 if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
2856 FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame) = Qnil;
2857 dpyinfo->x_highlight_frame = dpyinfo->w32_focus_frame;
2860 else
2861 dpyinfo->x_highlight_frame = 0;
2863 if (dpyinfo->x_highlight_frame != old_highlight)
2865 if (old_highlight)
2866 frame_unhighlight (old_highlight);
2867 if (dpyinfo->x_highlight_frame)
2868 frame_highlight (dpyinfo->x_highlight_frame);
2872 /* Keyboard processing - modifier keys, etc. */
2874 /* Convert a keysym to its name. */
2876 char *
2877 x_get_keysym_name (int keysym)
2879 /* Make static so we can always return it */
2880 static char value[100];
2882 BLOCK_INPUT;
2883 GetKeyNameText (keysym, value, 100);
2884 UNBLOCK_INPUT;
2886 return value;
2889 static int
2890 codepage_for_locale (LCID locale)
2892 char cp[20];
2894 if (GetLocaleInfo (locale, LOCALE_IDEFAULTANSICODEPAGE, cp, 20) > 0)
2895 return atoi (cp);
2896 else
2897 return CP_ACP;
2901 /* Mouse clicks and mouse movement. Rah. */
2903 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2904 the state in PUP. XBUTTON provides extra information for extended mouse
2905 button messages. Returns FALSE if unable to parse the message. */
2906 BOOL
2907 parse_button (int message, int xbutton, int * pbutton, int * pup)
2909 int button = 0;
2910 int up = 0;
2912 switch (message)
2914 case WM_LBUTTONDOWN:
2915 button = 0;
2916 up = 0;
2917 break;
2918 case WM_LBUTTONUP:
2919 button = 0;
2920 up = 1;
2921 break;
2922 case WM_MBUTTONDOWN:
2923 if (NILP (Vw32_swap_mouse_buttons))
2924 button = 1;
2925 else
2926 button = 2;
2927 up = 0;
2928 break;
2929 case WM_MBUTTONUP:
2930 if (NILP (Vw32_swap_mouse_buttons))
2931 button = 1;
2932 else
2933 button = 2;
2934 up = 1;
2935 break;
2936 case WM_RBUTTONDOWN:
2937 if (NILP (Vw32_swap_mouse_buttons))
2938 button = 2;
2939 else
2940 button = 1;
2941 up = 0;
2942 break;
2943 case WM_RBUTTONUP:
2944 if (NILP (Vw32_swap_mouse_buttons))
2945 button = 2;
2946 else
2947 button = 1;
2948 up = 1;
2949 break;
2950 case WM_XBUTTONDOWN:
2951 button = xbutton + 2;
2952 up = 0;
2953 break;
2954 case WM_XBUTTONUP:
2955 button = xbutton + 2;
2956 up = 1;
2957 break;
2958 default:
2959 return (FALSE);
2962 if (pup) *pup = up;
2963 if (pbutton) *pbutton = button;
2965 return (TRUE);
2969 /* Prepare a mouse-event in *RESULT for placement in the input queue.
2971 If the event is a button press, then note that we have grabbed
2972 the mouse. */
2974 static Lisp_Object
2975 construct_mouse_click (struct input_event *result, W32Msg *msg, struct frame *f)
2977 int button;
2978 int up;
2980 parse_button (msg->msg.message, HIWORD (msg->msg.wParam),
2981 &button, &up);
2983 /* Make the event type NO_EVENT; we'll change that when we decide
2984 otherwise. */
2985 result->kind = MOUSE_CLICK_EVENT;
2986 result->code = button;
2987 result->timestamp = msg->msg.time;
2988 result->modifiers = (msg->dwModifiers
2989 | (up
2990 ? up_modifier
2991 : down_modifier));
2993 XSETINT (result->x, LOWORD (msg->msg.lParam));
2994 XSETINT (result->y, HIWORD (msg->msg.lParam));
2995 XSETFRAME (result->frame_or_window, f);
2996 result->arg = Qnil;
2997 return Qnil;
3000 static Lisp_Object
3001 construct_mouse_wheel (struct input_event *result, W32Msg *msg, struct frame *f)
3003 POINT p;
3004 int delta;
3006 result->kind = msg->msg.message == WM_MOUSEHWHEEL ? HORIZ_WHEEL_EVENT
3007 : WHEEL_EVENT;
3008 result->code = 0;
3009 result->timestamp = msg->msg.time;
3011 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3012 forward, away from the user (up); a negative value indicates that
3013 the wheel was rotated backward, toward the user (down). */
3014 delta = GET_WHEEL_DELTA_WPARAM (msg->msg.wParam);
3016 /* The up and down modifiers indicate if the wheel was rotated up or
3017 down based on WHEEL_DELTA value. */
3018 result->modifiers = (msg->dwModifiers
3019 | ((delta < 0 ) ? down_modifier : up_modifier));
3021 /* With multiple monitors, we can legitimately get negative
3022 coordinates, so cast to short to interpret them correctly. */
3023 p.x = (short) LOWORD (msg->msg.lParam);
3024 p.y = (short) HIWORD (msg->msg.lParam);
3025 ScreenToClient (msg->msg.hwnd, &p);
3026 XSETINT (result->x, p.x);
3027 XSETINT (result->y, p.y);
3028 XSETFRAME (result->frame_or_window, f);
3029 result->arg = Qnil;
3030 return Qnil;
3033 static Lisp_Object
3034 construct_drag_n_drop (struct input_event *result, W32Msg *msg, struct frame *f)
3036 Lisp_Object files;
3037 Lisp_Object frame;
3038 HDROP hdrop;
3039 POINT p;
3040 WORD num_files;
3041 char *name;
3042 int i, len;
3044 result->kind = DRAG_N_DROP_EVENT;
3045 result->code = 0;
3046 result->timestamp = msg->msg.time;
3047 result->modifiers = msg->dwModifiers;
3049 hdrop = (HDROP) msg->msg.wParam;
3050 DragQueryPoint (hdrop, &p);
3052 #if 0
3053 p.x = LOWORD (msg->msg.lParam);
3054 p.y = HIWORD (msg->msg.lParam);
3055 ScreenToClient (msg->msg.hwnd, &p);
3056 #endif
3058 XSETINT (result->x, p.x);
3059 XSETINT (result->y, p.y);
3061 num_files = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0);
3062 files = Qnil;
3064 for (i = 0; i < num_files; i++)
3066 len = DragQueryFile (hdrop, i, NULL, 0);
3067 if (len <= 0)
3068 continue;
3069 name = alloca (len + 1);
3070 DragQueryFile (hdrop, i, name, len + 1);
3071 files = Fcons (DECODE_FILE (build_string (name)), files);
3074 DragFinish (hdrop);
3076 XSETFRAME (frame, f);
3077 result->frame_or_window = frame;
3078 result->arg = files;
3079 return Qnil;
3083 /* Function to report a mouse movement to the mainstream Emacs code.
3084 The input handler calls this.
3086 We have received a mouse movement event, which is given in *event.
3087 If the mouse is over a different glyph than it was last time, tell
3088 the mainstream emacs code by setting mouse_moved. If not, ask for
3089 another motion event, so we can check again the next time it moves. */
3091 static MSG last_mouse_motion_event;
3092 static Lisp_Object last_mouse_motion_frame;
3094 static int
3095 note_mouse_movement (FRAME_PTR frame, MSG *msg)
3097 int mouse_x = LOWORD (msg->lParam);
3098 int mouse_y = HIWORD (msg->lParam);
3100 last_mouse_movement_time = msg->time;
3101 memcpy (&last_mouse_motion_event, msg, sizeof (last_mouse_motion_event));
3102 XSETFRAME (last_mouse_motion_frame, frame);
3104 if (!FRAME_X_OUTPUT (frame))
3105 return 0;
3107 if (msg->hwnd != FRAME_W32_WINDOW (frame))
3109 frame->mouse_moved = 1;
3110 last_mouse_scroll_bar = Qnil;
3111 note_mouse_highlight (frame, -1, -1);
3112 last_mouse_glyph_frame = 0;
3113 return 1;
3116 /* Has the mouse moved off the glyph it was on at the last sighting? */
3117 if (frame != last_mouse_glyph_frame
3118 || mouse_x < last_mouse_glyph.left
3119 || mouse_x >= last_mouse_glyph.right
3120 || mouse_y < last_mouse_glyph.top
3121 || mouse_y >= last_mouse_glyph.bottom)
3123 frame->mouse_moved = 1;
3124 last_mouse_scroll_bar = Qnil;
3125 note_mouse_highlight (frame, mouse_x, mouse_y);
3126 /* Remember the mouse position here, as w32_mouse_position only
3127 gets called when mouse tracking is enabled but we also need
3128 to keep track of the mouse for help_echo and highlighting at
3129 other times. */
3130 remember_mouse_glyph (frame, mouse_x, mouse_y, &last_mouse_glyph);
3131 last_mouse_glyph_frame = frame;
3132 return 1;
3135 return 0;
3139 /************************************************************************
3140 Mouse Face
3141 ************************************************************************/
3143 static struct scroll_bar *x_window_to_scroll_bar (Window);
3144 static void x_scroll_bar_report_motion (FRAME_PTR *, Lisp_Object *,
3145 enum scroll_bar_part *,
3146 Lisp_Object *, Lisp_Object *,
3147 unsigned long *);
3148 static void x_check_fullscreen (struct frame *);
3150 static void
3151 redo_mouse_highlight (void)
3153 if (!NILP (last_mouse_motion_frame)
3154 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame)))
3155 note_mouse_highlight (XFRAME (last_mouse_motion_frame),
3156 LOWORD (last_mouse_motion_event.lParam),
3157 HIWORD (last_mouse_motion_event.lParam));
3160 static void
3161 w32_define_cursor (Window window, Cursor cursor)
3163 PostMessage (window, WM_EMACS_SETCURSOR, (WPARAM) cursor, 0);
3165 /* Return the current position of the mouse.
3166 *fp should be a frame which indicates which display to ask about.
3168 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3169 and *part to the frame, window, and scroll bar part that the mouse
3170 is over. Set *x and *y to the portion and whole of the mouse's
3171 position on the scroll bar.
3173 If the mouse movement started elsewhere, set *fp to the frame the
3174 mouse is on, *bar_window to nil, and *x and *y to the character cell
3175 the mouse is over.
3177 Set *time to the server time-stamp for the time at which the mouse
3178 was at this position.
3180 Don't store anything if we don't have a valid set of values to report.
3182 This clears the mouse_moved flag, so we can wait for the next mouse
3183 movement. */
3185 static void
3186 w32_mouse_position (FRAME_PTR *fp, int insist, Lisp_Object *bar_window,
3187 enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
3188 unsigned long *time)
3190 FRAME_PTR f1;
3192 BLOCK_INPUT;
3194 if (! NILP (last_mouse_scroll_bar) && insist == 0)
3195 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
3196 else
3198 POINT pt;
3200 Lisp_Object frame, tail;
3202 /* Clear the mouse-moved flag for every frame on this display. */
3203 FOR_EACH_FRAME (tail, frame)
3204 XFRAME (frame)->mouse_moved = 0;
3206 last_mouse_scroll_bar = Qnil;
3208 GetCursorPos (&pt);
3210 /* Now we have a position on the root; find the innermost window
3211 containing the pointer. */
3213 if (FRAME_W32_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
3214 && FRAME_LIVE_P (last_mouse_frame))
3216 /* If mouse was grabbed on a frame, give coords for that frame
3217 even if the mouse is now outside it. */
3218 f1 = last_mouse_frame;
3220 else
3222 /* Is window under mouse one of our frames? */
3223 f1 = x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp),
3224 WindowFromPoint (pt));
3227 /* If not, is it one of our scroll bars? */
3228 if (! f1)
3230 struct scroll_bar *bar
3231 = x_window_to_scroll_bar (WindowFromPoint (pt));
3233 if (bar)
3235 f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3239 if (f1 == 0 && insist > 0)
3240 f1 = SELECTED_FRAME ();
3242 if (f1)
3244 /* Ok, we found a frame. Store all the values.
3245 last_mouse_glyph is a rectangle used to reduce the
3246 generation of mouse events. To not miss any motion
3247 events, we must divide the frame into rectangles of the
3248 size of the smallest character that could be displayed
3249 on it, i.e. into the same rectangles that matrices on
3250 the frame are divided into. */
3252 ScreenToClient (FRAME_W32_WINDOW (f1), &pt);
3253 remember_mouse_glyph (f1, pt.x, pt.y, &last_mouse_glyph);
3254 last_mouse_glyph_frame = f1;
3256 *bar_window = Qnil;
3257 *part = 0;
3258 *fp = f1;
3259 XSETINT (*x, pt.x);
3260 XSETINT (*y, pt.y);
3261 *time = last_mouse_movement_time;
3266 UNBLOCK_INPUT;
3270 /***********************************************************************
3271 Tool-bars
3272 ***********************************************************************/
3274 /* Handle mouse button event on the tool-bar of frame F, at
3275 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
3276 or ButtonRelase. */
3278 static void
3279 w32_handle_tool_bar_click (struct frame *f, struct input_event *button_event)
3281 int x = XFASTINT (button_event->x);
3282 int y = XFASTINT (button_event->y);
3284 if (button_event->modifiers & down_modifier)
3285 handle_tool_bar_click (f, x, y, 1, 0);
3286 else
3287 handle_tool_bar_click (f, x, y, 0,
3288 button_event->modifiers & ~up_modifier);
3293 /***********************************************************************
3294 Scroll bars
3295 ***********************************************************************/
3297 /* Scroll bar support. */
3299 /* Given a window ID, find the struct scroll_bar which manages it.
3300 This can be called in GC, so we have to make sure to strip off mark
3301 bits. */
3303 static struct scroll_bar *
3304 x_window_to_scroll_bar (Window window_id)
3306 Lisp_Object tail;
3308 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
3310 Lisp_Object frame, bar, condemned;
3312 frame = XCAR (tail);
3313 /* All elements of Vframe_list should be frames. */
3314 if (! FRAMEP (frame))
3315 abort ();
3317 /* Scan this frame's scroll bar list for a scroll bar with the
3318 right window ID. */
3319 condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
3320 for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
3321 /* This trick allows us to search both the ordinary and
3322 condemned scroll bar lists with one loop. */
3323 ! NILP (bar) || (bar = condemned,
3324 condemned = Qnil,
3325 ! NILP (bar));
3326 bar = XSCROLL_BAR (bar)->next)
3327 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar)) == window_id)
3328 return XSCROLL_BAR (bar);
3331 return 0;
3336 /* Set the thumb size and position of scroll bar BAR. We are currently
3337 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3339 static void
3340 w32_set_scroll_bar_thumb (struct scroll_bar *bar,
3341 int portion, int position, int whole)
3343 Window w = SCROLL_BAR_W32_WINDOW (bar);
3344 /* We use the whole scroll-bar height in the calculations below, to
3345 avoid strange effects like scrolling backwards when just clicking
3346 on the handle (without moving it). */
3347 double range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height))
3348 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3349 int sb_page, sb_pos;
3350 BOOL draggingp = !NILP (bar->dragging) ? TRUE : FALSE;
3351 SCROLLINFO si;
3353 /* We used to change the nPage setting while dragging the handle,
3354 but that had very strange effects (such as scrolling backwards
3355 while dragging downwards).
3357 Now, we don't change the nPage setting while dragging unless we
3358 get near to the end of the buffer, in which case we often have to
3359 resize the handle to "go all the way". */
3361 if (draggingp)
3363 int near_bottom_p;
3364 BLOCK_INPUT;
3365 si.cbSize = sizeof (si);
3366 si.fMask = SIF_POS | SIF_PAGE;
3367 GetScrollInfo (w, SB_CTL, &si);
3368 near_bottom_p = si.nPos + si.nPage >= range;
3369 UNBLOCK_INPUT;
3370 if (!near_bottom_p)
3371 return;
3374 if (whole)
3376 /* Position scroll bar at rock bottom if the bottom of the
3377 buffer is visible. This avoids shinking the thumb away
3378 to nothing if it is held at the bottom of the buffer. */
3379 if (position + portion >= whole && !draggingp)
3381 sb_page = range * (whole - position) / whole;
3382 sb_pos = range;
3384 else
3386 sb_pos = position * range / whole;
3387 sb_page = (min (portion, (whole - position)) * range) / whole;
3390 else
3392 sb_page = range;
3393 sb_pos = 0;
3396 sb_page = max (sb_page, VERTICAL_SCROLL_BAR_MIN_HANDLE);
3398 BLOCK_INPUT;
3400 si.cbSize = sizeof (si);
3401 si.fMask = SIF_PAGE | SIF_POS;
3402 si.nPage = sb_page;
3403 si.nPos = sb_pos;
3405 SetScrollInfo (w, SB_CTL, &si, TRUE);
3407 UNBLOCK_INPUT;
3411 /************************************************************************
3412 Scroll bars, general
3413 ************************************************************************/
3415 static HWND
3416 my_create_scrollbar (struct frame * f, struct scroll_bar * bar)
3418 return (HWND) SendMessage (FRAME_W32_WINDOW (f),
3419 WM_EMACS_CREATESCROLLBAR, (WPARAM) f,
3420 (LPARAM) bar);
3423 /*#define ATTACH_THREADS*/
3425 static BOOL
3426 my_show_window (FRAME_PTR f, HWND hwnd, int how)
3428 #ifndef ATTACH_THREADS
3429 return SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SHOWWINDOW,
3430 (WPARAM) hwnd, (LPARAM) how);
3431 #else
3432 return ShowWindow (hwnd, how);
3433 #endif
3436 static void
3437 my_set_window_pos (HWND hwnd, HWND hwndAfter,
3438 int x, int y, int cx, int cy, UINT flags)
3440 #ifndef ATTACH_THREADS
3441 WINDOWPOS pos;
3442 pos.hwndInsertAfter = hwndAfter;
3443 pos.x = x;
3444 pos.y = y;
3445 pos.cx = cx;
3446 pos.cy = cy;
3447 pos.flags = flags;
3448 SendMessage (hwnd, WM_EMACS_SETWINDOWPOS, (WPARAM) &pos, 0);
3449 #else
3450 SetWindowPos (hwnd, hwndAfter, x, y, cx, cy, flags);
3451 #endif
3454 #if 0
3455 static void
3456 my_set_focus (struct frame * f, HWND hwnd)
3458 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SETFOCUS,
3459 (WPARAM) hwnd, 0);
3461 #endif
3463 static void
3464 my_set_foreground_window (HWND hwnd)
3466 SendMessage (hwnd, WM_EMACS_SETFOREGROUND, (WPARAM) hwnd, 0);
3470 static void
3471 my_destroy_window (struct frame * f, HWND hwnd)
3473 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_DESTROYWINDOW,
3474 (WPARAM) hwnd, 0);
3477 /* Create a scroll bar and return the scroll bar vector for it. W is
3478 the Emacs window on which to create the scroll bar. TOP, LEFT,
3479 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
3480 scroll bar. */
3482 static struct scroll_bar *
3483 x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
3485 struct frame *f = XFRAME (WINDOW_FRAME (w));
3486 HWND hwnd;
3487 SCROLLINFO si;
3488 struct scroll_bar *bar
3489 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
3491 BLOCK_INPUT;
3493 XSETWINDOW (bar->window, w);
3494 XSETINT (bar->top, top);
3495 XSETINT (bar->left, left);
3496 XSETINT (bar->width, width);
3497 XSETINT (bar->height, height);
3498 XSETINT (bar->start, 0);
3499 XSETINT (bar->end, 0);
3500 bar->dragging = Qnil;
3501 bar->fringe_extended_p = Qnil;
3503 /* Requires geometry to be set before call to create the real window */
3505 hwnd = my_create_scrollbar (f, bar);
3507 si.cbSize = sizeof (si);
3508 si.fMask = SIF_ALL;
3509 si.nMin = 0;
3510 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
3511 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3512 si.nPage = si.nMax;
3513 si.nPos = 0;
3515 SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3517 SET_SCROLL_BAR_W32_WINDOW (bar, hwnd);
3519 /* Add bar to its frame's list of scroll bars. */
3520 bar->next = FRAME_SCROLL_BARS (f);
3521 bar->prev = Qnil;
3522 XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
3523 if (! NILP (bar->next))
3524 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
3526 UNBLOCK_INPUT;
3528 return bar;
3532 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3533 nil. */
3535 static void
3536 x_scroll_bar_remove (struct scroll_bar *bar)
3538 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3540 BLOCK_INPUT;
3542 /* Destroy the window. */
3543 my_destroy_window (f, SCROLL_BAR_W32_WINDOW (bar));
3545 /* Disassociate this scroll bar from its window. */
3546 XWINDOW (bar->window)->vertical_scroll_bar = Qnil;
3548 UNBLOCK_INPUT;
3551 /* Set the handle of the vertical scroll bar for WINDOW to indicate
3552 that we are displaying PORTION characters out of a total of WHOLE
3553 characters, starting at POSITION. If WINDOW has no scroll bar,
3554 create one. */
3555 static void
3556 w32_set_vertical_scroll_bar (struct window *w,
3557 int portion, int whole, int position)
3559 struct frame *f = XFRAME (w->frame);
3560 struct scroll_bar *bar;
3561 int top, height, left, sb_left, width, sb_width;
3562 int window_y, window_height;
3563 int fringe_extended_p;
3565 /* Get window dimensions. */
3566 window_box (w, -1, 0, &window_y, 0, &window_height);
3567 top = window_y;
3568 width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
3569 height = window_height;
3571 /* Compute the left edge of the scroll bar area. */
3572 left = WINDOW_SCROLL_BAR_AREA_X (w);
3574 /* Compute the width of the scroll bar which might be less than
3575 the width of the area reserved for the scroll bar. */
3576 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w) > 0)
3577 sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
3578 else
3579 sb_width = width;
3581 /* Compute the left edge of the scroll bar. */
3582 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
3583 sb_left = left + (WINDOW_RIGHTMOST_P (w) ? width - sb_width : 0);
3584 else
3585 sb_left = left + (WINDOW_LEFTMOST_P (w) ? 0 : width - sb_width);
3587 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
3588 fringe_extended_p = (WINDOW_LEFTMOST_P (w)
3589 && WINDOW_LEFT_FRINGE_WIDTH (w)
3590 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
3591 || WINDOW_LEFT_MARGIN_COLS (w) == 0));
3592 else
3593 fringe_extended_p = (WINDOW_RIGHTMOST_P (w)
3594 && WINDOW_RIGHT_FRINGE_WIDTH (w)
3595 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
3596 || WINDOW_RIGHT_MARGIN_COLS (w) == 0));
3598 /* Does the scroll bar exist yet? */
3599 if (NILP (w->vertical_scroll_bar))
3601 HDC hdc;
3602 BLOCK_INPUT;
3603 if (width > 0 && height > 0)
3605 hdc = get_frame_dc (f);
3606 if (fringe_extended_p)
3607 w32_clear_area (f, hdc, sb_left, top, sb_width, height);
3608 else
3609 w32_clear_area (f, hdc, left, top, width, height);
3610 release_frame_dc (f, hdc);
3612 UNBLOCK_INPUT;
3614 bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
3616 else
3618 /* It may just need to be moved and resized. */
3619 HWND hwnd;
3621 bar = XSCROLL_BAR (w->vertical_scroll_bar);
3622 hwnd = SCROLL_BAR_W32_WINDOW (bar);
3624 /* If already correctly positioned, do nothing. */
3625 if ( XINT (bar->left) == sb_left
3626 && XINT (bar->top) == top
3627 && XINT (bar->width) == sb_width
3628 && XINT (bar->height) == height
3629 && !NILP (bar->fringe_extended_p) == fringe_extended_p )
3631 /* Redraw after clear_frame. */
3632 if (!my_show_window (f, hwnd, SW_NORMAL))
3633 InvalidateRect (hwnd, NULL, FALSE);
3635 else
3637 HDC hdc;
3638 SCROLLINFO si;
3640 BLOCK_INPUT;
3641 if (width && height)
3643 hdc = get_frame_dc (f);
3644 /* Since Windows scroll bars are smaller than the space reserved
3645 for them on the frame, we have to clear "under" them. */
3646 if (fringe_extended_p)
3647 w32_clear_area (f, hdc, sb_left, top, sb_width, height);
3648 else
3649 w32_clear_area (f, hdc, left, top, width, height);
3650 release_frame_dc (f, hdc);
3652 /* Make sure scroll bar is "visible" before moving, to ensure the
3653 area of the parent window now exposed will be refreshed. */
3654 my_show_window (f, hwnd, SW_HIDE);
3655 MoveWindow (hwnd, sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
3656 top, sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
3657 max (height, 1), TRUE);
3659 si.cbSize = sizeof (si);
3660 si.fMask = SIF_RANGE;
3661 si.nMin = 0;
3662 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
3663 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3665 SetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3667 my_show_window (f, hwnd, SW_NORMAL);
3668 /* InvalidateRect (w, NULL, FALSE); */
3670 /* Remember new settings. */
3671 XSETINT (bar->left, sb_left);
3672 XSETINT (bar->top, top);
3673 XSETINT (bar->width, sb_width);
3674 XSETINT (bar->height, height);
3676 UNBLOCK_INPUT;
3679 bar->fringe_extended_p = fringe_extended_p ? Qt : Qnil;
3681 w32_set_scroll_bar_thumb (bar, portion, position, whole);
3683 XSETVECTOR (w->vertical_scroll_bar, bar);
3687 /* The following three hooks are used when we're doing a thorough
3688 redisplay of the frame. We don't explicitly know which scroll bars
3689 are going to be deleted, because keeping track of when windows go
3690 away is a real pain - "Can you say set-window-configuration, boys
3691 and girls?" Instead, we just assert at the beginning of redisplay
3692 that *all* scroll bars are to be removed, and then save a scroll bar
3693 from the fiery pit when we actually redisplay its window. */
3695 /* Arrange for all scroll bars on FRAME to be removed at the next call
3696 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
3697 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
3699 static void
3700 w32_condemn_scroll_bars (FRAME_PTR frame)
3702 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
3703 while (! NILP (FRAME_SCROLL_BARS (frame)))
3705 Lisp_Object bar;
3706 bar = FRAME_SCROLL_BARS (frame);
3707 FRAME_SCROLL_BARS (frame) = XSCROLL_BAR (bar)->next;
3708 XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
3709 XSCROLL_BAR (bar)->prev = Qnil;
3710 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
3711 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
3712 FRAME_CONDEMNED_SCROLL_BARS (frame) = bar;
3717 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
3718 Note that WINDOW isn't necessarily condemned at all. */
3720 static void
3721 w32_redeem_scroll_bar (struct window *window)
3723 struct scroll_bar *bar;
3724 struct frame *f;
3726 /* We can't redeem this window's scroll bar if it doesn't have one. */
3727 if (NILP (window->vertical_scroll_bar))
3728 abort ();
3730 bar = XSCROLL_BAR (window->vertical_scroll_bar);
3732 /* Unlink it from the condemned list. */
3733 f = XFRAME (WINDOW_FRAME (window));
3734 if (NILP (bar->prev))
3736 /* If the prev pointer is nil, it must be the first in one of
3737 the lists. */
3738 if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
3739 /* It's not condemned. Everything's fine. */
3740 return;
3741 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
3742 window->vertical_scroll_bar))
3743 FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next;
3744 else
3745 /* If its prev pointer is nil, it must be at the front of
3746 one or the other! */
3747 abort ();
3749 else
3750 XSCROLL_BAR (bar->prev)->next = bar->next;
3752 if (! NILP (bar->next))
3753 XSCROLL_BAR (bar->next)->prev = bar->prev;
3755 bar->next = FRAME_SCROLL_BARS (f);
3756 bar->prev = Qnil;
3757 XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
3758 if (! NILP (bar->next))
3759 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
3762 /* Remove all scroll bars on FRAME that haven't been saved since the
3763 last call to `*condemn_scroll_bars_hook'. */
3765 static void
3766 w32_judge_scroll_bars (FRAME_PTR f)
3768 Lisp_Object bar, next;
3770 bar = FRAME_CONDEMNED_SCROLL_BARS (f);
3772 /* Clear out the condemned list now so we won't try to process any
3773 more events on the hapless scroll bars. */
3774 FRAME_CONDEMNED_SCROLL_BARS (f) = Qnil;
3776 for (; ! NILP (bar); bar = next)
3778 struct scroll_bar *b = XSCROLL_BAR (bar);
3780 x_scroll_bar_remove (b);
3782 next = b->next;
3783 b->next = b->prev = Qnil;
3786 /* Now there should be no references to the condemned scroll bars,
3787 and they should get garbage-collected. */
3790 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
3791 is set to something other than NO_EVENT, it is enqueued.
3793 This may be called from a signal handler, so we have to ignore GC
3794 mark bits. */
3796 static int
3797 w32_scroll_bar_handle_click (struct scroll_bar *bar, W32Msg *msg,
3798 struct input_event *emacs_event)
3800 if (! WINDOWP (bar->window))
3801 abort ();
3803 emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
3804 emacs_event->code = 0;
3805 /* not really meaningful to distinguish up/down */
3806 emacs_event->modifiers = msg->dwModifiers;
3807 emacs_event->frame_or_window = bar->window;
3808 emacs_event->arg = Qnil;
3809 emacs_event->timestamp = msg->msg.time;
3812 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
3813 int y;
3814 int dragging = !NILP (bar->dragging);
3815 SCROLLINFO si;
3817 si.cbSize = sizeof (si);
3818 si.fMask = SIF_POS;
3820 GetScrollInfo ((HWND) msg->msg.lParam, SB_CTL, &si);
3821 y = si.nPos;
3823 bar->dragging = Qnil;
3826 last_mouse_scroll_bar_pos = msg->msg.wParam;
3828 switch (LOWORD (msg->msg.wParam))
3830 case SB_LINEDOWN:
3831 emacs_event->part = scroll_bar_down_arrow;
3832 break;
3833 case SB_LINEUP:
3834 emacs_event->part = scroll_bar_up_arrow;
3835 break;
3836 case SB_PAGEUP:
3837 emacs_event->part = scroll_bar_above_handle;
3838 break;
3839 case SB_PAGEDOWN:
3840 emacs_event->part = scroll_bar_below_handle;
3841 break;
3842 case SB_TOP:
3843 emacs_event->part = scroll_bar_handle;
3844 y = 0;
3845 break;
3846 case SB_BOTTOM:
3847 emacs_event->part = scroll_bar_handle;
3848 y = top_range;
3849 break;
3850 case SB_THUMBTRACK:
3851 case SB_THUMBPOSITION:
3852 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) <= 0xffff)
3853 y = HIWORD (msg->msg.wParam);
3854 bar->dragging = Qt;
3855 emacs_event->part = scroll_bar_handle;
3857 /* "Silently" update current position. */
3859 SCROLLINFO si;
3861 si.cbSize = sizeof (si);
3862 si.fMask = SIF_POS;
3863 si.nPos = y;
3864 /* Remember apparent position (we actually lag behind the real
3865 position, so don't set that directly. */
3866 last_scroll_bar_drag_pos = y;
3868 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, FALSE);
3870 break;
3871 case SB_ENDSCROLL:
3872 /* If this is the end of a drag sequence, then reset the scroll
3873 handle size to normal and do a final redraw. Otherwise do
3874 nothing. */
3875 if (dragging)
3877 SCROLLINFO si;
3878 int start = XINT (bar->start);
3879 int end = XINT (bar->end);
3881 si.cbSize = sizeof (si);
3882 si.fMask = SIF_PAGE | SIF_POS;
3883 si.nPage = end - start + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3884 si.nPos = last_scroll_bar_drag_pos;
3885 SetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE);
3887 /* fall through */
3888 default:
3889 emacs_event->kind = NO_EVENT;
3890 return FALSE;
3893 XSETINT (emacs_event->x, y);
3894 XSETINT (emacs_event->y, top_range);
3896 return TRUE;
3900 /* Return information to the user about the current position of the mouse
3901 on the scroll bar. */
3903 static void
3904 x_scroll_bar_report_motion (FRAME_PTR *fp, Lisp_Object *bar_window,
3905 enum scroll_bar_part *part,
3906 Lisp_Object *x, Lisp_Object *y,
3907 unsigned long *time)
3909 struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
3910 Window w = SCROLL_BAR_W32_WINDOW (bar);
3911 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3912 int pos;
3913 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
3914 SCROLLINFO si;
3916 BLOCK_INPUT;
3918 *fp = f;
3919 *bar_window = bar->window;
3921 si.cbSize = sizeof (si);
3922 si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
3924 GetScrollInfo (w, SB_CTL, &si);
3925 pos = si.nPos;
3926 top_range = si.nMax - si.nPage + 1;
3928 switch (LOWORD (last_mouse_scroll_bar_pos))
3930 case SB_THUMBPOSITION:
3931 case SB_THUMBTRACK:
3932 *part = scroll_bar_handle;
3933 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) <= 0xffff)
3934 pos = HIWORD (last_mouse_scroll_bar_pos);
3935 break;
3936 case SB_LINEDOWN:
3937 *part = scroll_bar_handle;
3938 pos++;
3939 break;
3940 default:
3941 *part = scroll_bar_handle;
3942 break;
3945 XSETINT (*x, pos);
3946 XSETINT (*y, top_range);
3948 f->mouse_moved = 0;
3949 last_mouse_scroll_bar = Qnil;
3951 *time = last_mouse_movement_time;
3953 UNBLOCK_INPUT;
3957 /* The screen has been cleared so we may have changed foreground or
3958 background colors, and the scroll bars may need to be redrawn.
3959 Clear out the scroll bars, and ask for expose events, so we can
3960 redraw them. */
3962 void
3963 x_scroll_bar_clear (FRAME_PTR f)
3965 Lisp_Object bar;
3967 /* We can have scroll bars even if this is 0,
3968 if we just turned off scroll bar mode.
3969 But in that case we should not clear them. */
3970 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
3971 for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
3972 bar = XSCROLL_BAR (bar)->next)
3974 HWND window = SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar));
3975 HDC hdc = GetDC (window);
3976 RECT rect;
3978 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
3979 arranges to refresh the scroll bar if hidden. */
3980 my_show_window (f, window, SW_HIDE);
3982 GetClientRect (window, &rect);
3983 select_palette (f, hdc);
3984 w32_clear_rect (f, hdc, &rect);
3985 deselect_palette (f, hdc);
3987 ReleaseDC (window, hdc);
3992 /* The main W32 event-reading loop - w32_read_socket. */
3994 /* Record the last 100 characters stored
3995 to help debug the loss-of-chars-during-GC problem. */
3997 static int temp_index;
3998 static short temp_buffer[100];
4000 /* Temporarily store lead byte of DBCS input sequences. */
4001 static char dbcs_lead = 0;
4003 /* Read events coming from the W32 shell.
4004 This routine is called by the SIGIO handler.
4005 We return as soon as there are no more events to be read.
4007 We return the number of characters stored into the buffer,
4008 thus pretending to be `read'.
4010 EXPECTED is nonzero if the caller knows input is available.
4012 Some of these messages are reposted back to the message queue since the
4013 system calls the windows proc directly in a context where we cannot return
4014 the data nor can we guarantee the state we are in. So if we dispatch them
4015 we will get into an infinite loop. To prevent this from ever happening we
4016 will set a variable to indicate we are in the read_socket call and indicate
4017 which message we are processing since the windows proc gets called
4018 recursively with different messages by the system.
4021 static int
4022 w32_read_socket (struct terminal *terminal, int expected,
4023 struct input_event *hold_quit)
4025 int count = 0;
4026 int check_visibility = 0;
4027 W32Msg msg;
4028 struct frame *f;
4029 struct w32_display_info *dpyinfo = &one_w32_display_info;
4030 Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
4032 if (interrupt_input_blocked)
4034 interrupt_input_pending = 1;
4035 return -1;
4038 interrupt_input_pending = 0;
4039 BLOCK_INPUT;
4041 /* So people can tell when we have read the available input. */
4042 input_signal_count++;
4044 /* TODO: ghostscript integration. */
4045 while (get_next_msg (&msg, FALSE))
4047 struct input_event inev;
4048 int do_help = 0;
4050 EVENT_INIT (inev);
4051 inev.kind = NO_EVENT;
4052 inev.arg = Qnil;
4054 switch (msg.msg.message)
4056 case WM_EMACS_PAINT:
4057 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4059 if (f)
4061 if (msg.rect.right == msg.rect.left ||
4062 msg.rect.bottom == msg.rect.top)
4064 /* We may get paint messages even though the client
4065 area is clipped - these are not expose events. */
4066 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f,
4067 SDATA (f->name)));
4069 else if (f->async_visible != 1)
4071 /* Definitely not obscured, so mark as visible. */
4072 f->async_visible = 1;
4073 f->async_iconified = 0;
4074 SET_FRAME_GARBAGED (f);
4075 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f,
4076 SDATA (f->name)));
4078 /* WM_PAINT serves as MapNotify as well, so report
4079 visibility changes properly. */
4080 if (f->iconified)
4082 inev.kind = DEICONIFY_EVENT;
4083 XSETFRAME (inev.frame_or_window, f);
4085 else if (! NILP (Vframe_list)
4086 && ! NILP (XCDR (Vframe_list)))
4087 /* Force a redisplay sooner or later to update the
4088 frame titles in case this is the second frame. */
4089 record_asynch_buffer_change ();
4091 else
4093 HDC hdc = get_frame_dc (f);
4095 /* Erase background again for safety. */
4096 w32_clear_rect (f, hdc, &msg.rect);
4097 release_frame_dc (f, hdc);
4098 expose_frame (f,
4099 msg.rect.left,
4100 msg.rect.top,
4101 msg.rect.right - msg.rect.left,
4102 msg.rect.bottom - msg.rect.top);
4105 break;
4107 case WM_INPUTLANGCHANGE:
4108 /* Generate a language change event. */
4109 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4111 /* lParam contains the input lang ID. Use it to update our
4112 record of the keyboard codepage. */
4113 keyboard_codepage = codepage_for_locale ((LCID)(msg.msg.lParam
4114 & 0xffff));
4116 if (f)
4118 inev.kind = LANGUAGE_CHANGE_EVENT;
4119 XSETFRAME (inev.frame_or_window, f);
4120 inev.code = msg.msg.wParam;
4121 inev.modifiers = msg.msg.lParam & 0xffff;
4123 break;
4125 case WM_KEYDOWN:
4126 case WM_SYSKEYDOWN:
4127 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4129 if (f && !f->iconified)
4131 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4132 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4134 clear_mouse_face (hlinfo);
4135 hlinfo->mouse_face_hidden = 1;
4138 if (temp_index == sizeof temp_buffer / sizeof (short))
4139 temp_index = 0;
4140 temp_buffer[temp_index++] = msg.msg.wParam;
4141 inev.kind = NON_ASCII_KEYSTROKE_EVENT;
4142 inev.code = msg.msg.wParam;
4143 inev.modifiers = msg.dwModifiers;
4144 XSETFRAME (inev.frame_or_window, f);
4145 inev.timestamp = msg.msg.time;
4147 break;
4149 case WM_UNICHAR:
4150 case WM_SYSCHAR:
4151 case WM_CHAR:
4152 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4154 if (f && !f->iconified)
4156 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4157 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4159 clear_mouse_face (hlinfo);
4160 hlinfo->mouse_face_hidden = 1;
4163 if (temp_index == sizeof temp_buffer / sizeof (short))
4164 temp_index = 0;
4165 temp_buffer[temp_index++] = msg.msg.wParam;
4167 inev.modifiers = msg.dwModifiers;
4168 XSETFRAME (inev.frame_or_window, f);
4169 inev.timestamp = msg.msg.time;
4171 if (msg.msg.message == WM_UNICHAR)
4173 inev.code = msg.msg.wParam;
4175 else if (msg.msg.wParam < 256)
4177 wchar_t code;
4178 char dbcs[2];
4179 dbcs[0] = 0;
4180 dbcs[1] = (char) msg.msg.wParam;
4182 if (dbcs_lead)
4184 dbcs[0] = dbcs_lead;
4185 dbcs_lead = 0;
4186 if (!MultiByteToWideChar (keyboard_codepage, 0,
4187 dbcs, 2, &code, 1))
4189 /* Garbage */
4190 DebPrint (("Invalid DBCS sequence: %d %d\n",
4191 dbcs[0], dbcs[1]));
4192 inev.kind = NO_EVENT;
4193 break;
4196 else if (IsDBCSLeadByteEx (keyboard_codepage,
4197 (BYTE) msg.msg.wParam))
4199 dbcs_lead = (char) msg.msg.wParam;
4200 inev.kind = NO_EVENT;
4201 break;
4203 else
4205 if (!MultiByteToWideChar (keyboard_codepage, 0,
4206 &dbcs[1], 1, &code, 1))
4208 /* What to do with garbage? */
4209 DebPrint (("Invalid character: %d\n", dbcs[1]));
4210 inev.kind = NO_EVENT;
4211 break;
4214 inev.code = code;
4216 else
4218 /* Windows shouldn't generate WM_CHAR events above 0xFF
4219 in non-Unicode message handlers. */
4220 DebPrint (("Non-byte WM_CHAR: %d\n", msg.msg.wParam));
4221 inev.kind = NO_EVENT;
4222 break;
4224 inev.kind = inev.code < 128 ? ASCII_KEYSTROKE_EVENT
4225 : MULTIBYTE_CHAR_KEYSTROKE_EVENT;
4227 break;
4229 case WM_APPCOMMAND:
4230 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4232 if (f && !f->iconified)
4234 if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
4235 && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
4237 clear_mouse_face (hlinfo);
4238 hlinfo->mouse_face_hidden = 1;
4241 if (temp_index == sizeof temp_buffer / sizeof (short))
4242 temp_index = 0;
4243 temp_buffer[temp_index++] = msg.msg.wParam;
4244 inev.kind = MULTIMEDIA_KEY_EVENT;
4245 inev.code = GET_APPCOMMAND_LPARAM (msg.msg.lParam);
4246 inev.modifiers = msg.dwModifiers;
4247 XSETFRAME (inev.frame_or_window, f);
4248 inev.timestamp = msg.msg.time;
4250 break;
4252 case WM_MOUSEMOVE:
4253 /* Ignore non-movement. */
4255 int x = LOWORD (msg.msg.lParam);
4256 int y = HIWORD (msg.msg.lParam);
4257 if (x == last_mousemove_x && y == last_mousemove_y)
4258 break;
4259 last_mousemove_x = x;
4260 last_mousemove_y = y;
4263 previous_help_echo_string = help_echo_string;
4264 help_echo_string = Qnil;
4266 if (dpyinfo->grabbed && last_mouse_frame
4267 && FRAME_LIVE_P (last_mouse_frame))
4268 f = last_mouse_frame;
4269 else
4270 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4272 if (hlinfo->mouse_face_hidden)
4274 hlinfo->mouse_face_hidden = 0;
4275 clear_mouse_face (hlinfo);
4278 if (f)
4280 /* Generate SELECT_WINDOW_EVENTs when needed. */
4281 if (!NILP (Vmouse_autoselect_window))
4283 Lisp_Object window;
4284 int x = LOWORD (msg.msg.lParam);
4285 int y = HIWORD (msg.msg.lParam);
4287 window = window_from_coordinates (f, x, y, 0, 0);
4289 /* Window will be selected only when it is not
4290 selected now and last mouse movement event was
4291 not in it. Minibuffer window will be selected
4292 only when it is active. */
4293 if (WINDOWP (window)
4294 && !EQ (window, last_window)
4295 && !EQ (window, selected_window)
4296 /* For click-to-focus window managers
4297 create event iff we don't leave the
4298 selected frame. */
4299 && (focus_follows_mouse
4300 || (EQ (XWINDOW (window)->frame,
4301 XWINDOW (selected_window)->frame))))
4303 inev.kind = SELECT_WINDOW_EVENT;
4304 inev.frame_or_window = window;
4307 last_window = window;
4309 if (!note_mouse_movement (f, &msg.msg))
4310 help_echo_string = previous_help_echo_string;
4312 else
4314 /* If we move outside the frame, then we're
4315 certainly no longer on any text in the frame. */
4316 clear_mouse_face (hlinfo);
4319 /* If the contents of the global variable help_echo_string
4320 has changed, generate a HELP_EVENT. */
4321 #if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE.
4322 But it was originally changed to this to fix a bug, so I have
4323 not removed it completely in case the bug is still there. */
4324 if (help_echo_string != previous_help_echo_string ||
4325 (!NILP (help_echo_string) && !STRINGP (help_echo_string) && f->mouse_moved))
4326 #else /* This is what xterm.c does. */
4327 if (!NILP (help_echo_string)
4328 || !NILP (previous_help_echo_string))
4329 do_help = 1;
4330 #endif
4331 break;
4333 case WM_LBUTTONDOWN:
4334 case WM_LBUTTONUP:
4335 case WM_MBUTTONDOWN:
4336 case WM_MBUTTONUP:
4337 case WM_RBUTTONDOWN:
4338 case WM_RBUTTONUP:
4339 case WM_XBUTTONDOWN:
4340 case WM_XBUTTONUP:
4342 /* If we decide we want to generate an event to be seen
4343 by the rest of Emacs, we put it here. */
4344 int tool_bar_p = 0;
4345 int button;
4346 int up;
4348 if (dpyinfo->grabbed && last_mouse_frame
4349 && FRAME_LIVE_P (last_mouse_frame))
4350 f = last_mouse_frame;
4351 else
4352 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4354 if (f)
4356 construct_mouse_click (&inev, &msg, f);
4358 /* Is this in the tool-bar? */
4359 if (WINDOWP (f->tool_bar_window)
4360 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)))
4362 Lisp_Object window;
4363 int x = XFASTINT (inev.x);
4364 int y = XFASTINT (inev.y);
4366 window = window_from_coordinates (f, x, y, 0, 1);
4368 if (EQ (window, f->tool_bar_window))
4370 w32_handle_tool_bar_click (f, &inev);
4371 tool_bar_p = 1;
4375 if (tool_bar_p
4376 || (dpyinfo->w32_focus_frame
4377 && f != dpyinfo->w32_focus_frame))
4378 inev.kind = NO_EVENT;
4381 parse_button (msg.msg.message, HIWORD (msg.msg.wParam),
4382 &button, &up);
4384 if (up)
4386 dpyinfo->grabbed &= ~ (1 << button);
4388 else
4390 dpyinfo->grabbed |= (1 << button);
4391 last_mouse_frame = f;
4392 /* Ignore any mouse motion that happened
4393 before this event; any subsequent mouse-movement
4394 Emacs events should reflect only motion after
4395 the ButtonPress. */
4396 if (f != 0)
4397 f->mouse_moved = 0;
4399 if (!tool_bar_p)
4400 last_tool_bar_item = -1;
4402 break;
4405 case WM_MOUSEWHEEL:
4406 case WM_MOUSEHWHEEL:
4408 if (dpyinfo->grabbed && last_mouse_frame
4409 && FRAME_LIVE_P (last_mouse_frame))
4410 f = last_mouse_frame;
4411 else
4412 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4414 if (f)
4417 if (!dpyinfo->w32_focus_frame
4418 || f == dpyinfo->w32_focus_frame)
4420 /* Emit an Emacs wheel-up/down event. */
4421 construct_mouse_wheel (&inev, &msg, f);
4423 /* Ignore any mouse motion that happened before this
4424 event; any subsequent mouse-movement Emacs events
4425 should reflect only motion after the
4426 ButtonPress. */
4427 f->mouse_moved = 0;
4429 last_mouse_frame = f;
4430 last_tool_bar_item = -1;
4432 break;
4434 case WM_DROPFILES:
4435 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4437 if (f)
4438 construct_drag_n_drop (&inev, &msg, f);
4439 break;
4441 case WM_VSCROLL:
4443 struct scroll_bar *bar =
4444 x_window_to_scroll_bar ((HWND)msg.msg.lParam);
4446 if (bar)
4447 w32_scroll_bar_handle_click (bar, &msg, &inev);
4448 break;
4451 case WM_WINDOWPOSCHANGED:
4452 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4453 if (f)
4455 if (f->want_fullscreen & FULLSCREEN_WAIT)
4456 f->want_fullscreen &= ~(FULLSCREEN_WAIT|FULLSCREEN_BOTH);
4458 check_visibility = 1;
4459 break;
4461 case WM_ACTIVATE:
4462 case WM_ACTIVATEAPP:
4463 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4464 if (f)
4465 x_check_fullscreen (f);
4466 check_visibility = 1;
4467 break;
4469 case WM_MOVE:
4470 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4472 if (f && !f->async_iconified)
4474 int x, y;
4476 x_real_positions (f, &x, &y);
4477 f->left_pos = x;
4478 f->top_pos = y;
4481 check_visibility = 1;
4482 break;
4484 case WM_SHOWWINDOW:
4485 /* wParam non-zero means Window is about to be shown, 0 means
4486 about to be hidden. */
4487 /* Redo the mouse-highlight after the tooltip has gone. */
4488 if (!msg.msg.wParam && msg.msg.hwnd == tip_window)
4490 tip_window = NULL;
4491 redo_mouse_highlight ();
4494 /* If window has been obscured or exposed by another window
4495 being maximised or minimised/restored, then recheck
4496 visibility of all frames. Direct changes to our own
4497 windows get handled by WM_SIZE. */
4498 #if 0
4499 if (msg.msg.lParam != 0)
4500 check_visibility = 1;
4501 else
4503 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4504 f->async_visible = msg.msg.wParam;
4506 #endif
4508 check_visibility = 1;
4509 break;
4511 case WM_SIZE:
4512 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4514 /* Inform lisp of whether frame has been iconified etc. */
4515 if (f)
4517 switch (msg.msg.wParam)
4519 case SIZE_MINIMIZED:
4520 f->async_visible = 0;
4521 f->async_iconified = 1;
4523 inev.kind = ICONIFY_EVENT;
4524 XSETFRAME (inev.frame_or_window, f);
4525 break;
4527 case SIZE_MAXIMIZED:
4528 case SIZE_RESTORED:
4529 f->async_visible = 1;
4530 f->async_iconified = 0;
4532 /* wait_reading_process_output will notice this and update
4533 the frame's display structures. */
4534 SET_FRAME_GARBAGED (f);
4536 if (f->iconified)
4538 int x, y;
4540 /* Reset top and left positions of the Window
4541 here since Windows sends a WM_MOVE message
4542 BEFORE telling us the Window is minimized
4543 when the Window is iconified, with 3000,3000
4544 as the co-ords. */
4545 x_real_positions (f, &x, &y);
4546 f->left_pos = x;
4547 f->top_pos = y;
4549 inev.kind = DEICONIFY_EVENT;
4550 XSETFRAME (inev.frame_or_window, f);
4552 else if (! NILP (Vframe_list)
4553 && ! NILP (XCDR (Vframe_list)))
4554 /* Force a redisplay sooner or later
4555 to update the frame titles
4556 in case this is the second frame. */
4557 record_asynch_buffer_change ();
4558 break;
4562 if (f && !f->async_iconified && msg.msg.wParam != SIZE_MINIMIZED)
4564 RECT rect;
4565 int rows;
4566 int columns;
4567 int width;
4568 int height;
4570 GetClientRect (msg.msg.hwnd, &rect);
4572 height = rect.bottom - rect.top;
4573 width = rect.right - rect.left;
4575 rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height);
4576 columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width);
4578 /* TODO: Clip size to the screen dimensions. */
4580 /* Even if the number of character rows and columns has
4581 not changed, the font size may have changed, so we need
4582 to check the pixel dimensions as well. */
4584 if (columns != FRAME_COLS (f)
4585 || rows != FRAME_LINES (f)
4586 || width != FRAME_PIXEL_WIDTH (f)
4587 || height != FRAME_PIXEL_HEIGHT (f))
4589 change_frame_size (f, rows, columns, 0, 1, 0);
4590 SET_FRAME_GARBAGED (f);
4591 cancel_mouse_face (f);
4592 FRAME_PIXEL_WIDTH (f) = width;
4593 FRAME_PIXEL_HEIGHT (f) = height;
4594 f->win_gravity = NorthWestGravity;
4598 check_visibility = 1;
4599 break;
4601 case WM_MOUSELEAVE:
4602 f = x_any_window_to_frame (dpyinfo, msg.msg.hwnd);
4603 if (f)
4605 if (f == hlinfo->mouse_face_mouse_frame)
4607 /* If we move outside the frame, then we're
4608 certainly no longer on any text in the frame. */
4609 clear_mouse_face (hlinfo);
4610 hlinfo->mouse_face_mouse_frame = 0;
4613 /* Generate a nil HELP_EVENT to cancel a help-echo.
4614 Do it only if there's something to cancel.
4615 Otherwise, the startup message is cleared when
4616 the mouse leaves the frame. */
4617 if (any_help_event_p)
4618 do_help = -1;
4620 break;
4622 case WM_SETFOCUS:
4623 w32_detect_focus_change (dpyinfo, &msg, &inev);
4625 dpyinfo->grabbed = 0;
4626 check_visibility = 1;
4627 break;
4629 case WM_KILLFOCUS:
4630 f = x_top_window_to_frame (dpyinfo, msg.msg.hwnd);
4632 if (f)
4634 if (f == dpyinfo->w32_focus_event_frame)
4635 dpyinfo->w32_focus_event_frame = 0;
4637 if (f == dpyinfo->w32_focus_frame)
4638 x_new_focus_frame (dpyinfo, 0);
4640 if (f == hlinfo->mouse_face_mouse_frame)
4642 /* If we move outside the frame, then we're
4643 certainly no longer on any text in the frame. */
4644 clear_mouse_face (hlinfo);
4645 hlinfo->mouse_face_mouse_frame = 0;
4648 /* Generate a nil HELP_EVENT to cancel a help-echo.
4649 Do it only if there's something to cancel.
4650 Otherwise, the startup message is cleared when
4651 the mouse leaves the frame. */
4652 if (any_help_event_p)
4653 do_help = -1;
4656 dpyinfo->grabbed = 0;
4657 check_visibility = 1;
4658 break;
4660 case WM_CLOSE:
4661 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4663 if (f)
4665 inev.kind = DELETE_WINDOW_EVENT;
4666 XSETFRAME (inev.frame_or_window, f);
4668 break;
4670 case WM_INITMENU:
4671 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4673 if (f)
4675 inev.kind = MENU_BAR_ACTIVATE_EVENT;
4676 XSETFRAME (inev.frame_or_window, f);
4678 break;
4680 case WM_COMMAND:
4681 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4683 if (f)
4685 extern void menubar_selection_callback
4686 (FRAME_PTR f, void * client_data);
4687 menubar_selection_callback (f, (void *)msg.msg.wParam);
4690 check_visibility = 1;
4691 break;
4693 case WM_DISPLAYCHANGE:
4694 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4696 if (f)
4698 dpyinfo->n_cbits = msg.msg.wParam;
4699 DebPrint (("display change: %d %d\n",
4700 (short) LOWORD (msg.msg.lParam),
4701 (short) HIWORD (msg.msg.lParam)));
4704 check_visibility = 1;
4705 break;
4707 default:
4708 /* Check for messages registered at runtime. */
4709 if (msg.msg.message == msh_mousewheel)
4711 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
4712 msg.msg.message = WM_MOUSEWHEEL;
4713 prepend_msg (&msg);
4715 break;
4718 if (inev.kind != NO_EVENT)
4720 kbd_buffer_store_event_hold (&inev, hold_quit);
4721 count++;
4724 if (do_help
4725 && !(hold_quit && hold_quit->kind != NO_EVENT))
4727 Lisp_Object frame;
4729 if (f)
4730 XSETFRAME (frame, f);
4731 else
4732 frame = Qnil;
4734 if (do_help > 0)
4736 if (NILP (help_echo_string))
4738 help_echo_object = help_echo_window = Qnil;
4739 help_echo_pos = -1;
4742 any_help_event_p = 1;
4743 gen_help_event (help_echo_string, frame, help_echo_window,
4744 help_echo_object, help_echo_pos);
4746 else
4748 help_echo_string = Qnil;
4749 gen_help_event (Qnil, frame, Qnil, Qnil, 0);
4751 count++;
4755 /* If the focus was just given to an autoraising frame,
4756 raise it now. */
4757 /* ??? This ought to be able to handle more than one such frame. */
4758 if (pending_autoraise_frame)
4760 x_raise_frame (pending_autoraise_frame);
4761 pending_autoraise_frame = 0;
4764 /* Check which frames are still visisble, if we have enqueued any user
4765 events or been notified of events that may affect visibility. We
4766 do this here because there doesn't seem to be any direct
4767 notification from Windows that the visibility of a window has
4768 changed (at least, not in all cases). */
4769 if (count > 0 || check_visibility)
4771 Lisp_Object tail, frame;
4773 FOR_EACH_FRAME (tail, frame)
4775 FRAME_PTR f = XFRAME (frame);
4776 /* The tooltip has been drawn already. Avoid the
4777 SET_FRAME_GARBAGED below. */
4778 if (EQ (frame, tip_frame))
4779 continue;
4781 /* Check "visible" frames and mark each as obscured or not.
4782 Note that async_visible is nonzero for unobscured and
4783 obscured frames, but zero for hidden and iconified frames. */
4784 if (FRAME_W32_P (f) && f->async_visible)
4786 RECT clipbox;
4787 HDC hdc;
4789 enter_crit ();
4790 /* Query clipping rectangle for the entire window area
4791 (GetWindowDC), not just the client portion (GetDC).
4792 Otherwise, the scrollbars and menubar aren't counted as
4793 part of the visible area of the frame, and we may think
4794 the frame is obscured when really a scrollbar is still
4795 visible and gets WM_PAINT messages above. */
4796 hdc = GetWindowDC (FRAME_W32_WINDOW (f));
4797 GetClipBox (hdc, &clipbox);
4798 ReleaseDC (FRAME_W32_WINDOW (f), hdc);
4799 leave_crit ();
4801 if (clipbox.right == clipbox.left
4802 || clipbox.bottom == clipbox.top)
4804 /* Frame has become completely obscured so mark as
4805 such (we do this by setting async_visible to 2 so
4806 that FRAME_VISIBLE_P is still true, but redisplay
4807 will skip it). */
4808 f->async_visible = 2;
4810 if (!FRAME_OBSCURED_P (f))
4812 DebPrint (("frame %p (%s) obscured\n", f,
4813 SDATA (f->name)));
4816 else
4818 /* Frame is not obscured, so mark it as such. */
4819 f->async_visible = 1;
4821 if (FRAME_OBSCURED_P (f))
4823 SET_FRAME_GARBAGED (f);
4824 DebPrint (("obscured frame %p (%s) found to be visible\n", f,
4825 SDATA (f->name)));
4827 /* Force a redisplay sooner or later. */
4828 record_asynch_buffer_change ();
4835 UNBLOCK_INPUT;
4836 return count;
4841 /***********************************************************************
4842 Text Cursor
4843 ***********************************************************************/
4845 /* Set clipping for output in glyph row ROW. W is the window in which
4846 we operate. GC is the graphics context to set clipping in.
4848 ROW may be a text row or, e.g., a mode line. Text rows must be
4849 clipped to the interior of the window dedicated to text display,
4850 mode lines must be clipped to the whole window. */
4852 static void
4853 w32_clip_to_row (struct window *w, struct glyph_row *row, int area, HDC hdc)
4855 struct frame *f = XFRAME (WINDOW_FRAME (w));
4856 RECT clip_rect;
4857 int window_x, window_y, window_width;
4859 window_box (w, area, &window_x, &window_y, &window_width, 0);
4861 clip_rect.left = window_x;
4862 clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
4863 clip_rect.top = max (clip_rect.top, window_y);
4864 clip_rect.right = clip_rect.left + window_width;
4865 clip_rect.bottom = clip_rect.top + row->visible_height;
4867 w32_set_clip_rectangle (hdc, &clip_rect);
4871 /* Draw a hollow box cursor on window W in glyph row ROW. */
4873 static void
4874 x_draw_hollow_cursor (struct window *w, struct glyph_row *row)
4876 struct frame *f = XFRAME (WINDOW_FRAME (w));
4877 HDC hdc;
4878 RECT rect;
4879 int left, top, h;
4880 struct glyph *cursor_glyph;
4881 HBRUSH hb = CreateSolidBrush (f->output_data.w32->cursor_pixel);
4883 /* Get the glyph the cursor is on. If we can't tell because
4884 the current matrix is invalid or such, give up. */
4885 cursor_glyph = get_phys_cursor_glyph (w);
4886 if (cursor_glyph == NULL)
4887 return;
4889 /* Compute frame-relative coordinates for phys cursor. */
4890 get_phys_cursor_geometry (w, row, cursor_glyph, &left, &top, &h);
4891 rect.left = left;
4892 rect.top = top;
4893 rect.bottom = rect.top + h;
4894 rect.right = rect.left + w->phys_cursor_width;
4896 hdc = get_frame_dc (f);
4897 /* Set clipping, draw the rectangle, and reset clipping again. */
4898 w32_clip_to_row (w, row, TEXT_AREA, hdc);
4899 FrameRect (hdc, &rect, hb);
4900 DeleteObject (hb);
4901 w32_set_clip_rectangle (hdc, NULL);
4902 release_frame_dc (f, hdc);
4906 /* Draw a bar cursor on window W in glyph row ROW.
4908 Implementation note: One would like to draw a bar cursor with an
4909 angle equal to the one given by the font property XA_ITALIC_ANGLE.
4910 Unfortunately, I didn't find a font yet that has this property set.
4911 --gerd. */
4913 static void
4914 x_draw_bar_cursor (struct window *w, struct glyph_row *row,
4915 int width, enum text_cursor_kinds kind)
4917 struct frame *f = XFRAME (w->frame);
4918 struct glyph *cursor_glyph;
4920 /* If cursor is out of bounds, don't draw garbage. This can happen
4921 in mini-buffer windows when switching between echo area glyphs
4922 and mini-buffer. */
4923 cursor_glyph = get_phys_cursor_glyph (w);
4924 if (cursor_glyph == NULL)
4925 return;
4927 /* If on an image, draw like a normal cursor. That's usually better
4928 visible than drawing a bar, esp. if the image is large so that
4929 the bar might not be in the window. */
4930 if (cursor_glyph->type == IMAGE_GLYPH)
4932 struct glyph_row *row;
4933 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
4934 draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
4936 else
4938 COLORREF cursor_color = f->output_data.w32->cursor_pixel;
4939 struct face *face = FACE_FROM_ID (f, cursor_glyph->face_id);
4940 int x;
4941 HDC hdc;
4943 /* If the glyph's background equals the color we normally draw
4944 the bar cursor in, the bar cursor in its normal color is
4945 invisible. Use the glyph's foreground color instead in this
4946 case, on the assumption that the glyph's colors are chosen so
4947 that the glyph is legible. */
4948 if (face->background == cursor_color)
4949 cursor_color = face->foreground;
4951 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
4953 hdc = get_frame_dc (f);
4954 w32_clip_to_row (w, row, TEXT_AREA, hdc);
4956 if (kind == BAR_CURSOR)
4958 if (width < 0)
4959 width = FRAME_CURSOR_WIDTH (f);
4960 width = min (cursor_glyph->pixel_width, width);
4962 w->phys_cursor_width = width;
4964 /* If the character under cursor is R2L, draw the bar cursor
4965 on the right of its glyph, rather than on the left. */
4966 if ((cursor_glyph->resolved_level & 1) != 0)
4967 x += cursor_glyph->pixel_width - width;
4969 w32_fill_area (f, hdc, cursor_color, x,
4970 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
4971 width, row->height);
4973 else
4975 int dummy_x, dummy_y, dummy_h;
4977 if (width < 0)
4978 width = row->height;
4980 width = min (row->height, width);
4982 get_phys_cursor_geometry (w, row, cursor_glyph, &dummy_x,
4983 &dummy_y, &dummy_h);
4984 w32_fill_area (f, hdc, cursor_color, x,
4985 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
4986 row->height - width),
4987 w->phys_cursor_width, width);
4990 w32_set_clip_rectangle (hdc, NULL);
4991 release_frame_dc (f, hdc);
4996 /* RIF: Define cursor CURSOR on frame F. */
4998 static void
4999 w32_define_frame_cursor (struct frame *f, Cursor cursor)
5001 w32_define_cursor (FRAME_W32_WINDOW (f), cursor);
5005 /* RIF: Clear area on frame F. */
5007 static void
5008 w32_clear_frame_area (struct frame *f, int x, int y, int width, int height)
5010 HDC hdc;
5012 hdc = get_frame_dc (f);
5013 w32_clear_area (f, hdc, x, y, width, height);
5014 release_frame_dc (f, hdc);
5017 /* RIF: Draw or clear cursor on window W. */
5019 static void
5020 w32_draw_window_cursor (struct window *w, struct glyph_row *glyph_row,
5021 int x, int y, int cursor_type, int cursor_width,
5022 int on_p, int active_p)
5024 if (on_p)
5026 /* If the user wants to use the system caret, make sure our own
5027 cursor remains invisible. */
5028 if (w32_use_visible_system_caret)
5030 /* Call to erase_phys_cursor here seems to use the
5031 wrong values of w->phys_cursor, as they have been
5032 overwritten before this function was called. */
5033 if (w->phys_cursor_type != NO_CURSOR)
5034 erase_phys_cursor (w);
5036 cursor_type = w->phys_cursor_type = NO_CURSOR;
5037 w->phys_cursor_width = -1;
5039 else
5041 w->phys_cursor_type = cursor_type;
5044 w->phys_cursor_on_p = 1;
5046 /* If this is the active cursor, we need to track it with the
5047 system caret, so third party software like screen magnifiers
5048 and speech synthesizers can follow the cursor. */
5049 if (active_p)
5051 struct frame *f = XFRAME (WINDOW_FRAME (w));
5052 HWND hwnd = FRAME_W32_WINDOW (f);
5054 w32_system_caret_x
5055 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
5056 w32_system_caret_y
5057 = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y)
5058 + glyph_row->ascent - w->phys_cursor_ascent);
5060 PostMessage (hwnd, WM_IME_STARTCOMPOSITION, 0, 0);
5062 /* If the size of the active cursor changed, destroy the old
5063 system caret. */
5064 if (w32_system_caret_hwnd
5065 && (w32_system_caret_height != w->phys_cursor_height))
5066 PostMessage (hwnd, WM_EMACS_DESTROY_CARET, 0, 0);
5068 w32_system_caret_height = w->phys_cursor_height;
5070 /* Move the system caret. */
5071 PostMessage (hwnd, WM_EMACS_TRACK_CARET, 0, 0);
5074 if (glyph_row->exact_window_width_line_p
5075 && (glyph_row->reversed_p
5076 ? (w->phys_cursor.hpos < 0)
5077 : (w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])))
5079 glyph_row->cursor_in_fringe_p = 1;
5080 draw_fringe_bitmap (w, glyph_row, glyph_row->reversed_p);
5081 return;
5084 switch (cursor_type)
5086 case HOLLOW_BOX_CURSOR:
5087 x_draw_hollow_cursor (w, glyph_row);
5088 break;
5090 case FILLED_BOX_CURSOR:
5091 draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
5092 break;
5094 case BAR_CURSOR:
5095 x_draw_bar_cursor (w, glyph_row, cursor_width, BAR_CURSOR);
5096 break;
5098 case HBAR_CURSOR:
5099 x_draw_bar_cursor (w, glyph_row, cursor_width, HBAR_CURSOR);
5100 break;
5102 case NO_CURSOR:
5103 w->phys_cursor_width = 0;
5104 break;
5106 default:
5107 abort ();
5114 /* Icons. */
5117 x_bitmap_icon (struct frame *f, Lisp_Object icon)
5119 HANDLE main_icon;
5120 HANDLE small_icon = NULL;
5122 if (FRAME_W32_WINDOW (f) == 0)
5123 return 1;
5125 if (NILP (icon))
5126 main_icon = LoadIcon (hinst, EMACS_CLASS);
5127 else if (STRINGP (icon))
5129 /* Load the main icon from the named file. */
5130 main_icon = LoadImage (NULL, (LPCTSTR) SDATA (icon), IMAGE_ICON, 0, 0,
5131 LR_DEFAULTSIZE | LR_LOADFROMFILE);
5132 /* Try to load a small icon to go with it. */
5133 small_icon = LoadImage (NULL, (LPCSTR) SDATA (icon), IMAGE_ICON,
5134 GetSystemMetrics (SM_CXSMICON),
5135 GetSystemMetrics (SM_CYSMICON),
5136 LR_LOADFROMFILE);
5138 else if (SYMBOLP (icon))
5140 LPCTSTR name;
5142 if (EQ (icon, intern ("application")))
5143 name = (LPCTSTR) IDI_APPLICATION;
5144 else if (EQ (icon, intern ("hand")))
5145 name = (LPCTSTR) IDI_HAND;
5146 else if (EQ (icon, intern ("question")))
5147 name = (LPCTSTR) IDI_QUESTION;
5148 else if (EQ (icon, intern ("exclamation")))
5149 name = (LPCTSTR) IDI_EXCLAMATION;
5150 else if (EQ (icon, intern ("asterisk")))
5151 name = (LPCTSTR) IDI_ASTERISK;
5152 else if (EQ (icon, intern ("winlogo")))
5153 name = (LPCTSTR) IDI_WINLOGO;
5154 else
5155 return 1;
5157 main_icon = LoadIcon (NULL, name);
5159 else
5160 return 1;
5162 if (main_icon == NULL)
5163 return 1;
5165 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_BIG,
5166 (LPARAM) main_icon);
5168 /* If there is a small icon that goes with it, set that too. */
5169 if (small_icon)
5170 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_SMALL,
5171 (LPARAM) small_icon);
5173 return 0;
5177 /************************************************************************
5178 Handling X errors
5179 ************************************************************************/
5181 /* Display Error Handling functions not used on W32. Listing them here
5182 helps diff stay in step when comparing w32term.c with xterm.c.
5184 x_error_catcher (display, error)
5185 x_catch_errors (dpy)
5186 x_catch_errors_unwind (old_val)
5187 x_check_errors (dpy, format)
5188 x_fully_uncatch_errors ()
5189 x_catching_errors ()
5190 x_had_errors_p (dpy)
5191 x_clear_errors (dpy)
5192 x_uncatch_errors (dpy, count)
5193 x_trace_wire ()
5194 x_connection_signal (signalnum)
5195 x_connection_closed (dpy, error_message)
5196 x_error_quitter (display, error)
5197 x_error_handler (display, error)
5198 x_io_error_quitter (display)
5203 /* Changing the font of the frame. */
5205 Lisp_Object
5206 x_new_font (struct frame *f, Lisp_Object font_object, int fontset)
5208 struct font *font = XFONT_OBJECT (font_object);
5210 if (fontset < 0)
5211 fontset = fontset_from_font (font_object);
5212 FRAME_FONTSET (f) = fontset;
5213 if (FRAME_FONT (f) == font)
5214 /* This font is already set in frame F. There's nothing more to
5215 do. */
5216 return font_object;
5218 FRAME_FONT (f) = font;
5219 FRAME_BASELINE_OFFSET (f) = font->baseline_offset;
5220 FRAME_COLUMN_WIDTH (f) = font->average_width;
5221 FRAME_SPACE_WIDTH (f) = font->space_width;
5222 FRAME_LINE_HEIGHT (f) = font->height;
5224 compute_fringe_widths (f, 1);
5226 /* Compute the scroll bar width in character columns. */
5227 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
5229 int wid = FRAME_COLUMN_WIDTH (f);
5230 FRAME_CONFIG_SCROLL_BAR_COLS (f)
5231 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid - 1) / wid;
5233 else
5235 int wid = FRAME_COLUMN_WIDTH (f);
5236 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
5239 /* Now make the frame display the given font. */
5240 if (FRAME_X_WINDOW (f) != 0)
5242 /* Don't change the size of a tip frame; there's no point in
5243 doing it because it's done in Fx_show_tip, and it leads to
5244 problems because the tip frame has no widget. */
5245 if (NILP (tip_frame) || XFRAME (tip_frame) != f)
5246 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
5249 /* X version sets font of input methods here also. */
5251 return font_object;
5255 /***********************************************************************
5256 TODO: W32 Input Methods
5257 ***********************************************************************/
5258 /* Listing missing functions from xterm.c helps diff stay in step.
5260 xim_destroy_callback (xim, client_data, call_data)
5261 xim_open_dpy (dpyinfo, resource_name)
5262 struct xim_inst_t
5263 xim_instantiate_callback (display, client_data, call_data)
5264 xim_initialize (dpyinfo, resource_name)
5265 xim_close_dpy (dpyinfo)
5270 /* Calculate the absolute position in frame F
5271 from its current recorded position values and gravity. */
5273 void
5274 x_calc_absolute_position (struct frame *f)
5276 int flags = f->size_hint_flags;
5278 /* The sum of the widths of the frame's left and right borders, and
5279 the sum of the heights of the frame's top and bottom borders (in
5280 pixels) drawn by Windows. */
5281 unsigned int left_right_borders_width, top_bottom_borders_height;
5283 /* Try to get the actual values of these two variables. We compute
5284 the border width (height) by subtracting the width (height) of
5285 the frame's client area from the width (height) of the frame's
5286 entire window. */
5287 WINDOWPLACEMENT wp = { 0 };
5288 RECT client_rect = { 0 };
5290 if (GetWindowPlacement (FRAME_W32_WINDOW (f), &wp)
5291 && GetClientRect (FRAME_W32_WINDOW (f), &client_rect))
5293 left_right_borders_width =
5294 (wp.rcNormalPosition.right - wp.rcNormalPosition.left) -
5295 (client_rect.right - client_rect.left);
5297 top_bottom_borders_height =
5298 (wp.rcNormalPosition.bottom - wp.rcNormalPosition.top) -
5299 (client_rect.bottom - client_rect.top);
5301 else
5303 /* Use sensible default values. */
5304 left_right_borders_width = 8;
5305 top_bottom_borders_height = 32;
5308 /* Treat negative positions as relative to the rightmost bottommost
5309 position that fits on the screen. */
5310 if (flags & XNegative)
5311 f->left_pos = (x_display_pixel_width (FRAME_W32_DISPLAY_INFO (f))
5312 - FRAME_PIXEL_WIDTH (f)
5313 + f->left_pos
5314 - (left_right_borders_width - 1));
5316 if (flags & YNegative)
5317 f->top_pos = (x_display_pixel_height (FRAME_W32_DISPLAY_INFO (f))
5318 - FRAME_PIXEL_HEIGHT (f)
5319 + f->top_pos
5320 - (top_bottom_borders_height - 1));
5322 /* The left_pos and top_pos are now relative to the top and left
5323 screen edges, so the flags should correspond. */
5324 f->size_hint_flags &= ~ (XNegative | YNegative);
5327 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5328 to really change the position, and 0 when calling from
5329 x_make_frame_visible (in that case, XOFF and YOFF are the current
5330 position values). It is -1 when calling from x_set_frame_parameters,
5331 which means, do adjust for borders but don't change the gravity. */
5333 void
5334 x_set_offset (struct frame *f, register int xoff, register int yoff,
5335 int change_gravity)
5337 int modified_top, modified_left;
5339 if (change_gravity > 0)
5341 f->top_pos = yoff;
5342 f->left_pos = xoff;
5343 f->size_hint_flags &= ~ (XNegative | YNegative);
5344 if (xoff < 0)
5345 f->size_hint_flags |= XNegative;
5346 if (yoff < 0)
5347 f->size_hint_flags |= YNegative;
5348 f->win_gravity = NorthWestGravity;
5350 x_calc_absolute_position (f);
5352 BLOCK_INPUT;
5353 x_wm_set_size_hint (f, (long) 0, 0);
5355 modified_left = f->left_pos;
5356 modified_top = f->top_pos;
5358 my_set_window_pos (FRAME_W32_WINDOW (f),
5359 NULL,
5360 modified_left, modified_top,
5361 0, 0,
5362 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
5363 UNBLOCK_INPUT;
5367 /* Check if we need to resize the frame due to a fullscreen request.
5368 If so needed, resize the frame. */
5369 static void
5370 x_check_fullscreen (struct frame *f)
5372 if (f->want_fullscreen & FULLSCREEN_BOTH)
5374 int width, height, ign;
5376 x_real_positions (f, &f->left_pos, &f->top_pos);
5378 x_fullscreen_adjust (f, &width, &height, &ign, &ign);
5380 /* We do not need to move the window, it shall be taken care of
5381 when setting WM manager hints. */
5382 if (FRAME_COLS (f) != width || FRAME_LINES (f) != height)
5384 change_frame_size (f, height, width, 0, 1, 0);
5385 SET_FRAME_GARBAGED (f);
5386 cancel_mouse_face (f);
5388 /* Wait for the change of frame size to occur */
5389 f->want_fullscreen |= FULLSCREEN_WAIT;
5394 /* Call this to change the size of frame F's x-window.
5395 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5396 for this size change and subsequent size changes.
5397 Otherwise we leave the window gravity unchanged. */
5399 void
5400 x_set_window_size (struct frame *f, int change_gravity, int cols, int rows)
5402 int pixelwidth, pixelheight;
5404 BLOCK_INPUT;
5406 check_frame_size (f, &rows, &cols);
5407 f->scroll_bar_actual_width
5408 = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
5410 compute_fringe_widths (f, 0);
5412 pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols);
5413 pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
5415 f->win_gravity = NorthWestGravity;
5416 x_wm_set_size_hint (f, (long) 0, 0);
5419 RECT rect;
5421 rect.left = rect.top = 0;
5422 rect.right = pixelwidth;
5423 rect.bottom = pixelheight;
5425 AdjustWindowRect (&rect, f->output_data.w32->dwStyle,
5426 FRAME_EXTERNAL_MENU_BAR (f));
5428 my_set_window_pos (FRAME_W32_WINDOW (f),
5429 NULL,
5430 0, 0,
5431 rect.right - rect.left,
5432 rect.bottom - rect.top,
5433 SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
5436 #if 0
5437 /* The following mirrors what is done in xterm.c. It appears to be
5438 for informing lisp of the new size immediately, while the actual
5439 resize will happen asynchronously. But on Windows, the menu bar
5440 automatically wraps when the frame is too narrow to contain it,
5441 and that causes any calculations made here to come out wrong. The
5442 end is some nasty buggy behavior, including the potential loss
5443 of the minibuffer.
5445 Disabling this code is either not sufficient to fix the problems
5446 completely, or it causes fresh problems, but at least it removes
5447 the most problematic symptom of the minibuffer becoming unusable.
5449 -----------------------------------------------------------------
5451 Now, strictly speaking, we can't be sure that this is accurate,
5452 but the window manager will get around to dealing with the size
5453 change request eventually, and we'll hear how it went when the
5454 ConfigureNotify event gets here.
5456 We could just not bother storing any of this information here,
5457 and let the ConfigureNotify event set everything up, but that
5458 might be kind of confusing to the Lisp code, since size changes
5459 wouldn't be reported in the frame parameters until some random
5460 point in the future when the ConfigureNotify event arrives.
5462 We pass 1 for DELAY since we can't run Lisp code inside of
5463 a BLOCK_INPUT. */
5464 change_frame_size (f, rows, cols, 0, 1, 0);
5465 FRAME_PIXEL_WIDTH (f) = pixelwidth;
5466 FRAME_PIXEL_HEIGHT (f) = pixelheight;
5468 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5469 receive in the ConfigureNotify event; if we get what we asked
5470 for, then the event won't cause the screen to become garbaged, so
5471 we have to make sure to do it here. */
5472 SET_FRAME_GARBAGED (f);
5474 /* If cursor was outside the new size, mark it as off. */
5475 mark_window_cursors_off (XWINDOW (f->root_window));
5477 /* Clear out any recollection of where the mouse highlighting was,
5478 since it might be in a place that's outside the new frame size.
5479 Actually checking whether it is outside is a pain in the neck,
5480 so don't try--just let the highlighting be done afresh with new size. */
5481 cancel_mouse_face (f);
5482 #endif
5484 UNBLOCK_INPUT;
5487 /* Mouse warping. */
5489 void x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y);
5491 void
5492 x_set_mouse_position (struct frame *f, int x, int y)
5494 int pix_x, pix_y;
5496 pix_x = FRAME_COL_TO_PIXEL_X (f, x) + FRAME_COLUMN_WIDTH (f) / 2;
5497 pix_y = FRAME_LINE_TO_PIXEL_Y (f, y) + FRAME_LINE_HEIGHT (f) / 2;
5499 if (pix_x < 0) pix_x = 0;
5500 if (pix_x > FRAME_PIXEL_WIDTH (f)) pix_x = FRAME_PIXEL_WIDTH (f);
5502 if (pix_y < 0) pix_y = 0;
5503 if (pix_y > FRAME_PIXEL_HEIGHT (f)) pix_y = FRAME_PIXEL_HEIGHT (f);
5505 x_set_mouse_pixel_position (f, pix_x, pix_y);
5508 void
5509 x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y)
5511 RECT rect;
5512 POINT pt;
5514 BLOCK_INPUT;
5516 GetClientRect (FRAME_W32_WINDOW (f), &rect);
5517 pt.x = rect.left + pix_x;
5518 pt.y = rect.top + pix_y;
5519 ClientToScreen (FRAME_W32_WINDOW (f), &pt);
5521 SetCursorPos (pt.x, pt.y);
5523 UNBLOCK_INPUT;
5527 /* focus shifting, raising and lowering. */
5529 void
5530 x_focus_on_frame (struct frame *f)
5532 struct w32_display_info *dpyinfo = &one_w32_display_info;
5534 /* Give input focus to frame. */
5535 BLOCK_INPUT;
5536 #if 0
5537 /* Try not to change its Z-order if possible. */
5538 if (x_window_to_frame (dpyinfo, GetForegroundWindow ()))
5539 my_set_focus (f, FRAME_W32_WINDOW (f));
5540 else
5541 #endif
5542 my_set_foreground_window (FRAME_W32_WINDOW (f));
5543 UNBLOCK_INPUT;
5546 void
5547 x_unfocus_frame (struct frame *f)
5551 /* Raise frame F. */
5552 void
5553 x_raise_frame (struct frame *f)
5555 BLOCK_INPUT;
5557 /* Strictly speaking, raise-frame should only change the frame's Z
5558 order, leaving input focus unchanged. This is reasonable behavior
5559 on X where the usual policy is point-to-focus. However, this
5560 behavior would be very odd on Windows where the usual policy is
5561 click-to-focus.
5563 On X, if the mouse happens to be over the raised frame, it gets
5564 input focus anyway (so the window with focus will never be
5565 completely obscured) - if not, then just moving the mouse over it
5566 is sufficient to give it focus. On Windows, the user must actually
5567 click on the frame (preferrably the title bar so as not to move
5568 point), which is more awkward. Also, no other Windows program
5569 raises a window to the top but leaves another window (possibly now
5570 completely obscured) with input focus.
5572 Because there is a system setting on Windows that allows the user
5573 to choose the point to focus policy, we make the strict semantics
5574 optional, but by default we grab focus when raising. */
5576 if (NILP (Vw32_grab_focus_on_raise))
5578 /* The obvious call to my_set_window_pos doesn't work if Emacs is
5579 not already the foreground application: the frame is raised
5580 above all other frames belonging to us, but not above the
5581 current top window. To achieve that, we have to resort to this
5582 more cumbersome method. */
5584 HDWP handle = BeginDeferWindowPos (2);
5585 if (handle)
5587 DeferWindowPos (handle,
5588 FRAME_W32_WINDOW (f),
5589 HWND_TOP,
5590 0, 0, 0, 0,
5591 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
5593 DeferWindowPos (handle,
5594 GetForegroundWindow (),
5595 FRAME_W32_WINDOW (f),
5596 0, 0, 0, 0,
5597 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
5599 EndDeferWindowPos (handle);
5602 else
5604 my_set_foreground_window (FRAME_W32_WINDOW (f));
5607 UNBLOCK_INPUT;
5610 /* Lower frame F. */
5611 void
5612 x_lower_frame (struct frame *f)
5614 BLOCK_INPUT;
5615 my_set_window_pos (FRAME_W32_WINDOW (f),
5616 HWND_BOTTOM,
5617 0, 0, 0, 0,
5618 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
5619 UNBLOCK_INPUT;
5622 static void
5623 w32_frame_raise_lower (FRAME_PTR f, int raise_flag)
5625 if (! FRAME_W32_P (f))
5626 return;
5628 if (raise_flag)
5629 x_raise_frame (f);
5630 else
5631 x_lower_frame (f);
5634 /* Change of visibility. */
5636 /* This tries to wait until the frame is really visible.
5637 However, if the window manager asks the user where to position
5638 the frame, this will return before the user finishes doing that.
5639 The frame will not actually be visible at that time,
5640 but it will become visible later when the window manager
5641 finishes with it. */
5643 void
5644 x_make_frame_visible (struct frame *f)
5646 Lisp_Object type;
5648 BLOCK_INPUT;
5650 type = x_icon_type (f);
5651 if (!NILP (type))
5652 x_bitmap_icon (f, type);
5654 if (! FRAME_VISIBLE_P (f))
5656 /* We test FRAME_GARBAGED_P here to make sure we don't
5657 call x_set_offset a second time
5658 if we get to x_make_frame_visible a second time
5659 before the window gets really visible. */
5660 if (! FRAME_ICONIFIED_P (f)
5661 && ! f->output_data.w32->asked_for_visible)
5663 RECT workarea_rect;
5664 RECT window_rect;
5666 /* Adjust vertical window position in order to avoid being
5667 covered by a task bar placed at the bottom of the desktop. */
5668 SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0);
5669 GetWindowRect (FRAME_W32_WINDOW (f), &window_rect);
5670 if (window_rect.bottom > workarea_rect.bottom
5671 && window_rect.top > workarea_rect.top)
5672 f->top_pos = max (window_rect.top
5673 - window_rect.bottom + workarea_rect.bottom,
5674 workarea_rect.top);
5676 x_set_offset (f, f->left_pos, f->top_pos, 0);
5679 f->output_data.w32->asked_for_visible = 1;
5681 /* The first of these seems to give more expected behavior, but
5682 was added as a commented out line in Sept 1997, with the
5683 second version remaining uncommented. There may have been
5684 some problem with it that led to it not being enabled,
5685 so the old version remains commented out below in case we
5686 decide we need to go back to it [23.0.60 2008-06-09]. */
5687 my_show_window (f, FRAME_W32_WINDOW (f),
5688 f->async_iconified ? SW_RESTORE : SW_SHOW);
5689 /* my_show_window (f, FRAME_W32_WINDOW (f), SW_SHOWNORMAL); */
5692 /* Synchronize to ensure Emacs knows the frame is visible
5693 before we do anything else. We do this loop with input not blocked
5694 so that incoming events are handled. */
5696 Lisp_Object frame;
5697 int count;
5699 /* This must come after we set COUNT. */
5700 UNBLOCK_INPUT;
5702 XSETFRAME (frame, f);
5704 /* Wait until the frame is visible. Process X events until a
5705 MapNotify event has been seen, or until we think we won't get a
5706 MapNotify at all.. */
5707 for (count = input_signal_count + 10;
5708 input_signal_count < count && !FRAME_VISIBLE_P (f);)
5710 /* Force processing of queued events. */
5711 /* TODO: x_sync equivalent? */
5713 /* Machines that do polling rather than SIGIO have been observed
5714 to go into a busy-wait here. So we'll fake an alarm signal
5715 to let the handler know that there's something to be read.
5716 We used to raise a real alarm, but it seems that the handler
5717 isn't always enabled here. This is probably a bug. */
5718 if (input_polling_used ())
5720 /* It could be confusing if a real alarm arrives while processing
5721 the fake one. Turn it off and let the handler reset it. */
5722 int old_poll_suppress_count = poll_suppress_count;
5723 poll_suppress_count = 1;
5724 poll_for_input_1 ();
5725 poll_suppress_count = old_poll_suppress_count;
5728 FRAME_SAMPLE_VISIBILITY (f);
5732 /* Change from mapped state to withdrawn state. */
5734 /* Make the frame visible (mapped and not iconified). */
5736 void
5737 x_make_frame_invisible (struct frame *f)
5739 /* Don't keep the highlight on an invisible frame. */
5740 if (FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame == f)
5741 FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame = 0;
5743 BLOCK_INPUT;
5745 my_show_window (f, FRAME_W32_WINDOW (f), SW_HIDE);
5747 /* We can't distinguish this from iconification
5748 just by the event that we get from the server.
5749 So we can't win using the usual strategy of letting
5750 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5751 and synchronize with the server to make sure we agree. */
5752 f->visible = 0;
5753 FRAME_ICONIFIED_P (f) = 0;
5754 f->async_visible = 0;
5755 f->async_iconified = 0;
5757 UNBLOCK_INPUT;
5760 /* Change window state from mapped to iconified. */
5762 void
5763 x_iconify_frame (struct frame *f)
5765 Lisp_Object type;
5767 /* Don't keep the highlight on an invisible frame. */
5768 if (FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame == f)
5769 FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame = 0;
5771 if (f->async_iconified)
5772 return;
5774 BLOCK_INPUT;
5776 type = x_icon_type (f);
5777 if (!NILP (type))
5778 x_bitmap_icon (f, type);
5780 /* Simulate the user minimizing the frame. */
5781 SendMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, SC_MINIMIZE, 0);
5783 UNBLOCK_INPUT;
5787 /* Free X resources of frame F. */
5789 void
5790 x_free_frame_resources (struct frame *f)
5792 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
5793 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
5795 BLOCK_INPUT;
5797 /* We must free faces before destroying windows because some
5798 font-driver (e.g. xft) access a window while finishing a
5799 face. */
5800 if (FRAME_FACE_CACHE (f))
5801 free_frame_faces (f);
5803 if (FRAME_W32_WINDOW (f))
5804 my_destroy_window (f, FRAME_W32_WINDOW (f));
5806 free_frame_menubar (f);
5808 unload_color (f, FRAME_FOREGROUND_PIXEL (f));
5809 unload_color (f, FRAME_BACKGROUND_PIXEL (f));
5810 unload_color (f, f->output_data.w32->cursor_pixel);
5811 unload_color (f, f->output_data.w32->cursor_foreground_pixel);
5812 unload_color (f, f->output_data.w32->border_pixel);
5813 unload_color (f, f->output_data.w32->mouse_pixel);
5814 if (f->output_data.w32->white_relief.allocated_p)
5815 unload_color (f, f->output_data.w32->white_relief.pixel);
5816 if (f->output_data.w32->black_relief.allocated_p)
5817 unload_color (f, f->output_data.w32->black_relief.pixel);
5819 if (FRAME_FACE_CACHE (f))
5820 free_frame_faces (f);
5822 xfree (f->output_data.w32);
5823 f->output_data.w32 = NULL;
5825 if (f == dpyinfo->w32_focus_frame)
5826 dpyinfo->w32_focus_frame = 0;
5827 if (f == dpyinfo->w32_focus_event_frame)
5828 dpyinfo->w32_focus_event_frame = 0;
5829 if (f == dpyinfo->x_highlight_frame)
5830 dpyinfo->x_highlight_frame = 0;
5832 if (f == hlinfo->mouse_face_mouse_frame)
5834 hlinfo->mouse_face_beg_row
5835 = hlinfo->mouse_face_beg_col = -1;
5836 hlinfo->mouse_face_end_row
5837 = hlinfo->mouse_face_end_col = -1;
5838 hlinfo->mouse_face_window = Qnil;
5839 hlinfo->mouse_face_deferred_gc = 0;
5840 hlinfo->mouse_face_mouse_frame = 0;
5843 UNBLOCK_INPUT;
5847 /* Destroy the window of frame F. */
5848 void
5849 x_destroy_window (struct frame *f)
5851 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
5853 x_free_frame_resources (f);
5854 dpyinfo->reference_count--;
5858 /* Setting window manager hints. */
5860 /* Set the normal size hints for the window manager, for frame F.
5861 FLAGS is the flags word to use--or 0 meaning preserve the flags
5862 that the window now has.
5863 If USER_POSITION is nonzero, we set the USPosition
5864 flag (this is useful when FLAGS is 0). */
5865 void
5866 x_wm_set_size_hint (struct frame *f, long flags, int user_position)
5868 Window window = FRAME_W32_WINDOW (f);
5870 enter_crit ();
5872 SetWindowLong (window, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
5873 SetWindowLong (window, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
5874 SetWindowLong (window, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
5875 SetWindowLong (window, WND_SCROLLBAR_INDEX, f->scroll_bar_actual_width);
5877 leave_crit ();
5880 /* Window manager things */
5881 void
5882 x_wm_set_icon_position (struct frame *f, int icon_x, int icon_y)
5884 #if 0
5885 Window window = FRAME_W32_WINDOW (f);
5887 f->display.x->wm_hints.flags |= IconPositionHint;
5888 f->display.x->wm_hints.icon_x = icon_x;
5889 f->display.x->wm_hints.icon_y = icon_y;
5891 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->display.x->wm_hints);
5892 #endif
5896 /***********************************************************************
5897 Initialization
5898 ***********************************************************************/
5900 static int w32_initialized = 0;
5902 void
5903 w32_initialize_display_info (Lisp_Object display_name)
5905 struct w32_display_info *dpyinfo = &one_w32_display_info;
5906 Mouse_HLInfo *hlinfo = &dpyinfo->mouse_highlight;
5908 memset (dpyinfo, 0, sizeof (*dpyinfo));
5910 /* Put it on w32_display_name_list. */
5911 w32_display_name_list = Fcons (Fcons (display_name, Qnil),
5912 w32_display_name_list);
5913 dpyinfo->name_list_element = XCAR (w32_display_name_list);
5915 dpyinfo->w32_id_name
5916 = (char *) xmalloc (SCHARS (Vinvocation_name)
5917 + SCHARS (Vsystem_name)
5918 + 2);
5919 sprintf (dpyinfo->w32_id_name, "%s@%s",
5920 SDATA (Vinvocation_name), SDATA (Vsystem_name));
5922 /* Default Console mode values - overridden when running in GUI mode
5923 with values obtained from system metrics. */
5924 dpyinfo->resx = 1;
5925 dpyinfo->resy = 1;
5926 dpyinfo->n_planes = 1;
5927 dpyinfo->n_cbits = 4;
5928 dpyinfo->n_fonts = 0;
5929 dpyinfo->smallest_font_height = 1;
5930 dpyinfo->smallest_char_width = 1;
5932 hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
5933 hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
5934 hlinfo->mouse_face_face_id = DEFAULT_FACE_ID;
5935 hlinfo->mouse_face_window = Qnil;
5936 hlinfo->mouse_face_overlay = Qnil;
5937 hlinfo->mouse_face_hidden = 0;
5939 dpyinfo->vertical_scroll_bar_cursor = w32_load_cursor (IDC_ARROW);
5940 /* TODO: dpyinfo->gray */
5944 /* Create an xrdb-style database of resources to supersede registry settings.
5945 The database is just a concatenation of C strings, finished by an additional
5946 \0. The strings are submitted to some basic normalization, so
5948 [ *]option[ *]:[ *]value...
5950 becomes
5952 option:value...
5954 but any whitespace following value is not removed. */
5956 static char *
5957 w32_make_rdb (char *xrm_option)
5959 char *buffer = xmalloc (strlen (xrm_option) + 2);
5960 char *current = buffer;
5961 char ch;
5962 int in_option = 1;
5963 int before_value = 0;
5965 do {
5966 ch = *xrm_option++;
5968 if (ch == '\n')
5970 *current++ = '\0';
5971 in_option = 1;
5972 before_value = 0;
5974 else if (ch != ' ')
5976 *current++ = ch;
5977 if (in_option && (ch == ':'))
5979 in_option = 0;
5980 before_value = 1;
5982 else if (before_value)
5984 before_value = 0;
5987 else if (!(in_option || before_value))
5989 *current++ = ch;
5991 } while (ch);
5993 *current = '\0';
5995 return buffer;
5998 void
5999 x_flush (struct frame * f)
6000 { /* Nothing to do */ }
6003 extern frame_parm_handler w32_frame_parm_handlers[];
6005 static struct redisplay_interface w32_redisplay_interface =
6007 w32_frame_parm_handlers,
6008 x_produce_glyphs,
6009 x_write_glyphs,
6010 x_insert_glyphs,
6011 x_clear_end_of_line,
6012 x_scroll_run,
6013 x_after_update_window_line,
6014 x_update_window_begin,
6015 x_update_window_end,
6016 x_cursor_to,
6017 x_flush,
6018 0, /* flush_display_optional */
6019 x_clear_window_mouse_face,
6020 x_get_glyph_overhangs,
6021 x_fix_overlapping_area,
6022 w32_draw_fringe_bitmap,
6023 w32_define_fringe_bitmap,
6024 w32_destroy_fringe_bitmap,
6025 w32_compute_glyph_string_overhangs,
6026 x_draw_glyph_string,
6027 w32_define_frame_cursor,
6028 w32_clear_frame_area,
6029 w32_draw_window_cursor,
6030 w32_draw_vertical_window_border,
6031 w32_shift_glyphs_for_insert
6034 static void x_delete_terminal (struct terminal *term);
6036 static struct terminal *
6037 w32_create_terminal (struct w32_display_info *dpyinfo)
6039 struct terminal *terminal;
6041 terminal = create_terminal ();
6043 terminal->type = output_w32;
6044 terminal->display_info.w32 = dpyinfo;
6045 dpyinfo->terminal = terminal;
6047 /* MSVC does not type K&R functions with no arguments correctly, and
6048 so we must explicitly cast them. */
6049 terminal->clear_frame_hook = x_clear_frame;
6050 terminal->ins_del_lines_hook = x_ins_del_lines;
6051 terminal->delete_glyphs_hook = x_delete_glyphs;
6052 terminal->ring_bell_hook = w32_ring_bell;
6053 terminal->reset_terminal_modes_hook = w32_reset_terminal_modes;
6054 terminal->set_terminal_modes_hook = w32_set_terminal_modes;
6055 terminal->update_begin_hook = x_update_begin;
6056 terminal->update_end_hook = x_update_end;
6057 terminal->set_terminal_window_hook = w32_set_terminal_window;
6058 terminal->read_socket_hook = w32_read_socket;
6059 terminal->frame_up_to_date_hook = w32_frame_up_to_date;
6060 terminal->mouse_position_hook = w32_mouse_position;
6061 terminal->frame_rehighlight_hook = w32_frame_rehighlight;
6062 terminal->frame_raise_lower_hook = w32_frame_raise_lower;
6063 // terminal->fullscreen_hook = XTfullscreen_hook;
6064 terminal->set_vertical_scroll_bar_hook = w32_set_vertical_scroll_bar;
6065 terminal->condemn_scroll_bars_hook = w32_condemn_scroll_bars;
6066 terminal->redeem_scroll_bar_hook = w32_redeem_scroll_bar;
6067 terminal->judge_scroll_bars_hook = w32_judge_scroll_bars;
6069 terminal->delete_frame_hook = x_destroy_window;
6070 terminal->delete_terminal_hook = x_delete_terminal;
6072 terminal->rif = &w32_redisplay_interface;
6073 terminal->scroll_region_ok = 1; /* We'll scroll partial frames. */
6074 terminal->char_ins_del_ok = 1;
6075 terminal->line_ins_del_ok = 1; /* We'll just blt 'em. */
6076 terminal->fast_clear_end_of_line = 1; /* X does this well. */
6077 terminal->memory_below_frame = 0; /* We don't remember what scrolls
6078 off the bottom. */
6080 /* We don't yet support separate terminals on W32, so don't try to share
6081 keyboards between virtual terminals that are on the same physical
6082 terminal like X does. */
6083 terminal->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
6084 init_kboard (terminal->kboard);
6085 KVAR (terminal->kboard, Vwindow_system) = intern ("w32");
6086 terminal->kboard->next_kboard = all_kboards;
6087 all_kboards = terminal->kboard;
6088 /* Don't let the initial kboard remain current longer than necessary.
6089 That would cause problems if a file loaded on startup tries to
6090 prompt in the mini-buffer. */
6091 if (current_kboard == initial_kboard)
6092 current_kboard = terminal->kboard;
6093 terminal->kboard->reference_count++;
6095 return terminal;
6098 static void
6099 x_delete_terminal (struct terminal *terminal)
6101 struct w32_display_info *dpyinfo = terminal->display_info.w32;
6102 int i;
6104 /* Protect against recursive calls. delete_frame in
6105 delete_terminal calls us back when it deletes our last frame. */
6106 if (!terminal->name)
6107 return;
6109 BLOCK_INPUT;
6111 x_delete_display (dpyinfo);
6112 UNBLOCK_INPUT;
6115 struct w32_display_info *
6116 w32_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
6118 struct w32_display_info *dpyinfo;
6119 struct terminal *terminal;
6120 HDC hdc;
6122 BLOCK_INPUT;
6124 if (!w32_initialized)
6126 w32_initialize ();
6127 w32_initialized = 1;
6130 w32_initialize_display_info (display_name);
6132 dpyinfo = &one_w32_display_info;
6133 terminal = w32_create_terminal (dpyinfo);
6135 /* Set the name of the terminal. */
6136 terminal->name = (char *) xmalloc (SBYTES (display_name) + 1);
6137 strncpy (terminal->name, SDATA (display_name), SBYTES (display_name));
6138 terminal->name[SBYTES (display_name)] = 0;
6140 dpyinfo->xrdb = xrm_option ? w32_make_rdb (xrm_option) : NULL;
6142 /* Put this display on the chain. */
6143 dpyinfo->next = x_display_list;
6144 x_display_list = dpyinfo;
6146 hdc = GetDC (NULL);
6148 dpyinfo->root_window = GetDesktopWindow ();
6149 dpyinfo->n_planes = GetDeviceCaps (hdc, PLANES);
6150 dpyinfo->n_cbits = GetDeviceCaps (hdc, BITSPIXEL);
6151 dpyinfo->resx = GetDeviceCaps (hdc, LOGPIXELSX);
6152 dpyinfo->resy = GetDeviceCaps (hdc, LOGPIXELSY);
6153 dpyinfo->has_palette = GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE;
6154 ReleaseDC (NULL, hdc);
6156 /* initialise palette with white and black */
6158 XColor color;
6159 w32_defined_color (0, "white", &color, 1);
6160 w32_defined_color (0, "black", &color, 1);
6163 /* Add the default keyboard. */
6164 add_keyboard_wait_descriptor (0);
6166 /* Create Fringe Bitmaps and store them for later use.
6168 On W32, bitmaps are all unsigned short, as Windows requires
6169 bitmap data to be Word aligned. For some reason they are
6170 horizontally reflected compared to how they appear on X, so we
6171 need to bitswap and convert to unsigned shorts before creating
6172 the bitmaps. */
6173 w32_init_fringe (terminal->rif);
6175 #ifdef F_SETOWN
6176 fcntl (connection, F_SETOWN, getpid ());
6177 #endif /* ! defined (F_SETOWN) */
6179 #ifdef SIGIO
6180 if (interrupt_input)
6181 init_sigio (connection);
6182 #endif /* ! defined (SIGIO) */
6184 UNBLOCK_INPUT;
6186 return dpyinfo;
6189 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6190 void
6191 x_delete_display (struct w32_display_info *dpyinfo)
6193 /* Discard this display from w32_display_name_list and w32_display_list.
6194 We can't use Fdelq because that can quit. */
6195 if (! NILP (w32_display_name_list)
6196 && EQ (XCAR (w32_display_name_list), dpyinfo->name_list_element))
6197 w32_display_name_list = XCDR (w32_display_name_list);
6198 else
6200 Lisp_Object tail;
6202 tail = w32_display_name_list;
6203 while (CONSP (tail) && CONSP (XCDR (tail)))
6205 if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
6207 XSETCDR (tail, XCDR (XCDR (tail)));
6208 break;
6210 tail = XCDR (tail);
6214 /* free palette table */
6216 struct w32_palette_entry * plist;
6218 plist = dpyinfo->color_list;
6219 while (plist)
6221 struct w32_palette_entry * pentry = plist;
6222 plist = plist->next;
6223 xfree (pentry);
6225 dpyinfo->color_list = NULL;
6226 if (dpyinfo->palette)
6227 DeleteObject (dpyinfo->palette);
6229 xfree (dpyinfo->w32_id_name);
6231 w32_reset_fringes ();
6234 /* Set up use of W32. */
6236 DWORD WINAPI w32_msg_worker (void * arg);
6238 static void
6239 w32_initialize (void)
6241 HANDLE shell;
6242 HRESULT (WINAPI * set_user_model) (wchar_t * id);
6244 baud_rate = 19200;
6246 w32_system_caret_hwnd = NULL;
6247 w32_system_caret_height = 0;
6248 w32_system_caret_x = 0;
6249 w32_system_caret_y = 0;
6251 /* On Windows 7 and later, we need to set the user model ID
6252 to associate emacsclient launched files with Emacs frames
6253 in the UI. */
6254 shell = GetModuleHandle ("shell32.dll");
6255 if (shell)
6257 set_user_model
6258 = (void *) GetProcAddress (shell,
6259 "SetCurrentProcessExplicitAppUserModelID");
6261 /* If the function is defined, then we are running on Windows 7
6262 or newer, and the UI uses this to group related windows
6263 together. Since emacs, runemacs, emacsclient are related, we
6264 want them grouped even though the executables are different,
6265 so we need to set a consistent ID between them. */
6266 if (set_user_model)
6267 set_user_model (L"GNU.Emacs");
6270 /* Initialize w32_use_visible_system_caret based on whether a screen
6271 reader is in use. */
6272 if (!SystemParametersInfo (SPI_GETSCREENREADER, 0,
6273 &w32_use_visible_system_caret, 0))
6274 w32_use_visible_system_caret = 0;
6276 last_tool_bar_item = -1;
6277 any_help_event_p = 0;
6279 /* Initialize input mode: interrupt_input off, no flow control, allow
6280 8 bit character input, standard quit char. */
6281 Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
6284 DWORD input_locale_id = (DWORD) GetKeyboardLayout (0);
6285 keyboard_codepage = codepage_for_locale ((LCID) (input_locale_id & 0xffff));
6288 /* Create the window thread - it will terminate itself when the app
6289 terminates */
6290 init_crit ();
6292 dwMainThreadId = GetCurrentThreadId ();
6293 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6294 GetCurrentProcess (), &hMainThread, 0, TRUE, DUPLICATE_SAME_ACCESS);
6296 /* Wait for thread to start */
6298 MSG msg;
6300 PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
6302 hWindowsThread = CreateThread (NULL, 0,
6303 w32_msg_worker,
6304 0, 0, &dwWindowsThreadId);
6306 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
6309 /* It is desirable that mainThread should have the same notion of
6310 focus window and active window as windowsThread. Unfortunately, the
6311 following call to AttachThreadInput, which should do precisely what
6312 we need, causes major problems when Emacs is linked as a console
6313 program. Unfortunately, we have good reasons for doing that, so
6314 instead we need to send messages to windowsThread to make some API
6315 calls for us (ones that affect, or depend on, the active/focus
6316 window state.) */
6317 #ifdef ATTACH_THREADS
6318 AttachThreadInput (dwMainThreadId, dwWindowsThreadId, TRUE);
6319 #endif
6321 /* Dynamically link to optional system components. */
6323 HMODULE user_lib = GetModuleHandle ("user32.dll");
6325 #define LOAD_PROC(lib, fn) pfn##fn = (void *) GetProcAddress (lib, #fn)
6327 LOAD_PROC (user_lib, SetLayeredWindowAttributes);
6329 #undef LOAD_PROC
6331 /* Ensure scrollbar handle is at least 5 pixels. */
6332 vertical_scroll_bar_min_handle = 5;
6334 /* For either kind of scroll bar, take account of the arrows; these
6335 effectively form the border of the main scroll bar range. */
6336 vertical_scroll_bar_top_border = vertical_scroll_bar_bottom_border
6337 = GetSystemMetrics (SM_CYVSCROLL);
6341 void
6342 syms_of_w32term (void)
6344 staticpro (&w32_display_name_list);
6345 w32_display_name_list = Qnil;
6347 staticpro (&last_mouse_scroll_bar);
6348 last_mouse_scroll_bar = Qnil;
6350 DEFSYM (Qvendor_specific_keysyms, "vendor-specific-keysyms");
6352 DEFVAR_INT ("w32-num-mouse-buttons",
6353 w32_num_mouse_buttons,
6354 doc: /* Number of physical mouse buttons. */);
6355 w32_num_mouse_buttons = 2;
6357 DEFVAR_LISP ("w32-swap-mouse-buttons",
6358 Vw32_swap_mouse_buttons,
6359 doc: /* Swap the mapping of middle and right mouse buttons.
6360 When nil, middle button is mouse-2 and right button is mouse-3. */);
6361 Vw32_swap_mouse_buttons = Qnil;
6363 DEFVAR_LISP ("w32-grab-focus-on-raise",
6364 Vw32_grab_focus_on_raise,
6365 doc: /* Raised frame grabs input focus.
6366 When t, `raise-frame' grabs input focus as well. This fits well
6367 with the normal Windows click-to-focus policy, but might not be
6368 desirable when using a point-to-focus policy. */);
6369 Vw32_grab_focus_on_raise = Qt;
6371 DEFVAR_LISP ("w32-capslock-is-shiftlock",
6372 Vw32_capslock_is_shiftlock,
6373 doc: /* Apply CapsLock state to non character input keys.
6374 When nil, CapsLock only affects normal character input keys. */);
6375 Vw32_capslock_is_shiftlock = Qnil;
6377 DEFVAR_LISP ("w32-recognize-altgr",
6378 Vw32_recognize_altgr,
6379 doc: /* Recognize right-alt and left-ctrl as AltGr.
6380 When nil, the right-alt and left-ctrl key combination is
6381 interpreted normally. */);
6382 Vw32_recognize_altgr = Qt;
6384 DEFVAR_BOOL ("w32-use-visible-system-caret",
6385 w32_use_visible_system_caret,
6386 doc: /* Flag to make the system caret visible.
6387 When this is non-nil, Emacs will indicate the position of point by
6388 using the system caret instead of drawing its own cursor. Some screen
6389 reader software does not track the system cursor properly when it is
6390 invisible, and gets confused by Emacs drawing its own cursor, so this
6391 variable is initialized to t when Emacs detects that screen reader
6392 software is running as it starts up.
6394 When this variable is set, other variables affecting the appearance of
6395 the cursor have no effect. */);
6397 w32_use_visible_system_caret = 0;
6399 /* We don't yet support this, but defining this here avoids whining
6400 from cus-start.el and other places, like "M-x set-variable". */
6401 DEFVAR_BOOL ("x-use-underline-position-properties",
6402 x_use_underline_position_properties,
6403 doc: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
6404 A value of nil means ignore them. If you encounter fonts with bogus
6405 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
6406 to 4.1, set this to nil. You can also use `underline-minimum-offset'
6407 to override the font's UNDERLINE_POSITION for small font display
6408 sizes. */);
6409 x_use_underline_position_properties = 0;
6411 DEFVAR_BOOL ("x-underline-at-descent-line",
6412 x_underline_at_descent_line,
6413 doc: /* *Non-nil means to draw the underline at the same place as the descent line.
6414 A value of nil means to draw the underline according to the value of the
6415 variable `x-use-underline-position-properties', which is usually at the
6416 baseline level. The default value is nil. */);
6417 x_underline_at_descent_line = 0;
6419 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars,
6420 doc: /* Which toolkit scroll bars Emacs uses, if any.
6421 A value of nil means Emacs doesn't use toolkit scroll bars.
6422 With the X Window system, the value is a symbol describing the
6423 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
6424 With MS Windows, the value is t. */);
6425 Vx_toolkit_scroll_bars = Qt;
6427 staticpro (&last_mouse_motion_frame);
6428 last_mouse_motion_frame = Qnil;