1 /* Implementation of GUI terminal on the Microsoft W32 API.
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 w32 does not support multiple ones. */
60 struct w32_display_info one_w32_display_info
;
62 /* This is a list of cons cells, each of the form (NAME . FONT-LIST-CACHE),
63 one for each element of w32_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 w32_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 w32 functions. It is zero while not inside an update.
71 In that case, the w32 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 dwWindowsThreadId
= 0;
93 HANDLE hWindowsThread
= 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 Vw32_num_mouse_buttons
;
105 Lisp_Object Vw32_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 w32_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 w32_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 w32_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 w32_delete_display ();
146 static void redraw_previous_char ();
147 static void redraw_following_char ();
148 static unsigned int w32_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 w32_cursor_to ();
157 static int w32_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 w32_display_info. */
189 struct w32_display_info
*
190 w32_display_info_for_display ()
192 return (&one_w32_display_info
);
196 w32_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
);
228 GetClientRect (FRAME_W32_WINDOW (f
), &rect
);
229 w32_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 w32_... functions do not
238 need to take a frame as argument. Most of the w32_... functions
239 should never be called except during an update, the only exceptions
240 being w32_cursor_to, w32_write_glyphs and w32_reassert_line_highlight. */
249 flexlines
= f
->height
;
254 /* Regenerate display palette before drawing if list of requested
255 colors has changed. */
256 if (FRAME_W32_DISPLAY_INFO (f
)->regen_palette
)
258 w32_regenerate_palette (f
);
259 FRAME_W32_DISPLAY_INFO (f
)->regen_palette
= FALSE
;
262 if (f
== FRAME_W32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
264 /* Don't do highlighting for mouse motion during the update. */
265 FRAME_W32_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_W32_DISPLAY_INFO (f
)->mouse_face_window
= Qnil
;
272 if (!NILP (FRAME_W32_DISPLAY_INFO (f
)->mouse_face_window
))
274 int firstline
, lastline
, i
;
275 struct window
*w
= XWINDOW (FRAME_W32_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_W32_DISPLAY_INFO (f
));
312 x_display_cursor (f
, 1);
314 if (f
== FRAME_W32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
315 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
320 /* This is called after a redisplay on frame F. */
323 w32_frame_up_to_date (f
)
326 if (FRAME_W32_DISPLAY_INFO (f
)->mouse_face_deferred_gc
327 || f
== FRAME_W32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
)
329 note_mouse_highlight (FRAME_W32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
,
330 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_mouse_x
,
331 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_mouse_y
);
332 FRAME_W32_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 w32_reassert_line_highlight (new, vpos
)
346 /* Call this when about to modify line at position VPOS
347 and change whether it is highlighted. */
350 w32_change_line_highlight (new_highlight
, vpos
, first_unused_hpos
)
351 int new_highlight
, vpos
, first_unused_hpos
;
353 highlight
= new_highlight
;
354 w32_cursor_to (vpos
, 0);
355 w32_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 w32_set_terminal_modes ()
367 /* This is called when exiting or suspending Emacs.
368 Exiting will make the W32 windows go away, and suspending
369 requires no action. */
372 w32_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 w32_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_W32_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_W32_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
.w32
->font
)
514 && face
->background
== f
->output_data
.w32
->background_pixel
515 && face
->foreground
== f
->output_data
.w32
->foreground_pixel
)
517 bg
= f
->output_data
.w32
->cursor_pixel
;
518 fg
= face
->background
;
520 /* Cursor on non-default face: must merge. */
523 bg
= f
->output_data
.w32
->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
.w32
->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
.w32
->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
.w32
->line_height
!= FONT_HEIGHT (font
))
559 w32_fill_area (f
, hdc
, bg
,
561 top
+ FONT_HEIGHT (font
),
562 FONT_WIDTH (font
) * len
,
563 f
->output_data
.w32
->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 w32_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 w32_reassert_line_highlight or w32_change_line_highlight,
593 controls the pixel values used for foreground and background. */
596 w32_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 w32_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 w32_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
.w32
->font
) * (first_unused
- curs_x
),
675 f
->output_data
.w32
->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 w32_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_W32_WINDOW (selected_frame
), FALSE
);
712 w32_sys_ring_bell ();
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 w32_insert_glyphs (start
, len
)
725 register char *start
;
732 w32_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 w32_update_begin and w32_update_end. */
744 w32_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 w32_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
.w32
->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
.w32
->font
),
852 (j
-i
) * f
->output_data
.w32
->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
.w32
->font
),
868 (i
-j
) * f
->output_data
.w32
->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 w32_clear_area (f
, NULL
,
884 CHAR_TO_PIXEL_ROW (f
, i
),
885 f
->width
* FONT_WIDTH (f
->output_data
.w32
->font
),
886 (j
-i
) * f
->output_data
.w32
->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
.w32
->line_height
- 1);
923 right
+= (FONT_WIDTH (f
->output_data
.w32
->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 w32_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 w32_display_info
*dpyinfo
;
1002 struct frame
*frame
;
1004 struct frame
*old_focus
= dpyinfo
->w32_focus_frame
;
1005 int events_enqueued
= 0;
1007 if (frame
!= dpyinfo
->w32_focus_frame
)
1009 /* Set this before calling other routines, so that they see
1010 the correct value of w32_focus_frame. */
1011 dpyinfo
->w32_focus_frame
= frame
;
1013 if (old_focus
&& old_focus
->auto_lower
)
1014 x_lower_frame (old_focus
);
1016 if (dpyinfo
->w32_focus_frame
&& dpyinfo
->w32_focus_frame
->auto_raise
)
1017 pending_autoraise_frame
= dpyinfo
->w32_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 w32_display_info
*dpyinfo
;
1031 x_new_focus_frame (dpyinfo
, dpyinfo
->w32_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 w32_frame_rehighlight (frame
)
1043 struct frame
*frame
;
1045 x_frame_rehighlight (FRAME_W32_DISPLAY_INFO (frame
));
1049 x_frame_rehighlight (dpyinfo
)
1050 struct w32_display_info
*dpyinfo
;
1052 struct frame
*old_highlight
= dpyinfo
->w32_highlight_frame
;
1054 if (dpyinfo
->w32_focus_frame
)
1056 dpyinfo
->w32_highlight_frame
1057 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
)))
1058 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
))
1059 : dpyinfo
->w32_focus_frame
);
1060 if (! FRAME_LIVE_P (dpyinfo
->w32_highlight_frame
))
1062 FRAME_FOCUS_FRAME (dpyinfo
->w32_focus_frame
) = Qnil
;
1063 dpyinfo
->w32_highlight_frame
= dpyinfo
->w32_focus_frame
;
1067 dpyinfo
->w32_highlight_frame
= 0;
1069 if (dpyinfo
->w32_highlight_frame
!= old_highlight
)
1072 frame_unhighlight (old_highlight
);
1073 if (dpyinfo
->w32_highlight_frame
)
1074 frame_highlight (dpyinfo
->w32_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
.w32
->font
) - 1;
1124 pix_y
-= (f
)->output_data
.w32
->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
.w32
->font
) - 1;
1134 bounds
->bottom
= bounds
->top
+ f
->output_data
.w32
->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 (Vw32_swap_mouse_buttons
))
1199 if (NILP (Vw32_swap_mouse_buttons
))
1205 case WM_RBUTTONDOWN
:
1206 if (NILP (Vw32_swap_mouse_buttons
))
1213 if (NILP (Vw32_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_W32_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_W32_DISPLAY_INFO (f
)->mouse_face_mouse_x
= x
;
1324 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_mouse_y
= y
;
1325 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
= f
;
1327 if (FRAME_W32_DISPLAY_INFO (f
)->mouse_face_defer
)
1332 FRAME_W32_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_W32_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_W32_DISPLAY_INFO (f
)->mouse_face_window
))
1346 clear_mouse_face (FRAME_W32_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
))
1354 && w
->last_overlay_modified
== BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
)))
1356 int *ptr
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[row
];
1359 /* Find which buffer position the mouse corresponds to. */
1360 for (i
= column
; i
>= 0; i
--)
1364 /* Is it outside the displayed active region (if any)? */
1366 clear_mouse_face (FRAME_W32_DISPLAY_INFO (f
));
1367 else if (! (EQ (window
, FRAME_W32_DISPLAY_INFO (f
)->mouse_face_window
)
1368 && row
>= FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_row
1369 && row
<= FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_row
1370 && (row
> FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_row
1371 || column
>= FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_col
)
1372 && (row
< FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_row
1373 || column
< FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_col
1374 || FRAME_W32_DISPLAY_INFO (f
)->mouse_face_past_end
)))
1376 Lisp_Object mouse_face
, overlay
, position
;
1377 Lisp_Object
*overlay_vec
;
1378 int len
, noverlays
, ignor1
;
1379 struct buffer
*obuf
;
1382 /* If we get an out-of-range value, return now; avoid an error. */
1383 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1386 /* Make the window's buffer temporarily current for
1387 overlays_at and compute_char_face. */
1388 obuf
= current_buffer
;
1389 current_buffer
= XBUFFER (w
->buffer
);
1395 /* Yes. Clear the display of the old active region, if any. */
1396 clear_mouse_face (FRAME_W32_DISPLAY_INFO (f
));
1398 /* Is this char mouse-active? */
1399 XSETINT (position
, pos
);
1402 overlay_vec
= (Lisp_Object
*) xmalloc (len
* sizeof (Lisp_Object
));
1404 /* Put all the overlays we want in a vector in overlay_vec.
1405 Store the length in len. */
1406 noverlays
= overlays_at (XINT (pos
), 1, &overlay_vec
, &len
,
1408 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1410 /* Find the highest priority overlay that has a mouse-face prop. */
1412 for (i
= 0; i
< noverlays
; i
++)
1414 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1415 if (!NILP (mouse_face
))
1417 overlay
= overlay_vec
[i
];
1422 /* If no overlay applies, get a text property. */
1424 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
1426 /* Handle the overlay case. */
1427 if (! NILP (overlay
))
1429 /* Find the range of text around this char that
1430 should be active. */
1431 Lisp_Object before
, after
;
1434 before
= Foverlay_start (overlay
);
1435 after
= Foverlay_end (overlay
);
1436 /* Record this as the current active region. */
1437 fast_find_position (window
, before
,
1438 &FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_col
,
1439 &FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_row
);
1440 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_past_end
1441 = !fast_find_position (window
, after
,
1442 &FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_col
,
1443 &FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_row
);
1444 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_window
= window
;
1445 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_face_id
1446 = compute_char_face (f
, w
, pos
, 0, 0,
1447 &ignore
, pos
+ 1, 1);
1449 /* Display it as active. */
1450 show_mouse_face (FRAME_W32_DISPLAY_INFO (f
), 1);
1452 /* Handle the text property case. */
1453 else if (! NILP (mouse_face
))
1455 /* Find the range of text around this char that
1456 should be active. */
1457 Lisp_Object before
, after
, beginning
, end
;
1460 beginning
= Fmarker_position (w
->start
);
1461 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1462 - XFASTINT (w
->window_end_pos
)));
1464 = Fprevious_single_property_change (make_number (pos
+ 1),
1466 w
->buffer
, beginning
);
1468 = Fnext_single_property_change (position
, Qmouse_face
,
1470 /* Record this as the current active region. */
1471 fast_find_position (window
, before
,
1472 &FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_col
,
1473 &FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_row
);
1474 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_past_end
1475 = !fast_find_position (window
, after
,
1476 &FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_col
,
1477 &FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_row
);
1478 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_window
= window
;
1479 FRAME_W32_DISPLAY_INFO (f
)->mouse_face_face_id
1480 = compute_char_face (f
, w
, pos
, 0, 0,
1481 &ignore
, pos
+ 1, 1);
1483 /* Display it as active. */
1484 show_mouse_face (FRAME_W32_DISPLAY_INFO (f
), 1);
1488 current_buffer
= obuf
;
1493 /* Find the row and column of position POS in window WINDOW.
1494 Store them in *COLUMNP and *ROWP.
1495 This assumes display in WINDOW is up to date.
1496 If POS is above start of WINDOW, return coords
1497 of start of first screen line.
1498 If POS is after end of WINDOW, return coords of end of last screen line.
1500 Value is 1 if POS is in range, 0 if it was off screen. */
1503 fast_find_position (window
, pos
, columnp
, rowp
)
1506 int *columnp
, *rowp
;
1508 struct window
*w
= XWINDOW (window
);
1509 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1512 int left
= WINDOW_LEFT_MARGIN (w
);
1514 int height
= XFASTINT (w
->height
) - ! MINI_WINDOW_P (w
);
1515 int width
= window_internal_width (w
);
1518 int maybe_next_line
= 0;
1520 /* Find the right row. */
1525 int linestart
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ i
][left
];
1526 if (linestart
> pos
)
1528 /* If the position sought is the end of the buffer,
1529 don't include the blank lines at the bottom of the window. */
1530 if (linestart
== pos
&& pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1532 maybe_next_line
= 1;
1539 /* Find the right column with in it. */
1540 charstarts
= FRAME_CURRENT_GLYPHS (f
)->charstarts
[top
+ row
];
1542 for (i
= 0; i
< width
; i
++)
1544 if (charstarts
[left
+ i
] == pos
)
1547 *columnp
= i
+ left
;
1550 else if (charstarts
[left
+ i
] > pos
)
1552 else if (charstarts
[left
+ i
] > 0)
1556 /* If we're looking for the end of the buffer,
1557 and we didn't find it in the line we scanned,
1558 use the start of the following line. */
1559 if (maybe_next_line
)
1570 /* Display the active region described by mouse_face_*
1571 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1574 show_mouse_face (dpyinfo
, hl
)
1575 struct w32_display_info
*dpyinfo
;
1578 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
1579 int width
= window_internal_width (w
);
1580 FRAME_PTR f
= XFRAME (WINDOW_FRAME (w
));
1583 int old_curs_x
= curs_x
;
1584 int old_curs_y
= curs_y
;
1586 /* Set these variables temporarily
1587 so that if we have to turn the cursor off and on again
1588 we will put it back at the same place. */
1589 curs_x
= f
->phys_cursor_x
;
1590 curs_y
= f
->phys_cursor_y
;
1592 for (i
= FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_row
;
1593 i
<= FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_row
; i
++)
1595 int column
= (i
== FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_row
1596 ? FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_col
1597 : WINDOW_LEFT_MARGIN (w
));
1598 int endcolumn
= (i
== FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_row
1599 ? FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_col
1600 : WINDOW_LEFT_MARGIN (w
) + width
);
1601 endcolumn
= min (endcolumn
, FRAME_CURRENT_GLYPHS (f
)->used
[i
]);
1603 /* If the cursor's in the text we are about to rewrite,
1604 turn the cursor off. */
1606 && curs_x
>= FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_col
- 1
1607 && curs_x
<= FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_col
)
1609 x_display_cursor (f
, 0);
1614 CHAR_TO_PIXEL_COL (f
, column
),
1615 CHAR_TO_PIXEL_ROW (f
, i
),
1616 FRAME_CURRENT_GLYPHS (f
)->glyphs
[i
] + column
,
1618 /* Highlight with mouse face if hl > 0. */
1622 /* If we turned the cursor off, turn it back on. */
1624 x_display_cursor (f
, 1);
1626 curs_x
= old_curs_x
;
1627 curs_y
= old_curs_y
;
1629 /* Change the mouse cursor according to the value of HL. */
1631 SetCursor (f
->output_data
.w32
->cross_cursor
);
1633 SetCursor (f
->output_data
.w32
->text_cursor
);
1636 /* Clear out the mouse-highlighted active region.
1637 Redraw it unhighlighted first. */
1640 clear_mouse_face (dpyinfo
)
1641 struct w32_display_info
*dpyinfo
;
1643 if (! NILP (dpyinfo
->mouse_face_window
))
1644 show_mouse_face (dpyinfo
, 0);
1646 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1647 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1648 dpyinfo
->mouse_face_window
= Qnil
;
1651 struct scroll_bar
*x_window_to_scroll_bar ();
1652 static void x_scroll_bar_report_motion ();
1654 /* Return the current position of the mouse.
1655 *fp should be a frame which indicates which display to ask about.
1657 If the mouse movement started in a scroll bar, set *fp, *bar_window,
1658 and *part to the frame, window, and scroll bar part that the mouse
1659 is over. Set *x and *y to the portion and whole of the mouse's
1660 position on the scroll bar.
1662 If the mouse movement started elsewhere, set *fp to the frame the
1663 mouse is on, *bar_window to nil, and *x and *y to the character cell
1666 Set *time to the server timestamp for the time at which the mouse
1667 was at this position.
1669 Don't store anything if we don't have a valid set of values to report.
1671 This clears the mouse_moved flag, so we can wait for the next mouse
1672 movement. This also calls XQueryPointer, which will cause the
1673 server to give us another MotionNotify when the mouse moves
1677 w32_mouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
1680 Lisp_Object
*bar_window
;
1681 enum scroll_bar_part
*part
;
1683 unsigned long *time
;
1689 if (! NILP (last_mouse_scroll_bar
))
1690 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
1695 Lisp_Object frame
, tail
;
1697 /* Clear the mouse-moved flag for every frame on this display. */
1698 FOR_EACH_FRAME (tail
, frame
)
1699 XFRAME (frame
)->mouse_moved
= 0;
1701 last_mouse_scroll_bar
= Qnil
;
1705 /* Now we have a position on the root; find the innermost window
1706 containing the pointer. */
1708 if (FRAME_W32_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
1709 && FRAME_LIVE_P (last_mouse_frame
))
1711 f1
= last_mouse_frame
;
1715 /* Is win one of our frames? */
1716 f1
= x_window_to_frame (FRAME_W32_DISPLAY_INFO (*fp
), WindowFromPoint(pt
));
1719 /* If not, is it one of our scroll bars? */
1722 struct scroll_bar
*bar
= x_window_to_scroll_bar (WindowFromPoint(pt
));
1726 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
1730 if (f1
== 0 && insist
)
1731 f1
= selected_frame
;
1735 int ignore1
, ignore2
;
1737 ScreenToClient (FRAME_W32_WINDOW (f1
), &pt
);
1739 /* Ok, we found a frame. Store all the values. */
1741 pixel_to_glyph_coords (f1
, pt
.x
, pt
.y
, &ignore1
, &ignore2
,
1743 FRAME_W32_DISPLAY_INFO (f1
)->grabbed
1751 *time
= last_mouse_movement_time
;
1759 /* Scroll bar support. */
1761 /* Given an window ID, find the struct scroll_bar which manages it.
1762 This can be called in GC, so we have to make sure to strip off mark
1765 x_window_to_scroll_bar (window_id
)
1768 Lisp_Object tail
, frame
;
1770 for (tail
= Vframe_list
;
1771 XGCTYPE (tail
) == Lisp_Cons
;
1772 tail
= XCONS (tail
)->cdr
)
1774 Lisp_Object frame
, bar
, condemned
;
1776 frame
= XCONS (tail
)->car
;
1777 /* All elements of Vframe_list should be frames. */
1778 if (! GC_FRAMEP (frame
))
1781 /* Scan this frame's scroll bar list for a scroll bar with the
1783 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
1784 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
1785 /* This trick allows us to search both the ordinary and
1786 condemned scroll bar lists with one loop. */
1787 ! GC_NILP (bar
) || (bar
= condemned
,
1790 bar
= XSCROLL_BAR (bar
)->next
)
1791 if (SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
)) == window_id
)
1792 return XSCROLL_BAR (bar
);
1799 my_create_scrollbar (f
, bar
)
1801 struct scroll_bar
* bar
;
1805 PostThreadMessage (dwWindowsThreadId
, WM_EMACS_CREATESCROLLBAR
, (WPARAM
) f
,
1807 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
1809 return ((HWND
) msg
.wParam
);
1812 //#define ATTACH_THREADS
1815 my_show_window (HWND hwnd
, int how
)
1817 #ifndef ATTACH_THREADS
1818 SendMessage (hwnd
, WM_EMACS_SHOWWINDOW
, (WPARAM
) how
, 0);
1820 ShowWindow (hwnd
, how
);
1825 my_set_window_pos (HWND hwnd
, HWND hwndAfter
,
1826 int x
, int y
, int cx
, int cy
, int flags
)
1828 #ifndef ATTACH_THREADS
1830 pos
.hwndAfter
= hwndAfter
;
1836 SendMessage (hwnd
, WM_EMACS_SETWINDOWPOS
, (WPARAM
) &pos
, 0);
1838 SetWindowPos (hwnd
, hwndAfter
, x
, y
, cx
, cy
, flags
);
1843 my_destroy_window (f
, hwnd
)
1847 SendMessage (FRAME_W32_WINDOW (f
), WM_EMACS_DESTROYWINDOW
,
1851 /* Open a new window to serve as a scroll bar, and return the
1852 scroll bar vector for it. */
1853 static struct scroll_bar
*
1854 x_scroll_bar_create (window
, top
, left
, width
, height
)
1855 struct window
*window
;
1856 int top
, left
, width
, height
;
1858 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
1859 struct scroll_bar
*bar
1860 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
1865 XSETWINDOW (bar
->window
, window
);
1866 XSETINT (bar
->top
, top
);
1867 XSETINT (bar
->left
, left
);
1868 XSETINT (bar
->width
, width
);
1869 XSETINT (bar
->height
, height
);
1870 XSETINT (bar
->start
, 0);
1871 XSETINT (bar
->end
, 0);
1872 bar
->dragging
= Qnil
;
1874 /* Requires geometry to be set before call to create the real window */
1876 hwnd
= my_create_scrollbar (f
, bar
);
1878 SetScrollRange (hwnd
, SB_CTL
, 0, height
, FALSE
);
1879 SetScrollPos (hwnd
, SB_CTL
, 0, TRUE
);
1881 SET_SCROLL_BAR_W32_WINDOW (bar
, hwnd
);
1883 /* Add bar to its frame's list of scroll bars. */
1884 bar
->next
= FRAME_SCROLL_BARS (f
);
1886 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
1887 if (! NILP (bar
->next
))
1888 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
1895 /* Draw BAR's handle in the proper position.
1896 If the handle is already drawn from START to END, don't bother
1897 redrawing it, unless REBUILD is non-zero; in that case, always
1898 redraw it. (REBUILD is handy for drawing the handle after expose
1901 Normally, we want to constrain the start and end of the handle to
1902 fit inside its rectangle, but if the user is dragging the scroll bar
1903 handle, we want to let them drag it down all the way, so that the
1904 bar's top is as far down as it goes; otherwise, there's no way to
1905 move to the very end of the buffer. */
1907 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
1908 struct scroll_bar
*bar
;
1912 int dragging
= ! NILP (bar
->dragging
);
1913 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
1914 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
1916 /* If the display is already accurate, do nothing. */
1918 && start
== XINT (bar
->start
)
1919 && end
== XINT (bar
->end
))
1924 /* Store the adjusted setting in the scroll bar. */
1925 XSETINT (bar
->start
, start
);
1926 XSETINT (bar
->end
, end
);
1928 SetScrollPos (w
, SB_CTL
, start
, TRUE
);
1933 /* Move a scroll bar around on the screen, to accommodate changing
1934 window configurations. */
1936 x_scroll_bar_move (bar
, top
, left
, width
, height
)
1937 struct scroll_bar
*bar
;
1938 int top
, left
, width
, height
;
1940 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
1941 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
1945 MoveWindow (w
, left
, top
, width
, height
, TRUE
);
1946 SetScrollRange (w
, SB_CTL
, 0, height
, FALSE
);
1947 InvalidateRect (w
, NULL
, FALSE
);
1948 my_show_window (w
, SW_NORMAL
);
1950 XSETINT (bar
->left
, left
);
1951 XSETINT (bar
->top
, top
);
1952 XSETINT (bar
->width
, width
);
1953 XSETINT (bar
->height
, height
);
1958 /* Destroy the window for BAR, and set its Emacs window's scroll bar
1961 x_scroll_bar_remove (bar
)
1962 struct scroll_bar
*bar
;
1964 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
1968 /* Destroy the window. */
1969 my_destroy_window (f
, SCROLL_BAR_W32_WINDOW (bar
));
1971 /* Disassociate this scroll bar from its window. */
1972 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
1977 /* Set the handle of the vertical scroll bar for WINDOW to indicate
1978 that we are displaying PORTION characters out of a total of WHOLE
1979 characters, starting at POSITION. If WINDOW has no scroll bar,
1982 w32_set_vertical_scroll_bar (window
, portion
, whole
, position
)
1983 struct window
*window
;
1984 int portion
, whole
, position
;
1986 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
1987 int top
= XINT (window
->top
);
1988 int left
= WINDOW_VERTICAL_SCROLL_BAR_COLUMN (window
);
1989 int height
= WINDOW_VERTICAL_SCROLL_BAR_HEIGHT (window
);
1991 /* Where should this scroll bar be, pixelwise? */
1992 int pixel_top
= CHAR_TO_PIXEL_ROW (f
, top
);
1993 int pixel_left
= CHAR_TO_PIXEL_COL (f
, left
);
1995 = (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
1996 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
1997 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.w32
->font
)));
1998 int pixel_height
= VERTICAL_SCROLL_BAR_PIXEL_HEIGHT (f
, height
);
2000 struct scroll_bar
*bar
;
2002 /* Does the scroll bar exist yet? */
2003 if (NILP (window
->vertical_scroll_bar
))
2004 bar
= x_scroll_bar_create (window
,
2005 pixel_top
, pixel_left
,
2006 pixel_width
, pixel_height
);
2009 /* It may just need to be moved and resized. */
2010 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2011 x_scroll_bar_move (bar
, pixel_top
, pixel_left
, pixel_width
, pixel_height
);
2014 /* Set the scroll bar's current state, unless we're currently being
2016 if (NILP (bar
->dragging
))
2018 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (pixel_height
);
2021 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
2024 int start
= (int) (((double) position
* top_range
) / whole
);
2025 int end
= (int) (((double) (position
+ portion
) * top_range
) / whole
);
2027 x_scroll_bar_set_handle (bar
, start
, end
, 0);
2031 XSETVECTOR (window
->vertical_scroll_bar
, bar
);
2035 /* The following three hooks are used when we're doing a thorough
2036 redisplay of the frame. We don't explicitly know which scroll bars
2037 are going to be deleted, because keeping track of when windows go
2038 away is a real pain - "Can you say set-window-configuration, boys
2039 and girls?" Instead, we just assert at the beginning of redisplay
2040 that *all* scroll bars are to be removed, and then save a scroll bar
2041 from the fiery pit when we actually redisplay its window. */
2043 /* Arrange for all scroll bars on FRAME to be removed at the next call
2044 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
2045 `*redeem_scroll_bar_hook' is applied to its window before the judgement. */
2047 w32_condemn_scroll_bars (frame
)
2050 /* The condemned list should be empty at this point; if it's not,
2051 then the rest of Emacs isn't using the condemn/redeem/judge
2052 protocol correctly. */
2053 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
2056 /* Move them all to the "condemned" list. */
2057 FRAME_CONDEMNED_SCROLL_BARS (frame
) = FRAME_SCROLL_BARS (frame
);
2058 FRAME_SCROLL_BARS (frame
) = Qnil
;
2061 /* Unmark WINDOW's scroll bar for deletion in this judgement cycle.
2062 Note that WINDOW isn't necessarily condemned at all. */
2064 w32_redeem_scroll_bar (window
)
2065 struct window
*window
;
2067 struct scroll_bar
*bar
;
2069 /* We can't redeem this window's scroll bar if it doesn't have one. */
2070 if (NILP (window
->vertical_scroll_bar
))
2073 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
2075 /* Unlink it from the condemned list. */
2077 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
2079 if (NILP (bar
->prev
))
2081 /* If the prev pointer is nil, it must be the first in one of
2083 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
2084 /* It's not condemned. Everything's fine. */
2086 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
2087 window
->vertical_scroll_bar
))
2088 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
2090 /* If its prev pointer is nil, it must be at the front of
2091 one or the other! */
2095 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
2097 if (! NILP (bar
->next
))
2098 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
2100 bar
->next
= FRAME_SCROLL_BARS (f
);
2102 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
2103 if (! NILP (bar
->next
))
2104 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
2108 /* Remove all scroll bars on FRAME that haven't been saved since the
2109 last call to `*condemn_scroll_bars_hook'. */
2111 w32_judge_scroll_bars (f
)
2114 Lisp_Object bar
, next
;
2116 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
2118 /* Clear out the condemned list now so we won't try to process any
2119 more events on the hapless scroll bars. */
2120 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
2122 for (; ! NILP (bar
); bar
= next
)
2124 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
2126 x_scroll_bar_remove (b
);
2129 b
->next
= b
->prev
= Qnil
;
2132 /* Now there should be no references to the condemned scroll bars,
2133 and they should get garbage-collected. */
2136 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
2137 is set to something other than no_event, it is enqueued.
2139 This may be called from a signal handler, so we have to ignore GC
2143 x_scroll_bar_handle_click (bar
, msg
, emacs_event
)
2144 struct scroll_bar
*bar
;
2146 struct input_event
*emacs_event
;
2148 if (! GC_WINDOWP (bar
->window
))
2151 emacs_event
->kind
= w32_scroll_bar_click
;
2152 emacs_event
->code
= 0;
2153 /* not really meaningful to distinguish up/down */
2154 emacs_event
->modifiers
= msg
->dwModifiers
;
2155 emacs_event
->frame_or_window
= bar
->window
;
2156 emacs_event
->timestamp
= msg
->msg
.time
;
2160 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (XINT (bar
->height
));
2162 = VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
));
2163 int y
= GetScrollPos ((HWND
) msg
->msg
.lParam
, SB_CTL
);
2165 switch (LOWORD (msg
->msg
.wParam
))
2168 emacs_event
->part
= scroll_bar_handle
;
2169 if (VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
)) <= 0xffff)
2170 y
= HIWORD (msg
->msg
.wParam
);
2173 emacs_event
->part
= scroll_bar_down_arrow
;
2176 emacs_event
->part
= scroll_bar_up_arrow
;
2179 emacs_event
->part
= scroll_bar_above_handle
;
2182 emacs_event
->part
= scroll_bar_below_handle
;
2185 emacs_event
->part
= scroll_bar_handle
;
2189 emacs_event
->part
= scroll_bar_handle
;
2192 case SB_THUMBPOSITION
:
2193 emacs_event
->part
= scroll_bar_handle
;
2197 SetScrollPos (SCROLL_BAR_W32_WINDOW (bar
), SB_CTL
, y
, TRUE
);
2201 XSETINT (emacs_event
->x
, y
);
2202 XSETINT (emacs_event
->y
, top_range
);
2208 /* Return information to the user about the current position of the mouse
2209 on the scroll bar. */
2211 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
2213 Lisp_Object
*bar_window
;
2214 enum scroll_bar_part
*part
;
2216 unsigned long *time
;
2218 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
2219 Window w
= SCROLL_BAR_W32_WINDOW (bar
);
2220 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
2226 *bar_window
= bar
->window
;
2228 pos
= GetScrollPos (w
, SB_CTL
);
2230 switch (LOWORD (last_mouse_scroll_bar_pos
))
2232 case SB_THUMBPOSITION
:
2234 *part
= scroll_bar_handle
;
2235 if (VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
)) <= 0xffff)
2236 pos
= HIWORD (last_mouse_scroll_bar_pos
);
2239 *part
= scroll_bar_handle
;
2243 *part
= scroll_bar_handle
;
2248 XSETINT(*y
, VERTICAL_SCROLL_BAR_TOP_RANGE (XINT (bar
->height
)));
2251 last_mouse_scroll_bar
= Qnil
;
2253 *time
= last_mouse_movement_time
;
2258 /* The screen has been cleared so we may have changed foreground or
2259 background colors, and the scroll bars may need to be redrawn.
2260 Clear out the scroll bars, and ask for expose events, so we can
2263 x_scroll_bar_clear (f
)
2268 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
2269 bar
= XSCROLL_BAR (bar
)->next
)
2271 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
2272 HDC hdc
= GetDC (window
);
2275 my_show_window (window
, SW_HIDE
);
2276 GetClientRect (window
, &rect
);
2277 select_palette (f
, hdc
);
2278 w32_clear_rect (f
, hdc
, &rect
);
2279 deselect_palette (f
, hdc
);
2283 show_scroll_bars (f
, how
)
2289 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
2290 bar
= XSCROLL_BAR (bar
)->next
)
2292 HWND window
= SCROLL_BAR_W32_WINDOW (XSCROLL_BAR (bar
));
2293 my_show_window (window
, how
);
2298 /* The main W32 event-reading loop - w32_read_socket. */
2300 /* Timestamp of enter window event. This is only used by w32_read_socket,
2301 but we have to put it out here, since static variables within functions
2302 sometimes don't work. */
2303 static Time enter_timestamp
;
2305 /* Record the last 100 characters stored
2306 to help debug the loss-of-chars-during-GC problem. */
2308 short temp_buffer
[100];
2310 extern int key_event (KEY_EVENT_RECORD
*, struct input_event
*);
2312 /* Map a W32 WM_CHAR message into a KEY_EVENT_RECORD so that
2313 we can use the same routines to handle input in both console
2314 and window modes. */
2317 convert_to_key_event (W32Msg
*msgp
, KEY_EVENT_RECORD
*eventp
)
2319 eventp
->bKeyDown
= TRUE
;
2320 eventp
->wRepeatCount
= 1;
2321 eventp
->wVirtualKeyCode
= msgp
->msg
.wParam
;
2322 eventp
->wVirtualScanCode
= (msgp
->msg
.lParam
& 0xFF0000) >> 16;
2323 eventp
->uChar
.AsciiChar
= 0;
2324 eventp
->dwControlKeyState
= msgp
->dwModifiers
;
2327 /* Return nonzero if the virtual key is a dead key. */
2330 is_dead_key (int wparam
)
2332 unsigned int code
= MapVirtualKey (wparam
, 2);
2334 /* Windows 95 returns 0x8000, NT returns 0x80000000. */
2335 if ((code
& 0x8000) || (code
& 0x80000000))
2341 /* Read events coming from the W32 shell.
2342 This routine is called by the SIGIO handler.
2343 We return as soon as there are no more events to be read.
2345 Events representing keys are stored in buffer BUFP,
2346 which can hold up to NUMCHARS characters.
2347 We return the number of characters stored into the buffer,
2348 thus pretending to be `read'.
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 windows proc directly in a context where we cannot return
2354 the 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 windows proc gets called
2358 recursively with different messages by the system.
2362 w32_read_socket (sd
, bufp
, numchars
, expected
)
2364 register struct input_event
*bufp
;
2365 register int numchars
;
2370 int items_pending
; /* How many items are in the X queue. */
2373 int event_found
= 0;
2376 struct w32_display_info
*dpyinfo
= &one_w32_display_info
;
2378 if (interrupt_input_blocked
)
2380 interrupt_input_pending
= 1;
2384 interrupt_input_pending
= 0;
2387 /* So people can tell when we have read the available input. */
2388 input_signal_count
++;
2391 abort (); /* Don't think this happens. */
2393 while (get_next_msg (&msg
, FALSE
))
2395 switch (msg
.msg
.message
)
2399 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2403 if (f
->async_visible
== 0)
2405 f
->async_visible
= 1;
2406 f
->async_iconified
= 0;
2407 SET_FRAME_GARBAGED (f
);
2411 /* Erase background again for safety. */
2412 w32_clear_rect (f
, NULL
, &msg
.rect
);
2416 msg
.rect
.right
-msg
.rect
.left
+1,
2417 msg
.rect
.bottom
-msg
.rect
.top
+1);
2424 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2426 if (f
&& !f
->iconified
)
2428 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
2430 temp_buffer
[temp_index
++] = msg
.msg
.wParam
;
2431 bufp
->kind
= non_ascii_keystroke
;
2432 bufp
->code
= msg
.msg
.wParam
;
2433 bufp
->modifiers
= w32_kbd_mods_to_emacs (msg
.dwModifiers
);
2434 XSETFRAME (bufp
->frame_or_window
, f
);
2435 bufp
->timestamp
= msg
.msg
.time
;
2443 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2445 if (f
&& !f
->iconified
)
2450 KEY_EVENT_RECORD key
, *keyp
= &key
;
2452 if (temp_index
== sizeof temp_buffer
/ sizeof (short))
2455 convert_to_key_event (&msg
, keyp
);
2456 add
= key_event (keyp
, bufp
);
2457 XSETFRAME (bufp
->frame_or_window
, f
);
2460 /* The key pressed generated two characters, most likely
2461 an accent character and a key that could not be
2462 combined with it. Prepend the message on the queue
2463 again to process the second character (which is
2464 being held internally in key_event), and process
2465 the first character now. */
2470 /* Throw dead keys away. However, be sure not to
2471 throw away the dead key if it was produced using
2472 AltGr and there is a valid AltGr scan code for
2474 if (is_dead_key (msg
.msg
.wParam
)
2475 && !((VkKeyScan ((char) bufp
->code
) & 0xff00) == 0x600))
2489 if (dpyinfo
->grabbed
&& last_mouse_frame
2490 && FRAME_LIVE_P (last_mouse_frame
))
2491 f
= last_mouse_frame
;
2493 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2496 note_mouse_movement (f
, &msg
.msg
);
2498 clear_mouse_face (FRAME_W32_DISPLAY_INFO (f
));
2501 case WM_LBUTTONDOWN
:
2503 case WM_MBUTTONDOWN
:
2505 case WM_RBUTTONDOWN
:
2511 if (dpyinfo
->grabbed
&& last_mouse_frame
2512 && FRAME_LIVE_P (last_mouse_frame
))
2513 f
= last_mouse_frame
;
2515 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2519 if ((!dpyinfo
->w32_focus_frame
|| f
== dpyinfo
->w32_focus_frame
)
2522 construct_mouse_click (bufp
, &msg
, f
);
2529 parse_button (msg
.msg
.message
, &button
, &up
);
2533 dpyinfo
->grabbed
&= ~ (1 << button
);
2537 dpyinfo
->grabbed
|= (1 << button
);
2538 last_mouse_frame
= f
;
2545 struct scroll_bar
*bar
= x_window_to_scroll_bar ((HWND
)msg
.msg
.lParam
);
2547 if (bar
&& numchars
>= 1)
2549 if (x_scroll_bar_handle_click (bar
, &msg
, bufp
))
2560 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2562 if (f
&& !f
->async_iconified
)
2564 f
->output_data
.w32
->left_pos
= LOWORD (msg
.msg
.lParam
);
2565 f
->output_data
.w32
->top_pos
= HIWORD (msg
.msg
.lParam
);
2570 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2572 if (f
&& !f
->async_iconified
&& msg
.msg
.wParam
!= SIZE_MINIMIZED
)
2580 GetClientRect(msg
.msg
.hwnd
, &rect
);
2582 height
= rect
.bottom
- rect
.top
+ 1;
2583 width
= rect
.right
- rect
.left
+ 1;
2585 rows
= PIXEL_TO_CHAR_HEIGHT (f
, height
);
2586 columns
= PIXEL_TO_CHAR_WIDTH (f
, width
);
2588 /* Even if the number of character rows and columns has
2589 not changed, the font size may have changed, so we need
2590 to check the pixel dimensions as well. */
2592 if (columns
!= f
->width
2593 || rows
!= f
->height
2594 || width
!= f
->output_data
.w32
->pixel_width
2595 || height
!= f
->output_data
.w32
->pixel_height
)
2597 /* I had set this to 0, 0 - I am not sure why?? */
2599 change_frame_size (f
, rows
, columns
, 0, 1);
2600 SET_FRAME_GARBAGED (f
);
2602 f
->output_data
.w32
->pixel_width
= width
;
2603 f
->output_data
.w32
->pixel_height
= height
;
2604 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
2611 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2613 if (msg
.msg
.message
== WM_SETFOCUS
)
2615 x_new_focus_frame (dpyinfo
, f
);
2617 else if (f
== dpyinfo
->w32_focus_frame
)
2618 x_new_focus_frame (dpyinfo
, 0);
2622 switch (msg
.msg
.wParam
& 0xfff0) /* Lower 4 bits used by Windows. */
2625 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2632 bufp
->kind
= delete_window_event
;
2633 XSETFRAME (bufp
->frame_or_window
, f
);
2641 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2645 f
->async_visible
= 1;
2646 f
->async_iconified
= 1;
2648 bufp
->kind
= iconify_event
;
2649 XSETFRAME (bufp
->frame_or_window
, f
);
2658 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2662 f
->async_visible
= 1;
2663 f
->async_iconified
= 0;
2665 /* wait_reading_process_input will notice this and update
2666 the frame's display structures. */
2667 SET_FRAME_GARBAGED (f
);
2671 bufp
->kind
= deiconify_event
;
2672 XSETFRAME (bufp
->frame_or_window
, f
);
2678 /* Force a redisplay sooner or later
2679 to update the frame titles
2680 in case this is the second frame. */
2681 record_asynch_buffer_change ();
2689 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2696 bufp
->kind
= delete_window_event
;
2697 XSETFRAME (bufp
->frame_or_window
, f
);
2705 f
= x_window_to_frame (dpyinfo
, msg
.msg
.hwnd
);
2709 if (msg
.msg
.lParam
== 0)
2711 /* Came from window menu */
2713 extern Lisp_Object
get_frame_menubar_event ();
2714 Lisp_Object event
= get_frame_menubar_event (f
, msg
.msg
.wParam
);
2715 struct input_event buf
;
2718 XSETFRAME (frame
, f
);
2719 buf
.kind
= menu_bar_event
;
2721 /* Store initial menu bar event */
2725 buf
.frame_or_window
= Fcons (frame
, Fcons (Qmenu_bar
, Qnil
));
2726 kbd_buffer_store_event (&buf
);
2729 /* Enqueue the events */
2731 while (!NILP (event
))
2733 buf
.frame_or_window
= Fcons (frame
, XCONS (event
)->car
);
2734 kbd_buffer_store_event (&buf
);
2735 event
= XCONS (event
)->cdr
;
2740 /* Came from popup menu */
2747 /* If the focus was just given to an autoraising frame,
2749 /* ??? This ought to be able to handle more than one such frame. */
2750 if (pending_autoraise_frame
)
2752 x_raise_frame (pending_autoraise_frame
);
2753 pending_autoraise_frame
= 0;
2760 /* Drawing the cursor. */
2763 /* Draw a hollow box cursor. Don't change the inside of the box. */
2773 hdc
= get_frame_dc (f
);
2775 hb
= CreateSolidBrush (f
->output_data
.w32
->cursor_pixel
);
2777 rect
.left
= CHAR_TO_PIXEL_COL (f
, curs_x
);
2778 rect
.top
= CHAR_TO_PIXEL_ROW (f
, curs_y
);
2779 rect
.right
= rect
.left
+ FONT_WIDTH (f
->output_data
.w32
->font
);
2780 rect
.bottom
= rect
.top
+ f
->output_data
.w32
->line_height
;
2782 FrameRect (hdc
, &rect
, hb
);
2785 release_frame_dc (f
, hdc
);
2788 /* Clear the cursor of frame F to background color,
2789 and mark the cursor as not shown.
2790 This is used when the text where the cursor is
2791 is about to be rewritten. */
2797 if (! FRAME_VISIBLE_P (f
)
2798 || f
->phys_cursor_x
< 0)
2801 x_display_cursor (f
, 0);
2802 f
->phys_cursor_x
= -1;
2805 /* Redraw the glyph at ROW, COLUMN on frame F, in the style
2806 HIGHLIGHT. HIGHLIGHT is as defined for dumpglyphs. Return the
2810 x_draw_single_glyph (f
, row
, column
, glyph
, highlight
)
2817 CHAR_TO_PIXEL_COL (f
, column
),
2818 CHAR_TO_PIXEL_ROW (f
, row
),
2819 &glyph
, 1, highlight
, 0);
2823 x_display_bar_cursor (f
, on
)
2827 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
2829 /* This is pointless on invisible frames, and dangerous on garbaged
2830 frames; in the latter case, the frame may be in the midst of
2831 changing its size, and curs_x and curs_y may be off the frame. */
2832 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
2835 if (! on
&& f
->phys_cursor_x
< 0)
2838 /* If we're not updating, then we want to use the current frame's
2839 cursor position, not our local idea of where the cursor ought to be. */
2840 if (f
!= updating_frame
)
2842 curs_x
= FRAME_CURSOR_X (f
);
2843 curs_y
= FRAME_CURSOR_Y (f
);
2846 /* If there is anything wrong with the current cursor state, remove it. */
2847 if (f
->phys_cursor_x
>= 0
2849 || f
->phys_cursor_x
!= curs_x
2850 || f
->phys_cursor_y
!= curs_y
2851 || f
->output_data
.w32
->current_cursor
!= bar_cursor
))
2853 /* Erase the cursor by redrawing the character underneath it. */
2854 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
2855 f
->phys_cursor_glyph
,
2856 current_glyphs
->highlight
[f
->phys_cursor_y
]);
2857 f
->phys_cursor_x
= -1;
2860 /* If we now need a cursor in the new place or in the new form, do it so. */
2862 && (f
->phys_cursor_x
< 0
2863 || (f
->output_data
.w32
->current_cursor
!= bar_cursor
)))
2865 f
->phys_cursor_glyph
2866 = ((current_glyphs
->enable
[curs_y
]
2867 && curs_x
< current_glyphs
->used
[curs_y
])
2868 ? current_glyphs
->glyphs
[curs_y
][curs_x
]
2870 w32_fill_area (f
, NULL
, f
->output_data
.w32
->cursor_pixel
,
2871 CHAR_TO_PIXEL_COL (f
, curs_x
),
2872 CHAR_TO_PIXEL_ROW (f
, curs_y
),
2873 max (f
->output_data
.w32
->cursor_width
, 1),
2874 f
->output_data
.w32
->line_height
);
2876 f
->phys_cursor_x
= curs_x
;
2877 f
->phys_cursor_y
= curs_y
;
2879 f
->output_data
.w32
->current_cursor
= bar_cursor
;
2884 /* Turn the displayed cursor of frame F on or off according to ON.
2885 If ON is nonzero, where to put the cursor is specified
2886 by F->cursor_x and F->cursor_y. */
2889 x_display_box_cursor (f
, on
)
2893 struct frame_glyphs
*current_glyphs
= FRAME_CURRENT_GLYPHS (f
);
2895 /* This is pointless on invisible frames, and dangerous on garbaged
2896 frames; in the latter case, the frame may be in the midst of
2897 changing its size, and curs_x and curs_y may be off the frame. */
2898 if (! FRAME_VISIBLE_P (f
) || FRAME_GARBAGED_P (f
))
2901 /* If cursor is off and we want it off, return quickly. */
2902 if (!on
&& f
->phys_cursor_x
< 0)
2905 /* If we're not updating, then we want to use the current frame's
2906 cursor position, not our local idea of where the cursor ought to be. */
2907 if (f
!= updating_frame
)
2909 curs_x
= FRAME_CURSOR_X (f
);
2910 curs_y
= FRAME_CURSOR_Y (f
);
2913 /* If cursor is currently being shown and we don't want it to be
2914 or it is in the wrong place,
2915 or we want a hollow box and it's not so, (pout!)
2917 if (f
->phys_cursor_x
>= 0
2919 || f
->phys_cursor_x
!= curs_x
2920 || f
->phys_cursor_y
!= curs_y
2921 || (f
->output_data
.w32
->current_cursor
!= hollow_box_cursor
2922 && (f
!= FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
))))
2924 int mouse_face_here
= 0;
2925 struct frame_glyphs
*active_glyphs
= FRAME_CURRENT_GLYPHS (f
);
2927 /* If the cursor is in the mouse face area, redisplay that when
2928 we clear the cursor. */
2929 if (f
== FRAME_W32_DISPLAY_INFO (f
)->mouse_face_mouse_frame
2931 (f
->phys_cursor_y
> FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_row
2932 || (f
->phys_cursor_y
== FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_row
2933 && f
->phys_cursor_x
>= FRAME_W32_DISPLAY_INFO (f
)->mouse_face_beg_col
))
2935 (f
->phys_cursor_y
< FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_row
2936 || (f
->phys_cursor_y
== FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_row
2937 && f
->phys_cursor_x
< FRAME_W32_DISPLAY_INFO (f
)->mouse_face_end_col
))
2938 /* Don't redraw the cursor's spot in mouse face
2939 if it is at the end of a line (on a newline).
2940 The cursor appears there, but mouse highlighting does not. */
2941 && active_glyphs
->used
[f
->phys_cursor_y
] > f
->phys_cursor_x
)
2942 mouse_face_here
= 1;
2944 /* If the font is not as tall as a whole line,
2945 we must explicitly clear the line's whole height. */
2946 if (FONT_HEIGHT (f
->output_data
.w32
->font
) != f
->output_data
.w32
->line_height
)
2947 w32_clear_area (f
, NULL
,
2948 CHAR_TO_PIXEL_COL (f
, f
->phys_cursor_x
),
2949 CHAR_TO_PIXEL_ROW (f
, f
->phys_cursor_y
),
2950 FONT_WIDTH (f
->output_data
.w32
->font
),
2951 f
->output_data
.w32
->line_height
);
2952 /* Erase the cursor by redrawing the character underneath it. */
2953 x_draw_single_glyph (f
, f
->phys_cursor_y
, f
->phys_cursor_x
,
2954 f
->phys_cursor_glyph
,
2957 : current_glyphs
->highlight
[f
->phys_cursor_y
]));
2958 f
->phys_cursor_x
= -1;
2961 /* If we want to show a cursor,
2962 or we want a box cursor and it's not so,
2963 write it in the right place. */
2965 && (f
->phys_cursor_x
< 0
2966 || (f
->output_data
.w32
->current_cursor
!= filled_box_cursor
2967 && f
== FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
)))
2969 f
->phys_cursor_glyph
2970 = ((current_glyphs
->enable
[curs_y
]
2971 && curs_x
< current_glyphs
->used
[curs_y
])
2972 ? current_glyphs
->glyphs
[curs_y
][curs_x
]
2974 if (f
!= FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
)
2977 f
->output_data
.w32
->current_cursor
= hollow_box_cursor
;
2981 x_draw_single_glyph (f
, curs_y
, curs_x
,
2982 f
->phys_cursor_glyph
, 2);
2983 f
->output_data
.w32
->current_cursor
= filled_box_cursor
;
2986 f
->phys_cursor_x
= curs_x
;
2987 f
->phys_cursor_y
= curs_y
;
2991 x_display_cursor (f
, on
)
2997 if (FRAME_DESIRED_CURSOR (f
) == filled_box_cursor
)
2998 x_display_box_cursor (f
, on
);
2999 else if (FRAME_DESIRED_CURSOR (f
) == bar_cursor
)
3000 x_display_bar_cursor (f
, on
);
3002 /* Those are the only two we have implemented! */
3008 /* Changing the font of the frame. */
3010 /* Give frame F the font named FONTNAME as its default font, and
3011 return the full name of that font. FONTNAME may be a wildcard
3012 pattern; in that case, we choose some font that fits the pattern.
3013 The return value shows which font we chose. */
3016 x_new_font (f
, fontname
)
3018 register char *fontname
;
3021 int n_matching_fonts
;
3022 XFontStruct
*font_info
;
3023 char new_font_name
[101];
3025 /* Get a font which matches this name */
3029 if (!x_to_w32_font(fontname
, &lf
)
3030 || !w32_to_x_font(&lf
, new_font_name
, 100))
3036 /* See if we've already loaded a matching font. */
3037 already_loaded
= -1;
3042 for (i
= 0; i
< FRAME_W32_DISPLAY_INFO (f
)->n_fonts
; i
++)
3043 if (!strcmp (FRAME_W32_DISPLAY_INFO (f
)->font_table
[i
].name
, new_font_name
))
3046 fontname
= FRAME_W32_DISPLAY_INFO (f
)->font_table
[i
].name
;
3051 /* If we have, just return it from the table. */
3052 if (already_loaded
>= 0)
3053 f
->output_data
.w32
->font
= FRAME_W32_DISPLAY_INFO (f
)->font_table
[already_loaded
].font
;
3054 /* Otherwise, load the font and add it to the table. */
3060 font
= w32_load_font(FRAME_W32_DISPLAY_INFO (f
), fontname
);
3067 /* Do we need to create the table? */
3068 if (FRAME_W32_DISPLAY_INFO (f
)->font_table_size
== 0)
3070 FRAME_W32_DISPLAY_INFO (f
)->font_table_size
= 16;
3071 FRAME_W32_DISPLAY_INFO (f
)->font_table
3072 = (struct font_info
*) xmalloc (FRAME_W32_DISPLAY_INFO (f
)->font_table_size
3073 * sizeof (struct font_info
));
3075 /* Do we need to grow the table? */
3076 else if (FRAME_W32_DISPLAY_INFO (f
)->n_fonts
3077 >= FRAME_W32_DISPLAY_INFO (f
)->font_table_size
)
3079 FRAME_W32_DISPLAY_INFO (f
)->font_table_size
*= 2;
3080 FRAME_W32_DISPLAY_INFO (f
)->font_table
3081 = (struct font_info
*) xrealloc (FRAME_W32_DISPLAY_INFO (f
)->font_table
,
3082 (FRAME_W32_DISPLAY_INFO (f
)->font_table_size
3083 * sizeof (struct font_info
)));
3086 n_fonts
= FRAME_W32_DISPLAY_INFO (f
)->n_fonts
;
3087 FRAME_W32_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
= (char *) xmalloc (strlen (fontname
) + 1);
3088 bcopy (fontname
, FRAME_W32_DISPLAY_INFO (f
)->font_table
[n_fonts
].name
, strlen (fontname
) + 1);
3089 f
->output_data
.w32
->font
= FRAME_W32_DISPLAY_INFO (f
)->font_table
[n_fonts
].font
= font
;
3090 FRAME_W32_DISPLAY_INFO (f
)->n_fonts
++;
3093 /* Compute the scroll bar width in character columns. */
3094 if (f
->scroll_bar_pixel_width
> 0)
3096 int wid
= FONT_WIDTH (f
->output_data
.w32
->font
);
3097 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
3100 f
->scroll_bar_cols
= 2;
3102 /* Now make the frame display the given font. */
3103 if (FRAME_W32_WINDOW (f
) != 0)
3105 frame_update_line_height (f
);
3106 x_set_window_size (f
, 0, f
->width
, f
->height
);
3109 /* If we are setting a new frame's font for the first time,
3110 there are no faces yet, so this font's height is the line height. */
3111 f
->output_data
.w32
->line_height
= FONT_HEIGHT (f
->output_data
.w32
->font
);
3114 Lisp_Object lispy_name
;
3116 lispy_name
= build_string (fontname
);
3122 x_calc_absolute_position (f
)
3127 int flags
= f
->output_data
.w32
->size_hint_flags
;
3131 /* Find the position of the outside upper-left corner of
3132 the inner window, with respect to the outer window. */
3133 if (f
->output_data
.w32
->parent_desc
!= FRAME_W32_DISPLAY_INFO (f
)->root_window
)
3136 MapWindowPoints (FRAME_W32_WINDOW (f
),
3137 f
->output_data
.w32
->parent_desc
,
3144 rt
.left
= rt
.right
= rt
.top
= rt
.bottom
= 0;
3147 AdjustWindowRect(&rt
, f
->output_data
.w32
->dwStyle
,
3148 FRAME_EXTERNAL_MENU_BAR (f
));
3151 pt
.x
+= (rt
.right
- rt
.left
);
3152 pt
.y
+= (rt
.bottom
- rt
.top
);
3155 /* Treat negative positions as relative to the leftmost bottommost
3156 position that fits on the screen. */
3157 if (flags
& XNegative
)
3158 f
->output_data
.w32
->left_pos
= (FRAME_W32_DISPLAY_INFO (f
)->width
3159 - 2 * f
->output_data
.w32
->border_width
- pt
.x
3161 + f
->output_data
.w32
->left_pos
);
3163 if (flags
& YNegative
)
3164 f
->output_data
.w32
->top_pos
= (FRAME_W32_DISPLAY_INFO (f
)->height
3165 - 2 * f
->output_data
.w32
->border_width
- pt
.y
3167 + f
->output_data
.w32
->top_pos
);
3168 /* The left_pos and top_pos
3169 are now relative to the top and left screen edges,
3170 so the flags should correspond. */
3171 f
->output_data
.w32
->size_hint_flags
&= ~ (XNegative
| YNegative
);
3174 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
3175 to really change the position, and 0 when calling from
3176 x_make_frame_visible (in that case, XOFF and YOFF are the current
3177 position values). It is -1 when calling from x_set_frame_parameters,
3178 which means, do adjust for borders but don't change the gravity. */
3180 x_set_offset (f
, xoff
, yoff
, change_gravity
)
3182 register int xoff
, yoff
;
3185 int modified_top
, modified_left
;
3187 if (change_gravity
> 0)
3189 f
->output_data
.w32
->top_pos
= yoff
;
3190 f
->output_data
.w32
->left_pos
= xoff
;
3191 f
->output_data
.w32
->size_hint_flags
&= ~ (XNegative
| YNegative
);
3193 f
->output_data
.w32
->size_hint_flags
|= XNegative
;
3195 f
->output_data
.w32
->size_hint_flags
|= YNegative
;
3196 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
3198 x_calc_absolute_position (f
);
3201 x_wm_set_size_hint (f
, (long) 0, 0);
3203 /* It is a mystery why we need to add the border_width here
3204 when the frame is already visible, but experiment says we do. */
3205 modified_left
= f
->output_data
.w32
->left_pos
;
3206 modified_top
= f
->output_data
.w32
->top_pos
;
3207 if (change_gravity
!= 0)
3209 modified_left
+= f
->output_data
.w32
->border_width
;
3210 modified_top
+= f
->output_data
.w32
->border_width
;
3213 my_set_window_pos (FRAME_W32_WINDOW (f
),
3215 modified_left
, modified_top
,
3217 SWP_NOZORDER
| SWP_NOSIZE
);
3221 /* Call this to change the size of frame F's x-window.
3222 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
3223 for this size change and subsequent size changes.
3224 Otherwise we leave the window gravity unchanged. */
3226 x_set_window_size (f
, change_gravity
, cols
, rows
)
3231 int pixelwidth
, pixelheight
;
3235 check_frame_size (f
, &rows
, &cols
);
3236 f
->output_data
.w32
->vertical_scroll_bar_extra
3237 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
3239 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
3240 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
3241 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.w32
->font
)));
3242 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
3243 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
3245 f
->output_data
.w32
->win_gravity
= NorthWestGravity
;
3246 x_wm_set_size_hint (f
, (long) 0, 0);
3251 rect
.left
= rect
.top
= 0;
3252 rect
.right
= pixelwidth
;
3253 rect
.bottom
= pixelheight
;
3255 AdjustWindowRect(&rect
, f
->output_data
.w32
->dwStyle
,
3256 FRAME_EXTERNAL_MENU_BAR (f
));
3258 /* All windows have an extra pixel */
3260 my_set_window_pos (FRAME_W32_WINDOW (f
),
3263 rect
.right
- rect
.left
+ 1,
3264 rect
.bottom
- rect
.top
+ 1,
3265 SWP_NOZORDER
| SWP_NOMOVE
);
3268 /* Now, strictly speaking, we can't be sure that this is accurate,
3269 but the window manager will get around to dealing with the size
3270 change request eventually, and we'll hear how it went when the
3271 ConfigureNotify event gets here.
3273 We could just not bother storing any of this information here,
3274 and let the ConfigureNotify event set everything up, but that
3275 might be kind of confusing to the lisp code, since size changes
3276 wouldn't be reported in the frame parameters until some random
3277 point in the future when the ConfigureNotify event arrives. */
3278 change_frame_size (f
, rows
, cols
, 0, 0);
3279 PIXEL_WIDTH (f
) = pixelwidth
;
3280 PIXEL_HEIGHT (f
) = pixelheight
;
3282 /* If cursor was outside the new size, mark it as off. */
3283 if (f
->phys_cursor_y
>= rows
3284 || f
->phys_cursor_x
>= cols
)
3286 f
->phys_cursor_x
= -1;
3287 f
->phys_cursor_y
= -1;
3290 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
3291 receive in the ConfigureNotify event; if we get what we asked
3292 for, then the event won't cause the screen to become garbaged, so
3293 we have to make sure to do it here. */
3294 SET_FRAME_GARBAGED (f
);
3299 /* Mouse warping. */
3302 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
3308 pix_x
+= f
->output_data
.w32
->left_pos
;
3309 pix_y
+= f
->output_data
.w32
->top_pos
;
3311 SetCursorPos (pix_x
, pix_y
);
3317 x_set_mouse_position (f
, x
, y
)
3323 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.w32
->font
) / 2;
3324 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.w32
->line_height
/ 2;
3326 if (pix_x
< 0) pix_x
= 0;
3327 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
3329 if (pix_y
< 0) pix_y
= 0;
3330 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
3332 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
3335 /* focus shifting, raising and lowering. */
3337 x_focus_on_frame (f
)
3347 /* Raise frame F. */
3352 // if (f->async_visible)
3355 my_set_window_pos (FRAME_W32_WINDOW (f
),
3358 SWP_NOSIZE
| SWP_NOMOVE
);
3363 /* Lower frame F. */
3368 // if (f->async_visible)
3371 my_set_window_pos (FRAME_W32_WINDOW (f
),
3374 SWP_NOSIZE
| SWP_NOMOVE
);
3380 w32_frame_raise_lower (f
, raise
)
3390 /* Change of visibility. */
3392 /* This tries to wait until the frame is really visible.
3393 However, if the window manager asks the user where to position
3394 the frame, this will return before the user finishes doing that.
3395 The frame will not actually be visible at that time,
3396 but it will become visible later when the window manager
3397 finishes with it. */
3399 x_make_frame_visible (f
)
3404 if (! FRAME_VISIBLE_P (f
))
3406 /* We test FRAME_GARBAGED_P here to make sure we don't
3407 call x_set_offset a second time
3408 if we get to x_make_frame_visible a second time
3409 before the window gets really visible. */
3410 if (! FRAME_ICONIFIED_P (f
)
3411 && ! f
->output_data
.w32
->asked_for_visible
)
3413 x_set_offset (f
, f
->output_data
.w32
->left_pos
, f
->output_data
.w32
->top_pos
, 0);
3414 // SetForegroundWindow (FRAME_W32_WINDOW (f));
3417 f
->output_data
.w32
->asked_for_visible
= 1;
3419 my_show_window (FRAME_W32_WINDOW (f
), SW_SHOWNORMAL
);
3422 /* Synchronize to ensure Emacs knows the frame is visible
3423 before we do anything else. We do this loop with input not blocked
3424 so that incoming events are handled. */
3427 int count
= input_signal_count
;
3429 /* This must come after we set COUNT. */
3432 XSETFRAME (frame
, f
);
3436 /* Once we have handled input events,
3437 we should have received the MapNotify if one is coming.
3438 So if we have not got it yet, stop looping.
3439 Some window managers make their own decisions
3440 about visibility. */
3441 if (input_signal_count
!= count
)
3443 /* Machines that do polling rather than SIGIO have been observed
3444 to go into a busy-wait here. So we'll fake an alarm signal
3445 to let the handler know that there's something to be read.
3446 We used to raise a real alarm, but it seems that the handler
3447 isn't always enabled here. This is probably a bug. */
3448 if (input_polling_used ())
3450 /* It could be confusing if a real alarm arrives while processing
3451 the fake one. Turn it off and let the handler reset it. */
3453 input_poll_signal ();
3455 /* Once we have handled input events,
3456 we should have received the MapNotify if one is coming.
3457 So if we have not got it yet, stop looping.
3458 Some window managers make their own decisions
3459 about visibility. */
3460 if (input_signal_count
!= count
)
3463 FRAME_SAMPLE_VISIBILITY (f
);
3467 /* Change from mapped state to withdrawn state. */
3469 /* Make the frame visible (mapped and not iconified). */
3471 x_make_frame_invisible (f
)
3476 /* Don't keep the highlight on an invisible frame. */
3477 if (FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
== f
)
3478 FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
= 0;
3482 my_show_window (FRAME_W32_WINDOW (f
), SW_HIDE
);
3484 /* We can't distinguish this from iconification
3485 just by the event that we get from the server.
3486 So we can't win using the usual strategy of letting
3487 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
3488 and synchronize with the server to make sure we agree. */
3490 FRAME_ICONIFIED_P (f
) = 0;
3491 f
->async_visible
= 0;
3492 f
->async_iconified
= 0;
3497 /* Change window state from mapped to iconified. */
3505 /* Don't keep the highlight on an invisible frame. */
3506 if (FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
== f
)
3507 FRAME_W32_DISPLAY_INFO (f
)->w32_highlight_frame
= 0;
3509 if (f
->async_iconified
)
3514 my_show_window (FRAME_W32_WINDOW (f
), SW_SHOWMINIMIZED
);
3515 /* The frame doesn't seem to be lowered automatically. */
3518 f
->async_iconified
= 1;
3523 /* Destroy the window of frame F. */
3525 x_destroy_window (f
)
3528 struct w32_display_info
*dpyinfo
= FRAME_W32_DISPLAY_INFO (f
);
3532 my_destroy_window (f
, FRAME_W32_WINDOW (f
));
3533 free_frame_menubar (f
);
3534 free_frame_faces (f
);
3536 xfree (f
->output_data
.w32
);
3537 f
->output_data
.w32
= 0;
3538 if (f
== dpyinfo
->w32_focus_frame
)
3539 dpyinfo
->w32_focus_frame
= 0;
3540 if (f
== dpyinfo
->w32_focus_event_frame
)
3541 dpyinfo
->w32_focus_event_frame
= 0;
3542 if (f
== dpyinfo
->w32_highlight_frame
)
3543 dpyinfo
->w32_highlight_frame
= 0;
3545 dpyinfo
->reference_count
--;
3547 if (f
== dpyinfo
->mouse_face_mouse_frame
)
3549 dpyinfo
->mouse_face_beg_row
3550 = dpyinfo
->mouse_face_beg_col
= -1;
3551 dpyinfo
->mouse_face_end_row
3552 = dpyinfo
->mouse_face_end_col
= -1;
3553 dpyinfo
->mouse_face_window
= Qnil
;
3559 /* Setting window manager hints. */
3561 /* Set the normal size hints for the window manager, for frame F.
3562 FLAGS is the flags word to use--or 0 meaning preserve the flags
3563 that the window now has.
3564 If USER_POSITION is nonzero, we set the USPosition
3565 flag (this is useful when FLAGS is 0). */
3567 x_wm_set_size_hint (f
, flags
, user_position
)
3572 Window window
= FRAME_W32_WINDOW (f
);
3574 flexlines
= f
->height
;
3578 SetWindowLong (window
, WND_X_UNITS_INDEX
, FONT_WIDTH (f
->output_data
.w32
->font
));
3579 SetWindowLong (window
, WND_Y_UNITS_INDEX
, f
->output_data
.w32
->line_height
);
3584 /* Window manager things */
3585 x_wm_set_icon_position (f
, icon_x
, icon_y
)
3590 Window window
= FRAME_W32_WINDOW (f
);
3592 f
->display
.x
->wm_hints
.flags
|= IconPositionHint
;
3593 f
->display
.x
->wm_hints
.icon_x
= icon_x
;
3594 f
->display
.x
->wm_hints
.icon_y
= icon_y
;
3596 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->display
.x
->wm_hints
);
3601 /* Initialization. */
3603 #ifdef USE_X_TOOLKIT
3604 static XrmOptionDescRec emacs_options
[] = {
3605 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
3606 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
3608 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
3609 XrmoptionSepArg
, NULL
},
3610 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
3612 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
3613 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
3614 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
3615 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
3616 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
3617 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
3618 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
3620 #endif /* USE_X_TOOLKIT */
3622 static int w32_initialized
= 0;
3624 struct w32_display_info
*
3625 w32_term_init (display_name
, xrm_option
, resource_name
)
3626 Lisp_Object display_name
;
3628 char *resource_name
;
3632 struct w32_display_info
*dpyinfo
;
3637 if (!w32_initialized
)
3640 w32_initialized
= 1;
3651 argv
[argc
++] = "-xrm";
3652 argv
[argc
++] = xrm_option
;
3656 dpyinfo
= &one_w32_display_info
;
3658 /* Put this display on the chain. */
3659 dpyinfo
->next
= NULL
;
3661 /* Put it on w32_display_name_list as well, to keep them parallel. */
3662 w32_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
3663 w32_display_name_list
);
3664 dpyinfo
->name_list_element
= XCONS (w32_display_name_list
)->car
;
3666 dpyinfo
->w32_id_name
3667 = (char *) xmalloc (XSTRING (Vinvocation_name
)->size
3668 + XSTRING (Vsystem_name
)->size
3670 sprintf (dpyinfo
->w32_id_name
, "%s@%s",
3671 XSTRING (Vinvocation_name
)->data
, XSTRING (Vsystem_name
)->data
);
3674 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
3675 resource_name
, EMACS_CLASS
);
3677 /* Put the rdb where we can find it in a way that works on
3679 dpyinfo
->xrdb
= xrdb
;
3681 hdc
= GetDC (GetDesktopWindow ());
3683 dpyinfo
->height
= GetDeviceCaps (hdc
, VERTRES
);
3684 dpyinfo
->width
= GetDeviceCaps (hdc
, HORZRES
);
3685 dpyinfo
->root_window
= GetDesktopWindow ();
3686 dpyinfo
->n_planes
= GetDeviceCaps (hdc
, PLANES
);
3687 dpyinfo
->n_cbits
= GetDeviceCaps (hdc
, BITSPIXEL
);
3688 dpyinfo
->height_in
= GetDeviceCaps (hdc
, LOGPIXELSX
);
3689 dpyinfo
->width_in
= GetDeviceCaps (hdc
, LOGPIXELSY
);
3690 dpyinfo
->has_palette
= GetDeviceCaps (hdc
, RASTERCAPS
) & RC_PALETTE
;
3691 dpyinfo
->grabbed
= 0;
3692 dpyinfo
->reference_count
= 0;
3693 dpyinfo
->n_fonts
= 0;
3694 dpyinfo
->font_table_size
= 0;
3695 dpyinfo
->bitmaps
= 0;
3696 dpyinfo
->bitmaps_size
= 0;
3697 dpyinfo
->bitmaps_last
= 0;
3698 dpyinfo
->mouse_face_mouse_frame
= 0;
3699 dpyinfo
->mouse_face_deferred_gc
= 0;
3700 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
3701 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
3702 dpyinfo
->mouse_face_face_id
= 0;
3703 dpyinfo
->mouse_face_window
= Qnil
;
3704 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
3705 dpyinfo
->mouse_face_defer
= 0;
3706 dpyinfo
->w32_focus_frame
= 0;
3707 dpyinfo
->w32_focus_event_frame
= 0;
3708 dpyinfo
->w32_highlight_frame
= 0;
3710 ReleaseDC (GetDesktopWindow (), hdc
);
3712 /* Determine if there is a middle mouse button, to allow parse_button
3713 to decide whether right mouse events should be mouse-2 or
3715 XSETINT (Vw32_num_mouse_buttons
, GetSystemMetrics (SM_CMOUSEBUTTONS
));
3717 /* initialise palette with white and black */
3720 defined_color (0, "white", &color
, 1);
3721 defined_color (0, "black", &color
, 1);
3724 #ifndef F_SETOWN_BUG
3726 #ifdef F_SETOWN_SOCK_NEG
3727 /* stdin is a socket here */
3728 fcntl (connection
, F_SETOWN
, -getpid ());
3729 #else /* ! defined (F_SETOWN_SOCK_NEG) */
3730 fcntl (connection
, F_SETOWN
, getpid ());
3731 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
3732 #endif /* ! defined (F_SETOWN) */
3733 #endif /* F_SETOWN_BUG */
3736 if (interrupt_input
)
3737 init_sigio (connection
);
3738 #endif /* ! defined (SIGIO) */
3745 /* Get rid of display DPYINFO, assuming all frames are already gone. */
3748 x_delete_display (dpyinfo
)
3749 struct w32_display_info
*dpyinfo
;
3751 /* Discard this display from w32_display_name_list and w32_display_list.
3752 We can't use Fdelq because that can quit. */
3753 if (! NILP (w32_display_name_list
)
3754 && EQ (XCONS (w32_display_name_list
)->car
, dpyinfo
->name_list_element
))
3755 w32_display_name_list
= XCONS (w32_display_name_list
)->cdr
;
3760 tail
= w32_display_name_list
;
3761 while (CONSP (tail
) && CONSP (XCONS (tail
)->cdr
))
3763 if (EQ (XCONS (XCONS (tail
)->cdr
)->car
,
3764 dpyinfo
->name_list_element
))
3766 XCONS (tail
)->cdr
= XCONS (XCONS (tail
)->cdr
)->cdr
;
3769 tail
= XCONS (tail
)->cdr
;
3773 /* free palette table */
3775 struct w32_palette_entry
* plist
;
3777 plist
= dpyinfo
->color_list
;
3780 struct w32_palette_entry
* pentry
= plist
;
3781 plist
= plist
->next
;
3784 dpyinfo
->color_list
= NULL
;
3785 if (dpyinfo
->palette
)
3786 DeleteObject(dpyinfo
->palette
);
3788 xfree (dpyinfo
->font_table
);
3789 xfree (dpyinfo
->w32_id_name
);
3792 /* Set up use of W32. */
3794 DWORD
windows_msg_worker ();
3798 clear_frame_hook
= w32_clear_frame
;
3799 clear_end_of_line_hook
= w32_clear_end_of_line
;
3800 ins_del_lines_hook
= w32_ins_del_lines
;
3801 change_line_highlight_hook
= w32_change_line_highlight
;
3802 insert_glyphs_hook
= w32_insert_glyphs
;
3803 write_glyphs_hook
= w32_write_glyphs
;
3804 delete_glyphs_hook
= w32_delete_glyphs
;
3805 ring_bell_hook
= w32_ring_bell
;
3806 reset_terminal_modes_hook
= w32_reset_terminal_modes
;
3807 set_terminal_modes_hook
= w32_set_terminal_modes
;
3808 update_begin_hook
= w32_update_begin
;
3809 update_end_hook
= w32_update_end
;
3810 set_terminal_window_hook
= w32_set_terminal_window
;
3811 read_socket_hook
= w32_read_socket
;
3812 frame_up_to_date_hook
= w32_frame_up_to_date
;
3813 cursor_to_hook
= w32_cursor_to
;
3814 reassert_line_highlight_hook
= w32_reassert_line_highlight
;
3815 mouse_position_hook
= w32_mouse_position
;
3816 frame_rehighlight_hook
= w32_frame_rehighlight
;
3817 frame_raise_lower_hook
= w32_frame_raise_lower
;
3818 set_vertical_scroll_bar_hook
= w32_set_vertical_scroll_bar
;
3819 condemn_scroll_bars_hook
= w32_condemn_scroll_bars
;
3820 redeem_scroll_bar_hook
= w32_redeem_scroll_bar
;
3821 judge_scroll_bars_hook
= w32_judge_scroll_bars
;
3823 scroll_region_ok
= 1; /* we'll scroll partial frames */
3824 char_ins_del_ok
= 0; /* just as fast to write the line */
3825 line_ins_del_ok
= 1; /* we'll just blt 'em */
3826 fast_clear_end_of_line
= 1; /* X does this well */
3827 memory_below_frame
= 0; /* we don't remember what scrolls
3831 /* Try to use interrupt input; if we can't, then start polling. */
3832 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
3834 /* Create the window thread - it will terminate itself or when the app terminates */
3838 dwMainThreadId
= GetCurrentThreadId ();
3839 DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
3840 GetCurrentProcess (), &hMainThread
, 0, TRUE
, DUPLICATE_SAME_ACCESS
);
3842 /* Wait for thread to start */
3847 PeekMessage (&msg
, NULL
, 0, 0, PM_NOREMOVE
);
3849 hWindowsThread
= CreateThread (NULL
, 0,
3850 (LPTHREAD_START_ROUTINE
) windows_msg_worker
,
3851 0, 0, &dwWindowsThreadId
);
3853 GetMessage (&msg
, NULL
, WM_EMACS_DONE
, WM_EMACS_DONE
);
3856 /* It is desirable that mainThread should have the same notion of
3857 focus window and active window as windowsThread. Unfortunately, the
3858 following call to AttachThreadInput, which should do precisely what
3859 we need, causes major problems when Emacs is linked as a console
3860 program. Unfortunately, we have good reasons for doing that, so
3861 instead we need to send messages to windowsThread to make some API
3862 calls for us (ones that affect, or depend on, the active/focus
3864 #ifdef ATTACH_THREADS
3865 AttachThreadInput (dwMainThreadId
, dwWindowsThreadId
, TRUE
);
3872 staticpro (&w32_display_name_list
);
3873 w32_display_name_list
= Qnil
;
3875 staticpro (&last_mouse_scroll_bar
);
3876 last_mouse_scroll_bar
= Qnil
;
3878 staticpro (&Qvendor_specific_keysyms
);
3879 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
3881 DEFVAR_INT ("w32-num-mouse-buttons",
3882 &Vw32_num_mouse_buttons
,
3883 "Number of physical mouse buttons.");
3884 Vw32_num_mouse_buttons
= Qnil
;
3886 DEFVAR_LISP ("w32-swap-mouse-buttons",
3887 &Vw32_swap_mouse_buttons
,
3888 "Swap the mapping of middle and right mouse buttons.\n\
3889 When nil, middle button is mouse-2 and right button is mouse-3.");
3890 Vw32_swap_mouse_buttons
= Qnil
;