1 /* Implementation of Win32 GUI terminal
2 Copyright (C) 1989, 1993, 1994, 1995 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to the
18 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Added by Kevin Gallo */
27 #include "blockinput.h"
40 #include "dispextern.h"
41 #include "termhooks.h"
49 #include "intervals.h"
51 extern void free_frame_menubar ();
53 extern Lisp_Object Vwindow_system
;
55 #define x_any_window_to_frame x_window_to_frame
56 #define x_top_window_to_frame x_window_to_frame
59 /* This is display since win32 does not support multiple ones. */
60 struct win32_display_info one_win32_display_info
;
62 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
63 one for each element of win32_display_list and in the same order.
64 NAME is the name of the frame.
65 FONT-LIST-CACHE records previous values returned by x-list-fonts. */
66 Lisp_Object win32_display_name_list
;
68 /* Frame being updated by update_frame. This is declared in term.c.
69 This is set by update_begin and looked at by all the
70 win32 functions. It is zero while not inside an update.
71 In that case, the win32 functions assume that `selected_frame'
72 is the frame to apply to. */
73 extern struct frame
*updating_frame
;
75 /* This is a frame waiting to be autoraised, within w32_read_socket. */
76 struct frame
*pending_autoraise_frame
;
78 /* During an update, maximum vpos for ins/del line operations to affect. */
82 /* During an update, nonzero if chars output now should be highlighted. */
86 /* Nominal cursor position -- where to draw output.
87 During an update, these are different from the cursor-box position. */
92 DWORD dwWinThreadId
= 0;
93 HANDLE hWinThread
= NULL
;
94 DWORD dwMainThreadId
= 0;
95 HANDLE hMainThread
= NULL
;
99 /* Where the mouse was last time we reported a mouse event. */
100 static FRAME_PTR last_mouse_frame
;
101 static RECT last_mouse_glyph
;
103 Lisp_Object Vwin32_num_mouse_buttons
;
105 Lisp_Object Vwin32_swap_mouse_buttons
;
107 /* The scroll bar in which the last motion event occurred.
109 If the last motion event occurred in a scroll bar, we set this
110 so win32_mouse_position can know whether to report a scroll bar motion or
113 If the last motion event didn't occur in a scroll bar, we set this
114 to Qnil, to tell win32_mouse_position to return an ordinary motion event. */
115 Lisp_Object last_mouse_scroll_bar
;
116 int last_mouse_scroll_bar_pos
;
118 /* This is a hack. We would really prefer that win32_mouse_position would
119 return the time associated with the position it returns, but there
120 doesn't seem to be any way to wrest the timestamp from the server
121 along with the position query. So, we just keep track of the time
122 of the last movement we received, and return that in hopes that
123 it's somewhat accurate. */
124 Time last_mouse_movement_time
;
126 /* Incremented by w32_read_socket whenever it really tries to read events. */
128 static int volatile input_signal_count
;
130 static int input_signal_count
;
133 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
135 extern Lisp_Object Qface
, Qmouse_face
;
139 /* A mask of extra modifier bits to put into every keyboard char. */
140 extern int extra_keyboard_modifiers
;
142 static Lisp_Object Qvendor_specific_keysyms
;
144 void win32_delete_display ();
146 static void redraw_previous_char ();
147 static void redraw_following_char ();
148 static unsigned int win32_get_modifiers ();
150 static int fast_find_position ();
151 static void note_mouse_highlight ();
152 static void clear_mouse_face ();
153 static void show_mouse_face ();
154 static void do_line_dance ();
156 static int win32_cursor_to ();
157 static int win32_clear_end_of_line ();
160 /* This is a function useful for recording debugging information
161 about the sequence of occurrences in this file. */
169 struct record event_record
[100];
171 int event_record_index
;
173 record_event (locus
, type
)
177 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
178 event_record_index
= 0;
180 event_record
[event_record_index
].locus
= locus
;
181 event_record
[event_record_index
].type
= type
;
182 event_record_index
++;
187 /* Return the struct win32_display_info. */
189 struct win32_display_info
*
190 win32_display_info_for_display ()
192 return (&one_win32_display_info
);
196 win32_fill_rect (f
, _hdc
, pix
, lprect
)
211 hdc
= get_frame_dc (f
);
214 hb
= CreateSolidBrush (pix
);
215 FillRect (hdc
, lprect
, hb
);
219 release_frame_dc (f
, hdc
);
223 win32_clear_window (f
)
228 GetClientRect (FRAME_WIN32_WINDOW (f
), &rect
);
229 win32_clear_rect (f
, NULL
, &rect
);
233 /* Starting and ending updates.
235 These hooks are called by update_frame at the beginning and end
236 of a frame update. We record in `updating_frame' the identity
237 of the frame being updated, so that the win32_... functions do not
238 need to take a frame as argument. Most of the win32_... functions
239 should never be called except during an update, the only exceptions
240 being win32_cursor_to, win32_write_glyphs and win32_reassert_line_highlight. */
243 win32_update_begin (f
)
249 flexlines
= f
->height
;
254 /* Regenerate display palette before drawing if list of requested
255 colors has changed. */
256 if (FRAME_WIN32_DISPLAY_INFO (f
)->regen_palette
)
258 win32_regenerate_palette (f
);
259 FRAME_WIN32_DISPLAY_INFO (f
)->regen_palette
= FALSE
;
262 if (f
== FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
264 /* Don't do highlighting for mouse motion during the update. */
265 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_defer
= 1;
267 /* If the frame needs to be redrawn,
268 simply forget about any prior mouse highlighting. */
269 if (FRAME_GARBAGED_P (f
))
270 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_window
= Qnil
;
272 if (!NILP (FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_window
))
274 int firstline
, lastline
, i
;
275 struct window
*w
= XWINDOW (FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_window
);
277 /* Find the first, and the last+1, lines affected by redisplay. */
278 for (firstline
= 0; firstline
< f
->height
; firstline
++)
279 if (FRAME_DESIRED_GLYPHS (f
)->enable
[firstline
])
282 lastline
= f
->height
;
283 for (i
= f
->height
- 1; i
>= 0; i
--)
285 if (FRAME_DESIRED_GLYPHS (f
)->enable
[i
])
291 /* Can we tell that this update does not affect the window
292 where the mouse highlight is? If so, no need to turn off.
293 Likewise, don't do anything if the frame is garbaged;
294 in that case, the FRAME_CURRENT_GLYPHS that we would use
295 are all wrong, and we will redisplay that line anyway. */
296 if (! (firstline
> (XFASTINT (w
->top
) + window_internal_height (w
))
297 || lastline
< XFASTINT (w
->top
)))
298 clear_mouse_face (FRAME_WIN32_DISPLAY_INFO (f
));
312 x_display_cursor (f
, 1);
314 if (f
== FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
315 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
320 /* This is called after a redisplay on frame F. */
323 win32_frame_up_to_date (f
)
326 if (FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_deferred_gc
327 || f
== FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
329 note_mouse_highlight (FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
,
330 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_mouse_x
,
331 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_mouse_y
);
332 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_deferred_gc
= 0;
336 /* External interface to control of standout mode.
337 Call this when about to modify line at position VPOS
338 and not change whether it is highlighted. */
340 win32_reassert_line_highlight (new, vpos
)
346 /* Call this when about to modify line at position VPOS
347 and change whether it is highlighted. */
350 win32_change_line_highlight (new_highlight
, vpos
, first_unused_hpos
)
351 int new_highlight
, vpos
, first_unused_hpos
;
353 highlight
= new_highlight
;
354 win32_cursor_to (vpos
, 0);
355 win32_clear_end_of_line (updating_frame
->width
);
358 /* This is used when starting Emacs and when restarting after suspend.
359 When starting Emacs, no window is mapped. And nothing must be done
360 to Emacs's own window if it is suspended (though that rarely happens). */
363 win32_set_terminal_modes ()
367 /* This is called when exiting or suspending Emacs.
368 Exiting will make the Win32 windows go away, and suspending
369 requires no action. */
372 win32_reset_terminal_modes ()
376 /* Set the nominal cursor position of the frame.
377 This is where display update commands will take effect.
378 This does not affect the place where the cursor-box is displayed. */
381 win32_cursor_to (row
, col
)
382 register int row
, col
;
389 if (updating_frame
== 0)
392 x_display_cursor (selected_frame
, 1);
397 /* Display a sequence of N glyphs found at GP.
398 WINDOW is the window to output to. LEFT and TOP are starting coords.
399 HL is 1 if this text is highlighted, 2 if the cursor is on it,
400 3 if should appear in its mouse-face.
401 JUST_FOREGROUND if 1 means draw only the foreground;
402 don't alter the background.
404 FONT is the default font to use (for glyphs whose font-code is 0).
406 Since the display generation code is responsible for calling
407 compute_char_face and compute_glyph_face on everything it puts in
408 the display structure, we can assume that the face code on each
409 glyph is a valid index into FRAME_COMPUTED_FACES (f), and the one
410 to which we can actually apply intern_face.
411 Call this function with input blocked. */
414 dumpglyphs (f
, left
, top
, gp
, n
, hl
, just_foreground
)
417 register GLYPH
*gp
; /* Points to first GLYPH. */
418 register int n
; /* Number of glyphs to display. */
422 /* Holds characters to be displayed. */
423 char *buf
= (char *) alloca (f
->width
* sizeof (*buf
));
424 register char *cp
; /* Steps through buf[]. */
425 register int tlen
= GLYPH_TABLE_LENGTH
;
426 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
427 Window window
= FRAME_WIN32_WINDOW (f
);
428 int orig_left
= left
;
431 hdc
= get_frame_dc (f
);
435 /* Get the face-code of the next GLYPH. */
439 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
440 cf
= FAST_GLYPH_FACE (g
);
442 /* Find the run of consecutive glyphs with the same face-code.
443 Extract their character codes into BUF. */
448 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
449 if (FAST_GLYPH_FACE (g
) != cf
)
452 *cp
++ = FAST_GLYPH_CHAR (g
);
457 /* LEN gets the length of the run. */
460 /* Now output this run of chars, with the font and pixel values
461 determined by the face code CF. */
463 struct face
*face
= FRAME_DEFAULT_FACE (f
);
464 XFontStruct
*font
= FACE_FONT (face
);
469 /* HL = 3 means use a mouse face previously chosen. */
471 cf
= FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_face_id
;
473 /* First look at the face of the text itself. */
476 /* It's possible for the display table to specify
477 a face code that is out of range. Use 0 in that case. */
478 if (cf
< 0 || cf
>= FRAME_N_COMPUTED_FACES (f
)
479 || FRAME_COMPUTED_FACES (f
) [cf
] == 0)
483 face
= FRAME_MODE_LINE_FACE (f
);
485 face
= intern_face (f
, FRAME_COMPUTED_FACES (f
) [cf
]);
486 font
= FACE_FONT (face
);
487 if (FACE_STIPPLE (face
))
491 /* Then comes the distinction between modeline and normal text. */
496 face
= FRAME_MODE_LINE_FACE (f
);
497 font
= FACE_FONT (face
);
498 if (FACE_STIPPLE (face
))
502 fg
= face
->foreground
;
503 bg
= face
->background
;
505 /* Now override that if the cursor's on this character. */
508 /* The cursor overrides stippling. */
512 || face
->font
== (XFontStruct
*) FACE_DEFAULT
513 || face
->font
== f
->output_data
.win32
->font
)
514 && face
->background
== f
->output_data
.win32
->background_pixel
515 && face
->foreground
== f
->output_data
.win32
->foreground_pixel
)
517 bg
= f
->output_data
.win32
->cursor_pixel
;
518 fg
= face
->background
;
520 /* Cursor on non-default face: must merge. */
523 bg
= f
->output_data
.win32
->cursor_pixel
;
524 fg
= face
->background
;
525 /* If the glyph would be invisible,
526 try a different foreground. */
528 fg
= face
->foreground
;
530 fg
= f
->output_data
.win32
->cursor_foreground_pixel
;
532 fg
= face
->foreground
;
533 /* Make sure the cursor is distinct from text in this face. */
534 if (bg
== face
->background
535 && fg
== face
->foreground
)
537 bg
= face
->foreground
;
538 fg
= face
->background
;
543 if (font
== (XFontStruct
*) FACE_DEFAULT
)
544 font
= f
->output_data
.win32
->font
;
546 SetBkMode (hdc
, just_foreground
? TRANSPARENT
: OPAQUE
);
548 SetTextColor (hdc
, fg
);
549 SetBkColor (hdc
, bg
);
551 SelectObject (hdc
, font
->hfont
);
553 TextOut (hdc
, left
, top
, buf
, len
);
555 if (!just_foreground
)
557 /* Clear the rest of the line's height. */
558 if (f
->output_data
.win32
->line_height
!= FONT_HEIGHT (font
))
559 win32_fill_area (f
, hdc
, bg
,
561 top
+ FONT_HEIGHT (font
),
562 FONT_WIDTH (font
) * len
,
563 f
->output_data
.win32
->line_height
- FONT_HEIGHT (font
));
567 int underline_position
= 1;
569 if (font
->tm
.tmDescent
<= underline_position
)
570 underline_position
= font
->tm
.tmDescent
- 1;
573 win32_fill_area (f
, hdc
, fg
,
576 + underline_position
),
577 len
* FONT_WIDTH (font
), 1);
580 left
+= len
* FONT_WIDTH (font
);
584 release_frame_dc (f
, hdc
);
588 /* Output some text at the nominal frame cursor position.
589 Advance the cursor over the text.
590 Output LEN glyphs at START.
592 `highlight', set up by win32_reassert_line_highlight or win32_change_line_highlight,
593 controls the pixel values used for foreground and background. */
596 win32_write_glyphs (start
, len
)
597 register GLYPH
*start
;
600 register int temp_length
;
610 /* If not within an update,
611 output at the frame's visible cursor. */
612 curs_x
= f
->cursor_x
;
613 curs_y
= f
->cursor_y
;
617 CHAR_TO_PIXEL_COL (f
, curs_x
),
618 CHAR_TO_PIXEL_ROW (f
, curs_y
),
619 start
, len
, highlight
, 0);
621 /* If we drew on top of the cursor, note that it is turned off. */
622 if (curs_y
== f
->phys_cursor_y
623 && curs_x
<= f
->phys_cursor_x
624 && curs_x
+ len
> f
->phys_cursor_x
)
625 f
->phys_cursor_x
= -1;
627 if (updating_frame
== 0)
630 x_display_cursor (f
, 1);
639 /* Clear to the end of the line.
640 Erase the current text line from the nominal cursor position (inclusive)
641 to column FIRST_UNUSED (exclusive). The idea is that everything
642 from FIRST_UNUSED onward is already erased. */
645 win32_clear_end_of_line (first_unused
)
646 register int first_unused
;
648 struct frame
*f
= updating_frame
;
653 if (curs_y
< 0 || curs_y
>= f
->height
)
655 if (first_unused
<= 0)
658 if (first_unused
>= f
->width
)
659 first_unused
= f
->width
;
665 /* Notice if the cursor will be cleared by this operation. */
666 if (curs_y
== f
->phys_cursor_y
667 && curs_x
<= f
->phys_cursor_x
668 && f
->phys_cursor_x
< first_unused
)
669 f
->phys_cursor_x
= -1;
671 win32_clear_area (f
, NULL
,
672 CHAR_TO_PIXEL_COL (f
, curs_x
),
673 CHAR_TO_PIXEL_ROW (f
, curs_y
),
674 FONT_WIDTH (f
->output_data
.win32
->font
) * (first_unused
- curs_x
),
675 f
->output_data
.win32
->line_height
);
683 struct frame
*f
= updating_frame
;
688 f
->phys_cursor_x
= -1; /* Cursor not visible. */
689 curs_x
= 0; /* Nominal cursor position is top left. */
694 win32_clear_window (f
);
696 /* We have to clear the scroll bars, too. If we have changed
697 colors or something like that, then they should be notified. */
698 x_scroll_bar_clear (f
);
703 /* Make audible bell. */
710 FlashWindow (FRAME_WIN32_WINDOW (selected_frame
), FALSE
);
719 /* Insert and delete character.
720 These are not supposed to be used because we are supposed to turn
721 off the feature of using them. */
724 win32_insert_glyphs (start
, len
)
725 register char *start
;
732 win32_delete_glyphs (n
)
738 /* Specify how many text lines, from the top of the window,
739 should be affected by insert-lines and delete-lines operations.
740 This, and those operations, are used only within an update
741 that is bounded by calls to win32_update_begin and win32_update_end. */
744 win32_set_terminal_window (n
)
747 if (updating_frame
== 0)
750 if ((n
<= 0) || (n
> updating_frame
->height
))
751 flexlines
= updating_frame
->height
;
756 /* These variables need not be per frame
757 because redisplay is done on a frame-by-frame basis
758 and the line dance for one frame is finished before
759 anything is done for another frame. */
761 /* Array of line numbers from cached insert/delete operations.
762 line_dance[i] is the old position of the line that we want
763 to move to line i, or -1 if we want a blank line there. */
764 static int *line_dance
;
766 /* Allocated length of that array. */
767 static int line_dance_len
;
769 /* Flag indicating whether we've done any work. */
770 static int line_dance_in_progress
;
772 /* Perform an insert-lines or delete-lines operation,
773 inserting N lines or deleting -N lines at vertical position VPOS. */
774 win32_ins_del_lines (vpos
, n
)
777 register int fence
, i
;
779 if (vpos
>= flexlines
)
782 if (!line_dance_in_progress
)
784 int ht
= updating_frame
->height
;
785 if (ht
> line_dance_len
)
787 line_dance
= (int *)xrealloc (line_dance
, ht
* sizeof (int));
790 for (i
= 0; i
< ht
; ++i
) line_dance
[i
] = i
;
791 line_dance_in_progress
= 1;
795 if (n
> flexlines
- vpos
)
796 n
= flexlines
- vpos
;
798 for (i
= flexlines
; --i
>= fence
;)
799 line_dance
[i
] = line_dance
[i
-n
];
800 for (i
= fence
; --i
>= vpos
;)
806 if (n
> flexlines
- vpos
)
807 n
= flexlines
- vpos
;
808 fence
= flexlines
- n
;
809 for (i
= vpos
; i
< fence
; ++i
)
810 line_dance
[i
] = line_dance
[i
+ n
];
811 for (i
= fence
; i
< flexlines
; ++i
)
816 /* Here's where we actually move the pixels around.
817 Must be called with input blocked. */
821 register int i
, j
, distance
;
822 register struct frame
*f
;
827 /* Must check this flag first. If it's not set, then not only is the
828 array uninitialized, but we might not even have a frame. */
829 if (!line_dance_in_progress
)
837 intborder
= f
->output_data
.win32
->internal_border_width
;
839 x_display_cursor (updating_frame
, 0);
841 hdc
= get_frame_dc (f
);
843 for (i
= 0; i
< ht
; ++i
)
844 if (line_dance
[i
] != -1 && (distance
= line_dance
[i
]-i
) > 0)
846 for (j
= i
; (j
< ht
&& line_dance
[j
] != -1
847 && line_dance
[j
]-j
== distance
); ++j
);
848 /* Copy [i,j) upward from [i+distance, j+distance) */
850 intborder
, CHAR_TO_PIXEL_ROW (f
, i
+distance
),
851 f
->width
* FONT_WIDTH (f
->output_data
.win32
->font
),
852 (j
-i
) * f
->output_data
.win32
->line_height
,
854 intborder
, CHAR_TO_PIXEL_ROW (f
, i
),
859 for (i
= ht
; --i
>=0; )
860 if (line_dance
[i
] != -1 && (distance
= line_dance
[i
]-i
) < 0)
862 for (j
= i
; (--j
>= 0 && line_dance
[j
] != -1
863 && line_dance
[j
]-j
== distance
););
864 /* Copy (j, i] downward from (j+distance, i+distance] */
866 intborder
, CHAR_TO_PIXEL_ROW (f
, j
+1+distance
),
867 f
->width
* FONT_WIDTH (f
->output_data
.win32
->font
),
868 (i
-j
) * f
->output_data
.win32
->line_height
,
870 intborder
, CHAR_TO_PIXEL_ROW (f
, j
+1),
875 release_frame_dc (f
, hdc
);
877 for (i
= 0; i
< ht
; ++i
)
878 if (line_dance
[i
] == -1)
880 for (j
= i
; j
< ht
&& line_dance
[j
] == -1; ++j
);
882 win32_clear_area (f
, NULL
,
884 CHAR_TO_PIXEL_ROW (f
, i
),
885 f
->width
* FONT_WIDTH (f
->output_data
.win32
->font
),
886 (j
-i
) * f
->output_data
.win32
->line_height
);
889 line_dance_in_progress
= 0;
892 /* Support routines for exposure events. */
893 static void clear_cursor ();
895 /* Output into a rectangle of a window (for frame F)
896 the characters in f->phys_lines that overlap that rectangle.
897 TOP and LEFT are the position of the upper left corner of the rectangle.
898 ROWS and COLS are the size of the rectangle.
899 Call this function with input blocked. */
902 dumprectangle (f
, left
, top
, cols
, rows
)
904 register int left
, top
, cols
, rows
;
906 register struct frame_glyphs
*active_frame
= FRAME_CURRENT_GLYPHS (f
);
907 int cursor_cleared
= 0;
911 if (FRAME_GARBAGED_P (f
))
914 /* Express rectangle as four edges, instead of position-and-size. */
918 /* Convert rectangle edges in pixels to edges in chars.
919 Round down for left and top, up for right and bottom. */
920 top
= PIXEL_TO_CHAR_ROW (f
, top
);
921 left
= PIXEL_TO_CHAR_COL (f
, left
);
922 bottom
+= (f
->output_data
.win32
->line_height
- 1);
923 right
+= (FONT_WIDTH (f
->output_data
.win32
->font
) - 1);
924 bottom
= PIXEL_TO_CHAR_ROW (f
, bottom
);
925 right
= PIXEL_TO_CHAR_COL (f
, right
);
927 /* Clip the rectangle to what can be visible. */
932 if (right
> f
->width
)
934 if (bottom
> f
->height
)
937 /* Get size in chars of the rectangle. */
941 /* If rectangle has zero area, return. */
942 if (rows
<= 0) return;
943 if (cols
<= 0) return;
945 /* Turn off the cursor if it is in the rectangle.
946 We will turn it back on afterward. */
947 if ((f
->phys_cursor_x
>= left
) && (f
->phys_cursor_x
< right
)
948 && (f
->phys_cursor_y
>= top
) && (f
->phys_cursor_y
< bottom
))
954 /* Display the text in the rectangle, one text line at a time. */
956 for (y
= top
; y
< bottom
; y
++)
958 GLYPH
*line
= &active_frame
->glyphs
[y
][left
];
960 if (! active_frame
->enable
[y
] || left
> active_frame
->used
[y
])
964 CHAR_TO_PIXEL_COL (f
, left
),
965 CHAR_TO_PIXEL_ROW (f
, y
),
966 line
, min (cols
, active_frame
->used
[y
] - left
),
967 active_frame
->highlight
[y
], 0);
970 /* Turn the cursor on if we turned it off. */
973 x_display_cursor (f
, 1);
980 x_display_cursor (f
, 1);
984 frame_unhighlight (f
)
987 x_display_cursor (f
, 1);
990 static void win32_frame_rehighlight ();
991 static void x_frame_rehighlight ();
993 /* The focus has changed. Update the frames as necessary to reflect
994 the new situation. Note that we can't change the selected frame
995 here, because the Lisp code we are interrupting might become confused.
996 Each event gets marked with the frame in which it occurred, so the
997 Lisp code can tell when the switch took place by examining the events. */
1000 x_new_focus_frame (dpyinfo
, frame
)
1001 struct win32_display_info
*dpyinfo
;
1002 struct frame
*frame
;
1004 struct frame
*old_focus
= dpyinfo
->win32_focus_frame
;
1005 int events_enqueued
= 0;
1007 if (frame
!= dpyinfo
->win32_focus_frame
)
1009 /* Set this before calling other routines, so that they see
1010 the correct value of win32_focus_frame. */
1011 dpyinfo
->win32_focus_frame
= frame
;
1013 if (old_focus
&& old_focus
->auto_lower
)
1014 x_lower_frame (old_focus
);
1016 if (dpyinfo
->win32_focus_frame
&& dpyinfo
->win32_focus_frame
->auto_raise
)
1017 pending_autoraise_frame
= dpyinfo
->win32_focus_frame
;
1019 pending_autoraise_frame
= 0;
1022 x_frame_rehighlight (dpyinfo
);
1025 /* Handle an event saying the mouse has moved out of an Emacs frame. */
1028 x_mouse_leave (dpyinfo
)
1029 struct win32_display_info
*dpyinfo
;
1031 x_new_focus_frame (dpyinfo
, dpyinfo
->win32_focus_event_frame
);
1034 /* The focus has changed, or we have redirected a frame's focus to
1035 another frame (this happens when a frame uses a surrogate
1036 minibuffer frame). Shift the highlight as appropriate.
1038 The FRAME argument doesn't necessarily have anything to do with which
1039 frame is being highlighted or unhighlighted; we only use it to find
1040 the appropriate display info. */
1042 win32_frame_rehighlight (frame
)
1043 struct frame
*frame
;
1045 x_frame_rehighlight (FRAME_WIN32_DISPLAY_INFO (frame
));
1049 x_frame_rehighlight (dpyinfo
)
1050 struct win32_display_info
*dpyinfo
;
1052 struct frame
*old_highlight
= dpyinfo
->win32_highlight_frame
;
1054 if (dpyinfo
->win32_focus_frame
)
1056 dpyinfo
->win32_highlight_frame
1057 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->win32_focus_frame
)))
1058 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->win32_focus_frame
))
1059 : dpyinfo
->win32_focus_frame
);
1060 if (! FRAME_LIVE_P (dpyinfo
->win32_highlight_frame
))
1062 FRAME_FOCUS_FRAME (dpyinfo
->win32_focus_frame
) = Qnil
;
1063 dpyinfo
->win32_highlight_frame
= dpyinfo
->win32_focus_frame
;
1067 dpyinfo
->win32_highlight_frame
= 0;
1069 if (dpyinfo
->win32_highlight_frame
!= old_highlight
)
1072 frame_unhighlight (old_highlight
);
1073 if (dpyinfo
->win32_highlight_frame
)
1074 frame_highlight (dpyinfo
->win32_highlight_frame
);
1078 /* Keyboard processing - modifier keys, etc. */
1080 /* Convert a keysym to its name. */
1083 x_get_keysym_name (keysym
)
1086 /* Make static so we can always return it */
1087 static char value
[100];
1090 GetKeyNameText(keysym
, value
, 100);
1096 /* Mouse clicks and mouse movement. Rah. */
1098 /* Given a pixel position (PIX_X, PIX_Y) on the frame F, return
1099 glyph co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle
1100 that the glyph at X, Y occupies, if BOUNDS != 0.
1101 If NOCLIP is nonzero, do not force the value into range. */
1104 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
1106 register int pix_x
, pix_y
;
1107 register int *x
, *y
;
1111 /* Support tty mode: if Vwindow_system is nil, behave correctly. */
1112 if (NILP (Vwindow_system
))
1119 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
1120 even for negative values. */
1122 pix_x
-= FONT_WIDTH ((f
)->output_data
.win32
->font
) - 1;
1124 pix_y
-= (f
)->output_data
.win32
->line_height
- 1;
1126 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
1127 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
1131 bounds
->left
= CHAR_TO_PIXEL_COL (f
, pix_x
);
1132 bounds
->top
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
1133 bounds
->right
= bounds
->left
+ FONT_WIDTH (f
->output_data
.win32
->font
) - 1;
1134 bounds
->bottom
= bounds
->top
+ f
->output_data
.win32
->line_height
- 1;
1141 else if (pix_x
> f
->width
)
1146 else if (pix_y
> f
->height
)
1155 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
1158 register int *pix_x
, *pix_y
;
1160 /* Support tty mode: if Vwindow_system is nil, behave correctly. */
1161 if (NILP (Vwindow_system
))
1168 *pix_x
= CHAR_TO_PIXEL_COL (f
, x
);
1169 *pix_y
= CHAR_TO_PIXEL_ROW (f
, y
);
1173 parse_button (message
, pbutton
, pup
)
1183 case WM_LBUTTONDOWN
:
1191 case WM_MBUTTONDOWN
:
1192 if (NILP (Vwin32_swap_mouse_buttons
))
1199 if (NILP (Vwin32_swap_mouse_buttons
))
1205 case WM_RBUTTONDOWN
:
1206 if (NILP (Vwin32_swap_mouse_buttons
))
1213 if (NILP (Vwin32_swap_mouse_buttons
))
1224 if (pbutton
) *pbutton
= button
;
1230 /* Prepare a mouse-event in *RESULT for placement in the input queue.
1232 If the event is a button press, then note that we have grabbed
1236 construct_mouse_click (result
, msg
, f
)
1237 struct input_event
*result
;
1244 parse_button (msg
->msg
.message
, &button
, &up
);
1246 /* Make the event type no_event; we'll change that when we decide
1248 result
->kind
= mouse_click
;
1249 result
->code
= button
;
1250 result
->timestamp
= msg
->msg
.time
;
1251 result
->modifiers
= (msg
->dwModifiers
1259 XSETINT (result
->x
, LOWORD (msg
->msg
.lParam
));
1260 XSETINT (result
->y
, HIWORD (msg
->msg
.lParam
));
1261 XSETFRAME (result
->frame_or_window
, f
);
1266 /* Function to report a mouse movement to the mainstream Emacs code.
1267 The input handler calls this.
1269 We have received a mouse movement event, which is given in *event.
1270 If the mouse is over a different glyph than it was last time, tell
1271 the mainstream emacs code by setting mouse_moved. If not, ask for
1272 another motion event, so we can check again the next time it moves. */
1275 note_mouse_movement (frame
, msg
)
1279 last_mouse_movement_time
= msg
->time
;
1281 if (msg
->hwnd
!= FRAME_WIN32_WINDOW (frame
))
1283 frame
->mouse_moved
= 1;
1284 last_mouse_scroll_bar
= Qnil
;
1286 note_mouse_highlight (frame
, -1, -1);
1289 /* Has the mouse moved off the glyph it was on at the last sighting? */
1290 else if (LOWORD (msg
->lParam
) < last_mouse_glyph
.left
1291 || LOWORD (msg
->lParam
) > last_mouse_glyph
.right
1292 || HIWORD (msg
->lParam
) < last_mouse_glyph
.top
1293 || HIWORD (msg
->lParam
) > last_mouse_glyph
.bottom
)
1295 frame
->mouse_moved
= 1;
1296 last_mouse_scroll_bar
= Qnil
;
1298 note_mouse_highlight (frame
, LOWORD (msg
->lParam
), HIWORD (msg
->lParam
));
1302 /* This is used for debugging, to turn off note_mouse_highlight. */
1303 static int disable_mouse_highlight
;
1305 /* Take proper action when the mouse has moved to position X, Y on frame F
1306 as regards highlighting characters that have mouse-face properties.
1307 Also dehighlighting chars where the mouse was before.
1308 X and Y can be negative or out of range. */
1311 note_mouse_highlight (f
, x
, y
)
1315 int row
, column
, portion
;
1320 if (disable_mouse_highlight
)
1323 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_mouse_x
= x
;
1324 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_mouse_y
= y
;
1325 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
= f
;
1327 if (FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_defer
)
1332 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_deferred_gc
= 1;
1336 /* Find out which glyph the mouse is on. */
1337 pixel_to_glyph_coords (f
, x
, y
, &column
, &row
,
1338 &new_glyph
, FRAME_WIN32_DISPLAY_INFO (f
)->grabbed
);
1340 /* Which window is that in? */
1341 window
= window_from_coordinates (f
, column
, row
, &portion
);
1342 w
= XWINDOW (window
);
1344 /* If we were displaying active text in another window, clear that. */
1345 if (! EQ (window
, FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_window
))
1346 clear_mouse_face (FRAME_WIN32_DISPLAY_INFO (f
));
1348 /* Are we in a window whose display is up to date?
1349 And verify the buffer's text has not changed. */
1350 if (WINDOWP (window
) && portion
== 0 && row
>= 0 && column
>= 0
1351 && row
< FRAME_HEIGHT (f
) && column
< FRAME_WIDTH (f
)
1352 && EQ (w
->window_end_valid
, w
->buffer
)
1353 && w
->last_modified
== BUF_MODIFF (XBUFFER (w
->buffer
)))
1355 int *ptr
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[row
];
1358 /* Find which buffer position the mouse corresponds to. */
1359 for (i
= column
; i
>= 0; i
--)
1363 /* Is it outside the displayed active region (if any)? */
1365 clear_mouse_face (FRAME_WIN32_DISPLAY_INFO (f
));
1366 else if (! (EQ (window
, FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_window
)
1367 && row
>= FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_row
1368 && row
<= FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_row
1369 && (row
> FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_row
1370 || column
>= FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_col
)
1371 && (row
< FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_row
1372 || column
< FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_col
1373 || FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_past_end
)))
1375 Lisp_Object mouse_face
, overlay
, position
;
1376 Lisp_Object
*overlay_vec
;
1377 int len
, noverlays
, ignor1
;
1378 struct buffer
*obuf
;
1381 /* If we get an out-of-range value, return now; avoid an error. */
1382 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1385 /* Make the window's buffer temporarily current for
1386 overlays_at and compute_char_face. */
1387 obuf
= current_buffer
;
1388 current_buffer
= XBUFFER (w
->buffer
);
1394 /* Yes. Clear the display of the old active region, if any. */
1395 clear_mouse_face (FRAME_WIN32_DISPLAY_INFO (f
));
1397 /* Is this char mouse-active? */
1398 XSETINT (position
, pos
);
1401 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
1403 /* Put all the overlays we want in a vector in overlay_vec.
1404 Store the length in len. */
1405 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
1407 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1409 /* Find the highest priority overlay that has a mouse-face prop. */
1411 for (i
= 0; i
< noverlays
; i
++)
1413 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1414 if (!NILP (mouse_face
))
1416 overlay
= overlay_vec
[i
];
1421 /* If no overlay applies, get a text property. */
1423 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
1425 /* Handle the overlay case. */
1426 if (! NILP (overlay
))
1428 /* Find the range of text around this char that
1429 should be active. */
1430 Lisp_Object before
, after
;
1433 before
= Foverlay_start (overlay
);
1434 after
= Foverlay_end (overlay
);
1435 /* Record this as the current active region. */
1436 fast_find_position (window
, before
,
1437 &FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_col
,
1438 &FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_row
);
1439 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_past_end
1440 = !fast_find_position (window
, after
,
1441 &FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_col
,
1442 &FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_row
);
1443 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_window
= window
;
1444 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_face_id
1445 = compute_char_face (f
, w
, pos
, 0, 0,
1446 &ignore
, pos
+ 1, 1);
1448 /* Display it as active. */
1449 show_mouse_face (FRAME_WIN32_DISPLAY_INFO (f
), 1);
1451 /* Handle the text property case. */
1452 else if (! NILP (mouse_face
))
1454 /* Find the range of text around this char that
1455 should be active. */
1456 Lisp_Object before
, after
, beginning
, end
;
1459 beginning
= Fmarker_position (w
->start
);
1460 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1461 - XFASTINT (w
->window_end_pos
)));
1463 = Fprevious_single_property_change (make_number (pos
+ 1),
1465 w
->buffer
, beginning
);
1467 = Fnext_single_property_change (position
, Qmouse_face
,
1469 /* Record this as the current active region. */
1470 fast_find_position (window
, before
,
1471 &FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_col
,
1472 &FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_row
);
1473 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_past_end
1474 = !fast_find_position (window
, after
,
1475 &FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_col
,
1476 &FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_row
);
1477 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_window
= window
;
1478 FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_face_id
1479 = compute_char_face (f
, w
, pos
, 0, 0,
1480 &ignore
, pos
+ 1, 1);
1482 /* Display it as active. */
1483 show_mouse_face (FRAME_WIN32_DISPLAY_INFO (f
), 1);
1487 current_buffer
= obuf
;
1492 /* Find the row and column of position POS in window WINDOW.
1493 Store them in *COLUMNP and *ROWP.
1494 This assumes display in WINDOW is up to date.
1495 If POS is above start of WINDOW, return coords
1496 of start of first screen line.
1497 If POS is after end of WINDOW, return coords of end of last screen line.
1499 Value is 1 if POS is in range, 0 if it was off screen. */
1502 fast_find_position (window
, pos
, columnp
, rowp
)
1505 int *columnp
, *rowp
;
1507 struct window
*w
= XWINDOW (window
);
1508 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1513 int height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
1514 int width
= window_internal_width (w
);
1517 int maybe_next_line
= 0;
1519 /* Find the right row. */
1524 int linestart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ i
][left
];
1525 if (linestart
> pos
)
1527 /* If the position sought is the end of the buffer,
1528 don't include the blank lines at the bottom of the window. */
1529 if (linestart
== pos
&& pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1531 maybe_next_line
= 1;
1538 /* Find the right column with in it. */
1539 charstarts
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ row
];
1541 for (i
= 0; i
< width
; i
++)
1543 if (charstarts
[left
+ i
] == pos
)
1546 *columnp
= i
+ left
;
1549 else if (charstarts
[left
+ i
] > pos
)
1551 else if (charstarts
[left
+ i
] > 0)
1555 /* If we're looking for the end of the buffer,
1556 and we didn't find it in the line we scanned,
1557 use the start of the following line. */
1558 if (maybe_next_line
)
1569 /* Display the active region described by mouse_face_*
1570 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1573 show_mouse_face (dpyinfo
, hl
)
1574 struct win32_display_info
*dpyinfo
;
1577 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
1578 int width
= window_internal_width (w
);
1579 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1582 int old_curs_x
= curs_x
;
1583 int old_curs_y
= curs_y
;
1585 /* Set these variables temporarily
1586 so that if we have to turn the cursor off and on again
1587 we will put it back at the same place. */
1588 curs_x
= f
->phys_cursor_x
;
1589 curs_y
= f
->phys_cursor_y
;
1591 for (i
= FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_row
;
1592 i
<= FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_row
; i
++)
1594 int column
= (i
== FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_row
1595 ? FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_col
1597 int endcolumn
= (i
== FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_row
1598 ? FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_col
1600 endcolumn
= min (endcolumn
, FRAME_CURRENT_GLYPHS (f
)->used
[i
]);
1602 /* If the cursor's in the text we are about to rewrite,
1603 turn the cursor off. */
1605 && curs_x
>= FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_col
- 1
1606 && curs_x
<= FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_col
)
1608 x_display_cursor (f
, 0);
1613 CHAR_TO_PIXEL_COL (f
, column
),
1614 CHAR_TO_PIXEL_ROW (f
, i
),
1615 FRAME_CURRENT_GLYPHS (f
)->glyphs
[i
] + column
,
1617 /* Highlight with mouse face if hl > 0. */
1621 /* If we turned the cursor off, turn it back on. */
1623 x_display_cursor (f
, 1);
1625 curs_x
= old_curs_x
;
1626 curs_y
= old_curs_y
;
1628 /* Change the mouse cursor according to the value of HL. */
1630 SetCursor (f
->output_data
.win32
->cross_cursor
);
1632 SetCursor (f
->output_data
.win32
->text_cursor
);
1635 /* Clear out the mouse-highlighted active region.
1636 Redraw it unhighlighted first. */
1639 clear_mouse_face (dpyinfo
)
1640 struct win32_display_info
*dpyinfo
;
1642 if (! NILP (dpyinfo
->mouse_face_window
))
1643 show_mouse_face (dpyinfo
, 0);
1645 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1646 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1647 dpyinfo
->mouse_face_window
= Qnil
;
1650 struct scroll_bar
*x_window_to_scroll_bar ();
1651 static void x_scroll_bar_report_motion ();
1653 /* Return the current position of the mouse.
1654 *fp should be a frame which indicates which display to ask about.
1656 If the mouse movement started in a scroll bar, set *fp, *bar_window,
1657 and *part to the frame, window, and scroll bar part that the mouse
1658 is over. Set *x and *y to the portion and whole of the mouse's
1659 position on the scroll bar.
1661 If the mouse movement started elsewhere, set *fp to the frame the
1662 mouse is on, *bar_window to nil, and *x and *y to the character cell
1665 Set *time to the server timestamp for the time at which the mouse
1666 was at this position.
1668 Don't store anything if we don't have a valid set of values to report.
1670 This clears the mouse_moved flag, so we can wait for the next mouse
1671 movement. This also calls XQueryPointer, which will cause the
1672 server to give us another MotionNotify when the mouse moves
1676 win32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
1679 Lisp_Object
*bar_window
;
1680 enum scroll_bar_part
*part
;
1682 unsigned long *time
;
1688 if (! NILP (last_mouse_scroll_bar
))
1689 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
1694 Lisp_Object frame
, tail
;
1696 /* Clear the mouse-moved flag for every frame on this display. */
1697 FOR_EACH_FRAME (tail
, frame
)
1698 XFRAME (frame
)->mouse_moved
= 0;
1700 last_mouse_scroll_bar
= Qnil
;
1704 /* Now we have a position on the root; find the innermost window
1705 containing the pointer. */
1707 if (FRAME_WIN32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
1708 && FRAME_LIVE_P (last_mouse_frame
))
1710 f1
= last_mouse_frame
;
1714 /* Is win one of our frames? */
1715 f1
= x_window_to_frame (FRAME_WIN32_DISPLAY_INFO (*fp
), WindowFromPoint(pt
));
1718 /* If not, is it one of our scroll bars? */
1721 struct scroll_bar
*bar
= x_window_to_scroll_bar (WindowFromPoint(pt
));
1725 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
1729 if (f1
== 0 && insist
)
1730 f1
= selected_frame
;
1734 int ignore1
, ignore2
;
1736 ScreenToClient (FRAME_WIN32_WINDOW (f1
), &pt
);
1738 /* Ok, we found a frame. Store all the values. */
1740 pixel_to_glyph_coords (f1
, pt
.x
, pt
.y
, &ignore1
, &ignore2
,
1742 FRAME_WIN32_DISPLAY_INFO (f1
)->grabbed
1750 *time
= last_mouse_movement_time
;
1758 /* Scroll bar support. */
1760 /* Given an window ID, find the struct scroll_bar which manages it.
1761 This can be called in GC, so we have to make sure to strip off mark
1764 x_window_to_scroll_bar (window_id
)
1767 Lisp_Object tail
, frame
;
1769 for (tail
= Vframe_list
;
1770 XGCTYPE (tail
) == Lisp_Cons
;
1771 tail
= XCONS (tail
)->cdr
)
1773 Lisp_Object frame
, bar
, condemned
;
1775 frame
= XCONS (tail
)->car
;
1776 /* All elements of Vframe_list should be frames. */
1777 if (! GC_FRAMEP (frame
))
1780 /* Scan this frame's scroll bar list for a scroll bar with the
1782 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
1783 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
1784 /* This trick allows us to search both the ordinary and
1785 condemned scroll bar lists with one loop. */
1786 ! GC_NILP (bar
) || (bar
= condemned
,
1789 bar
= XSCROLL_BAR (bar
)->next
)
1790 if (SCROLL_BAR_WIN32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
1791 return XSCROLL_BAR (bar
);
1798 my_create_scrollbar (f
, bar
)
1800 struct scroll_bar
* bar
;
1804 PostThreadMessage (dwWinThreadId
, WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
1806 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
1808 return ((HWND
) msg
.wParam
);
1811 //#define ATTACH_THREADS
1814 my_show_window (HWND hwnd
, int how
)
1816 #ifndef ATTACH_THREADS
1817 SendMessage (hwnd
, WM_EMACS_SHOWWINDOW
, (WPARAM
) how
, 0);
1819 ShowWindow (hwnd
, how
);
1824 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
1825 int x
, int y
, int cx
, int cy
, int flags
)
1827 #ifndef ATTACH_THREADS
1829 pos
.hwndAfter
= hwndAfter
;
1835 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
1837 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
1842 my_destroy_window (f
, hwnd
)
1846 SendMessage (FRAME_WIN32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
1850 /* Open a new window to serve as a scroll bar, and return the
1851 scroll bar vector for it. */
1852 static struct scroll_bar
*
1853 x_scroll_bar_create (window
, top
, left
, width
, height
)
1854 struct window
*window
;
1855 int top
, left
, width
, height
;
1857 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
1858 struct scroll_bar
*bar
1859 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
1864 XSETWINDOW (bar
->window
, window
);
1865 XSETINT (bar
->top
, top
);
1866 XSETINT (bar
->left
, left
);
1867 XSETINT (bar
->width
, width
);
1868 XSETINT (bar
->height
, height
);
1869 XSETINT (bar
->start
, 0);
1870 XSETINT (bar
->end
, 0);
1871 bar
->dragging
= Qnil
;
1873 /* Requires geometry to be set before call to create the real window */
1875 hwnd
= my_create_scrollbar (f
, bar
);
1877 SetScrollRange (hwnd
, SB_CTL
, 0, height
, FALSE
);
1878 SetScrollPos (hwnd
, SB_CTL
, 0, TRUE
);
1880 SET_SCROLL_BAR_WIN32_WINDOW (bar
, hwnd
);
1882 /* Add bar to its frame's list of scroll bars. */
1883 bar
->next
= FRAME_SCROLL_BARS (f
);
1885 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
1886 if (! NILP (bar
->next
))
1887 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
1894 /* Draw BAR's handle in the proper position.
1895 If the handle is already drawn from START to END, don't bother
1896 redrawing it, unless REBUILD is non-zero; in that case, always
1897 redraw it. (REBUILD is handy for drawing the handle after expose
1900 Normally, we want to constrain the start and end of the handle to
1901 fit inside its rectangle, but if the user is dragging the scroll bar
1902 handle, we want to let them drag it down all the way, so that the
1903 bar's top is as far down as it goes; otherwise, there's no way to
1904 move to the very end of the buffer. */
1906 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
1907 struct scroll_bar
*bar
;
1911 int dragging
= ! NILP (bar
->dragging
);
1912 Window w
= SCROLL_BAR_WIN32_WINDOW (bar
);
1913 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
1915 /* If the display is already accurate, do nothing. */
1917 && start
== XINT (bar
->start
)
1918 && end
== XINT (bar
->end
))
1923 /* Store the adjusted setting in the scroll bar. */
1924 XSETINT (bar
->start
, start
);
1925 XSETINT (bar
->end
, end
);
1927 SetScrollPos (w
, SB_CTL
, start
, TRUE
);
1932 /* Move a scroll bar around on the screen, to accommodate changing
1933 window configurations. */
1935 x_scroll_bar_move (bar
, top
, left
, width
, height
)
1936 struct scroll_bar
*bar
;
1937 int top
, left
, width
, height
;
1939 Window w
= SCROLL_BAR_WIN32_WINDOW (bar
);
1940 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
1944 MoveWindow (w
, left
, top
, width
, height
, TRUE
);
1945 SetScrollRange (w
, SB_CTL
, 0, height
, FALSE
);
1946 InvalidateRect (w
, NULL
, FALSE
);
1947 my_show_window (w
, SW_NORMAL
);
1949 XSETINT (bar
->left
, left
);
1950 XSETINT (bar
->top
, top
);
1951 XSETINT (bar
->width
, width
);
1952 XSETINT (bar
->height
, height
);
1957 /* Destroy the window for BAR, and set its Emacs window's scroll bar
1960 x_scroll_bar_remove (bar
)
1961 struct scroll_bar
*bar
;
1963 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
1967 /* Destroy the window. */
1968 my_destroy_window (f
, SCROLL_BAR_WIN32_WINDOW (bar
));
1970 /* Disassociate this scroll bar from its window. */
1971 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
1976 /* Set the handle of the vertical scroll bar for WINDOW to indicate
1977 that we are displaying PORTION characters out of a total of WHOLE
1978 characters, starting at POSITION. If WINDOW has no scroll bar,
1981 win32_set_vertical_scroll_bar (window
, portion
, whole
, position
)
1982 struct window
*window
;
1983 int portion
, whole
, position
;
1985 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
1986 int top
= XINT (window
->top
);
1987 int left
= WINDOW_VERTICAL_SCROLL_BAR_COLUMN (window
);
1988 int height
= WINDOW_VERTICAL_SCROLL_BAR_HEIGHT (window
);
1990 /* Where should this scroll bar be, pixelwise? */
1991 int pixel_top
= CHAR_TO_PIXEL_ROW (f
, top
);
1992 int pixel_left
= CHAR_TO_PIXEL_COL (f
, left
);
1994 = (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
1995 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
1996 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.win32
->font
)));
1997 int pixel_height
= VERTICAL_SCROLL_BAR_PIXEL_HEIGHT (f
, height
);
1999 struct scroll_bar
*bar
;
2001 /* Does the scroll bar exist yet? */
2002 if (NILP (window
->vertical_scroll_bar
))
2003 bar
= x_scroll_bar_create (window
,
2004 pixel_top
, pixel_left
,
2005 pixel_width
, pixel_height
);
2008 /* It may just need to be moved and resized. */
2009 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2010 x_scroll_bar_move (bar
, pixel_top
, pixel_left
, pixel_width
, pixel_height
);
2013 /* Set the scroll bar's current state, unless we're currently being
2015 if (NILP (bar
->dragging
))
2017 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (pixel_height
);
2020 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
2023 int start
= (int) (((double) position
* top_range
) / whole
);
2024 int end
= (int) (((double) (position
+ portion
) * top_range
) / whole
);
2026 x_scroll_bar_set_handle (bar
, start
, end
, 0);
2030 XSETVECTOR (window
->vertical_scroll_bar
, bar
);
2034 /* The following three hooks are used when we're doing a thorough
2035 redisplay of the frame. We don't explicitly know which scroll bars
2036 are going to be deleted, because keeping track of when windows go
2037 away is a real pain - "Can you say set-window-configuration, boys
2038 and girls?" Instead, we just assert at the beginning of redisplay
2039 that *all* scroll bars are to be removed, and then save a scroll bar
2040 from the fiery pit when we actually redisplay its window. */
2042 /* Arrange for all scroll bars on FRAME to be removed at the next call
2043 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
2044 `*redeem_scroll_bar_hook' is applied to its window before the judgement. */
2046 win32_condemn_scroll_bars (frame
)
2049 /* The condemned list should be empty at this point; if it's not,
2050 then the rest of Emacs isn't using the condemn/redeem/judge
2051 protocol correctly. */
2052 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
2055 /* Move them all to the "condemned" list. */
2056 FRAME_CONDEMNED_SCROLL_BARS (frame
) = FRAME_SCROLL_BARS (frame
);
2057 FRAME_SCROLL_BARS (frame
) = Qnil
;
2060 /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
2061 Note that WINDOW isn't necessarily condemned at all. */
2063 win32_redeem_scroll_bar (window
)
2064 struct window
*window
;
2066 struct scroll_bar
*bar
;
2068 /* We can't redeem this window's scroll bar if it doesn't have one. */
2069 if (NILP (window
->vertical_scroll_bar
))
2072 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2074 /* Unlink it from the condemned list. */
2076 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2078 if (NILP (bar
->prev
))
2080 /* If the prev pointer is nil, it must be the first in one of
2082 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
2083 /* It's not condemned. Everything's fine. */
2085 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
2086 window
->vertical_scroll_bar
))
2087 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
2089 /* If its prev pointer is nil, it must be at the front of
2090 one or the other! */
2094 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
2096 if (! NILP (bar
->next
))
2097 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
2099 bar
->next
= FRAME_SCROLL_BARS (f
);
2101 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2102 if (! NILP (bar
->next
))
2103 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2107 /* Remove all scroll bars on FRAME that haven't been saved since the
2108 last call to `*condemn_scroll_bars_hook'. */
2110 win32_judge_scroll_bars (f
)
2113 Lisp_Object bar
, next
;
2115 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
2117 /* Clear out the condemned list now so we won't try to process any
2118 more events on the hapless scroll bars. */
2119 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
2121 for (; ! NILP (bar
); bar
= next
)
2123 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
2125 x_scroll_bar_remove (b
);
2128 b
->next
= b
->prev
= Qnil
;
2131 /* Now there should be no references to the condemned scroll bars,
2132 and they should get garbage-collected. */
2135 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
2136 is set to something other than no_event, it is enqueued.
2138 This may be called from a signal handler, so we have to ignore GC
2142 x_scroll_bar_handle_click (bar
, msg
, emacs_event
)
2143 struct scroll_bar
*bar
;
2145 struct input_event
*emacs_event
;
2147 if (! GC_WINDOWP (bar
->window
))
2150 emacs_event
->kind
= win32_scroll_bar_click
;
2151 emacs_event
->code
= 0;
2152 /* not really meaningful to distinguish up/down */
2153 emacs_event
->modifiers
= msg
->dwModifiers
;
2154 emacs_event
->frame_or_window
= bar
->window
;
2155 emacs_event
->timestamp
= msg
->msg
.time
;
2159 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2161 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2162 int y
= GetScrollPos ((HWND
) msg
->msg
.lParam
, SB_CTL
);
2164 switch (LOWORD (msg
->msg
.wParam
))
2167 emacs_event
->part
= scroll_bar_handle
;
2168 if (VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
)) <= 0xffff)
2169 y
= HIWORD (msg
->msg
.wParam
);
2172 emacs_event
->part
= scroll_bar_down_arrow
;
2175 emacs_event
->part
= scroll_bar_up_arrow
;
2178 emacs_event
->part
= scroll_bar_above_handle
;
2181 emacs_event
->part
= scroll_bar_below_handle
;
2184 emacs_event
->part
= scroll_bar_handle
;
2188 emacs_event
->part
= scroll_bar_handle
;
2191 case SB_THUMBPOSITION
:
2192 emacs_event
->part
= scroll_bar_handle
;
2196 SetScrollPos (SCROLL_BAR_WIN32_WINDOW (bar
), SB_CTL
, y
, TRUE
);
2200 XSETINT (emacs_event
->x
, y
);
2201 XSETINT (emacs_event
->y
, top_range
);
2207 /* Return information to the user about the current position of the mouse
2208 on the scroll bar. */
2210 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
2212 Lisp_Object
*bar_window
;
2213 enum scroll_bar_part
*part
;
2215 unsigned long *time
;
2217 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
2218 Window w
= SCROLL_BAR_WIN32_WINDOW (bar
);
2219 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2225 *bar_window
= bar
->window
;
2227 pos
= GetScrollPos (w
, SB_CTL
);
2229 switch (LOWORD (last_mouse_scroll_bar_pos
))
2231 case SB_THUMBPOSITION
:
2233 *part
= scroll_bar_handle
;
2234 if (VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
)) <= 0xffff)
2235 pos
= HIWORD (last_mouse_scroll_bar_pos
);
2238 *part
= scroll_bar_handle
;
2242 *part
= scroll_bar_handle
;
2247 XSETINT(*y
, VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
)));
2250 last_mouse_scroll_bar
= Qnil
;
2252 *time
= last_mouse_movement_time
;
2257 /* The screen has been cleared so we may have changed foreground or
2258 background colors, and the scroll bars may need to be redrawn.
2259 Clear out the scroll bars, and ask for expose events, so we can
2262 x_scroll_bar_clear (f
)
2267 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
2268 bar
= XSCROLL_BAR (bar
)->next
)
2270 HWND window
= SCROLL_BAR_WIN32_WINDOW (XSCROLL_BAR (bar
));
2271 HDC hdc
= GetDC (window
);
2274 my_show_window (window
, SW_HIDE
);
2275 GetClientRect (window
, &rect
);
2276 select_palette (f
, hdc
);
2277 win32_clear_rect (f
, hdc
, &rect
);
2278 deselect_palette (f
, hdc
);
2282 show_scroll_bars (f
, how
)
2288 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
2289 bar
= XSCROLL_BAR (bar
)->next
)
2291 HWND window
= SCROLL_BAR_WIN32_WINDOW (XSCROLL_BAR (bar
));
2292 my_show_window (window
, how
);
2297 /* The main Win32 event-reading loop - w32_read_socket. */
2299 /* Timestamp of enter window event. This is only used by w32_read_socket,
2300 but we have to put it out here, since static variables within functions
2301 sometimes don't work. */
2302 static Time enter_timestamp
;
2304 /* Record the last 100 characters stored
2305 to help debug the loss-of-chars-during-GC problem. */
2307 short temp_buffer
[100];
2309 extern int key_event (KEY_EVENT_RECORD
*, struct input_event
*);
2311 /* Map a Win32 WM_CHAR message into a KEY_EVENT_RECORD so that
2312 we can use the same routines to handle input in both console
2313 and window modes. */
2316 convert_to_key_event (Win32Msg
*msgp
, KEY_EVENT_RECORD
*eventp
)
2318 eventp
->bKeyDown
= TRUE
;
2319 eventp
->wRepeatCount
= 1;
2320 eventp
->wVirtualKeyCode
= msgp
->msg
.wParam
;
2321 eventp
->wVirtualScanCode
= (msgp
->msg
.lParam
& 0xFF0000) >> 16;
2322 eventp
->uChar
.AsciiChar
= 0;
2323 eventp
->dwControlKeyState
= msgp
->dwModifiers
;
2326 /* Return nonzero if the virtual key is a dead key. */
2329 is_dead_key (int wparam
)
2331 unsigned int code
= MapVirtualKey (wparam
, 2);
2333 /* Win95 returns 0x8000, NT returns 0x80000000. */
2334 if ((code
& 0x8000) || (code
& 0x80000000))
2340 /* Read events coming from the Win32 shell.
2341 This routine is called by the SIGIO handler.
2342 We return as soon as there are no more events to be read.
2344 Events representing keys are stored in buffer BUFP,
2345 which can hold up to NUMCHARS characters.
2346 We return the number of characters stored into the buffer,
2347 thus pretending to be `read'.
2349 WAITP is nonzero if we should block until input arrives.
2350 EXPECTED is nonzero if the caller knows input is available.
2352 Some of these messages are reposted back to the message queue since the
2353 system calls the winproc directly in a context where we cannot return the
2354 data nor can we guarantee the state we are in. So if we dispatch them
2355 we will get into an infinite loop. To prevent this from ever happening we
2356 will set a variable to indicate we are in the read_socket call and indicate
2357 which message we are processing since the winproc gets called recursively with different
2358 messages by the system.
2362 w32_read_socket (sd
, bufp
, numchars
, waitp
, expected
)
2364 register struct input_event
*bufp
;
2365 register int numchars
;
2371 int items_pending
; /* How many items are in the X queue. */
2374 int event_found
= 0;
2377 struct win32_display_info
*dpyinfo
= &one_win32_display_info
;
2379 if (interrupt_input_blocked
)
2381 interrupt_input_pending
= 1;
2385 interrupt_input_pending
= 0;
2388 /* So people can tell when we have read the available input. */
2389 input_signal_count
++;
2392 abort (); /* Don't think this happens. */
2394 while (get_next_msg (&msg
, FALSE
))
2396 switch (msg
.msg
.message
)
2400 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2404 if (f
->async_visible
== 0)
2406 f
->async_visible
= 1;
2407 f
->async_iconified
= 0;
2408 SET_FRAME_GARBAGED (f
);
2412 /* Erase background again for safety. */
2413 win32_clear_rect (f
, NULL
, &msg
.rect
);
2417 msg
.rect
.right
-msg
.rect
.left
+1,
2418 msg
.rect
.bottom
-msg
.rect
.top
+1);
2425 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2427 if (f
&& !f
->iconified
)
2429 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
2431 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
2432 bufp
->kind
= non_ascii_keystroke
;
2433 bufp
->code
= msg
.msg
.wParam
;
2434 bufp
->modifiers
= win32_kbd_mods_to_emacs (msg
.dwModifiers
);
2435 XSETFRAME (bufp
->frame_or_window
, f
);
2436 bufp
->timestamp
= msg
.msg
.time
;
2444 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2446 if (f
&& !f
->iconified
)
2451 KEY_EVENT_RECORD key
, *keyp
= &key
;
2453 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
2456 convert_to_key_event (&msg
, keyp
);
2457 add
= key_event (keyp
, bufp
);
2458 XSETFRAME (bufp
->frame_or_window
, f
);
2461 /* The key pressed generated two characters, most likely
2462 an accent character and a key that could not be
2463 combined with it. Prepend the message on the queue
2464 again to process the second character (which is
2465 being held internally in key_event), and process
2466 the first character now. */
2471 /* Throw dead keys away. However, be sure not to
2472 throw away the dead key if it was produced using
2473 AltGr and there is a valid AltGr scan code for
2475 if (is_dead_key (msg
.msg
.wParam
)
2476 && !((VkKeyScan ((char) bufp
->code
) & 0xff00) == 0x600))
2490 if (dpyinfo
->grabbed
&& last_mouse_frame
2491 && FRAME_LIVE_P (last_mouse_frame
))
2492 f
= last_mouse_frame
;
2494 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2497 note_mouse_movement (f
, &msg
.msg
);
2499 clear_mouse_face (FRAME_WIN32_DISPLAY_INFO (f
));
2502 case WM_LBUTTONDOWN
:
2504 case WM_MBUTTONDOWN
:
2506 case WM_RBUTTONDOWN
:
2512 if (dpyinfo
->grabbed
&& last_mouse_frame
2513 && FRAME_LIVE_P (last_mouse_frame
))
2514 f
= last_mouse_frame
;
2516 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2520 if ((!dpyinfo
->win32_focus_frame
|| f
== dpyinfo
->win32_focus_frame
)
2523 construct_mouse_click (bufp
, &msg
, f
);
2530 parse_button (msg
.msg
.message
, &button
, &up
);
2534 dpyinfo
->grabbed
&= ~ (1 << button
);
2538 dpyinfo
->grabbed
|= (1 << button
);
2539 last_mouse_frame
= f
;
2546 struct scroll_bar
*bar
= x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
2548 if (bar
&& numchars
>= 1)
2550 if (x_scroll_bar_handle_click (bar
, &msg
, bufp
))
2561 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2563 if (f
&& !f
->async_iconified
)
2565 f
->output_data
.win32
->left_pos
= LOWORD (msg
.msg
.lParam
);
2566 f
->output_data
.win32
->top_pos
= HIWORD (msg
.msg
.lParam
);
2571 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2573 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
2581 GetClientRect(msg
.msg
.hwnd
, &rect
);
2583 height
= rect
.bottom
- rect
.top
+ 1;
2584 width
= rect
.right
- rect
.left
+ 1;
2586 rows
= PIXEL_TO_CHAR_HEIGHT (f
, height
);
2587 columns
= PIXEL_TO_CHAR_WIDTH (f
, width
);
2589 /* Even if the number of character rows and columns has
2590 not changed, the font size may have changed, so we need
2591 to check the pixel dimensions as well. */
2593 if (columns
!= f
->width
2594 || rows
!= f
->height
2595 || width
!= f
->output_data
.win32
->pixel_width
2596 || height
!= f
->output_data
.win32
->pixel_height
)
2598 /* I had set this to 0, 0 - I am not sure why?? */
2600 change_frame_size (f
, rows
, columns
, 0, 1);
2601 SET_FRAME_GARBAGED (f
);
2603 f
->output_data
.win32
->pixel_width
= width
;
2604 f
->output_data
.win32
->pixel_height
= height
;
2605 f
->output_data
.win32
->win_gravity
= NorthWestGravity
;
2612 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2614 if (msg
.msg
.message
== WM_SETFOCUS
)
2616 x_new_focus_frame (dpyinfo
, f
);
2618 else if (f
== dpyinfo
->win32_focus_frame
)
2619 x_new_focus_frame (dpyinfo
, 0);
2623 switch (msg
.msg
.wParam
& 0xfff0) /* Lower 4 bits used by Windows. */
2626 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2633 bufp
->kind
= delete_window_event
;
2634 XSETFRAME (bufp
->frame_or_window
, f
);
2642 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2646 f
->async_visible
= 1;
2647 f
->async_iconified
= 1;
2649 bufp
->kind
= iconify_event
;
2650 XSETFRAME (bufp
->frame_or_window
, f
);
2659 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2663 f
->async_visible
= 1;
2664 f
->async_iconified
= 0;
2666 /* wait_reading_process_input will notice this and update
2667 the frame's display structures. */
2668 SET_FRAME_GARBAGED (f
);
2672 bufp
->kind
= deiconify_event
;
2673 XSETFRAME (bufp
->frame_or_window
, f
);
2679 /* Force a redisplay sooner or later
2680 to update the frame titles
2681 in case this is the second frame. */
2682 record_asynch_buffer_change ();
2690 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2697 bufp
->kind
= delete_window_event
;
2698 XSETFRAME (bufp
->frame_or_window
, f
);
2706 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2710 if (msg
.msg
.lParam
== 0)
2712 /* Came from window menu */
2714 extern Lisp_Object
get_frame_menubar_event ();
2715 Lisp_Object event
= get_frame_menubar_event (f
, msg
.msg
.wParam
);
2716 struct input_event buf
;
2719 XSETFRAME (frame
, f
);
2720 buf
.kind
= menu_bar_event
;
2722 /* Store initial menu bar event */
2726 buf
.frame_or_window
= Fcons (frame
, Fcons (Qmenu_bar
, Qnil
));
2727 kbd_buffer_store_event (&buf
);
2730 /* Enqueue the events */
2732 while (!NILP (event
))
2734 buf
.frame_or_window
= Fcons (frame
, XCONS (event
)->car
);
2735 kbd_buffer_store_event (&buf
);
2736 event
= XCONS (event
)->cdr
;
2741 /* Came from popup menu */
2748 /* If the focus was just given to an autoraising frame,
2750 /* ??? This ought to be able to handle more than one such frame. */
2751 if (pending_autoraise_frame
)
2753 x_raise_frame (pending_autoraise_frame
);
2754 pending_autoraise_frame
= 0;
2761 /* Drawing the cursor. */
2764 /* Draw a hollow box cursor. Don't change the inside of the box. */
2774 hdc
= get_frame_dc (f
);
2776 hb
= CreateSolidBrush (f
->output_data
.win32
->cursor_pixel
);
2778 rect
.left
= CHAR_TO_PIXEL_COL (f
, curs_x
);
2779 rect
.top
= CHAR_TO_PIXEL_ROW (f
, curs_y
);
2780 rect
.right
= rect
.left
+ FONT_WIDTH (f
->output_data
.win32
->font
);
2781 rect
.bottom
= rect
.top
+ f
->output_data
.win32
->line_height
;
2783 FrameRect (hdc
, &rect
, hb
);
2786 release_frame_dc (f
, hdc
);
2789 /* Clear the cursor of frame F to background color,
2790 and mark the cursor as not shown.
2791 This is used when the text where the cursor is
2792 is about to be rewritten. */
2798 if (! FRAME_VISIBLE_P (f
)
2799 || f
->phys_cursor_x
< 0)
2802 x_display_cursor (f
, 0);
2803 f
->phys_cursor_x
= -1;
2806 /* Redraw the glyph at ROW, COLUMN on frame F, in the style
2807 HIGHLIGHT. HIGHLIGHT is as defined for dumpglyphs. Return the
2811 x_draw_single_glyph (f
, row
, column
, glyph
, highlight
)
2818 CHAR_TO_PIXEL_COL (f
, column
),
2819 CHAR_TO_PIXEL_ROW (f
, row
),
2820 &glyph
, 1, highlight
, 0);
2824 x_display_bar_cursor (f
, on
)
2828 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
2830 /* This is pointless on invisible frames, and dangerous on garbaged
2831 frames; in the latter case, the frame may be in the midst of
2832 changing its size, and curs_x and curs_y may be off the frame. */
2833 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
2836 if (! on
&& f
->phys_cursor_x
< 0)
2839 /* If we're not updating, then we want to use the current frame's
2840 cursor position, not our local idea of where the cursor ought to be. */
2841 if (f
!= updating_frame
)
2843 curs_x
= FRAME_CURSOR_X (f
);
2844 curs_y
= FRAME_CURSOR_Y (f
);
2847 /* If there is anything wrong with the current cursor state, remove it. */
2848 if (f
->phys_cursor_x
>= 0
2850 || f
->phys_cursor_x
!= curs_x
2851 || f
->phys_cursor_y
!= curs_y
2852 || f
->output_data
.win32
->current_cursor
!= bar_cursor
))
2854 /* Erase the cursor by redrawing the character underneath it. */
2855 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
2856 f
->phys_cursor_glyph
,
2857 current_glyphs
->highlight
[f
->phys_cursor_y
]);
2858 f
->phys_cursor_x
= -1;
2861 /* If we now need a cursor in the new place or in the new form, do it so. */
2863 && (f
->phys_cursor_x
< 0
2864 || (f
->output_data
.win32
->current_cursor
!= bar_cursor
)))
2866 f
->phys_cursor_glyph
2867 = ((current_glyphs
->enable
[curs_y
]
2868 && curs_x
< current_glyphs
->used
[curs_y
])
2869 ? current_glyphs
->glyphs
[curs_y
][curs_x
]
2871 win32_fill_area (f
, NULL
, f
->output_data
.win32
->cursor_pixel
,
2872 CHAR_TO_PIXEL_COL (f
, curs_x
),
2873 CHAR_TO_PIXEL_ROW (f
, curs_y
),
2874 max (f
->output_data
.win32
->cursor_width
, 1),
2875 f
->output_data
.win32
->line_height
);
2877 f
->phys_cursor_x
= curs_x
;
2878 f
->phys_cursor_y
= curs_y
;
2880 f
->output_data
.win32
->current_cursor
= bar_cursor
;
2885 /* Turn the displayed cursor of frame F on or off according to ON.
2886 If ON is nonzero, where to put the cursor is specified
2887 by F->cursor_x and F->cursor_y. */
2890 x_display_box_cursor (f
, on
)
2894 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
2896 /* This is pointless on invisible frames, and dangerous on garbaged
2897 frames; in the latter case, the frame may be in the midst of
2898 changing its size, and curs_x and curs_y may be off the frame. */
2899 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
2902 /* If cursor is off and we want it off, return quickly. */
2903 if (!on
&& f
->phys_cursor_x
< 0)
2906 /* If we're not updating, then we want to use the current frame's
2907 cursor position, not our local idea of where the cursor ought to be. */
2908 if (f
!= updating_frame
)
2910 curs_x
= FRAME_CURSOR_X (f
);
2911 curs_y
= FRAME_CURSOR_Y (f
);
2914 /* If cursor is currently being shown and we don't want it to be
2915 or it is in the wrong place,
2916 or we want a hollow box and it's not so, (pout!)
2918 if (f
->phys_cursor_x
>= 0
2920 || f
->phys_cursor_x
!= curs_x
2921 || f
->phys_cursor_y
!= curs_y
2922 || (f
->output_data
.win32
->current_cursor
!= hollow_box_cursor
2923 && (f
!= FRAME_WIN32_DISPLAY_INFO (f
)->win32_highlight_frame
))))
2925 int mouse_face_here
= 0;
2926 struct frame_glyphs
*active_glyphs
= FRAME_CURRENT_GLYPHS (f
);
2928 /* If the cursor is in the mouse face area, redisplay that when
2929 we clear the cursor. */
2930 if (f
== FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
2932 (f
->phys_cursor_y
> FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_row
2933 || (f
->phys_cursor_y
== FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_row
2934 && f
->phys_cursor_x
>= FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_beg_col
))
2936 (f
->phys_cursor_y
< FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_row
2937 || (f
->phys_cursor_y
== FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_row
2938 && f
->phys_cursor_x
< FRAME_WIN32_DISPLAY_INFO (f
)->mouse_face_end_col
))
2939 /* Don't redraw the cursor's spot in mouse face
2940 if it is at the end of a line (on a newline).
2941 The cursor appears there, but mouse highlighting does not. */
2942 && active_glyphs
->used
[f
->phys_cursor_y
] > f
->phys_cursor_x
)
2943 mouse_face_here
= 1;
2945 /* If the font is not as tall as a whole line,
2946 we must explicitly clear the line's whole height. */
2947 if (FONT_HEIGHT (f
->output_data
.win32
->font
) != f
->output_data
.win32
->line_height
)
2948 win32_clear_area (f
, NULL
,
2949 CHAR_TO_PIXEL_COL (f
, f
->phys_cursor_x
),
2950 CHAR_TO_PIXEL_ROW (f
, f
->phys_cursor_y
),
2951 FONT_WIDTH (f
->output_data
.win32
->font
),
2952 f
->output_data
.win32
->line_height
);
2953 /* Erase the cursor by redrawing the character underneath it. */
2954 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
2955 f
->phys_cursor_glyph
,
2958 : current_glyphs
->highlight
[f
->phys_cursor_y
]));
2959 f
->phys_cursor_x
= -1;
2962 /* If we want to show a cursor,
2963 or we want a box cursor and it's not so,
2964 write it in the right place. */
2966 && (f
->phys_cursor_x
< 0
2967 || (f
->output_data
.win32
->current_cursor
!= filled_box_cursor
2968 && f
== FRAME_WIN32_DISPLAY_INFO (f
)->win32_highlight_frame
)))
2970 f
->phys_cursor_glyph
2971 = ((current_glyphs
->enable
[curs_y
]
2972 && curs_x
< current_glyphs
->used
[curs_y
])
2973 ? current_glyphs
->glyphs
[curs_y
][curs_x
]
2975 if (f
!= FRAME_WIN32_DISPLAY_INFO (f
)->win32_highlight_frame
)
2978 f
->output_data
.win32
->current_cursor
= hollow_box_cursor
;
2982 x_draw_single_glyph (f
, curs_y
, curs_x
,
2983 f
->phys_cursor_glyph
, 2);
2984 f
->output_data
.win32
->current_cursor
= filled_box_cursor
;
2987 f
->phys_cursor_x
= curs_x
;
2988 f
->phys_cursor_y
= curs_y
;
2992 x_display_cursor (f
, on
)
2998 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
2999 x_display_box_cursor (f
, on
);
3000 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
3001 x_display_bar_cursor (f
, on
);
3003 /* Those are the only two we have implemented! */
3009 /* Changing the font of the frame. */
3011 /* Give frame F the font named FONTNAME as its default font, and
3012 return the full name of that font. FONTNAME may be a wildcard
3013 pattern; in that case, we choose some font that fits the pattern.
3014 The return value shows which font we chose. */
3017 x_new_font (f
, fontname
)
3019 register char *fontname
;
3022 int n_matching_fonts
;
3023 XFontStruct
*font_info
;
3024 char new_font_name
[101];
3026 /* Get a font which matches this name */
3030 if (!x_to_win32_font(fontname
, &lf
)
3031 || !win32_to_x_font(&lf
, new_font_name
, 100))
3037 /* See if we've already loaded a matching font. */
3038 already_loaded
= -1;
3043 for (i
= 0; i
< FRAME_WIN32_DISPLAY_INFO (f
)->n_fonts
; i
++)
3044 if (!strcmp (FRAME_WIN32_DISPLAY_INFO (f
)->font_table
[i
].name
, new_font_name
))
3047 fontname
= FRAME_WIN32_DISPLAY_INFO (f
)->font_table
[i
].name
;
3052 /* If we have, just return it from the table. */
3053 if (already_loaded
>= 0)
3054 f
->output_data
.win32
->font
= FRAME_WIN32_DISPLAY_INFO (f
)->font_table
[already_loaded
].font
;
3055 /* Otherwise, load the font and add it to the table. */
3061 font
= win32_load_font(FRAME_WIN32_DISPLAY_INFO (f
), fontname
);
3068 /* Do we need to create the table? */
3069 if (FRAME_WIN32_DISPLAY_INFO (f
)->font_table_size
== 0)
3071 FRAME_WIN32_DISPLAY_INFO (f
)->font_table_size
= 16;
3072 FRAME_WIN32_DISPLAY_INFO (f
)->font_table
3073 = (struct font_info
*) xmalloc (FRAME_WIN32_DISPLAY_INFO (f
)->font_table_size
3074 * sizeof (struct font_info
));
3076 /* Do we need to grow the table? */
3077 else if (FRAME_WIN32_DISPLAY_INFO (f
)->n_fonts
3078 >= FRAME_WIN32_DISPLAY_INFO (f
)->font_table_size
)
3080 FRAME_WIN32_DISPLAY_INFO (f
)->font_table_size
*= 2;
3081 FRAME_WIN32_DISPLAY_INFO (f
)->font_table
3082 = (struct font_info
*) xrealloc (FRAME_WIN32_DISPLAY_INFO (f
)->font_table
,
3083 (FRAME_WIN32_DISPLAY_INFO (f
)->font_table_size
3084 * sizeof (struct font_info
)));
3087 n_fonts
= FRAME_WIN32_DISPLAY_INFO (f
)->n_fonts
;
3088 FRAME_WIN32_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
= (char *) xmalloc (strlen (fontname
) + 1);
3089 bcopy (fontname
, FRAME_WIN32_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
, strlen (fontname
) + 1);
3090 f
->output_data
.win32
->font
= FRAME_WIN32_DISPLAY_INFO (f
)->font_table
[n_fonts
].font
= font
;
3091 FRAME_WIN32_DISPLAY_INFO (f
)->n_fonts
++;
3094 /* Compute the scroll bar width in character columns. */
3095 if (f
->scroll_bar_pixel_width
> 0)
3097 int wid
= FONT_WIDTH (f
->output_data
.win32
->font
);
3098 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
3101 f
->scroll_bar_cols
= 2;
3103 /* Now make the frame display the given font. */
3104 if (FRAME_WIN32_WINDOW (f
) != 0)
3106 frame_update_line_height (f
);
3107 x_set_window_size (f
, 0, f
->width
, f
->height
);
3110 /* If we are setting a new frame's font for the first time,
3111 there are no faces yet, so this font's height is the line height. */
3112 f
->output_data
.win32
->line_height
= FONT_HEIGHT (f
->output_data
.win32
->font
);
3115 Lisp_Object lispy_name
;
3117 lispy_name
= build_string (fontname
);
3123 x_calc_absolute_position (f
)
3128 int flags
= f
->output_data
.win32
->size_hint_flags
;
3132 /* Find the position of the outside upper-left corner of
3133 the inner window, with respect to the outer window. */
3134 if (f
->output_data
.win32
->parent_desc
!= FRAME_WIN32_DISPLAY_INFO (f
)->root_window
)
3137 MapWindowPoints (FRAME_WIN32_WINDOW (f
),
3138 f
->output_data
.win32
->parent_desc
,
3145 rt
.left
= rt
.right
= rt
.top
= rt
.bottom
= 0;
3148 AdjustWindowRect(&rt
, f
->output_data
.win32
->dwStyle
,
3149 FRAME_EXTERNAL_MENU_BAR (f
));
3152 pt
.x
+= (rt
.right
- rt
.left
);
3153 pt
.y
+= (rt
.bottom
- rt
.top
);
3156 /* Treat negative positions as relative to the leftmost bottommost
3157 position that fits on the screen. */
3158 if (flags
& XNegative
)
3159 f
->output_data
.win32
->left_pos
= (FRAME_WIN32_DISPLAY_INFO (f
)->width
3160 - 2 * f
->output_data
.win32
->border_width
- pt
.x
3162 + f
->output_data
.win32
->left_pos
);
3164 if (flags
& YNegative
)
3165 f
->output_data
.win32
->top_pos
= (FRAME_WIN32_DISPLAY_INFO (f
)->height
3166 - 2 * f
->output_data
.win32
->border_width
- pt
.y
3168 + f
->output_data
.win32
->top_pos
);
3169 /* The left_pos and top_pos
3170 are now relative to the top and left screen edges,
3171 so the flags should correspond. */
3172 f
->output_data
.win32
->size_hint_flags
&= ~ (XNegative
| YNegative
);
3175 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
3176 to really change the position, and 0 when calling from
3177 x_make_frame_visible (in that case, XOFF and YOFF are the current
3178 position values). It is -1 when calling from x_set_frame_parameters,
3179 which means, do adjust for borders but don't change the gravity. */
3181 x_set_offset (f
, xoff
, yoff
, change_gravity
)
3183 register int xoff
, yoff
;
3186 int modified_top
, modified_left
;
3188 if (change_gravity
> 0)
3190 f
->output_data
.win32
->top_pos
= yoff
;
3191 f
->output_data
.win32
->left_pos
= xoff
;
3192 f
->output_data
.win32
->size_hint_flags
&= ~ (XNegative
| YNegative
);
3194 f
->output_data
.win32
->size_hint_flags
|= XNegative
;
3196 f
->output_data
.win32
->size_hint_flags
|= YNegative
;
3197 f
->output_data
.win32
->win_gravity
= NorthWestGravity
;
3199 x_calc_absolute_position (f
);
3202 x_wm_set_size_hint (f
, (long) 0, 0);
3204 /* It is a mystery why we need to add the border_width here
3205 when the frame is already visible, but experiment says we do. */
3206 modified_left
= f
->output_data
.win32
->left_pos
;
3207 modified_top
= f
->output_data
.win32
->top_pos
;
3208 if (change_gravity
!= 0)
3210 modified_left
+= f
->output_data
.win32
->border_width
;
3211 modified_top
+= f
->output_data
.win32
->border_width
;
3214 my_set_window_pos (FRAME_WIN32_WINDOW (f
),
3216 modified_left
, modified_top
,
3218 SWP_NOZORDER
| SWP_NOSIZE
);
3222 /* Call this to change the size of frame F's x-window.
3223 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
3224 for this size change and subsequent size changes.
3225 Otherwise we leave the window gravity unchanged. */
3227 x_set_window_size (f
, change_gravity
, cols
, rows
)
3232 int pixelwidth
, pixelheight
;
3236 check_frame_size (f
, &rows
, &cols
);
3237 f
->output_data
.win32
->vertical_scroll_bar_extra
3238 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
3240 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
3241 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
3242 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.win32
->font
)));
3243 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
3244 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
3246 f
->output_data
.win32
->win_gravity
= NorthWestGravity
;
3247 x_wm_set_size_hint (f
, (long) 0, 0);
3252 rect
.left
= rect
.top
= 0;
3253 rect
.right
= pixelwidth
;
3254 rect
.bottom
= pixelheight
;
3256 AdjustWindowRect(&rect
, f
->output_data
.win32
->dwStyle
,
3257 FRAME_EXTERNAL_MENU_BAR (f
));
3259 /* All windows have an extra pixel */
3261 my_set_window_pos (FRAME_WIN32_WINDOW (f
),
3264 rect
.right
- rect
.left
+ 1,
3265 rect
.bottom
- rect
.top
+ 1,
3266 SWP_NOZORDER
| SWP_NOMOVE
);
3269 /* Now, strictly speaking, we can't be sure that this is accurate,
3270 but the window manager will get around to dealing with the size
3271 change request eventually, and we'll hear how it went when the
3272 ConfigureNotify event gets here.
3274 We could just not bother storing any of this information here,
3275 and let the ConfigureNotify event set everything up, but that
3276 might be kind of confusing to the lisp code, since size changes
3277 wouldn't be reported in the frame parameters until some random
3278 point in the future when the ConfigureNotify event arrives. */
3279 change_frame_size (f
, rows
, cols
, 0, 0);
3280 PIXEL_WIDTH (f
) = pixelwidth
;
3281 PIXEL_HEIGHT (f
) = pixelheight
;
3283 /* If cursor was outside the new size, mark it as off. */
3284 if (f
->phys_cursor_y
>= rows
3285 || f
->phys_cursor_x
>= cols
)
3287 f
->phys_cursor_x
= -1;
3288 f
->phys_cursor_y
= -1;
3291 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
3292 receive in the ConfigureNotify event; if we get what we asked
3293 for, then the event won't cause the screen to become garbaged, so
3294 we have to make sure to do it here. */
3295 SET_FRAME_GARBAGED (f
);
3300 /* Mouse warping. */
3303 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
3309 pix_x
+= f
->output_data
.win32
->left_pos
;
3310 pix_y
+= f
->output_data
.win32
->top_pos
;
3312 SetCursorPos (pix_x
, pix_y
);
3318 x_set_mouse_position (f
, x
, y
)
3324 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.win32
->font
) / 2;
3325 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.win32
->line_height
/ 2;
3327 if (pix_x
< 0) pix_x
= 0;
3328 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
3330 if (pix_y
< 0) pix_y
= 0;
3331 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
3333 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
3336 /* focus shifting, raising and lowering. */
3338 x_focus_on_frame (f
)
3348 /* Raise frame F. */
3353 // if (f->async_visible)
3356 my_set_window_pos (FRAME_WIN32_WINDOW (f
),
3359 SWP_NOSIZE
| SWP_NOMOVE
);
3364 /* Lower frame F. */
3369 // if (f->async_visible)
3372 my_set_window_pos (FRAME_WIN32_WINDOW (f
),
3375 SWP_NOSIZE
| SWP_NOMOVE
);
3381 win32_frame_raise_lower (f
, raise
)
3391 /* Change of visibility. */
3393 /* This tries to wait until the frame is really visible.
3394 However, if the window manager asks the user where to position
3395 the frame, this will return before the user finishes doing that.
3396 The frame will not actually be visible at that time,
3397 but it will become visible later when the window manager
3398 finishes with it. */
3400 x_make_frame_visible (f
)
3405 if (! FRAME_VISIBLE_P (f
))
3407 /* We test FRAME_GARBAGED_P here to make sure we don't
3408 call x_set_offset a second time
3409 if we get to x_make_frame_visible a second time
3410 before the window gets really visible. */
3411 if (! FRAME_ICONIFIED_P (f
)
3412 && ! f
->output_data
.win32
->asked_for_visible
)
3414 x_set_offset (f
, f
->output_data
.win32
->left_pos
, f
->output_data
.win32
->top_pos
, 0);
3415 // SetForegroundWindow (FRAME_WIN32_WINDOW (f));
3418 f
->output_data
.win32
->asked_for_visible
= 1;
3420 my_show_window (FRAME_WIN32_WINDOW (f
), SW_SHOWNORMAL
);
3423 /* Synchronize to ensure Emacs knows the frame is visible
3424 before we do anything else. We do this loop with input not blocked
3425 so that incoming events are handled. */
3428 int count
= input_signal_count
;
3430 /* This must come after we set COUNT. */
3433 XSETFRAME (frame
, f
);
3437 /* Once we have handled input events,
3438 we should have received the MapNotify if one is coming.
3439 So if we have not got it yet, stop looping.
3440 Some window managers make their own decisions
3441 about visibility. */
3442 if (input_signal_count
!= count
)
3444 /* Machines that do polling rather than SIGIO have been observed
3445 to go into a busy-wait here. So we'll fake an alarm signal
3446 to let the handler know that there's something to be read.
3447 We used to raise a real alarm, but it seems that the handler
3448 isn't always enabled here. This is probably a bug. */
3449 if (input_polling_used ())
3451 /* It could be confusing if a real alarm arrives while processing
3452 the fake one. Turn it off and let the handler reset it. */
3454 input_poll_signal ();
3456 /* Once we have handled input events,
3457 we should have received the MapNotify if one is coming.
3458 So if we have not got it yet, stop looping.
3459 Some window managers make their own decisions
3460 about visibility. */
3461 if (input_signal_count
!= count
)
3464 FRAME_SAMPLE_VISIBILITY (f
);
3468 /* Change from mapped state to withdrawn state. */
3470 /* Make the frame visible (mapped and not iconified). */
3472 x_make_frame_invisible (f
)
3477 /* Don't keep the highlight on an invisible frame. */
3478 if (FRAME_WIN32_DISPLAY_INFO (f
)->win32_highlight_frame
== f
)
3479 FRAME_WIN32_DISPLAY_INFO (f
)->win32_highlight_frame
= 0;
3483 my_show_window (FRAME_WIN32_WINDOW (f
), SW_HIDE
);
3485 /* We can't distinguish this from iconification
3486 just by the event that we get from the server.
3487 So we can't win using the usual strategy of letting
3488 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
3489 and synchronize with the server to make sure we agree. */
3491 FRAME_ICONIFIED_P (f
) = 0;
3492 f
->async_visible
= 0;
3493 f
->async_iconified
= 0;
3498 /* Change window state from mapped to iconified. */
3506 /* Don't keep the highlight on an invisible frame. */
3507 if (FRAME_WIN32_DISPLAY_INFO (f
)->win32_highlight_frame
== f
)
3508 FRAME_WIN32_DISPLAY_INFO (f
)->win32_highlight_frame
= 0;
3510 if (f
->async_iconified
)
3515 my_show_window (FRAME_WIN32_WINDOW (f
), SW_SHOWMINIMIZED
);
3516 /* The frame doesn't seem to be lowered automatically. */
3519 f
->async_iconified
= 1;
3524 /* Destroy the window of frame F. */
3526 x_destroy_window (f
)
3529 struct win32_display_info
*dpyinfo
= FRAME_WIN32_DISPLAY_INFO (f
);
3533 my_destroy_window (f
, FRAME_WIN32_WINDOW (f
));
3534 free_frame_menubar (f
);
3535 free_frame_faces (f
);
3537 xfree (f
->output_data
.win32
);
3538 f
->output_data
.win32
= 0;
3539 if (f
== dpyinfo
->win32_focus_frame
)
3540 dpyinfo
->win32_focus_frame
= 0;
3541 if (f
== dpyinfo
->win32_focus_event_frame
)
3542 dpyinfo
->win32_focus_event_frame
= 0;
3543 if (f
== dpyinfo
->win32_highlight_frame
)
3544 dpyinfo
->win32_highlight_frame
= 0;
3546 dpyinfo
->reference_count
--;
3548 if (f
== dpyinfo
->mouse_face_mouse_frame
)
3550 dpyinfo
->mouse_face_beg_row
3551 = dpyinfo
->mouse_face_beg_col
= -1;
3552 dpyinfo
->mouse_face_end_row
3553 = dpyinfo
->mouse_face_end_col
= -1;
3554 dpyinfo
->mouse_face_window
= Qnil
;
3560 /* Setting window manager hints. */
3562 /* Set the normal size hints for the window manager, for frame F.
3563 FLAGS is the flags word to use--or 0 meaning preserve the flags
3564 that the window now has.
3565 If USER_POSITION is nonzero, we set the USPosition
3566 flag (this is useful when FLAGS is 0). */
3568 x_wm_set_size_hint (f
, flags
, user_position
)
3573 Window window
= FRAME_WIN32_WINDOW (f
);
3575 flexlines
= f
->height
;
3579 SetWindowLong (window
, WND_X_UNITS_INDEX
, FONT_WIDTH (f
->output_data
.win32
->font
));
3580 SetWindowLong (window
, WND_Y_UNITS_INDEX
, f
->output_data
.win32
->line_height
);
3585 /* Window manager things */
3586 x_wm_set_icon_position (f
, icon_x
, icon_y
)
3591 Window window
= FRAME_WIN32_WINDOW (f
);
3593 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
3594 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
3595 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
3597 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
3602 /* Initialization. */
3604 #ifdef USE_X_TOOLKIT
3605 static XrmOptionDescRec emacs_options
[] = {
3606 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
3607 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
3609 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
3610 XrmoptionSepArg
, NULL
},
3611 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
3613 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
3614 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
3615 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
3616 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
3617 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
3618 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
3619 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
3621 #endif /* USE_X_TOOLKIT */
3623 static int win32_initialized
= 0;
3625 struct win32_display_info
*
3626 win32_term_init (display_name
, xrm_option
, resource_name
)
3627 Lisp_Object display_name
;
3629 char *resource_name
;
3633 struct win32_display_info
*dpyinfo
;
3638 if (!win32_initialized
)
3640 win32_initialize ();
3641 win32_initialized
= 1;
3652 argv
[argc
++] = "-xrm";
3653 argv
[argc
++] = xrm_option
;
3657 dpyinfo
= &one_win32_display_info
;
3659 /* Put this display on the chain. */
3660 dpyinfo
->next
= NULL
;
3662 /* Put it on win32_display_name_list as well, to keep them parallel. */
3663 win32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
3664 win32_display_name_list
);
3665 dpyinfo
->name_list_element
= XCONS (win32_display_name_list
)->car
;
3667 dpyinfo
->win32_id_name
3668 = (char *) xmalloc (XSTRING (Vinvocation_name
)->size
3669 + XSTRING (Vsystem_name
)->size
3671 sprintf (dpyinfo
->win32_id_name
, "%s@%s",
3672 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
3675 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
3676 resource_name
, EMACS_CLASS
);
3678 /* Put the rdb where we can find it in a way that works on
3680 dpyinfo
->xrdb
= xrdb
;
3682 hdc
= GetDC (GetDesktopWindow ());
3684 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
3685 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
3686 dpyinfo
->root_window
= GetDesktopWindow ();
3687 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
3688 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
3689 dpyinfo
->height_in
= GetDeviceCaps (hdc
, LOGPIXELSX
);
3690 dpyinfo
->width_in
= GetDeviceCaps (hdc
, LOGPIXELSY
);
3691 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
3692 dpyinfo
->grabbed
= 0;
3693 dpyinfo
->reference_count
= 0;
3694 dpyinfo
->n_fonts
= 0;
3695 dpyinfo
->font_table_size
= 0;
3696 dpyinfo
->bitmaps
= 0;
3697 dpyinfo
->bitmaps_size
= 0;
3698 dpyinfo
->bitmaps_last
= 0;
3699 dpyinfo
->mouse_face_mouse_frame
= 0;
3700 dpyinfo
->mouse_face_deferred_gc
= 0;
3701 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
3702 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
3703 dpyinfo
->mouse_face_face_id
= 0;
3704 dpyinfo
->mouse_face_window
= Qnil
;
3705 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
3706 dpyinfo
->mouse_face_defer
= 0;
3707 dpyinfo
->win32_focus_frame
= 0;
3708 dpyinfo
->win32_focus_event_frame
= 0;
3709 dpyinfo
->win32_highlight_frame
= 0;
3711 ReleaseDC (GetDesktopWindow (), hdc
);
3713 /* Determine if there is a middle mouse button, to allow parse_button
3714 to decide whether right mouse events should be mouse-2 or
3716 XSETINT (Vwin32_num_mouse_buttons
, GetSystemMetrics (SM_CMOUSEBUTTONS
));
3718 /* initialise palette with white and black */
3721 defined_color (0, "white", &color
, 1);
3722 defined_color (0, "black", &color
, 1);
3725 #ifndef F_SETOWN_BUG
3727 #ifdef F_SETOWN_SOCK_NEG
3728 /* stdin is a socket here */
3729 fcntl (connection
, F_SETOWN
, -getpid ());
3730 #else /* ! defined (F_SETOWN_SOCK_NEG) */
3731 fcntl (connection
, F_SETOWN
, getpid ());
3732 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
3733 #endif /* ! defined (F_SETOWN) */
3734 #endif /* F_SETOWN_BUG */
3737 if (interrupt_input
)
3738 init_sigio (connection
);
3739 #endif /* ! defined (SIGIO) */
3746 /* Get rid of display DPYINFO, assuming all frames are already gone. */
3749 x_delete_display (dpyinfo
)
3750 struct win32_display_info
*dpyinfo
;
3752 /* Discard this display from win32_display_name_list and win32_display_list.
3753 We can't use Fdelq because that can quit. */
3754 if (! NILP (win32_display_name_list
)
3755 && EQ (XCONS (win32_display_name_list
)->car
, dpyinfo
->name_list_element
))
3756 win32_display_name_list
= XCONS (win32_display_name_list
)->cdr
;
3761 tail
= win32_display_name_list
;
3762 while (CONSP (tail
) && CONSP (XCONS (tail
)->cdr
))
3764 if (EQ (XCONS (XCONS (tail
)->cdr
)->car
,
3765 dpyinfo
->name_list_element
))
3767 XCONS (tail
)->cdr
= XCONS (XCONS (tail
)->cdr
)->cdr
;
3770 tail
= XCONS (tail
)->cdr
;
3774 /* free palette table */
3776 struct win32_palette_entry
* plist
;
3778 plist
= dpyinfo
->color_list
;
3781 struct win32_palette_entry
* pentry
= plist
;
3782 plist
= plist
->next
;
3785 dpyinfo
->color_list
= NULL
;
3786 if (dpyinfo
->palette
)
3787 DeleteObject(dpyinfo
->palette
);
3789 xfree (dpyinfo
->font_table
);
3790 xfree (dpyinfo
->win32_id_name
);
3793 /* Set up use of Win32. */
3795 DWORD
win_msg_worker ();
3799 clear_frame_hook
= win32_clear_frame
;
3800 clear_end_of_line_hook
= win32_clear_end_of_line
;
3801 ins_del_lines_hook
= win32_ins_del_lines
;
3802 change_line_highlight_hook
= win32_change_line_highlight
;
3803 insert_glyphs_hook
= win32_insert_glyphs
;
3804 write_glyphs_hook
= win32_write_glyphs
;
3805 delete_glyphs_hook
= win32_delete_glyphs
;
3806 ring_bell_hook
= win32_ring_bell
;
3807 reset_terminal_modes_hook
= win32_reset_terminal_modes
;
3808 set_terminal_modes_hook
= win32_set_terminal_modes
;
3809 update_begin_hook
= win32_update_begin
;
3810 update_end_hook
= win32_update_end
;
3811 set_terminal_window_hook
= win32_set_terminal_window
;
3812 read_socket_hook
= w32_read_socket
;
3813 frame_up_to_date_hook
= win32_frame_up_to_date
;
3814 cursor_to_hook
= win32_cursor_to
;
3815 reassert_line_highlight_hook
= win32_reassert_line_highlight
;
3816 mouse_position_hook
= win32_mouse_position
;
3817 frame_rehighlight_hook
= win32_frame_rehighlight
;
3818 frame_raise_lower_hook
= win32_frame_raise_lower
;
3819 set_vertical_scroll_bar_hook
= win32_set_vertical_scroll_bar
;
3820 condemn_scroll_bars_hook
= win32_condemn_scroll_bars
;
3821 redeem_scroll_bar_hook
= win32_redeem_scroll_bar
;
3822 judge_scroll_bars_hook
= win32_judge_scroll_bars
;
3824 scroll_region_ok
= 1; /* we'll scroll partial frames */
3825 char_ins_del_ok
= 0; /* just as fast to write the line */
3826 line_ins_del_ok
= 1; /* we'll just blt 'em */
3827 fast_clear_end_of_line
= 1; /* X does this well */
3828 memory_below_frame
= 0; /* we don't remember what scrolls
3832 /* Try to use interrupt input; if we can't, then start polling. */
3833 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
3835 /* Create the window thread - it will terminate itself or when the app terminates */
3839 dwMainThreadId
= GetCurrentThreadId ();
3840 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
3841 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
3843 /* Wait for thread to start */
3848 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
3850 hWinThread
= CreateThread (NULL
, 0,
3851 (LPTHREAD_START_ROUTINE
) win_msg_worker
,
3852 0, 0, &dwWinThreadId
);
3854 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3857 /* It is desirable that mainThread should have the same notion of
3858 focus window and active window as winThread. Unfortunately, the
3859 following call to AttachThreadInput, which should do precisely what
3860 we need, causes major problems when Emacs is linked as a console
3861 program. Unfortunately, we have good reasons for doing that, so
3862 instead we need to send messages to winThread to make some API
3863 calls for us (ones that affect, or depend on, the active/focus
3865 #ifdef ATTACH_THREADS
3866 AttachThreadInput (dwMainThreadId
, dwWinThreadId
, TRUE
);
3871 syms_of_win32term ()
3873 staticpro (&win32_display_name_list
);
3874 win32_display_name_list
= Qnil
;
3876 staticpro (&last_mouse_scroll_bar
);
3877 last_mouse_scroll_bar
= Qnil
;
3879 staticpro (&Qvendor_specific_keysyms
);
3880 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
3882 DEFVAR_INT ("win32-num-mouse-buttons",
3883 &Vwin32_num_mouse_buttons
,
3884 "Number of physical mouse buttons.");
3885 Vwin32_num_mouse_buttons
= Qnil
;
3887 DEFVAR_LISP ("win32-swap-mouse-buttons",
3888 &Vwin32_swap_mouse_buttons
,
3889 "Swap the mapping of middle and right mouse buttons.\n\
3890 When nil, middle button is mouse-2 and right button is mouse-3.");
3891 Vwin32_swap_mouse_buttons
= Qnil
;