]> code.delx.au - gnu-emacs/blob - src/w32term.c
(x_draw_hollow_cursor): Use get_phys_cursor_geometry.
[gnu-emacs] / src / w32term.c
1 /* Implementation of GUI terminal on the Microsoft W32 API.
2 Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
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.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include <config.h>
23 #include <signal.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include "lisp.h"
27 #include "charset.h"
28 #include "blockinput.h"
29
30 #include "w32heap.h"
31 #include "w32term.h"
32 #include "w32bdf.h"
33 #include <shellapi.h>
34
35 #include "systty.h"
36 #include "systime.h"
37 #include "atimer.h"
38 #include "keymap.h"
39
40 #include <ctype.h>
41 #include <errno.h>
42 #include <setjmp.h>
43 #include <sys/stat.h>
44
45 #include "keyboard.h"
46 #include "frame.h"
47 #include "dispextern.h"
48 #include "fontset.h"
49 #include "termhooks.h"
50 #include "termopts.h"
51 #include "termchar.h"
52 #include "gnu.h"
53 #include "disptab.h"
54 #include "buffer.h"
55 #include "window.h"
56 #include "intervals.h"
57 #include "composite.h"
58 #include "coding.h"
59
60 #define abs(x) ((x) < 0 ? -(x) : (x))
61
62 \f
63 /* Fringe bitmaps. */
64
65 static int max_fringe_bmp = 0;
66 static HBITMAP *fringe_bmp = 0;
67
68 /* Non-nil means Emacs uses toolkit scroll bars. */
69
70 Lisp_Object Vx_toolkit_scroll_bars;
71
72 /* Temporary variables for w32_read_socket. */
73
74 static int last_mousemove_x = 0;
75 static int last_mousemove_y = 0;
76
77 /* Define GET_WHEEL_DELTA_WPARAM macro if system headers don't. */
78 #ifndef GET_WHEEL_DELTA_WPARAM
79 #define GET_WHEEL_DELTA_WPARAM(wparam) ((short)HIWORD (wparam))
80 #endif
81
82 /* Non-zero means that a HELP_EVENT has been generated since Emacs
83 start. */
84
85 static int any_help_event_p;
86
87 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
88 static Lisp_Object last_window;
89
90 extern unsigned int msh_mousewheel;
91
92 extern void free_frame_menubar ();
93
94 extern int w32_codepage_for_font (char *fontname);
95 extern Cursor w32_load_cursor (LPCTSTR name);
96
97 extern glyph_metric *w32_BDF_TextMetric(bdffont *fontp,
98 unsigned char *text, int dim);
99 extern Lisp_Object Vwindow_system;
100
101 #define x_any_window_to_frame x_window_to_frame
102 #define x_top_window_to_frame x_window_to_frame
103
104 \f
105 /* This is display since w32 does not support multiple ones. */
106 struct w32_display_info one_w32_display_info;
107 struct w32_display_info *x_display_list;
108
109 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
110 one for each element of w32_display_list and in the same order.
111 NAME is the name of the frame.
112 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
113 Lisp_Object w32_display_name_list;
114
115 /* Frame being updated by update_frame. This is declared in term.c.
116 This is set by update_begin and looked at by all the
117 w32 functions. It is zero while not inside an update.
118 In that case, the w32 functions assume that `SELECTED_FRAME ()'
119 is the frame to apply to. */
120 extern struct frame *updating_frame;
121
122 /* This is a frame waiting to be autoraised, within w32_read_socket. */
123 struct frame *pending_autoraise_frame;
124
125 /* The handle of the frame that currently owns the system caret. */
126 HWND w32_system_caret_hwnd;
127 int w32_system_caret_height;
128 int w32_system_caret_x;
129 int w32_system_caret_y;
130 int w32_use_visible_system_caret;
131
132 /* Flag to enable Unicode output in case users wish to use programs
133 like Twinbridge on '95 rather than installed system level support
134 for Far East languages. */
135 int w32_enable_unicode_output;
136
137 DWORD dwWindowsThreadId = 0;
138 HANDLE hWindowsThread = NULL;
139 DWORD dwMainThreadId = 0;
140 HANDLE hMainThread = NULL;
141
142 #ifndef SIF_ALL
143 /* These definitions are new with Windows 95. */
144 #define SIF_RANGE 0x0001
145 #define SIF_PAGE 0x0002
146 #define SIF_POS 0x0004
147 #define SIF_DISABLENOSCROLL 0x0008
148 #define SIF_TRACKPOS 0x0010
149 #define SIF_ALL (SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS)
150
151 typedef struct tagSCROLLINFO
152 {
153 UINT cbSize;
154 UINT fMask;
155 int nMin;
156 int nMax;
157 UINT nPage;
158 int nPos;
159 int nTrackPos;
160 } SCROLLINFO, FAR *LPSCROLLINFO;
161 typedef SCROLLINFO CONST FAR *LPCSCROLLINFO;
162 #endif /* SIF_ALL */
163
164 /* Dynamic linking to new proportional scroll bar functions. */
165 int (PASCAL *pfnSetScrollInfo) (HWND hwnd, int fnBar, LPSCROLLINFO lpsi, BOOL fRedraw);
166 BOOL (PASCAL *pfnGetScrollInfo) (HWND hwnd, int fnBar, LPSCROLLINFO lpsi);
167
168 int vertical_scroll_bar_min_handle;
169 int vertical_scroll_bar_top_border;
170 int vertical_scroll_bar_bottom_border;
171
172 int last_scroll_bar_drag_pos;
173
174 /* Mouse movement. */
175
176 /* Where the mouse was last time we reported a mouse event. */
177
178 static RECT last_mouse_glyph;
179 static Lisp_Object last_mouse_press_frame;
180
181 int w32_num_mouse_buttons;
182
183 Lisp_Object Vw32_swap_mouse_buttons;
184
185 /* Control whether x_raise_frame also sets input focus. */
186 Lisp_Object Vw32_grab_focus_on_raise;
187
188 /* Control whether Caps Lock affects non-ascii characters. */
189 Lisp_Object Vw32_capslock_is_shiftlock;
190
191 /* Control whether right-alt and left-ctrl should be recognized as AltGr. */
192 Lisp_Object Vw32_recognize_altgr;
193
194 /* The scroll bar in which the last motion event occurred.
195
196 If the last motion event occurred in a scroll bar, we set this
197 so w32_mouse_position can know whether to report a scroll bar motion or
198 an ordinary motion.
199
200 If the last motion event didn't occur in a scroll bar, we set this
201 to Qnil, to tell w32_mouse_position to return an ordinary motion event. */
202 static Lisp_Object last_mouse_scroll_bar;
203 static int last_mouse_scroll_bar_pos;
204
205 /* This is a hack. We would really prefer that w32_mouse_position would
206 return the time associated with the position it returns, but there
207 doesn't seem to be any way to wrest the time-stamp from the server
208 along with the position query. So, we just keep track of the time
209 of the last movement we received, and return that in hopes that
210 it's somewhat accurate. */
211
212 static Time last_mouse_movement_time;
213
214 /* Incremented by w32_read_socket whenever it really tries to read
215 events. */
216
217 #ifdef __STDC__
218 static int volatile input_signal_count;
219 #else
220 static int input_signal_count;
221 #endif
222
223 extern Lisp_Object Vcommand_line_args, Vsystem_name;
224
225 #ifndef USE_CRT_DLL
226 extern int errno;
227 #endif
228
229 /* A mask of extra modifier bits to put into every keyboard char. */
230
231 extern EMACS_INT extra_keyboard_modifiers;
232
233 static void x_update_window_end P_ ((struct window *, int, int));
234 void w32_delete_display P_ ((struct w32_display_info *));
235 static void w32_handle_tool_bar_click P_ ((struct frame *,
236 struct input_event *));
237 void w32_define_cursor P_ ((Window, Cursor));
238
239 void x_lower_frame P_ ((struct frame *));
240 void x_scroll_bar_clear P_ ((struct frame *));
241 void x_wm_set_size_hint P_ ((struct frame *, long, int));
242 void x_raise_frame P_ ((struct frame *));
243 void x_set_window_size P_ ((struct frame *, int, int, int));
244 void x_wm_set_window_state P_ ((struct frame *, int));
245 void x_wm_set_icon_pixmap P_ ((struct frame *, int));
246 void w32_initialize P_ ((void));
247 static void x_font_min_bounds P_ ((XFontStruct *, int *, int *));
248 int x_compute_min_glyph_bounds P_ ((struct frame *));
249 static void x_update_end P_ ((struct frame *));
250 static void w32_frame_up_to_date P_ ((struct frame *));
251 static void w32_set_terminal_modes P_ ((void));
252 static void w32_reset_terminal_modes P_ ((void));
253 static void x_clear_frame P_ ((void));
254 static void frame_highlight P_ ((struct frame *));
255 static void frame_unhighlight P_ ((struct frame *));
256 static void x_new_focus_frame P_ ((struct w32_display_info *,
257 struct frame *));
258 static void w32_frame_rehighlight P_ ((struct frame *));
259 static void x_frame_rehighlight P_ ((struct w32_display_info *));
260 static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *));
261 static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int,
262 enum text_cursor_kinds));
263 static void w32_clip_to_row P_ ((struct window *, struct glyph_row *, int, HDC));
264
265 static Lisp_Object Qvendor_specific_keysyms;
266
267 \f
268 /***********************************************************************
269 Debugging
270 ***********************************************************************/
271
272 #if 0
273
274 /* This is a function useful for recording debugging information about
275 the sequence of occurrences in this file. */
276
277 struct record
278 {
279 char *locus;
280 int type;
281 };
282
283 struct record event_record[100];
284
285 int event_record_index;
286
287 record_event (locus, type)
288 char *locus;
289 int type;
290 {
291 if (event_record_index == sizeof (event_record) / sizeof (struct record))
292 event_record_index = 0;
293
294 event_record[event_record_index].locus = locus;
295 event_record[event_record_index].type = type;
296 event_record_index++;
297 }
298
299 #endif /* 0 */
300 \f
301
302 void
303 XChangeGC (void * ignore, XGCValues* gc, unsigned long mask,
304 XGCValues *xgcv)
305 {
306 if (mask & GCForeground)
307 gc->foreground = xgcv->foreground;
308 if (mask & GCBackground)
309 gc->background = xgcv->background;
310 if (mask & GCFont)
311 gc->font = xgcv->font;
312 }
313
314 XGCValues *XCreateGC (void * ignore, Window window, unsigned long mask,
315 XGCValues *xgcv)
316 {
317 XGCValues *gc = (XGCValues *) xmalloc (sizeof (XGCValues));
318 bzero (gc, sizeof (XGCValues));
319
320 XChangeGC (ignore, gc, mask, xgcv);
321
322 return gc;
323 }
324
325 void
326 XGetGCValues (void* ignore, XGCValues *gc,
327 unsigned long mask, XGCValues *xgcv)
328 {
329 XChangeGC (ignore, xgcv, mask, gc);
330 }
331
332 static void
333 w32_set_clip_rectangle (HDC hdc, RECT *rect)
334 {
335 if (rect)
336 {
337 HRGN clip_region = CreateRectRgnIndirect (rect);
338 SelectClipRgn (hdc, clip_region);
339 DeleteObject (clip_region);
340 }
341 else
342 SelectClipRgn (hdc, NULL);
343 }
344
345
346 /* Draw a hollow rectangle at the specified position. */
347 void
348 w32_draw_rectangle (HDC hdc, XGCValues *gc, int x, int y,
349 int width, int height)
350 {
351 HBRUSH hb, oldhb;
352 HPEN hp, oldhp;
353
354 hb = CreateSolidBrush (gc->background);
355 hp = CreatePen (PS_SOLID, 0, gc->foreground);
356 oldhb = SelectObject (hdc, hb);
357 oldhp = SelectObject (hdc, hp);
358
359 Rectangle (hdc, x, y, x + width, y + height);
360
361 SelectObject (hdc, oldhb);
362 SelectObject (hdc, oldhp);
363 DeleteObject (hb);
364 DeleteObject (hp);
365 }
366
367 /* Draw a filled rectangle at the specified position. */
368 void
369 w32_fill_rect (f, hdc, pix, lprect)
370 FRAME_PTR f;
371 HDC hdc;
372 COLORREF pix;
373 RECT * lprect;
374 {
375 HBRUSH hb;
376
377 hb = CreateSolidBrush (pix);
378 FillRect (hdc, lprect, hb);
379 DeleteObject (hb);
380 }
381
382 void
383 w32_clear_window (f)
384 FRAME_PTR f;
385 {
386 RECT rect;
387 HDC hdc = get_frame_dc (f);
388
389 /* Under certain conditions, this can be called at startup with
390 a console frame pointer before the GUI frame is created. An HDC
391 of 0 indicates this. */
392 if (hdc)
393 {
394 GetClientRect (FRAME_W32_WINDOW (f), &rect);
395 w32_clear_rect (f, hdc, &rect);
396 }
397
398 release_frame_dc (f, hdc);
399 }
400
401 \f
402 /***********************************************************************
403 Starting and ending an update
404 ***********************************************************************/
405
406 /* Start an update of frame F. This function is installed as a hook
407 for update_begin, i.e. it is called when update_begin is called.
408 This function is called prior to calls to x_update_window_begin for
409 each window being updated. */
410
411 static void
412 x_update_begin (f)
413 struct frame *f;
414 {
415 struct w32_display_info *display_info = FRAME_W32_DISPLAY_INFO (f);
416
417 if (! FRAME_W32_P (f))
418 return;
419
420 /* Regenerate display palette before drawing if list of requested
421 colors has changed. */
422 if (display_info->regen_palette)
423 {
424 w32_regenerate_palette (f);
425 display_info->regen_palette = FALSE;
426 }
427 }
428
429
430 /* Start update of window W. Set the global variable updated_window
431 to the window being updated and set output_cursor to the cursor
432 position of W. */
433
434 static void
435 x_update_window_begin (w)
436 struct window *w;
437 {
438 struct frame *f = XFRAME (WINDOW_FRAME (w));
439 struct w32_display_info *display_info = FRAME_W32_DISPLAY_INFO (f);
440
441 /* Hide the system caret during an update. */
442 if (w32_use_visible_system_caret && w32_system_caret_hwnd)
443 {
444 SendMessage (w32_system_caret_hwnd, WM_EMACS_HIDE_CARET, 0, 0);
445 }
446
447 updated_window = w;
448 set_output_cursor (&w->cursor);
449
450 BLOCK_INPUT;
451
452 if (f == display_info->mouse_face_mouse_frame)
453 {
454 /* Don't do highlighting for mouse motion during the update. */
455 display_info->mouse_face_defer = 1;
456
457 /* If F needs to be redrawn, simply forget about any prior mouse
458 highlighting. */
459 if (FRAME_GARBAGED_P (f))
460 display_info->mouse_face_window = Qnil;
461
462 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
463 their mouse_face_p flag set, which means that they are always
464 unequal to rows in a desired matrix which never have that
465 flag set. So, rows containing mouse-face glyphs are never
466 scrolled, and we don't have to switch the mouse highlight off
467 here to prevent it from being scrolled. */
468
469 /* Can we tell that this update does not affect the window
470 where the mouse highlight is? If so, no need to turn off.
471 Likewise, don't do anything if the frame is garbaged;
472 in that case, the frame's current matrix that we would use
473 is all wrong, and we will redisplay that line anyway. */
474 if (!NILP (display_info->mouse_face_window)
475 && w == XWINDOW (display_info->mouse_face_window))
476 {
477 int i;
478
479 for (i = 0; i < w->desired_matrix->nrows; ++i)
480 if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
481 break;
482
483 if (i < w->desired_matrix->nrows)
484 clear_mouse_face (display_info);
485 }
486 #endif /* 0 */
487 }
488
489 UNBLOCK_INPUT;
490 }
491
492 /* Draw a vertical window border from (x,y0) to (x,y1) */
493
494 static void
495 w32_draw_vertical_window_border (w, x, y0, y1)
496 struct window *w;
497 int x, y0, y1;
498 {
499 struct frame *f = XFRAME (WINDOW_FRAME (w));
500 RECT r;
501 HDC hdc;
502
503 r.left = x;
504 r.right = x + 1;
505 r.top = y0;
506 r.bottom = y1;
507
508 hdc = get_frame_dc (f);
509 w32_fill_rect (f, hdc, FRAME_FOREGROUND_PIXEL (f), &r);
510 release_frame_dc (f, hdc);
511 }
512
513
514 /* End update of window W (which is equal to updated_window).
515
516 Draw vertical borders between horizontally adjacent windows, and
517 display W's cursor if CURSOR_ON_P is non-zero.
518
519 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
520 glyphs in mouse-face were overwritten. In that case we have to
521 make sure that the mouse-highlight is properly redrawn.
522
523 W may be a menu bar pseudo-window in case we don't have X toolkit
524 support. Such windows don't have a cursor, so don't display it
525 here. */
526
527 static void
528 x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
529 struct window *w;
530 int cursor_on_p, mouse_face_overwritten_p;
531 {
532 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (XFRAME (w->frame));
533
534 if (!w->pseudo_window_p)
535 {
536 BLOCK_INPUT;
537
538 if (cursor_on_p)
539 display_and_set_cursor (w, 1, output_cursor.hpos,
540 output_cursor.vpos,
541 output_cursor.x, output_cursor.y);
542
543 if (draw_window_fringes (w, 1))
544 x_draw_vertical_border (w);
545
546 UNBLOCK_INPUT;
547 }
548
549 /* If a row with mouse-face was overwritten, arrange for
550 XTframe_up_to_date to redisplay the mouse highlight. */
551 if (mouse_face_overwritten_p)
552 {
553 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
554 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
555 dpyinfo->mouse_face_window = Qnil;
556 }
557
558 /* Unhide the caret. This won't actually show the cursor, unless it
559 was visible before the corresponding call to HideCaret in
560 x_update_window_begin. */
561 if (w32_use_visible_system_caret && w32_system_caret_hwnd)
562 {
563 SendMessage (w32_system_caret_hwnd, WM_EMACS_SHOW_CARET, 0, 0);
564 }
565
566 updated_window = NULL;
567 }
568
569
570 /* End update of frame F. This function is installed as a hook in
571 update_end. */
572
573 static void
574 x_update_end (f)
575 struct frame *f;
576 {
577 if (! FRAME_W32_P (f))
578 return;
579
580 /* Mouse highlight may be displayed again. */
581 FRAME_W32_DISPLAY_INFO (f)->mouse_face_defer = 0;
582 }
583
584
585 /* This function is called from various places in xdisp.c whenever a
586 complete update has been performed. The global variable
587 updated_window is not available here. */
588
589 static void
590 w32_frame_up_to_date (f)
591 struct frame *f;
592 {
593 if (FRAME_W32_P (f))
594 {
595 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
596
597 if (dpyinfo->mouse_face_deferred_gc
598 || f == dpyinfo->mouse_face_mouse_frame)
599 {
600 BLOCK_INPUT;
601 if (dpyinfo->mouse_face_mouse_frame)
602 note_mouse_highlight (dpyinfo->mouse_face_mouse_frame,
603 dpyinfo->mouse_face_mouse_x,
604 dpyinfo->mouse_face_mouse_y);
605 dpyinfo->mouse_face_deferred_gc = 0;
606 UNBLOCK_INPUT;
607 }
608 }
609 }
610
611
612 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
613 arrow bitmaps, or clear the fringes if no bitmaps are required
614 before DESIRED_ROW is made current. The window being updated is
615 found in updated_window. This function is called from
616 update_window_line only if it is known that there are differences
617 between bitmaps to be drawn between current row and DESIRED_ROW. */
618
619 static void
620 x_after_update_window_line (desired_row)
621 struct glyph_row *desired_row;
622 {
623 struct window *w = updated_window;
624 struct frame *f;
625 int width, height;
626
627 xassert (w);
628
629 if (!desired_row->mode_line_p && !w->pseudo_window_p)
630 desired_row->redraw_fringe_bitmaps_p = 1;
631
632 /* When a window has disappeared, make sure that no rest of
633 full-width rows stays visible in the internal border. Could
634 check here if updated_window is the leftmost/rightmost window,
635 but I guess it's not worth doing since vertically split windows
636 are almost never used, internal border is rarely set, and the
637 overhead is very small. */
638 if (windows_or_buffers_changed
639 && desired_row->full_width_p
640 && (f = XFRAME (w->frame),
641 width = FRAME_INTERNAL_BORDER_WIDTH (f),
642 width != 0)
643 && (height = desired_row->visible_height,
644 height > 0))
645 {
646 int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
647
648 /* Internal border is drawn below the tool bar. */
649 if (WINDOWP (f->tool_bar_window)
650 && w == XWINDOW (f->tool_bar_window))
651 y -= width;
652
653 BLOCK_INPUT;
654 {
655 HDC hdc = get_frame_dc (f);
656 w32_clear_area (f, hdc, 0, y, width, height);
657 w32_clear_area (f, hdc, FRAME_PIXEL_WIDTH (f) - width,
658 y, width, height);
659 release_frame_dc (f, hdc);
660 }
661 UNBLOCK_INPUT;
662 }
663 }
664
665
666 /* Draw the bitmap WHICH in one of the left or right fringes of
667 window W. ROW is the glyph row for which to display the bitmap; it
668 determines the vertical position at which the bitmap has to be
669 drawn. */
670
671 static void
672 w32_draw_fringe_bitmap (w, row, p)
673 struct window *w;
674 struct glyph_row *row;
675 struct draw_fringe_bitmap_params *p;
676 {
677 struct frame *f = XFRAME (WINDOW_FRAME (w));
678 HDC hdc;
679 struct face *face = p->face;
680 int rowY;
681
682 hdc = get_frame_dc (f);
683
684 /* Must clip because of partially visible lines. */
685 rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
686 if (p->y < rowY)
687 {
688 /* Adjust position of "bottom aligned" bitmap on partially
689 visible last row. */
690 int oldY = row->y;
691 int oldVH = row->visible_height;
692 row->visible_height = p->h;
693 row->y -= rowY - p->y;
694 w32_clip_to_row (w, row, -1, hdc);
695 row->y = oldY;
696 row->visible_height = oldVH;
697 }
698 else
699 w32_clip_to_row (w, row, -1, hdc);
700
701 if (p->bx >= 0 && !p->overlay_p)
702 {
703 w32_fill_area (f, hdc, face->background,
704 p->bx, p->by, p->nx, p->ny);
705 }
706
707 if (p->which && p->which < max_fringe_bmp)
708 {
709 HBITMAP pixmap = fringe_bmp[p->which];
710 HDC compat_hdc;
711 HANDLE horig_obj;
712
713 compat_hdc = CreateCompatibleDC (hdc);
714
715 SaveDC (hdc);
716
717 horig_obj = SelectObject (compat_hdc, pixmap);
718
719 /* Paint overlays transparently. */
720 if (p->overlay_p)
721 {
722 HBRUSH h_brush, h_orig_brush;
723
724 SetTextColor (hdc, BLACK_PIX_DEFAULT (f));
725 SetBkColor (hdc, WHITE_PIX_DEFAULT (f));
726 h_brush = CreateSolidBrush (face->foreground);
727 h_orig_brush = SelectObject (hdc, h_brush);
728
729 BitBlt (hdc, p->x, p->y, p->wd, p->h,
730 compat_hdc, 0, p->dh,
731 DSTINVERT);
732 BitBlt (hdc, p->x, p->y, p->wd, p->h,
733 compat_hdc, 0, p->dh,
734 0x2E064A);
735 BitBlt (hdc, p->x, p->y, p->wd, p->h,
736 compat_hdc, 0, p->dh,
737 DSTINVERT);
738
739 SelectObject (hdc, h_orig_brush);
740 DeleteObject (h_brush);
741 }
742 else
743 {
744 SetTextColor (hdc, face->background);
745 SetBkColor (hdc, (p->cursor_p
746 ? f->output_data.w32->cursor_pixel
747 : face->foreground));
748
749 BitBlt (hdc, p->x, p->y, p->wd, p->h,
750 compat_hdc, 0, p->dh,
751 SRCCOPY);
752 }
753
754 SelectObject (compat_hdc, horig_obj);
755 DeleteDC (compat_hdc);
756 RestoreDC (hdc, -1);
757 }
758
759 w32_set_clip_rectangle (hdc, NULL);
760
761 release_frame_dc (f, hdc);
762 }
763
764 static void
765 w32_define_fringe_bitmap (which, bits, h, wd)
766 int which;
767 unsigned short *bits;
768 int h, wd;
769 {
770 if (which >= max_fringe_bmp)
771 {
772 int i = max_fringe_bmp;
773 max_fringe_bmp = which + 20;
774 fringe_bmp = (HBITMAP *) xrealloc (fringe_bmp, max_fringe_bmp * sizeof (HBITMAP));
775 while (i < max_fringe_bmp)
776 fringe_bmp[i++] = 0;
777 }
778
779 fringe_bmp[which] = CreateBitmap (wd, h, 1, 1, bits);
780 }
781
782 static void
783 w32_destroy_fringe_bitmap (which)
784 int which;
785 {
786 if (which >= max_fringe_bmp)
787 return;
788
789 if (fringe_bmp[which])
790 DeleteObject (fringe_bmp[which]);
791 fringe_bmp[which] = 0;
792 }
793
794
795 \f
796 /* This is called when starting Emacs and when restarting after
797 suspend. When starting Emacs, no window is mapped. And nothing
798 must be done to Emacs's own window if it is suspended (though that
799 rarely happens). */
800
801 static void
802 w32_set_terminal_modes (void)
803 {
804 }
805
806 /* This is called when exiting or suspending Emacs. Exiting will make
807 the W32 windows go away, and suspending requires no action. */
808
809 static void
810 w32_reset_terminal_modes (void)
811 {
812 }
813
814
815 \f
816 /***********************************************************************
817 Display Iterator
818 ***********************************************************************/
819
820 /* Function prototypes of this page. */
821
822 XCharStruct *w32_per_char_metric P_ ((XFontStruct *, wchar_t *, int));
823 static int w32_encode_char P_ ((int, wchar_t *, struct font_info *, int *));
824
825
826 /* Get metrics of character CHAR2B in FONT. Value is always non-null.
827 If CHAR2B is not contained in FONT, the font's default character
828 metric is returned. */
829
830 static int
831 w32_bdf_per_char_metric (font, char2b, dim, pcm)
832 XFontStruct *font;
833 wchar_t *char2b;
834 int dim;
835 XCharStruct * pcm;
836 {
837 glyph_metric * bdf_metric;
838 char buf[2];
839
840 if (dim == 1)
841 buf[0] = (char)(*char2b);
842 else
843 {
844 buf[0] = XCHAR2B_BYTE1 (char2b);
845 buf[1] = XCHAR2B_BYTE2 (char2b);
846 }
847
848 bdf_metric = w32_BDF_TextMetric (font->bdf, buf, dim);
849
850 if (bdf_metric)
851 {
852 pcm->width = bdf_metric->dwidth;
853 pcm->lbearing = bdf_metric->bbox;
854 pcm->rbearing = bdf_metric->dwidth
855 - (bdf_metric->bbox + bdf_metric->bbw);
856 pcm->ascent = bdf_metric->bboy + bdf_metric->bbh;
857 pcm->descent = -bdf_metric->bboy;
858
859 return 1;
860 }
861 return 0;
862 }
863
864
865 static int
866 w32_native_per_char_metric (font, char2b, font_type, pcm)
867 XFontStruct *font;
868 wchar_t *char2b;
869 enum w32_char_font_type font_type;
870 XCharStruct * pcm;
871 {
872 HDC hdc = GetDC (NULL);
873 HFONT old_font;
874 BOOL retval = FALSE;
875
876 xassert (font && char2b);
877 xassert (font->hfont);
878 xassert (font_type == UNICODE_FONT || font_type == ANSI_FONT);
879
880 old_font = SelectObject (hdc, font->hfont);
881
882 if ((font->tm.tmPitchAndFamily & TMPF_TRUETYPE) != 0)
883 {
884 ABC char_widths;
885
886 if (font_type == UNICODE_FONT)
887 retval = GetCharABCWidthsW (hdc, *char2b, *char2b, &char_widths);
888 else
889 retval = GetCharABCWidthsA (hdc, *char2b, *char2b, &char_widths);
890
891 if (retval)
892 {
893 #if 0
894 /* Disabled until we can find a way to get the right results
895 on all versions of Windows. */
896
897 /* Don't trust the ABC widths. For synthesized fonts they are
898 wrong, and so is the result of GetCharWidth()! */
899 int real_width;
900 GetCharWidth (hdc, *char2b, *char2b, &real_width);
901 #endif
902 pcm->width = char_widths.abcA + char_widths.abcB + char_widths.abcC;
903 #if 0
904 /* As far as I can tell, this is the best way to determine what
905 ExtTextOut will do with the broken font. */
906 if (pcm->width != real_width)
907 pcm->width = (pcm->width + real_width) / 2;
908 #endif
909 pcm->lbearing = char_widths.abcA;
910 pcm->rbearing = char_widths.abcA + char_widths.abcB;
911 pcm->ascent = FONT_BASE (font);
912 pcm->descent = FONT_DESCENT (font);
913 }
914 }
915
916 if (!retval)
917 {
918 /* Either font is not a True-type font, or GetCharABCWidthsW
919 failed (it is not supported on Windows 9x for instance), so we
920 can't determine the full info we would like. All is not lost
921 though - we can call GetTextExtentPoint32 to get rbearing and
922 deduce width based on the font's per-string overhang. lbearing
923 is assumed to be zero. */
924
925 /* TODO: Some Thai characters (and other composites if Windows
926 supports them) do have lbearing, and report their total width
927 as zero. Need some way of handling them when
928 GetCharABCWidthsW fails. */
929 SIZE sz;
930
931 if (font_type == UNICODE_FONT)
932 retval = GetTextExtentPoint32W (hdc, char2b, 1, &sz);
933 else
934 retval = GetTextExtentPoint32A (hdc, (char*)char2b, 1, &sz);
935
936 if (retval)
937 {
938 pcm->width = sz.cx - font->tm.tmOverhang;
939 pcm->rbearing = sz.cx;
940 pcm->lbearing = 0;
941 pcm->ascent = FONT_BASE (font);
942 pcm->descent = FONT_DESCENT (font);
943 }
944 }
945
946
947 if (pcm->width == 0 && (pcm->rbearing - pcm->lbearing) == 0)
948 {
949 retval = FALSE;
950 }
951
952 SelectObject (hdc, old_font);
953 ReleaseDC (NULL, hdc);
954
955 return retval;
956 }
957
958
959 XCharStruct *
960 w32_per_char_metric (font, char2b, font_type)
961 XFontStruct *font;
962 wchar_t *char2b;
963 int /* enum w32_char_font_type */ font_type;
964 {
965 /* The result metric information. */
966 XCharStruct *pcm;
967 BOOL retval;
968
969 xassert (font && char2b);
970
971 /* TODO: This function is currently called through the RIF, and in
972 some cases font_type is UNKNOWN_FONT. We currently allow the
973 cached metrics to be used, which seems to work, but in cases
974 where font_type is UNKNOWN_FONT, we probably haven't encoded
975 char2b appropriately. All callers need checking to see what they
976 are passing. This is most likely to affect variable width fonts
977 outside the Latin-1 range, particularly in languages like Thai
978 that rely on rbearing and lbearing to provide composition. I
979 don't think that is working currently anyway, but we don't seem
980 to have anyone testing such languages on Windows. */
981
982 /* Handle the common cases quickly. */
983 if (!font->bdf && font->per_char == NULL)
984 /* TODO: determine whether char2b exists in font? */
985 return &font->max_bounds;
986 else if (!font->bdf && *char2b < 128)
987 return &font->per_char[*char2b];
988
989 xassert (font_type != UNKNOWN_FONT);
990
991 pcm = &font->scratch;
992
993 if (font_type == BDF_1D_FONT)
994 retval = w32_bdf_per_char_metric (font, char2b, 1, pcm);
995 else if (font_type == BDF_2D_FONT)
996 retval = w32_bdf_per_char_metric (font, char2b, 2, pcm);
997 else
998 retval = w32_native_per_char_metric (font, char2b, font_type, pcm);
999
1000 if (retval)
1001 return pcm;
1002
1003 return NULL;
1004 }
1005
1006 void
1007 w32_cache_char_metrics (font)
1008 XFontStruct *font;
1009 {
1010 wchar_t char2b = L'x';
1011
1012 /* Cache char metrics for the common cases. */
1013 if (font->bdf)
1014 {
1015 /* TODO: determine whether font is fixed-pitch. */
1016 if (!w32_bdf_per_char_metric (font, &char2b, 1, &font->max_bounds))
1017 {
1018 /* Use the font width and height as max bounds, as not all BDF
1019 fonts contain the letter 'x'. */
1020 font->max_bounds.width = FONT_MAX_WIDTH (font);
1021 font->max_bounds.lbearing = -font->bdf->llx;
1022 font->max_bounds.rbearing = FONT_MAX_WIDTH (font) - font->bdf->urx;
1023 font->max_bounds.ascent = FONT_BASE (font);
1024 font->max_bounds.descent = FONT_DESCENT (font);
1025 }
1026 }
1027 else
1028 {
1029 if (((font->tm.tmPitchAndFamily & TMPF_FIXED_PITCH) != 0)
1030 /* Some fonts (eg DBCS fonts) are marked as fixed width even
1031 though they contain characters of different widths. */
1032 || (font->tm.tmMaxCharWidth != font->tm.tmAveCharWidth))
1033 {
1034 /* Font is not fixed pitch, so cache per_char info for the
1035 ASCII characters. It would be much more work, and probably
1036 not worth it, to cache other chars, since we may change
1037 between using Unicode and ANSI text drawing functions at
1038 run-time. */
1039 int i;
1040
1041 font->per_char = xmalloc (128 * sizeof(XCharStruct));
1042 for (i = 0; i < 128; i++)
1043 {
1044 char2b = i;
1045 w32_native_per_char_metric (font, &char2b, ANSI_FONT,
1046 &font->per_char[i]);
1047 }
1048 }
1049 else
1050 w32_native_per_char_metric (font, &char2b, ANSI_FONT,
1051 &font->max_bounds);
1052 }
1053 }
1054
1055
1056 /* Determine if a font is double byte. */
1057 int w32_font_is_double_byte (XFontStruct *font)
1058 {
1059 return font->double_byte_p;
1060 }
1061
1062
1063 static BOOL
1064 w32_use_unicode_for_codepage (codepage)
1065 int codepage;
1066 {
1067 /* If the current codepage is supported, use Unicode for output. */
1068 return (w32_enable_unicode_output
1069 && codepage != CP_8BIT
1070 && (codepage == CP_UNICODE || IsValidCodePage (codepage)));
1071 }
1072
1073 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1074 the two-byte form of C. Encoding is returned in *CHAR2B. */
1075
1076 static int /* enum w32_char_font_type */
1077 w32_encode_char (c, char2b, font_info, two_byte_p)
1078 int c;
1079 wchar_t *char2b;
1080 struct font_info *font_info;
1081 int * two_byte_p;
1082 {
1083 int charset = CHAR_CHARSET (c);
1084 int codepage;
1085 int unicode_p = 0;
1086 int internal_two_byte_p = 0;
1087
1088 XFontStruct *font = font_info->font;
1089
1090 internal_two_byte_p = w32_font_is_double_byte (font);
1091
1092 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1093 This may be either a program in a special encoder language or a
1094 fixed encoding. */
1095 if (font_info->font_encoder)
1096 {
1097 /* It's a program. */
1098 struct ccl_program *ccl = font_info->font_encoder;
1099
1100 if (CHARSET_DIMENSION (charset) == 1)
1101 {
1102 ccl->reg[0] = charset;
1103 ccl->reg[1] = XCHAR2B_BYTE2 (char2b);
1104 ccl->reg[2] = -1;
1105 }
1106 else
1107 {
1108 ccl->reg[0] = charset;
1109 ccl->reg[1] = XCHAR2B_BYTE1 (char2b);
1110 ccl->reg[2] = XCHAR2B_BYTE2 (char2b);
1111 }
1112
1113 ccl_driver (ccl, NULL, NULL, 0, 0, NULL);
1114
1115 /* We assume that MSBs are appropriately set/reset by CCL
1116 program. */
1117 if (!internal_two_byte_p) /* 1-byte font */
1118 STORE_XCHAR2B (char2b, 0, ccl->reg[1]);
1119 else
1120 STORE_XCHAR2B (char2b, ccl->reg[1], ccl->reg[2]);
1121 }
1122 else if (font_info->encoding[charset])
1123 {
1124 /* Fixed encoding scheme. See fontset.h for the meaning of the
1125 encoding numbers. */
1126 int enc = font_info->encoding[charset];
1127
1128 if ((enc == 1 || enc == 2)
1129 && CHARSET_DIMENSION (charset) == 2)
1130 STORE_XCHAR2B (char2b, XCHAR2B_BYTE1 (char2b) | 0x80, XCHAR2B_BYTE2 (char2b));
1131
1132 if (enc == 1 || enc == 3
1133 || (enc == 4 && CHARSET_DIMENSION (charset) == 1))
1134 STORE_XCHAR2B (char2b, XCHAR2B_BYTE1 (char2b), XCHAR2B_BYTE2 (char2b) | 0x80);
1135 else if (enc == 4)
1136 {
1137 int sjis1, sjis2;
1138
1139 ENCODE_SJIS (XCHAR2B_BYTE1 (char2b), XCHAR2B_BYTE2 (char2b),
1140 sjis1, sjis2);
1141 STORE_XCHAR2B (char2b, sjis1, sjis2);
1142 }
1143 }
1144 codepage = font_info->codepage;
1145
1146 /* If charset is not ASCII or Latin-1, may need to move it into
1147 Unicode space. */
1148 if ( font && !font->bdf && w32_use_unicode_for_codepage (codepage)
1149 && charset != CHARSET_ASCII && charset != charset_latin_iso8859_1
1150 && charset != CHARSET_8_BIT_CONTROL && charset != CHARSET_8_BIT_GRAPHIC)
1151 {
1152 char temp[3];
1153 temp[0] = XCHAR2B_BYTE1 (char2b);
1154 temp[1] = XCHAR2B_BYTE2 (char2b);
1155 temp[2] = '\0';
1156 if (codepage != CP_UNICODE)
1157 {
1158 if (temp[0])
1159 MultiByteToWideChar (codepage, 0, temp, 2, char2b, 1);
1160 else
1161 MultiByteToWideChar (codepage, 0, temp+1, 1, char2b, 1);
1162 }
1163 unicode_p = 1;
1164 internal_two_byte_p = 1;
1165 }
1166
1167 if (two_byte_p)
1168 *two_byte_p = internal_two_byte_p;
1169
1170 if (!font)
1171 return UNKNOWN_FONT;
1172 else if (font->bdf && CHARSET_DIMENSION (charset) == 1)
1173 return BDF_1D_FONT;
1174 else if (font->bdf)
1175 return BDF_2D_FONT;
1176 else if (unicode_p)
1177 return UNICODE_FONT;
1178 else
1179 return ANSI_FONT;
1180 }
1181
1182
1183 \f
1184 /***********************************************************************
1185 Glyph display
1186 ***********************************************************************/
1187
1188
1189 /* Encapsulate the different ways of displaying text under W32. */
1190
1191 static void
1192 w32_text_out (s, x, y,chars,nchars)
1193 struct glyph_string * s;
1194 int x, y;
1195 wchar_t * chars;
1196 int nchars;
1197 {
1198 int charset_dim = w32_font_is_double_byte (s->font) ? 2 : 1;
1199 if (s->font->bdf)
1200 w32_BDF_TextOut (s->font->bdf, s->hdc,
1201 x, y, (char *) chars, charset_dim,
1202 nchars * charset_dim, 0);
1203 else if (s->first_glyph->font_type == UNICODE_FONT)
1204 ExtTextOutW (s->hdc, x, y, 0, NULL, chars, nchars, NULL);
1205 else
1206 ExtTextOutA (s->hdc, x, y, 0, NULL, (char *) chars,
1207 nchars * charset_dim, NULL);
1208 }
1209
1210
1211 static void x_set_glyph_string_clipping P_ ((struct glyph_string *));
1212 static void x_set_glyph_string_gc P_ ((struct glyph_string *));
1213 static void x_draw_glyph_string_background P_ ((struct glyph_string *,
1214 int));
1215 static void x_draw_glyph_string_foreground P_ ((struct glyph_string *));
1216 static void x_draw_composite_glyph_string_foreground P_ ((struct glyph_string *));
1217 static void x_draw_glyph_string_box P_ ((struct glyph_string *));
1218 static void x_draw_glyph_string P_ ((struct glyph_string *));
1219 static void x_set_cursor_gc P_ ((struct glyph_string *));
1220 static void x_set_mode_line_face_gc P_ ((struct glyph_string *));
1221 static void x_set_mouse_face_gc P_ ((struct glyph_string *));
1222 static int w32_alloc_lighter_color (struct frame *, COLORREF *, double, int);
1223 static void w32_setup_relief_color P_ ((struct frame *, struct relief *,
1224 double, int, COLORREF));
1225 static void x_setup_relief_colors P_ ((struct glyph_string *));
1226 static void x_draw_image_glyph_string P_ ((struct glyph_string *));
1227 static void x_draw_image_relief P_ ((struct glyph_string *));
1228 static void x_draw_image_foreground P_ ((struct glyph_string *));
1229 static void w32_draw_image_foreground_1 P_ ((struct glyph_string *, HBITMAP));
1230 static void x_clear_glyph_string_rect P_ ((struct glyph_string *, int,
1231 int, int, int));
1232 static void w32_draw_relief_rect P_ ((struct frame *, int, int, int, int,
1233 int, int, int, int, int, int,
1234 RECT *));
1235 static void w32_draw_box_rect P_ ((struct glyph_string *, int, int, int, int,
1236 int, int, int, RECT *));
1237
1238 #if GLYPH_DEBUG
1239 static void x_check_font P_ ((struct frame *, XFontStruct *));
1240 #endif
1241
1242
1243 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1244 face. */
1245
1246 static void
1247 x_set_cursor_gc (s)
1248 struct glyph_string *s;
1249 {
1250 if (s->font == FRAME_FONT (s->f)
1251 && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
1252 && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
1253 && !s->cmp)
1254 s->gc = s->f->output_data.w32->cursor_gc;
1255 else
1256 {
1257 /* Cursor on non-default face: must merge. */
1258 XGCValues xgcv;
1259 unsigned long mask;
1260
1261 xgcv.background = s->f->output_data.w32->cursor_pixel;
1262 xgcv.foreground = s->face->background;
1263
1264 /* If the glyph would be invisible, try a different foreground. */
1265 if (xgcv.foreground == xgcv.background)
1266 xgcv.foreground = s->face->foreground;
1267 if (xgcv.foreground == xgcv.background)
1268 xgcv.foreground = s->f->output_data.w32->cursor_foreground_pixel;
1269 if (xgcv.foreground == xgcv.background)
1270 xgcv.foreground = s->face->foreground;
1271
1272 /* Make sure the cursor is distinct from text in this face. */
1273 if (xgcv.background == s->face->background
1274 && xgcv.foreground == s->face->foreground)
1275 {
1276 xgcv.background = s->face->foreground;
1277 xgcv.foreground = s->face->background;
1278 }
1279
1280 IF_DEBUG (x_check_font (s->f, s->font));
1281 xgcv.font = s->font;
1282 mask = GCForeground | GCBackground | GCFont;
1283
1284 if (FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc)
1285 XChangeGC (NULL, FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc,
1286 mask, &xgcv);
1287 else
1288 FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc
1289 = XCreateGC (NULL, s->window, mask, &xgcv);
1290
1291 s->gc = FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc;
1292 }
1293 }
1294
1295
1296 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1297
1298 static void
1299 x_set_mouse_face_gc (s)
1300 struct glyph_string *s;
1301 {
1302 int face_id;
1303 struct face *face;
1304
1305 /* What face has to be used last for the mouse face? */
1306 face_id = FRAME_W32_DISPLAY_INFO (s->f)->mouse_face_face_id;
1307 face = FACE_FROM_ID (s->f, face_id);
1308 if (face == NULL)
1309 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
1310
1311 if (s->first_glyph->type == CHAR_GLYPH)
1312 face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch);
1313 else
1314 face_id = FACE_FOR_CHAR (s->f, face, 0);
1315 s->face = FACE_FROM_ID (s->f, face_id);
1316 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
1317
1318 /* If font in this face is same as S->font, use it. */
1319 if (s->font == s->face->font)
1320 s->gc = s->face->gc;
1321 else
1322 {
1323 /* Otherwise construct scratch_cursor_gc with values from FACE
1324 but font FONT. */
1325 XGCValues xgcv;
1326 unsigned long mask;
1327
1328 xgcv.background = s->face->background;
1329 xgcv.foreground = s->face->foreground;
1330 IF_DEBUG (x_check_font (s->f, s->font));
1331 xgcv.font = s->font;
1332 mask = GCForeground | GCBackground | GCFont;
1333
1334 if (FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc)
1335 XChangeGC (NULL, FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc,
1336 mask, &xgcv);
1337 else
1338 FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc
1339 = XCreateGC (NULL, s->window, mask, &xgcv);
1340
1341 s->gc = FRAME_W32_DISPLAY_INFO (s->f)->scratch_cursor_gc;
1342 }
1343
1344 xassert (s->gc != 0);
1345 }
1346
1347
1348 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1349 Faces to use in the mode line have already been computed when the
1350 matrix was built, so there isn't much to do, here. */
1351
1352 static INLINE void
1353 x_set_mode_line_face_gc (s)
1354 struct glyph_string *s;
1355 {
1356 s->gc = s->face->gc;
1357 }
1358
1359
1360 /* Set S->gc of glyph string S for drawing that glyph string. Set
1361 S->stippled_p to a non-zero value if the face of S has a stipple
1362 pattern. */
1363
1364 static INLINE void
1365 x_set_glyph_string_gc (s)
1366 struct glyph_string *s;
1367 {
1368 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
1369
1370 if (s->hl == DRAW_NORMAL_TEXT)
1371 {
1372 s->gc = s->face->gc;
1373 s->stippled_p = s->face->stipple != 0;
1374 }
1375 else if (s->hl == DRAW_INVERSE_VIDEO)
1376 {
1377 x_set_mode_line_face_gc (s);
1378 s->stippled_p = s->face->stipple != 0;
1379 }
1380 else if (s->hl == DRAW_CURSOR)
1381 {
1382 x_set_cursor_gc (s);
1383 s->stippled_p = 0;
1384 }
1385 else if (s->hl == DRAW_MOUSE_FACE)
1386 {
1387 x_set_mouse_face_gc (s);
1388 s->stippled_p = s->face->stipple != 0;
1389 }
1390 else if (s->hl == DRAW_IMAGE_RAISED
1391 || s->hl == DRAW_IMAGE_SUNKEN)
1392 {
1393 s->gc = s->face->gc;
1394 s->stippled_p = s->face->stipple != 0;
1395 }
1396 else
1397 {
1398 s->gc = s->face->gc;
1399 s->stippled_p = s->face->stipple != 0;
1400 }
1401
1402 /* GC must have been set. */
1403 xassert (s->gc != 0);
1404 }
1405
1406
1407 /* Set clipping for output of glyph string S. S may be part of a mode
1408 line or menu if we don't have X toolkit support. */
1409
1410 static INLINE void
1411 x_set_glyph_string_clipping (s)
1412 struct glyph_string *s;
1413 {
1414 RECT r;
1415 get_glyph_string_clip_rect (s, &r);
1416 w32_set_clip_rectangle (s->hdc, &r);
1417 }
1418
1419
1420 /* RIF:
1421 Compute left and right overhang of glyph string S. If S is a glyph
1422 string for a composition, assume overhangs don't exist. */
1423
1424 static void
1425 w32_compute_glyph_string_overhangs (s)
1426 struct glyph_string *s;
1427 {
1428 /* TODO: Windows does not appear to have a method for
1429 getting this info without getting the ABC widths for each
1430 individual character and working it out manually. */
1431 }
1432
1433
1434 static void
1435 w32_get_glyph_overhangs (glyph, f, left, right)
1436 struct glyph *glyph;
1437 struct frame *f;
1438 int *left, *right;
1439 {
1440 HDC hdc = get_frame_dc (f);
1441 /* Convert to unicode! */
1442 x_get_glyph_overhangs (glyph, f, left, right);
1443 release_frame_dc (f, hdc);
1444 }
1445
1446
1447 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1448
1449 static INLINE void
1450 x_clear_glyph_string_rect (s, x, y, w, h)
1451 struct glyph_string *s;
1452 int x, y, w, h;
1453 {
1454 int real_x = x;
1455 int real_y = y;
1456 int real_w = w;
1457 int real_h = h;
1458 #if 0
1459 /* Take clipping into account. */
1460 if (s->gc->clip_mask == Rect)
1461 {
1462 real_x = max (real_x, s->gc->clip_rectangle.left);
1463 real_y = max (real_y, s->gc->clip_rectangle.top);
1464 real_w = min (real_w, s->gc->clip_rectangle.right
1465 - s->gc->clip_rectangle.left);
1466 real_h = min (real_h, s->gc->clip_rectangle.bottom
1467 - s->gc->clip_rectangle.top);
1468 }
1469 #endif
1470 w32_fill_area (s->f, s->hdc, s->gc->background, real_x, real_y,
1471 real_w, real_h);
1472 }
1473
1474
1475 /* Draw the background of glyph_string S. If S->background_filled_p
1476 is non-zero don't draw it. FORCE_P non-zero means draw the
1477 background even if it wouldn't be drawn normally. This is used
1478 when a string preceding S draws into the background of S, or S
1479 contains the first component of a composition. */
1480
1481 static void
1482 x_draw_glyph_string_background (s, force_p)
1483 struct glyph_string *s;
1484 int force_p;
1485 {
1486 /* Nothing to do if background has already been drawn or if it
1487 shouldn't be drawn in the first place. */
1488 if (!s->background_filled_p)
1489 {
1490 int box_line_width = max (s->face->box_line_width, 0);
1491
1492 #if 0 /* TODO: stipple */
1493 if (s->stippled_p)
1494 {
1495 /* Fill background with a stipple pattern. */
1496 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
1497 XFillRectangle (s->display, s->window, s->gc, s->x,
1498 s->y + box_line_width,
1499 s->background_width,
1500 s->height - 2 * box_line_width);
1501 XSetFillStyle (s->display, s->gc, FillSolid);
1502 s->background_filled_p = 1;
1503 }
1504 else
1505 #endif
1506 if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
1507 || s->font_not_found_p
1508 || s->extends_to_end_of_line_p
1509 || s->font->bdf
1510 || force_p)
1511 {
1512 x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
1513 s->background_width,
1514 s->height - 2 * box_line_width);
1515 s->background_filled_p = 1;
1516 }
1517 }
1518 }
1519
1520
1521 /* Draw the foreground of glyph string S. */
1522
1523 static void
1524 x_draw_glyph_string_foreground (s)
1525 struct glyph_string *s;
1526 {
1527 int i, x;
1528 HFONT old_font;
1529
1530 /* If first glyph of S has a left box line, start drawing the text
1531 of S to the right of that box line. */
1532 if (s->face->box != FACE_NO_BOX
1533 && s->first_glyph->left_box_line_p)
1534 x = s->x + abs (s->face->box_line_width);
1535 else
1536 x = s->x;
1537
1538 if (s->for_overlaps_p || (s->background_filled_p && s->hl != DRAW_CURSOR))
1539 SetBkMode (s->hdc, TRANSPARENT);
1540 else
1541 SetBkMode (s->hdc, OPAQUE);
1542
1543 SetTextColor (s->hdc, s->gc->foreground);
1544 SetBkColor (s->hdc, s->gc->background);
1545 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1546
1547 if (s->font && s->font->hfont)
1548 old_font = SelectObject (s->hdc, s->font->hfont);
1549
1550 /* Draw characters of S as rectangles if S's font could not be
1551 loaded. */
1552 if (s->font_not_found_p)
1553 {
1554 for (i = 0; i < s->nchars; ++i)
1555 {
1556 struct glyph *g = s->first_glyph + i;
1557
1558 w32_draw_rectangle (s->hdc, s->gc, x, s->y, g->pixel_width - 1,
1559 s->height - 1);
1560 x += g->pixel_width;
1561 }
1562 }
1563 else
1564 {
1565 char *char1b = (char *) s->char2b;
1566 int boff = s->font_info->baseline_offset;
1567
1568 if (s->font_info->vertical_centering)
1569 boff = VCENTER_BASELINE_OFFSET (s->font, s->f) - boff;
1570
1571 /* If we can use 8-bit functions, condense S->char2b. */
1572 if (!s->two_byte_p)
1573 for (i = 0; i < s->nchars; ++i)
1574 char1b[i] = XCHAR2B_BYTE2 (&s->char2b[i]);
1575
1576 /* Draw text with TextOut and friends. */
1577 w32_text_out (s, x, s->ybase - boff, s->char2b, s->nchars);
1578
1579 if (s->face->overstrike)
1580 {
1581 /* For overstriking (to simulate bold-face), draw the
1582 characters again shifted to the right by one pixel. */
1583 w32_text_out (s, x + 1, s->ybase - boff, s->char2b, s->nchars);
1584 }
1585 }
1586 if (s->font && s->font->hfont)
1587 SelectObject (s->hdc, old_font);
1588 }
1589
1590 /* Draw the foreground of composite glyph string S. */
1591
1592 static void
1593 x_draw_composite_glyph_string_foreground (s)
1594 struct glyph_string *s;
1595 {
1596 int i, x;
1597 HFONT old_font;
1598
1599 /* If first glyph of S has a left box line, start drawing the text
1600 of S to the right of that box line. */
1601 if (s->face->box != FACE_NO_BOX
1602 && s->first_glyph->left_box_line_p)
1603 x = s->x + abs (s->face->box_line_width);
1604 else
1605 x = s->x;
1606
1607 /* S is a glyph string for a composition. S->gidx is the index of
1608 the first character drawn for glyphs of this composition.
1609 S->gidx == 0 means we are drawing the very first character of
1610 this composition. */
1611
1612 SetTextColor (s->hdc, s->gc->foreground);
1613 SetBkColor (s->hdc, s->gc->background);
1614 SetBkMode (s->hdc, TRANSPARENT);
1615 SetTextAlign (s->hdc, TA_BASELINE | TA_LEFT);
1616
1617 if (s->font && s->font->hfont)
1618 old_font = SelectObject (s->hdc, s->font->hfont);
1619
1620 /* Draw a rectangle for the composition if the font for the very
1621 first character of the composition could not be loaded. */
1622 if (s->font_not_found_p)
1623 {
1624 if (s->gidx == 0)
1625 w32_draw_rectangle (s->hdc, s->gc, x, s->y, s->width - 1,
1626 s->height - 1);
1627 }
1628 else
1629 {
1630 for (i = 0; i < s->nchars; i++, ++s->gidx)
1631 {
1632 w32_text_out (s, x + s->cmp->offsets[s->gidx * 2],
1633 s->ybase - s->cmp->offsets[s->gidx * 2 + 1],
1634 s->char2b + i, 1);
1635 if (s->face->overstrike)
1636 w32_text_out (s, x + s->cmp->offsets[s->gidx * 2] + 1,
1637 s->ybase - s->cmp->offsets[s->gidx * 2 + 1],
1638 s->char2b + i, 1);
1639 }
1640 }
1641
1642 if (s->font && s->font->hfont)
1643 SelectObject (s->hdc, old_font);
1644 }
1645
1646
1647 /* Brightness beyond which a color won't have its highlight brightness
1648 boosted.
1649
1650 Nominally, highlight colors for `3d' faces are calculated by
1651 brightening an object's color by a constant scale factor, but this
1652 doesn't yield good results for dark colors, so for colors who's
1653 brightness is less than this value (on a scale of 0-255) have to
1654 use an additional additive factor.
1655
1656 The value here is set so that the default menu-bar/mode-line color
1657 (grey75) will not have its highlights changed at all. */
1658 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
1659
1660
1661 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
1662 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1663 If this produces the same color as COLOR, try a color where all RGB
1664 values have DELTA added. Return the allocated color in *COLOR.
1665 DISPLAY is the X display, CMAP is the colormap to operate on.
1666 Value is non-zero if successful. */
1667
1668 static int
1669 w32_alloc_lighter_color (f, color, factor, delta)
1670 struct frame *f;
1671 COLORREF *color;
1672 double factor;
1673 int delta;
1674 {
1675 COLORREF new;
1676 long bright;
1677
1678 /* On Windows, RGB values are 0-255, not 0-65535, so scale delta. */
1679 delta /= 256;
1680
1681 /* Change RGB values by specified FACTOR. Avoid overflow! */
1682 xassert (factor >= 0);
1683 new = PALETTERGB (min (0xff, factor * GetRValue (*color)),
1684 min (0xff, factor * GetGValue (*color)),
1685 min (0xff, factor * GetBValue (*color)));
1686
1687 /* Calculate brightness of COLOR. */
1688 bright = (2 * GetRValue (*color) + 3 * GetGValue (*color)
1689 + GetBValue (*color)) / 6;
1690
1691 /* We only boost colors that are darker than
1692 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1693 if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
1694 /* Make an additive adjustment to NEW, because it's dark enough so
1695 that scaling by FACTOR alone isn't enough. */
1696 {
1697 /* How far below the limit this color is (0 - 1, 1 being darker). */
1698 double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
1699 /* The additive adjustment. */
1700 int min_delta = delta * dimness * factor / 2;
1701
1702 if (factor < 1)
1703 new = PALETTERGB (max (0, min (0xff, min_delta - GetRValue (*color))),
1704 max (0, min (0xff, min_delta - GetGValue (*color))),
1705 max (0, min (0xff, min_delta - GetBValue (*color))));
1706 else
1707 new = PALETTERGB (max (0, min (0xff, min_delta + GetRValue (*color))),
1708 max (0, min (0xff, min_delta + GetGValue (*color))),
1709 max (0, min (0xff, min_delta + GetBValue (*color))));
1710 }
1711
1712 if (new == *color)
1713 new = PALETTERGB (max (0, min (0xff, delta + GetRValue (*color))),
1714 max (0, min (0xff, delta + GetGValue (*color))),
1715 max (0, min (0xff, delta + GetBValue (*color))));
1716
1717 /* TODO: Map to palette and retry with delta if same? */
1718 /* TODO: Free colors (if using palette)? */
1719
1720 if (new == *color)
1721 return 0;
1722
1723 *color = new;
1724
1725 return 1;
1726 }
1727
1728
1729 /* Set up the foreground color for drawing relief lines of glyph
1730 string S. RELIEF is a pointer to a struct relief containing the GC
1731 with which lines will be drawn. Use a color that is FACTOR or
1732 DELTA lighter or darker than the relief's background which is found
1733 in S->f->output_data.x->relief_background. If such a color cannot
1734 be allocated, use DEFAULT_PIXEL, instead. */
1735
1736 static void
1737 w32_setup_relief_color (f, relief, factor, delta, default_pixel)
1738 struct frame *f;
1739 struct relief *relief;
1740 double factor;
1741 int delta;
1742 COLORREF default_pixel;
1743 {
1744 XGCValues xgcv;
1745 struct w32_output *di = f->output_data.w32;
1746 unsigned long mask = GCForeground;
1747 COLORREF pixel;
1748 COLORREF background = di->relief_background;
1749 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
1750
1751 /* TODO: Free colors (if using palette)? */
1752
1753 /* Allocate new color. */
1754 xgcv.foreground = default_pixel;
1755 pixel = background;
1756 if (w32_alloc_lighter_color (f, &pixel, factor, delta))
1757 {
1758 relief->allocated_p = 1;
1759 xgcv.foreground = relief->pixel = pixel;
1760 }
1761
1762 if (relief->gc == 0)
1763 {
1764 #if 0 /* TODO: stipple */
1765 xgcv.stipple = dpyinfo->gray;
1766 mask |= GCStipple;
1767 #endif
1768 relief->gc = XCreateGC (NULL, FRAME_W32_WINDOW (f), mask, &xgcv);
1769 }
1770 else
1771 XChangeGC (NULL, relief->gc, mask, &xgcv);
1772 }
1773
1774
1775 /* Set up colors for the relief lines around glyph string S. */
1776
1777 static void
1778 x_setup_relief_colors (s)
1779 struct glyph_string *s;
1780 {
1781 struct w32_output *di = s->f->output_data.w32;
1782 COLORREF color;
1783
1784 if (s->face->use_box_color_for_shadows_p)
1785 color = s->face->box_color;
1786 else if (s->first_glyph->type == IMAGE_GLYPH
1787 && s->img->pixmap
1788 && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
1789 color = IMAGE_BACKGROUND (s->img, s->f, 0);
1790 else
1791 color = s->gc->background;
1792
1793 if (di->white_relief.gc == 0
1794 || color != di->relief_background)
1795 {
1796 di->relief_background = color;
1797 w32_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
1798 WHITE_PIX_DEFAULT (s->f));
1799 w32_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
1800 BLACK_PIX_DEFAULT (s->f));
1801 }
1802 }
1803
1804
1805 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1806 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1807 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1808 relief. LEFT_P non-zero means draw a relief on the left side of
1809 the rectangle. RIGHT_P non-zero means draw a relief on the right
1810 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1811 when drawing. */
1812
1813 static void
1814 w32_draw_relief_rect (f, left_x, top_y, right_x, bottom_y, width,
1815 raised_p, top_p, bot_p, left_p, right_p, clip_rect)
1816 struct frame *f;
1817 int left_x, top_y, right_x, bottom_y, width;
1818 int top_p, bot_p, left_p, right_p, raised_p;
1819 RECT *clip_rect;
1820 {
1821 int i;
1822 XGCValues gc;
1823 HDC hdc = get_frame_dc (f);
1824
1825 if (raised_p)
1826 gc.foreground = f->output_data.w32->white_relief.gc->foreground;
1827 else
1828 gc.foreground = f->output_data.w32->black_relief.gc->foreground;
1829
1830 w32_set_clip_rectangle (hdc, clip_rect);
1831
1832 /* Top. */
1833 if (top_p)
1834 for (i = 0; i < width; ++i)
1835 w32_fill_area (f, hdc, gc.foreground,
1836 left_x + i * left_p, top_y + i,
1837 right_x - left_x - i * (left_p + right_p ) + 1, 1);
1838
1839 /* Left. */
1840 if (left_p)
1841 for (i = 0; i < width; ++i)
1842 w32_fill_area (f, hdc, gc.foreground,
1843 left_x + i, top_y + i, 1,
1844 bottom_y - top_y - 2 * i + 1);
1845
1846 if (raised_p)
1847 gc.foreground = f->output_data.w32->black_relief.gc->foreground;
1848 else
1849 gc.foreground = f->output_data.w32->white_relief.gc->foreground;
1850
1851 /* Bottom. */
1852 if (bot_p)
1853 for (i = 0; i < width; ++i)
1854 w32_fill_area (f, hdc, gc.foreground,
1855 left_x + i * left_p, bottom_y - i,
1856 right_x - left_x - i * (left_p + right_p) + 1, 1);
1857
1858 /* Right. */
1859 if (right_p)
1860 for (i = 0; i < width; ++i)
1861 w32_fill_area (f, hdc, gc.foreground,
1862 right_x - i, top_y + i + 1, 1,
1863 bottom_y - top_y - 2 * i - 1);
1864
1865 w32_set_clip_rectangle (hdc, NULL);
1866
1867 release_frame_dc (f, hdc);
1868 }
1869
1870
1871 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1872 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1873 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1874 left side of the rectangle. RIGHT_P non-zero means draw a line
1875 on the right side of the rectangle. CLIP_RECT is the clipping
1876 rectangle to use when drawing. */
1877
1878 static void
1879 w32_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
1880 left_p, right_p, clip_rect)
1881 struct glyph_string *s;
1882 int left_x, top_y, right_x, bottom_y, width, left_p, right_p;
1883 RECT *clip_rect;
1884 {
1885 w32_set_clip_rectangle (s->hdc, clip_rect);
1886
1887 /* Top. */
1888 w32_fill_area (s->f, s->hdc, s->face->box_color,
1889 left_x, top_y, right_x - left_x + 1, width);
1890
1891 /* Left. */
1892 if (left_p)
1893 {
1894 w32_fill_area (s->f, s->hdc, s->face->box_color,
1895 left_x, top_y, width, bottom_y - top_y + 1);
1896 }
1897
1898 /* Bottom. */
1899 w32_fill_area (s->f, s->hdc, s->face->box_color,
1900 left_x, bottom_y - width + 1, right_x - left_x + 1, width);
1901
1902 /* Right. */
1903 if (right_p)
1904 {
1905 w32_fill_area (s->f, s->hdc, s->face->box_color,
1906 right_x - width + 1, top_y, width, bottom_y - top_y + 1);
1907 }
1908
1909 w32_set_clip_rectangle (s->hdc, NULL);
1910 }
1911
1912
1913 /* Draw a box around glyph string S. */
1914
1915 static void
1916 x_draw_glyph_string_box (s)
1917 struct glyph_string *s;
1918 {
1919 int width, left_x, right_x, top_y, bottom_y, last_x, raised_p;
1920 int left_p, right_p;
1921 struct glyph *last_glyph;
1922 RECT clip_rect;
1923
1924 last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
1925 ? WINDOW_RIGHT_EDGE_X (s->w)
1926 : window_box_right (s->w, s->area));
1927
1928 /* The glyph that may have a right box line. */
1929 last_glyph = (s->cmp || s->img
1930 ? s->first_glyph
1931 : s->first_glyph + s->nchars - 1);
1932
1933 width = abs (s->face->box_line_width);
1934 raised_p = s->face->box == FACE_RAISED_BOX;
1935 left_x = s->x;
1936 right_x = ((s->row->full_width_p && s->extends_to_end_of_line_p
1937 ? last_x - 1
1938 : min (last_x, s->x + s->background_width) - 1));
1939 top_y = s->y;
1940 bottom_y = top_y + s->height - 1;
1941
1942 left_p = (s->first_glyph->left_box_line_p
1943 || (s->hl == DRAW_MOUSE_FACE
1944 && (s->prev == NULL
1945 || s->prev->hl != s->hl)));
1946 right_p = (last_glyph->right_box_line_p
1947 || (s->hl == DRAW_MOUSE_FACE
1948 && (s->next == NULL
1949 || s->next->hl != s->hl)));
1950
1951 get_glyph_string_clip_rect (s, &clip_rect);
1952
1953 if (s->face->box == FACE_SIMPLE_BOX)
1954 w32_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
1955 left_p, right_p, &clip_rect);
1956 else
1957 {
1958 x_setup_relief_colors (s);
1959 w32_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
1960 width, raised_p, 1, 1, left_p, right_p, &clip_rect);
1961 }
1962 }
1963
1964
1965 /* Draw foreground of image glyph string S. */
1966
1967 static void
1968 x_draw_image_foreground (s)
1969 struct glyph_string *s;
1970 {
1971 int x = s->x;
1972 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
1973
1974 /* If first glyph of S has a left box line, start drawing it to the
1975 right of that line. */
1976 if (s->face->box != FACE_NO_BOX
1977 && s->first_glyph->left_box_line_p
1978 && s->slice.x == 0)
1979 x += abs (s->face->box_line_width);
1980
1981 /* If there is a margin around the image, adjust x- and y-position
1982 by that margin. */
1983 if (s->slice.x == 0)
1984 x += s->img->hmargin;
1985 if (s->slice.y == 0)
1986 y += s->img->vmargin;
1987
1988 SaveDC (s->hdc);
1989
1990 if (s->img->pixmap)
1991 {
1992 HDC compat_hdc = CreateCompatibleDC (s->hdc);
1993 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
1994 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
1995 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
1996 SetBkColor (compat_hdc, RGB (255, 255, 255));
1997 SetTextColor (s->hdc, RGB (0, 0, 0));
1998 x_set_glyph_string_clipping (s);
1999
2000 if (s->img->mask)
2001 {
2002 HDC mask_dc = CreateCompatibleDC (s->hdc);
2003 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask);
2004
2005 SetTextColor (s->hdc, RGB (255, 255, 255));
2006 SetBkColor (s->hdc, RGB (0, 0, 0));
2007
2008 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
2009 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
2010 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
2011 mask_dc, s->slice.x, s->slice.y, SRCAND);
2012 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
2013 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
2014
2015 SelectObject (mask_dc, mask_orig_obj);
2016 DeleteDC (mask_dc);
2017 }
2018 else
2019 {
2020 SetTextColor (s->hdc, s->gc->foreground);
2021 SetBkColor (s->hdc, s->gc->background);
2022
2023 BitBlt (s->hdc, x, y, s->slice.width, s->slice.height,
2024 compat_hdc, s->slice.x, s->slice.y, SRCCOPY);
2025
2026 /* When the image has a mask, we can expect that at
2027 least part of a mouse highlight or a block cursor will
2028 be visible. If the image doesn't have a mask, make
2029 a block cursor visible by drawing a rectangle around
2030 the image. I believe it's looking better if we do
2031 nothing here for mouse-face. */
2032 if (s->hl == DRAW_CURSOR)
2033 {
2034 int r = s->img->relief;
2035 if (r < 0) r = -r;
2036 w32_draw_rectangle (s->hdc, s->gc, x - r, y - r ,
2037 s->slice.width + r*2 - 1,
2038 s->slice.height + r*2 - 1);
2039 }
2040 }
2041
2042 w32_set_clip_rectangle (s->hdc, NULL);
2043 SelectObject (s->hdc, orig_brush);
2044 DeleteObject (fg_brush);
2045 SelectObject (compat_hdc, orig_obj);
2046 DeleteDC (compat_hdc);
2047 }
2048 else
2049 w32_draw_rectangle (s->hdc, s->gc, x, y,
2050 s->slice.width - 1, s->slice.height - 1);
2051
2052 RestoreDC (s->hdc ,-1);
2053 }
2054
2055
2056 /* Draw a relief around the image glyph string S. */
2057
2058 static void
2059 x_draw_image_relief (s)
2060 struct glyph_string *s;
2061 {
2062 int x0, y0, x1, y1, thick, raised_p;
2063 RECT r;
2064 int x = s->x;
2065 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
2066
2067 /* If first glyph of S has a left box line, start drawing it to the
2068 right of that line. */
2069 if (s->face->box != FACE_NO_BOX
2070 && s->first_glyph->left_box_line_p
2071 && s->slice.x == 0)
2072 x += abs (s->face->box_line_width);
2073
2074 /* If there is a margin around the image, adjust x- and y-position
2075 by that margin. */
2076 if (s->slice.x == 0)
2077 x += s->img->hmargin;
2078 if (s->slice.y == 0)
2079 y += s->img->vmargin;
2080
2081 if (s->hl == DRAW_IMAGE_SUNKEN
2082 || s->hl == DRAW_IMAGE_RAISED)
2083 {
2084 thick = tool_bar_button_relief >= 0 ? tool_bar_button_relief : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
2085 raised_p = s->hl == DRAW_IMAGE_RAISED;
2086 }
2087 else
2088 {
2089 thick = abs (s->img->relief);
2090 raised_p = s->img->relief > 0;
2091 }
2092
2093 x0 = x - thick;
2094 y0 = y - thick;
2095 x1 = x + s->slice.width + thick - 1;
2096 y1 = y + s->slice.height + thick - 1;
2097
2098 x_setup_relief_colors (s);
2099 get_glyph_string_clip_rect (s, &r);
2100 w32_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p,
2101 s->slice.y == 0,
2102 s->slice.y + s->slice.height == s->img->height,
2103 s->slice.x == 0,
2104 s->slice.x + s->slice.width == s->img->width,
2105 &r);
2106 }
2107
2108
2109 /* Draw the foreground of image glyph string S to PIXMAP. */
2110
2111 static void
2112 w32_draw_image_foreground_1 (s, pixmap)
2113 struct glyph_string *s;
2114 HBITMAP pixmap;
2115 {
2116 HDC hdc = CreateCompatibleDC (s->hdc);
2117 HGDIOBJ orig_hdc_obj = SelectObject (hdc, pixmap);
2118 int x = 0;
2119 int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
2120
2121 /* If first glyph of S has a left box line, start drawing it to the
2122 right of that line. */
2123 if (s->face->box != FACE_NO_BOX
2124 && s->first_glyph->left_box_line_p
2125 && s->slice.x == 0)
2126 x += abs (s->face->box_line_width);
2127
2128 /* If there is a margin around the image, adjust x- and y-position
2129 by that margin. */
2130 if (s->slice.x == 0)
2131 x += s->img->hmargin;
2132 if (s->slice.y == 0)
2133 y += s->img->vmargin;
2134
2135 if (s->img->pixmap)
2136 {
2137 HDC compat_hdc = CreateCompatibleDC (hdc);
2138 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
2139 HBRUSH orig_brush = SelectObject (hdc, fg_brush);
2140 HGDIOBJ orig_obj = SelectObject (compat_hdc, s->img->pixmap);
2141
2142 if (s->img->mask)
2143 {
2144 HDC mask_dc = CreateCompatibleDC (hdc);
2145 HGDIOBJ mask_orig_obj = SelectObject (mask_dc, s->img->mask);
2146
2147 SetTextColor (hdc, RGB (0, 0, 0));
2148 SetBkColor (hdc, RGB (255, 255, 255));
2149 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2150 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
2151 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2152 mask_dc, s->slice.x, s->slice.y, SRCAND);
2153 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2154 compat_hdc, s->slice.x, s->slice.y, SRCINVERT);
2155
2156 SelectObject (mask_dc, mask_orig_obj);
2157 DeleteDC (mask_dc);
2158 }
2159 else
2160 {
2161 SetTextColor (hdc, s->gc->foreground);
2162 SetBkColor (hdc, s->gc->background);
2163
2164 BitBlt (hdc, x, y, s->slice.width, s->slice.height,
2165 compat_hdc, s->slice.x, s->slice.y, SRCCOPY);
2166
2167 /* When the image has a mask, we can expect that at
2168 least part of a mouse highlight or a block cursor will
2169 be visible. If the image doesn't have a mask, make
2170 a block cursor visible by drawing a rectangle around
2171 the image. I believe it's looking better if we do
2172 nothing here for mouse-face. */
2173 if (s->hl == DRAW_CURSOR)
2174 {
2175 int r = s->img->relief;
2176 if (r < 0) r = -r;
2177 w32_draw_rectangle (hdc, s->gc, x - r, y - r,
2178 s->slice.width + r*2 - 1,
2179 s->slice.height + r*2 - 1);
2180 }
2181 }
2182
2183 SelectObject (hdc, orig_brush);
2184 DeleteObject (fg_brush);
2185 SelectObject (compat_hdc, orig_obj);
2186 DeleteDC (compat_hdc);
2187 }
2188 else
2189 w32_draw_rectangle (hdc, s->gc, x, y,
2190 s->slice.width - 1, s->slice.height - 1);
2191
2192 SelectObject (hdc, orig_hdc_obj);
2193 DeleteDC (hdc);
2194 }
2195
2196
2197 /* Draw part of the background of glyph string S. X, Y, W, and H
2198 give the rectangle to draw. */
2199
2200 static void
2201 x_draw_glyph_string_bg_rect (s, x, y, w, h)
2202 struct glyph_string *s;
2203 int x, y, w, h;
2204 {
2205 #if 0 /* TODO: stipple */
2206 if (s->stippled_p)
2207 {
2208 /* Fill background with a stipple pattern. */
2209 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2210 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
2211 XSetFillStyle (s->display, s->gc, FillSolid);
2212 }
2213 else
2214 #endif
2215 x_clear_glyph_string_rect (s, x, y, w, h);
2216 }
2217
2218
2219 /* Draw image glyph string S.
2220
2221 s->y
2222 s->x +-------------------------
2223 | s->face->box
2224 |
2225 | +-------------------------
2226 | | s->img->vmargin
2227 | |
2228 | | +-------------------
2229 | | | the image
2230
2231 */
2232
2233 static void
2234 x_draw_image_glyph_string (s)
2235 struct glyph_string *s;
2236 {
2237 int x, y;
2238 int box_line_hwidth = abs (s->face->box_line_width);
2239 int box_line_vwidth = max (s->face->box_line_width, 0);
2240 int height;
2241 HBITMAP pixmap = 0;
2242
2243 height = s->height - 2 * box_line_vwidth;
2244
2245 /* Fill background with face under the image. Do it only if row is
2246 taller than image or if image has a clip mask to reduce
2247 flickering. */
2248 s->stippled_p = s->face->stipple != 0;
2249 if (height > s->slice.height
2250 || s->img->hmargin
2251 || s->img->vmargin
2252 || s->img->mask
2253 || s->img->pixmap == 0
2254 || s->width != s->background_width)
2255 {
2256 x = s->x;
2257 if (s->first_glyph->left_box_line_p
2258 && s->slice.x == 0)
2259 x += box_line_hwidth;
2260
2261 y = s->y;
2262 if (s->slice.y == 0)
2263 y += box_line_vwidth;
2264
2265 #if 0 /* TODO: figure out if we need to do this on Windows. */
2266 if (s->img->mask)
2267 {
2268 /* Create a pixmap as large as the glyph string. Fill it
2269 with the background color. Copy the image to it, using
2270 its mask. Copy the temporary pixmap to the display. */
2271 Screen *screen = FRAME_X_SCREEN (s->f);
2272 int depth = DefaultDepthOfScreen (screen);
2273
2274 /* Create a pixmap as large as the glyph string. */
2275 pixmap = XCreatePixmap (s->display, s->window,
2276 s->background_width,
2277 s->height, depth);
2278
2279 /* Don't clip in the following because we're working on the
2280 pixmap. */
2281 XSetClipMask (s->display, s->gc, None);
2282
2283 /* Fill the pixmap with the background color/stipple. */
2284 if (s->stippled_p)
2285 {
2286 /* Fill background with a stipple pattern. */
2287 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2288 XFillRectangle (s->display, pixmap, s->gc,
2289 0, 0, s->background_width, s->height);
2290 XSetFillStyle (s->display, s->gc, FillSolid);
2291 }
2292 else
2293 {
2294 XGCValues xgcv;
2295 XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
2296 &xgcv);
2297 XSetForeground (s->display, s->gc, xgcv.background);
2298 XFillRectangle (s->display, pixmap, s->gc,
2299 0, 0, s->background_width, s->height);
2300 XSetForeground (s->display, s->gc, xgcv.foreground);
2301 }
2302 }
2303 else
2304 #endif
2305 x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
2306
2307 s->background_filled_p = 1;
2308 }
2309
2310 /* Draw the foreground. */
2311 if (pixmap != 0)
2312 {
2313 w32_draw_image_foreground_1 (s, pixmap);
2314 x_set_glyph_string_clipping (s);
2315 {
2316 HDC compat_hdc = CreateCompatibleDC (s->hdc);
2317 HBRUSH fg_brush = CreateSolidBrush (s->gc->foreground);
2318 HBRUSH orig_brush = SelectObject (s->hdc, fg_brush);
2319 HGDIOBJ orig_obj = SelectObject (compat_hdc, pixmap);
2320
2321 SetTextColor (s->hdc, s->gc->foreground);
2322 SetBkColor (s->hdc, s->gc->background);
2323 BitBlt (s->hdc, s->x, s->y, s->background_width, s->height,
2324 compat_hdc, 0, 0, SRCCOPY);
2325
2326 SelectObject (s->hdc, orig_brush);
2327 DeleteObject (fg_brush);
2328 SelectObject (compat_hdc, orig_obj);
2329 DeleteDC (compat_hdc);
2330 }
2331 DeleteObject (pixmap);
2332 pixmap = 0;
2333 }
2334 else
2335 x_draw_image_foreground (s);
2336
2337 /* If we must draw a relief around the image, do it. */
2338 if (s->img->relief
2339 || s->hl == DRAW_IMAGE_RAISED
2340 || s->hl == DRAW_IMAGE_SUNKEN)
2341 x_draw_image_relief (s);
2342 }
2343
2344
2345 /* Draw stretch glyph string S. */
2346
2347 static void
2348 x_draw_stretch_glyph_string (s)
2349 struct glyph_string *s;
2350 {
2351 xassert (s->first_glyph->type == STRETCH_GLYPH);
2352 s->stippled_p = s->face->stipple != 0;
2353
2354 if (s->hl == DRAW_CURSOR
2355 && !x_stretch_cursor_p)
2356 {
2357 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2358 as wide as the stretch glyph. */
2359 int width = min (FRAME_COLUMN_WIDTH (s->f), s->background_width);
2360
2361 /* Draw cursor. */
2362 x_draw_glyph_string_bg_rect (s, s->x, s->y, width, s->height);
2363
2364 /* Clear rest using the GC of the original non-cursor face. */
2365 if (width < s->background_width)
2366 {
2367 XGCValues *gc = s->face->gc;
2368 int x = s->x + width, y = s->y;
2369 int w = s->background_width - width, h = s->height;
2370 RECT r;
2371 HDC hdc = s->hdc;
2372
2373 if (s->row->mouse_face_p
2374 && cursor_in_mouse_face_p (s->w))
2375 {
2376 x_set_mouse_face_gc (s);
2377 gc = s->gc;
2378 }
2379 else
2380 gc = s->face->gc;
2381
2382 get_glyph_string_clip_rect (s, &r);
2383 w32_set_clip_rectangle (hdc, &r);
2384
2385 #if 0 /* TODO: stipple */
2386 if (s->face->stipple)
2387 {
2388 /* Fill background with a stipple pattern. */
2389 XSetFillStyle (s->display, gc, FillOpaqueStippled);
2390 XFillRectangle (s->display, s->window, gc, x, y, w, h);
2391 XSetFillStyle (s->display, gc, FillSolid);
2392 }
2393 else
2394 #endif
2395 {
2396 w32_fill_area (s->f, s->hdc, gc->background, x, y, w, h);
2397 }
2398 }
2399 }
2400 else if (!s->background_filled_p)
2401 x_draw_glyph_string_bg_rect (s, s->x, s->y, s->background_width,
2402 s->height);
2403
2404 s->background_filled_p = 1;
2405 }
2406
2407
2408 /* Draw glyph string S. */
2409
2410 static void
2411 x_draw_glyph_string (s)
2412 struct glyph_string *s;
2413 {
2414 int relief_drawn_p = 0;
2415
2416 /* If S draws into the background of its successor, draw the
2417 background of the successor first so that S can draw into it.
2418 This makes S->next use XDrawString instead of XDrawImageString. */
2419 if (s->next && s->right_overhang && !s->for_overlaps_p)
2420 {
2421 xassert (s->next->img == NULL);
2422 x_set_glyph_string_gc (s->next);
2423 x_set_glyph_string_clipping (s->next);
2424 x_draw_glyph_string_background (s->next, 1);
2425 }
2426
2427 /* Set up S->gc, set clipping and draw S. */
2428 x_set_glyph_string_gc (s);
2429
2430 /* Draw relief (if any) in advance for char/composition so that the
2431 glyph string can be drawn over it. */
2432 if (!s->for_overlaps_p
2433 && s->face->box != FACE_NO_BOX
2434 && (s->first_glyph->type == CHAR_GLYPH
2435 || s->first_glyph->type == COMPOSITE_GLYPH))
2436
2437 {
2438 x_set_glyph_string_clipping (s);
2439 x_draw_glyph_string_background (s, 1);
2440 x_draw_glyph_string_box (s);
2441 x_set_glyph_string_clipping (s);
2442 relief_drawn_p = 1;
2443 }
2444 else
2445 x_set_glyph_string_clipping (s);
2446
2447 switch (s->first_glyph->type)
2448 {
2449 case IMAGE_GLYPH:
2450 x_draw_image_glyph_string (s);
2451 break;
2452
2453 case STRETCH_GLYPH:
2454 x_draw_stretch_glyph_string (s);
2455 break;
2456
2457 case CHAR_GLYPH:
2458 if (s->for_overlaps_p)
2459 s->background_filled_p = 1;
2460 else
2461 x_draw_glyph_string_background (s, 0);
2462 x_draw_glyph_string_foreground (s);
2463 break;
2464
2465 case COMPOSITE_GLYPH:
2466 if (s->for_overlaps_p || s->gidx > 0)
2467 s->background_filled_p = 1;
2468 else
2469 x_draw_glyph_string_background (s, 1);
2470 x_draw_composite_glyph_string_foreground (s);
2471 break;
2472
2473 default:
2474 abort ();
2475 }
2476
2477 if (!s->for_overlaps_p)
2478 {
2479 /* Draw underline. */
2480 if (s->face->underline_p
2481 && (s->font->bdf || !s->font->tm.tmUnderlined))
2482 {
2483 unsigned long h = 1;
2484 unsigned long dy = s->height - h;
2485
2486 /* TODO: Use font information for positioning and thickness
2487 of underline. See OUTLINETEXTMETRIC, and xterm.c. */
2488 if (s->face->underline_defaulted_p)
2489 {
2490 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
2491 s->y + dy, s->width, 1);
2492 }
2493 else
2494 {
2495 w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x,
2496 s->y + dy, s->width, 1);
2497 }
2498 }
2499
2500 /* Draw overline. */
2501 if (s->face->overline_p)
2502 {
2503 unsigned long dy = 0, h = 1;
2504
2505 if (s->face->overline_color_defaulted_p)
2506 {
2507 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
2508 s->y + dy, s->width, h);
2509 }
2510 else
2511 {
2512 w32_fill_area (s->f, s->hdc, s->face->overline_color, s->x,
2513 s->y + dy, s->width, h);
2514 }
2515 }
2516
2517 /* Draw strike-through. */
2518 if (s->face->strike_through_p
2519 && (s->font->bdf || !s->font->tm.tmStruckOut))
2520 {
2521 unsigned long h = 1;
2522 unsigned long dy = (s->height - h) / 2;
2523
2524 if (s->face->strike_through_color_defaulted_p)
2525 {
2526 w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x, s->y + dy,
2527 s->width, h);
2528 }
2529 else
2530 {
2531 w32_fill_area (s->f, s->hdc, s->face->underline_color, s->x,
2532 s->y + dy, s->width, h);
2533 }
2534 }
2535
2536 /* Draw relief. */
2537 if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
2538 x_draw_glyph_string_box (s);
2539 }
2540
2541 /* Reset clipping. */
2542 w32_set_clip_rectangle (s->hdc, NULL);
2543 }
2544
2545
2546 /* Shift display to make room for inserted glyphs. */
2547
2548 void
2549 w32_shift_glyphs_for_insert (f, x, y, width, height, shift_by)
2550 struct frame *f;
2551 int x, y, width, height, shift_by;
2552 {
2553 HDC hdc;
2554
2555 hdc = get_frame_dc (f);
2556 BitBlt (hdc, x + shift_by, y, width, height,
2557 hdc, x, y, SRCCOPY);
2558
2559 release_frame_dc (f, hdc);
2560 }
2561
2562
2563 /* Delete N glyphs at the nominal cursor position. Not implemented
2564 for X frames. */
2565
2566 static void
2567 x_delete_glyphs (n)
2568 register int n;
2569 {
2570 struct frame *f;
2571
2572 if (updating_frame)
2573 f = updating_frame;
2574 else
2575 f = SELECTED_FRAME ();
2576
2577 if (! FRAME_W32_P (f))
2578 return;
2579
2580 abort ();
2581 }
2582
2583
2584 /* Clear entire frame. If updating_frame is non-null, clear that
2585 frame. Otherwise clear the selected frame. */
2586
2587 static void
2588 x_clear_frame ()
2589 {
2590 struct frame *f;
2591
2592 if (updating_frame)
2593 f = updating_frame;
2594 else
2595 f = SELECTED_FRAME ();
2596
2597 if (! FRAME_W32_P (f))
2598 return;
2599
2600 /* Clearing the frame will erase any cursor, so mark them all as no
2601 longer visible. */
2602 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
2603 output_cursor.hpos = output_cursor.vpos = 0;
2604 output_cursor.x = -1;
2605
2606 /* We don't set the output cursor here because there will always
2607 follow an explicit cursor_to. */
2608 BLOCK_INPUT;
2609
2610 w32_clear_window (f);
2611
2612 /* We have to clear the scroll bars, too. If we have changed
2613 colors or something like that, then they should be notified. */
2614 x_scroll_bar_clear (f);
2615
2616 UNBLOCK_INPUT;
2617 }
2618
2619 \f
2620 /* Make audible bell. */
2621
2622 static void
2623 w32_ring_bell (void)
2624 {
2625 struct frame *f;
2626
2627 f = SELECTED_FRAME ();
2628
2629 BLOCK_INPUT;
2630
2631 if (FRAME_W32_P (f) && visible_bell)
2632 {
2633 int i;
2634 HWND hwnd = FRAME_W32_WINDOW (SELECTED_FRAME ());
2635
2636 for (i = 0; i < 5; i++)
2637 {
2638 FlashWindow (hwnd, TRUE);
2639 Sleep (10);
2640 }
2641 FlashWindow (hwnd, FALSE);
2642 }
2643 else
2644 w32_sys_ring_bell ();
2645
2646 UNBLOCK_INPUT;
2647 }
2648
2649 \f
2650 /* Specify how many text lines, from the top of the window,
2651 should be affected by insert-lines and delete-lines operations.
2652 This, and those operations, are used only within an update
2653 that is bounded by calls to x_update_begin and x_update_end. */
2654
2655 static void
2656 w32_set_terminal_window (n)
2657 register int n;
2658 {
2659 /* This function intentionally left blank. */
2660 }
2661
2662 \f
2663 /***********************************************************************
2664 Line Dance
2665 ***********************************************************************/
2666
2667 /* Perform an insert-lines or delete-lines operation, inserting N
2668 lines or deleting -N lines at vertical position VPOS. */
2669
2670 static void
2671 x_ins_del_lines (vpos, n)
2672 int vpos, n;
2673 {
2674 struct frame *f;
2675
2676 if (updating_frame)
2677 f = updating_frame;
2678 else
2679 f = SELECTED_FRAME ();
2680
2681 if (! FRAME_W32_P (f))
2682 return;
2683
2684 abort ();
2685 }
2686
2687
2688 /* Scroll part of the display as described by RUN. */
2689
2690 static void
2691 x_scroll_run (w, run)
2692 struct window *w;
2693 struct run *run;
2694 {
2695 struct frame *f = XFRAME (w->frame);
2696 int x, y, width, height, from_y, to_y, bottom_y;
2697 HWND hwnd = FRAME_W32_WINDOW (f);
2698 HRGN expect_dirty;
2699
2700 /* Get frame-relative bounding box of the text display area of W,
2701 without mode lines. Include in this box the left and right
2702 fringes of W. */
2703 window_box (w, -1, &x, &y, &width, &height);
2704
2705 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
2706 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
2707 bottom_y = y + height;
2708
2709 if (to_y < from_y)
2710 {
2711 /* Scrolling up. Make sure we don't copy part of the mode
2712 line at the bottom. */
2713 if (from_y + run->height > bottom_y)
2714 height = bottom_y - from_y;
2715 else
2716 height = run->height;
2717 expect_dirty = CreateRectRgn (x, y + height, x + width, bottom_y);
2718 }
2719 else
2720 {
2721 /* Scolling down. Make sure we don't copy over the mode line.
2722 at the bottom. */
2723 if (to_y + run->height > bottom_y)
2724 height = bottom_y - to_y;
2725 else
2726 height = run->height;
2727 expect_dirty = CreateRectRgn (x, y, x + width, to_y);
2728 }
2729
2730 BLOCK_INPUT;
2731
2732 /* Cursor off. Will be switched on again in x_update_window_end. */
2733 updated_window = w;
2734 x_clear_cursor (w);
2735
2736 {
2737 RECT from;
2738 RECT to;
2739 HRGN dirty = CreateRectRgn (0, 0, 0, 0);
2740 HRGN combined = CreateRectRgn (0, 0, 0, 0);
2741
2742 from.left = to.left = x;
2743 from.right = to.right = x + width;
2744 from.top = from_y;
2745 from.bottom = from_y + height;
2746 to.top = y;
2747 to.bottom = bottom_y;
2748
2749 ScrollWindowEx (hwnd, 0, to_y - from_y, &from, &to, dirty,
2750 NULL, SW_INVALIDATE);
2751
2752 /* Combine this with what we expect to be dirty. This covers the
2753 case where not all of the region we expect is actually dirty. */
2754 CombineRgn (combined, dirty, expect_dirty, RGN_OR);
2755
2756 /* If the dirty region is not what we expected, redraw the entire frame. */
2757 if (!EqualRgn (combined, expect_dirty))
2758 SET_FRAME_GARBAGED (f);
2759
2760 DeleteObject (dirty);
2761 DeleteObject (combined);
2762 }
2763
2764 UNBLOCK_INPUT;
2765 DeleteObject (expect_dirty);
2766 }
2767
2768
2769 \f
2770 /***********************************************************************
2771 Exposure Events
2772 ***********************************************************************/
2773
2774 static void
2775 frame_highlight (f)
2776 struct frame *f;
2777 {
2778 x_update_cursor (f, 1);
2779 }
2780
2781 static void
2782 frame_unhighlight (f)
2783 struct frame *f;
2784 {
2785 x_update_cursor (f, 1);
2786 }
2787
2788 /* The focus has changed. Update the frames as necessary to reflect
2789 the new situation. Note that we can't change the selected frame
2790 here, because the Lisp code we are interrupting might become confused.
2791 Each event gets marked with the frame in which it occurred, so the
2792 Lisp code can tell when the switch took place by examining the events. */
2793
2794 static void
2795 x_new_focus_frame (dpyinfo, frame)
2796 struct w32_display_info *dpyinfo;
2797 struct frame *frame;
2798 {
2799 struct frame *old_focus = dpyinfo->w32_focus_frame;
2800
2801 if (frame != dpyinfo->w32_focus_frame)
2802 {
2803 /* Set this before calling other routines, so that they see
2804 the correct value of w32_focus_frame. */
2805 dpyinfo->w32_focus_frame = frame;
2806
2807 if (old_focus && old_focus->auto_lower)
2808 x_lower_frame (old_focus);
2809
2810 if (dpyinfo->w32_focus_frame && dpyinfo->w32_focus_frame->auto_raise)
2811 pending_autoraise_frame = dpyinfo->w32_focus_frame;
2812 else
2813 pending_autoraise_frame = 0;
2814 }
2815
2816 x_frame_rehighlight (dpyinfo);
2817 }
2818
2819 /* Handle an event saying the mouse has moved out of an Emacs frame. */
2820
2821 void
2822 x_mouse_leave (dpyinfo)
2823 struct w32_display_info *dpyinfo;
2824 {
2825 x_new_focus_frame (dpyinfo, dpyinfo->w32_focus_event_frame);
2826 }
2827
2828 /* The focus has changed, or we have redirected a frame's focus to
2829 another frame (this happens when a frame uses a surrogate
2830 mini-buffer frame). Shift the highlight as appropriate.
2831
2832 The FRAME argument doesn't necessarily have anything to do with which
2833 frame is being highlighted or un-highlighted; we only use it to find
2834 the appropriate X display info. */
2835
2836 static void
2837 w32_frame_rehighlight (frame)
2838 struct frame *frame;
2839 {
2840 if (! FRAME_W32_P (frame))
2841 return;
2842 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame));
2843 }
2844
2845 static void
2846 x_frame_rehighlight (dpyinfo)
2847 struct w32_display_info *dpyinfo;
2848 {
2849 struct frame *old_highlight = dpyinfo->x_highlight_frame;
2850
2851 if (dpyinfo->w32_focus_frame)
2852 {
2853 dpyinfo->x_highlight_frame
2854 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame)))
2855 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame))
2856 : dpyinfo->w32_focus_frame);
2857 if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
2858 {
2859 FRAME_FOCUS_FRAME (dpyinfo->w32_focus_frame) = Qnil;
2860 dpyinfo->x_highlight_frame = dpyinfo->w32_focus_frame;
2861 }
2862 }
2863 else
2864 dpyinfo->x_highlight_frame = 0;
2865
2866 if (dpyinfo->x_highlight_frame != old_highlight)
2867 {
2868 if (old_highlight)
2869 frame_unhighlight (old_highlight);
2870 if (dpyinfo->x_highlight_frame)
2871 frame_highlight (dpyinfo->x_highlight_frame);
2872 }
2873 }
2874 \f
2875 /* Keyboard processing - modifier keys, etc. */
2876
2877 /* Convert a keysym to its name. */
2878
2879 char *
2880 x_get_keysym_name (keysym)
2881 int keysym;
2882 {
2883 /* Make static so we can always return it */
2884 static char value[100];
2885
2886 BLOCK_INPUT;
2887 GetKeyNameText (keysym, value, 100);
2888 UNBLOCK_INPUT;
2889
2890 return value;
2891 }
2892
2893
2894 \f
2895 /* Mouse clicks and mouse movement. Rah. */
2896
2897 /* Parse a button MESSAGE. The button index is returned in PBUTTON, and
2898 the state in PUP. XBUTTON provides extra information for extended mouse
2899 button messages. Returns FALSE if unable to parse the message. */
2900 BOOL
2901 parse_button (message, xbutton, pbutton, pup)
2902 int message;
2903 int xbutton;
2904 int * pbutton;
2905 int * pup;
2906 {
2907 int button = 0;
2908 int up = 0;
2909
2910 switch (message)
2911 {
2912 case WM_LBUTTONDOWN:
2913 button = 0;
2914 up = 0;
2915 break;
2916 case WM_LBUTTONUP:
2917 button = 0;
2918 up = 1;
2919 break;
2920 case WM_MBUTTONDOWN:
2921 if (NILP (Vw32_swap_mouse_buttons))
2922 button = 1;
2923 else
2924 button = 2;
2925 up = 0;
2926 break;
2927 case WM_MBUTTONUP:
2928 if (NILP (Vw32_swap_mouse_buttons))
2929 button = 1;
2930 else
2931 button = 2;
2932 up = 1;
2933 break;
2934 case WM_RBUTTONDOWN:
2935 if (NILP (Vw32_swap_mouse_buttons))
2936 button = 2;
2937 else
2938 button = 1;
2939 up = 0;
2940 break;
2941 case WM_RBUTTONUP:
2942 if (NILP (Vw32_swap_mouse_buttons))
2943 button = 2;
2944 else
2945 button = 1;
2946 up = 1;
2947 break;
2948 case WM_XBUTTONDOWN:
2949 button = xbutton + 2;
2950 up = 0;
2951 break;
2952 case WM_XBUTTONUP:
2953 button = xbutton + 2;
2954 up = 1;
2955 break;
2956 default:
2957 return (FALSE);
2958 }
2959
2960 if (pup) *pup = up;
2961 if (pbutton) *pbutton = button;
2962
2963 return (TRUE);
2964 }
2965
2966
2967 /* Prepare a mouse-event in *RESULT for placement in the input queue.
2968
2969 If the event is a button press, then note that we have grabbed
2970 the mouse. */
2971
2972 static Lisp_Object
2973 construct_mouse_click (result, msg, f)
2974 struct input_event *result;
2975 W32Msg *msg;
2976 struct frame *f;
2977 {
2978 int button;
2979 int up;
2980
2981 parse_button (msg->msg.message, HIWORD (msg->msg.wParam),
2982 &button, &up);
2983
2984 /* Make the event type NO_EVENT; we'll change that when we decide
2985 otherwise. */
2986 result->kind = MOUSE_CLICK_EVENT;
2987 result->code = button;
2988 result->timestamp = msg->msg.time;
2989 result->modifiers = (msg->dwModifiers
2990 | (up
2991 ? up_modifier
2992 : down_modifier));
2993
2994 XSETINT (result->x, LOWORD (msg->msg.lParam));
2995 XSETINT (result->y, HIWORD (msg->msg.lParam));
2996 XSETFRAME (result->frame_or_window, f);
2997 result->arg = Qnil;
2998 return Qnil;
2999 }
3000
3001 static Lisp_Object
3002 construct_mouse_wheel (result, msg, f)
3003 struct input_event *result;
3004 W32Msg *msg;
3005 struct frame *f;
3006 {
3007 POINT p;
3008 int delta;
3009
3010 result->kind = WHEEL_EVENT;
3011 result->code = 0;
3012 result->timestamp = msg->msg.time;
3013
3014 /* A WHEEL_DELTA positive value indicates that the wheel was rotated
3015 forward, away from the user (up); a negative value indicates that
3016 the wheel was rotated backward, toward the user (down). */
3017 delta = GET_WHEEL_DELTA_WPARAM (msg->msg.wParam);
3018
3019 /* The up and down modifiers indicate if the wheel was rotated up or
3020 down based on WHEEL_DELTA value. */
3021 result->modifiers = (msg->dwModifiers
3022 | ((delta < 0 ) ? down_modifier : up_modifier));
3023
3024 p.x = LOWORD (msg->msg.lParam);
3025 p.y = HIWORD (msg->msg.lParam);
3026 ScreenToClient (msg->msg.hwnd, &p);
3027 XSETINT (result->x, p.x);
3028 XSETINT (result->y, p.y);
3029 XSETFRAME (result->frame_or_window, f);
3030 result->arg = Qnil;
3031 return Qnil;
3032 }
3033
3034 static Lisp_Object
3035 construct_drag_n_drop (result, msg, f)
3036 struct input_event *result;
3037 W32Msg *msg;
3038 struct frame *f;
3039 {
3040 Lisp_Object files;
3041 Lisp_Object frame;
3042 HDROP hdrop;
3043 POINT p;
3044 WORD num_files;
3045 char *name;
3046 int i, len;
3047
3048 result->kind = DRAG_N_DROP_EVENT;
3049 result->code = 0;
3050 result->timestamp = msg->msg.time;
3051 result->modifiers = msg->dwModifiers;
3052
3053 hdrop = (HDROP) msg->msg.wParam;
3054 DragQueryPoint (hdrop, &p);
3055
3056 #if 0
3057 p.x = LOWORD (msg->msg.lParam);
3058 p.y = HIWORD (msg->msg.lParam);
3059 ScreenToClient (msg->msg.hwnd, &p);
3060 #endif
3061
3062 XSETINT (result->x, p.x);
3063 XSETINT (result->y, p.y);
3064
3065 num_files = DragQueryFile (hdrop, 0xFFFFFFFF, NULL, 0);
3066 files = Qnil;
3067
3068 for (i = 0; i < num_files; i++)
3069 {
3070 len = DragQueryFile (hdrop, i, NULL, 0);
3071 if (len <= 0)
3072 continue;
3073 name = alloca (len + 1);
3074 DragQueryFile (hdrop, i, name, len + 1);
3075 files = Fcons (DECODE_FILE (build_string (name)), files);
3076 }
3077
3078 DragFinish (hdrop);
3079
3080 XSETFRAME (frame, f);
3081 result->frame_or_window = Fcons (frame, files);
3082 result->arg = Qnil;
3083 return Qnil;
3084 }
3085
3086 \f
3087 /* Function to report a mouse movement to the mainstream Emacs code.
3088 The input handler calls this.
3089
3090 We have received a mouse movement event, which is given in *event.
3091 If the mouse is over a different glyph than it was last time, tell
3092 the mainstream emacs code by setting mouse_moved. If not, ask for
3093 another motion event, so we can check again the next time it moves. */
3094
3095 static MSG last_mouse_motion_event;
3096 static Lisp_Object last_mouse_motion_frame;
3097
3098 static void remember_mouse_glyph P_ ((struct frame *, int, int));
3099
3100 static void
3101 note_mouse_movement (frame, msg)
3102 FRAME_PTR frame;
3103 MSG *msg;
3104 {
3105 int mouse_x = LOWORD (msg->lParam);
3106 int mouse_y = HIWORD (msg->lParam);
3107
3108 last_mouse_movement_time = msg->time;
3109 memcpy (&last_mouse_motion_event, msg, sizeof (last_mouse_motion_event));
3110 XSETFRAME (last_mouse_motion_frame, frame);
3111
3112 if (msg->hwnd != FRAME_W32_WINDOW (frame))
3113 {
3114 frame->mouse_moved = 1;
3115 last_mouse_scroll_bar = Qnil;
3116 note_mouse_highlight (frame, -1, -1);
3117 }
3118
3119 /* Has the mouse moved off the glyph it was on at the last sighting? */
3120 else if (mouse_x < last_mouse_glyph.left
3121 || mouse_x > last_mouse_glyph.right
3122 || mouse_y < last_mouse_glyph.top
3123 || mouse_y > last_mouse_glyph.bottom)
3124 {
3125 frame->mouse_moved = 1;
3126 last_mouse_scroll_bar = Qnil;
3127 note_mouse_highlight (frame, mouse_x, mouse_y);
3128 /* Remember the mouse position here, as w32_mouse_position only
3129 gets called when mouse tracking is enabled but we also need
3130 to keep track of the mouse for help_echo and highlighting at
3131 other times. */
3132 remember_mouse_glyph (frame, mouse_x, mouse_y);
3133 }
3134 }
3135
3136 \f
3137 /************************************************************************
3138 Mouse Face
3139 ************************************************************************/
3140
3141 static struct scroll_bar *x_window_to_scroll_bar ();
3142 static void x_scroll_bar_report_motion ();
3143 static void x_check_fullscreen P_ ((struct frame *));
3144 static int glyph_rect P_ ((struct frame *f, int, int, RECT *));
3145
3146
3147 static void
3148 redo_mouse_highlight ()
3149 {
3150 if (!NILP (last_mouse_motion_frame)
3151 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame)))
3152 note_mouse_highlight (XFRAME (last_mouse_motion_frame),
3153 LOWORD (last_mouse_motion_event.lParam),
3154 HIWORD (last_mouse_motion_event.lParam));
3155 }
3156
3157 void
3158 w32_define_cursor (window, cursor)
3159 Window window;
3160 Cursor cursor;
3161 {
3162 PostMessage (window, WM_EMACS_SETCURSOR, (WPARAM) cursor, 0);
3163 }
3164
3165 /* Try to determine frame pixel position and size of the glyph under
3166 frame pixel coordinates X/Y on frame F . Return the position and
3167 size in *RECT. Value is non-zero if we could compute these
3168 values. */
3169
3170 static int
3171 glyph_rect (f, x, y, rect)
3172 struct frame *f;
3173 int x, y;
3174 RECT *rect;
3175 {
3176 Lisp_Object window;
3177
3178 window = window_from_coordinates (f, x, y, 0, &x, &y, 0);
3179
3180 if (!NILP (window))
3181 {
3182 struct window *w = XWINDOW (window);
3183 struct glyph_row *r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
3184 struct glyph_row *end = r + w->current_matrix->nrows - 1;
3185
3186 for (; r < end && r->enabled_p; ++r)
3187 if (r->y <= y && r->y + r->height > y)
3188 {
3189 /* Found the row at y. */
3190 struct glyph *g = r->glyphs[TEXT_AREA];
3191 struct glyph *end = g + r->used[TEXT_AREA];
3192 int gx;
3193
3194 rect->top = WINDOW_TO_FRAME_PIXEL_Y (w, r->y);
3195 rect->bottom = rect->top + r->height;
3196
3197 if (x < r->x)
3198 {
3199 /* x is to the left of the first glyph in the row. */
3200 /* Shouldn't this be a pixel value?
3201 WINDOW_LEFT_EDGE_X (w) seems to be the right value.
3202 ++KFS */
3203 rect->left = WINDOW_LEFT_EDGE_COL (w);
3204 rect->right = WINDOW_TO_FRAME_PIXEL_X (w, r->x);
3205 return 1;
3206 }
3207
3208 for (gx = r->x; g < end; gx += g->pixel_width, ++g)
3209 if (gx <= x && gx + g->pixel_width > x)
3210 {
3211 /* x is on a glyph. */
3212 rect->left = WINDOW_TO_FRAME_PIXEL_X (w, gx);
3213 rect->right = rect->left + g->pixel_width;
3214 return 1;
3215 }
3216
3217 /* x is to the right of the last glyph in the row. */
3218 rect->left = WINDOW_TO_FRAME_PIXEL_X (w, gx);
3219 /* Shouldn't this be a pixel value?
3220 WINDOW_RIGHT_EDGE_X (w) seems to be the right value.
3221 ++KFS */
3222 rect->right = WINDOW_RIGHT_EDGE_COL (w);
3223 return 1;
3224 }
3225 }
3226
3227 /* The y is not on any row. */
3228 return 0;
3229 }
3230
3231 /* Record the position of the mouse in last_mouse_glyph. */
3232 static void
3233 remember_mouse_glyph (f1, gx, gy)
3234 struct frame * f1;
3235 int gx, gy;
3236 {
3237 if (!glyph_rect (f1, gx, gy, &last_mouse_glyph))
3238 {
3239 int width = FRAME_SMALLEST_CHAR_WIDTH (f1);
3240 int height = FRAME_SMALLEST_FONT_HEIGHT (f1);
3241
3242 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
3243 round down even for negative values. */
3244 if (gx < 0)
3245 gx -= width - 1;
3246 if (gy < 0)
3247 gy -= height - 1;
3248 #if 0
3249 /* This was the original code from XTmouse_position, but it seems
3250 to give the position of the glyph diagonally next to the one
3251 the mouse is over. */
3252 gx = (gx + width - 1) / width * width;
3253 gy = (gy + height - 1) / height * height;
3254 #else
3255 gx = gx / width * width;
3256 gy = gy / height * height;
3257 #endif
3258
3259 last_mouse_glyph.left = gx;
3260 last_mouse_glyph.top = gy;
3261 last_mouse_glyph.right = gx + width;
3262 last_mouse_glyph.bottom = gy + height;
3263 }
3264 }
3265
3266 /* Return the current position of the mouse.
3267 *fp should be a frame which indicates which display to ask about.
3268
3269 If the mouse movement started in a scroll bar, set *fp, *bar_window,
3270 and *part to the frame, window, and scroll bar part that the mouse
3271 is over. Set *x and *y to the portion and whole of the mouse's
3272 position on the scroll bar.
3273
3274 If the mouse movement started elsewhere, set *fp to the frame the
3275 mouse is on, *bar_window to nil, and *x and *y to the character cell
3276 the mouse is over.
3277
3278 Set *time to the server time-stamp for the time at which the mouse
3279 was at this position.
3280
3281 Don't store anything if we don't have a valid set of values to report.
3282
3283 This clears the mouse_moved flag, so we can wait for the next mouse
3284 movement. */
3285
3286 static void
3287 w32_mouse_position (fp, insist, bar_window, part, x, y, time)
3288 FRAME_PTR *fp;
3289 int insist;
3290 Lisp_Object *bar_window;
3291 enum scroll_bar_part *part;
3292 Lisp_Object *x, *y;
3293 unsigned long *time;
3294 {
3295 FRAME_PTR f1;
3296
3297 BLOCK_INPUT;
3298
3299 if (! NILP (last_mouse_scroll_bar) && insist == 0)
3300 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
3301 else
3302 {
3303 POINT pt;
3304
3305 Lisp_Object frame, tail;
3306
3307 /* Clear the mouse-moved flag for every frame on this display. */
3308 FOR_EACH_FRAME (tail, frame)
3309 XFRAME (frame)->mouse_moved = 0;
3310
3311 last_mouse_scroll_bar = Qnil;
3312
3313 GetCursorPos (&pt);
3314
3315 /* Now we have a position on the root; find the innermost window
3316 containing the pointer. */
3317 {
3318 if (FRAME_W32_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
3319 && FRAME_LIVE_P (last_mouse_frame))
3320 {
3321 /* If mouse was grabbed on a frame, give coords for that frame
3322 even if the mouse is now outside it. */
3323 f1 = last_mouse_frame;
3324 }
3325 else
3326 {
3327 /* Is window under mouse one of our frames? */
3328 f1 = x_any_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp),
3329 WindowFromPoint (pt));
3330 }
3331
3332 /* If not, is it one of our scroll bars? */
3333 if (! f1)
3334 {
3335 struct scroll_bar *bar
3336 = x_window_to_scroll_bar (WindowFromPoint (pt));
3337
3338 if (bar)
3339 {
3340 f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3341 }
3342 }
3343
3344 if (f1 == 0 && insist > 0)
3345 f1 = SELECTED_FRAME ();
3346
3347 if (f1)
3348 {
3349 /* Ok, we found a frame. Store all the values.
3350 last_mouse_glyph is a rectangle used to reduce the
3351 generation of mouse events. To not miss any motion
3352 events, we must divide the frame into rectangles of the
3353 size of the smallest character that could be displayed
3354 on it, i.e. into the same rectangles that matrices on
3355 the frame are divided into. */
3356
3357 #if OLD_REDISPLAY_CODE
3358 int ignore1, ignore2;
3359
3360 ScreenToClient (FRAME_W32_WINDOW (f1), &pt);
3361
3362 pixel_to_glyph_coords (f1, pt.x, pt.y, &ignore1, &ignore2,
3363 &last_mouse_glyph,
3364 FRAME_W32_DISPLAY_INFO (f1)->grabbed
3365 || insist);
3366 #else
3367 ScreenToClient (FRAME_W32_WINDOW (f1), &pt);
3368 remember_mouse_glyph (f1, pt.x, pt.y);
3369 #endif
3370
3371 *bar_window = Qnil;
3372 *part = 0;
3373 *fp = f1;
3374 XSETINT (*x, pt.x);
3375 XSETINT (*y, pt.y);
3376 *time = last_mouse_movement_time;
3377 }
3378 }
3379 }
3380
3381 UNBLOCK_INPUT;
3382 }
3383
3384 \f
3385 /***********************************************************************
3386 Tool-bars
3387 ***********************************************************************/
3388
3389 /* Handle mouse button event on the tool-bar of frame F, at
3390 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
3391 or ButtonRelase. */
3392
3393 static void
3394 w32_handle_tool_bar_click (f, button_event)
3395 struct frame *f;
3396 struct input_event *button_event;
3397 {
3398 int x = XFASTINT (button_event->x);
3399 int y = XFASTINT (button_event->y);
3400
3401 if (button_event->modifiers & down_modifier)
3402 handle_tool_bar_click (f, x, y, 1, 0);
3403 else
3404 handle_tool_bar_click (f, x, y, 0,
3405 button_event->modifiers & ~up_modifier);
3406 }
3407
3408
3409 \f
3410 /***********************************************************************
3411 Scroll bars
3412 ***********************************************************************/
3413
3414 /* Scroll bar support. */
3415
3416 /* Given a window ID, find the struct scroll_bar which manages it.
3417 This can be called in GC, so we have to make sure to strip off mark
3418 bits. */
3419
3420 static struct scroll_bar *
3421 x_window_to_scroll_bar (window_id)
3422 Window window_id;
3423 {
3424 Lisp_Object tail;
3425
3426 for (tail = Vframe_list;
3427 XGCTYPE (tail) == Lisp_Cons;
3428 tail = XCDR (tail))
3429 {
3430 Lisp_Object frame, bar, condemned;
3431
3432 frame = XCAR (tail);
3433 /* All elements of Vframe_list should be frames. */
3434 if (! GC_FRAMEP (frame))
3435 abort ();
3436
3437 /* Scan this frame's scroll bar list for a scroll bar with the
3438 right window ID. */
3439 condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
3440 for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
3441 /* This trick allows us to search both the ordinary and
3442 condemned scroll bar lists with one loop. */
3443 ! GC_NILP (bar) || (bar = condemned,
3444 condemned = Qnil,
3445 ! GC_NILP (bar));
3446 bar = XSCROLL_BAR (bar)->next)
3447 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar)) == window_id)
3448 return XSCROLL_BAR (bar);
3449 }
3450
3451 return 0;
3452 }
3453
3454
3455 \f
3456 /* Set the thumb size and position of scroll bar BAR. We are currently
3457 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3458
3459 static void
3460 w32_set_scroll_bar_thumb (bar, portion, position, whole)
3461 struct scroll_bar *bar;
3462 int portion, position, whole;
3463 {
3464 Window w = SCROLL_BAR_W32_WINDOW (bar);
3465 double range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
3466 int sb_page, sb_pos;
3467 BOOL draggingp = !NILP (bar->dragging) ? TRUE : FALSE;
3468
3469 if (whole)
3470 {
3471 /* Position scroll bar at rock bottom if the bottom of the
3472 buffer is visible. This avoids shinking the thumb away
3473 to nothing if it is held at the bottom of the buffer. */
3474 if (position + portion >= whole)
3475 {
3476 sb_page = range * (whole - position) / whole
3477 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3478 sb_pos = range;
3479 }
3480
3481 sb_page = portion * range / whole + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3482 sb_pos = position * range / whole;
3483 }
3484 else
3485 {
3486 sb_page = range;
3487 sb_pos = 0;
3488 }
3489
3490 BLOCK_INPUT;
3491
3492 if (pfnSetScrollInfo)
3493 {
3494 SCROLLINFO si;
3495
3496 si.cbSize = sizeof (si);
3497 /* Only update page size if currently dragging, to reduce
3498 flicker effects. */
3499 if (draggingp)
3500 si.fMask = SIF_PAGE;
3501 else
3502 si.fMask = SIF_PAGE | SIF_POS;
3503 si.nPage = sb_page;
3504 si.nPos = sb_pos;
3505
3506 pfnSetScrollInfo (w, SB_CTL, &si, !draggingp);
3507 }
3508 else
3509 SetScrollPos (w, SB_CTL, sb_pos, !draggingp);
3510
3511 UNBLOCK_INPUT;
3512 }
3513
3514 \f
3515 /************************************************************************
3516 Scroll bars, general
3517 ************************************************************************/
3518
3519 HWND
3520 my_create_scrollbar (f, bar)
3521 struct frame * f;
3522 struct scroll_bar * bar;
3523 {
3524 return (HWND) SendMessage (FRAME_W32_WINDOW (f),
3525 WM_EMACS_CREATESCROLLBAR, (WPARAM) f,
3526 (LPARAM) bar);
3527 }
3528
3529 /*#define ATTACH_THREADS*/
3530
3531 BOOL
3532 my_show_window (FRAME_PTR f, HWND hwnd, int how)
3533 {
3534 #ifndef ATTACH_THREADS
3535 return SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SHOWWINDOW,
3536 (WPARAM) hwnd, (LPARAM) how);
3537 #else
3538 return ShowWindow (hwnd, how);
3539 #endif
3540 }
3541
3542 void
3543 my_set_window_pos (HWND hwnd, HWND hwndAfter,
3544 int x, int y, int cx, int cy, UINT flags)
3545 {
3546 #ifndef ATTACH_THREADS
3547 WINDOWPOS pos;
3548 pos.hwndInsertAfter = hwndAfter;
3549 pos.x = x;
3550 pos.y = y;
3551 pos.cx = cx;
3552 pos.cy = cy;
3553 pos.flags = flags;
3554 SendMessage (hwnd, WM_EMACS_SETWINDOWPOS, (WPARAM) &pos, 0);
3555 #else
3556 SetWindowPos (hwnd, hwndAfter, x, y, cx, cy, flags);
3557 #endif
3558 }
3559
3560 void
3561 my_set_focus (f, hwnd)
3562 struct frame * f;
3563 HWND hwnd;
3564 {
3565 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_SETFOCUS,
3566 (WPARAM) hwnd, 0);
3567 }
3568
3569 void
3570 my_set_foreground_window (hwnd)
3571 HWND hwnd;
3572 {
3573 SendMessage (hwnd, WM_EMACS_SETFOREGROUND, (WPARAM) hwnd, 0);
3574 }
3575
3576 void
3577 my_destroy_window (f, hwnd)
3578 struct frame * f;
3579 HWND hwnd;
3580 {
3581 SendMessage (FRAME_W32_WINDOW (f), WM_EMACS_DESTROYWINDOW,
3582 (WPARAM) hwnd, 0);
3583 }
3584
3585 /* Create a scroll bar and return the scroll bar vector for it. W is
3586 the Emacs window on which to create the scroll bar. TOP, LEFT,
3587 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
3588 scroll bar. */
3589
3590 static struct scroll_bar *
3591 x_scroll_bar_create (w, top, left, width, height)
3592 struct window *w;
3593 int top, left, width, height;
3594 {
3595 struct frame *f = XFRAME (WINDOW_FRAME (w));
3596 HWND hwnd;
3597 struct scroll_bar *bar
3598 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
3599
3600 BLOCK_INPUT;
3601
3602 XSETWINDOW (bar->window, w);
3603 XSETINT (bar->top, top);
3604 XSETINT (bar->left, left);
3605 XSETINT (bar->width, width);
3606 XSETINT (bar->height, height);
3607 XSETINT (bar->start, 0);
3608 XSETINT (bar->end, 0);
3609 bar->dragging = Qnil;
3610
3611 /* Requires geometry to be set before call to create the real window */
3612
3613 hwnd = my_create_scrollbar (f, bar);
3614
3615 if (pfnSetScrollInfo)
3616 {
3617 SCROLLINFO si;
3618
3619 si.cbSize = sizeof (si);
3620 si.fMask = SIF_ALL;
3621 si.nMin = 0;
3622 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
3623 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3624 si.nPage = si.nMax;
3625 si.nPos = 0;
3626
3627 pfnSetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3628 }
3629 else
3630 {
3631 SetScrollRange (hwnd, SB_CTL, 0,
3632 VERTICAL_SCROLL_BAR_TOP_RANGE (f, height), FALSE);
3633 SetScrollPos (hwnd, SB_CTL, 0, FALSE);
3634 }
3635
3636 SET_SCROLL_BAR_W32_WINDOW (bar, hwnd);
3637
3638 /* Add bar to its frame's list of scroll bars. */
3639 bar->next = FRAME_SCROLL_BARS (f);
3640 bar->prev = Qnil;
3641 XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
3642 if (! NILP (bar->next))
3643 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
3644
3645 UNBLOCK_INPUT;
3646
3647 return bar;
3648 }
3649
3650
3651 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
3652 nil. */
3653
3654 static void
3655 x_scroll_bar_remove (bar)
3656 struct scroll_bar *bar;
3657 {
3658 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3659
3660 BLOCK_INPUT;
3661
3662 /* Destroy the window. */
3663 my_destroy_window (f, SCROLL_BAR_W32_WINDOW (bar));
3664
3665 /* Disassociate this scroll bar from its window. */
3666 XWINDOW (bar->window)->vertical_scroll_bar = Qnil;
3667
3668 UNBLOCK_INPUT;
3669 }
3670
3671 /* Set the handle of the vertical scroll bar for WINDOW to indicate
3672 that we are displaying PORTION characters out of a total of WHOLE
3673 characters, starting at POSITION. If WINDOW has no scroll bar,
3674 create one. */
3675 static void
3676 w32_set_vertical_scroll_bar (w, portion, whole, position)
3677 struct window *w;
3678 int portion, whole, position;
3679 {
3680 struct frame *f = XFRAME (w->frame);
3681 struct scroll_bar *bar;
3682 int top, height, left, sb_left, width, sb_width;
3683 int window_y, window_height;
3684
3685 /* Get window dimensions. */
3686 window_box (w, -1, 0, &window_y, 0, &window_height);
3687 top = window_y;
3688 width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
3689 height = window_height;
3690
3691 /* Compute the left edge of the scroll bar area. */
3692 left = WINDOW_SCROLL_BAR_AREA_X (w);
3693
3694 /* Compute the width of the scroll bar which might be less than
3695 the width of the area reserved for the scroll bar. */
3696 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w) > 0)
3697 sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
3698 else
3699 sb_width = width;
3700
3701 /* Compute the left edge of the scroll bar. */
3702 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
3703 sb_left = left + width - sb_width - (width - sb_width) / 2;
3704 else
3705 sb_left = left + (width - sb_width) / 2;
3706
3707 /* Does the scroll bar exist yet? */
3708 if (NILP (w->vertical_scroll_bar))
3709 {
3710 HDC hdc;
3711 BLOCK_INPUT;
3712 if (width > 0 && height > 0)
3713 {
3714 hdc = get_frame_dc (f);
3715 w32_clear_area (f, hdc, left, top, width, height);
3716 release_frame_dc (f, hdc);
3717 }
3718 UNBLOCK_INPUT;
3719
3720 bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
3721 }
3722 else
3723 {
3724 /* It may just need to be moved and resized. */
3725 HWND hwnd;
3726
3727 bar = XSCROLL_BAR (w->vertical_scroll_bar);
3728 hwnd = SCROLL_BAR_W32_WINDOW (bar);
3729
3730 /* If already correctly positioned, do nothing. */
3731 if ( XINT (bar->left) == sb_left
3732 && XINT (bar->top) == top
3733 && XINT (bar->width) == sb_width
3734 && XINT (bar->height) == height )
3735 {
3736 /* Redraw after clear_frame. */
3737 if (!my_show_window (f, hwnd, SW_NORMAL))
3738 InvalidateRect (hwnd, NULL, FALSE);
3739 }
3740 else
3741 {
3742 HDC hdc;
3743 BLOCK_INPUT;
3744 if (width && height)
3745 {
3746 hdc = get_frame_dc (f);
3747 /* Since Windows scroll bars are smaller than the space reserved
3748 for them on the frame, we have to clear "under" them. */
3749 w32_clear_area (f, hdc,
3750 left,
3751 top,
3752 width,
3753 height);
3754 release_frame_dc (f, hdc);
3755 }
3756 /* Make sure scroll bar is "visible" before moving, to ensure the
3757 area of the parent window now exposed will be refreshed. */
3758 my_show_window (f, hwnd, SW_HIDE);
3759 MoveWindow (hwnd, sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
3760 top, sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
3761 max (height, 1), TRUE);
3762 if (pfnSetScrollInfo)
3763 {
3764 SCROLLINFO si;
3765
3766 si.cbSize = sizeof (si);
3767 si.fMask = SIF_RANGE;
3768 si.nMin = 0;
3769 si.nMax = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height)
3770 + VERTICAL_SCROLL_BAR_MIN_HANDLE;
3771
3772 pfnSetScrollInfo (hwnd, SB_CTL, &si, FALSE);
3773 }
3774 else
3775 SetScrollRange (hwnd, SB_CTL, 0,
3776 VERTICAL_SCROLL_BAR_TOP_RANGE (f, height), FALSE);
3777 my_show_window (f, hwnd, SW_NORMAL);
3778 /* InvalidateRect (w, NULL, FALSE); */
3779
3780 /* Remember new settings. */
3781 XSETINT (bar->left, sb_left);
3782 XSETINT (bar->top, top);
3783 XSETINT (bar->width, sb_width);
3784 XSETINT (bar->height, height);
3785
3786 UNBLOCK_INPUT;
3787 }
3788 }
3789 w32_set_scroll_bar_thumb (bar, portion, position, whole);
3790
3791 XSETVECTOR (w->vertical_scroll_bar, bar);
3792 }
3793
3794
3795 /* The following three hooks are used when we're doing a thorough
3796 redisplay of the frame. We don't explicitly know which scroll bars
3797 are going to be deleted, because keeping track of when windows go
3798 away is a real pain - "Can you say set-window-configuration, boys
3799 and girls?" Instead, we just assert at the beginning of redisplay
3800 that *all* scroll bars are to be removed, and then save a scroll bar
3801 from the fiery pit when we actually redisplay its window. */
3802
3803 /* Arrange for all scroll bars on FRAME to be removed at the next call
3804 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
3805 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
3806
3807 static void
3808 w32_condemn_scroll_bars (frame)
3809 FRAME_PTR frame;
3810 {
3811 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
3812 while (! NILP (FRAME_SCROLL_BARS (frame)))
3813 {
3814 Lisp_Object bar;
3815 bar = FRAME_SCROLL_BARS (frame);
3816 FRAME_SCROLL_BARS (frame) = XSCROLL_BAR (bar)->next;
3817 XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
3818 XSCROLL_BAR (bar)->prev = Qnil;
3819 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
3820 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
3821 FRAME_CONDEMNED_SCROLL_BARS (frame) = bar;
3822 }
3823 }
3824
3825
3826 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
3827 Note that WINDOW isn't necessarily condemned at all. */
3828
3829 static void
3830 w32_redeem_scroll_bar (window)
3831 struct window *window;
3832 {
3833 struct scroll_bar *bar;
3834 struct frame *f;
3835
3836 /* We can't redeem this window's scroll bar if it doesn't have one. */
3837 if (NILP (window->vertical_scroll_bar))
3838 abort ();
3839
3840 bar = XSCROLL_BAR (window->vertical_scroll_bar);
3841
3842 /* Unlink it from the condemned list. */
3843 f = XFRAME (WINDOW_FRAME (window));
3844 if (NILP (bar->prev))
3845 {
3846 /* If the prev pointer is nil, it must be the first in one of
3847 the lists. */
3848 if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
3849 /* It's not condemned. Everything's fine. */
3850 return;
3851 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
3852 window->vertical_scroll_bar))
3853 FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next;
3854 else
3855 /* If its prev pointer is nil, it must be at the front of
3856 one or the other! */
3857 abort ();
3858 }
3859 else
3860 XSCROLL_BAR (bar->prev)->next = bar->next;
3861
3862 if (! NILP (bar->next))
3863 XSCROLL_BAR (bar->next)->prev = bar->prev;
3864
3865 bar->next = FRAME_SCROLL_BARS (f);
3866 bar->prev = Qnil;
3867 XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
3868 if (! NILP (bar->next))
3869 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
3870 }
3871
3872 /* Remove all scroll bars on FRAME that haven't been saved since the
3873 last call to `*condemn_scroll_bars_hook'. */
3874
3875 static void
3876 w32_judge_scroll_bars (f)
3877 FRAME_PTR f;
3878 {
3879 Lisp_Object bar, next;
3880
3881 bar = FRAME_CONDEMNED_SCROLL_BARS (f);
3882
3883 /* Clear out the condemned list now so we won't try to process any
3884 more events on the hapless scroll bars. */
3885 FRAME_CONDEMNED_SCROLL_BARS (f) = Qnil;
3886
3887 for (; ! NILP (bar); bar = next)
3888 {
3889 struct scroll_bar *b = XSCROLL_BAR (bar);
3890
3891 x_scroll_bar_remove (b);
3892
3893 next = b->next;
3894 b->next = b->prev = Qnil;
3895 }
3896
3897 /* Now there should be no references to the condemned scroll bars,
3898 and they should get garbage-collected. */
3899 }
3900
3901 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
3902 is set to something other than NO_EVENT, it is enqueued.
3903
3904 This may be called from a signal handler, so we have to ignore GC
3905 mark bits. */
3906
3907 static int
3908 w32_scroll_bar_handle_click (bar, msg, emacs_event)
3909 struct scroll_bar *bar;
3910 W32Msg *msg;
3911 struct input_event *emacs_event;
3912 {
3913 if (! GC_WINDOWP (bar->window))
3914 abort ();
3915
3916 emacs_event->kind = W32_SCROLL_BAR_CLICK_EVENT;
3917 emacs_event->code = 0;
3918 /* not really meaningful to distinguish up/down */
3919 emacs_event->modifiers = msg->dwModifiers;
3920 emacs_event->frame_or_window = bar->window;
3921 emacs_event->arg = Qnil;
3922 emacs_event->timestamp = msg->msg.time;
3923
3924 {
3925 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
3926 int y;
3927 int dragging = !NILP (bar->dragging);
3928
3929 if (pfnGetScrollInfo)
3930 {
3931 SCROLLINFO si;
3932
3933 si.cbSize = sizeof (si);
3934 si.fMask = SIF_POS;
3935
3936 pfnGetScrollInfo ((HWND) msg->msg.lParam, SB_CTL, &si);
3937 y = si.nPos;
3938 }
3939 else
3940 y = GetScrollPos ((HWND) msg->msg.lParam, SB_CTL);
3941
3942 bar->dragging = Qnil;
3943
3944
3945 last_mouse_scroll_bar_pos = msg->msg.wParam;
3946
3947 switch (LOWORD (msg->msg.wParam))
3948 {
3949 case SB_LINEDOWN:
3950 emacs_event->part = scroll_bar_down_arrow;
3951 break;
3952 case SB_LINEUP:
3953 emacs_event->part = scroll_bar_up_arrow;
3954 break;
3955 case SB_PAGEUP:
3956 emacs_event->part = scroll_bar_above_handle;
3957 break;
3958 case SB_PAGEDOWN:
3959 emacs_event->part = scroll_bar_below_handle;
3960 break;
3961 case SB_TOP:
3962 emacs_event->part = scroll_bar_handle;
3963 y = 0;
3964 break;
3965 case SB_BOTTOM:
3966 emacs_event->part = scroll_bar_handle;
3967 y = top_range;
3968 break;
3969 case SB_THUMBTRACK:
3970 case SB_THUMBPOSITION:
3971 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) <= 0xffff)
3972 y = HIWORD (msg->msg.wParam);
3973 bar->dragging = Qt;
3974 emacs_event->part = scroll_bar_handle;
3975
3976 /* "Silently" update current position. */
3977 if (pfnSetScrollInfo)
3978 {
3979 SCROLLINFO si;
3980
3981 si.cbSize = sizeof (si);
3982 si.fMask = SIF_POS;
3983 si.nPos = y;
3984 /* Remember apparent position (we actually lag behind the real
3985 position, so don't set that directly. */
3986 last_scroll_bar_drag_pos = y;
3987
3988 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, FALSE);
3989 }
3990 else
3991 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, y, FALSE);
3992 break;
3993 case SB_ENDSCROLL:
3994 /* If this is the end of a drag sequence, then reset the scroll
3995 handle size to normal and do a final redraw. Otherwise do
3996 nothing. */
3997 if (dragging)
3998 {
3999 if (pfnSetScrollInfo)
4000 {
4001 SCROLLINFO si;
4002 int start = XINT (bar->start);
4003 int end = XINT (bar->end);
4004
4005 si.cbSize = sizeof (si);
4006 si.fMask = SIF_PAGE | SIF_POS;
4007 si.nPage = end - start + VERTICAL_SCROLL_BAR_MIN_HANDLE;
4008 si.nPos = last_scroll_bar_drag_pos;
4009 pfnSetScrollInfo (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, &si, TRUE);
4010 }
4011 else
4012 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar), SB_CTL, y, TRUE);
4013 }
4014 /* fall through */
4015 default:
4016 emacs_event->kind = NO_EVENT;
4017 return FALSE;
4018 }
4019
4020 XSETINT (emacs_event->x, y);
4021 XSETINT (emacs_event->y, top_range);
4022
4023 return TRUE;
4024 }
4025 }
4026
4027 /* Return information to the user about the current position of the mouse
4028 on the scroll bar. */
4029
4030 static void
4031 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
4032 FRAME_PTR *fp;
4033 Lisp_Object *bar_window;
4034 enum scroll_bar_part *part;
4035 Lisp_Object *x, *y;
4036 unsigned long *time;
4037 {
4038 struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
4039 Window w = SCROLL_BAR_W32_WINDOW (bar);
4040 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
4041 int pos;
4042 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
4043
4044 BLOCK_INPUT;
4045
4046 *fp = f;
4047 *bar_window = bar->window;
4048
4049 if (pfnGetScrollInfo)
4050 {
4051 SCROLLINFO si;
4052
4053 si.cbSize = sizeof (si);
4054 si.fMask = SIF_POS | SIF_PAGE | SIF_RANGE;
4055
4056 pfnGetScrollInfo (w, SB_CTL, &si);
4057 pos = si.nPos;
4058 top_range = si.nMax - si.nPage + 1;
4059 }
4060 else
4061 pos = GetScrollPos (w, SB_CTL);
4062
4063 switch (LOWORD (last_mouse_scroll_bar_pos))
4064 {
4065 case SB_THUMBPOSITION:
4066 case SB_THUMBTRACK:
4067 *part = scroll_bar_handle;
4068 if (VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height)) <= 0xffff)
4069 pos = HIWORD (last_mouse_scroll_bar_pos);
4070 break;
4071 case SB_LINEDOWN:
4072 *part = scroll_bar_handle;
4073 pos++;
4074 break;
4075 default:
4076 *part = scroll_bar_handle;
4077 break;
4078 }
4079
4080 XSETINT (*x, pos);
4081 XSETINT (*y, top_range);
4082
4083 f->mouse_moved = 0;
4084 last_mouse_scroll_bar = Qnil;
4085
4086 *time = last_mouse_movement_time;
4087
4088 UNBLOCK_INPUT;
4089 }
4090
4091
4092 /* The screen has been cleared so we may have changed foreground or
4093 background colors, and the scroll bars may need to be redrawn.
4094 Clear out the scroll bars, and ask for expose events, so we can
4095 redraw them. */
4096
4097 void
4098 x_scroll_bar_clear (f)
4099 FRAME_PTR f;
4100 {
4101 Lisp_Object bar;
4102
4103 /* We can have scroll bars even if this is 0,
4104 if we just turned off scroll bar mode.
4105 But in that case we should not clear them. */
4106 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
4107 for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
4108 bar = XSCROLL_BAR (bar)->next)
4109 {
4110 HWND window = SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar));
4111 HDC hdc = GetDC (window);
4112 RECT rect;
4113
4114 /* Hide scroll bar until ready to repaint. x_scroll_bar_move
4115 arranges to refresh the scroll bar if hidden. */
4116 my_show_window (f, window, SW_HIDE);
4117
4118 GetClientRect (window, &rect);
4119 select_palette (f, hdc);
4120 w32_clear_rect (f, hdc, &rect);
4121 deselect_palette (f, hdc);
4122
4123 ReleaseDC (window, hdc);
4124 }
4125 }
4126
4127 \f
4128 /* The main W32 event-reading loop - w32_read_socket. */
4129
4130 /* Record the last 100 characters stored
4131 to help debug the loss-of-chars-during-GC problem. */
4132
4133 static int temp_index;
4134 static short temp_buffer[100];
4135
4136
4137 /* Read events coming from the W32 shell.
4138 This routine is called by the SIGIO handler.
4139 We return as soon as there are no more events to be read.
4140
4141 We return the number of characters stored into the buffer,
4142 thus pretending to be `read'.
4143
4144 EXPECTED is nonzero if the caller knows input is available.
4145
4146 Some of these messages are reposted back to the message queue since the
4147 system calls the windows proc directly in a context where we cannot return
4148 the data nor can we guarantee the state we are in. So if we dispatch them
4149 we will get into an infinite loop. To prevent this from ever happening we
4150 will set a variable to indicate we are in the read_socket call and indicate
4151 which message we are processing since the windows proc gets called
4152 recursively with different messages by the system.
4153 */
4154
4155 int
4156 w32_read_socket (sd, expected, hold_quit)
4157 register int sd;
4158 int expected;
4159 struct input_event *hold_quit;
4160 {
4161 int count = 0;
4162 int check_visibility = 0;
4163 W32Msg msg;
4164 struct frame *f;
4165 struct w32_display_info *dpyinfo = &one_w32_display_info;
4166
4167 if (interrupt_input_blocked)
4168 {
4169 interrupt_input_pending = 1;
4170 return -1;
4171 }
4172
4173 interrupt_input_pending = 0;
4174 BLOCK_INPUT;
4175
4176 /* So people can tell when we have read the available input. */
4177 input_signal_count++;
4178
4179 /* TODO: ghostscript integration. */
4180 while (get_next_msg (&msg, FALSE))
4181 {
4182 struct input_event inev;
4183 int do_help = 0;
4184
4185 EVENT_INIT (inev);
4186 inev.kind = NO_EVENT;
4187 inev.arg = Qnil;
4188
4189 switch (msg.msg.message)
4190 {
4191 case WM_PAINT:
4192 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4193
4194 if (f)
4195 {
4196 if (msg.rect.right == msg.rect.left ||
4197 msg.rect.bottom == msg.rect.top)
4198 {
4199 /* We may get paint messages even though the client
4200 area is clipped - these are not expose events. */
4201 DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f,
4202 SDATA (f->name)));
4203 }
4204 else if (f->async_visible != 1)
4205 {
4206 /* Definitely not obscured, so mark as visible. */
4207 f->async_visible = 1;
4208 f->async_iconified = 0;
4209 SET_FRAME_GARBAGED (f);
4210 DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f,
4211 SDATA (f->name)));
4212
4213 /* WM_PAINT serves as MapNotify as well, so report
4214 visibility changes properly. */
4215 if (f->iconified)
4216 {
4217 inev.kind = DEICONIFY_EVENT;
4218 XSETFRAME (inev.frame_or_window, f);
4219 }
4220 else if (! NILP (Vframe_list)
4221 && ! NILP (XCDR (Vframe_list)))
4222 /* Force a redisplay sooner or later to update the
4223 frame titles in case this is the second frame. */
4224 record_asynch_buffer_change ();
4225 }
4226 else
4227 {
4228 HDC hdc = get_frame_dc (f);
4229
4230 /* Erase background again for safety. */
4231 w32_clear_rect (f, hdc, &msg.rect);
4232 release_frame_dc (f, hdc);
4233 expose_frame (f,
4234 msg.rect.left,
4235 msg.rect.top,
4236 msg.rect.right - msg.rect.left,
4237 msg.rect.bottom - msg.rect.top);
4238 }
4239 }
4240 break;
4241
4242 case WM_INPUTLANGCHANGE:
4243 /* Generate a language change event. */
4244 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4245
4246 if (f)
4247 {
4248 inev.kind = LANGUAGE_CHANGE_EVENT;
4249 XSETFRAME (inev.frame_or_window, f);
4250 inev.code = msg.msg.wParam;
4251 inev.modifiers = msg.msg.lParam & 0xffff;
4252 }
4253 break;
4254
4255 case WM_KEYDOWN:
4256 case WM_SYSKEYDOWN:
4257 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4258
4259 if (f && !f->iconified)
4260 {
4261 if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
4262 {
4263 clear_mouse_face (dpyinfo);
4264 dpyinfo->mouse_face_hidden = 1;
4265 }
4266
4267 if (temp_index == sizeof temp_buffer / sizeof (short))
4268 temp_index = 0;
4269 temp_buffer[temp_index++] = msg.msg.wParam;
4270 inev.kind = NON_ASCII_KEYSTROKE_EVENT;
4271 inev.code = msg.msg.wParam;
4272 inev.modifiers = msg.dwModifiers;
4273 XSETFRAME (inev.frame_or_window, f);
4274 inev.timestamp = msg.msg.time;
4275 }
4276 break;
4277
4278 case WM_SYSCHAR:
4279 case WM_CHAR:
4280 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4281
4282 if (f && !f->iconified)
4283 {
4284 if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
4285 {
4286 clear_mouse_face (dpyinfo);
4287 dpyinfo->mouse_face_hidden = 1;
4288 }
4289
4290 if (temp_index == sizeof temp_buffer / sizeof (short))
4291 temp_index = 0;
4292 temp_buffer[temp_index++] = msg.msg.wParam;
4293 inev.kind = ASCII_KEYSTROKE_EVENT;
4294 inev.code = msg.msg.wParam;
4295 inev.modifiers = msg.dwModifiers;
4296 XSETFRAME (inev.frame_or_window, f);
4297 inev.timestamp = msg.msg.time;
4298 }
4299 break;
4300
4301 case WM_MOUSEMOVE:
4302 /* Ignore non-movement. */
4303 {
4304 int x = LOWORD (msg.msg.lParam);
4305 int y = HIWORD (msg.msg.lParam);
4306 if (x == last_mousemove_x && y == last_mousemove_y)
4307 break;
4308 last_mousemove_x = x;
4309 last_mousemove_y = y;
4310 }
4311
4312 previous_help_echo_string = help_echo_string;
4313
4314 if (dpyinfo->grabbed && last_mouse_frame
4315 && FRAME_LIVE_P (last_mouse_frame))
4316 f = last_mouse_frame;
4317 else
4318 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4319
4320 if (dpyinfo->mouse_face_hidden)
4321 {
4322 dpyinfo->mouse_face_hidden = 0;
4323 clear_mouse_face (dpyinfo);
4324 }
4325
4326 if (f)
4327 {
4328 /* Generate SELECT_WINDOW_EVENTs when needed. */
4329 if (mouse_autoselect_window)
4330 {
4331 Lisp_Object window;
4332 int x = LOWORD (msg.msg.lParam);
4333 int y = HIWORD (msg.msg.lParam);
4334
4335 window = window_from_coordinates (f, x, y, 0, 0, 0, 0);
4336
4337 /* Window will be selected only when it is not
4338 selected now and last mouse movement event was
4339 not in it. Minibuffer window will be selected
4340 iff it is active. */
4341 if (WINDOWP(window)
4342 && !EQ (window, last_window)
4343 && !EQ (window, selected_window))
4344 {
4345 inev.kind = SELECT_WINDOW_EVENT;
4346 inev.frame_or_window = window;
4347 }
4348
4349 last_window=window;
4350 }
4351 note_mouse_movement (f, &msg.msg);
4352 }
4353 else
4354 {
4355 /* If we move outside the frame, then we're
4356 certainly no longer on any text in the frame. */
4357 clear_mouse_face (dpyinfo);
4358 }
4359
4360 /* If the contents of the global variable help_echo_string
4361 has changed, generate a HELP_EVENT. */
4362 #if 0 /* The below is an invalid comparison when USE_LISP_UNION_TYPE.
4363 But it was originally changed to this to fix a bug, so I have
4364 not removed it completely in case the bug is still there. */
4365 if (help_echo_string != previous_help_echo_string ||
4366 (!NILP (help_echo_string) && !STRINGP (help_echo_string) && f->mouse_moved))
4367 #else /* This is what xterm.c does. */
4368 if (!NILP (help_echo_string)
4369 || !NILP (previous_help_echo_string))
4370 do_help = 1;
4371 #endif
4372 break;
4373
4374 case WM_LBUTTONDOWN:
4375 case WM_LBUTTONUP:
4376 case WM_MBUTTONDOWN:
4377 case WM_MBUTTONUP:
4378 case WM_RBUTTONDOWN:
4379 case WM_RBUTTONUP:
4380 case WM_XBUTTONDOWN:
4381 case WM_XBUTTONUP:
4382 {
4383 /* If we decide we want to generate an event to be seen
4384 by the rest of Emacs, we put it here. */
4385 int tool_bar_p = 0;
4386 int button;
4387 int up;
4388
4389 if (dpyinfo->grabbed && last_mouse_frame
4390 && FRAME_LIVE_P (last_mouse_frame))
4391 f = last_mouse_frame;
4392 else
4393 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4394
4395 if (f)
4396 {
4397 construct_mouse_click (&inev, &msg, f);
4398
4399 /* Is this in the tool-bar? */
4400 if (WINDOWP (f->tool_bar_window)
4401 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)))
4402 {
4403 Lisp_Object window;
4404 int x = XFASTINT (inev.x);
4405 int y = XFASTINT (inev.y);
4406
4407 window = window_from_coordinates (f, x, y, 0, 0, 0, 1);
4408
4409 if (EQ (window, f->tool_bar_window))
4410 {
4411 w32_handle_tool_bar_click (f, &inev);
4412 tool_bar_p = 1;
4413 }
4414 }
4415
4416 if (tool_bar_p
4417 || (dpyinfo->w32_focus_frame
4418 && f != dpyinfo->w32_focus_frame))
4419 inev.kind = NO_EVENT;
4420 }
4421
4422 parse_button (msg.msg.message, HIWORD (msg.msg.wParam),
4423 &button, &up);
4424
4425 if (up)
4426 {
4427 dpyinfo->grabbed &= ~ (1 << button);
4428 }
4429 else
4430 {
4431 dpyinfo->grabbed |= (1 << button);
4432 last_mouse_frame = f;
4433 /* Ignore any mouse motion that happened
4434 before this event; any subsequent mouse-movement
4435 Emacs events should reflect only motion after
4436 the ButtonPress. */
4437 if (f != 0)
4438 f->mouse_moved = 0;
4439
4440 if (!tool_bar_p)
4441 last_tool_bar_item = -1;
4442 }
4443 break;
4444 }
4445
4446 case WM_MOUSEWHEEL:
4447 {
4448 if (dpyinfo->grabbed && last_mouse_frame
4449 && FRAME_LIVE_P (last_mouse_frame))
4450 f = last_mouse_frame;
4451 else
4452 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4453
4454 if (f)
4455 {
4456
4457 if (!dpyinfo->w32_focus_frame
4458 || f == dpyinfo->w32_focus_frame)
4459 {
4460 /* Emit an Emacs wheel-up/down event. */
4461 construct_mouse_wheel (&inev, &msg, f);
4462 }
4463 /* Ignore any mouse motion that happened before this
4464 event; any subsequent mouse-movement Emacs events
4465 should reflect only motion after the
4466 ButtonPress. */
4467 f->mouse_moved = 0;
4468 }
4469 last_mouse_frame = f;
4470 last_tool_bar_item = -1;
4471 }
4472 break;
4473
4474 case WM_DROPFILES:
4475 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4476
4477 if (f)
4478 construct_drag_n_drop (&inev, &msg, f);
4479 break;
4480
4481 case WM_VSCROLL:
4482 {
4483 struct scroll_bar *bar =
4484 x_window_to_scroll_bar ((HWND)msg.msg.lParam);
4485
4486 if (bar)
4487 w32_scroll_bar_handle_click (bar, &msg, &inev);
4488 break;
4489 }
4490
4491 case WM_WINDOWPOSCHANGED:
4492 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4493 if (f)
4494 {
4495 if (f->want_fullscreen & FULLSCREEN_WAIT)
4496 f->want_fullscreen &= ~(FULLSCREEN_WAIT|FULLSCREEN_BOTH);
4497 }
4498 check_visibility = 1;
4499 break;
4500
4501 case WM_ACTIVATE:
4502 case WM_ACTIVATEAPP:
4503 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4504 if (f)
4505 x_check_fullscreen (f);
4506 check_visibility = 1;
4507 break;
4508
4509 case WM_MOVE:
4510 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4511
4512 if (f && !f->async_iconified)
4513 {
4514 int x, y;
4515
4516 x_real_positions (f, &x, &y);
4517 f->left_pos = x;
4518 f->top_pos = y;
4519 }
4520
4521 check_visibility = 1;
4522 break;
4523
4524 case WM_SHOWWINDOW:
4525 /* wParam non-zero means Window is about to be shown, 0 means
4526 about to be hidden. */
4527 /* Redo the mouse-highlight after the tooltip has gone. */
4528 if (!msg.msg.wParam && msg.msg.hwnd == tip_window)
4529 {
4530 tip_window = NULL;
4531 redo_mouse_highlight ();
4532 }
4533
4534 /* If window has been obscured or exposed by another window
4535 being maximised or minimised/restored, then recheck
4536 visibility of all frames. Direct changes to our own
4537 windows get handled by WM_SIZE. */
4538 #if 0
4539 if (msg.msg.lParam != 0)
4540 check_visibility = 1;
4541 else
4542 {
4543 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4544 f->async_visible = msg.msg.wParam;
4545 }
4546 #endif
4547
4548 check_visibility = 1;
4549 break;
4550
4551 case WM_SIZE:
4552 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4553
4554 /* Inform lisp of whether frame has been iconified etc. */
4555 if (f)
4556 {
4557 switch (msg.msg.wParam)
4558 {
4559 case SIZE_MINIMIZED:
4560 f->async_visible = 0;
4561 f->async_iconified = 1;
4562
4563 inev.kind = ICONIFY_EVENT;
4564 XSETFRAME (inev.frame_or_window, f);
4565 break;
4566
4567 case SIZE_MAXIMIZED:
4568 case SIZE_RESTORED:
4569 f->async_visible = 1;
4570 f->async_iconified = 0;
4571
4572 /* wait_reading_process_output will notice this and update
4573 the frame's display structures. */
4574 SET_FRAME_GARBAGED (f);
4575
4576 if (f->iconified)
4577 {
4578 int x, y;
4579
4580 /* Reset top and left positions of the Window
4581 here since Windows sends a WM_MOVE message
4582 BEFORE telling us the Window is minimized
4583 when the Window is iconified, with 3000,3000
4584 as the co-ords. */
4585 x_real_positions (f, &x, &y);
4586 f->left_pos = x;
4587 f->top_pos = y;
4588
4589 inev.kind = DEICONIFY_EVENT;
4590 XSETFRAME (inev.frame_or_window, f);
4591 }
4592 else if (! NILP (Vframe_list)
4593 && ! NILP (XCDR (Vframe_list)))
4594 /* Force a redisplay sooner or later
4595 to update the frame titles
4596 in case this is the second frame. */
4597 record_asynch_buffer_change ();
4598 break;
4599 }
4600 }
4601
4602 if (f && !f->async_iconified && msg.msg.wParam != SIZE_MINIMIZED)
4603 {
4604 RECT rect;
4605 int rows;
4606 int columns;
4607 int width;
4608 int height;
4609
4610 GetClientRect (msg.msg.hwnd, &rect);
4611
4612 height = rect.bottom - rect.top;
4613 width = rect.right - rect.left;
4614
4615 rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, height);
4616 columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, width);
4617
4618 /* TODO: Clip size to the screen dimensions. */
4619
4620 /* Even if the number of character rows and columns has
4621 not changed, the font size may have changed, so we need
4622 to check the pixel dimensions as well. */
4623
4624 if (columns != FRAME_COLS (f)
4625 || rows != FRAME_LINES (f)
4626 || width != FRAME_PIXEL_WIDTH (f)
4627 || height != FRAME_PIXEL_HEIGHT (f))
4628 {
4629 change_frame_size (f, rows, columns, 0, 1, 0);
4630 SET_FRAME_GARBAGED (f);
4631 cancel_mouse_face (f);
4632 FRAME_PIXEL_WIDTH (f) = width;
4633 FRAME_PIXEL_HEIGHT (f) = height;
4634 f->win_gravity = NorthWestGravity;
4635 }
4636 }
4637
4638 check_visibility = 1;
4639 break;
4640
4641 case WM_MOUSELEAVE:
4642 f = x_any_window_to_frame (dpyinfo, msg.msg.hwnd);
4643 if (f)
4644 {
4645 if (f == dpyinfo->mouse_face_mouse_frame)
4646 {
4647 /* If we move outside the frame, then we're
4648 certainly no longer on any text in the frame. */
4649 clear_mouse_face (dpyinfo);
4650 dpyinfo->mouse_face_mouse_frame = 0;
4651 }
4652
4653 /* Generate a nil HELP_EVENT to cancel a help-echo.
4654 Do it only if there's something to cancel.
4655 Otherwise, the startup message is cleared when
4656 the mouse leaves the frame. */
4657 if (any_help_event_p)
4658 do_help = -1;
4659 }
4660 break;
4661
4662 case WM_SETFOCUS:
4663 /* TODO: Port this change:
4664 2002-06-28 Jan D. <jan.h.d@swipnet.se>
4665 * xterm.h (struct x_output): Add focus_state.
4666 * xterm.c (x_focus_changed): New function.
4667 (x_detect_focus_change): New function.
4668 (XTread_socket): Call x_detect_focus_change for FocusIn/FocusOut
4669 EnterNotify and LeaveNotify to track X focus changes.
4670 */
4671 f = x_any_window_to_frame (dpyinfo, msg.msg.hwnd);
4672
4673 dpyinfo->w32_focus_event_frame = f;
4674
4675 if (f)
4676 x_new_focus_frame (dpyinfo, f);
4677
4678 dpyinfo->grabbed = 0;
4679 check_visibility = 1;
4680 break;
4681
4682 case WM_KILLFOCUS:
4683 /* TODO: some of this belongs in MOUSE_LEAVE */
4684 f = x_top_window_to_frame (dpyinfo, msg.msg.hwnd);
4685
4686 if (f)
4687 {
4688 if (f == dpyinfo->w32_focus_event_frame)
4689 dpyinfo->w32_focus_event_frame = 0;
4690
4691 if (f == dpyinfo->w32_focus_frame)
4692 x_new_focus_frame (dpyinfo, 0);
4693
4694 if (f == dpyinfo->mouse_face_mouse_frame)
4695 {
4696 /* If we move outside the frame, then we're
4697 certainly no longer on any text in the frame. */
4698 clear_mouse_face (dpyinfo);
4699 dpyinfo->mouse_face_mouse_frame = 0;
4700 }
4701
4702 /* Generate a nil HELP_EVENT to cancel a help-echo.
4703 Do it only if there's something to cancel.
4704 Otherwise, the startup message is cleared when
4705 the mouse leaves the frame. */
4706 if (any_help_event_p)
4707 do_help = -1;
4708 }
4709
4710 dpyinfo->grabbed = 0;
4711 check_visibility = 1;
4712 break;
4713
4714 case WM_CLOSE:
4715 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4716
4717 if (f)
4718 {
4719 inev.kind = DELETE_WINDOW_EVENT;
4720 XSETFRAME (inev.frame_or_window, f);
4721 }
4722 break;
4723
4724 case WM_INITMENU:
4725 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4726
4727 if (f)
4728 {
4729 inev.kind = MENU_BAR_ACTIVATE_EVENT;
4730 XSETFRAME (inev.frame_or_window, f);
4731 }
4732 break;
4733
4734 case WM_COMMAND:
4735 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4736
4737 if (f)
4738 {
4739 extern void menubar_selection_callback
4740 (FRAME_PTR f, void * client_data);
4741 menubar_selection_callback (f, (void *)msg.msg.wParam);
4742 }
4743
4744 check_visibility = 1;
4745 break;
4746
4747 case WM_DISPLAYCHANGE:
4748 f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
4749
4750 if (f)
4751 {
4752 dpyinfo->width = (short) LOWORD (msg.msg.lParam);
4753 dpyinfo->height = (short) HIWORD (msg.msg.lParam);
4754 dpyinfo->n_cbits = msg.msg.wParam;
4755 DebPrint (("display change: %d %d\n", dpyinfo->width,
4756 dpyinfo->height));
4757 }
4758
4759 check_visibility = 1;
4760 break;
4761
4762 default:
4763 /* Check for messages registered at runtime. */
4764 if (msg.msg.message == msh_mousewheel)
4765 {
4766 /* Forward MSH_MOUSEWHEEL as WM_MOUSEWHEEL. */
4767 msg.msg.message = WM_MOUSEWHEEL;
4768 prepend_msg (&msg);
4769 }
4770 break;
4771 }
4772
4773 if (inev.kind != NO_EVENT)
4774 {
4775 kbd_buffer_store_event_hold (&inev, hold_quit);
4776 count++;
4777 }
4778
4779 if (do_help
4780 && !(hold_quit && hold_quit->kind != NO_EVENT))
4781 {
4782 Lisp_Object frame;
4783
4784 if (f)
4785 XSETFRAME (frame, f);
4786 else
4787 frame = Qnil;
4788
4789 if (do_help > 0)
4790 {
4791 if (NILP (help_echo_string))
4792 {
4793 help_echo_object = help_echo_window = Qnil;
4794 help_echo_pos = -1;
4795 }
4796
4797 any_help_event_p = 1;
4798 gen_help_event (help_echo_string, frame, help_echo_window,
4799 help_echo_object, help_echo_pos);
4800 }
4801 else
4802 {
4803 help_echo_string = Qnil;
4804 gen_help_event (Qnil, frame, Qnil, Qnil, 0);
4805 }
4806 count++;
4807 }
4808 }
4809
4810 /* If the focus was just given to an autoraising frame,
4811 raise it now. */
4812 /* ??? This ought to be able to handle more than one such frame. */
4813 if (pending_autoraise_frame)
4814 {
4815 x_raise_frame (pending_autoraise_frame);
4816 pending_autoraise_frame = 0;
4817 }
4818
4819 /* Check which frames are still visisble, if we have enqueued any user
4820 events or been notified of events that may affect visibility. We
4821 do this here because there doesn't seem to be any direct
4822 notification from Windows that the visibility of a window has
4823 changed (at least, not in all cases). */
4824 if (count > 0 || check_visibility)
4825 {
4826 Lisp_Object tail, frame;
4827
4828 FOR_EACH_FRAME (tail, frame)
4829 {
4830 FRAME_PTR f = XFRAME (frame);
4831 /* The tooltip has been drawn already. Avoid the
4832 SET_FRAME_GARBAGED below. */
4833 if (EQ (frame, tip_frame))
4834 continue;
4835
4836 /* Check "visible" frames and mark each as obscured or not.
4837 Note that async_visible is nonzero for unobscured and
4838 obscured frames, but zero for hidden and iconified frames. */
4839 if (FRAME_W32_P (f) && f->async_visible)
4840 {
4841 RECT clipbox;
4842 HDC hdc;
4843
4844 enter_crit ();
4845 /* Query clipping rectangle for the entire window area
4846 (GetWindowDC), not just the client portion (GetDC).
4847 Otherwise, the scrollbars and menubar aren't counted as
4848 part of the visible area of the frame, and we may think
4849 the frame is obscured when really a scrollbar is still
4850 visible and gets WM_PAINT messages above. */
4851 hdc = GetWindowDC (FRAME_W32_WINDOW (f));
4852 GetClipBox (hdc, &clipbox);
4853 ReleaseDC (FRAME_W32_WINDOW (f), hdc);
4854 leave_crit ();
4855
4856 if (clipbox.right == clipbox.left
4857 || clipbox.bottom == clipbox.top)
4858 {
4859 /* Frame has become completely obscured so mark as
4860 such (we do this by setting async_visible to 2 so
4861 that FRAME_VISIBLE_P is still true, but redisplay
4862 will skip it). */
4863 f->async_visible = 2;
4864
4865 if (!FRAME_OBSCURED_P (f))
4866 {
4867 DebPrint (("frame %p (%s) obscured\n", f,
4868 SDATA (f->name)));
4869 }
4870 }
4871 else
4872 {
4873 /* Frame is not obscured, so mark it as such. */
4874 f->async_visible = 1;
4875
4876 if (FRAME_OBSCURED_P (f))
4877 {
4878 SET_FRAME_GARBAGED (f);
4879 DebPrint (("obscured frame %p (%s) found to be visible\n", f,
4880 SDATA (f->name)));
4881
4882 /* Force a redisplay sooner or later. */
4883 record_asynch_buffer_change ();
4884 }
4885 }
4886 }
4887 }
4888 }
4889
4890 UNBLOCK_INPUT;
4891 return count;
4892 }
4893
4894
4895 \f
4896 /***********************************************************************
4897 Text Cursor
4898 ***********************************************************************/
4899
4900 /* Set clipping for output in glyph row ROW. W is the window in which
4901 we operate. GC is the graphics context to set clipping in.
4902
4903 ROW may be a text row or, e.g., a mode line. Text rows must be
4904 clipped to the interior of the window dedicated to text display,
4905 mode lines must be clipped to the whole window. */
4906
4907 static void
4908 w32_clip_to_row (w, row, area, hdc)
4909 struct window *w;
4910 struct glyph_row *row;
4911 int area;
4912 HDC hdc;
4913 {
4914 struct frame *f = XFRAME (WINDOW_FRAME (w));
4915 RECT clip_rect;
4916 int window_x, window_y, window_width;
4917
4918 window_box (w, area, &window_x, &window_y, &window_width, 0);
4919
4920 clip_rect.left = window_x;
4921 clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
4922 clip_rect.top = max (clip_rect.top, window_y);
4923 clip_rect.right = clip_rect.left + window_width;
4924 clip_rect.bottom = clip_rect.top + row->visible_height;
4925
4926 w32_set_clip_rectangle (hdc, &clip_rect);
4927 }
4928
4929
4930 /* Draw a hollow box cursor on window W in glyph row ROW. */
4931
4932 static void
4933 x_draw_hollow_cursor (w, row)
4934 struct window *w;
4935 struct glyph_row *row;
4936 {
4937 struct frame *f = XFRAME (WINDOW_FRAME (w));
4938 HDC hdc;
4939 RECT rect;
4940 int h;
4941 struct glyph *cursor_glyph;
4942 HBRUSH hb = CreateSolidBrush (f->output_data.w32->cursor_pixel);
4943
4944 /* Get the glyph the cursor is on. If we can't tell because
4945 the current matrix is invalid or such, give up. */
4946 cursor_glyph = get_phys_cursor_glyph (w);
4947 if (cursor_glyph == NULL)
4948 return;
4949
4950 /* Compute frame-relative coordinates for phys cursor. */
4951 rect.left = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
4952 rect.top = get_phys_cursor_geometry (w, row, cursor_glyph, &h);
4953 rect.bottom = rect.top + h;
4954 rect.right = rect.left + w->phys_cursor_width;
4955
4956 hdc = get_frame_dc (f);
4957 /* Set clipping, draw the rectangle, and reset clipping again. */
4958 w32_clip_to_row (w, row, TEXT_AREA, hdc);
4959 FrameRect (hdc, &rect, hb);
4960 DeleteObject (hb);
4961 w32_set_clip_rectangle (hdc, NULL);
4962 release_frame_dc (f, hdc);
4963 }
4964
4965
4966 /* Draw a bar cursor on window W in glyph row ROW.
4967
4968 Implementation note: One would like to draw a bar cursor with an
4969 angle equal to the one given by the font property XA_ITALIC_ANGLE.
4970 Unfortunately, I didn't find a font yet that has this property set.
4971 --gerd. */
4972
4973 static void
4974 x_draw_bar_cursor (w, row, width, kind)
4975 struct window *w;
4976 struct glyph_row *row;
4977 int width;
4978 enum text_cursor_kinds kind;
4979 {
4980 struct frame *f = XFRAME (w->frame);
4981 struct glyph *cursor_glyph;
4982 int x;
4983 HDC hdc;
4984
4985 /* If cursor is out of bounds, don't draw garbage. This can happen
4986 in mini-buffer windows when switching between echo area glyphs
4987 and mini-buffer. */
4988 cursor_glyph = get_phys_cursor_glyph (w);
4989 if (cursor_glyph == NULL)
4990 return;
4991
4992 /* If on an image, draw like a normal cursor. That's usually better
4993 visible than drawing a bar, esp. if the image is large so that
4994 the bar might not be in the window. */
4995 if (cursor_glyph->type == IMAGE_GLYPH)
4996 {
4997 struct glyph_row *row;
4998 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
4999 draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
5000 }
5001 else
5002 {
5003 COLORREF cursor_color = f->output_data.w32->cursor_pixel;
5004 struct face *face = FACE_FROM_ID (f, cursor_glyph->face_id);
5005
5006 /* If the glyph's background equals the color we normally draw
5007 the bar cursor in, the bar cursor in its normal color is
5008 invisible. Use the glyph's foreground color instead in this
5009 case, on the assumption that the glyph's colors are chosen so
5010 that the glyph is legible. */
5011 if (face->background == cursor_color)
5012 cursor_color = face->foreground;
5013
5014 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
5015
5016 if (width < 0)
5017 width = FRAME_CURSOR_WIDTH (f);
5018 width = min (cursor_glyph->pixel_width, width);
5019
5020 w->phys_cursor_width = width;
5021
5022
5023 hdc = get_frame_dc (f);
5024 w32_clip_to_row (w, row, TEXT_AREA, hdc);
5025
5026 if (kind == BAR_CURSOR)
5027 {
5028 w32_fill_area (f, hdc, cursor_color, x,
5029 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
5030 width, row->height);
5031 }
5032 else
5033 {
5034 w32_fill_area (f, hdc, cursor_color, x,
5035 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
5036 row->height - width),
5037 cursor_glyph->pixel_width, width);
5038 }
5039
5040 w32_set_clip_rectangle (hdc, NULL);
5041 release_frame_dc (f, hdc);
5042 }
5043 }
5044
5045
5046 /* RIF: Define cursor CURSOR on frame F. */
5047
5048 static void
5049 w32_define_frame_cursor (f, cursor)
5050 struct frame *f;
5051 Cursor cursor;
5052 {
5053 w32_define_cursor (FRAME_W32_WINDOW (f), cursor);
5054 }
5055
5056
5057 /* RIF: Clear area on frame F. */
5058
5059 static void
5060 w32_clear_frame_area (f, x, y, width, height)
5061 struct frame *f;
5062 int x, y, width, height;
5063 {
5064 HDC hdc;
5065
5066 hdc = get_frame_dc (f);
5067 w32_clear_area (f, hdc, x, y, width, height);
5068 release_frame_dc (f, hdc);
5069 }
5070
5071 /* RIF: Draw or clear cursor on window W. */
5072
5073 static void
5074 w32_draw_window_cursor (w, glyph_row, x, y, cursor_type, cursor_width, on_p, active_p)
5075 struct window *w;
5076 struct glyph_row *glyph_row;
5077 int x, y;
5078 int cursor_type, cursor_width;
5079 int on_p, active_p;
5080 {
5081 if (on_p)
5082 {
5083 /* If the user wants to use the system caret, make sure our own
5084 cursor remains invisible. */
5085 if (w32_use_visible_system_caret)
5086 {
5087 /* Call to erase_phys_cursor here seems to use the
5088 wrong values of w->phys_cursor, as they have been
5089 overwritten before this function was called. */
5090 if (w->phys_cursor_type != NO_CURSOR)
5091 erase_phys_cursor (w);
5092
5093 cursor_type = w->phys_cursor_type = NO_CURSOR;
5094 w->phys_cursor_width = -1;
5095 }
5096 else
5097 {
5098 w->phys_cursor_type = cursor_type;
5099 }
5100
5101 w->phys_cursor_on_p = 1;
5102
5103 /* If this is the active cursor, we need to track it with the
5104 system caret, so third party software like screen magnifiers
5105 and speech synthesizers can follow the cursor. */
5106 if (active_p)
5107 {
5108 struct frame *f = XFRAME (WINDOW_FRAME (w));
5109 HWND hwnd = FRAME_W32_WINDOW (f);
5110
5111 w32_system_caret_x
5112 = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
5113 w32_system_caret_y
5114 = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y)
5115 + glyph_row->ascent - w->phys_cursor_ascent);
5116
5117 /* If the size of the active cursor changed, destroy the old
5118 system caret. */
5119 if (w32_system_caret_hwnd
5120 && (w32_system_caret_height != w->phys_cursor_height))
5121 PostMessage (hwnd, WM_EMACS_DESTROY_CARET, 0, 0);
5122
5123 w32_system_caret_height = w->phys_cursor_height;
5124
5125 /* Move the system caret. */
5126 PostMessage (hwnd, WM_EMACS_TRACK_CARET, 0, 0);
5127 }
5128
5129 if (glyph_row->exact_window_width_line_p
5130 && w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])
5131 {
5132 glyph_row->cursor_in_fringe_p = 1;
5133 draw_fringe_bitmap (w, glyph_row, 0);
5134 return;
5135 }
5136
5137 switch (cursor_type)
5138 {
5139 case HOLLOW_BOX_CURSOR:
5140 x_draw_hollow_cursor (w, glyph_row);
5141 break;
5142
5143 case FILLED_BOX_CURSOR:
5144 draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
5145 break;
5146
5147 case BAR_CURSOR:
5148 x_draw_bar_cursor (w, glyph_row, cursor_width, BAR_CURSOR);
5149 break;
5150
5151 case HBAR_CURSOR:
5152 x_draw_bar_cursor (w, glyph_row, cursor_width, HBAR_CURSOR);
5153 break;
5154
5155 case NO_CURSOR:
5156 w->phys_cursor_width = 0;
5157 break;
5158
5159 default:
5160 abort ();
5161 }
5162 }
5163 }
5164
5165
5166 \f
5167 /* Icons. */
5168
5169 int
5170 x_bitmap_icon (f, icon)
5171 struct frame *f;
5172 Lisp_Object icon;
5173 {
5174 HANDLE hicon;
5175
5176 if (FRAME_W32_WINDOW (f) == 0)
5177 return 1;
5178
5179 if (NILP (icon))
5180 hicon = LoadIcon (hinst, EMACS_CLASS);
5181 else if (STRINGP (icon))
5182 hicon = LoadImage (NULL, (LPCTSTR) SDATA (icon), IMAGE_ICON, 0, 0,
5183 LR_DEFAULTSIZE | LR_LOADFROMFILE);
5184 else if (SYMBOLP (icon))
5185 {
5186 LPCTSTR name;
5187
5188 if (EQ (icon, intern ("application")))
5189 name = (LPCTSTR) IDI_APPLICATION;
5190 else if (EQ (icon, intern ("hand")))
5191 name = (LPCTSTR) IDI_HAND;
5192 else if (EQ (icon, intern ("question")))
5193 name = (LPCTSTR) IDI_QUESTION;
5194 else if (EQ (icon, intern ("exclamation")))
5195 name = (LPCTSTR) IDI_EXCLAMATION;
5196 else if (EQ (icon, intern ("asterisk")))
5197 name = (LPCTSTR) IDI_ASTERISK;
5198 else if (EQ (icon, intern ("winlogo")))
5199 name = (LPCTSTR) IDI_WINLOGO;
5200 else
5201 return 1;
5202
5203 hicon = LoadIcon (NULL, name);
5204 }
5205 else
5206 return 1;
5207
5208 if (hicon == NULL)
5209 return 1;
5210
5211 PostMessage (FRAME_W32_WINDOW (f), WM_SETICON, (WPARAM) ICON_BIG,
5212 (LPARAM) hicon);
5213
5214 return 0;
5215 }
5216
5217 \f
5218 /************************************************************************
5219 Handling X errors
5220 ************************************************************************/
5221
5222 /* Display Error Handling functions not used on W32. Listing them here
5223 helps diff stay in step when comparing w32term.c with xterm.c.
5224
5225 x_error_catcher (display, error)
5226 x_catch_errors (dpy)
5227 x_catch_errors_unwind (old_val)
5228 x_check_errors (dpy, format)
5229 x_had_errors_p (dpy)
5230 x_clear_errors (dpy)
5231 x_uncatch_errors (dpy, count)
5232 x_trace_wire ()
5233 x_connection_signal (signalnum)
5234 x_connection_closed (dpy, error_message)
5235 x_error_quitter (display, error)
5236 x_error_handler (display, error)
5237 x_io_error_quitter (display)
5238
5239 */
5240
5241 \f
5242 /* Changing the font of the frame. */
5243
5244 /* Give frame F the font named FONTNAME as its default font, and
5245 return the full name of that font. FONTNAME may be a wildcard
5246 pattern; in that case, we choose some font that fits the pattern.
5247 The return value shows which font we chose. */
5248
5249 Lisp_Object
5250 x_new_font (f, fontname)
5251 struct frame *f;
5252 register char *fontname;
5253 {
5254 struct font_info *fontp
5255 = FS_LOAD_FONT (f, 0, fontname, -1);
5256
5257 if (!fontp)
5258 return Qnil;
5259
5260 FRAME_FONT (f) = (XFontStruct *) (fontp->font);
5261 FRAME_BASELINE_OFFSET (f) = fontp->baseline_offset;
5262 FRAME_FONTSET (f) = -1;
5263
5264 FRAME_COLUMN_WIDTH (f) = fontp->average_width;
5265 FRAME_SPACE_WIDTH (f) = fontp->space_width;
5266 FRAME_LINE_HEIGHT (f) = FONT_HEIGHT (FRAME_FONT (f));
5267
5268 compute_fringe_widths (f, 1);
5269
5270 /* Compute the scroll bar width in character columns. */
5271 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
5272 {
5273 int wid = FRAME_COLUMN_WIDTH (f);
5274 FRAME_CONFIG_SCROLL_BAR_COLS (f)
5275 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid-1) / wid;
5276 }
5277 else
5278 {
5279 int wid = FRAME_COLUMN_WIDTH (f);
5280 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
5281 }
5282
5283 /* Now make the frame display the given font. */
5284 if (FRAME_W32_WINDOW (f) != 0)
5285 {
5286 if (NILP (tip_frame) || XFRAME (tip_frame) != f)
5287 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
5288 }
5289
5290 return build_string (fontp->full_name);
5291 }
5292 \f
5293 /* Give frame F the fontset named FONTSETNAME as its default font, and
5294 return the full name of that fontset. FONTSETNAME may be a wildcard
5295 pattern; in that case, we choose some fontset that fits the pattern.
5296 The return value shows which fontset we chose. */
5297
5298 Lisp_Object
5299 x_new_fontset (f, fontsetname)
5300 struct frame *f;
5301 char *fontsetname;
5302 {
5303 int fontset = fs_query_fontset (build_string (fontsetname), 0);
5304 Lisp_Object result;
5305
5306 if (fontset < 0)
5307 return Qnil;
5308
5309 if (FRAME_FONTSET (f) == fontset)
5310 /* This fontset is already set in frame F. There's nothing more
5311 to do. */
5312 return fontset_name (fontset);
5313
5314 result = x_new_font (f, (SDATA (fontset_ascii (fontset))));
5315
5316 if (!STRINGP (result))
5317 /* Can't load ASCII font. */
5318 return Qnil;
5319
5320 /* Since x_new_font doesn't update any fontset information, do it now. */
5321 FRAME_FONTSET(f) = fontset;
5322
5323 return build_string (fontsetname);
5324 }
5325
5326 \f
5327 /***********************************************************************
5328 TODO: W32 Input Methods
5329 ***********************************************************************/
5330 /* Listing missing functions from xterm.c helps diff stay in step.
5331
5332 xim_destroy_callback (xim, client_data, call_data)
5333 xim_open_dpy (dpyinfo, resource_name)
5334 struct xim_inst_t
5335 xim_instantiate_callback (display, client_data, call_data)
5336 xim_initialize (dpyinfo, resource_name)
5337 xim_close_dpy (dpyinfo)
5338
5339 */
5340
5341 \f
5342 /* Calculate the absolute position in frame F
5343 from its current recorded position values and gravity. */
5344
5345 void
5346 x_calc_absolute_position (f)
5347 struct frame *f;
5348 {
5349 int flags = f->size_hint_flags;
5350
5351 /* Treat negative positions as relative to the leftmost bottommost
5352 position that fits on the screen. */
5353 if (flags & XNegative)
5354 f->left_pos = (FRAME_W32_DISPLAY_INFO (f)->width
5355 - FRAME_PIXEL_WIDTH (f)
5356 + f->left_pos);
5357
5358 if (flags & YNegative)
5359 f->top_pos = (FRAME_W32_DISPLAY_INFO (f)->height
5360 - FRAME_PIXEL_HEIGHT (f)
5361 + f->top_pos);
5362 /* The left_pos and top_pos
5363 are now relative to the top and left screen edges,
5364 so the flags should correspond. */
5365 f->size_hint_flags &= ~ (XNegative | YNegative);
5366 }
5367
5368 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
5369 to really change the position, and 0 when calling from
5370 x_make_frame_visible (in that case, XOFF and YOFF are the current
5371 position values). It is -1 when calling from x_set_frame_parameters,
5372 which means, do adjust for borders but don't change the gravity. */
5373
5374 void
5375 x_set_offset (f, xoff, yoff, change_gravity)
5376 struct frame *f;
5377 register int xoff, yoff;
5378 int change_gravity;
5379 {
5380 int modified_top, modified_left;
5381
5382 if (change_gravity > 0)
5383 {
5384 f->top_pos = yoff;
5385 f->left_pos = xoff;
5386 f->size_hint_flags &= ~ (XNegative | YNegative);
5387 if (xoff < 0)
5388 f->size_hint_flags |= XNegative;
5389 if (yoff < 0)
5390 f->size_hint_flags |= YNegative;
5391 f->win_gravity = NorthWestGravity;
5392 }
5393 x_calc_absolute_position (f);
5394
5395 BLOCK_INPUT;
5396 x_wm_set_size_hint (f, (long) 0, 0);
5397
5398 modified_left = f->left_pos;
5399 modified_top = f->top_pos;
5400
5401 my_set_window_pos (FRAME_W32_WINDOW (f),
5402 NULL,
5403 modified_left, modified_top,
5404 0, 0,
5405 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
5406 UNBLOCK_INPUT;
5407 }
5408
5409
5410 /* Check if we need to resize the frame due to a fullscreen request.
5411 If so needed, resize the frame. */
5412 static void
5413 x_check_fullscreen (f)
5414 struct frame *f;
5415 {
5416 if (f->want_fullscreen & FULLSCREEN_BOTH)
5417 {
5418 int width, height, ign;
5419
5420 x_real_positions (f, &f->left_pos, &f->top_pos);
5421
5422 x_fullscreen_adjust (f, &width, &height, &ign, &ign);
5423
5424 /* We do not need to move the window, it shall be taken care of
5425 when setting WM manager hints. */
5426 if (FRAME_COLS (f) != width || FRAME_LINES (f) != height)
5427 {
5428 change_frame_size (f, height, width, 0, 1, 0);
5429 SET_FRAME_GARBAGED (f);
5430 cancel_mouse_face (f);
5431
5432 /* Wait for the change of frame size to occur */
5433 f->want_fullscreen |= FULLSCREEN_WAIT;
5434 }
5435 }
5436 }
5437
5438 /* Call this to change the size of frame F's x-window.
5439 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
5440 for this size change and subsequent size changes.
5441 Otherwise we leave the window gravity unchanged. */
5442
5443 void
5444 x_set_window_size (f, change_gravity, cols, rows)
5445 struct frame *f;
5446 int change_gravity;
5447 int cols, rows;
5448 {
5449 int pixelwidth, pixelheight;
5450
5451 BLOCK_INPUT;
5452
5453 check_frame_size (f, &rows, &cols);
5454 f->scroll_bar_actual_width
5455 = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
5456
5457 compute_fringe_widths (f, 0);
5458
5459 pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols);
5460 pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
5461
5462 f->win_gravity = NorthWestGravity;
5463 x_wm_set_size_hint (f, (long) 0, 0);
5464
5465 {
5466 RECT rect;
5467
5468 rect.left = rect.top = 0;
5469 rect.right = pixelwidth;
5470 rect.bottom = pixelheight;
5471
5472 AdjustWindowRect(&rect, f->output_data.w32->dwStyle,
5473 FRAME_EXTERNAL_MENU_BAR (f));
5474
5475 my_set_window_pos (FRAME_W32_WINDOW (f),
5476 NULL,
5477 0, 0,
5478 rect.right - rect.left,
5479 rect.bottom - rect.top,
5480 SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
5481 }
5482
5483 /* Now, strictly speaking, we can't be sure that this is accurate,
5484 but the window manager will get around to dealing with the size
5485 change request eventually, and we'll hear how it went when the
5486 ConfigureNotify event gets here.
5487
5488 We could just not bother storing any of this information here,
5489 and let the ConfigureNotify event set everything up, but that
5490 might be kind of confusing to the Lisp code, since size changes
5491 wouldn't be reported in the frame parameters until some random
5492 point in the future when the ConfigureNotify event arrives.
5493
5494 We pass 1 for DELAY since we can't run Lisp code inside of
5495 a BLOCK_INPUT. */
5496 change_frame_size (f, rows, cols, 0, 1, 0);
5497 FRAME_PIXEL_WIDTH (f) = pixelwidth;
5498 FRAME_PIXEL_HEIGHT (f) = pixelheight;
5499
5500 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
5501 receive in the ConfigureNotify event; if we get what we asked
5502 for, then the event won't cause the screen to become garbaged, so
5503 we have to make sure to do it here. */
5504 SET_FRAME_GARBAGED (f);
5505
5506 /* If cursor was outside the new size, mark it as off. */
5507 mark_window_cursors_off (XWINDOW (f->root_window));
5508
5509 /* Clear out any recollection of where the mouse highlighting was,
5510 since it might be in a place that's outside the new frame size.
5511 Actually checking whether it is outside is a pain in the neck,
5512 so don't try--just let the highlighting be done afresh with new size. */
5513 cancel_mouse_face (f);
5514
5515 UNBLOCK_INPUT;
5516 }
5517 \f
5518 /* Mouse warping. */
5519
5520 void x_set_mouse_pixel_position (struct frame *f, int pix_x, int pix_y);
5521
5522 void
5523 x_set_mouse_position (f, x, y)
5524 struct frame *f;
5525 int x, y;
5526 {
5527 int pix_x, pix_y;
5528
5529 pix_x = FRAME_COL_TO_PIXEL_X (f, x) + FRAME_COLUMN_WIDTH (f) / 2;
5530 pix_y = FRAME_LINE_TO_PIXEL_Y (f, y) + FRAME_LINE_HEIGHT (f) / 2;
5531
5532 if (pix_x < 0) pix_x = 0;
5533 if (pix_x > FRAME_PIXEL_WIDTH (f)) pix_x = FRAME_PIXEL_WIDTH (f);
5534
5535 if (pix_y < 0) pix_y = 0;
5536 if (pix_y > FRAME_PIXEL_HEIGHT (f)) pix_y = FRAME_PIXEL_HEIGHT (f);
5537
5538 x_set_mouse_pixel_position (f, pix_x, pix_y);
5539 }
5540
5541 void
5542 x_set_mouse_pixel_position (f, pix_x, pix_y)
5543 struct frame *f;
5544 int pix_x, pix_y;
5545 {
5546 RECT rect;
5547 POINT pt;
5548
5549 BLOCK_INPUT;
5550
5551 GetClientRect (FRAME_W32_WINDOW (f), &rect);
5552 pt.x = rect.left + pix_x;
5553 pt.y = rect.top + pix_y;
5554 ClientToScreen (FRAME_W32_WINDOW (f), &pt);
5555
5556 SetCursorPos (pt.x, pt.y);
5557
5558 UNBLOCK_INPUT;
5559 }
5560
5561 \f
5562 /* focus shifting, raising and lowering. */
5563
5564 void
5565 x_focus_on_frame (f)
5566 struct frame *f;
5567 {
5568 struct w32_display_info *dpyinfo = &one_w32_display_info;
5569
5570 /* Give input focus to frame. */
5571 BLOCK_INPUT;
5572 #if 0
5573 /* Try not to change its Z-order if possible. */
5574 if (x_window_to_frame (dpyinfo, GetForegroundWindow ()))
5575 my_set_focus (f, FRAME_W32_WINDOW (f));
5576 else
5577 #endif
5578 my_set_foreground_window (FRAME_W32_WINDOW (f));
5579 UNBLOCK_INPUT;
5580 }
5581
5582 void
5583 x_unfocus_frame (f)
5584 struct frame *f;
5585 {
5586 }
5587
5588 /* Raise frame F. */
5589 void
5590 x_raise_frame (f)
5591 struct frame *f;
5592 {
5593 BLOCK_INPUT;
5594
5595 /* Strictly speaking, raise-frame should only change the frame's Z
5596 order, leaving input focus unchanged. This is reasonable behaviour
5597 on X where the usual policy is point-to-focus. However, this
5598 behaviour would be very odd on Windows where the usual policy is
5599 click-to-focus.
5600
5601 On X, if the mouse happens to be over the raised frame, it gets
5602 input focus anyway (so the window with focus will never be
5603 completely obscured) - if not, then just moving the mouse over it
5604 is sufficient to give it focus. On Windows, the user must actually
5605 click on the frame (preferrably the title bar so as not to move
5606 point), which is more awkward. Also, no other Windows program
5607 raises a window to the top but leaves another window (possibly now
5608 completely obscured) with input focus.
5609
5610 Because there is a system setting on Windows that allows the user
5611 to choose the point to focus policy, we make the strict semantics
5612 optional, but by default we grab focus when raising. */
5613
5614 if (NILP (Vw32_grab_focus_on_raise))
5615 {
5616 /* The obvious call to my_set_window_pos doesn't work if Emacs is
5617 not already the foreground application: the frame is raised
5618 above all other frames belonging to us, but not above the
5619 current top window. To achieve that, we have to resort to this
5620 more cumbersome method. */
5621
5622 HDWP handle = BeginDeferWindowPos (2);
5623 if (handle)
5624 {
5625 DeferWindowPos (handle,
5626 FRAME_W32_WINDOW (f),
5627 HWND_TOP,
5628 0, 0, 0, 0,
5629 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
5630
5631 DeferWindowPos (handle,
5632 GetForegroundWindow (),
5633 FRAME_W32_WINDOW (f),
5634 0, 0, 0, 0,
5635 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
5636
5637 EndDeferWindowPos (handle);
5638 }
5639 }
5640 else
5641 {
5642 my_set_foreground_window (FRAME_W32_WINDOW (f));
5643 }
5644
5645 UNBLOCK_INPUT;
5646 }
5647
5648 /* Lower frame F. */
5649 void
5650 x_lower_frame (f)
5651 struct frame *f;
5652 {
5653 BLOCK_INPUT;
5654 my_set_window_pos (FRAME_W32_WINDOW (f),
5655 HWND_BOTTOM,
5656 0, 0, 0, 0,
5657 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
5658 UNBLOCK_INPUT;
5659 }
5660
5661 static void
5662 w32_frame_raise_lower (f, raise_flag)
5663 FRAME_PTR f;
5664 int raise_flag;
5665 {
5666 if (! FRAME_W32_P (f))
5667 return;
5668
5669 if (raise_flag)
5670 x_raise_frame (f);
5671 else
5672 x_lower_frame (f);
5673 }
5674 \f
5675 /* Change of visibility. */
5676
5677 /* This tries to wait until the frame is really visible.
5678 However, if the window manager asks the user where to position
5679 the frame, this will return before the user finishes doing that.
5680 The frame will not actually be visible at that time,
5681 but it will become visible later when the window manager
5682 finishes with it. */
5683
5684 void
5685 x_make_frame_visible (f)
5686 struct frame *f;
5687 {
5688 Lisp_Object type;
5689
5690 BLOCK_INPUT;
5691
5692 type = x_icon_type (f);
5693 if (!NILP (type))
5694 x_bitmap_icon (f, type);
5695
5696 if (! FRAME_VISIBLE_P (f))
5697 {
5698 /* We test FRAME_GARBAGED_P here to make sure we don't
5699 call x_set_offset a second time
5700 if we get to x_make_frame_visible a second time
5701 before the window gets really visible. */
5702 if (! FRAME_ICONIFIED_P (f)
5703 && ! f->output_data.w32->asked_for_visible)
5704 x_set_offset (f, f->left_pos, f->top_pos, 0);
5705
5706 f->output_data.w32->asked_for_visible = 1;
5707
5708 /* my_show_window (f, FRAME_W32_WINDOW (f), f->async_iconified ? SW_RESTORE : SW_SHOW); */
5709 my_show_window (f, FRAME_W32_WINDOW (f), SW_SHOWNORMAL);
5710 }
5711
5712 /* Synchronize to ensure Emacs knows the frame is visible
5713 before we do anything else. We do this loop with input not blocked
5714 so that incoming events are handled. */
5715 {
5716 Lisp_Object frame;
5717 int count;
5718
5719 /* This must come after we set COUNT. */
5720 UNBLOCK_INPUT;
5721
5722 XSETFRAME (frame, f);
5723
5724 /* Wait until the frame is visible. Process X events until a
5725 MapNotify event has been seen, or until we think we won't get a
5726 MapNotify at all.. */
5727 for (count = input_signal_count + 10;
5728 input_signal_count < count && !FRAME_VISIBLE_P (f);)
5729 {
5730 /* Force processing of queued events. */
5731 /* TODO: x_sync equivalent? */
5732
5733 /* Machines that do polling rather than SIGIO have been observed
5734 to go into a busy-wait here. So we'll fake an alarm signal
5735 to let the handler know that there's something to be read.
5736 We used to raise a real alarm, but it seems that the handler
5737 isn't always enabled here. This is probably a bug. */
5738 if (input_polling_used ())
5739 {
5740 /* It could be confusing if a real alarm arrives while processing
5741 the fake one. Turn it off and let the handler reset it. */
5742 int old_poll_suppress_count = poll_suppress_count;
5743 poll_suppress_count = 1;
5744 poll_for_input_1 ();
5745 poll_suppress_count = old_poll_suppress_count;
5746 }
5747 }
5748 FRAME_SAMPLE_VISIBILITY (f);
5749 }
5750 }
5751
5752 /* Change from mapped state to withdrawn state. */
5753
5754 /* Make the frame visible (mapped and not iconified). */
5755
5756 x_make_frame_invisible (f)
5757 struct frame *f;
5758 {
5759 /* Don't keep the highlight on an invisible frame. */
5760 if (FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame == f)
5761 FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame = 0;
5762
5763 BLOCK_INPUT;
5764
5765 my_show_window (f, FRAME_W32_WINDOW (f), SW_HIDE);
5766
5767 /* We can't distinguish this from iconification
5768 just by the event that we get from the server.
5769 So we can't win using the usual strategy of letting
5770 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
5771 and synchronize with the server to make sure we agree. */
5772 f->visible = 0;
5773 FRAME_ICONIFIED_P (f) = 0;
5774 f->async_visible = 0;
5775 f->async_iconified = 0;
5776
5777 UNBLOCK_INPUT;
5778 }
5779
5780 /* Change window state from mapped to iconified. */
5781
5782 void
5783 x_iconify_frame (f)
5784 struct frame *f;
5785 {
5786 Lisp_Object type;
5787
5788 /* Don't keep the highlight on an invisible frame. */
5789 if (FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame == f)
5790 FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame = 0;
5791
5792 if (f->async_iconified)
5793 return;
5794
5795 BLOCK_INPUT;
5796
5797 type = x_icon_type (f);
5798 if (!NILP (type))
5799 x_bitmap_icon (f, type);
5800
5801 /* Simulate the user minimizing the frame. */
5802 SendMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, SC_MINIMIZE, 0);
5803
5804 UNBLOCK_INPUT;
5805 }
5806
5807 \f
5808 /* Free X resources of frame F. */
5809
5810 void
5811 x_free_frame_resources (f)
5812 struct frame *f;
5813 {
5814 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
5815
5816 BLOCK_INPUT;
5817
5818 if (FRAME_W32_WINDOW (f))
5819 my_destroy_window (f, FRAME_W32_WINDOW (f));
5820
5821 free_frame_menubar (f);
5822
5823 unload_color (f, f->output_data.x->foreground_pixel);
5824 unload_color (f, f->output_data.x->background_pixel);
5825 unload_color (f, f->output_data.w32->cursor_pixel);
5826 unload_color (f, f->output_data.w32->cursor_foreground_pixel);
5827 unload_color (f, f->output_data.w32->border_pixel);
5828 unload_color (f, f->output_data.w32->mouse_pixel);
5829 if (f->output_data.w32->white_relief.allocated_p)
5830 unload_color (f, f->output_data.w32->white_relief.pixel);
5831 if (f->output_data.w32->black_relief.allocated_p)
5832 unload_color (f, f->output_data.w32->black_relief.pixel);
5833
5834 if (FRAME_FACE_CACHE (f))
5835 free_frame_faces (f);
5836
5837 xfree (f->output_data.w32);
5838 f->output_data.w32 = NULL;
5839
5840 if (f == dpyinfo->w32_focus_frame)
5841 dpyinfo->w32_focus_frame = 0;
5842 if (f == dpyinfo->w32_focus_event_frame)
5843 dpyinfo->w32_focus_event_frame = 0;
5844 if (f == dpyinfo->x_highlight_frame)
5845 dpyinfo->x_highlight_frame = 0;
5846
5847 if (f == dpyinfo->mouse_face_mouse_frame)
5848 {
5849 dpyinfo->mouse_face_beg_row
5850 = dpyinfo->mouse_face_beg_col = -1;
5851 dpyinfo->mouse_face_end_row
5852 = dpyinfo->mouse_face_end_col = -1;
5853 dpyinfo->mouse_face_window = Qnil;
5854 dpyinfo->mouse_face_deferred_gc = 0;
5855 dpyinfo->mouse_face_mouse_frame = 0;
5856 }
5857
5858 UNBLOCK_INPUT;
5859 }
5860
5861
5862 /* Destroy the window of frame F. */
5863
5864 x_destroy_window (f)
5865 struct frame *f;
5866 {
5867 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
5868
5869 x_free_frame_resources (f);
5870
5871 dpyinfo->reference_count--;
5872 }
5873
5874 \f
5875 /* Setting window manager hints. */
5876
5877 /* Set the normal size hints for the window manager, for frame F.
5878 FLAGS is the flags word to use--or 0 meaning preserve the flags
5879 that the window now has.
5880 If USER_POSITION is nonzero, we set the USPosition
5881 flag (this is useful when FLAGS is 0). */
5882 void
5883 x_wm_set_size_hint (f, flags, user_position)
5884 struct frame *f;
5885 long flags;
5886 int user_position;
5887 {
5888 Window window = FRAME_W32_WINDOW (f);
5889
5890 enter_crit ();
5891
5892 SetWindowLong (window, WND_FONTWIDTH_INDEX, FRAME_COLUMN_WIDTH (f));
5893 SetWindowLong (window, WND_LINEHEIGHT_INDEX, FRAME_LINE_HEIGHT (f));
5894 SetWindowLong (window, WND_BORDER_INDEX, FRAME_INTERNAL_BORDER_WIDTH (f));
5895 SetWindowLong (window, WND_SCROLLBAR_INDEX, f->scroll_bar_actual_width);
5896
5897 leave_crit ();
5898 }
5899
5900 /* Window manager things */
5901 void
5902 x_wm_set_icon_position (f, icon_x, icon_y)
5903 struct frame *f;
5904 int icon_x, icon_y;
5905 {
5906 #if 0
5907 Window window = FRAME_W32_WINDOW (f);
5908
5909 f->display.x->wm_hints.flags |= IconPositionHint;
5910 f->display.x->wm_hints.icon_x = icon_x;
5911 f->display.x->wm_hints.icon_y = icon_y;
5912
5913 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->display.x->wm_hints);
5914 #endif
5915 }
5916
5917 \f
5918 /***********************************************************************
5919 Fonts
5920 ***********************************************************************/
5921
5922 /* The following functions are listed here to help diff stay in step
5923 with xterm.c. See w32fns.c for definitions.
5924
5925 x_get_font_info (f, font_idx)
5926 x_list_fonts (f, pattern, size, maxnames)
5927
5928 */
5929
5930 #if GLYPH_DEBUG
5931
5932 /* Check that FONT is valid on frame F. It is if it can be found in F's
5933 font table. */
5934
5935 static void
5936 x_check_font (f, font)
5937 struct frame *f;
5938 XFontStruct *font;
5939 {
5940 int i;
5941 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
5942
5943 xassert (font != NULL);
5944
5945 for (i = 0; i < dpyinfo->n_fonts; i++)
5946 if (dpyinfo->font_table[i].name
5947 && font == dpyinfo->font_table[i].font)
5948 break;
5949
5950 xassert (i < dpyinfo->n_fonts);
5951 }
5952
5953 #endif /* GLYPH_DEBUG != 0 */
5954
5955 /* Set *W to the minimum width, *H to the minimum font height of FONT.
5956 Note: There are (broken) X fonts out there with invalid XFontStruct
5957 min_bounds contents. For example, handa@etl.go.jp reports that
5958 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
5959 have font->min_bounds.width == 0. */
5960
5961 static INLINE void
5962 x_font_min_bounds (font, w, h)
5963 XFontStruct *font;
5964 int *w, *h;
5965 {
5966 /*
5967 * TODO: Windows does not appear to offer min bound, only
5968 * average and maximum width, and maximum height.
5969 */
5970 *h = FONT_HEIGHT (font);
5971 *w = FONT_WIDTH (font);
5972 }
5973
5974
5975 /* Compute the smallest character width and smallest font height over
5976 all fonts available on frame F. Set the members smallest_char_width
5977 and smallest_font_height in F's x_display_info structure to
5978 the values computed. Value is non-zero if smallest_font_height or
5979 smallest_char_width become smaller than they were before. */
5980
5981 int
5982 x_compute_min_glyph_bounds (f)
5983 struct frame *f;
5984 {
5985 int i;
5986 struct w32_display_info *dpyinfo = FRAME_W32_DISPLAY_INFO (f);
5987 XFontStruct *font;
5988 int old_width = dpyinfo->smallest_char_width;
5989 int old_height = dpyinfo->smallest_font_height;
5990
5991 dpyinfo->smallest_font_height = 100000;
5992 dpyinfo->smallest_char_width = 100000;
5993
5994 for (i = 0; i < dpyinfo->n_fonts; ++i)
5995 if (dpyinfo->font_table[i].name)
5996 {
5997 struct font_info *fontp = dpyinfo->font_table + i;
5998 int w, h;
5999
6000 font = (XFontStruct *) fontp->font;
6001 xassert (font != (XFontStruct *) ~0);
6002 x_font_min_bounds (font, &w, &h);
6003
6004 dpyinfo->smallest_font_height = min (dpyinfo->smallest_font_height, h);
6005 dpyinfo->smallest_char_width = min (dpyinfo->smallest_char_width, w);
6006 }
6007
6008 xassert (dpyinfo->smallest_char_width > 0
6009 && dpyinfo->smallest_font_height > 0);
6010
6011 return (dpyinfo->n_fonts == 1
6012 || dpyinfo->smallest_char_width < old_width
6013 || dpyinfo->smallest_font_height < old_height);
6014 }
6015
6016 /* The following functions are listed here to help diff stay in step
6017 with xterm.c. See w32fns.c for definitions.
6018
6019 x_load_font (f, fontname, size)
6020 x_query_font (f, fontname)
6021 x_find_ccl_program (fontp)
6022
6023 */
6024 \f
6025 /***********************************************************************
6026 Initialization
6027 ***********************************************************************/
6028
6029 static int w32_initialized = 0;
6030
6031 void
6032 w32_initialize_display_info (display_name)
6033 Lisp_Object display_name;
6034 {
6035 struct w32_display_info *dpyinfo = &one_w32_display_info;
6036
6037 bzero (dpyinfo, sizeof (*dpyinfo));
6038
6039 /* Put it on w32_display_name_list. */
6040 w32_display_name_list = Fcons (Fcons (display_name, Qnil),
6041 w32_display_name_list);
6042 dpyinfo->name_list_element = XCAR (w32_display_name_list);
6043
6044 dpyinfo->w32_id_name
6045 = (char *) xmalloc (SCHARS (Vinvocation_name)
6046 + SCHARS (Vsystem_name)
6047 + 2);
6048 sprintf (dpyinfo->w32_id_name, "%s@%s",
6049 SDATA (Vinvocation_name), SDATA (Vsystem_name));
6050
6051 /* Default Console mode values - overridden when running in GUI mode
6052 with values obtained from system metrics. */
6053 dpyinfo->resx = 1;
6054 dpyinfo->resy = 1;
6055 dpyinfo->height_in = 1;
6056 dpyinfo->width_in = 1;
6057 dpyinfo->n_planes = 1;
6058 dpyinfo->n_cbits = 4;
6059 dpyinfo->n_fonts = 0;
6060 dpyinfo->smallest_font_height = 1;
6061 dpyinfo->smallest_char_width = 1;
6062
6063 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
6064 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
6065 dpyinfo->mouse_face_face_id = DEFAULT_FACE_ID;
6066 dpyinfo->mouse_face_window = Qnil;
6067 dpyinfo->mouse_face_overlay = Qnil;
6068 dpyinfo->mouse_face_hidden = 0;
6069
6070 dpyinfo->vertical_scroll_bar_cursor = w32_load_cursor (IDC_ARROW);
6071 /* TODO: dpyinfo->gray */
6072
6073 }
6074
6075 /* Create an xrdb-style database of resources to supercede registry settings.
6076 The database is just a concatenation of C strings, finished by an additional
6077 \0. The string are submitted to some basic normalization, so
6078
6079 [ *]option[ *]:[ *]value...
6080
6081 becomes
6082
6083 option:value...
6084
6085 but any whitespace following value is not removed. */
6086
6087 static char *
6088 w32_make_rdb (xrm_option)
6089 char *xrm_option;
6090 {
6091 char *buffer = xmalloc (strlen (xrm_option) + 2);
6092 char *current = buffer;
6093 char ch;
6094 int in_option = 1;
6095 int before_value = 0;
6096
6097 do {
6098 ch = *xrm_option++;
6099
6100 if (ch == '\n')
6101 {
6102 *current++ = '\0';
6103 in_option = 1;
6104 before_value = 0;
6105 }
6106 else if (ch != ' ')
6107 {
6108 *current++ = ch;
6109 if (in_option && (ch == ':'))
6110 {
6111 in_option = 0;
6112 before_value = 1;
6113 }
6114 else if (before_value)
6115 {
6116 before_value = 0;
6117 }
6118 }
6119 else if (!(in_option || before_value))
6120 {
6121 *current++ = ch;
6122 }
6123 } while (ch);
6124
6125 *current = '\0';
6126
6127 return buffer;
6128 }
6129
6130 struct w32_display_info *
6131 w32_term_init (display_name, xrm_option, resource_name)
6132 Lisp_Object display_name;
6133 char *xrm_option;
6134 char *resource_name;
6135 {
6136 struct w32_display_info *dpyinfo;
6137 HDC hdc;
6138
6139 BLOCK_INPUT;
6140
6141 if (!w32_initialized)
6142 {
6143 w32_initialize ();
6144 w32_initialized = 1;
6145 }
6146
6147 w32_initialize_display_info (display_name);
6148
6149 dpyinfo = &one_w32_display_info;
6150
6151 dpyinfo->xrdb = xrm_option ? w32_make_rdb (xrm_option) : NULL;
6152
6153 /* Put this display on the chain. */
6154 dpyinfo->next = x_display_list;
6155 x_display_list = dpyinfo;
6156
6157 hdc = GetDC (GetDesktopWindow ());
6158
6159 dpyinfo->height = GetDeviceCaps (hdc, VERTRES);
6160 dpyinfo->width = GetDeviceCaps (hdc, HORZRES);
6161 dpyinfo->root_window = GetDesktopWindow ();
6162 dpyinfo->n_planes = GetDeviceCaps (hdc, PLANES);
6163 dpyinfo->n_cbits = GetDeviceCaps (hdc, BITSPIXEL);
6164 dpyinfo->resx = GetDeviceCaps (hdc, LOGPIXELSX);
6165 dpyinfo->resy = GetDeviceCaps (hdc, LOGPIXELSY);
6166 dpyinfo->has_palette = GetDeviceCaps (hdc, RASTERCAPS) & RC_PALETTE;
6167 dpyinfo->image_cache = make_image_cache ();
6168 dpyinfo->height_in = dpyinfo->height / dpyinfo->resx;
6169 dpyinfo->width_in = dpyinfo->width / dpyinfo->resy;
6170 ReleaseDC (GetDesktopWindow (), hdc);
6171
6172 /* initialise palette with white and black */
6173 {
6174 XColor color;
6175 w32_defined_color (0, "white", &color, 1);
6176 w32_defined_color (0, "black", &color, 1);
6177 }
6178
6179 /* Create Fringe Bitmaps and store them for later use.
6180
6181 On W32, bitmaps are all unsigned short, as Windows requires
6182 bitmap data to be Word aligned. For some reason they are
6183 horizontally reflected compared to how they appear on X, so we
6184 need to bitswap and convert to unsigned shorts before creating
6185 the bitmaps. */
6186 w32_init_fringe ();
6187
6188 #ifndef F_SETOWN_BUG
6189 #ifdef F_SETOWN
6190 #ifdef F_SETOWN_SOCK_NEG
6191 /* stdin is a socket here */
6192 fcntl (connection, F_SETOWN, -getpid ());
6193 #else /* ! defined (F_SETOWN_SOCK_NEG) */
6194 fcntl (connection, F_SETOWN, getpid ());
6195 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
6196 #endif /* ! defined (F_SETOWN) */
6197 #endif /* F_SETOWN_BUG */
6198
6199 #ifdef SIGIO
6200 if (interrupt_input)
6201 init_sigio (connection);
6202 #endif /* ! defined (SIGIO) */
6203
6204 UNBLOCK_INPUT;
6205
6206 return dpyinfo;
6207 }
6208 \f
6209 /* Get rid of display DPYINFO, assuming all frames are already gone. */
6210
6211 void
6212 x_delete_display (dpyinfo)
6213 struct w32_display_info *dpyinfo;
6214 {
6215 /* Discard this display from w32_display_name_list and w32_display_list.
6216 We can't use Fdelq because that can quit. */
6217 if (! NILP (w32_display_name_list)
6218 && EQ (XCAR (w32_display_name_list), dpyinfo->name_list_element))
6219 w32_display_name_list = XCDR (w32_display_name_list);
6220 else
6221 {
6222 Lisp_Object tail;
6223
6224 tail = w32_display_name_list;
6225 while (CONSP (tail) && CONSP (XCDR (tail)))
6226 {
6227 if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
6228 {
6229 XSETCDR (tail, XCDR (XCDR (tail)));
6230 break;
6231 }
6232 tail = XCDR (tail);
6233 }
6234 }
6235
6236 /* free palette table */
6237 {
6238 struct w32_palette_entry * plist;
6239
6240 plist = dpyinfo->color_list;
6241 while (plist)
6242 {
6243 struct w32_palette_entry * pentry = plist;
6244 plist = plist->next;
6245 xfree (pentry);
6246 }
6247 dpyinfo->color_list = NULL;
6248 if (dpyinfo->palette)
6249 DeleteObject(dpyinfo->palette);
6250 }
6251 xfree (dpyinfo->font_table);
6252 xfree (dpyinfo->w32_id_name);
6253
6254 w32_reset_fringes ();
6255 }
6256 \f
6257 /* Set up use of W32. */
6258
6259 DWORD w32_msg_worker ();
6260
6261 void
6262 x_flush (struct frame * f)
6263 { /* Nothing to do */ }
6264
6265 extern frame_parm_handler w32_frame_parm_handlers[];
6266
6267 static struct redisplay_interface w32_redisplay_interface =
6268 {
6269 w32_frame_parm_handlers,
6270 x_produce_glyphs,
6271 x_write_glyphs,
6272 x_insert_glyphs,
6273 x_clear_end_of_line,
6274 x_scroll_run,
6275 x_after_update_window_line,
6276 x_update_window_begin,
6277 x_update_window_end,
6278 x_cursor_to,
6279 x_flush,
6280 0, /* flush_display_optional */
6281 x_clear_window_mouse_face,
6282 w32_get_glyph_overhangs,
6283 x_fix_overlapping_area,
6284 w32_draw_fringe_bitmap,
6285 w32_define_fringe_bitmap,
6286 w32_destroy_fringe_bitmap,
6287 w32_per_char_metric,
6288 w32_encode_char,
6289 NULL, /* w32_compute_glyph_string_overhangs */
6290 x_draw_glyph_string,
6291 w32_define_frame_cursor,
6292 w32_clear_frame_area,
6293 w32_draw_window_cursor,
6294 w32_draw_vertical_window_border,
6295 w32_shift_glyphs_for_insert
6296 };
6297
6298 void
6299 w32_initialize ()
6300 {
6301 rif = &w32_redisplay_interface;
6302
6303 /* MSVC does not type K&R functions with no arguments correctly, and
6304 so we must explicitly cast them. */
6305 clear_frame_hook = (void (*)(void)) x_clear_frame;
6306 ring_bell_hook = (void (*)(void)) w32_ring_bell;
6307 update_begin_hook = x_update_begin;
6308 update_end_hook = x_update_end;
6309
6310 read_socket_hook = w32_read_socket;
6311
6312 frame_up_to_date_hook = w32_frame_up_to_date;
6313
6314 mouse_position_hook = w32_mouse_position;
6315 frame_rehighlight_hook = w32_frame_rehighlight;
6316 frame_raise_lower_hook = w32_frame_raise_lower;
6317 set_vertical_scroll_bar_hook = w32_set_vertical_scroll_bar;
6318 condemn_scroll_bars_hook = w32_condemn_scroll_bars;
6319 redeem_scroll_bar_hook = w32_redeem_scroll_bar;
6320 judge_scroll_bars_hook = w32_judge_scroll_bars;
6321
6322 scroll_region_ok = 1; /* we'll scroll partial frames */
6323 char_ins_del_ok = 1;
6324 line_ins_del_ok = 1; /* we'll just blt 'em */
6325 fast_clear_end_of_line = 1; /* X does this well */
6326 memory_below_frame = 0; /* we don't remember what scrolls
6327 off the bottom */
6328 baud_rate = 19200;
6329
6330 w32_system_caret_hwnd = NULL;
6331 w32_system_caret_height = 0;
6332 w32_system_caret_x = 0;
6333 w32_system_caret_y = 0;
6334
6335 last_tool_bar_item = -1;
6336 any_help_event_p = 0;
6337
6338 /* Initialize input mode: interrupt_input off, no flow control, allow
6339 8 bit character input, standard quit char. */
6340 Fset_input_mode (Qnil, Qnil, make_number (2), Qnil);
6341
6342 /* Create the window thread - it will terminate itself or when the app terminates */
6343
6344 init_crit ();
6345
6346 dwMainThreadId = GetCurrentThreadId ();
6347 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
6348 GetCurrentProcess (), &hMainThread, 0, TRUE, DUPLICATE_SAME_ACCESS);
6349
6350 /* Wait for thread to start */
6351
6352 {
6353 MSG msg;
6354
6355 PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
6356
6357 hWindowsThread = CreateThread (NULL, 0,
6358 (LPTHREAD_START_ROUTINE) w32_msg_worker,
6359 0, 0, &dwWindowsThreadId);
6360
6361 GetMessage (&msg, NULL, WM_EMACS_DONE, WM_EMACS_DONE);
6362 }
6363
6364 /* It is desirable that mainThread should have the same notion of
6365 focus window and active window as windowsThread. Unfortunately, the
6366 following call to AttachThreadInput, which should do precisely what
6367 we need, causes major problems when Emacs is linked as a console
6368 program. Unfortunately, we have good reasons for doing that, so
6369 instead we need to send messages to windowsThread to make some API
6370 calls for us (ones that affect, or depend on, the active/focus
6371 window state. */
6372 #ifdef ATTACH_THREADS
6373 AttachThreadInput (dwMainThreadId, dwWindowsThreadId, TRUE);
6374 #endif
6375
6376 /* Dynamically link to optional system components. */
6377 {
6378 HANDLE user_lib = LoadLibrary ("user32.dll");
6379
6380 #define LOAD_PROC(fn) pfn##fn = (void *) GetProcAddress (user_lib, #fn)
6381
6382 /* New proportional scroll bar functions. */
6383 LOAD_PROC (SetScrollInfo);
6384 LOAD_PROC (GetScrollInfo);
6385
6386 #undef LOAD_PROC
6387
6388 FreeLibrary (user_lib);
6389
6390 /* If using proportional scroll bars, ensure handle is at least 5 pixels;
6391 otherwise use the fixed height. */
6392 vertical_scroll_bar_min_handle = (pfnSetScrollInfo != NULL) ? 5 :
6393 GetSystemMetrics (SM_CYVTHUMB);
6394
6395 /* For either kind of scroll bar, take account of the arrows; these
6396 effectively form the border of the main scroll bar range. */
6397 vertical_scroll_bar_top_border = vertical_scroll_bar_bottom_border
6398 = GetSystemMetrics (SM_CYVSCROLL);
6399 }
6400 }
6401
6402 void
6403 syms_of_w32term ()
6404 {
6405 staticpro (&w32_display_name_list);
6406 w32_display_name_list = Qnil;
6407
6408 staticpro (&last_mouse_scroll_bar);
6409 last_mouse_scroll_bar = Qnil;
6410
6411 staticpro (&Qvendor_specific_keysyms);
6412 Qvendor_specific_keysyms = intern ("vendor-specific-keysyms");
6413
6414 DEFVAR_INT ("w32-num-mouse-buttons",
6415 &w32_num_mouse_buttons,
6416 doc: /* Number of physical mouse buttons. */);
6417 w32_num_mouse_buttons = 2;
6418
6419 DEFVAR_LISP ("w32-swap-mouse-buttons",
6420 &Vw32_swap_mouse_buttons,
6421 doc: /* Swap the mapping of middle and right mouse buttons.
6422 When nil, middle button is mouse-2 and right button is mouse-3. */);
6423 Vw32_swap_mouse_buttons = Qnil;
6424
6425 DEFVAR_LISP ("w32-grab-focus-on-raise",
6426 &Vw32_grab_focus_on_raise,
6427 doc: /* Raised frame grabs input focus.
6428 When t, `raise-frame' grabs input focus as well. This fits well
6429 with the normal Windows click-to-focus policy, but might not be
6430 desirable when using a point-to-focus policy. */);
6431 Vw32_grab_focus_on_raise = Qt;
6432
6433 DEFVAR_LISP ("w32-capslock-is-shiftlock",
6434 &Vw32_capslock_is_shiftlock,
6435 doc: /* Apply CapsLock state to non character input keys.
6436 When nil, CapsLock only affects normal character input keys. */);
6437 Vw32_capslock_is_shiftlock = Qnil;
6438
6439 DEFVAR_LISP ("w32-recognize-altgr",
6440 &Vw32_recognize_altgr,
6441 doc: /* Recognize right-alt and left-ctrl as AltGr.
6442 When nil, the right-alt and left-ctrl key combination is
6443 interpreted normally. */);
6444 Vw32_recognize_altgr = Qt;
6445
6446 DEFVAR_BOOL ("w32-enable-unicode-output",
6447 &w32_enable_unicode_output,
6448 doc: /* Enable the use of Unicode for text output if non-nil.
6449 Unicode output may prevent some third party applications for displaying
6450 Far-East Languages on Windows 95/98 from working properly.
6451 NT uses Unicode internally anyway, so this flag will probably have no
6452 affect on NT machines. */);
6453 w32_enable_unicode_output = 1;
6454
6455 DEFVAR_BOOL ("w32-use-visible-system-caret",
6456 &w32_use_visible_system_caret,
6457 doc: /* Flag to make the system caret visible.
6458 When this is non-nil, Emacs will indicate the position of point by
6459 using the system caret instead of drawing its own cursor. Some screen
6460 reader software does not track the system cursor properly when it is
6461 invisible, and gets confused by Emacs drawing its own cursor, so this
6462 variable is initialized to t when Emacs detects that screen reader
6463 software is running as it starts up.
6464
6465 When this variable is set, other variables affecting the appearance of
6466 the cursor have no effect. */);
6467
6468 /* Initialize w32_use_visible_system_caret based on whether a screen
6469 reader is in use. */
6470 if (!SystemParametersInfo (SPI_GETSCREENREADER, 0,
6471 &w32_use_visible_system_caret, 0))
6472 w32_use_visible_system_caret = 0;
6473
6474 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
6475 doc: /* If not nil, Emacs uses toolkit scroll bars. */);
6476 Vx_toolkit_scroll_bars = Qt;
6477
6478 staticpro (&last_mouse_motion_frame);
6479 last_mouse_motion_frame = Qnil;
6480 }
6481
6482 /* arch-tag: 5fa70624-ab86-499c-8a85-473958ee4646
6483 (do not change this comment) */