]> code.delx.au - gnu-emacs/blob - src/xterm.c
Merged from miles@gnu.org--gnu-2005 (patch 659-663)
[gnu-emacs] / src / xterm.c
1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
23 /* Xt features made by Fred Pierresteguy. */
24
25 #include <config.h>
26
27 /* On 4.3 these lose if they come after xterm.h. */
28 /* Putting these at the beginning seems to be standard for other .c files. */
29 #include <signal.h>
30
31 #include <stdio.h>
32
33 #ifdef HAVE_X_WINDOWS
34
35 #include "lisp.h"
36 #include "blockinput.h"
37
38 /* Need syssignal.h for various externs and definitions that may be required
39 by some configurations for calls to signal later in this source file. */
40 #include "syssignal.h"
41
42 /* This may include sys/types.h, and that somehow loses
43 if this is not done before the other system files. */
44 #include "xterm.h"
45 #include <X11/cursorfont.h>
46
47 /* Load sys/types.h if not already loaded.
48 In some systems loading it twice is suicidal. */
49 #ifndef makedev
50 #include <sys/types.h>
51 #endif /* makedev */
52
53 #ifdef BSD_SYSTEM
54 #include <sys/ioctl.h>
55 #endif /* ! defined (BSD_SYSTEM) */
56
57 #include "systime.h"
58
59 #ifndef INCLUDED_FCNTL
60 #include <fcntl.h>
61 #endif
62 #include <ctype.h>
63 #include <errno.h>
64 #include <setjmp.h>
65 #include <sys/stat.h>
66 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
67 /* #include <sys/param.h> */
68
69 #include "charset.h"
70 #include "coding.h"
71 #include "ccl.h"
72 #include "frame.h"
73 #include "dispextern.h"
74 #include "fontset.h"
75 #include "termhooks.h"
76 #include "termopts.h"
77 #include "termchar.h"
78 #include "gnu.h"
79 #include "disptab.h"
80 #include "buffer.h"
81 #include "window.h"
82 #include "keyboard.h"
83 #include "intervals.h"
84 #include "process.h"
85 #include "atimer.h"
86 #include "keymap.h"
87
88 #ifdef USE_X_TOOLKIT
89 #include <X11/Shell.h>
90 #endif
91
92 #ifdef HAVE_SYS_TIME_H
93 #include <sys/time.h>
94 #endif
95 #ifdef HAVE_UNISTD_H
96 #include <unistd.h>
97 #endif
98
99 #ifdef USE_GTK
100 #include "gtkutil.h"
101 #endif
102
103 #ifdef USE_LUCID
104 extern int xlwmenu_window_p P_ ((Widget w, Window window));
105 extern void xlwmenu_redisplay P_ ((Widget));
106 #endif
107
108 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
109
110 extern void free_frame_menubar P_ ((struct frame *));
111 extern struct frame *x_menubar_window_to_frame P_ ((struct x_display_info *,
112 int));
113 #endif
114
115 #ifdef USE_X_TOOLKIT
116 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
117 #define HACK_EDITRES
118 extern void _XEditResCheckMessages ();
119 #endif /* not NO_EDITRES */
120
121 /* Include toolkit specific headers for the scroll bar widget. */
122
123 #ifdef USE_TOOLKIT_SCROLL_BARS
124 #if defined USE_MOTIF
125 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
126 #include <Xm/ScrollBar.h>
127 #else /* !USE_MOTIF i.e. use Xaw */
128
129 #ifdef HAVE_XAW3D
130 #include <X11/Xaw3d/Simple.h>
131 #include <X11/Xaw3d/Scrollbar.h>
132 #include <X11/Xaw3d/ThreeD.h>
133 #else /* !HAVE_XAW3D */
134 #include <X11/Xaw/Simple.h>
135 #include <X11/Xaw/Scrollbar.h>
136 #endif /* !HAVE_XAW3D */
137 #ifndef XtNpickTop
138 #define XtNpickTop "pickTop"
139 #endif /* !XtNpickTop */
140 #endif /* !USE_MOTIF */
141 #endif /* USE_TOOLKIT_SCROLL_BARS */
142
143 #endif /* USE_X_TOOLKIT */
144
145 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
146 #define x_any_window_to_frame x_window_to_frame
147 #define x_top_window_to_frame x_window_to_frame
148 #endif
149
150 #ifdef USE_X_TOOLKIT
151 #include "widget.h"
152 #ifndef XtNinitialState
153 #define XtNinitialState "initialState"
154 #endif
155 #endif
156
157 #define abs(x) ((x) < 0 ? -(x) : (x))
158
159 /* Default to using XIM if available. */
160 #ifdef USE_XIM
161 int use_xim = 1;
162 #else
163 int use_xim = 0; /* configure --without-xim */
164 #endif
165
166 \f
167
168 /* Non-nil means Emacs uses toolkit scroll bars. */
169
170 Lisp_Object Vx_toolkit_scroll_bars;
171
172 /* Non-zero means that a HELP_EVENT has been generated since Emacs
173 start. */
174
175 static int any_help_event_p;
176
177 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
178 static Lisp_Object last_window;
179
180 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
181
182 int x_use_underline_position_properties;
183
184 /* This is a chain of structures for all the X displays currently in
185 use. */
186
187 struct x_display_info *x_display_list;
188
189 /* This is a list of cons cells, each of the form (NAME
190 . FONT-LIST-CACHE), one for each element of x_display_list and in
191 the same order. NAME is the name of the frame. FONT-LIST-CACHE
192 records previous values returned by x-list-fonts. */
193
194 Lisp_Object x_display_name_list;
195
196 /* Frame being updated by update_frame. This is declared in term.c.
197 This is set by update_begin and looked at by all the XT functions.
198 It is zero while not inside an update. In that case, the XT
199 functions assume that `selected_frame' is the frame to apply to. */
200
201 extern struct frame *updating_frame;
202
203 /* This is a frame waiting to be auto-raised, within XTread_socket. */
204
205 struct frame *pending_autoraise_frame;
206
207 #ifdef USE_X_TOOLKIT
208 /* The application context for Xt use. */
209 XtAppContext Xt_app_con;
210 static String Xt_default_resources[] = {0};
211 #endif /* USE_X_TOOLKIT */
212
213 /* Non-zero means user is interacting with a toolkit scroll bar. */
214
215 static int toolkit_scroll_bar_interaction;
216
217 /* Non-zero means to not move point as a result of clicking on a
218 frame to focus it (when focus-follows-mouse is nil). */
219
220 int x_mouse_click_focus_ignore_position;
221
222 /* Non-zero timeout value means ignore next mouse click if it arrives
223 before that timeout elapses (i.e. as part of the same sequence of
224 events resulting from clicking on a frame to select it). */
225
226 static unsigned long ignore_next_mouse_click_timeout;
227
228 /* Mouse movement.
229
230 Formerly, we used PointerMotionHintMask (in standard_event_mask)
231 so that we would have to call XQueryPointer after each MotionNotify
232 event to ask for another such event. However, this made mouse tracking
233 slow, and there was a bug that made it eventually stop.
234
235 Simply asking for MotionNotify all the time seems to work better.
236
237 In order to avoid asking for motion events and then throwing most
238 of them away or busy-polling the server for mouse positions, we ask
239 the server for pointer motion hints. This means that we get only
240 one event per group of mouse movements. "Groups" are delimited by
241 other kinds of events (focus changes and button clicks, for
242 example), or by XQueryPointer calls; when one of these happens, we
243 get another MotionNotify event the next time the mouse moves. This
244 is at least as efficient as getting motion events when mouse
245 tracking is on, and I suspect only negligibly worse when tracking
246 is off. */
247
248 /* Where the mouse was last time we reported a mouse event. */
249
250 static XRectangle last_mouse_glyph;
251 static FRAME_PTR last_mouse_glyph_frame;
252 static Lisp_Object last_mouse_press_frame;
253
254 /* The scroll bar in which the last X motion event occurred.
255
256 If the last X motion event occurred in a scroll bar, we set this so
257 XTmouse_position can know whether to report a scroll bar motion or
258 an ordinary motion.
259
260 If the last X motion event didn't occur in a scroll bar, we set
261 this to Qnil, to tell XTmouse_position to return an ordinary motion
262 event. */
263
264 static Lisp_Object last_mouse_scroll_bar;
265
266 /* This is a hack. We would really prefer that XTmouse_position would
267 return the time associated with the position it returns, but there
268 doesn't seem to be any way to wrest the time-stamp from the server
269 along with the position query. So, we just keep track of the time
270 of the last movement we received, and return that in hopes that
271 it's somewhat accurate. */
272
273 static Time last_mouse_movement_time;
274
275 /* Incremented by XTread_socket whenever it really tries to read
276 events. */
277
278 #ifdef __STDC__
279 static int volatile input_signal_count;
280 #else
281 static int input_signal_count;
282 #endif
283
284 /* Used locally within XTread_socket. */
285
286 static int x_noop_count;
287
288 /* Initial values of argv and argc. */
289
290 extern char **initial_argv;
291 extern int initial_argc;
292
293 extern Lisp_Object Vcommand_line_args, Vsystem_name;
294
295 /* Tells if a window manager is present or not. */
296
297 extern Lisp_Object Vx_no_window_manager;
298
299 extern Lisp_Object Qeql;
300
301 extern int errno;
302
303 /* A mask of extra modifier bits to put into every keyboard char. */
304
305 extern EMACS_INT extra_keyboard_modifiers;
306
307 /* The keysyms to use for the various modifiers. */
308
309 Lisp_Object Vx_alt_keysym, Vx_hyper_keysym, Vx_meta_keysym, Vx_super_keysym;
310 Lisp_Object Vx_keysym_table;
311 static Lisp_Object Qalt, Qhyper, Qmeta, Qsuper, Qmodifier_value;
312
313 static Lisp_Object Qvendor_specific_keysyms;
314 static Lisp_Object Qlatin_1;
315
316 /* Used in x_flush. */
317
318 extern Lisp_Object Vinhibit_redisplay;
319
320 extern XrmDatabase x_load_resources P_ ((Display *, char *, char *, char *));
321 extern int x_bitmap_mask P_ ((FRAME_PTR, int));
322
323 static int x_alloc_nearest_color_1 P_ ((Display *, Colormap, XColor *));
324 static void x_set_window_size_1 P_ ((struct frame *, int, int, int));
325 static const XColor *x_color_cells P_ ((Display *, int *));
326 static void x_update_window_end P_ ((struct window *, int, int));
327 void x_delete_display P_ ((struct x_display_info *));
328 static unsigned int x_x_to_emacs_modifiers P_ ((struct x_display_info *,
329 unsigned));
330 static int x_io_error_quitter P_ ((Display *));
331 int x_catch_errors P_ ((Display *));
332 void x_uncatch_errors P_ ((Display *, int));
333 void x_lower_frame P_ ((struct frame *));
334 void x_scroll_bar_clear P_ ((struct frame *));
335 int x_had_errors_p P_ ((Display *));
336 void x_wm_set_size_hint P_ ((struct frame *, long, int));
337 void x_raise_frame P_ ((struct frame *));
338 void x_set_window_size P_ ((struct frame *, int, int, int));
339 void x_wm_set_window_state P_ ((struct frame *, int));
340 void x_wm_set_icon_pixmap P_ ((struct frame *, int));
341 struct device *x_create_device P_ ((struct x_display_info *));
342 void x_delete_device P_ ((struct device *));
343 void x_initialize P_ ((void));
344 static void x_font_min_bounds P_ ((XFontStruct *, int *, int *));
345 static int x_compute_min_glyph_bounds P_ ((struct frame *));
346 static void x_update_end P_ ((struct frame *));
347 static void XTframe_up_to_date P_ ((struct frame *));
348 static void XTset_terminal_modes P_ ((struct device *));
349 static void XTreset_terminal_modes P_ ((struct device *));
350 static void x_clear_frame P_ ((struct frame *));
351 static void frame_highlight P_ ((struct frame *));
352 static void frame_unhighlight P_ ((struct frame *));
353 static void x_new_focus_frame P_ ((struct x_display_info *, struct frame *));
354 static void x_focus_changed P_ ((int, int, struct x_display_info *,
355 struct frame *, struct input_event *));
356 static void x_detect_focus_change P_ ((struct x_display_info *,
357 XEvent *, struct input_event *));
358 static void XTframe_rehighlight P_ ((struct frame *));
359 static void x_frame_rehighlight P_ ((struct x_display_info *));
360 static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *));
361 static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int,
362 enum text_cursor_kinds));
363
364 static void x_clip_to_row P_ ((struct window *, struct glyph_row *, int, GC));
365 static void x_flush P_ ((struct frame *f));
366 static void x_update_begin P_ ((struct frame *));
367 static void x_update_window_begin P_ ((struct window *));
368 static void x_after_update_window_line P_ ((struct glyph_row *));
369 static struct scroll_bar *x_window_to_scroll_bar P_ ((Display *, Window));
370 static void x_scroll_bar_report_motion P_ ((struct frame **, Lisp_Object *,
371 enum scroll_bar_part *,
372 Lisp_Object *, Lisp_Object *,
373 unsigned long *));
374 static void x_check_fullscreen P_ ((struct frame *));
375 static void x_check_expected_move P_ ((struct frame *));
376 static int handle_one_xevent P_ ((struct x_display_info *, XEvent *,
377 int *, struct input_event *));
378
379
380 /* Flush display of frame F, or of all frames if F is null. */
381
382 static void
383 x_flush (f)
384 struct frame *f;
385 {
386 /* Don't call XFlush when it is not safe to redisplay; the X
387 connection may be broken. */
388 if (!NILP (Vinhibit_redisplay))
389 return;
390
391 BLOCK_INPUT;
392 if (f == NULL)
393 {
394 Lisp_Object rest, frame;
395 FOR_EACH_FRAME (rest, frame)
396 if (FRAME_X_P (XFRAME (frame)))
397 x_flush (XFRAME (frame));
398 }
399 else if (FRAME_X_P (f))
400 XFlush (FRAME_X_DISPLAY (f));
401 UNBLOCK_INPUT;
402 }
403
404
405 /* Remove calls to XFlush by defining XFlush to an empty replacement.
406 Calls to XFlush should be unnecessary because the X output buffer
407 is flushed automatically as needed by calls to XPending,
408 XNextEvent, or XWindowEvent according to the XFlush man page.
409 XTread_socket calls XPending. Removing XFlush improves
410 performance. */
411
412 #define XFlush(DISPLAY) (void) 0
413
414 \f
415 /***********************************************************************
416 Debugging
417 ***********************************************************************/
418
419 #if 0
420
421 /* This is a function useful for recording debugging information about
422 the sequence of occurrences in this file. */
423
424 struct record
425 {
426 char *locus;
427 int type;
428 };
429
430 struct record event_record[100];
431
432 int event_record_index;
433
434 record_event (locus, type)
435 char *locus;
436 int type;
437 {
438 if (event_record_index == sizeof (event_record) / sizeof (struct record))
439 event_record_index = 0;
440
441 event_record[event_record_index].locus = locus;
442 event_record[event_record_index].type = type;
443 event_record_index++;
444 }
445
446 #endif /* 0 */
447
448
449 \f
450 /* Return the struct x_display_info corresponding to DPY. */
451
452 struct x_display_info *
453 x_display_info_for_display (dpy)
454 Display *dpy;
455 {
456 struct x_display_info *dpyinfo;
457
458 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
459 if (dpyinfo->display == dpy)
460 return dpyinfo;
461
462 return 0;
463 }
464
465
466 \f
467 /***********************************************************************
468 Starting and ending an update
469 ***********************************************************************/
470
471 /* Start an update of frame F. This function is installed as a hook
472 for update_begin, i.e. it is called when update_begin is called.
473 This function is called prior to calls to x_update_window_begin for
474 each window being updated. Currently, there is nothing to do here
475 because all interesting stuff is done on a window basis. */
476
477 static void
478 x_update_begin (f)
479 struct frame *f;
480 {
481 /* Nothing to do. */
482 }
483
484
485 /* Start update of window W. Set the global variable updated_window
486 to the window being updated and set output_cursor to the cursor
487 position of W. */
488
489 static void
490 x_update_window_begin (w)
491 struct window *w;
492 {
493 struct frame *f = XFRAME (WINDOW_FRAME (w));
494 struct x_display_info *display_info = FRAME_X_DISPLAY_INFO (f);
495
496 updated_window = w;
497 set_output_cursor (&w->cursor);
498
499 BLOCK_INPUT;
500
501 if (f == display_info->mouse_face_mouse_frame)
502 {
503 /* Don't do highlighting for mouse motion during the update. */
504 display_info->mouse_face_defer = 1;
505
506 /* If F needs to be redrawn, simply forget about any prior mouse
507 highlighting. */
508 if (FRAME_GARBAGED_P (f))
509 display_info->mouse_face_window = Qnil;
510
511 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
512 their mouse_face_p flag set, which means that they are always
513 unequal to rows in a desired matrix which never have that
514 flag set. So, rows containing mouse-face glyphs are never
515 scrolled, and we don't have to switch the mouse highlight off
516 here to prevent it from being scrolled. */
517
518 /* Can we tell that this update does not affect the window
519 where the mouse highlight is? If so, no need to turn off.
520 Likewise, don't do anything if the frame is garbaged;
521 in that case, the frame's current matrix that we would use
522 is all wrong, and we will redisplay that line anyway. */
523 if (!NILP (display_info->mouse_face_window)
524 && w == XWINDOW (display_info->mouse_face_window))
525 {
526 int i;
527
528 for (i = 0; i < w->desired_matrix->nrows; ++i)
529 if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
530 break;
531
532 if (i < w->desired_matrix->nrows)
533 clear_mouse_face (display_info);
534 }
535 #endif /* 0 */
536 }
537
538 UNBLOCK_INPUT;
539 }
540
541
542 /* Draw a vertical window border from (x,y0) to (x,y1) */
543
544 static void
545 x_draw_vertical_window_border (w, x, y0, y1)
546 struct window *w;
547 int x, y0, y1;
548 {
549 struct frame *f = XFRAME (WINDOW_FRAME (w));
550 struct face *face;
551
552 face = FACE_FROM_ID (f, VERTICAL_BORDER_FACE_ID);
553 if (face)
554 XSetForeground (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc,
555 face->foreground);
556
557 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
558 f->output_data.x->normal_gc, x, y0, x, y1);
559 }
560
561 /* End update of window W (which is equal to updated_window).
562
563 Draw vertical borders between horizontally adjacent windows, and
564 display W's cursor if CURSOR_ON_P is non-zero.
565
566 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
567 glyphs in mouse-face were overwritten. In that case we have to
568 make sure that the mouse-highlight is properly redrawn.
569
570 W may be a menu bar pseudo-window in case we don't have X toolkit
571 support. Such windows don't have a cursor, so don't display it
572 here. */
573
574 static void
575 x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
576 struct window *w;
577 int cursor_on_p, mouse_face_overwritten_p;
578 {
579 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
580
581 if (!w->pseudo_window_p)
582 {
583 BLOCK_INPUT;
584
585 if (cursor_on_p)
586 display_and_set_cursor (w, 1, output_cursor.hpos,
587 output_cursor.vpos,
588 output_cursor.x, output_cursor.y);
589
590 if (draw_window_fringes (w, 1))
591 x_draw_vertical_border (w);
592
593 UNBLOCK_INPUT;
594 }
595
596 /* If a row with mouse-face was overwritten, arrange for
597 XTframe_up_to_date to redisplay the mouse highlight. */
598 if (mouse_face_overwritten_p)
599 {
600 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
601 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
602 dpyinfo->mouse_face_window = Qnil;
603 }
604
605 updated_window = NULL;
606 }
607
608
609 /* End update of frame F. This function is installed as a hook in
610 update_end. */
611
612 static void
613 x_update_end (f)
614 struct frame *f;
615 {
616 /* Mouse highlight may be displayed again. */
617 FRAME_X_DISPLAY_INFO (f)->mouse_face_defer = 0;
618
619 #ifndef XFlush
620 BLOCK_INPUT;
621 XFlush (FRAME_X_DISPLAY (f));
622 UNBLOCK_INPUT;
623 #endif
624 }
625
626
627 /* This function is called from various places in xdisp.c whenever a
628 complete update has been performed. The global variable
629 updated_window is not available here. */
630
631 static void
632 XTframe_up_to_date (f)
633 struct frame *f;
634 {
635 if (FRAME_X_P (f))
636 {
637 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
638
639 if (dpyinfo->mouse_face_deferred_gc
640 || f == dpyinfo->mouse_face_mouse_frame)
641 {
642 BLOCK_INPUT;
643 if (dpyinfo->mouse_face_mouse_frame)
644 note_mouse_highlight (dpyinfo->mouse_face_mouse_frame,
645 dpyinfo->mouse_face_mouse_x,
646 dpyinfo->mouse_face_mouse_y);
647 dpyinfo->mouse_face_deferred_gc = 0;
648 UNBLOCK_INPUT;
649 }
650 }
651 }
652
653
654 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
655 arrow bitmaps, or clear the fringes if no bitmaps are required
656 before DESIRED_ROW is made current. The window being updated is
657 found in updated_window. This function It is called from
658 update_window_line only if it is known that there are differences
659 between bitmaps to be drawn between current row and DESIRED_ROW. */
660
661 static void
662 x_after_update_window_line (desired_row)
663 struct glyph_row *desired_row;
664 {
665 struct window *w = updated_window;
666 struct frame *f;
667 int width, height;
668
669 xassert (w);
670
671 if (!desired_row->mode_line_p && !w->pseudo_window_p)
672 desired_row->redraw_fringe_bitmaps_p = 1;
673
674 /* When a window has disappeared, make sure that no rest of
675 full-width rows stays visible in the internal border. Could
676 check here if updated_window is the leftmost/rightmost window,
677 but I guess it's not worth doing since vertically split windows
678 are almost never used, internal border is rarely set, and the
679 overhead is very small. */
680 if (windows_or_buffers_changed
681 && desired_row->full_width_p
682 && (f = XFRAME (w->frame),
683 width = FRAME_INTERNAL_BORDER_WIDTH (f),
684 width != 0)
685 && (height = desired_row->visible_height,
686 height > 0))
687 {
688 int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
689
690 /* Internal border is drawn below the tool bar. */
691 if (WINDOWP (f->tool_bar_window)
692 && w == XWINDOW (f->tool_bar_window))
693 y -= width;
694
695 BLOCK_INPUT;
696 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
697 0, y, width, height, False);
698 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
699 FRAME_PIXEL_WIDTH (f) - width,
700 y, width, height, False);
701 UNBLOCK_INPUT;
702 }
703 }
704
705 static void
706 x_draw_fringe_bitmap (w, row, p)
707 struct window *w;
708 struct glyph_row *row;
709 struct draw_fringe_bitmap_params *p;
710 {
711 struct frame *f = XFRAME (WINDOW_FRAME (w));
712 Display *display = FRAME_X_DISPLAY (f);
713 Window window = FRAME_X_WINDOW (f);
714 GC gc = f->output_data.x->normal_gc;
715 struct face *face = p->face;
716 int rowY;
717
718 /* Must clip because of partially visible lines. */
719 rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
720 if (p->y < rowY)
721 {
722 /* Adjust position of "bottom aligned" bitmap on partially
723 visible last row. */
724 int oldY = row->y;
725 int oldVH = row->visible_height;
726 row->visible_height = p->h;
727 row->y -= rowY - p->y;
728 x_clip_to_row (w, row, -1, gc);
729 row->y = oldY;
730 row->visible_height = oldVH;
731 }
732 else
733 x_clip_to_row (w, row, -1, gc);
734
735 if (p->bx >= 0 && !p->overlay_p)
736 {
737 /* In case the same realized face is used for fringes and
738 for something displayed in the text (e.g. face `region' on
739 mono-displays, the fill style may have been changed to
740 FillSolid in x_draw_glyph_string_background. */
741 if (face->stipple)
742 XSetFillStyle (display, face->gc, FillOpaqueStippled);
743 else
744 XSetForeground (display, face->gc, face->background);
745
746 XFillRectangle (display, window, face->gc,
747 p->bx, p->by, p->nx, p->ny);
748
749 if (!face->stipple)
750 XSetForeground (display, face->gc, face->foreground);
751 }
752
753 if (p->which)
754 {
755 unsigned char *bits;
756 Pixmap pixmap, clipmask = (Pixmap) 0;
757 int depth = DefaultDepthOfScreen (FRAME_X_SCREEN (f));
758 XGCValues gcv;
759
760 if (p->wd > 8)
761 bits = (unsigned char *)(p->bits + p->dh);
762 else
763 bits = (unsigned char *)p->bits + p->dh;
764
765 /* Draw the bitmap. I believe these small pixmaps can be cached
766 by the server. */
767 pixmap = XCreatePixmapFromBitmapData (display, window, bits, p->wd, p->h,
768 (p->cursor_p
769 ? (p->overlay_p ? face->background
770 : f->output_data.x->cursor_pixel)
771 : face->foreground),
772 face->background, depth);
773
774 if (p->overlay_p)
775 {
776 clipmask = XCreatePixmapFromBitmapData (display,
777 FRAME_X_DISPLAY_INFO (f)->root_window,
778 bits, p->wd, p->h,
779 1, 0, 1);
780 gcv.clip_mask = clipmask;
781 gcv.clip_x_origin = p->x;
782 gcv.clip_y_origin = p->y;
783 XChangeGC (display, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
784 }
785
786 XCopyArea (display, pixmap, window, gc, 0, 0,
787 p->wd, p->h, p->x, p->y);
788 XFreePixmap (display, pixmap);
789
790 if (p->overlay_p)
791 {
792 gcv.clip_mask = (Pixmap) 0;
793 XChangeGC (display, gc, GCClipMask, &gcv);
794 XFreePixmap (display, clipmask);
795 }
796 }
797
798 XSetClipMask (display, gc, None);
799 }
800
801 \f
802
803 /* This is called when starting Emacs and when restarting after
804 suspend. When starting Emacs, no X window is mapped. And nothing
805 must be done to Emacs's own window if it is suspended (though that
806 rarely happens). */
807
808 static void
809 XTset_terminal_modes (struct device *device)
810 {
811 }
812
813 /* This is called when exiting or suspending Emacs. Exiting will make
814 the X-windows go away, and suspending requires no action. */
815
816 static void
817 XTreset_terminal_modes (struct device *device)
818 {
819 }
820
821
822 \f
823 /***********************************************************************
824 Display Iterator
825 ***********************************************************************/
826
827 /* Function prototypes of this page. */
828
829 static int x_encode_char P_ ((int, XChar2b *, struct font_info *, int *));
830
831
832 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
833 is not contained in the font. */
834
835 static XCharStruct *
836 x_per_char_metric (font, char2b, font_type)
837 XFontStruct *font;
838 XChar2b *char2b;
839 int font_type; /* unused on X */
840 {
841 /* The result metric information. */
842 XCharStruct *pcm = NULL;
843
844 xassert (font && char2b);
845
846 if (font->per_char != NULL)
847 {
848 if (font->min_byte1 == 0 && font->max_byte1 == 0)
849 {
850 /* min_char_or_byte2 specifies the linear character index
851 corresponding to the first element of the per_char array,
852 max_char_or_byte2 is the index of the last character. A
853 character with non-zero CHAR2B->byte1 is not in the font.
854 A character with byte2 less than min_char_or_byte2 or
855 greater max_char_or_byte2 is not in the font. */
856 if (char2b->byte1 == 0
857 && char2b->byte2 >= font->min_char_or_byte2
858 && char2b->byte2 <= font->max_char_or_byte2)
859 pcm = font->per_char + char2b->byte2 - font->min_char_or_byte2;
860 }
861 else
862 {
863 /* If either min_byte1 or max_byte1 are nonzero, both
864 min_char_or_byte2 and max_char_or_byte2 are less than
865 256, and the 2-byte character index values corresponding
866 to the per_char array element N (counting from 0) are:
867
868 byte1 = N/D + min_byte1
869 byte2 = N\D + min_char_or_byte2
870
871 where:
872
873 D = max_char_or_byte2 - min_char_or_byte2 + 1
874 / = integer division
875 \ = integer modulus */
876 if (char2b->byte1 >= font->min_byte1
877 && char2b->byte1 <= font->max_byte1
878 && char2b->byte2 >= font->min_char_or_byte2
879 && char2b->byte2 <= font->max_char_or_byte2)
880 {
881 pcm = (font->per_char
882 + ((font->max_char_or_byte2 - font->min_char_or_byte2 + 1)
883 * (char2b->byte1 - font->min_byte1))
884 + (char2b->byte2 - font->min_char_or_byte2));
885 }
886 }
887 }
888 else
889 {
890 /* If the per_char pointer is null, all glyphs between the first
891 and last character indexes inclusive have the same
892 information, as given by both min_bounds and max_bounds. */
893 if (char2b->byte2 >= font->min_char_or_byte2
894 && char2b->byte2 <= font->max_char_or_byte2)
895 pcm = &font->max_bounds;
896 }
897
898 return ((pcm == NULL
899 || (pcm->width == 0 && (pcm->rbearing - pcm->lbearing) == 0))
900 ? NULL : pcm);
901 }
902
903
904 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
905 the two-byte form of C. Encoding is returned in *CHAR2B. */
906
907 static int
908 x_encode_char (c, char2b, font_info, two_byte_p)
909 int c;
910 XChar2b *char2b;
911 struct font_info *font_info;
912 int *two_byte_p;
913 {
914 int charset = CHAR_CHARSET (c);
915 XFontStruct *font = font_info->font;
916
917 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
918 This may be either a program in a special encoder language or a
919 fixed encoding. */
920 if (font_info->font_encoder)
921 {
922 /* It's a program. */
923 struct ccl_program *ccl = font_info->font_encoder;
924
925 check_ccl_update (ccl);
926 if (CHARSET_DIMENSION (charset) == 1)
927 {
928 ccl->reg[0] = charset;
929 ccl->reg[1] = char2b->byte2;
930 ccl->reg[2] = -1;
931 }
932 else
933 {
934 ccl->reg[0] = charset;
935 ccl->reg[1] = char2b->byte1;
936 ccl->reg[2] = char2b->byte2;
937 }
938
939 ccl_driver (ccl, NULL, NULL, 0, 0, NULL);
940
941 /* We assume that MSBs are appropriately set/reset by CCL
942 program. */
943 if (font->max_byte1 == 0) /* 1-byte font */
944 char2b->byte1 = 0, char2b->byte2 = ccl->reg[1];
945 else
946 char2b->byte1 = ccl->reg[1], char2b->byte2 = ccl->reg[2];
947 }
948 else if (font_info->encoding[charset])
949 {
950 /* Fixed encoding scheme. See fontset.h for the meaning of the
951 encoding numbers. */
952 int enc = font_info->encoding[charset];
953
954 if ((enc == 1 || enc == 2)
955 && CHARSET_DIMENSION (charset) == 2)
956 char2b->byte1 |= 0x80;
957
958 if (enc == 1 || enc == 3)
959 char2b->byte2 |= 0x80;
960 }
961
962 if (two_byte_p)
963 *two_byte_p = ((XFontStruct *) (font_info->font))->max_byte1 > 0;
964
965 return FONT_TYPE_UNKNOWN;
966 }
967
968
969 \f
970 /***********************************************************************
971 Glyph display
972 ***********************************************************************/
973
974
975
976 static void x_set_glyph_string_clipping P_ ((struct glyph_string *));
977 static void x_set_glyph_string_gc P_ ((struct glyph_string *));
978 static void x_draw_glyph_string_background P_ ((struct glyph_string *,
979 int));
980 static void x_draw_glyph_string_foreground P_ ((struct glyph_string *));
981 static void x_draw_composite_glyph_string_foreground P_ ((struct glyph_string *));
982 static void x_draw_glyph_string_box P_ ((struct glyph_string *));
983 static void x_draw_glyph_string P_ ((struct glyph_string *));
984 static void x_compute_glyph_string_overhangs P_ ((struct glyph_string *));
985 static void x_set_cursor_gc P_ ((struct glyph_string *));
986 static void x_set_mode_line_face_gc P_ ((struct glyph_string *));
987 static void x_set_mouse_face_gc P_ ((struct glyph_string *));
988 static int x_alloc_lighter_color P_ ((struct frame *, Display *, Colormap,
989 unsigned long *, double, int));
990 static void x_setup_relief_color P_ ((struct frame *, struct relief *,
991 double, int, unsigned long));
992 static void x_setup_relief_colors P_ ((struct glyph_string *));
993 static void x_draw_image_glyph_string P_ ((struct glyph_string *));
994 static void x_draw_image_relief P_ ((struct glyph_string *));
995 static void x_draw_image_foreground P_ ((struct glyph_string *));
996 static void x_draw_image_foreground_1 P_ ((struct glyph_string *, Pixmap));
997 static void x_clear_glyph_string_rect P_ ((struct glyph_string *, int,
998 int, int, int));
999 static void x_draw_relief_rect P_ ((struct frame *, int, int, int, int,
1000 int, int, int, int, int, int,
1001 XRectangle *));
1002 static void x_draw_box_rect P_ ((struct glyph_string *, int, int, int, int,
1003 int, int, int, XRectangle *));
1004
1005 #if GLYPH_DEBUG
1006 static void x_check_font P_ ((struct frame *, XFontStruct *));
1007 #endif
1008
1009
1010 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1011 face. */
1012
1013 static void
1014 x_set_cursor_gc (s)
1015 struct glyph_string *s;
1016 {
1017 if (s->font == FRAME_FONT (s->f)
1018 && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
1019 && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
1020 && !s->cmp)
1021 s->gc = s->f->output_data.x->cursor_gc;
1022 else
1023 {
1024 /* Cursor on non-default face: must merge. */
1025 XGCValues xgcv;
1026 unsigned long mask;
1027
1028 xgcv.background = s->f->output_data.x->cursor_pixel;
1029 xgcv.foreground = s->face->background;
1030
1031 /* If the glyph would be invisible, try a different foreground. */
1032 if (xgcv.foreground == xgcv.background)
1033 xgcv.foreground = s->face->foreground;
1034 if (xgcv.foreground == xgcv.background)
1035 xgcv.foreground = s->f->output_data.x->cursor_foreground_pixel;
1036 if (xgcv.foreground == xgcv.background)
1037 xgcv.foreground = s->face->foreground;
1038
1039 /* Make sure the cursor is distinct from text in this face. */
1040 if (xgcv.background == s->face->background
1041 && xgcv.foreground == s->face->foreground)
1042 {
1043 xgcv.background = s->face->foreground;
1044 xgcv.foreground = s->face->background;
1045 }
1046
1047 IF_DEBUG (x_check_font (s->f, s->font));
1048 xgcv.font = s->font->fid;
1049 xgcv.graphics_exposures = False;
1050 mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
1051
1052 if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
1053 XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
1054 mask, &xgcv);
1055 else
1056 FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc
1057 = XCreateGC (s->display, s->window, mask, &xgcv);
1058
1059 s->gc = FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc;
1060 }
1061 }
1062
1063
1064 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1065
1066 static void
1067 x_set_mouse_face_gc (s)
1068 struct glyph_string *s;
1069 {
1070 int face_id;
1071 struct face *face;
1072
1073 /* What face has to be used last for the mouse face? */
1074 face_id = FRAME_X_DISPLAY_INFO (s->f)->mouse_face_face_id;
1075 face = FACE_FROM_ID (s->f, face_id);
1076 if (face == NULL)
1077 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
1078
1079 if (s->first_glyph->type == CHAR_GLYPH)
1080 face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch);
1081 else
1082 face_id = FACE_FOR_CHAR (s->f, face, 0);
1083 s->face = FACE_FROM_ID (s->f, face_id);
1084 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
1085
1086 /* If font in this face is same as S->font, use it. */
1087 if (s->font == s->face->font)
1088 s->gc = s->face->gc;
1089 else
1090 {
1091 /* Otherwise construct scratch_cursor_gc with values from FACE
1092 but font FONT. */
1093 XGCValues xgcv;
1094 unsigned long mask;
1095
1096 xgcv.background = s->face->background;
1097 xgcv.foreground = s->face->foreground;
1098 IF_DEBUG (x_check_font (s->f, s->font));
1099 xgcv.font = s->font->fid;
1100 xgcv.graphics_exposures = False;
1101 mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
1102
1103 if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
1104 XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
1105 mask, &xgcv);
1106 else
1107 FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc
1108 = XCreateGC (s->display, s->window, mask, &xgcv);
1109
1110 s->gc = FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc;
1111 }
1112
1113 xassert (s->gc != 0);
1114 }
1115
1116
1117 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1118 Faces to use in the mode line have already been computed when the
1119 matrix was built, so there isn't much to do, here. */
1120
1121 static INLINE void
1122 x_set_mode_line_face_gc (s)
1123 struct glyph_string *s;
1124 {
1125 s->gc = s->face->gc;
1126 }
1127
1128
1129 /* Set S->gc of glyph string S for drawing that glyph string. Set
1130 S->stippled_p to a non-zero value if the face of S has a stipple
1131 pattern. */
1132
1133 static INLINE void
1134 x_set_glyph_string_gc (s)
1135 struct glyph_string *s;
1136 {
1137 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
1138
1139 if (s->hl == DRAW_NORMAL_TEXT)
1140 {
1141 s->gc = s->face->gc;
1142 s->stippled_p = s->face->stipple != 0;
1143 }
1144 else if (s->hl == DRAW_INVERSE_VIDEO)
1145 {
1146 x_set_mode_line_face_gc (s);
1147 s->stippled_p = s->face->stipple != 0;
1148 }
1149 else if (s->hl == DRAW_CURSOR)
1150 {
1151 x_set_cursor_gc (s);
1152 s->stippled_p = 0;
1153 }
1154 else if (s->hl == DRAW_MOUSE_FACE)
1155 {
1156 x_set_mouse_face_gc (s);
1157 s->stippled_p = s->face->stipple != 0;
1158 }
1159 else if (s->hl == DRAW_IMAGE_RAISED
1160 || s->hl == DRAW_IMAGE_SUNKEN)
1161 {
1162 s->gc = s->face->gc;
1163 s->stippled_p = s->face->stipple != 0;
1164 }
1165 else
1166 {
1167 s->gc = s->face->gc;
1168 s->stippled_p = s->face->stipple != 0;
1169 }
1170
1171 /* GC must have been set. */
1172 xassert (s->gc != 0);
1173 }
1174
1175
1176 /* Set clipping for output of glyph string S. S may be part of a mode
1177 line or menu if we don't have X toolkit support. */
1178
1179 static INLINE void
1180 x_set_glyph_string_clipping (s)
1181 struct glyph_string *s;
1182 {
1183 XRectangle r;
1184 get_glyph_string_clip_rect (s, &r);
1185 XSetClipRectangles (s->display, s->gc, 0, 0, &r, 1, Unsorted);
1186 }
1187
1188
1189 /* RIF:
1190 Compute left and right overhang of glyph string S. If S is a glyph
1191 string for a composition, assume overhangs don't exist. */
1192
1193 static void
1194 x_compute_glyph_string_overhangs (s)
1195 struct glyph_string *s;
1196 {
1197 if (s->cmp == NULL
1198 && s->first_glyph->type == CHAR_GLYPH)
1199 {
1200 XCharStruct cs;
1201 int direction, font_ascent, font_descent;
1202 XTextExtents16 (s->font, s->char2b, s->nchars, &direction,
1203 &font_ascent, &font_descent, &cs);
1204 s->right_overhang = cs.rbearing > cs.width ? cs.rbearing - cs.width : 0;
1205 s->left_overhang = cs.lbearing < 0 ? -cs.lbearing : 0;
1206 }
1207 }
1208
1209
1210 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1211
1212 static INLINE void
1213 x_clear_glyph_string_rect (s, x, y, w, h)
1214 struct glyph_string *s;
1215 int x, y, w, h;
1216 {
1217 XGCValues xgcv;
1218 XGetGCValues (s->display, s->gc, GCForeground | GCBackground, &xgcv);
1219 XSetForeground (s->display, s->gc, xgcv.background);
1220 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
1221 XSetForeground (s->display, s->gc, xgcv.foreground);
1222 }
1223
1224
1225 /* Draw the background of glyph_string S. If S->background_filled_p
1226 is non-zero don't draw it. FORCE_P non-zero means draw the
1227 background even if it wouldn't be drawn normally. This is used
1228 when a string preceding S draws into the background of S, or S
1229 contains the first component of a composition. */
1230
1231 static void
1232 x_draw_glyph_string_background (s, force_p)
1233 struct glyph_string *s;
1234 int force_p;
1235 {
1236 /* Nothing to do if background has already been drawn or if it
1237 shouldn't be drawn in the first place. */
1238 if (!s->background_filled_p)
1239 {
1240 int box_line_width = max (s->face->box_line_width, 0);
1241
1242 if (s->stippled_p)
1243 {
1244 /* Fill background with a stipple pattern. */
1245 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
1246 XFillRectangle (s->display, s->window, s->gc, s->x,
1247 s->y + box_line_width,
1248 s->background_width,
1249 s->height - 2 * box_line_width);
1250 XSetFillStyle (s->display, s->gc, FillSolid);
1251 s->background_filled_p = 1;
1252 }
1253 else if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
1254 || s->font_not_found_p
1255 || s->extends_to_end_of_line_p
1256 || force_p)
1257 {
1258 x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
1259 s->background_width,
1260 s->height - 2 * box_line_width);
1261 s->background_filled_p = 1;
1262 }
1263 }
1264 }
1265
1266
1267 /* Draw the foreground of glyph string S. */
1268
1269 static void
1270 x_draw_glyph_string_foreground (s)
1271 struct glyph_string *s;
1272 {
1273 int i, x;
1274
1275 /* If first glyph of S has a left box line, start drawing the text
1276 of S to the right of that box line. */
1277 if (s->face->box != FACE_NO_BOX
1278 && s->first_glyph->left_box_line_p)
1279 x = s->x + abs (s->face->box_line_width);
1280 else
1281 x = s->x;
1282
1283 /* Draw characters of S as rectangles if S's font could not be
1284 loaded. */
1285 if (s->font_not_found_p)
1286 {
1287 for (i = 0; i < s->nchars; ++i)
1288 {
1289 struct glyph *g = s->first_glyph + i;
1290 XDrawRectangle (s->display, s->window,
1291 s->gc, x, s->y, g->pixel_width - 1,
1292 s->height - 1);
1293 x += g->pixel_width;
1294 }
1295 }
1296 else
1297 {
1298 char *char1b = (char *) s->char2b;
1299 int boff = s->font_info->baseline_offset;
1300
1301 if (s->font_info->vertical_centering)
1302 boff = VCENTER_BASELINE_OFFSET (s->font, s->f) - boff;
1303
1304 /* If we can use 8-bit functions, condense S->char2b. */
1305 if (!s->two_byte_p)
1306 for (i = 0; i < s->nchars; ++i)
1307 char1b[i] = s->char2b[i].byte2;
1308
1309 /* Draw text with XDrawString if background has already been
1310 filled. Otherwise, use XDrawImageString. (Note that
1311 XDrawImageString is usually faster than XDrawString.) Always
1312 use XDrawImageString when drawing the cursor so that there is
1313 no chance that characters under a box cursor are invisible. */
1314 if (s->for_overlaps
1315 || (s->background_filled_p && s->hl != DRAW_CURSOR))
1316 {
1317 /* Draw characters with 16-bit or 8-bit functions. */
1318 if (s->two_byte_p)
1319 XDrawString16 (s->display, s->window, s->gc, x,
1320 s->ybase - boff, s->char2b, s->nchars);
1321 else
1322 XDrawString (s->display, s->window, s->gc, x,
1323 s->ybase - boff, char1b, s->nchars);
1324 }
1325 else
1326 {
1327 if (s->two_byte_p)
1328 XDrawImageString16 (s->display, s->window, s->gc, x,
1329 s->ybase - boff, s->char2b, s->nchars);
1330 else
1331 XDrawImageString (s->display, s->window, s->gc, x,
1332 s->ybase - boff, char1b, s->nchars);
1333 }
1334
1335 if (s->face->overstrike)
1336 {
1337 /* For overstriking (to simulate bold-face), draw the
1338 characters again shifted to the right by one pixel. */
1339 if (s->two_byte_p)
1340 XDrawString16 (s->display, s->window, s->gc, x + 1,
1341 s->ybase - boff, s->char2b, s->nchars);
1342 else
1343 XDrawString (s->display, s->window, s->gc, x + 1,
1344 s->ybase - boff, char1b, s->nchars);
1345 }
1346 }
1347 }
1348
1349 /* Draw the foreground of composite glyph string S. */
1350
1351 static void
1352 x_draw_composite_glyph_string_foreground (s)
1353 struct glyph_string *s;
1354 {
1355 int i, x;
1356
1357 /* If first glyph of S has a left box line, start drawing the text
1358 of S to the right of that box line. */
1359 if (s->face->box != FACE_NO_BOX
1360 && s->first_glyph->left_box_line_p)
1361 x = s->x + abs (s->face->box_line_width);
1362 else
1363 x = s->x;
1364
1365 /* S is a glyph string for a composition. S->gidx is the index of
1366 the first character drawn for glyphs of this composition.
1367 S->gidx == 0 means we are drawing the very first character of
1368 this composition. */
1369
1370 /* Draw a rectangle for the composition if the font for the very
1371 first character of the composition could not be loaded. */
1372 if (s->font_not_found_p)
1373 {
1374 if (s->gidx == 0)
1375 XDrawRectangle (s->display, s->window, s->gc, x, s->y,
1376 s->width - 1, s->height - 1);
1377 }
1378 else
1379 {
1380 for (i = 0; i < s->nchars; i++, ++s->gidx)
1381 {
1382 XDrawString16 (s->display, s->window, s->gc,
1383 x + s->cmp->offsets[s->gidx * 2],
1384 s->ybase - s->cmp->offsets[s->gidx * 2 + 1],
1385 s->char2b + i, 1);
1386 if (s->face->overstrike)
1387 XDrawString16 (s->display, s->window, s->gc,
1388 x + s->cmp->offsets[s->gidx * 2] + 1,
1389 s->ybase - s->cmp->offsets[s->gidx * 2 + 1],
1390 s->char2b + i, 1);
1391 }
1392 }
1393 }
1394
1395
1396 #ifdef USE_X_TOOLKIT
1397
1398 static struct frame *x_frame_of_widget P_ ((Widget));
1399 static Boolean cvt_string_to_pixel P_ ((Display *, XrmValue *, Cardinal *,
1400 XrmValue *, XrmValue *, XtPointer *));
1401 static void cvt_pixel_dtor P_ ((XtAppContext, XrmValue *, XtPointer,
1402 XrmValue *, Cardinal *));
1403
1404
1405 /* Return the frame on which widget WIDGET is used.. Abort if frame
1406 cannot be determined. */
1407
1408 static struct frame *
1409 x_frame_of_widget (widget)
1410 Widget widget;
1411 {
1412 struct x_display_info *dpyinfo;
1413 Lisp_Object tail;
1414 struct frame *f;
1415
1416 dpyinfo = x_display_info_for_display (XtDisplay (widget));
1417
1418 /* Find the top-level shell of the widget. Note that this function
1419 can be called when the widget is not yet realized, so XtWindow
1420 (widget) == 0. That's the reason we can't simply use
1421 x_any_window_to_frame. */
1422 while (!XtIsTopLevelShell (widget))
1423 widget = XtParent (widget);
1424
1425 /* Look for a frame with that top-level widget. Allocate the color
1426 on that frame to get the right gamma correction value. */
1427 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
1428 if (GC_FRAMEP (XCAR (tail))
1429 && (f = XFRAME (XCAR (tail)),
1430 (FRAME_X_P (f)
1431 && f->output_data.nothing != 1
1432 && FRAME_X_DISPLAY_INFO (f) == dpyinfo))
1433 && f->output_data.x->widget == widget)
1434 return f;
1435
1436 abort ();
1437 }
1438
1439
1440 /* Allocate the color COLOR->pixel on the screen and display of
1441 widget WIDGET in colormap CMAP. If an exact match cannot be
1442 allocated, try the nearest color available. Value is non-zero
1443 if successful. This is called from lwlib. */
1444
1445 int
1446 x_alloc_nearest_color_for_widget (widget, cmap, color)
1447 Widget widget;
1448 Colormap cmap;
1449 XColor *color;
1450 {
1451 struct frame *f = x_frame_of_widget (widget);
1452 return x_alloc_nearest_color (f, cmap, color);
1453 }
1454
1455
1456 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1457 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1458 If this produces the same color as PIXEL, try a color where all RGB
1459 values have DELTA added. Return the allocated color in *PIXEL.
1460 DISPLAY is the X display, CMAP is the colormap to operate on.
1461 Value is non-zero if successful. */
1462
1463 int
1464 x_alloc_lighter_color_for_widget (widget, display, cmap, pixel, factor, delta)
1465 Widget widget;
1466 Display *display;
1467 Colormap cmap;
1468 unsigned long *pixel;
1469 double factor;
1470 int delta;
1471 {
1472 struct frame *f = x_frame_of_widget (widget);
1473 return x_alloc_lighter_color (f, display, cmap, pixel, factor, delta);
1474 }
1475
1476
1477 /* Structure specifying which arguments should be passed by Xt to
1478 cvt_string_to_pixel. We want the widget's screen and colormap. */
1479
1480 static XtConvertArgRec cvt_string_to_pixel_args[] =
1481 {
1482 {XtWidgetBaseOffset, (XtPointer) XtOffset (Widget, core.screen),
1483 sizeof (Screen *)},
1484 {XtWidgetBaseOffset, (XtPointer) XtOffset (Widget, core.colormap),
1485 sizeof (Colormap)}
1486 };
1487
1488
1489 /* The address of this variable is returned by
1490 cvt_string_to_pixel. */
1491
1492 static Pixel cvt_string_to_pixel_value;
1493
1494
1495 /* Convert a color name to a pixel color.
1496
1497 DPY is the display we are working on.
1498
1499 ARGS is an array of *NARGS XrmValue structures holding additional
1500 information about the widget for which the conversion takes place.
1501 The contents of this array are determined by the specification
1502 in cvt_string_to_pixel_args.
1503
1504 FROM is a pointer to an XrmValue which points to the color name to
1505 convert. TO is an XrmValue in which to return the pixel color.
1506
1507 CLOSURE_RET is a pointer to user-data, in which we record if
1508 we allocated the color or not.
1509
1510 Value is True if successful, False otherwise. */
1511
1512 static Boolean
1513 cvt_string_to_pixel (dpy, args, nargs, from, to, closure_ret)
1514 Display *dpy;
1515 XrmValue *args;
1516 Cardinal *nargs;
1517 XrmValue *from, *to;
1518 XtPointer *closure_ret;
1519 {
1520 Screen *screen;
1521 Colormap cmap;
1522 Pixel pixel;
1523 String color_name;
1524 XColor color;
1525
1526 if (*nargs != 2)
1527 {
1528 XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
1529 "wrongParameters", "cvt_string_to_pixel",
1530 "XtToolkitError",
1531 "Screen and colormap args required", NULL, NULL);
1532 return False;
1533 }
1534
1535 screen = *(Screen **) args[0].addr;
1536 cmap = *(Colormap *) args[1].addr;
1537 color_name = (String) from->addr;
1538
1539 if (strcmp (color_name, XtDefaultBackground) == 0)
1540 {
1541 *closure_ret = (XtPointer) False;
1542 pixel = WhitePixelOfScreen (screen);
1543 }
1544 else if (strcmp (color_name, XtDefaultForeground) == 0)
1545 {
1546 *closure_ret = (XtPointer) False;
1547 pixel = BlackPixelOfScreen (screen);
1548 }
1549 else if (XParseColor (dpy, cmap, color_name, &color)
1550 && x_alloc_nearest_color_1 (dpy, cmap, &color))
1551 {
1552 pixel = color.pixel;
1553 *closure_ret = (XtPointer) True;
1554 }
1555 else
1556 {
1557 String params[1];
1558 Cardinal nparams = 1;
1559
1560 params[0] = color_name;
1561 XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
1562 "badValue", "cvt_string_to_pixel",
1563 "XtToolkitError", "Invalid color `%s'",
1564 params, &nparams);
1565 return False;
1566 }
1567
1568 if (to->addr != NULL)
1569 {
1570 if (to->size < sizeof (Pixel))
1571 {
1572 to->size = sizeof (Pixel);
1573 return False;
1574 }
1575
1576 *(Pixel *) to->addr = pixel;
1577 }
1578 else
1579 {
1580 cvt_string_to_pixel_value = pixel;
1581 to->addr = (XtPointer) &cvt_string_to_pixel_value;
1582 }
1583
1584 to->size = sizeof (Pixel);
1585 return True;
1586 }
1587
1588
1589 /* Free a pixel color which was previously allocated via
1590 cvt_string_to_pixel. This is registered as the destructor
1591 for this type of resource via XtSetTypeConverter.
1592
1593 APP is the application context in which we work.
1594
1595 TO is a pointer to an XrmValue holding the color to free.
1596 CLOSURE is the value we stored in CLOSURE_RET for this color
1597 in cvt_string_to_pixel.
1598
1599 ARGS and NARGS are like for cvt_string_to_pixel. */
1600
1601 static void
1602 cvt_pixel_dtor (app, to, closure, args, nargs)
1603 XtAppContext app;
1604 XrmValuePtr to;
1605 XtPointer closure;
1606 XrmValuePtr args;
1607 Cardinal *nargs;
1608 {
1609 if (*nargs != 2)
1610 {
1611 XtAppWarningMsg (app, "wrongParameters", "cvt_pixel_dtor",
1612 "XtToolkitError",
1613 "Screen and colormap arguments required",
1614 NULL, NULL);
1615 }
1616 else if (closure != NULL)
1617 {
1618 /* We did allocate the pixel, so free it. */
1619 Screen *screen = *(Screen **) args[0].addr;
1620 Colormap cmap = *(Colormap *) args[1].addr;
1621 x_free_dpy_colors (DisplayOfScreen (screen), screen, cmap,
1622 (Pixel *) to->addr, 1);
1623 }
1624 }
1625
1626
1627 #endif /* USE_X_TOOLKIT */
1628
1629
1630 /* Value is an array of XColor structures for the contents of the
1631 color map of display DPY. Set *NCELLS to the size of the array.
1632 Note that this probably shouldn't be called for large color maps,
1633 say a 24-bit TrueColor map. */
1634
1635 static const XColor *
1636 x_color_cells (dpy, ncells)
1637 Display *dpy;
1638 int *ncells;
1639 {
1640 struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
1641
1642 if (dpyinfo->color_cells == NULL)
1643 {
1644 Screen *screen = dpyinfo->screen;
1645 int i;
1646
1647 dpyinfo->ncolor_cells
1648 = XDisplayCells (dpy, XScreenNumberOfScreen (screen));
1649 dpyinfo->color_cells
1650 = (XColor *) xmalloc (dpyinfo->ncolor_cells
1651 * sizeof *dpyinfo->color_cells);
1652
1653 for (i = 0; i < dpyinfo->ncolor_cells; ++i)
1654 dpyinfo->color_cells[i].pixel = i;
1655
1656 XQueryColors (dpy, dpyinfo->cmap,
1657 dpyinfo->color_cells, dpyinfo->ncolor_cells);
1658 }
1659
1660 *ncells = dpyinfo->ncolor_cells;
1661 return dpyinfo->color_cells;
1662 }
1663
1664
1665 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1666 colors in COLORS. Use cached information, if available. */
1667
1668 void
1669 x_query_colors (f, colors, ncolors)
1670 struct frame *f;
1671 XColor *colors;
1672 int ncolors;
1673 {
1674 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1675
1676 if (dpyinfo->color_cells)
1677 {
1678 int i;
1679 for (i = 0; i < ncolors; ++i)
1680 {
1681 unsigned long pixel = colors[i].pixel;
1682 xassert (pixel < dpyinfo->ncolor_cells);
1683 xassert (dpyinfo->color_cells[pixel].pixel == pixel);
1684 colors[i] = dpyinfo->color_cells[pixel];
1685 }
1686 }
1687 else
1688 XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), colors, ncolors);
1689 }
1690
1691
1692 /* On frame F, translate pixel color to RGB values for the color in
1693 COLOR. Use cached information, if available. */
1694
1695 void
1696 x_query_color (f, color)
1697 struct frame *f;
1698 XColor *color;
1699 {
1700 x_query_colors (f, color, 1);
1701 }
1702
1703
1704 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1705 exact match can't be allocated, try the nearest color available.
1706 Value is non-zero if successful. Set *COLOR to the color
1707 allocated. */
1708
1709 static int
1710 x_alloc_nearest_color_1 (dpy, cmap, color)
1711 Display *dpy;
1712 Colormap cmap;
1713 XColor *color;
1714 {
1715 int rc;
1716
1717 rc = XAllocColor (dpy, cmap, color);
1718 if (rc == 0)
1719 {
1720 /* If we got to this point, the colormap is full, so we're going
1721 to try to get the next closest color. The algorithm used is
1722 a least-squares matching, which is what X uses for closest
1723 color matching with StaticColor visuals. */
1724 int nearest, i;
1725 unsigned long nearest_delta = ~0;
1726 int ncells;
1727 const XColor *cells = x_color_cells (dpy, &ncells);
1728
1729 for (nearest = i = 0; i < ncells; ++i)
1730 {
1731 long dred = (color->red >> 8) - (cells[i].red >> 8);
1732 long dgreen = (color->green >> 8) - (cells[i].green >> 8);
1733 long dblue = (color->blue >> 8) - (cells[i].blue >> 8);
1734 unsigned long delta = dred * dred + dgreen * dgreen + dblue * dblue;
1735
1736 if (delta < nearest_delta)
1737 {
1738 nearest = i;
1739 nearest_delta = delta;
1740 }
1741 }
1742
1743 color->red = cells[nearest].red;
1744 color->green = cells[nearest].green;
1745 color->blue = cells[nearest].blue;
1746 rc = XAllocColor (dpy, cmap, color);
1747 }
1748 else
1749 {
1750 /* If allocation succeeded, and the allocated pixel color is not
1751 equal to a cached pixel color recorded earlier, there was a
1752 change in the colormap, so clear the color cache. */
1753 struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
1754 XColor *cached_color;
1755
1756 if (dpyinfo->color_cells
1757 && (cached_color = &dpyinfo->color_cells[color->pixel],
1758 (cached_color->red != color->red
1759 || cached_color->blue != color->blue
1760 || cached_color->green != color->green)))
1761 {
1762 xfree (dpyinfo->color_cells);
1763 dpyinfo->color_cells = NULL;
1764 dpyinfo->ncolor_cells = 0;
1765 }
1766 }
1767
1768 #ifdef DEBUG_X_COLORS
1769 if (rc)
1770 register_color (color->pixel);
1771 #endif /* DEBUG_X_COLORS */
1772
1773 return rc;
1774 }
1775
1776
1777 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1778 exact match can't be allocated, try the nearest color available.
1779 Value is non-zero if successful. Set *COLOR to the color
1780 allocated. */
1781
1782 int
1783 x_alloc_nearest_color (f, cmap, color)
1784 struct frame *f;
1785 Colormap cmap;
1786 XColor *color;
1787 {
1788 gamma_correct (f, color);
1789 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f), cmap, color);
1790 }
1791
1792
1793 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1794 It's necessary to do this instead of just using PIXEL directly to
1795 get color reference counts right. */
1796
1797 unsigned long
1798 x_copy_color (f, pixel)
1799 struct frame *f;
1800 unsigned long pixel;
1801 {
1802 XColor color;
1803
1804 color.pixel = pixel;
1805 BLOCK_INPUT;
1806 x_query_color (f, &color);
1807 XAllocColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), &color);
1808 UNBLOCK_INPUT;
1809 #ifdef DEBUG_X_COLORS
1810 register_color (pixel);
1811 #endif
1812 return color.pixel;
1813 }
1814
1815
1816 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
1817 It's necessary to do this instead of just using PIXEL directly to
1818 get color reference counts right. */
1819
1820 unsigned long
1821 x_copy_dpy_color (dpy, cmap, pixel)
1822 Display *dpy;
1823 Colormap cmap;
1824 unsigned long pixel;
1825 {
1826 XColor color;
1827
1828 color.pixel = pixel;
1829 BLOCK_INPUT;
1830 XQueryColor (dpy, cmap, &color);
1831 XAllocColor (dpy, cmap, &color);
1832 UNBLOCK_INPUT;
1833 #ifdef DEBUG_X_COLORS
1834 register_color (pixel);
1835 #endif
1836 return color.pixel;
1837 }
1838
1839
1840 /* Brightness beyond which a color won't have its highlight brightness
1841 boosted.
1842
1843 Nominally, highlight colors for `3d' faces are calculated by
1844 brightening an object's color by a constant scale factor, but this
1845 doesn't yield good results for dark colors, so for colors who's
1846 brightness is less than this value (on a scale of 0-65535) have an
1847 use an additional additive factor.
1848
1849 The value here is set so that the default menu-bar/mode-line color
1850 (grey75) will not have its highlights changed at all. */
1851 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1852
1853
1854 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1855 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1856 If this produces the same color as PIXEL, try a color where all RGB
1857 values have DELTA added. Return the allocated color in *PIXEL.
1858 DISPLAY is the X display, CMAP is the colormap to operate on.
1859 Value is non-zero if successful. */
1860
1861 static int
1862 x_alloc_lighter_color (f, display, cmap, pixel, factor, delta)
1863 struct frame *f;
1864 Display *display;
1865 Colormap cmap;
1866 unsigned long *pixel;
1867 double factor;
1868 int delta;
1869 {
1870 XColor color, new;
1871 long bright;
1872 int success_p;
1873
1874 /* Get RGB color values. */
1875 color.pixel = *pixel;
1876 x_query_color (f, &color);
1877
1878 /* Change RGB values by specified FACTOR. Avoid overflow! */
1879 xassert (factor >= 0);
1880 new.red = min (0xffff, factor * color.red);
1881 new.green = min (0xffff, factor * color.green);
1882 new.blue = min (0xffff, factor * color.blue);
1883
1884 /* Calculate brightness of COLOR. */
1885 bright = (2 * color.red + 3 * color.green + color.blue) / 6;
1886
1887 /* We only boost colors that are darker than
1888 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1889 if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
1890 /* Make an additive adjustment to NEW, because it's dark enough so
1891 that scaling by FACTOR alone isn't enough. */
1892 {
1893 /* How far below the limit this color is (0 - 1, 1 being darker). */
1894 double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
1895 /* The additive adjustment. */
1896 int min_delta = delta * dimness * factor / 2;
1897
1898 if (factor < 1)
1899 {
1900 new.red = max (0, new.red - min_delta);
1901 new.green = max (0, new.green - min_delta);
1902 new.blue = max (0, new.blue - min_delta);
1903 }
1904 else
1905 {
1906 new.red = min (0xffff, min_delta + new.red);
1907 new.green = min (0xffff, min_delta + new.green);
1908 new.blue = min (0xffff, min_delta + new.blue);
1909 }
1910 }
1911
1912 /* Try to allocate the color. */
1913 success_p = x_alloc_nearest_color (f, cmap, &new);
1914 if (success_p)
1915 {
1916 if (new.pixel == *pixel)
1917 {
1918 /* If we end up with the same color as before, try adding
1919 delta to the RGB values. */
1920 x_free_colors (f, &new.pixel, 1);
1921
1922 new.red = min (0xffff, delta + color.red);
1923 new.green = min (0xffff, delta + color.green);
1924 new.blue = min (0xffff, delta + color.blue);
1925 success_p = x_alloc_nearest_color (f, cmap, &new);
1926 }
1927 else
1928 success_p = 1;
1929 *pixel = new.pixel;
1930 }
1931
1932 return success_p;
1933 }
1934
1935
1936 /* Set up the foreground color for drawing relief lines of glyph
1937 string S. RELIEF is a pointer to a struct relief containing the GC
1938 with which lines will be drawn. Use a color that is FACTOR or
1939 DELTA lighter or darker than the relief's background which is found
1940 in S->f->output_data.x->relief_background. If such a color cannot
1941 be allocated, use DEFAULT_PIXEL, instead. */
1942
1943 static void
1944 x_setup_relief_color (f, relief, factor, delta, default_pixel)
1945 struct frame *f;
1946 struct relief *relief;
1947 double factor;
1948 int delta;
1949 unsigned long default_pixel;
1950 {
1951 XGCValues xgcv;
1952 struct x_output *di = f->output_data.x;
1953 unsigned long mask = GCForeground | GCLineWidth | GCGraphicsExposures;
1954 unsigned long pixel;
1955 unsigned long background = di->relief_background;
1956 Colormap cmap = FRAME_X_COLORMAP (f);
1957 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1958 Display *dpy = FRAME_X_DISPLAY (f);
1959
1960 xgcv.graphics_exposures = False;
1961 xgcv.line_width = 1;
1962
1963 /* Free previously allocated color. The color cell will be reused
1964 when it has been freed as many times as it was allocated, so this
1965 doesn't affect faces using the same colors. */
1966 if (relief->gc
1967 && relief->allocated_p)
1968 {
1969 x_free_colors (f, &relief->pixel, 1);
1970 relief->allocated_p = 0;
1971 }
1972
1973 /* Allocate new color. */
1974 xgcv.foreground = default_pixel;
1975 pixel = background;
1976 if (dpyinfo->n_planes != 1
1977 && x_alloc_lighter_color (f, dpy, cmap, &pixel, factor, delta))
1978 {
1979 relief->allocated_p = 1;
1980 xgcv.foreground = relief->pixel = pixel;
1981 }
1982
1983 if (relief->gc == 0)
1984 {
1985 xgcv.stipple = dpyinfo->gray;
1986 mask |= GCStipple;
1987 relief->gc = XCreateGC (dpy, FRAME_X_WINDOW (f), mask, &xgcv);
1988 }
1989 else
1990 XChangeGC (dpy, relief->gc, mask, &xgcv);
1991 }
1992
1993
1994 /* Set up colors for the relief lines around glyph string S. */
1995
1996 static void
1997 x_setup_relief_colors (s)
1998 struct glyph_string *s;
1999 {
2000 struct x_output *di = s->f->output_data.x;
2001 unsigned long color;
2002
2003 if (s->face->use_box_color_for_shadows_p)
2004 color = s->face->box_color;
2005 else if (s->first_glyph->type == IMAGE_GLYPH
2006 && s->img->pixmap
2007 && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
2008 color = IMAGE_BACKGROUND (s->img, s->f, 0);
2009 else
2010 {
2011 XGCValues xgcv;
2012
2013 /* Get the background color of the face. */
2014 XGetGCValues (s->display, s->gc, GCBackground, &xgcv);
2015 color = xgcv.background;
2016 }
2017
2018 if (di->white_relief.gc == 0
2019 || color != di->relief_background)
2020 {
2021 di->relief_background = color;
2022 x_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
2023 WHITE_PIX_DEFAULT (s->f));
2024 x_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
2025 BLACK_PIX_DEFAULT (s->f));
2026 }
2027 }
2028
2029
2030 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2031 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2032 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
2033 relief. LEFT_P non-zero means draw a relief on the left side of
2034 the rectangle. RIGHT_P non-zero means draw a relief on the right
2035 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2036 when drawing. */
2037
2038 static void
2039 x_draw_relief_rect (f, left_x, top_y, right_x, bottom_y, width,
2040 raised_p, top_p, bot_p, left_p, right_p, clip_rect)
2041 struct frame *f;
2042 int left_x, top_y, right_x, bottom_y, width;
2043 int top_p, bot_p, left_p, right_p, raised_p;
2044 XRectangle *clip_rect;
2045 {
2046 Display *dpy = FRAME_X_DISPLAY (f);
2047 Window window = FRAME_X_WINDOW (f);
2048 int i;
2049 GC gc;
2050
2051 if (raised_p)
2052 gc = f->output_data.x->white_relief.gc;
2053 else
2054 gc = f->output_data.x->black_relief.gc;
2055 XSetClipRectangles (dpy, gc, 0, 0, clip_rect, 1, Unsorted);
2056
2057 /* Top. */
2058 if (top_p)
2059 for (i = 0; i < width; ++i)
2060 XDrawLine (dpy, window, gc,
2061 left_x + i * left_p, top_y + i,
2062 right_x + 1 - i * right_p, top_y + i);
2063
2064 /* Left. */
2065 if (left_p)
2066 for (i = 0; i < width; ++i)
2067 XDrawLine (dpy, window, gc,
2068 left_x + i, top_y + i, left_x + i, bottom_y - i + 1);
2069
2070 XSetClipMask (dpy, gc, None);
2071 if (raised_p)
2072 gc = f->output_data.x->black_relief.gc;
2073 else
2074 gc = f->output_data.x->white_relief.gc;
2075 XSetClipRectangles (dpy, gc, 0, 0, clip_rect, 1, Unsorted);
2076
2077 /* Bottom. */
2078 if (bot_p)
2079 for (i = 0; i < width; ++i)
2080 XDrawLine (dpy, window, gc,
2081 left_x + i * left_p, bottom_y - i,
2082 right_x + 1 - i * right_p, bottom_y - i);
2083
2084 /* Right. */
2085 if (right_p)
2086 for (i = 0; i < width; ++i)
2087 XDrawLine (dpy, window, gc,
2088 right_x - i, top_y + i + 1, right_x - i, bottom_y - i);
2089
2090 XSetClipMask (dpy, gc, None);
2091 }
2092
2093
2094 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2095 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2096 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2097 left side of the rectangle. RIGHT_P non-zero means draw a line
2098 on the right side of the rectangle. CLIP_RECT is the clipping
2099 rectangle to use when drawing. */
2100
2101 static void
2102 x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
2103 left_p, right_p, clip_rect)
2104 struct glyph_string *s;
2105 int left_x, top_y, right_x, bottom_y, width, left_p, right_p;
2106 XRectangle *clip_rect;
2107 {
2108 XGCValues xgcv;
2109
2110 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
2111 XSetForeground (s->display, s->gc, s->face->box_color);
2112 XSetClipRectangles (s->display, s->gc, 0, 0, clip_rect, 1, Unsorted);
2113
2114 /* Top. */
2115 XFillRectangle (s->display, s->window, s->gc,
2116 left_x, top_y, right_x - left_x + 1, width);
2117
2118 /* Left. */
2119 if (left_p)
2120 XFillRectangle (s->display, s->window, s->gc,
2121 left_x, top_y, width, bottom_y - top_y + 1);
2122
2123 /* Bottom. */
2124 XFillRectangle (s->display, s->window, s->gc,
2125 left_x, bottom_y - width + 1, right_x - left_x + 1, width);
2126
2127 /* Right. */
2128 if (right_p)
2129 XFillRectangle (s->display, s->window, s->gc,
2130 right_x - width + 1, top_y, width, bottom_y - top_y + 1);
2131
2132 XSetForeground (s->display, s->gc, xgcv.foreground);
2133 XSetClipMask (s->display, s->gc, None);
2134 }
2135
2136
2137 /* Draw a box around glyph string S. */
2138
2139 static void
2140 x_draw_glyph_string_box (s)
2141 struct glyph_string *s;
2142 {
2143 int width, left_x, right_x, top_y, bottom_y, last_x, raised_p;
2144 int left_p, right_p;
2145 struct glyph *last_glyph;
2146 XRectangle clip_rect;
2147
2148 last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
2149 ? WINDOW_RIGHT_EDGE_X (s->w)
2150 : window_box_right (s->w, s->area));
2151
2152 /* The glyph that may have a right box line. */
2153 last_glyph = (s->cmp || s->img
2154 ? s->first_glyph
2155 : s->first_glyph + s->nchars - 1);
2156
2157 width = abs (s->face->box_line_width);
2158 raised_p = s->face->box == FACE_RAISED_BOX;
2159 left_x = s->x;
2160 right_x = (s->row->full_width_p && s->extends_to_end_of_line_p
2161 ? last_x - 1
2162 : min (last_x, s->x + s->background_width) - 1);
2163 top_y = s->y;
2164 bottom_y = top_y + s->height - 1;
2165
2166 left_p = (s->first_glyph->left_box_line_p
2167 || (s->hl == DRAW_MOUSE_FACE
2168 && (s->prev == NULL
2169 || s->prev->hl != s->hl)));
2170 right_p = (last_glyph->right_box_line_p
2171 || (s->hl == DRAW_MOUSE_FACE
2172 && (s->next == NULL
2173 || s->next->hl != s->hl)));
2174
2175 get_glyph_string_clip_rect (s, &clip_rect);
2176
2177 if (s->face->box == FACE_SIMPLE_BOX)
2178 x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
2179 left_p, right_p, &clip_rect);
2180 else
2181 {
2182 x_setup_relief_colors (s);
2183 x_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
2184 width, raised_p, 1, 1, left_p, right_p, &clip_rect);
2185 }
2186 }
2187
2188
2189 /* Draw foreground of image glyph string S. */
2190
2191 static void
2192 x_draw_image_foreground (s)
2193 struct glyph_string *s;
2194 {
2195 int x = s->x;
2196 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
2197
2198 /* If first glyph of S has a left box line, start drawing it to the
2199 right of that line. */
2200 if (s->face->box != FACE_NO_BOX
2201 && s->first_glyph->left_box_line_p
2202 && s->slice.x == 0)
2203 x += abs (s->face->box_line_width);
2204
2205 /* If there is a margin around the image, adjust x- and y-position
2206 by that margin. */
2207 if (s->slice.x == 0)
2208 x += s->img->hmargin;
2209 if (s->slice.y == 0)
2210 y += s->img->vmargin;
2211
2212 if (s->img->pixmap)
2213 {
2214 if (s->img->mask)
2215 {
2216 /* We can't set both a clip mask and use XSetClipRectangles
2217 because the latter also sets a clip mask. We also can't
2218 trust on the shape extension to be available
2219 (XShapeCombineRegion). So, compute the rectangle to draw
2220 manually. */
2221 unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
2222 | GCFunction);
2223 XGCValues xgcv;
2224 XRectangle clip_rect, image_rect, r;
2225
2226 xgcv.clip_mask = s->img->mask;
2227 xgcv.clip_x_origin = x;
2228 xgcv.clip_y_origin = y;
2229 xgcv.function = GXcopy;
2230 XChangeGC (s->display, s->gc, mask, &xgcv);
2231
2232 get_glyph_string_clip_rect (s, &clip_rect);
2233 image_rect.x = x;
2234 image_rect.y = y;
2235 image_rect.width = s->slice.width;
2236 image_rect.height = s->slice.height;
2237 if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
2238 XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
2239 s->slice.x + r.x - x, s->slice.y + r.y - y,
2240 r.width, r.height, r.x, r.y);
2241 }
2242 else
2243 {
2244 XRectangle clip_rect, image_rect, r;
2245
2246 get_glyph_string_clip_rect (s, &clip_rect);
2247 image_rect.x = x;
2248 image_rect.y = y;
2249 image_rect.width = s->slice.width;
2250 image_rect.height = s->slice.height;
2251 if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
2252 XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
2253 s->slice.x + r.x - x, s->slice.y + r.y - y,
2254 r.width, r.height, r.x, r.y);
2255
2256 /* When the image has a mask, we can expect that at
2257 least part of a mouse highlight or a block cursor will
2258 be visible. If the image doesn't have a mask, make
2259 a block cursor visible by drawing a rectangle around
2260 the image. I believe it's looking better if we do
2261 nothing here for mouse-face. */
2262 if (s->hl == DRAW_CURSOR)
2263 {
2264 int r = s->img->relief;
2265 if (r < 0) r = -r;
2266 XDrawRectangle (s->display, s->window, s->gc,
2267 x - r, y - r,
2268 s->slice.width + r*2 - 1,
2269 s->slice.height + r*2 - 1);
2270 }
2271 }
2272 }
2273 else
2274 /* Draw a rectangle if image could not be loaded. */
2275 XDrawRectangle (s->display, s->window, s->gc, x, y,
2276 s->slice.width - 1, s->slice.height - 1);
2277 }
2278
2279
2280 /* Draw a relief around the image glyph string S. */
2281
2282 static void
2283 x_draw_image_relief (s)
2284 struct glyph_string *s;
2285 {
2286 int x0, y0, x1, y1, thick, raised_p;
2287 XRectangle r;
2288 int x = s->x;
2289 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
2290
2291 /* If first glyph of S has a left box line, start drawing it to the
2292 right of that line. */
2293 if (s->face->box != FACE_NO_BOX
2294 && s->first_glyph->left_box_line_p
2295 && s->slice.x == 0)
2296 x += abs (s->face->box_line_width);
2297
2298 /* If there is a margin around the image, adjust x- and y-position
2299 by that margin. */
2300 if (s->slice.x == 0)
2301 x += s->img->hmargin;
2302 if (s->slice.y == 0)
2303 y += s->img->vmargin;
2304
2305 if (s->hl == DRAW_IMAGE_SUNKEN
2306 || s->hl == DRAW_IMAGE_RAISED)
2307 {
2308 thick = tool_bar_button_relief >= 0 ? tool_bar_button_relief : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
2309 raised_p = s->hl == DRAW_IMAGE_RAISED;
2310 }
2311 else
2312 {
2313 thick = abs (s->img->relief);
2314 raised_p = s->img->relief > 0;
2315 }
2316
2317 x0 = x - thick;
2318 y0 = y - thick;
2319 x1 = x + s->slice.width + thick - 1;
2320 y1 = y + s->slice.height + thick - 1;
2321
2322 x_setup_relief_colors (s);
2323 get_glyph_string_clip_rect (s, &r);
2324 x_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p,
2325 s->slice.y == 0,
2326 s->slice.y + s->slice.height == s->img->height,
2327 s->slice.x == 0,
2328 s->slice.x + s->slice.width == s->img->width,
2329 &r);
2330 }
2331
2332
2333 /* Draw the foreground of image glyph string S to PIXMAP. */
2334
2335 static void
2336 x_draw_image_foreground_1 (s, pixmap)
2337 struct glyph_string *s;
2338 Pixmap pixmap;
2339 {
2340 int x = 0;
2341 int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
2342
2343 /* If first glyph of S has a left box line, start drawing it to the
2344 right of that line. */
2345 if (s->face->box != FACE_NO_BOX
2346 && s->first_glyph->left_box_line_p
2347 && s->slice.x == 0)
2348 x += abs (s->face->box_line_width);
2349
2350 /* If there is a margin around the image, adjust x- and y-position
2351 by that margin. */
2352 if (s->slice.x == 0)
2353 x += s->img->hmargin;
2354 if (s->slice.y == 0)
2355 y += s->img->vmargin;
2356
2357 if (s->img->pixmap)
2358 {
2359 if (s->img->mask)
2360 {
2361 /* We can't set both a clip mask and use XSetClipRectangles
2362 because the latter also sets a clip mask. We also can't
2363 trust on the shape extension to be available
2364 (XShapeCombineRegion). So, compute the rectangle to draw
2365 manually. */
2366 unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
2367 | GCFunction);
2368 XGCValues xgcv;
2369
2370 xgcv.clip_mask = s->img->mask;
2371 xgcv.clip_x_origin = x - s->slice.x;
2372 xgcv.clip_y_origin = y - s->slice.y;
2373 xgcv.function = GXcopy;
2374 XChangeGC (s->display, s->gc, mask, &xgcv);
2375
2376 XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
2377 s->slice.x, s->slice.y,
2378 s->slice.width, s->slice.height, x, y);
2379 XSetClipMask (s->display, s->gc, None);
2380 }
2381 else
2382 {
2383 XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
2384 s->slice.x, s->slice.y,
2385 s->slice.width, s->slice.height, x, y);
2386
2387 /* When the image has a mask, we can expect that at
2388 least part of a mouse highlight or a block cursor will
2389 be visible. If the image doesn't have a mask, make
2390 a block cursor visible by drawing a rectangle around
2391 the image. I believe it's looking better if we do
2392 nothing here for mouse-face. */
2393 if (s->hl == DRAW_CURSOR)
2394 {
2395 int r = s->img->relief;
2396 if (r < 0) r = -r;
2397 XDrawRectangle (s->display, s->window, s->gc, x - r, y - r,
2398 s->slice.width + r*2 - 1,
2399 s->slice.height + r*2 - 1);
2400 }
2401 }
2402 }
2403 else
2404 /* Draw a rectangle if image could not be loaded. */
2405 XDrawRectangle (s->display, pixmap, s->gc, x, y,
2406 s->slice.width - 1, s->slice.height - 1);
2407 }
2408
2409
2410 /* Draw part of the background of glyph string S. X, Y, W, and H
2411 give the rectangle to draw. */
2412
2413 static void
2414 x_draw_glyph_string_bg_rect (s, x, y, w, h)
2415 struct glyph_string *s;
2416 int x, y, w, h;
2417 {
2418 if (s->stippled_p)
2419 {
2420 /* Fill background with a stipple pattern. */
2421 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2422 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
2423 XSetFillStyle (s->display, s->gc, FillSolid);
2424 }
2425 else
2426 x_clear_glyph_string_rect (s, x, y, w, h);
2427 }
2428
2429
2430 /* Draw image glyph string S.
2431
2432 s->y
2433 s->x +-------------------------
2434 | s->face->box
2435 |
2436 | +-------------------------
2437 | | s->img->margin
2438 | |
2439 | | +-------------------
2440 | | | the image
2441
2442 */
2443
2444 static void
2445 x_draw_image_glyph_string (s)
2446 struct glyph_string *s;
2447 {
2448 int box_line_hwidth = abs (s->face->box_line_width);
2449 int box_line_vwidth = max (s->face->box_line_width, 0);
2450 int height;
2451 Pixmap pixmap = None;
2452
2453 height = s->height;
2454 if (s->slice.y == 0)
2455 height -= box_line_vwidth;
2456 if (s->slice.y + s->slice.height >= s->img->height)
2457 height -= box_line_vwidth;
2458
2459 /* Fill background with face under the image. Do it only if row is
2460 taller than image or if image has a clip mask to reduce
2461 flickering. */
2462 s->stippled_p = s->face->stipple != 0;
2463 if (height > s->slice.height
2464 || s->img->hmargin
2465 || s->img->vmargin
2466 || s->img->mask
2467 || s->img->pixmap == 0
2468 || s->width != s->background_width)
2469 {
2470 if (s->img->mask)
2471 {
2472 /* Create a pixmap as large as the glyph string. Fill it
2473 with the background color. Copy the image to it, using
2474 its mask. Copy the temporary pixmap to the display. */
2475 Screen *screen = FRAME_X_SCREEN (s->f);
2476 int depth = DefaultDepthOfScreen (screen);
2477
2478 /* Create a pixmap as large as the glyph string. */
2479 pixmap = XCreatePixmap (s->display, s->window,
2480 s->background_width,
2481 s->height, depth);
2482
2483 /* Don't clip in the following because we're working on the
2484 pixmap. */
2485 XSetClipMask (s->display, s->gc, None);
2486
2487 /* Fill the pixmap with the background color/stipple. */
2488 if (s->stippled_p)
2489 {
2490 /* Fill background with a stipple pattern. */
2491 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2492 XFillRectangle (s->display, pixmap, s->gc,
2493 0, 0, s->background_width, s->height);
2494 XSetFillStyle (s->display, s->gc, FillSolid);
2495 }
2496 else
2497 {
2498 XGCValues xgcv;
2499 XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
2500 &xgcv);
2501 XSetForeground (s->display, s->gc, xgcv.background);
2502 XFillRectangle (s->display, pixmap, s->gc,
2503 0, 0, s->background_width, s->height);
2504 XSetForeground (s->display, s->gc, xgcv.foreground);
2505 }
2506 }
2507 else
2508 {
2509 int x = s->x;
2510 int y = s->y;
2511
2512 if (s->first_glyph->left_box_line_p
2513 && s->slice.x == 0)
2514 x += box_line_hwidth;
2515
2516 if (s->slice.y == 0)
2517 y += box_line_vwidth;
2518
2519 x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
2520 }
2521
2522 s->background_filled_p = 1;
2523 }
2524
2525 /* Draw the foreground. */
2526 if (pixmap != None)
2527 {
2528 x_draw_image_foreground_1 (s, pixmap);
2529 x_set_glyph_string_clipping (s);
2530 XCopyArea (s->display, pixmap, s->window, s->gc,
2531 0, 0, s->background_width, s->height, s->x, s->y);
2532 XFreePixmap (s->display, pixmap);
2533 }
2534 else
2535 x_draw_image_foreground (s);
2536
2537 /* If we must draw a relief around the image, do it. */
2538 if (s->img->relief
2539 || s->hl == DRAW_IMAGE_RAISED
2540 || s->hl == DRAW_IMAGE_SUNKEN)
2541 x_draw_image_relief (s);
2542 }
2543
2544
2545 /* Draw stretch glyph string S. */
2546
2547 static void
2548 x_draw_stretch_glyph_string (s)
2549 struct glyph_string *s;
2550 {
2551 xassert (s->first_glyph->type == STRETCH_GLYPH);
2552 s->stippled_p = s->face->stipple != 0;
2553
2554 if (s->hl == DRAW_CURSOR
2555 && !x_stretch_cursor_p)
2556 {
2557 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2558 as wide as the stretch glyph. */
2559 int width = min (FRAME_COLUMN_WIDTH (s->f), s->background_width);
2560
2561 /* Draw cursor. */
2562 x_draw_glyph_string_bg_rect (s, s->x, s->y, width, s->height);
2563
2564 /* Clear rest using the GC of the original non-cursor face. */
2565 if (width < s->background_width)
2566 {
2567 int x = s->x + width, y = s->y;
2568 int w = s->background_width - width, h = s->height;
2569 XRectangle r;
2570 GC gc;
2571
2572 if (s->row->mouse_face_p
2573 && cursor_in_mouse_face_p (s->w))
2574 {
2575 x_set_mouse_face_gc (s);
2576 gc = s->gc;
2577 }
2578 else
2579 gc = s->face->gc;
2580
2581 get_glyph_string_clip_rect (s, &r);
2582 XSetClipRectangles (s->display, gc, 0, 0, &r, 1, Unsorted);
2583
2584 if (s->face->stipple)
2585 {
2586 /* Fill background with a stipple pattern. */
2587 XSetFillStyle (s->display, gc, FillOpaqueStippled);
2588 XFillRectangle (s->display, s->window, gc, x, y, w, h);
2589 XSetFillStyle (s->display, gc, FillSolid);
2590 }
2591 else
2592 {
2593 XGCValues xgcv;
2594 XGetGCValues (s->display, gc, GCForeground | GCBackground, &xgcv);
2595 XSetForeground (s->display, gc, xgcv.background);
2596 XFillRectangle (s->display, s->window, gc, x, y, w, h);
2597 XSetForeground (s->display, gc, xgcv.foreground);
2598 }
2599 }
2600 }
2601 else if (!s->background_filled_p)
2602 x_draw_glyph_string_bg_rect (s, s->x, s->y, s->background_width,
2603 s->height);
2604
2605 s->background_filled_p = 1;
2606 }
2607
2608
2609 /* Draw glyph string S. */
2610
2611 static void
2612 x_draw_glyph_string (s)
2613 struct glyph_string *s;
2614 {
2615 int relief_drawn_p = 0;
2616
2617 /* If S draws into the background of its successor, draw the
2618 background of the successor first so that S can draw into it.
2619 This makes S->next use XDrawString instead of XDrawImageString. */
2620 if (s->next && s->right_overhang && !s->for_overlaps)
2621 {
2622 xassert (s->next->img == NULL);
2623 x_set_glyph_string_gc (s->next);
2624 x_set_glyph_string_clipping (s->next);
2625 x_draw_glyph_string_background (s->next, 1);
2626 }
2627
2628 /* Set up S->gc, set clipping and draw S. */
2629 x_set_glyph_string_gc (s);
2630
2631 /* Draw relief (if any) in advance for char/composition so that the
2632 glyph string can be drawn over it. */
2633 if (!s->for_overlaps
2634 && s->face->box != FACE_NO_BOX
2635 && (s->first_glyph->type == CHAR_GLYPH
2636 || s->first_glyph->type == COMPOSITE_GLYPH))
2637
2638 {
2639 x_set_glyph_string_clipping (s);
2640 x_draw_glyph_string_background (s, 1);
2641 x_draw_glyph_string_box (s);
2642 x_set_glyph_string_clipping (s);
2643 relief_drawn_p = 1;
2644 }
2645 else
2646 x_set_glyph_string_clipping (s);
2647
2648 switch (s->first_glyph->type)
2649 {
2650 case IMAGE_GLYPH:
2651 x_draw_image_glyph_string (s);
2652 break;
2653
2654 case STRETCH_GLYPH:
2655 x_draw_stretch_glyph_string (s);
2656 break;
2657
2658 case CHAR_GLYPH:
2659 if (s->for_overlaps)
2660 s->background_filled_p = 1;
2661 else
2662 x_draw_glyph_string_background (s, 0);
2663 x_draw_glyph_string_foreground (s);
2664 break;
2665
2666 case COMPOSITE_GLYPH:
2667 if (s->for_overlaps || s->gidx > 0)
2668 s->background_filled_p = 1;
2669 else
2670 x_draw_glyph_string_background (s, 1);
2671 x_draw_composite_glyph_string_foreground (s);
2672 break;
2673
2674 default:
2675 abort ();
2676 }
2677
2678 if (!s->for_overlaps)
2679 {
2680 /* Draw underline. */
2681 if (s->face->underline_p)
2682 {
2683 unsigned long tem, h;
2684 int y;
2685
2686 /* Get the underline thickness. Default is 1 pixel. */
2687 if (!XGetFontProperty (s->font, XA_UNDERLINE_THICKNESS, &h))
2688 h = 1;
2689
2690 /* Get the underline position. This is the recommended
2691 vertical offset in pixels from the baseline to the top of
2692 the underline. This is a signed value according to the
2693 specs, and its default is
2694
2695 ROUND ((maximum descent) / 2), with
2696 ROUND(x) = floor (x + 0.5) */
2697
2698 if (x_use_underline_position_properties
2699 && XGetFontProperty (s->font, XA_UNDERLINE_POSITION, &tem))
2700 y = s->ybase + (long) tem;
2701 else if (s->face->font)
2702 y = s->ybase + (s->face->font->max_bounds.descent + 1) / 2;
2703 else
2704 y = s->y + s->height - h;
2705
2706 if (s->face->underline_defaulted_p)
2707 XFillRectangle (s->display, s->window, s->gc,
2708 s->x, y, s->width, h);
2709 else
2710 {
2711 XGCValues xgcv;
2712 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
2713 XSetForeground (s->display, s->gc, s->face->underline_color);
2714 XFillRectangle (s->display, s->window, s->gc,
2715 s->x, y, s->width, h);
2716 XSetForeground (s->display, s->gc, xgcv.foreground);
2717 }
2718 }
2719
2720 /* Draw overline. */
2721 if (s->face->overline_p)
2722 {
2723 unsigned long dy = 0, h = 1;
2724
2725 if (s->face->overline_color_defaulted_p)
2726 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
2727 s->width, h);
2728 else
2729 {
2730 XGCValues xgcv;
2731 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
2732 XSetForeground (s->display, s->gc, s->face->overline_color);
2733 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
2734 s->width, h);
2735 XSetForeground (s->display, s->gc, xgcv.foreground);
2736 }
2737 }
2738
2739 /* Draw strike-through. */
2740 if (s->face->strike_through_p)
2741 {
2742 unsigned long h = 1;
2743 unsigned long dy = (s->height - h) / 2;
2744
2745 if (s->face->strike_through_color_defaulted_p)
2746 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
2747 s->width, h);
2748 else
2749 {
2750 XGCValues xgcv;
2751 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
2752 XSetForeground (s->display, s->gc, s->face->strike_through_color);
2753 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
2754 s->width, h);
2755 XSetForeground (s->display, s->gc, xgcv.foreground);
2756 }
2757 }
2758
2759 /* Draw relief if not yet drawn. */
2760 if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
2761 x_draw_glyph_string_box (s);
2762 }
2763
2764 /* Reset clipping. */
2765 XSetClipMask (s->display, s->gc, None);
2766 }
2767
2768 /* Shift display to make room for inserted glyphs. */
2769
2770 void
2771 x_shift_glyphs_for_insert (f, x, y, width, height, shift_by)
2772 struct frame *f;
2773 int x, y, width, height, shift_by;
2774 {
2775 XCopyArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
2776 f->output_data.x->normal_gc,
2777 x, y, width, height,
2778 x + shift_by, y);
2779 }
2780
2781 /* Delete N glyphs at the nominal cursor position. Not implemented
2782 for X frames. */
2783
2784 static void
2785 x_delete_glyphs (f, n)
2786 struct frame *f;
2787 register int n;
2788 {
2789 abort ();
2790 }
2791
2792
2793 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2794 If they are <= 0, this is probably an error. */
2795
2796 void
2797 x_clear_area (dpy, window, x, y, width, height, exposures)
2798 Display *dpy;
2799 Window window;
2800 int x, y;
2801 int width, height;
2802 int exposures;
2803 {
2804 xassert (width > 0 && height > 0);
2805 XClearArea (dpy, window, x, y, width, height, exposures);
2806 }
2807
2808
2809 /* Clear an entire frame. */
2810
2811 static void
2812 x_clear_frame (struct frame *f)
2813 {
2814 /* Clearing the frame will erase any cursor, so mark them all as no
2815 longer visible. */
2816 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
2817 output_cursor.hpos = output_cursor.vpos = 0;
2818 output_cursor.x = -1;
2819
2820 /* We don't set the output cursor here because there will always
2821 follow an explicit cursor_to. */
2822 BLOCK_INPUT;
2823 XClearWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
2824
2825 /* We have to clear the scroll bars, too. If we have changed
2826 colors or something like that, then they should be notified. */
2827 x_scroll_bar_clear (f);
2828
2829 XFlush (FRAME_X_DISPLAY (f));
2830
2831 UNBLOCK_INPUT;
2832 }
2833
2834
2835 \f
2836 /* Invert the middle quarter of the frame for .15 sec. */
2837
2838 /* We use the select system call to do the waiting, so we have to make
2839 sure it's available. If it isn't, we just won't do visual bells. */
2840
2841 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
2842
2843
2844 /* Subtract the `struct timeval' values X and Y, storing the result in
2845 *RESULT. Return 1 if the difference is negative, otherwise 0. */
2846
2847 static int
2848 timeval_subtract (result, x, y)
2849 struct timeval *result, x, y;
2850 {
2851 /* Perform the carry for the later subtraction by updating y. This
2852 is safer because on some systems the tv_sec member is unsigned. */
2853 if (x.tv_usec < y.tv_usec)
2854 {
2855 int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1;
2856 y.tv_usec -= 1000000 * nsec;
2857 y.tv_sec += nsec;
2858 }
2859
2860 if (x.tv_usec - y.tv_usec > 1000000)
2861 {
2862 int nsec = (y.tv_usec - x.tv_usec) / 1000000;
2863 y.tv_usec += 1000000 * nsec;
2864 y.tv_sec -= nsec;
2865 }
2866
2867 /* Compute the time remaining to wait. tv_usec is certainly
2868 positive. */
2869 result->tv_sec = x.tv_sec - y.tv_sec;
2870 result->tv_usec = x.tv_usec - y.tv_usec;
2871
2872 /* Return indication of whether the result should be considered
2873 negative. */
2874 return x.tv_sec < y.tv_sec;
2875 }
2876
2877 void
2878 XTflash (f)
2879 struct frame *f;
2880 {
2881 BLOCK_INPUT;
2882
2883 {
2884 GC gc;
2885
2886 /* Create a GC that will use the GXxor function to flip foreground
2887 pixels into background pixels. */
2888 {
2889 XGCValues values;
2890
2891 values.function = GXxor;
2892 values.foreground = (f->output_data.x->foreground_pixel
2893 ^ f->output_data.x->background_pixel);
2894
2895 gc = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2896 GCFunction | GCForeground, &values);
2897 }
2898
2899 {
2900 /* Get the height not including a menu bar widget. */
2901 int height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, FRAME_LINES (f));
2902 /* Height of each line to flash. */
2903 int flash_height = FRAME_LINE_HEIGHT (f);
2904 /* These will be the left and right margins of the rectangles. */
2905 int flash_left = FRAME_INTERNAL_BORDER_WIDTH (f);
2906 int flash_right = FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f);
2907
2908 int width;
2909
2910 /* Don't flash the area between a scroll bar and the frame
2911 edge it is next to. */
2912 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f))
2913 {
2914 case vertical_scroll_bar_left:
2915 flash_left += VERTICAL_SCROLL_BAR_WIDTH_TRIM;
2916 break;
2917
2918 case vertical_scroll_bar_right:
2919 flash_right -= VERTICAL_SCROLL_BAR_WIDTH_TRIM;
2920 break;
2921
2922 default:
2923 break;
2924 }
2925
2926 width = flash_right - flash_left;
2927
2928 /* If window is tall, flash top and bottom line. */
2929 if (height > 3 * FRAME_LINE_HEIGHT (f))
2930 {
2931 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
2932 flash_left,
2933 (FRAME_INTERNAL_BORDER_WIDTH (f)
2934 + FRAME_TOOL_BAR_LINES (f) * FRAME_LINE_HEIGHT (f)),
2935 width, flash_height);
2936 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
2937 flash_left,
2938 (height - flash_height
2939 - FRAME_INTERNAL_BORDER_WIDTH (f)),
2940 width, flash_height);
2941 }
2942 else
2943 /* If it is short, flash it all. */
2944 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
2945 flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
2946 width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
2947
2948 x_flush (f);
2949
2950 {
2951 struct timeval wakeup;
2952
2953 EMACS_GET_TIME (wakeup);
2954
2955 /* Compute time to wait until, propagating carry from usecs. */
2956 wakeup.tv_usec += 150000;
2957 wakeup.tv_sec += (wakeup.tv_usec / 1000000);
2958 wakeup.tv_usec %= 1000000;
2959
2960 /* Keep waiting until past the time wakeup or any input gets
2961 available. */
2962 while (! detect_input_pending ())
2963 {
2964 struct timeval current;
2965 struct timeval timeout;
2966
2967 EMACS_GET_TIME (current);
2968
2969 /* Break if result would be negative. */
2970 if (timeval_subtract (&current, wakeup, current))
2971 break;
2972
2973 /* How long `select' should wait. */
2974 timeout.tv_sec = 0;
2975 timeout.tv_usec = 10000;
2976
2977 /* Try to wait that long--but we might wake up sooner. */
2978 select (0, NULL, NULL, NULL, &timeout);
2979 }
2980 }
2981
2982 /* If window is tall, flash top and bottom line. */
2983 if (height > 3 * FRAME_LINE_HEIGHT (f))
2984 {
2985 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
2986 flash_left,
2987 (FRAME_INTERNAL_BORDER_WIDTH (f)
2988 + FRAME_TOOL_BAR_LINES (f) * FRAME_LINE_HEIGHT (f)),
2989 width, flash_height);
2990 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
2991 flash_left,
2992 (height - flash_height
2993 - FRAME_INTERNAL_BORDER_WIDTH (f)),
2994 width, flash_height);
2995 }
2996 else
2997 /* If it is short, flash it all. */
2998 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
2999 flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
3000 width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
3001
3002 XFreeGC (FRAME_X_DISPLAY (f), gc);
3003 x_flush (f);
3004 }
3005 }
3006
3007 UNBLOCK_INPUT;
3008 }
3009
3010 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
3011
3012
3013 /* Make audible bell. */
3014
3015 void
3016 XTring_bell ()
3017 {
3018 struct frame *f = SELECTED_FRAME ();
3019
3020 if (FRAME_X_DISPLAY (f))
3021 {
3022 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
3023 if (visible_bell)
3024 XTflash (f);
3025 else
3026 #endif
3027 {
3028 BLOCK_INPUT;
3029 XBell (FRAME_X_DISPLAY (f), 0);
3030 XFlush (FRAME_X_DISPLAY (f));
3031 UNBLOCK_INPUT;
3032 }
3033 }
3034 }
3035
3036 \f
3037 /* Specify how many text lines, from the top of the window,
3038 should be affected by insert-lines and delete-lines operations.
3039 This, and those operations, are used only within an update
3040 that is bounded by calls to x_update_begin and x_update_end. */
3041
3042 static void
3043 XTset_terminal_window (n)
3044 register int n;
3045 {
3046 /* This function intentionally left blank. */
3047 }
3048
3049
3050 \f
3051 /***********************************************************************
3052 Line Dance
3053 ***********************************************************************/
3054
3055 /* Perform an insert-lines or delete-lines operation, inserting N
3056 lines or deleting -N lines at vertical position VPOS. */
3057
3058 static void
3059 x_ins_del_lines (f, vpos, n)
3060 struct frame *f;
3061 int vpos, n;
3062 {
3063 abort ();
3064 }
3065
3066
3067 /* Scroll part of the display as described by RUN. */
3068
3069 static void
3070 x_scroll_run (w, run)
3071 struct window *w;
3072 struct run *run;
3073 {
3074 struct frame *f = XFRAME (w->frame);
3075 int x, y, width, height, from_y, to_y, bottom_y;
3076
3077 /* Get frame-relative bounding box of the text display area of W,
3078 without mode lines. Include in this box the left and right
3079 fringe of W. */
3080 window_box (w, -1, &x, &y, &width, &height);
3081
3082 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
3083 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
3084 bottom_y = y + height;
3085
3086 if (to_y < from_y)
3087 {
3088 /* Scrolling up. Make sure we don't copy part of the mode
3089 line at the bottom. */
3090 if (from_y + run->height > bottom_y)
3091 height = bottom_y - from_y;
3092 else
3093 height = run->height;
3094 }
3095 else
3096 {
3097 /* Scolling down. Make sure we don't copy over the mode line.
3098 at the bottom. */
3099 if (to_y + run->height > bottom_y)
3100 height = bottom_y - to_y;
3101 else
3102 height = run->height;
3103 }
3104
3105 BLOCK_INPUT;
3106
3107 /* Cursor off. Will be switched on again in x_update_window_end. */
3108 updated_window = w;
3109 x_clear_cursor (w);
3110
3111 XCopyArea (FRAME_X_DISPLAY (f),
3112 FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
3113 f->output_data.x->normal_gc,
3114 x, from_y,
3115 width, height,
3116 x, to_y);
3117
3118 UNBLOCK_INPUT;
3119 }
3120
3121
3122 \f
3123 /***********************************************************************
3124 Exposure Events
3125 ***********************************************************************/
3126
3127 \f
3128 static void
3129 frame_highlight (f)
3130 struct frame *f;
3131 {
3132 /* We used to only do this if Vx_no_window_manager was non-nil, but
3133 the ICCCM (section 4.1.6) says that the window's border pixmap
3134 and border pixel are window attributes which are "private to the
3135 client", so we can always change it to whatever we want. */
3136 BLOCK_INPUT;
3137 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3138 f->output_data.x->border_pixel);
3139 UNBLOCK_INPUT;
3140 x_update_cursor (f, 1);
3141 }
3142
3143 static void
3144 frame_unhighlight (f)
3145 struct frame *f;
3146 {
3147 /* We used to only do this if Vx_no_window_manager was non-nil, but
3148 the ICCCM (section 4.1.6) says that the window's border pixmap
3149 and border pixel are window attributes which are "private to the
3150 client", so we can always change it to whatever we want. */
3151 BLOCK_INPUT;
3152 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3153 f->output_data.x->border_tile);
3154 UNBLOCK_INPUT;
3155 x_update_cursor (f, 1);
3156 }
3157
3158 /* The focus has changed. Update the frames as necessary to reflect
3159 the new situation. Note that we can't change the selected frame
3160 here, because the Lisp code we are interrupting might become confused.
3161 Each event gets marked with the frame in which it occurred, so the
3162 Lisp code can tell when the switch took place by examining the events. */
3163
3164 static void
3165 x_new_focus_frame (dpyinfo, frame)
3166 struct x_display_info *dpyinfo;
3167 struct frame *frame;
3168 {
3169 struct frame *old_focus = dpyinfo->x_focus_frame;
3170
3171 if (frame != dpyinfo->x_focus_frame)
3172 {
3173 /* Set this before calling other routines, so that they see
3174 the correct value of x_focus_frame. */
3175 dpyinfo->x_focus_frame = frame;
3176
3177 if (old_focus && old_focus->auto_lower)
3178 x_lower_frame (old_focus);
3179
3180 #if 0
3181 selected_frame = frame;
3182 XSETFRAME (XWINDOW (selected_frame->selected_window)->frame,
3183 selected_frame);
3184 Fselect_window (selected_frame->selected_window, Qnil);
3185 choose_minibuf_frame ();
3186 #endif /* ! 0 */
3187
3188 if (dpyinfo->x_focus_frame && dpyinfo->x_focus_frame->auto_raise)
3189 pending_autoraise_frame = dpyinfo->x_focus_frame;
3190 else
3191 pending_autoraise_frame = 0;
3192 }
3193
3194 x_frame_rehighlight (dpyinfo);
3195 }
3196
3197 /* Handle FocusIn and FocusOut state changes for FRAME.
3198 If FRAME has focus and there exists more than one frame, puts
3199 a FOCUS_IN_EVENT into *BUFP. */
3200
3201 static void
3202 x_focus_changed (type, state, dpyinfo, frame, bufp)
3203 int type;
3204 int state;
3205 struct x_display_info *dpyinfo;
3206 struct frame *frame;
3207 struct input_event *bufp;
3208 {
3209 if (type == FocusIn)
3210 {
3211 if (dpyinfo->x_focus_event_frame != frame)
3212 {
3213 x_new_focus_frame (dpyinfo, frame);
3214 dpyinfo->x_focus_event_frame = frame;
3215
3216 /* Don't stop displaying the initial startup message
3217 for a switch-frame event we don't need. */
3218 if (GC_NILP (Vterminal_frame)
3219 && GC_CONSP (Vframe_list)
3220 && !GC_NILP (XCDR (Vframe_list)))
3221 {
3222 bufp->kind = FOCUS_IN_EVENT;
3223 XSETFRAME (bufp->frame_or_window, frame);
3224 }
3225 }
3226
3227 frame->output_data.x->focus_state |= state;
3228
3229 #ifdef HAVE_X_I18N
3230 if (FRAME_XIC (frame))
3231 XSetICFocus (FRAME_XIC (frame));
3232 #endif
3233 }
3234 else if (type == FocusOut)
3235 {
3236 frame->output_data.x->focus_state &= ~state;
3237
3238 if (dpyinfo->x_focus_event_frame == frame)
3239 {
3240 dpyinfo->x_focus_event_frame = 0;
3241 x_new_focus_frame (dpyinfo, 0);
3242 }
3243
3244 #ifdef HAVE_X_I18N
3245 if (FRAME_XIC (frame))
3246 XUnsetICFocus (FRAME_XIC (frame));
3247 #endif
3248 }
3249 }
3250
3251 /* The focus may have changed. Figure out if it is a real focus change,
3252 by checking both FocusIn/Out and Enter/LeaveNotify events.
3253
3254 Returns FOCUS_IN_EVENT event in *BUFP. */
3255
3256 static void
3257 x_detect_focus_change (dpyinfo, event, bufp)
3258 struct x_display_info *dpyinfo;
3259 XEvent *event;
3260 struct input_event *bufp;
3261 {
3262 struct frame *frame;
3263
3264 frame = x_any_window_to_frame (dpyinfo, event->xany.window);
3265 if (! frame)
3266 return;
3267
3268 switch (event->type)
3269 {
3270 case EnterNotify:
3271 case LeaveNotify:
3272 {
3273 struct frame *focus_frame = dpyinfo->x_focus_event_frame;
3274 int focus_state
3275 = focus_frame ? focus_frame->output_data.x->focus_state : 0;
3276
3277 if (event->xcrossing.detail != NotifyInferior
3278 && event->xcrossing.focus
3279 && ! (focus_state & FOCUS_EXPLICIT))
3280 x_focus_changed ((event->type == EnterNotify ? FocusIn : FocusOut),
3281 FOCUS_IMPLICIT,
3282 dpyinfo, frame, bufp);
3283 }
3284 break;
3285
3286 case FocusIn:
3287 case FocusOut:
3288 x_focus_changed (event->type,
3289 (event->xfocus.detail == NotifyPointer ?
3290 FOCUS_IMPLICIT : FOCUS_EXPLICIT),
3291 dpyinfo, frame, bufp);
3292 break;
3293 }
3294 }
3295
3296
3297 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3298
3299 void
3300 x_mouse_leave (dpyinfo)
3301 struct x_display_info *dpyinfo;
3302 {
3303 x_new_focus_frame (dpyinfo, dpyinfo->x_focus_event_frame);
3304 }
3305
3306 /* The focus has changed, or we have redirected a frame's focus to
3307 another frame (this happens when a frame uses a surrogate
3308 mini-buffer frame). Shift the highlight as appropriate.
3309
3310 The FRAME argument doesn't necessarily have anything to do with which
3311 frame is being highlighted or un-highlighted; we only use it to find
3312 the appropriate X display info. */
3313
3314 static void
3315 XTframe_rehighlight (frame)
3316 struct frame *frame;
3317 {
3318 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame));
3319 }
3320
3321 static void
3322 x_frame_rehighlight (dpyinfo)
3323 struct x_display_info *dpyinfo;
3324 {
3325 struct frame *old_highlight = dpyinfo->x_highlight_frame;
3326
3327 if (dpyinfo->x_focus_frame)
3328 {
3329 dpyinfo->x_highlight_frame
3330 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame)))
3331 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame))
3332 : dpyinfo->x_focus_frame);
3333 if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
3334 {
3335 FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame) = Qnil;
3336 dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
3337 }
3338 }
3339 else
3340 dpyinfo->x_highlight_frame = 0;
3341
3342 if (dpyinfo->x_highlight_frame != old_highlight)
3343 {
3344 if (old_highlight)
3345 frame_unhighlight (old_highlight);
3346 if (dpyinfo->x_highlight_frame)
3347 frame_highlight (dpyinfo->x_highlight_frame);
3348 }
3349 }
3350
3351
3352 \f
3353 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3354
3355 /* Initialize mode_switch_bit and modifier_meaning. */
3356 static void
3357 x_find_modifier_meanings (dpyinfo)
3358 struct x_display_info *dpyinfo;
3359 {
3360 int min_code, max_code;
3361 KeySym *syms;
3362 int syms_per_code;
3363 XModifierKeymap *mods;
3364
3365 dpyinfo->meta_mod_mask = 0;
3366 dpyinfo->shift_lock_mask = 0;
3367 dpyinfo->alt_mod_mask = 0;
3368 dpyinfo->super_mod_mask = 0;
3369 dpyinfo->hyper_mod_mask = 0;
3370
3371 #ifdef HAVE_X11R4
3372 XDisplayKeycodes (dpyinfo->display, &min_code, &max_code);
3373 #else
3374 min_code = dpyinfo->display->min_keycode;
3375 max_code = dpyinfo->display->max_keycode;
3376 #endif
3377
3378 syms = XGetKeyboardMapping (dpyinfo->display,
3379 min_code, max_code - min_code + 1,
3380 &syms_per_code);
3381 mods = XGetModifierMapping (dpyinfo->display);
3382
3383 /* Scan the modifier table to see which modifier bits the Meta and
3384 Alt keysyms are on. */
3385 {
3386 int row, col; /* The row and column in the modifier table. */
3387 int found_alt_or_meta;
3388
3389 for (row = 3; row < 8; row++)
3390 {
3391 found_alt_or_meta = 0;
3392 for (col = 0; col < mods->max_keypermod; col++)
3393 {
3394 KeyCode code = mods->modifiermap[(row * mods->max_keypermod) + col];
3395
3396 /* Zeroes are used for filler. Skip them. */
3397 if (code == 0)
3398 continue;
3399
3400 /* Are any of this keycode's keysyms a meta key? */
3401 {
3402 int code_col;
3403
3404 for (code_col = 0; code_col < syms_per_code; code_col++)
3405 {
3406 int sym = syms[((code - min_code) * syms_per_code) + code_col];
3407
3408 switch (sym)
3409 {
3410 case XK_Meta_L:
3411 case XK_Meta_R:
3412 found_alt_or_meta = 1;
3413 dpyinfo->meta_mod_mask |= (1 << row);
3414 break;
3415
3416 case XK_Alt_L:
3417 case XK_Alt_R:
3418 found_alt_or_meta = 1;
3419 dpyinfo->alt_mod_mask |= (1 << row);
3420 break;
3421
3422 case XK_Hyper_L:
3423 case XK_Hyper_R:
3424 if (!found_alt_or_meta)
3425 dpyinfo->hyper_mod_mask |= (1 << row);
3426 code_col = syms_per_code;
3427 col = mods->max_keypermod;
3428 break;
3429
3430 case XK_Super_L:
3431 case XK_Super_R:
3432 if (!found_alt_or_meta)
3433 dpyinfo->super_mod_mask |= (1 << row);
3434 code_col = syms_per_code;
3435 col = mods->max_keypermod;
3436 break;
3437
3438 case XK_Shift_Lock:
3439 /* Ignore this if it's not on the lock modifier. */
3440 if (!found_alt_or_meta && ((1 << row) == LockMask))
3441 dpyinfo->shift_lock_mask = LockMask;
3442 code_col = syms_per_code;
3443 col = mods->max_keypermod;
3444 break;
3445 }
3446 }
3447 }
3448 }
3449 }
3450 }
3451
3452 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3453 if (! dpyinfo->meta_mod_mask)
3454 {
3455 dpyinfo->meta_mod_mask = dpyinfo->alt_mod_mask;
3456 dpyinfo->alt_mod_mask = 0;
3457 }
3458
3459 /* If some keys are both alt and meta,
3460 make them just meta, not alt. */
3461 if (dpyinfo->alt_mod_mask & dpyinfo->meta_mod_mask)
3462 {
3463 dpyinfo->alt_mod_mask &= ~dpyinfo->meta_mod_mask;
3464 }
3465
3466 XFree ((char *) syms);
3467 XFreeModifiermap (mods);
3468 }
3469
3470 /* Convert between the modifier bits X uses and the modifier bits
3471 Emacs uses. */
3472
3473 static unsigned int
3474 x_x_to_emacs_modifiers (dpyinfo, state)
3475 struct x_display_info *dpyinfo;
3476 unsigned int state;
3477 {
3478 EMACS_UINT mod_meta = meta_modifier;
3479 EMACS_UINT mod_alt = alt_modifier;
3480 EMACS_UINT mod_hyper = hyper_modifier;
3481 EMACS_UINT mod_super = super_modifier;
3482 Lisp_Object tem;
3483
3484 tem = Fget (Vx_alt_keysym, Qmodifier_value);
3485 if (! EQ (tem, Qnil)) mod_alt = XUINT (tem);
3486 tem = Fget (Vx_meta_keysym, Qmodifier_value);
3487 if (! EQ (tem, Qnil)) mod_meta = XUINT (tem);
3488 tem = Fget (Vx_hyper_keysym, Qmodifier_value);
3489 if (! EQ (tem, Qnil)) mod_hyper = XUINT (tem);
3490 tem = Fget (Vx_super_keysym, Qmodifier_value);
3491 if (! EQ (tem, Qnil)) mod_super = XUINT (tem);
3492
3493
3494 return ( ((state & (ShiftMask | dpyinfo->shift_lock_mask)) ? shift_modifier : 0)
3495 | ((state & ControlMask) ? ctrl_modifier : 0)
3496 | ((state & dpyinfo->meta_mod_mask) ? mod_meta : 0)
3497 | ((state & dpyinfo->alt_mod_mask) ? mod_alt : 0)
3498 | ((state & dpyinfo->super_mod_mask) ? mod_super : 0)
3499 | ((state & dpyinfo->hyper_mod_mask) ? mod_hyper : 0));
3500 }
3501
3502 static unsigned int
3503 x_emacs_to_x_modifiers (dpyinfo, state)
3504 struct x_display_info *dpyinfo;
3505 unsigned int state;
3506 {
3507 EMACS_UINT mod_meta = meta_modifier;
3508 EMACS_UINT mod_alt = alt_modifier;
3509 EMACS_UINT mod_hyper = hyper_modifier;
3510 EMACS_UINT mod_super = super_modifier;
3511
3512 Lisp_Object tem;
3513
3514 tem = Fget (Vx_alt_keysym, Qmodifier_value);
3515 if (! EQ (tem, Qnil)) mod_alt = XUINT (tem);
3516 tem = Fget (Vx_meta_keysym, Qmodifier_value);
3517 if (! EQ (tem, Qnil)) mod_meta = XUINT (tem);
3518 tem = Fget (Vx_hyper_keysym, Qmodifier_value);
3519 if (! EQ (tem, Qnil)) mod_hyper = XUINT (tem);
3520 tem = Fget (Vx_super_keysym, Qmodifier_value);
3521 if (! EQ (tem, Qnil)) mod_super = XUINT (tem);
3522
3523
3524 return ( ((state & mod_alt) ? dpyinfo->alt_mod_mask : 0)
3525 | ((state & mod_super) ? dpyinfo->super_mod_mask : 0)
3526 | ((state & mod_hyper) ? dpyinfo->hyper_mod_mask : 0)
3527 | ((state & shift_modifier) ? ShiftMask : 0)
3528 | ((state & ctrl_modifier) ? ControlMask : 0)
3529 | ((state & mod_meta) ? dpyinfo->meta_mod_mask : 0));
3530 }
3531
3532 /* Convert a keysym to its name. */
3533
3534 char *
3535 x_get_keysym_name (keysym)
3536 KeySym keysym;
3537 {
3538 char *value;
3539
3540 BLOCK_INPUT;
3541 value = XKeysymToString (keysym);
3542 UNBLOCK_INPUT;
3543
3544 return value;
3545 }
3546
3547
3548 \f
3549 /* Mouse clicks and mouse movement. Rah. */
3550
3551 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3552
3553 If the event is a button press, then note that we have grabbed
3554 the mouse. */
3555
3556 static Lisp_Object
3557 construct_mouse_click (result, event, f)
3558 struct input_event *result;
3559 XButtonEvent *event;
3560 struct frame *f;
3561 {
3562 /* Make the event type NO_EVENT; we'll change that when we decide
3563 otherwise. */
3564 result->kind = MOUSE_CLICK_EVENT;
3565 result->code = event->button - Button1;
3566 result->timestamp = event->time;
3567 result->modifiers = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
3568 event->state)
3569 | (event->type == ButtonRelease
3570 ? up_modifier
3571 : down_modifier));
3572
3573 XSETINT (result->x, event->x);
3574 XSETINT (result->y, event->y);
3575 XSETFRAME (result->frame_or_window, f);
3576 result->arg = Qnil;
3577 return Qnil;
3578 }
3579
3580 \f
3581 /* Function to report a mouse movement to the mainstream Emacs code.
3582 The input handler calls this.
3583
3584 We have received a mouse movement event, which is given in *event.
3585 If the mouse is over a different glyph than it was last time, tell
3586 the mainstream emacs code by setting mouse_moved. If not, ask for
3587 another motion event, so we can check again the next time it moves. */
3588
3589 static XMotionEvent last_mouse_motion_event;
3590 static Lisp_Object last_mouse_motion_frame;
3591
3592 static int
3593 note_mouse_movement (frame, event)
3594 FRAME_PTR frame;
3595 XMotionEvent *event;
3596 {
3597 last_mouse_movement_time = event->time;
3598 last_mouse_motion_event = *event;
3599 XSETFRAME (last_mouse_motion_frame, frame);
3600
3601 if (event->window != FRAME_X_WINDOW (frame))
3602 {
3603 frame->mouse_moved = 1;
3604 last_mouse_scroll_bar = Qnil;
3605 note_mouse_highlight (frame, -1, -1);
3606 last_mouse_glyph_frame = 0;
3607 return 1;
3608 }
3609
3610
3611 /* Has the mouse moved off the glyph it was on at the last sighting? */
3612 if (frame != last_mouse_glyph_frame
3613 || event->x < last_mouse_glyph.x
3614 || event->x >= last_mouse_glyph.x + last_mouse_glyph.width
3615 || event->y < last_mouse_glyph.y
3616 || event->y >= last_mouse_glyph.y + last_mouse_glyph.height)
3617 {
3618 frame->mouse_moved = 1;
3619 last_mouse_scroll_bar = Qnil;
3620 note_mouse_highlight (frame, event->x, event->y);
3621 /* Remember which glyph we're now on. */
3622 remember_mouse_glyph (frame, event->x, event->y, &last_mouse_glyph);
3623 last_mouse_glyph_frame = frame;
3624 return 1;
3625 }
3626
3627 return 0;
3628 }
3629
3630 \f
3631 /************************************************************************
3632 Mouse Face
3633 ************************************************************************/
3634
3635 static void
3636 redo_mouse_highlight ()
3637 {
3638 if (!NILP (last_mouse_motion_frame)
3639 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame)))
3640 note_mouse_highlight (XFRAME (last_mouse_motion_frame),
3641 last_mouse_motion_event.x,
3642 last_mouse_motion_event.y);
3643 }
3644
3645
3646
3647 /* Return the current position of the mouse.
3648 *FP should be a frame which indicates which display to ask about.
3649
3650 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3651 and *PART to the frame, window, and scroll bar part that the mouse
3652 is over. Set *X and *Y to the portion and whole of the mouse's
3653 position on the scroll bar.
3654
3655 If the mouse movement started elsewhere, set *FP to the frame the
3656 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3657 the mouse is over.
3658
3659 Set *TIME to the server time-stamp for the time at which the mouse
3660 was at this position.
3661
3662 Don't store anything if we don't have a valid set of values to report.
3663
3664 This clears the mouse_moved flag, so we can wait for the next mouse
3665 movement. */
3666
3667 static void
3668 XTmouse_position (fp, insist, bar_window, part, x, y, time)
3669 FRAME_PTR *fp;
3670 int insist;
3671 Lisp_Object *bar_window;
3672 enum scroll_bar_part *part;
3673 Lisp_Object *x, *y;
3674 unsigned long *time;
3675 {
3676 FRAME_PTR f1;
3677
3678 BLOCK_INPUT;
3679
3680 if (! NILP (last_mouse_scroll_bar) && insist == 0)
3681 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
3682 else
3683 {
3684 Window root;
3685 int root_x, root_y;
3686
3687 Window dummy_window;
3688 int dummy;
3689
3690 Lisp_Object frame, tail;
3691
3692 /* Clear the mouse-moved flag for every frame on this display. */
3693 FOR_EACH_FRAME (tail, frame)
3694 if (FRAME_X_P (XFRAME (frame))
3695 && FRAME_X_DISPLAY (XFRAME (frame)) == FRAME_X_DISPLAY (*fp))
3696 XFRAME (frame)->mouse_moved = 0;
3697
3698 last_mouse_scroll_bar = Qnil;
3699
3700 /* Figure out which root window we're on. */
3701 XQueryPointer (FRAME_X_DISPLAY (*fp),
3702 DefaultRootWindow (FRAME_X_DISPLAY (*fp)),
3703
3704 /* The root window which contains the pointer. */
3705 &root,
3706
3707 /* Trash which we can't trust if the pointer is on
3708 a different screen. */
3709 &dummy_window,
3710
3711 /* The position on that root window. */
3712 &root_x, &root_y,
3713
3714 /* More trash we can't trust. */
3715 &dummy, &dummy,
3716
3717 /* Modifier keys and pointer buttons, about which
3718 we don't care. */
3719 (unsigned int *) &dummy);
3720
3721 /* Now we have a position on the root; find the innermost window
3722 containing the pointer. */
3723 {
3724 Window win, child;
3725 int win_x, win_y;
3726 int parent_x = 0, parent_y = 0;
3727 int count;
3728
3729 win = root;
3730
3731 /* XTranslateCoordinates can get errors if the window
3732 structure is changing at the same time this function
3733 is running. So at least we must not crash from them. */
3734
3735 count = x_catch_errors (FRAME_X_DISPLAY (*fp));
3736
3737 if (FRAME_X_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
3738 && FRAME_LIVE_P (last_mouse_frame))
3739 {
3740 /* If mouse was grabbed on a frame, give coords for that frame
3741 even if the mouse is now outside it. */
3742 XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
3743
3744 /* From-window, to-window. */
3745 root, FRAME_X_WINDOW (last_mouse_frame),
3746
3747 /* From-position, to-position. */
3748 root_x, root_y, &win_x, &win_y,
3749
3750 /* Child of win. */
3751 &child);
3752 f1 = last_mouse_frame;
3753 }
3754 else
3755 {
3756 while (1)
3757 {
3758 XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
3759
3760 /* From-window, to-window. */
3761 root, win,
3762
3763 /* From-position, to-position. */
3764 root_x, root_y, &win_x, &win_y,
3765
3766 /* Child of win. */
3767 &child);
3768
3769 if (child == None || child == win)
3770 break;
3771
3772 win = child;
3773 parent_x = win_x;
3774 parent_y = win_y;
3775 }
3776
3777 /* Now we know that:
3778 win is the innermost window containing the pointer
3779 (XTC says it has no child containing the pointer),
3780 win_x and win_y are the pointer's position in it
3781 (XTC did this the last time through), and
3782 parent_x and parent_y are the pointer's position in win's parent.
3783 (They are what win_x and win_y were when win was child.
3784 If win is the root window, it has no parent, and
3785 parent_{x,y} are invalid, but that's okay, because we'll
3786 never use them in that case.) */
3787
3788 /* Is win one of our frames? */
3789 f1 = x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp), win);
3790
3791 #ifdef USE_X_TOOLKIT
3792 /* If we end up with the menu bar window, say it's not
3793 on the frame. */
3794 if (f1 != NULL
3795 && f1->output_data.x->menubar_widget
3796 && win == XtWindow (f1->output_data.x->menubar_widget))
3797 f1 = NULL;
3798 #endif /* USE_X_TOOLKIT */
3799 }
3800
3801 if (x_had_errors_p (FRAME_X_DISPLAY (*fp)))
3802 f1 = 0;
3803
3804 x_uncatch_errors (FRAME_X_DISPLAY (*fp), count);
3805
3806 /* If not, is it one of our scroll bars? */
3807 if (! f1)
3808 {
3809 struct scroll_bar *bar;
3810
3811 bar = x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp), win);
3812
3813 if (bar)
3814 {
3815 f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
3816 win_x = parent_x;
3817 win_y = parent_y;
3818 }
3819 }
3820
3821 if (f1 == 0 && insist > 0)
3822 f1 = SELECTED_FRAME ();
3823
3824 if (f1)
3825 {
3826 /* Ok, we found a frame. Store all the values.
3827 last_mouse_glyph is a rectangle used to reduce the
3828 generation of mouse events. To not miss any motion
3829 events, we must divide the frame into rectangles of the
3830 size of the smallest character that could be displayed
3831 on it, i.e. into the same rectangles that matrices on
3832 the frame are divided into. */
3833
3834 remember_mouse_glyph (f1, win_x, win_y, &last_mouse_glyph);
3835 last_mouse_glyph_frame = f1;
3836
3837 *bar_window = Qnil;
3838 *part = 0;
3839 *fp = f1;
3840 XSETINT (*x, win_x);
3841 XSETINT (*y, win_y);
3842 *time = last_mouse_movement_time;
3843 }
3844 }
3845 }
3846
3847 UNBLOCK_INPUT;
3848 }
3849
3850
3851 \f
3852 /***********************************************************************
3853 Scroll bars
3854 ***********************************************************************/
3855
3856 /* Scroll bar support. */
3857
3858 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
3859 manages it.
3860 This can be called in GC, so we have to make sure to strip off mark
3861 bits. */
3862
3863 static struct scroll_bar *
3864 x_window_to_scroll_bar (display, window_id)
3865 Display *display;
3866 Window window_id;
3867 {
3868 Lisp_Object tail;
3869
3870 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3871 window_id = (Window) xg_get_scroll_id_for_window (display, window_id);
3872 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
3873
3874 for (tail = Vframe_list;
3875 XGCTYPE (tail) == Lisp_Cons;
3876 tail = XCDR (tail))
3877 {
3878 Lisp_Object frame, bar, condemned;
3879
3880 frame = XCAR (tail);
3881 /* All elements of Vframe_list should be frames. */
3882 if (! GC_FRAMEP (frame))
3883 abort ();
3884
3885 if (! FRAME_X_P (XFRAME (frame)))
3886 continue;
3887
3888 /* Scan this frame's scroll bar list for a scroll bar with the
3889 right window ID. */
3890 condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
3891 for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
3892 /* This trick allows us to search both the ordinary and
3893 condemned scroll bar lists with one loop. */
3894 ! GC_NILP (bar) || (bar = condemned,
3895 condemned = Qnil,
3896 ! GC_NILP (bar));
3897 bar = XSCROLL_BAR (bar)->next)
3898 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)) == window_id &&
3899 FRAME_X_DISPLAY (XFRAME (frame)) == display)
3900 return XSCROLL_BAR (bar);
3901 }
3902
3903 return 0;
3904 }
3905
3906
3907 #if defined USE_LUCID
3908
3909 /* Return the Lucid menu bar WINDOW is part of. Return null
3910 if WINDOW is not part of a menu bar. */
3911
3912 static Widget
3913 x_window_to_menu_bar (window)
3914 Window window;
3915 {
3916 Lisp_Object tail;
3917
3918 for (tail = Vframe_list;
3919 XGCTYPE (tail) == Lisp_Cons;
3920 tail = XCDR (tail))
3921 {
3922 if (FRAME_X_P (XFRAME (XCAR (tail))))
3923 {
3924 Lisp_Object frame = XCAR (tail);
3925 Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
3926
3927 if (menu_bar && xlwmenu_window_p (menu_bar, window))
3928 return menu_bar;
3929 }
3930 }
3931
3932 return NULL;
3933 }
3934
3935 #endif /* USE_LUCID */
3936
3937 \f
3938 /************************************************************************
3939 Toolkit scroll bars
3940 ************************************************************************/
3941
3942 #ifdef USE_TOOLKIT_SCROLL_BARS
3943
3944 static void x_scroll_bar_to_input_event P_ ((XEvent *, struct input_event *));
3945 static void x_send_scroll_bar_event P_ ((Lisp_Object, int, int, int));
3946 static void x_create_toolkit_scroll_bar P_ ((struct frame *,
3947 struct scroll_bar *));
3948 static void x_set_toolkit_scroll_bar_thumb P_ ((struct scroll_bar *,
3949 int, int, int));
3950
3951
3952 /* Lisp window being scrolled. Set when starting to interact with
3953 a toolkit scroll bar, reset to nil when ending the interaction. */
3954
3955 static Lisp_Object window_being_scrolled;
3956
3957 /* Last scroll bar part sent in xm_scroll_callback. */
3958
3959 static int last_scroll_bar_part;
3960
3961 /* Whether this is an Xaw with arrow-scrollbars. This should imply
3962 that movements of 1/20 of the screen size are mapped to up/down. */
3963
3964 #ifndef USE_GTK
3965 /* Id of action hook installed for scroll bars. */
3966
3967 static XtActionHookId action_hook_id;
3968
3969 static Boolean xaw3d_arrow_scroll;
3970
3971 /* Whether the drag scrolling maintains the mouse at the top of the
3972 thumb. If not, resizing the thumb needs to be done more carefully
3973 to avoid jerkyness. */
3974
3975 static Boolean xaw3d_pick_top;
3976
3977 /* Action hook installed via XtAppAddActionHook when toolkit scroll
3978 bars are used.. The hook is responsible for detecting when
3979 the user ends an interaction with the scroll bar, and generates
3980 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
3981
3982 static void
3983 xt_action_hook (widget, client_data, action_name, event, params,
3984 num_params)
3985 Widget widget;
3986 XtPointer client_data;
3987 String action_name;
3988 XEvent *event;
3989 String *params;
3990 Cardinal *num_params;
3991 {
3992 int scroll_bar_p;
3993 char *end_action;
3994
3995 #ifdef USE_MOTIF
3996 scroll_bar_p = XmIsScrollBar (widget);
3997 end_action = "Release";
3998 #else /* !USE_MOTIF i.e. use Xaw */
3999 scroll_bar_p = XtIsSubclass (widget, scrollbarWidgetClass);
4000 end_action = "EndScroll";
4001 #endif /* USE_MOTIF */
4002
4003 if (scroll_bar_p
4004 && strcmp (action_name, end_action) == 0
4005 && WINDOWP (window_being_scrolled))
4006 {
4007 struct window *w;
4008
4009 x_send_scroll_bar_event (window_being_scrolled,
4010 scroll_bar_end_scroll, 0, 0);
4011 w = XWINDOW (window_being_scrolled);
4012
4013 if (!NILP (XSCROLL_BAR (w->vertical_scroll_bar)->dragging))
4014 {
4015 XSCROLL_BAR (w->vertical_scroll_bar)->dragging = Qnil;
4016 /* The thumb size is incorrect while dragging: fix it. */
4017 set_vertical_scroll_bar (w);
4018 }
4019 window_being_scrolled = Qnil;
4020 last_scroll_bar_part = -1;
4021
4022 /* Xt timeouts no longer needed. */
4023 toolkit_scroll_bar_interaction = 0;
4024 }
4025 }
4026 #endif /* not USE_GTK */
4027
4028 /* A vector of windows used for communication between
4029 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
4030
4031 static struct window **scroll_bar_windows;
4032 static int scroll_bar_windows_size;
4033
4034
4035 /* Send a client message with message type Xatom_Scrollbar for a
4036 scroll action to the frame of WINDOW. PART is a value identifying
4037 the part of the scroll bar that was clicked on. PORTION is the
4038 amount to scroll of a whole of WHOLE. */
4039
4040 static void
4041 x_send_scroll_bar_event (window, part, portion, whole)
4042 Lisp_Object window;
4043 int part, portion, whole;
4044 {
4045 XEvent event;
4046 XClientMessageEvent *ev = (XClientMessageEvent *) &event;
4047 struct window *w = XWINDOW (window);
4048 struct frame *f = XFRAME (w->frame);
4049 int i;
4050
4051 BLOCK_INPUT;
4052
4053 /* Construct a ClientMessage event to send to the frame. */
4054 ev->type = ClientMessage;
4055 ev->message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_Scrollbar;
4056 ev->display = FRAME_X_DISPLAY (f);
4057 ev->window = FRAME_X_WINDOW (f);
4058 ev->format = 32;
4059
4060 /* We can only transfer 32 bits in the XClientMessageEvent, which is
4061 not enough to store a pointer or Lisp_Object on a 64 bit system.
4062 So, store the window in scroll_bar_windows and pass the index
4063 into that array in the event. */
4064 for (i = 0; i < scroll_bar_windows_size; ++i)
4065 if (scroll_bar_windows[i] == NULL)
4066 break;
4067
4068 if (i == scroll_bar_windows_size)
4069 {
4070 int new_size = max (10, 2 * scroll_bar_windows_size);
4071 size_t nbytes = new_size * sizeof *scroll_bar_windows;
4072 size_t old_nbytes = scroll_bar_windows_size * sizeof *scroll_bar_windows;
4073
4074 scroll_bar_windows = (struct window **) xrealloc (scroll_bar_windows,
4075 nbytes);
4076 bzero (&scroll_bar_windows[i], nbytes - old_nbytes);
4077 scroll_bar_windows_size = new_size;
4078 }
4079
4080 scroll_bar_windows[i] = w;
4081 ev->data.l[0] = (long) i;
4082 ev->data.l[1] = (long) part;
4083 ev->data.l[2] = (long) 0;
4084 ev->data.l[3] = (long) portion;
4085 ev->data.l[4] = (long) whole;
4086
4087 /* Make Xt timeouts work while the scroll bar is active. */
4088 toolkit_scroll_bar_interaction = 1;
4089
4090 /* Setting the event mask to zero means that the message will
4091 be sent to the client that created the window, and if that
4092 window no longer exists, no event will be sent. */
4093 XSendEvent (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), False, 0, &event);
4094 UNBLOCK_INPUT;
4095 }
4096
4097
4098 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4099 in *IEVENT. */
4100
4101 static void
4102 x_scroll_bar_to_input_event (event, ievent)
4103 XEvent *event;
4104 struct input_event *ievent;
4105 {
4106 XClientMessageEvent *ev = (XClientMessageEvent *) event;
4107 Lisp_Object window;
4108 struct frame *f;
4109 struct window *w;
4110
4111 w = scroll_bar_windows[ev->data.l[0]];
4112 scroll_bar_windows[ev->data.l[0]] = NULL;
4113
4114 XSETWINDOW (window, w);
4115 f = XFRAME (w->frame);
4116
4117 ievent->kind = SCROLL_BAR_CLICK_EVENT;
4118 ievent->frame_or_window = window;
4119 ievent->arg = Qnil;
4120 #ifdef USE_GTK
4121 ievent->timestamp = CurrentTime;
4122 #else
4123 ievent->timestamp = XtLastTimestampProcessed (FRAME_X_DISPLAY (f));
4124 #endif
4125 ievent->part = ev->data.l[1];
4126 ievent->code = ev->data.l[2];
4127 ievent->x = make_number ((int) ev->data.l[3]);
4128 ievent->y = make_number ((int) ev->data.l[4]);
4129 ievent->modifiers = 0;
4130 }
4131
4132
4133 #ifdef USE_MOTIF
4134
4135 /* Minimum and maximum values used for Motif scroll bars. */
4136
4137 #define XM_SB_MAX 10000000
4138
4139
4140 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4141 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4142 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4143
4144 static void
4145 xm_scroll_callback (widget, client_data, call_data)
4146 Widget widget;
4147 XtPointer client_data, call_data;
4148 {
4149 struct scroll_bar *bar = (struct scroll_bar *) client_data;
4150 XmScrollBarCallbackStruct *cs = (XmScrollBarCallbackStruct *) call_data;
4151 int part = -1, whole = 0, portion = 0;
4152
4153 switch (cs->reason)
4154 {
4155 case XmCR_DECREMENT:
4156 bar->dragging = Qnil;
4157 part = scroll_bar_up_arrow;
4158 break;
4159
4160 case XmCR_INCREMENT:
4161 bar->dragging = Qnil;
4162 part = scroll_bar_down_arrow;
4163 break;
4164
4165 case XmCR_PAGE_DECREMENT:
4166 bar->dragging = Qnil;
4167 part = scroll_bar_above_handle;
4168 break;
4169
4170 case XmCR_PAGE_INCREMENT:
4171 bar->dragging = Qnil;
4172 part = scroll_bar_below_handle;
4173 break;
4174
4175 case XmCR_TO_TOP:
4176 bar->dragging = Qnil;
4177 part = scroll_bar_to_top;
4178 break;
4179
4180 case XmCR_TO_BOTTOM:
4181 bar->dragging = Qnil;
4182 part = scroll_bar_to_bottom;
4183 break;
4184
4185 case XmCR_DRAG:
4186 {
4187 int slider_size;
4188
4189 /* Get the slider size. */
4190 BLOCK_INPUT;
4191 XtVaGetValues (widget, XmNsliderSize, &slider_size, NULL);
4192 UNBLOCK_INPUT;
4193
4194 whole = XM_SB_MAX - slider_size;
4195 portion = min (cs->value, whole);
4196 part = scroll_bar_handle;
4197 bar->dragging = make_number (cs->value);
4198 }
4199 break;
4200
4201 case XmCR_VALUE_CHANGED:
4202 break;
4203 };
4204
4205 if (part >= 0)
4206 {
4207 window_being_scrolled = bar->window;
4208 last_scroll_bar_part = part;
4209 x_send_scroll_bar_event (bar->window, part, portion, whole);
4210 }
4211 }
4212
4213
4214 #else /* !USE_MOTIF, i.e. Xaw or GTK */
4215 #ifdef USE_GTK
4216 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4217 bar widget. DATA is a pointer to the scroll_bar structure. */
4218
4219 static void
4220 xg_scroll_callback (widget, data)
4221 GtkRange *widget;
4222 gpointer data;
4223 {
4224 struct scroll_bar *bar = (struct scroll_bar *) data;
4225 gdouble previous;
4226 gdouble position;
4227 gdouble *p;
4228 int diff;
4229
4230 int part = -1, whole = 0, portion = 0;
4231 GtkAdjustment *adj = GTK_ADJUSTMENT (gtk_range_get_adjustment (widget));
4232
4233 position = gtk_adjustment_get_value (adj);
4234
4235 p = g_object_get_data (G_OBJECT (widget), XG_LAST_SB_DATA);
4236 if (! p)
4237 {
4238 p = (gdouble*) xmalloc (sizeof (gdouble));
4239 *p = XG_SB_MIN;
4240 g_object_set_data (G_OBJECT (widget), XG_LAST_SB_DATA, p);
4241 }
4242
4243 previous = *p;
4244 *p = position;
4245
4246 if (xg_ignore_gtk_scrollbar) return;
4247
4248 diff = (int) (position - previous);
4249
4250 if (diff == (int) adj->step_increment)
4251 {
4252 part = scroll_bar_down_arrow;
4253 bar->dragging = Qnil;
4254 }
4255 else if (-diff == (int) adj->step_increment)
4256 {
4257 part = scroll_bar_up_arrow;
4258 bar->dragging = Qnil;
4259 }
4260 else if (diff == (int) adj->page_increment)
4261 {
4262 part = scroll_bar_below_handle;
4263 bar->dragging = Qnil;
4264 }
4265 else if (-diff == (int) adj->page_increment)
4266 {
4267 part = scroll_bar_above_handle;
4268 bar->dragging = Qnil;
4269 }
4270 else
4271 {
4272 part = scroll_bar_handle;
4273 whole = adj->upper - adj->page_size;
4274 portion = min ((int)position, whole);
4275 bar->dragging = make_number ((int)portion);
4276 }
4277
4278 if (part >= 0)
4279 {
4280 window_being_scrolled = bar->window;
4281 last_scroll_bar_part = part;
4282 x_send_scroll_bar_event (bar->window, part, portion, whole);
4283 }
4284 }
4285
4286 #else /* not USE_GTK */
4287
4288 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4289 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4290 scroll bar struct. CALL_DATA is a pointer to a float saying where
4291 the thumb is. */
4292
4293 static void
4294 xaw_jump_callback (widget, client_data, call_data)
4295 Widget widget;
4296 XtPointer client_data, call_data;
4297 {
4298 struct scroll_bar *bar = (struct scroll_bar *) client_data;
4299 float top = *(float *) call_data;
4300 float shown;
4301 int whole, portion, height;
4302 int part;
4303
4304 /* Get the size of the thumb, a value between 0 and 1. */
4305 BLOCK_INPUT;
4306 XtVaGetValues (widget, XtNshown, &shown, XtNheight, &height, NULL);
4307 UNBLOCK_INPUT;
4308
4309 whole = 10000000;
4310 portion = shown < 1 ? top * whole : 0;
4311
4312 if (shown < 1 && (abs (top + shown - 1) < 1.0/height))
4313 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4314 the bottom, so we force the scrolling whenever we see that we're
4315 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4316 we try to ensure that we always stay two pixels away from the
4317 bottom). */
4318 part = scroll_bar_down_arrow;
4319 else
4320 part = scroll_bar_handle;
4321
4322 window_being_scrolled = bar->window;
4323 bar->dragging = make_number (portion);
4324 last_scroll_bar_part = part;
4325 x_send_scroll_bar_event (bar->window, part, portion, whole);
4326 }
4327
4328
4329 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4330 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4331 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4332 the scroll bar. CALL_DATA is an integer specifying the action that
4333 has taken place. Its magnitude is in the range 0..height of the
4334 scroll bar. Negative values mean scroll towards buffer start.
4335 Values < height of scroll bar mean line-wise movement. */
4336
4337 static void
4338 xaw_scroll_callback (widget, client_data, call_data)
4339 Widget widget;
4340 XtPointer client_data, call_data;
4341 {
4342 struct scroll_bar *bar = (struct scroll_bar *) client_data;
4343 /* The position really is stored cast to a pointer. */
4344 int position = (long) call_data;
4345 Dimension height;
4346 int part;
4347
4348 /* Get the height of the scroll bar. */
4349 BLOCK_INPUT;
4350 XtVaGetValues (widget, XtNheight, &height, NULL);
4351 UNBLOCK_INPUT;
4352
4353 if (abs (position) >= height)
4354 part = (position < 0) ? scroll_bar_above_handle : scroll_bar_below_handle;
4355
4356 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4357 it maps line-movement to call_data = max(5, height/20). */
4358 else if (xaw3d_arrow_scroll && abs (position) <= max (5, height / 20))
4359 part = (position < 0) ? scroll_bar_up_arrow : scroll_bar_down_arrow;
4360 else
4361 part = scroll_bar_move_ratio;
4362
4363 window_being_scrolled = bar->window;
4364 bar->dragging = Qnil;
4365 last_scroll_bar_part = part;
4366 x_send_scroll_bar_event (bar->window, part, position, height);
4367 }
4368
4369 #endif /* not USE_GTK */
4370 #endif /* not USE_MOTIF */
4371
4372 #define SCROLL_BAR_NAME "verticalScrollBar"
4373
4374 /* Create the widget for scroll bar BAR on frame F. Record the widget
4375 and X window of the scroll bar in BAR. */
4376
4377 #ifdef USE_GTK
4378 static void
4379 x_create_toolkit_scroll_bar (f, bar)
4380 struct frame *f;
4381 struct scroll_bar *bar;
4382 {
4383 char *scroll_bar_name = SCROLL_BAR_NAME;
4384
4385 BLOCK_INPUT;
4386 xg_create_scroll_bar (f, bar, G_CALLBACK (xg_scroll_callback),
4387 scroll_bar_name);
4388 UNBLOCK_INPUT;
4389 }
4390
4391 #else /* not USE_GTK */
4392
4393 static void
4394 x_create_toolkit_scroll_bar (f, bar)
4395 struct frame *f;
4396 struct scroll_bar *bar;
4397 {
4398 Window xwindow;
4399 Widget widget;
4400 Arg av[20];
4401 int ac = 0;
4402 char *scroll_bar_name = SCROLL_BAR_NAME;
4403 unsigned long pixel;
4404
4405 BLOCK_INPUT;
4406
4407 #ifdef USE_MOTIF
4408 /* Set resources. Create the widget. */
4409 XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
4410 XtSetArg (av[ac], XmNminimum, 0); ++ac;
4411 XtSetArg (av[ac], XmNmaximum, XM_SB_MAX); ++ac;
4412 XtSetArg (av[ac], XmNorientation, XmVERTICAL); ++ac;
4413 XtSetArg (av[ac], XmNprocessingDirection, XmMAX_ON_BOTTOM), ++ac;
4414 XtSetArg (av[ac], XmNincrement, 1); ++ac;
4415 XtSetArg (av[ac], XmNpageIncrement, 1); ++ac;
4416
4417 pixel = f->output_data.x->scroll_bar_foreground_pixel;
4418 if (pixel != -1)
4419 {
4420 XtSetArg (av[ac], XmNforeground, pixel);
4421 ++ac;
4422 }
4423
4424 pixel = f->output_data.x->scroll_bar_background_pixel;
4425 if (pixel != -1)
4426 {
4427 XtSetArg (av[ac], XmNbackground, pixel);
4428 ++ac;
4429 }
4430
4431 widget = XmCreateScrollBar (f->output_data.x->edit_widget,
4432 scroll_bar_name, av, ac);
4433
4434 /* Add one callback for everything that can happen. */
4435 XtAddCallback (widget, XmNdecrementCallback, xm_scroll_callback,
4436 (XtPointer) bar);
4437 XtAddCallback (widget, XmNdragCallback, xm_scroll_callback,
4438 (XtPointer) bar);
4439 XtAddCallback (widget, XmNincrementCallback, xm_scroll_callback,
4440 (XtPointer) bar);
4441 XtAddCallback (widget, XmNpageDecrementCallback, xm_scroll_callback,
4442 (XtPointer) bar);
4443 XtAddCallback (widget, XmNpageIncrementCallback, xm_scroll_callback,
4444 (XtPointer) bar);
4445 XtAddCallback (widget, XmNtoBottomCallback, xm_scroll_callback,
4446 (XtPointer) bar);
4447 XtAddCallback (widget, XmNtoTopCallback, xm_scroll_callback,
4448 (XtPointer) bar);
4449
4450 /* Realize the widget. Only after that is the X window created. */
4451 XtRealizeWidget (widget);
4452
4453 /* Set the cursor to an arrow. I didn't find a resource to do that.
4454 And I'm wondering why it hasn't an arrow cursor by default. */
4455 XDefineCursor (XtDisplay (widget), XtWindow (widget),
4456 f->output_data.x->nontext_cursor);
4457
4458 #else /* !USE_MOTIF i.e. use Xaw */
4459
4460 /* Set resources. Create the widget. The background of the
4461 Xaw3d scroll bar widget is a little bit light for my taste.
4462 We don't alter it here to let users change it according
4463 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4464 XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
4465 XtSetArg (av[ac], XtNorientation, XtorientVertical); ++ac;
4466 /* For smoother scrolling with Xaw3d -sm */
4467 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4468
4469 pixel = f->output_data.x->scroll_bar_foreground_pixel;
4470 if (pixel != -1)
4471 {
4472 XtSetArg (av[ac], XtNforeground, pixel);
4473 ++ac;
4474 }
4475
4476 pixel = f->output_data.x->scroll_bar_background_pixel;
4477 if (pixel != -1)
4478 {
4479 XtSetArg (av[ac], XtNbackground, pixel);
4480 ++ac;
4481 }
4482
4483 /* Top/bottom shadow colors. */
4484
4485 /* Allocate them, if necessary. */
4486 if (f->output_data.x->scroll_bar_top_shadow_pixel == -1)
4487 {
4488 pixel = f->output_data.x->scroll_bar_background_pixel;
4489 if (!x_alloc_lighter_color (f, FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
4490 &pixel, 1.2, 0x8000))
4491 pixel = -1;
4492 f->output_data.x->scroll_bar_top_shadow_pixel = pixel;
4493 }
4494 if (f->output_data.x->scroll_bar_bottom_shadow_pixel == -1)
4495 {
4496 pixel = f->output_data.x->scroll_bar_background_pixel;
4497 if (!x_alloc_lighter_color (f, FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
4498 &pixel, 0.6, 0x4000))
4499 pixel = -1;
4500 f->output_data.x->scroll_bar_bottom_shadow_pixel = pixel;
4501 }
4502
4503 #ifdef XtNbeNiceToColormap
4504 /* Tell the toolkit about them. */
4505 if (f->output_data.x->scroll_bar_top_shadow_pixel == -1
4506 || f->output_data.x->scroll_bar_bottom_shadow_pixel == -1)
4507 /* We tried to allocate a color for the top/bottom shadow, and
4508 failed, so tell Xaw3d to use dithering instead. */
4509 {
4510 XtSetArg (av[ac], XtNbeNiceToColormap, True);
4511 ++ac;
4512 }
4513 else
4514 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4515 be more consistent with other emacs 3d colors, and since Xaw3d is
4516 not good at dealing with allocation failure. */
4517 {
4518 /* This tells Xaw3d to use real colors instead of dithering for
4519 the shadows. */
4520 XtSetArg (av[ac], XtNbeNiceToColormap, False);
4521 ++ac;
4522
4523 /* Specify the colors. */
4524 pixel = f->output_data.x->scroll_bar_top_shadow_pixel;
4525 if (pixel != -1)
4526 {
4527 XtSetArg (av[ac], XtNtopShadowPixel, pixel);
4528 ++ac;
4529 }
4530 pixel = f->output_data.x->scroll_bar_bottom_shadow_pixel;
4531 if (pixel != -1)
4532 {
4533 XtSetArg (av[ac], XtNbottomShadowPixel, pixel);
4534 ++ac;
4535 }
4536 }
4537 #endif
4538
4539 widget = XtCreateWidget (scroll_bar_name, scrollbarWidgetClass,
4540 f->output_data.x->edit_widget, av, ac);
4541
4542 {
4543 char *initial = "";
4544 char *val = initial;
4545 XtVaGetValues (widget, XtNscrollVCursor, (XtPointer) &val,
4546 #ifdef XtNarrowScrollbars
4547 XtNarrowScrollbars, (XtPointer) &xaw3d_arrow_scroll,
4548 #endif
4549 XtNpickTop, (XtPointer) &xaw3d_pick_top, NULL);
4550 if (xaw3d_arrow_scroll || val == initial)
4551 { /* ARROW_SCROLL */
4552 xaw3d_arrow_scroll = True;
4553 /* Isn't that just a personal preference ? --Stef */
4554 XtVaSetValues (widget, XtNcursorName, "top_left_arrow", NULL);
4555 }
4556 }
4557
4558 /* Define callbacks. */
4559 XtAddCallback (widget, XtNjumpProc, xaw_jump_callback, (XtPointer) bar);
4560 XtAddCallback (widget, XtNscrollProc, xaw_scroll_callback,
4561 (XtPointer) bar);
4562
4563 /* Realize the widget. Only after that is the X window created. */
4564 XtRealizeWidget (widget);
4565
4566 #endif /* !USE_MOTIF */
4567
4568 /* Install an action hook that lets us detect when the user
4569 finishes interacting with a scroll bar. */
4570 if (action_hook_id == 0)
4571 action_hook_id = XtAppAddActionHook (Xt_app_con, xt_action_hook, 0);
4572
4573 /* Remember X window and widget in the scroll bar vector. */
4574 SET_SCROLL_BAR_X_WIDGET (bar, widget);
4575 xwindow = XtWindow (widget);
4576 SET_SCROLL_BAR_X_WINDOW (bar, xwindow);
4577
4578 UNBLOCK_INPUT;
4579 }
4580 #endif /* not USE_GTK */
4581
4582
4583 /* Set the thumb size and position of scroll bar BAR. We are currently
4584 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4585
4586 #ifdef USE_GTK
4587 static void
4588 x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole)
4589 struct scroll_bar *bar;
4590 int portion, position, whole;
4591 {
4592 xg_set_toolkit_scroll_bar_thumb (bar, portion, position, whole);
4593 }
4594
4595 #else /* not USE_GTK */
4596 static void
4597 x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole)
4598 struct scroll_bar *bar;
4599 int portion, position, whole;
4600 {
4601 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
4602 Widget widget = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
4603 float top, shown;
4604
4605 BLOCK_INPUT;
4606
4607 #ifdef USE_MOTIF
4608
4609 /* We use an estimate of 30 chars per line rather than the real
4610 `portion' value. This has the disadvantage that the thumb size
4611 is not very representative, but it makes our life a lot easier.
4612 Otherwise, we have to constantly adjust the thumb size, which
4613 we can't always do quickly enough: while dragging, the size of
4614 the thumb might prevent the user from dragging the thumb all the
4615 way to the end. but Motif and some versions of Xaw3d don't allow
4616 updating the thumb size while dragging. Also, even if we can update
4617 its size, the update will often happen too late.
4618 If you don't believe it, check out revision 1.650 of xterm.c to see
4619 what hoops we were going through and the still poor behavior we got. */
4620 portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
4621 /* When the thumb is at the bottom, position == whole.
4622 So we need to increase `whole' to make space for the thumb. */
4623 whole += portion;
4624
4625 if (whole <= 0)
4626 top = 0, shown = 1;
4627 else
4628 {
4629 top = (float) position / whole;
4630 shown = (float) portion / whole;
4631 }
4632
4633 if (NILP (bar->dragging))
4634 {
4635 int size, value;
4636
4637 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4638 is the scroll bar's maximum and MIN is the scroll bar's minimum
4639 value. */
4640 size = shown * XM_SB_MAX;
4641 size = min (size, XM_SB_MAX);
4642 size = max (size, 1);
4643
4644 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4645 value = top * XM_SB_MAX;
4646 value = min (value, XM_SB_MAX - size);
4647
4648 XmScrollBarSetValues (widget, value, size, 0, 0, False);
4649 }
4650 #else /* !USE_MOTIF i.e. use Xaw */
4651
4652 if (whole == 0)
4653 top = 0, shown = 1;
4654 else
4655 {
4656 top = (float) position / whole;
4657 shown = (float) portion / whole;
4658 }
4659
4660 {
4661 float old_top, old_shown;
4662 Dimension height;
4663 XtVaGetValues (widget,
4664 XtNtopOfThumb, &old_top,
4665 XtNshown, &old_shown,
4666 XtNheight, &height,
4667 NULL);
4668
4669 /* Massage the top+shown values. */
4670 if (NILP (bar->dragging) || last_scroll_bar_part == scroll_bar_down_arrow)
4671 top = max (0, min (1, top));
4672 else
4673 top = old_top;
4674 /* Keep two pixels available for moving the thumb down. */
4675 shown = max (0, min (1 - top - (2.0 / height), shown));
4676
4677 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
4678 check that your system's configuration file contains a define
4679 for `NARROWPROTO'. See s/freebsd.h for an example. */
4680 if (top != old_top || shown != old_shown)
4681 {
4682 if (NILP (bar->dragging))
4683 XawScrollbarSetThumb (widget, top, shown);
4684 else
4685 {
4686 /* Try to make the scrolling a tad smoother. */
4687 if (!xaw3d_pick_top)
4688 shown = min (shown, old_shown);
4689
4690 XawScrollbarSetThumb (widget, top, shown);
4691 }
4692 }
4693 }
4694 #endif /* !USE_MOTIF */
4695
4696 UNBLOCK_INPUT;
4697 }
4698 #endif /* not USE_GTK */
4699
4700 #endif /* USE_TOOLKIT_SCROLL_BARS */
4701
4702
4703 \f
4704 /************************************************************************
4705 Scroll bars, general
4706 ************************************************************************/
4707
4708 /* Create a scroll bar and return the scroll bar vector for it. W is
4709 the Emacs window on which to create the scroll bar. TOP, LEFT,
4710 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4711 scroll bar. */
4712
4713 static struct scroll_bar *
4714 x_scroll_bar_create (w, top, left, width, height)
4715 struct window *w;
4716 int top, left, width, height;
4717 {
4718 struct frame *f = XFRAME (w->frame);
4719 struct scroll_bar *bar
4720 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
4721
4722 BLOCK_INPUT;
4723
4724 #ifdef USE_TOOLKIT_SCROLL_BARS
4725 x_create_toolkit_scroll_bar (f, bar);
4726 #else /* not USE_TOOLKIT_SCROLL_BARS */
4727 {
4728 XSetWindowAttributes a;
4729 unsigned long mask;
4730 Window window;
4731
4732 a.background_pixel = f->output_data.x->scroll_bar_background_pixel;
4733 if (a.background_pixel == -1)
4734 a.background_pixel = f->output_data.x->background_pixel;
4735
4736 a.event_mask = (ButtonPressMask | ButtonReleaseMask
4737 | ButtonMotionMask | PointerMotionHintMask
4738 | ExposureMask);
4739 a.cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
4740
4741 mask = (CWBackPixel | CWEventMask | CWCursor);
4742
4743 /* Clear the area of W that will serve as a scroll bar. This is
4744 for the case that a window has been split horizontally. In
4745 this case, no clear_frame is generated to reduce flickering. */
4746 if (width > 0 && height > 0)
4747 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
4748 left, top, width,
4749 window_box_height (w), False);
4750
4751 window = XCreateWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
4752 /* Position and size of scroll bar. */
4753 left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
4754 top,
4755 width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
4756 height,
4757 /* Border width, depth, class, and visual. */
4758 0,
4759 CopyFromParent,
4760 CopyFromParent,
4761 CopyFromParent,
4762 /* Attributes. */
4763 mask, &a);
4764 SET_SCROLL_BAR_X_WINDOW (bar, window);
4765 }
4766 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4767
4768 XSETWINDOW (bar->window, w);
4769 XSETINT (bar->top, top);
4770 XSETINT (bar->left, left);
4771 XSETINT (bar->width, width);
4772 XSETINT (bar->height, height);
4773 XSETINT (bar->start, 0);
4774 XSETINT (bar->end, 0);
4775 bar->dragging = Qnil;
4776
4777 /* Add bar to its frame's list of scroll bars. */
4778 bar->next = FRAME_SCROLL_BARS (f);
4779 bar->prev = Qnil;
4780 XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
4781 if (!NILP (bar->next))
4782 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
4783
4784 /* Map the window/widget. */
4785 #ifdef USE_TOOLKIT_SCROLL_BARS
4786 {
4787 #ifdef USE_GTK
4788 xg_update_scrollbar_pos (f,
4789 SCROLL_BAR_X_WINDOW (bar),
4790 top,
4791 left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
4792 width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
4793 max (height, 1));
4794 xg_show_scroll_bar (SCROLL_BAR_X_WINDOW (bar));
4795 #else /* not USE_GTK */
4796 Widget scroll_bar = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
4797 XtConfigureWidget (scroll_bar,
4798 left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
4799 top,
4800 width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
4801 max (height, 1), 0);
4802 XtMapWidget (scroll_bar);
4803 #endif /* not USE_GTK */
4804 }
4805 #else /* not USE_TOOLKIT_SCROLL_BARS */
4806 XMapRaised (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
4807 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4808
4809 UNBLOCK_INPUT;
4810 return bar;
4811 }
4812
4813
4814 /* Draw BAR's handle in the proper position.
4815
4816 If the handle is already drawn from START to END, don't bother
4817 redrawing it, unless REBUILD is non-zero; in that case, always
4818 redraw it. (REBUILD is handy for drawing the handle after expose
4819 events.)
4820
4821 Normally, we want to constrain the start and end of the handle to
4822 fit inside its rectangle, but if the user is dragging the scroll
4823 bar handle, we want to let them drag it down all the way, so that
4824 the bar's top is as far down as it goes; otherwise, there's no way
4825 to move to the very end of the buffer. */
4826
4827 #ifndef USE_TOOLKIT_SCROLL_BARS
4828
4829 static void
4830 x_scroll_bar_set_handle (bar, start, end, rebuild)
4831 struct scroll_bar *bar;
4832 int start, end;
4833 int rebuild;
4834 {
4835 int dragging = ! NILP (bar->dragging);
4836 Window w = SCROLL_BAR_X_WINDOW (bar);
4837 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
4838 GC gc = f->output_data.x->normal_gc;
4839
4840 /* If the display is already accurate, do nothing. */
4841 if (! rebuild
4842 && start == XINT (bar->start)
4843 && end == XINT (bar->end))
4844 return;
4845
4846 BLOCK_INPUT;
4847
4848 {
4849 int inside_width = VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f, XINT (bar->width));
4850 int inside_height = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
4851 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
4852
4853 /* Make sure the values are reasonable, and try to preserve
4854 the distance between start and end. */
4855 {
4856 int length = end - start;
4857
4858 if (start < 0)
4859 start = 0;
4860 else if (start > top_range)
4861 start = top_range;
4862 end = start + length;
4863
4864 if (end < start)
4865 end = start;
4866 else if (end > top_range && ! dragging)
4867 end = top_range;
4868 }
4869
4870 /* Store the adjusted setting in the scroll bar. */
4871 XSETINT (bar->start, start);
4872 XSETINT (bar->end, end);
4873
4874 /* Clip the end position, just for display. */
4875 if (end > top_range)
4876 end = top_range;
4877
4878 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
4879 below top positions, to make sure the handle is always at least
4880 that many pixels tall. */
4881 end += VERTICAL_SCROLL_BAR_MIN_HANDLE;
4882
4883 /* Draw the empty space above the handle. Note that we can't clear
4884 zero-height areas; that means "clear to end of window." */
4885 if (0 < start)
4886 x_clear_area (FRAME_X_DISPLAY (f), w,
4887 /* x, y, width, height, and exposures. */
4888 VERTICAL_SCROLL_BAR_LEFT_BORDER,
4889 VERTICAL_SCROLL_BAR_TOP_BORDER,
4890 inside_width, start,
4891 False);
4892
4893 /* Change to proper foreground color if one is specified. */
4894 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
4895 XSetForeground (FRAME_X_DISPLAY (f), gc,
4896 f->output_data.x->scroll_bar_foreground_pixel);
4897
4898 /* Draw the handle itself. */
4899 XFillRectangle (FRAME_X_DISPLAY (f), w, gc,
4900 /* x, y, width, height */
4901 VERTICAL_SCROLL_BAR_LEFT_BORDER,
4902 VERTICAL_SCROLL_BAR_TOP_BORDER + start,
4903 inside_width, end - start);
4904
4905 /* Restore the foreground color of the GC if we changed it above. */
4906 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
4907 XSetForeground (FRAME_X_DISPLAY (f), gc,
4908 f->output_data.x->foreground_pixel);
4909
4910 /* Draw the empty space below the handle. Note that we can't
4911 clear zero-height areas; that means "clear to end of window." */
4912 if (end < inside_height)
4913 x_clear_area (FRAME_X_DISPLAY (f), w,
4914 /* x, y, width, height, and exposures. */
4915 VERTICAL_SCROLL_BAR_LEFT_BORDER,
4916 VERTICAL_SCROLL_BAR_TOP_BORDER + end,
4917 inside_width, inside_height - end,
4918 False);
4919
4920 }
4921
4922 UNBLOCK_INPUT;
4923 }
4924
4925 #endif /* !USE_TOOLKIT_SCROLL_BARS */
4926
4927 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
4928 nil. */
4929
4930 static void
4931 x_scroll_bar_remove (bar)
4932 struct scroll_bar *bar;
4933 {
4934 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
4935 BLOCK_INPUT;
4936
4937 #ifdef USE_TOOLKIT_SCROLL_BARS
4938 #ifdef USE_GTK
4939 xg_remove_scroll_bar (f, SCROLL_BAR_X_WINDOW (bar));
4940 #else /* not USE_GTK */
4941 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar));
4942 #endif /* not USE_GTK */
4943 #else
4944 XDestroyWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
4945 #endif
4946
4947 /* Disassociate this scroll bar from its window. */
4948 XWINDOW (bar->window)->vertical_scroll_bar = Qnil;
4949
4950 UNBLOCK_INPUT;
4951 }
4952
4953
4954 /* Set the handle of the vertical scroll bar for WINDOW to indicate
4955 that we are displaying PORTION characters out of a total of WHOLE
4956 characters, starting at POSITION. If WINDOW has no scroll bar,
4957 create one. */
4958
4959 static void
4960 XTset_vertical_scroll_bar (w, portion, whole, position)
4961 struct window *w;
4962 int portion, whole, position;
4963 {
4964 struct frame *f = XFRAME (w->frame);
4965 struct scroll_bar *bar;
4966 int top, height, left, sb_left, width, sb_width;
4967 int window_y, window_height;
4968
4969 /* Get window dimensions. */
4970 window_box (w, -1, 0, &window_y, 0, &window_height);
4971 top = window_y;
4972 width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
4973 height = window_height;
4974
4975 /* Compute the left edge of the scroll bar area. */
4976 left = WINDOW_SCROLL_BAR_AREA_X (w);
4977
4978 /* Compute the width of the scroll bar which might be less than
4979 the width of the area reserved for the scroll bar. */
4980 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w) > 0)
4981 sb_width = WINDOW_CONFIG_SCROLL_BAR_WIDTH (w);
4982 else
4983 sb_width = width;
4984
4985 /* Compute the left edge of the scroll bar. */
4986 #ifdef USE_TOOLKIT_SCROLL_BARS
4987 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
4988 sb_left = (left +
4989 (WINDOW_RIGHTMOST_P (w)
4990 ? width - sb_width - (width - sb_width) / 2
4991 : 0));
4992 else
4993 sb_left = (left +
4994 (WINDOW_LEFTMOST_P (w)
4995 ? (width - sb_width) / 2
4996 : width - sb_width));
4997 #else
4998 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
4999 sb_left = left + width - sb_width;
5000 else
5001 sb_left = left;
5002 #endif
5003
5004 /* Does the scroll bar exist yet? */
5005 if (NILP (w->vertical_scroll_bar))
5006 {
5007 if (width > 0 && height > 0)
5008 {
5009 BLOCK_INPUT;
5010 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5011 left, top, width, height, False);
5012 UNBLOCK_INPUT;
5013 }
5014
5015 bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
5016 }
5017 else
5018 {
5019 /* It may just need to be moved and resized. */
5020 unsigned int mask = 0;
5021
5022 bar = XSCROLL_BAR (w->vertical_scroll_bar);
5023
5024 BLOCK_INPUT;
5025
5026 if (sb_left != XINT (bar->left))
5027 mask |= CWX;
5028 if (top != XINT (bar->top))
5029 mask |= CWY;
5030 if (sb_width != XINT (bar->width))
5031 mask |= CWWidth;
5032 if (height != XINT (bar->height))
5033 mask |= CWHeight;
5034
5035 #ifdef USE_TOOLKIT_SCROLL_BARS
5036
5037 /* Move/size the scroll bar widget. */
5038 if (mask)
5039 {
5040 /* Since toolkit scroll bars are smaller than the space reserved
5041 for them on the frame, we have to clear "under" them. */
5042 if (width > 0 && height > 0)
5043 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5044 left, top, width, height, False);
5045 #ifdef USE_GTK
5046 xg_update_scrollbar_pos (f,
5047 SCROLL_BAR_X_WINDOW (bar),
5048 top,
5049 sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
5050 sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM *2,
5051 max (height, 1));
5052 #else /* not USE_GTK */
5053 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar),
5054 sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
5055 top,
5056 sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
5057 max (height, 1), 0);
5058 #endif /* not USE_GTK */
5059 }
5060 #else /* not USE_TOOLKIT_SCROLL_BARS */
5061
5062 /* Clear areas not covered by the scroll bar because of
5063 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
5064 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM)
5065 {
5066 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5067 left, top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
5068 height, False);
5069 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5070 left + width - VERTICAL_SCROLL_BAR_WIDTH_TRIM,
5071 top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
5072 height, False);
5073 }
5074
5075 /* Clear areas not covered by the scroll bar because it's not as
5076 wide as the area reserved for it. This makes sure a
5077 previous mode line display is cleared after C-x 2 C-x 1, for
5078 example. */
5079 {
5080 int area_width = WINDOW_CONFIG_SCROLL_BAR_COLS (w) * FRAME_COLUMN_WIDTH (f);
5081 int rest = area_width - sb_width;
5082 if (rest > 0 && height > 0)
5083 {
5084 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
5085 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5086 left + area_width - rest, top,
5087 rest, height, False);
5088 else
5089 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5090 left, top, rest, height, False);
5091 }
5092 }
5093
5094 /* Move/size the scroll bar window. */
5095 if (mask)
5096 {
5097 XWindowChanges wc;
5098
5099 wc.x = sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM;
5100 wc.y = top;
5101 wc.width = sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2;
5102 wc.height = height;
5103 XConfigureWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar),
5104 mask, &wc);
5105 }
5106
5107 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5108
5109 /* Remember new settings. */
5110 XSETINT (bar->left, sb_left);
5111 XSETINT (bar->top, top);
5112 XSETINT (bar->width, sb_width);
5113 XSETINT (bar->height, height);
5114
5115 UNBLOCK_INPUT;
5116 }
5117
5118 #ifdef USE_TOOLKIT_SCROLL_BARS
5119 x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole);
5120 #else /* not USE_TOOLKIT_SCROLL_BARS */
5121 /* Set the scroll bar's current state, unless we're currently being
5122 dragged. */
5123 if (NILP (bar->dragging))
5124 {
5125 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height);
5126
5127 if (whole == 0)
5128 x_scroll_bar_set_handle (bar, 0, top_range, 0);
5129 else
5130 {
5131 int start = ((double) position * top_range) / whole;
5132 int end = ((double) (position + portion) * top_range) / whole;
5133 x_scroll_bar_set_handle (bar, start, end, 0);
5134 }
5135 }
5136 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5137
5138 XSETVECTOR (w->vertical_scroll_bar, bar);
5139 }
5140
5141
5142 /* The following three hooks are used when we're doing a thorough
5143 redisplay of the frame. We don't explicitly know which scroll bars
5144 are going to be deleted, because keeping track of when windows go
5145 away is a real pain - "Can you say set-window-configuration, boys
5146 and girls?" Instead, we just assert at the beginning of redisplay
5147 that *all* scroll bars are to be removed, and then save a scroll bar
5148 from the fiery pit when we actually redisplay its window. */
5149
5150 /* Arrange for all scroll bars on FRAME to be removed at the next call
5151 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5152 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5153
5154 static void
5155 XTcondemn_scroll_bars (frame)
5156 FRAME_PTR frame;
5157 {
5158 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5159 while (! NILP (FRAME_SCROLL_BARS (frame)))
5160 {
5161 Lisp_Object bar;
5162 bar = FRAME_SCROLL_BARS (frame);
5163 FRAME_SCROLL_BARS (frame) = XSCROLL_BAR (bar)->next;
5164 XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
5165 XSCROLL_BAR (bar)->prev = Qnil;
5166 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
5167 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
5168 FRAME_CONDEMNED_SCROLL_BARS (frame) = bar;
5169 }
5170 }
5171
5172
5173 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5174 Note that WINDOW isn't necessarily condemned at all. */
5175
5176 static void
5177 XTredeem_scroll_bar (window)
5178 struct window *window;
5179 {
5180 struct scroll_bar *bar;
5181 struct frame *f;
5182
5183 /* We can't redeem this window's scroll bar if it doesn't have one. */
5184 if (NILP (window->vertical_scroll_bar))
5185 abort ();
5186
5187 bar = XSCROLL_BAR (window->vertical_scroll_bar);
5188
5189 /* Unlink it from the condemned list. */
5190 f = XFRAME (WINDOW_FRAME (window));
5191 if (NILP (bar->prev))
5192 {
5193 /* If the prev pointer is nil, it must be the first in one of
5194 the lists. */
5195 if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
5196 /* It's not condemned. Everything's fine. */
5197 return;
5198 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
5199 window->vertical_scroll_bar))
5200 FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next;
5201 else
5202 /* If its prev pointer is nil, it must be at the front of
5203 one or the other! */
5204 abort ();
5205 }
5206 else
5207 XSCROLL_BAR (bar->prev)->next = bar->next;
5208
5209 if (! NILP (bar->next))
5210 XSCROLL_BAR (bar->next)->prev = bar->prev;
5211
5212 bar->next = FRAME_SCROLL_BARS (f);
5213 bar->prev = Qnil;
5214 XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
5215 if (! NILP (bar->next))
5216 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
5217 }
5218
5219 /* Remove all scroll bars on FRAME that haven't been saved since the
5220 last call to `*condemn_scroll_bars_hook'. */
5221
5222 static void
5223 XTjudge_scroll_bars (f)
5224 FRAME_PTR f;
5225 {
5226 Lisp_Object bar, next;
5227
5228 bar = FRAME_CONDEMNED_SCROLL_BARS (f);
5229
5230 /* Clear out the condemned list now so we won't try to process any
5231 more events on the hapless scroll bars. */
5232 FRAME_CONDEMNED_SCROLL_BARS (f) = Qnil;
5233
5234 for (; ! NILP (bar); bar = next)
5235 {
5236 struct scroll_bar *b = XSCROLL_BAR (bar);
5237
5238 x_scroll_bar_remove (b);
5239
5240 next = b->next;
5241 b->next = b->prev = Qnil;
5242 }
5243
5244 /* Now there should be no references to the condemned scroll bars,
5245 and they should get garbage-collected. */
5246 }
5247
5248
5249 #ifndef USE_TOOLKIT_SCROLL_BARS
5250 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5251 is a no-op when using toolkit scroll bars.
5252
5253 This may be called from a signal handler, so we have to ignore GC
5254 mark bits. */
5255
5256 static void
5257 x_scroll_bar_expose (bar, event)
5258 struct scroll_bar *bar;
5259 XEvent *event;
5260 {
5261 Window w = SCROLL_BAR_X_WINDOW (bar);
5262 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
5263 GC gc = f->output_data.x->normal_gc;
5264 int width_trim = VERTICAL_SCROLL_BAR_WIDTH_TRIM;
5265
5266 BLOCK_INPUT;
5267
5268 x_scroll_bar_set_handle (bar, XINT (bar->start), XINT (bar->end), 1);
5269
5270 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5271 XDrawRectangle (FRAME_X_DISPLAY (f), w, gc,
5272
5273 /* x, y, width, height */
5274 0, 0,
5275 XINT (bar->width) - 1 - width_trim - width_trim,
5276 XINT (bar->height) - 1);
5277
5278 UNBLOCK_INPUT;
5279
5280 }
5281 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5282
5283 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5284 is set to something other than NO_EVENT, it is enqueued.
5285
5286 This may be called from a signal handler, so we have to ignore GC
5287 mark bits. */
5288
5289
5290 static void
5291 x_scroll_bar_handle_click (bar, event, emacs_event)
5292 struct scroll_bar *bar;
5293 XEvent *event;
5294 struct input_event *emacs_event;
5295 {
5296 if (! GC_WINDOWP (bar->window))
5297 abort ();
5298
5299 emacs_event->kind = SCROLL_BAR_CLICK_EVENT;
5300 emacs_event->code = event->xbutton.button - Button1;
5301 emacs_event->modifiers
5302 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
5303 (XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))),
5304 event->xbutton.state)
5305 | (event->type == ButtonRelease
5306 ? up_modifier
5307 : down_modifier));
5308 emacs_event->frame_or_window = bar->window;
5309 emacs_event->arg = Qnil;
5310 emacs_event->timestamp = event->xbutton.time;
5311 {
5312 #if 0
5313 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
5314 int internal_height
5315 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
5316 #endif
5317 int top_range
5318 = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
5319 int y = event->xbutton.y - VERTICAL_SCROLL_BAR_TOP_BORDER;
5320
5321 if (y < 0) y = 0;
5322 if (y > top_range) y = top_range;
5323
5324 if (y < XINT (bar->start))
5325 emacs_event->part = scroll_bar_above_handle;
5326 else if (y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
5327 emacs_event->part = scroll_bar_handle;
5328 else
5329 emacs_event->part = scroll_bar_below_handle;
5330
5331 /* Just because the user has clicked on the handle doesn't mean
5332 they want to drag it. Lisp code needs to be able to decide
5333 whether or not we're dragging. */
5334 #if 0
5335 /* If the user has just clicked on the handle, record where they're
5336 holding it. */
5337 if (event->type == ButtonPress
5338 && emacs_event->part == scroll_bar_handle)
5339 XSETINT (bar->dragging, y - XINT (bar->start));
5340 #endif
5341
5342 #ifndef USE_TOOLKIT_SCROLL_BARS
5343 /* If the user has released the handle, set it to its final position. */
5344 if (event->type == ButtonRelease
5345 && ! NILP (bar->dragging))
5346 {
5347 int new_start = y - XINT (bar->dragging);
5348 int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
5349
5350 x_scroll_bar_set_handle (bar, new_start, new_end, 0);
5351 bar->dragging = Qnil;
5352 }
5353 #endif
5354
5355 /* Same deal here as the other #if 0. */
5356 #if 0
5357 /* Clicks on the handle are always reported as occurring at the top of
5358 the handle. */
5359 if (emacs_event->part == scroll_bar_handle)
5360 emacs_event->x = bar->start;
5361 else
5362 XSETINT (emacs_event->x, y);
5363 #else
5364 XSETINT (emacs_event->x, y);
5365 #endif
5366
5367 XSETINT (emacs_event->y, top_range);
5368 }
5369 }
5370
5371 #ifndef USE_TOOLKIT_SCROLL_BARS
5372
5373 /* Handle some mouse motion while someone is dragging the scroll bar.
5374
5375 This may be called from a signal handler, so we have to ignore GC
5376 mark bits. */
5377
5378 static void
5379 x_scroll_bar_note_movement (bar, event)
5380 struct scroll_bar *bar;
5381 XEvent *event;
5382 {
5383 FRAME_PTR f = XFRAME (XWINDOW (bar->window)->frame);
5384
5385 last_mouse_movement_time = event->xmotion.time;
5386
5387 f->mouse_moved = 1;
5388 XSETVECTOR (last_mouse_scroll_bar, bar);
5389
5390 /* If we're dragging the bar, display it. */
5391 if (! GC_NILP (bar->dragging))
5392 {
5393 /* Where should the handle be now? */
5394 int new_start = event->xmotion.y - XINT (bar->dragging);
5395
5396 if (new_start != XINT (bar->start))
5397 {
5398 int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
5399
5400 x_scroll_bar_set_handle (bar, new_start, new_end, 0);
5401 }
5402 }
5403 }
5404
5405 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5406
5407 /* Return information to the user about the current position of the mouse
5408 on the scroll bar. */
5409
5410 static void
5411 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
5412 FRAME_PTR *fp;
5413 Lisp_Object *bar_window;
5414 enum scroll_bar_part *part;
5415 Lisp_Object *x, *y;
5416 unsigned long *time;
5417 {
5418 struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
5419 Window w = SCROLL_BAR_X_WINDOW (bar);
5420 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
5421 int win_x, win_y;
5422 Window dummy_window;
5423 int dummy_coord;
5424 unsigned int dummy_mask;
5425
5426 BLOCK_INPUT;
5427
5428 /* Get the mouse's position relative to the scroll bar window, and
5429 report that. */
5430 if (! XQueryPointer (FRAME_X_DISPLAY (f), w,
5431
5432 /* Root, child, root x and root y. */
5433 &dummy_window, &dummy_window,
5434 &dummy_coord, &dummy_coord,
5435
5436 /* Position relative to scroll bar. */
5437 &win_x, &win_y,
5438
5439 /* Mouse buttons and modifier keys. */
5440 &dummy_mask))
5441 ;
5442 else
5443 {
5444 #if 0
5445 int inside_height
5446 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
5447 #endif
5448 int top_range
5449 = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
5450
5451 win_y -= VERTICAL_SCROLL_BAR_TOP_BORDER;
5452
5453 if (! NILP (bar->dragging))
5454 win_y -= XINT (bar->dragging);
5455
5456 if (win_y < 0)
5457 win_y = 0;
5458 if (win_y > top_range)
5459 win_y = top_range;
5460
5461 *fp = f;
5462 *bar_window = bar->window;
5463
5464 if (! NILP (bar->dragging))
5465 *part = scroll_bar_handle;
5466 else if (win_y < XINT (bar->start))
5467 *part = scroll_bar_above_handle;
5468 else if (win_y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
5469 *part = scroll_bar_handle;
5470 else
5471 *part = scroll_bar_below_handle;
5472
5473 XSETINT (*x, win_y);
5474 XSETINT (*y, top_range);
5475
5476 f->mouse_moved = 0;
5477 last_mouse_scroll_bar = Qnil;
5478 }
5479
5480 *time = last_mouse_movement_time;
5481
5482 UNBLOCK_INPUT;
5483 }
5484
5485
5486 /* The screen has been cleared so we may have changed foreground or
5487 background colors, and the scroll bars may need to be redrawn.
5488 Clear out the scroll bars, and ask for expose events, so we can
5489 redraw them. */
5490
5491 void
5492 x_scroll_bar_clear (f)
5493 FRAME_PTR f;
5494 {
5495 #ifndef USE_TOOLKIT_SCROLL_BARS
5496 Lisp_Object bar;
5497
5498 /* We can have scroll bars even if this is 0,
5499 if we just turned off scroll bar mode.
5500 But in that case we should not clear them. */
5501 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
5502 for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
5503 bar = XSCROLL_BAR (bar)->next)
5504 XClearArea (FRAME_X_DISPLAY (f),
5505 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)),
5506 0, 0, 0, 0, True);
5507 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5508 }
5509
5510 \f
5511 /* The main X event-reading loop - XTread_socket. */
5512
5513 #if 0
5514 /* Time stamp of enter window event. This is only used by XTread_socket,
5515 but we have to put it out here, since static variables within functions
5516 sometimes don't work. */
5517
5518 static Time enter_timestamp;
5519 #endif
5520
5521 /* This holds the state XLookupString needs to implement dead keys
5522 and other tricks known as "compose processing". _X Window System_
5523 says that a portable program can't use this, but Stephen Gildea assures
5524 me that letting the compiler initialize it to zeros will work okay.
5525
5526 This must be defined outside of XTread_socket, for the same reasons
5527 given for enter_timestamp, above. */
5528
5529 static XComposeStatus compose_status;
5530
5531 /* Record the last 100 characters stored
5532 to help debug the loss-of-chars-during-GC problem. */
5533
5534 static int temp_index;
5535 static short temp_buffer[100];
5536
5537 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5538 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5539 temp_index = 0; \
5540 temp_buffer[temp_index++] = (keysym)
5541
5542 /* Set this to nonzero to fake an "X I/O error"
5543 on a particular display. */
5544
5545 struct x_display_info *XTread_socket_fake_io_error;
5546
5547 /* When we find no input here, we occasionally do a no-op command
5548 to verify that the X server is still running and we can still talk with it.
5549 We try all the open displays, one by one.
5550 This variable is used for cycling thru the displays. */
5551
5552 static struct x_display_info *next_noop_dpyinfo;
5553
5554 #define SET_SAVED_MENU_EVENT(size) \
5555 do \
5556 { \
5557 if (f->output_data.x->saved_menu_event == 0) \
5558 f->output_data.x->saved_menu_event \
5559 = (XEvent *) xmalloc (sizeof (XEvent)); \
5560 bcopy (&event, f->output_data.x->saved_menu_event, size); \
5561 inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
5562 XSETFRAME (inev.ie.frame_or_window, f); \
5563 } \
5564 while (0)
5565
5566 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
5567 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
5568
5569
5570 enum
5571 {
5572 X_EVENT_NORMAL,
5573 X_EVENT_GOTO_OUT,
5574 X_EVENT_DROP
5575 };
5576
5577 /* Filter events for the current X input method.
5578 DPYINFO is the display this event is for.
5579 EVENT is the X event to filter.
5580
5581 Returns non-zero if the event was filtered, caller shall not process
5582 this event further.
5583 Returns zero if event is wasn't filtered. */
5584
5585 #ifdef HAVE_X_I18N
5586 static int
5587 x_filter_event (dpyinfo, event)
5588 struct x_display_info *dpyinfo;
5589 XEvent *event;
5590 {
5591 /* XFilterEvent returns non-zero if the input method has
5592 consumed the event. We pass the frame's X window to
5593 XFilterEvent because that's the one for which the IC
5594 was created. */
5595
5596 struct frame *f1 = x_any_window_to_frame (dpyinfo,
5597 event->xclient.window);
5598
5599 return XFilterEvent (event, f1 ? FRAME_X_WINDOW (f1) : None);
5600 }
5601 #endif
5602
5603 #ifdef USE_GTK
5604 static int current_count;
5605 static int current_finish;
5606 static struct input_event *current_hold_quit;
5607
5608 /* This is the filter function invoked by the GTK event loop.
5609 It is invoked before the XEvent is translated to a GdkEvent,
5610 so we have a chance to act on the event before GTK. */
5611 static GdkFilterReturn
5612 event_handler_gdk (gxev, ev, data)
5613 GdkXEvent *gxev;
5614 GdkEvent *ev;
5615 gpointer data;
5616 {
5617 XEvent *xev = (XEvent *) gxev;
5618
5619 if (current_count >= 0)
5620 {
5621 struct x_display_info *dpyinfo;
5622
5623 dpyinfo = x_display_info_for_display (xev->xany.display);
5624
5625 #ifdef HAVE_X_I18N
5626 /* Filter events for the current X input method.
5627 GTK calls XFilterEvent but not for key press and release,
5628 so we do it here. */
5629 if (xev->type == KeyPress || xev->type == KeyRelease)
5630 if (dpyinfo && x_filter_event (dpyinfo, xev))
5631 return GDK_FILTER_REMOVE;
5632 #endif
5633
5634 if (! dpyinfo)
5635 current_finish = X_EVENT_NORMAL;
5636 else
5637 {
5638 current_count +=
5639 handle_one_xevent (dpyinfo, xev, &current_finish,
5640 current_hold_quit);
5641 }
5642 }
5643 else
5644 current_finish = x_dispatch_event (xev, xev->xany.display);
5645
5646 if (current_finish == X_EVENT_GOTO_OUT || current_finish == X_EVENT_DROP)
5647 return GDK_FILTER_REMOVE;
5648
5649 return GDK_FILTER_CONTINUE;
5650 }
5651 #endif /* USE_GTK */
5652
5653
5654 /* Handles the XEvent EVENT on display DPYINFO.
5655
5656 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5657 *FINISH is zero if caller should continue reading events.
5658 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5659
5660 We return the number of characters stored into the buffer. */
5661
5662 static int
5663 handle_one_xevent (dpyinfo, eventp, finish, hold_quit)
5664 struct x_display_info *dpyinfo;
5665 XEvent *eventp;
5666 int *finish;
5667 struct input_event *hold_quit;
5668 {
5669 union {
5670 struct input_event ie;
5671 struct selection_input_event sie;
5672 } inev;
5673 int count = 0;
5674 int do_help = 0;
5675 int nbytes = 0;
5676 struct frame *f;
5677 struct coding_system coding;
5678 XEvent event = *eventp;
5679
5680 *finish = X_EVENT_NORMAL;
5681
5682 EVENT_INIT (inev.ie);
5683 inev.ie.kind = NO_EVENT;
5684 inev.ie.arg = Qnil;
5685
5686 switch (event.type)
5687 {
5688 case ClientMessage:
5689 {
5690 if (event.xclient.message_type
5691 == dpyinfo->Xatom_wm_protocols
5692 && event.xclient.format == 32)
5693 {
5694 if (event.xclient.data.l[0]
5695 == dpyinfo->Xatom_wm_take_focus)
5696 {
5697 /* Use x_any_window_to_frame because this
5698 could be the shell widget window
5699 if the frame has no title bar. */
5700 f = x_any_window_to_frame (dpyinfo, event.xclient.window);
5701 #ifdef HAVE_X_I18N
5702 /* Not quite sure this is needed -pd */
5703 if (f && FRAME_XIC (f))
5704 XSetICFocus (FRAME_XIC (f));
5705 #endif
5706 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5707 instructs the WM to set the input focus automatically for
5708 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5709 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5710 it has set the focus. So, XSetInputFocus below is not
5711 needed.
5712
5713 The call to XSetInputFocus below has also caused trouble. In
5714 cases where the XSetInputFocus done by the WM and the one
5715 below are temporally close (on a fast machine), the call
5716 below can generate additional FocusIn events which confuse
5717 Emacs. */
5718
5719 /* Since we set WM_TAKE_FOCUS, we must call
5720 XSetInputFocus explicitly. But not if f is null,
5721 since that might be an event for a deleted frame. */
5722 if (f)
5723 {
5724 Display *d = event.xclient.display;
5725 /* Catch and ignore errors, in case window has been
5726 iconified by a window manager such as GWM. */
5727 int count = x_catch_errors (d);
5728 XSetInputFocus (d, event.xclient.window,
5729 /* The ICCCM says this is
5730 the only valid choice. */
5731 RevertToParent,
5732 event.xclient.data.l[1]);
5733 /* This is needed to detect the error
5734 if there is an error. */
5735 XSync (d, False);
5736 x_uncatch_errors (d, count);
5737 }
5738 /* Not certain about handling scroll bars here */
5739 #endif /* 0 */
5740 goto done;
5741 }
5742
5743 if (event.xclient.data.l[0]
5744 == dpyinfo->Xatom_wm_save_yourself)
5745 {
5746 /* Save state modify the WM_COMMAND property to
5747 something which can reinstate us. This notifies
5748 the session manager, who's looking for such a
5749 PropertyNotify. Can restart processing when
5750 a keyboard or mouse event arrives. */
5751 /* If we have a session manager, don't set this.
5752 KDE will then start two Emacsen, one for the
5753 session manager and one for this. */
5754 #ifdef HAVE_X_SM
5755 if (! x_session_have_connection ())
5756 #endif
5757 {
5758 f = x_top_window_to_frame (dpyinfo,
5759 event.xclient.window);
5760 /* This is just so we only give real data once
5761 for a single Emacs process. */
5762 if (f == SELECTED_FRAME ())
5763 XSetCommand (FRAME_X_DISPLAY (f),
5764 event.xclient.window,
5765 initial_argv, initial_argc);
5766 else if (f)
5767 XSetCommand (FRAME_X_DISPLAY (f),
5768 event.xclient.window,
5769 0, 0);
5770 }
5771 goto done;
5772 }
5773
5774 if (event.xclient.data.l[0]
5775 == dpyinfo->Xatom_wm_delete_window)
5776 {
5777 f = x_any_window_to_frame (dpyinfo,
5778 event.xclient.window);
5779 if (!f)
5780 goto OTHER; /* May be a dialog that is to be removed */
5781
5782 inev.ie.kind = DELETE_WINDOW_EVENT;
5783 XSETFRAME (inev.ie.frame_or_window, f);
5784 goto done;
5785 }
5786
5787 goto done;
5788 }
5789
5790 if (event.xclient.message_type
5791 == dpyinfo->Xatom_wm_configure_denied)
5792 {
5793 goto done;
5794 }
5795
5796 if (event.xclient.message_type
5797 == dpyinfo->Xatom_wm_window_moved)
5798 {
5799 int new_x, new_y;
5800 f = x_window_to_frame (dpyinfo, event.xclient.window);
5801
5802 new_x = event.xclient.data.s[0];
5803 new_y = event.xclient.data.s[1];
5804
5805 if (f)
5806 {
5807 f->left_pos = new_x;
5808 f->top_pos = new_y;
5809 }
5810 goto done;
5811 }
5812
5813 #ifdef HACK_EDITRES
5814 if (event.xclient.message_type
5815 == dpyinfo->Xatom_editres)
5816 {
5817 f = x_any_window_to_frame (dpyinfo, event.xclient.window);
5818 _XEditResCheckMessages (f->output_data.x->widget, NULL,
5819 &event, NULL);
5820 goto done;
5821 }
5822 #endif /* HACK_EDITRES */
5823
5824 if ((event.xclient.message_type
5825 == dpyinfo->Xatom_DONE)
5826 || (event.xclient.message_type
5827 == dpyinfo->Xatom_PAGE))
5828 {
5829 /* Ghostview job completed. Kill it. We could
5830 reply with "Next" if we received "Page", but we
5831 currently never do because we are interested in
5832 images, only, which should have 1 page. */
5833 Pixmap pixmap = (Pixmap) event.xclient.data.l[1];
5834 f = x_window_to_frame (dpyinfo, event.xclient.window);
5835 x_kill_gs_process (pixmap, f);
5836 expose_frame (f, 0, 0, 0, 0);
5837 goto done;
5838 }
5839
5840 #ifdef USE_TOOLKIT_SCROLL_BARS
5841 /* Scroll bar callbacks send a ClientMessage from which
5842 we construct an input_event. */
5843 if (event.xclient.message_type
5844 == dpyinfo->Xatom_Scrollbar)
5845 {
5846 x_scroll_bar_to_input_event (&event, &inev.ie);
5847 *finish = X_EVENT_GOTO_OUT;
5848 goto done;
5849 }
5850 #endif /* USE_TOOLKIT_SCROLL_BARS */
5851
5852 f = x_any_window_to_frame (dpyinfo, event.xclient.window);
5853
5854 if (!f)
5855 goto OTHER;
5856
5857 if (x_handle_dnd_message (f, &event.xclient, dpyinfo, &inev.ie))
5858 *finish = X_EVENT_DROP;
5859 }
5860 break;
5861
5862 case SelectionNotify:
5863 #ifdef USE_X_TOOLKIT
5864 if (! x_window_to_frame (dpyinfo, event.xselection.requestor))
5865 goto OTHER;
5866 #endif /* not USE_X_TOOLKIT */
5867 x_handle_selection_notify (&event.xselection);
5868 break;
5869
5870 case SelectionClear: /* Someone has grabbed ownership. */
5871 #ifdef USE_X_TOOLKIT
5872 if (! x_window_to_frame (dpyinfo, event.xselectionclear.window))
5873 goto OTHER;
5874 #endif /* USE_X_TOOLKIT */
5875 {
5876 XSelectionClearEvent *eventp = (XSelectionClearEvent *) &event;
5877
5878 inev.ie.kind = SELECTION_CLEAR_EVENT;
5879 SELECTION_EVENT_DISPLAY (&inev.sie) = eventp->display;
5880 SELECTION_EVENT_SELECTION (&inev.sie) = eventp->selection;
5881 SELECTION_EVENT_TIME (&inev.sie) = eventp->time;
5882 inev.ie.frame_or_window = Qnil;
5883 }
5884 break;
5885
5886 case SelectionRequest: /* Someone wants our selection. */
5887 #ifdef USE_X_TOOLKIT
5888 if (!x_window_to_frame (dpyinfo, event.xselectionrequest.owner))
5889 goto OTHER;
5890 #endif /* USE_X_TOOLKIT */
5891 {
5892 XSelectionRequestEvent *eventp
5893 = (XSelectionRequestEvent *) &event;
5894
5895 inev.ie.kind = SELECTION_REQUEST_EVENT;
5896 SELECTION_EVENT_DISPLAY (&inev.sie) = eventp->display;
5897 SELECTION_EVENT_REQUESTOR (&inev.sie) = eventp->requestor;
5898 SELECTION_EVENT_SELECTION (&inev.sie) = eventp->selection;
5899 SELECTION_EVENT_TARGET (&inev.sie) = eventp->target;
5900 SELECTION_EVENT_PROPERTY (&inev.sie) = eventp->property;
5901 SELECTION_EVENT_TIME (&inev.sie) = eventp->time;
5902 inev.ie.frame_or_window = Qnil;
5903 }
5904 break;
5905
5906 case PropertyNotify:
5907 #if 0 /* This is plain wrong. In the case that we are waiting for a
5908 PropertyNotify used as an ACK in incremental selection
5909 transfer, the property will be on the receiver's window. */
5910 #if defined USE_X_TOOLKIT
5911 if (!x_any_window_to_frame (dpyinfo, event.xproperty.window))
5912 goto OTHER;
5913 #endif
5914 #endif
5915 x_handle_property_notify (&event.xproperty);
5916 goto OTHER;
5917
5918 case ReparentNotify:
5919 f = x_top_window_to_frame (dpyinfo, event.xreparent.window);
5920 if (f)
5921 {
5922 int x, y;
5923 f->output_data.x->parent_desc = event.xreparent.parent;
5924 x_real_positions (f, &x, &y);
5925 f->left_pos = x;
5926 f->top_pos = y;
5927
5928 /* Perhaps reparented due to a WM restart. Reset this. */
5929 FRAME_X_DISPLAY_INFO (f)->wm_type = X_WMTYPE_UNKNOWN;
5930 }
5931 goto OTHER;
5932
5933 case Expose:
5934 f = x_window_to_frame (dpyinfo, event.xexpose.window);
5935 if (f)
5936 {
5937 x_check_fullscreen (f);
5938
5939 #ifdef USE_GTK
5940 /* This seems to be needed for GTK 2.6. */
5941 x_clear_area (event.xexpose.display,
5942 event.xexpose.window,
5943 event.xexpose.x, event.xexpose.y,
5944 event.xexpose.width, event.xexpose.height,
5945 FALSE);
5946 #endif
5947 if (f->async_visible == 0)
5948 {
5949 f->async_visible = 1;
5950 f->async_iconified = 0;
5951 f->output_data.x->has_been_visible = 1;
5952 SET_FRAME_GARBAGED (f);
5953 }
5954 else
5955 expose_frame (f,
5956 event.xexpose.x, event.xexpose.y,
5957 event.xexpose.width, event.xexpose.height);
5958 }
5959 else
5960 {
5961 #ifndef USE_TOOLKIT_SCROLL_BARS
5962 struct scroll_bar *bar;
5963 #endif
5964 #if defined USE_LUCID
5965 /* Submenus of the Lucid menu bar aren't widgets
5966 themselves, so there's no way to dispatch events
5967 to them. Recognize this case separately. */
5968 {
5969 Widget widget
5970 = x_window_to_menu_bar (event.xexpose.window);
5971 if (widget)
5972 xlwmenu_redisplay (widget);
5973 }
5974 #endif /* USE_LUCID */
5975
5976 #ifdef USE_TOOLKIT_SCROLL_BARS
5977 /* Dispatch event to the widget. */
5978 goto OTHER;
5979 #else /* not USE_TOOLKIT_SCROLL_BARS */
5980 bar = x_window_to_scroll_bar (event.xexpose.display,
5981 event.xexpose.window);
5982
5983 if (bar)
5984 x_scroll_bar_expose (bar, &event);
5985 #ifdef USE_X_TOOLKIT
5986 else
5987 goto OTHER;
5988 #endif /* USE_X_TOOLKIT */
5989 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5990 }
5991 break;
5992
5993 case GraphicsExpose: /* This occurs when an XCopyArea's
5994 source area was obscured or not
5995 available. */
5996 f = x_window_to_frame (dpyinfo, event.xgraphicsexpose.drawable);
5997 if (f)
5998 {
5999 expose_frame (f,
6000 event.xgraphicsexpose.x, event.xgraphicsexpose.y,
6001 event.xgraphicsexpose.width,
6002 event.xgraphicsexpose.height);
6003 }
6004 #ifdef USE_X_TOOLKIT
6005 else
6006 goto OTHER;
6007 #endif /* USE_X_TOOLKIT */
6008 break;
6009
6010 case NoExpose: /* This occurs when an XCopyArea's
6011 source area was completely
6012 available. */
6013 break;
6014
6015 case UnmapNotify:
6016 /* Redo the mouse-highlight after the tooltip has gone. */
6017 if (event.xmap.window == tip_window)
6018 {
6019 tip_window = 0;
6020 redo_mouse_highlight ();
6021 }
6022
6023 f = x_top_window_to_frame (dpyinfo, event.xunmap.window);
6024 if (f) /* F may no longer exist if
6025 the frame was deleted. */
6026 {
6027 /* While a frame is unmapped, display generation is
6028 disabled; you don't want to spend time updating a
6029 display that won't ever be seen. */
6030 f->async_visible = 0;
6031 /* We can't distinguish, from the event, whether the window
6032 has become iconified or invisible. So assume, if it
6033 was previously visible, than now it is iconified.
6034 But x_make_frame_invisible clears both
6035 the visible flag and the iconified flag;
6036 and that way, we know the window is not iconified now. */
6037 if (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f))
6038 {
6039 f->async_iconified = 1;
6040
6041 inev.ie.kind = ICONIFY_EVENT;
6042 XSETFRAME (inev.ie.frame_or_window, f);
6043 }
6044 }
6045 goto OTHER;
6046
6047 case MapNotify:
6048 if (event.xmap.window == tip_window)
6049 /* The tooltip has been drawn already. Avoid
6050 the SET_FRAME_GARBAGED below. */
6051 goto OTHER;
6052
6053 /* We use x_top_window_to_frame because map events can
6054 come for sub-windows and they don't mean that the
6055 frame is visible. */
6056 f = x_top_window_to_frame (dpyinfo, event.xmap.window);
6057 if (f)
6058 {
6059 /* wait_reading_process_output will notice this and update
6060 the frame's display structures.
6061 If we where iconified, we should not set garbaged,
6062 because that stops redrawing on Expose events. This looks
6063 bad if we are called from a recursive event loop
6064 (x_dispatch_event), for example when a dialog is up. */
6065 if (! f->async_iconified)
6066 SET_FRAME_GARBAGED (f);
6067
6068 f->async_visible = 1;
6069 f->async_iconified = 0;
6070 f->output_data.x->has_been_visible = 1;
6071
6072 if (f->iconified)
6073 {
6074 inev.ie.kind = DEICONIFY_EVENT;
6075 XSETFRAME (inev.ie.frame_or_window, f);
6076 }
6077 else if (! NILP (Vframe_list)
6078 && ! NILP (XCDR (Vframe_list)))
6079 /* Force a redisplay sooner or later
6080 to update the frame titles
6081 in case this is the second frame. */
6082 record_asynch_buffer_change ();
6083 }
6084 goto OTHER;
6085
6086 case KeyPress:
6087
6088 ignore_next_mouse_click_timeout = 0;
6089
6090 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6091 /* Dispatch KeyPress events when in menu. */
6092 if (popup_activated ())
6093 goto OTHER;
6094 #endif
6095
6096 f = x_any_window_to_frame (dpyinfo, event.xkey.window);
6097
6098 if (!dpyinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight))
6099 {
6100 clear_mouse_face (dpyinfo);
6101 dpyinfo->mouse_face_hidden = 1;
6102 }
6103
6104 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6105 if (f == 0)
6106 {
6107 /* Scroll bars consume key events, but we want
6108 the keys to go to the scroll bar's frame. */
6109 Widget widget = XtWindowToWidget (dpyinfo->display,
6110 event.xkey.window);
6111 if (widget && XmIsScrollBar (widget))
6112 {
6113 widget = XtParent (widget);
6114 f = x_any_window_to_frame (dpyinfo, XtWindow (widget));
6115 }
6116 }
6117 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6118
6119 if (f != 0)
6120 {
6121 KeySym keysym, orig_keysym;
6122 /* al%imercury@uunet.uu.net says that making this 81
6123 instead of 80 fixed a bug whereby meta chars made
6124 his Emacs hang.
6125
6126 It seems that some version of XmbLookupString has
6127 a bug of not returning XBufferOverflow in
6128 status_return even if the input is too long to
6129 fit in 81 bytes. So, we must prepare sufficient
6130 bytes for copy_buffer. 513 bytes (256 chars for
6131 two-byte character set) seems to be a fairly good
6132 approximation. -- 2000.8.10 handa@etl.go.jp */
6133 unsigned char copy_buffer[513];
6134 unsigned char *copy_bufptr = copy_buffer;
6135 int copy_bufsiz = sizeof (copy_buffer);
6136 int modifiers;
6137 Lisp_Object coding_system = Qlatin_1;
6138 Lisp_Object c;
6139
6140 #ifdef USE_GTK
6141 /* Don't pass keys to GTK. A Tab will shift focus to the
6142 tool bar in GTK 2.4. Keys will still go to menus and
6143 dialogs because in that case popup_activated is TRUE
6144 (see above). */
6145 *finish = X_EVENT_DROP;
6146 #endif
6147
6148 event.xkey.state
6149 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f),
6150 extra_keyboard_modifiers);
6151 modifiers = event.xkey.state;
6152
6153 /* This will have to go some day... */
6154
6155 /* make_lispy_event turns chars into control chars.
6156 Don't do it here because XLookupString is too eager. */
6157 event.xkey.state &= ~ControlMask;
6158 event.xkey.state &= ~(dpyinfo->meta_mod_mask
6159 | dpyinfo->super_mod_mask
6160 | dpyinfo->hyper_mod_mask
6161 | dpyinfo->alt_mod_mask);
6162
6163 /* In case Meta is ComposeCharacter,
6164 clear its status. According to Markus Ehrnsperger
6165 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6166 this enables ComposeCharacter to work whether or
6167 not it is combined with Meta. */
6168 if (modifiers & dpyinfo->meta_mod_mask)
6169 bzero (&compose_status, sizeof (compose_status));
6170
6171 #ifdef HAVE_X_I18N
6172 if (FRAME_XIC (f))
6173 {
6174 Status status_return;
6175
6176 coding_system = Vlocale_coding_system;
6177 nbytes = XmbLookupString (FRAME_XIC (f),
6178 &event.xkey, copy_bufptr,
6179 copy_bufsiz, &keysym,
6180 &status_return);
6181 if (status_return == XBufferOverflow)
6182 {
6183 copy_bufsiz = nbytes + 1;
6184 copy_bufptr = (unsigned char *) alloca (copy_bufsiz);
6185 nbytes = XmbLookupString (FRAME_XIC (f),
6186 &event.xkey, copy_bufptr,
6187 copy_bufsiz, &keysym,
6188 &status_return);
6189 }
6190 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6191 #if 0 && defined X_HAVE_UTF8_STRING
6192 else if (status_return == XLookupKeySym)
6193 { /* Try again but with utf-8. */
6194 coding_system = Qutf_8;
6195 nbytes = Xutf8LookupString (FRAME_XIC (f),
6196 &event.xkey, copy_bufptr,
6197 copy_bufsiz, &keysym,
6198 &status_return);
6199 if (status_return == XBufferOverflow)
6200 {
6201 copy_bufsiz = nbytes + 1;
6202 copy_bufptr = (unsigned char *) alloca (copy_bufsiz);
6203 nbytes = Xutf8LookupString (FRAME_XIC (f),
6204 &event.xkey,
6205 copy_bufptr,
6206 copy_bufsiz, &keysym,
6207 &status_return);
6208 }
6209 }
6210 #endif
6211
6212 if (status_return == XLookupNone)
6213 break;
6214 else if (status_return == XLookupChars)
6215 {
6216 keysym = NoSymbol;
6217 modifiers = 0;
6218 }
6219 else if (status_return != XLookupKeySym
6220 && status_return != XLookupBoth)
6221 abort ();
6222 }
6223 else
6224 nbytes = XLookupString (&event.xkey, copy_bufptr,
6225 copy_bufsiz, &keysym,
6226 &compose_status);
6227 #else
6228 nbytes = XLookupString (&event.xkey, copy_bufptr,
6229 copy_bufsiz, &keysym,
6230 &compose_status);
6231 #endif
6232
6233 /* If not using XIM/XIC, and a compose sequence is in progress,
6234 we break here. Otherwise, chars_matched is always 0. */
6235 if (compose_status.chars_matched > 0 && nbytes == 0)
6236 break;
6237
6238 bzero (&compose_status, sizeof (compose_status));
6239 orig_keysym = keysym;
6240
6241 /* Common for all keysym input events. */
6242 XSETFRAME (inev.ie.frame_or_window, f);
6243 inev.ie.modifiers
6244 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f), modifiers);
6245 inev.ie.timestamp = event.xkey.time;
6246
6247 /* First deal with keysyms which have defined
6248 translations to characters. */
6249 if (keysym >= 32 && keysym < 128)
6250 /* Avoid explicitly decoding each ASCII character. */
6251 {
6252 inev.ie.kind = ASCII_KEYSTROKE_EVENT;
6253 inev.ie.code = keysym;
6254 goto done_keysym;
6255 }
6256
6257 /* Keysyms directly mapped to supported Unicode characters. */
6258 if ((keysym >= 0x01000100 && keysym <= 0x010033ff)
6259 || (keysym >= 0x0100e000 && keysym <= 0x0100ffff))
6260 {
6261 int code, charset_id, c1, c2;
6262
6263 if (keysym < 0x01002500)
6264 charset_id = charset_mule_unicode_0100_24ff,
6265 code = (keysym & 0xFFFF) - 0x100;
6266 else if (keysym < 0x0100e000)
6267 charset_id = charset_mule_unicode_2500_33ff,
6268 code = (keysym & 0xFFFF) - 0x2500;
6269 else
6270 charset_id = charset_mule_unicode_e000_ffff,
6271 code = (keysym & 0xFFFF) - 0xe000;
6272 c1 = (code / 96) + 32, c2 = (code % 96) + 32;
6273 inev.ie.kind = MULTIBYTE_CHAR_KEYSTROKE_EVENT;
6274 inev.ie.code = MAKE_CHAR (charset_id, c1, c2);
6275 goto done_keysym;
6276 }
6277
6278 /* Now non-ASCII. */
6279 if (HASH_TABLE_P (Vx_keysym_table)
6280 && (NATNUMP (c = Fgethash (make_number (keysym),
6281 Vx_keysym_table,
6282 Qnil))))
6283 {
6284 inev.ie.kind = (SINGLE_BYTE_CHAR_P (XFASTINT (c))
6285 ? ASCII_KEYSTROKE_EVENT
6286 : MULTIBYTE_CHAR_KEYSTROKE_EVENT);
6287 inev.ie.code = XFASTINT (c);
6288 goto done_keysym;
6289 }
6290
6291 /* Random non-modifier sorts of keysyms. */
6292 if (((keysym >= XK_BackSpace && keysym <= XK_Escape)
6293 || keysym == XK_Delete
6294 #ifdef XK_ISO_Left_Tab
6295 || (keysym >= XK_ISO_Left_Tab
6296 && keysym <= XK_ISO_Enter)
6297 #endif
6298 || IsCursorKey (keysym) /* 0xff50 <= x < 0xff60 */
6299 || IsMiscFunctionKey (keysym) /* 0xff60 <= x < VARIES */
6300 #ifdef HPUX
6301 /* This recognizes the "extended function
6302 keys". It seems there's no cleaner way.
6303 Test IsModifierKey to avoid handling
6304 mode_switch incorrectly. */
6305 || ((unsigned) (keysym) >= XK_Select
6306 && (unsigned)(keysym) < XK_KP_Space)
6307 #endif
6308 #ifdef XK_dead_circumflex
6309 || orig_keysym == XK_dead_circumflex
6310 #endif
6311 #ifdef XK_dead_grave
6312 || orig_keysym == XK_dead_grave
6313 #endif
6314 #ifdef XK_dead_tilde
6315 || orig_keysym == XK_dead_tilde
6316 #endif
6317 #ifdef XK_dead_diaeresis
6318 || orig_keysym == XK_dead_diaeresis
6319 #endif
6320 #ifdef XK_dead_macron
6321 || orig_keysym == XK_dead_macron
6322 #endif
6323 #ifdef XK_dead_degree
6324 || orig_keysym == XK_dead_degree
6325 #endif
6326 #ifdef XK_dead_acute
6327 || orig_keysym == XK_dead_acute
6328 #endif
6329 #ifdef XK_dead_cedilla
6330 || orig_keysym == XK_dead_cedilla
6331 #endif
6332 #ifdef XK_dead_breve
6333 || orig_keysym == XK_dead_breve
6334 #endif
6335 #ifdef XK_dead_ogonek
6336 || orig_keysym == XK_dead_ogonek
6337 #endif
6338 #ifdef XK_dead_caron
6339 || orig_keysym == XK_dead_caron
6340 #endif
6341 #ifdef XK_dead_doubleacute
6342 || orig_keysym == XK_dead_doubleacute
6343 #endif
6344 #ifdef XK_dead_abovedot
6345 || orig_keysym == XK_dead_abovedot
6346 #endif
6347 || IsKeypadKey (keysym) /* 0xff80 <= x < 0xffbe */
6348 || IsFunctionKey (keysym) /* 0xffbe <= x < 0xffe1 */
6349 /* Any "vendor-specific" key is ok. */
6350 || (orig_keysym & (1 << 28))
6351 || (keysym != NoSymbol && nbytes == 0))
6352 && ! (IsModifierKey (orig_keysym)
6353 #ifndef HAVE_X11R5
6354 #ifdef XK_Mode_switch
6355 || ((unsigned)(orig_keysym) == XK_Mode_switch)
6356 #endif
6357 #ifdef XK_Num_Lock
6358 || ((unsigned)(orig_keysym) == XK_Num_Lock)
6359 #endif
6360 #endif /* not HAVE_X11R5 */
6361 /* The symbols from XK_ISO_Lock
6362 to XK_ISO_Last_Group_Lock
6363 don't have real modifiers but
6364 should be treated similarly to
6365 Mode_switch by Emacs. */
6366 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6367 || ((unsigned)(orig_keysym)
6368 >= XK_ISO_Lock
6369 && (unsigned)(orig_keysym)
6370 <= XK_ISO_Last_Group_Lock)
6371 #endif
6372 ))
6373 {
6374 STORE_KEYSYM_FOR_DEBUG (keysym);
6375 /* make_lispy_event will convert this to a symbolic
6376 key. */
6377 inev.ie.kind = NON_ASCII_KEYSTROKE_EVENT;
6378 inev.ie.code = keysym;
6379 goto done_keysym;
6380 }
6381
6382 { /* Raw bytes, not keysym. */
6383 register int i;
6384 register int c;
6385 int nchars, len;
6386
6387 /* The input should be decoded with `coding_system'
6388 which depends on which X*LookupString function
6389 we used just above and the locale. */
6390 setup_coding_system (coding_system, &coding);
6391 coding.src_multibyte = 0;
6392 coding.dst_multibyte = 1;
6393 /* The input is converted to events, thus we can't
6394 handle composition. Anyway, there's no XIM that
6395 gives us composition information. */
6396 coding.composing = COMPOSITION_DISABLED;
6397
6398 for (i = 0; i < nbytes; i++)
6399 {
6400 STORE_KEYSYM_FOR_DEBUG (copy_bufptr[i]);
6401 }
6402
6403 {
6404 /* Decode the input data. */
6405 int require;
6406 unsigned char *p;
6407
6408 require = decoding_buffer_size (&coding, nbytes);
6409 p = (unsigned char *) alloca (require);
6410 coding.mode |= CODING_MODE_LAST_BLOCK;
6411 /* We explicitly disable composition handling because
6412 key data should not contain any composition sequence. */
6413 coding.composing = COMPOSITION_DISABLED;
6414 decode_coding (&coding, copy_bufptr, p, nbytes, require);
6415 nbytes = coding.produced;
6416 nchars = coding.produced_char;
6417 copy_bufptr = p;
6418 }
6419
6420 /* Convert the input data to a sequence of
6421 character events. */
6422 for (i = 0; i < nbytes; i += len)
6423 {
6424 if (nchars == nbytes)
6425 c = copy_bufptr[i], len = 1;
6426 else
6427 c = STRING_CHAR_AND_LENGTH (copy_bufptr + i,
6428 nbytes - i, len);
6429 inev.ie.kind = (SINGLE_BYTE_CHAR_P (c)
6430 ? ASCII_KEYSTROKE_EVENT
6431 : MULTIBYTE_CHAR_KEYSTROKE_EVENT);
6432 inev.ie.code = c;
6433 kbd_buffer_store_event_hold (&inev.ie, hold_quit);
6434 }
6435
6436 /* Previous code updated count by nchars rather than nbytes,
6437 but that seems bogus to me. ++kfs */
6438 count += nbytes;
6439
6440 inev.ie.kind = NO_EVENT; /* Already stored above. */
6441
6442 if (keysym == NoSymbol)
6443 break;
6444 }
6445 }
6446 done_keysym:
6447 #ifdef HAVE_X_I18N
6448 /* Don't dispatch this event since XtDispatchEvent calls
6449 XFilterEvent, and two calls in a row may freeze the
6450 client. */
6451 break;
6452 #else
6453 goto OTHER;
6454 #endif
6455
6456 case KeyRelease:
6457 #ifdef HAVE_X_I18N
6458 /* Don't dispatch this event since XtDispatchEvent calls
6459 XFilterEvent, and two calls in a row may freeze the
6460 client. */
6461 break;
6462 #else
6463 goto OTHER;
6464 #endif
6465
6466 case EnterNotify:
6467 x_detect_focus_change (dpyinfo, &event, &inev.ie);
6468
6469 f = x_any_window_to_frame (dpyinfo, event.xcrossing.window);
6470
6471 if (f && x_mouse_click_focus_ignore_position)
6472 ignore_next_mouse_click_timeout = event.xmotion.time + 200;
6473
6474 #if 0
6475 if (event.xcrossing.focus)
6476 {
6477 /* Avoid nasty pop/raise loops. */
6478 if (f && (!(f->auto_raise)
6479 || !(f->auto_lower)
6480 || (event.xcrossing.time - enter_timestamp) > 500))
6481 {
6482 x_new_focus_frame (dpyinfo, f);
6483 enter_timestamp = event.xcrossing.time;
6484 }
6485 }
6486 else if (f == dpyinfo->x_focus_frame)
6487 x_new_focus_frame (dpyinfo, 0);
6488 #endif
6489
6490 /* EnterNotify counts as mouse movement,
6491 so update things that depend on mouse position. */
6492 if (f && !f->output_data.x->hourglass_p)
6493 note_mouse_movement (f, &event.xmotion);
6494 goto OTHER;
6495
6496 case FocusIn:
6497 x_detect_focus_change (dpyinfo, &event, &inev.ie);
6498 goto OTHER;
6499
6500 case LeaveNotify:
6501 x_detect_focus_change (dpyinfo, &event, &inev.ie);
6502
6503 f = x_top_window_to_frame (dpyinfo, event.xcrossing.window);
6504 if (f)
6505 {
6506 if (f == dpyinfo->mouse_face_mouse_frame)
6507 {
6508 /* If we move outside the frame, then we're
6509 certainly no longer on any text in the frame. */
6510 clear_mouse_face (dpyinfo);
6511 dpyinfo->mouse_face_mouse_frame = 0;
6512 }
6513
6514 /* Generate a nil HELP_EVENT to cancel a help-echo.
6515 Do it only if there's something to cancel.
6516 Otherwise, the startup message is cleared when
6517 the mouse leaves the frame. */
6518 if (any_help_event_p)
6519 do_help = -1;
6520 }
6521 goto OTHER;
6522
6523 case FocusOut:
6524 x_detect_focus_change (dpyinfo, &event, &inev.ie);
6525 goto OTHER;
6526
6527 case MotionNotify:
6528 {
6529 previous_help_echo_string = help_echo_string;
6530 help_echo_string = Qnil;
6531
6532 if (dpyinfo->grabbed && last_mouse_frame
6533 && FRAME_LIVE_P (last_mouse_frame))
6534 f = last_mouse_frame;
6535 else
6536 f = x_window_to_frame (dpyinfo, event.xmotion.window);
6537
6538 if (dpyinfo->mouse_face_hidden)
6539 {
6540 dpyinfo->mouse_face_hidden = 0;
6541 clear_mouse_face (dpyinfo);
6542 }
6543
6544 if (f)
6545 {
6546
6547 /* Generate SELECT_WINDOW_EVENTs when needed. */
6548 if (mouse_autoselect_window)
6549 {
6550 Lisp_Object window;
6551
6552 window = window_from_coordinates (f,
6553 event.xmotion.x, event.xmotion.y,
6554 0, 0, 0, 0);
6555
6556 /* Window will be selected only when it is not selected now and
6557 last mouse movement event was not in it. Minibuffer window
6558 will be selected iff it is active. */
6559 if (WINDOWP (window)
6560 && !EQ (window, last_window)
6561 && !EQ (window, selected_window))
6562 {
6563 inev.ie.kind = SELECT_WINDOW_EVENT;
6564 inev.ie.frame_or_window = window;
6565 }
6566
6567 last_window=window;
6568 }
6569 if (!note_mouse_movement (f, &event.xmotion))
6570 help_echo_string = previous_help_echo_string;
6571 }
6572 else
6573 {
6574 #ifndef USE_TOOLKIT_SCROLL_BARS
6575 struct scroll_bar *bar
6576 = x_window_to_scroll_bar (event.xmotion.display,
6577 event.xmotion.window);
6578
6579 if (bar)
6580 x_scroll_bar_note_movement (bar, &event);
6581 #endif /* USE_TOOLKIT_SCROLL_BARS */
6582
6583 /* If we move outside the frame, then we're
6584 certainly no longer on any text in the frame. */
6585 clear_mouse_face (dpyinfo);
6586 }
6587
6588 /* If the contents of the global variable help_echo_string
6589 has changed, generate a HELP_EVENT. */
6590 if (!NILP (help_echo_string)
6591 || !NILP (previous_help_echo_string))
6592 do_help = 1;
6593 goto OTHER;
6594 }
6595
6596 case ConfigureNotify:
6597 f = x_top_window_to_frame (dpyinfo, event.xconfigure.window);
6598 if (f)
6599 {
6600 #ifndef USE_X_TOOLKIT
6601 #ifdef USE_GTK
6602 xg_resize_widgets (f, event.xconfigure.width,
6603 event.xconfigure.height);
6604 #else /* not USE_GTK */
6605 /* If there is a pending resize for fullscreen, don't
6606 do this one, the right one will come later.
6607 The toolkit version doesn't seem to need this, but we
6608 need to reset it below. */
6609 int dont_resize
6610 = ((f->want_fullscreen & FULLSCREEN_WAIT)
6611 && f->new_text_cols != 0);
6612 int rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, event.xconfigure.height);
6613 int columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, event.xconfigure.width);
6614
6615 if (dont_resize)
6616 goto OTHER;
6617
6618 /* In the toolkit version, change_frame_size
6619 is called by the code that handles resizing
6620 of the EmacsFrame widget. */
6621
6622 /* Even if the number of character rows and columns has
6623 not changed, the font size may have changed, so we need
6624 to check the pixel dimensions as well. */
6625 if (columns != FRAME_COLS (f)
6626 || rows != FRAME_LINES (f)
6627 || event.xconfigure.width != FRAME_PIXEL_WIDTH (f)
6628 || event.xconfigure.height != FRAME_PIXEL_HEIGHT (f))
6629 {
6630 change_frame_size (f, rows, columns, 0, 1, 0);
6631 SET_FRAME_GARBAGED (f);
6632 cancel_mouse_face (f);
6633 }
6634 #endif /* not USE_GTK */
6635 #endif
6636
6637 FRAME_PIXEL_WIDTH (f) = event.xconfigure.width;
6638 FRAME_PIXEL_HEIGHT (f) = event.xconfigure.height;
6639
6640 #ifdef USE_GTK
6641 /* GTK creates windows but doesn't map them.
6642 Only get real positions and check fullscreen when mapped. */
6643 if (FRAME_GTK_OUTER_WIDGET (f)
6644 && GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f)))
6645 #endif
6646 {
6647 /* What we have now is the position of Emacs's own window.
6648 Convert that to the position of the window manager window. */
6649 x_real_positions (f, &f->left_pos, &f->top_pos);
6650
6651 x_check_expected_move (f);
6652 if (f->want_fullscreen & FULLSCREEN_WAIT)
6653 f->want_fullscreen &= ~(FULLSCREEN_WAIT|FULLSCREEN_BOTH);
6654 }
6655
6656 #ifdef HAVE_X_I18N
6657 if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMStatusArea))
6658 xic_set_statusarea (f);
6659 #endif
6660
6661 if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
6662 {
6663 /* Since the WM decorations come below top_pos now,
6664 we must put them below top_pos in the future. */
6665 f->win_gravity = NorthWestGravity;
6666 x_wm_set_size_hint (f, (long) 0, 0);
6667 }
6668 }
6669 goto OTHER;
6670
6671 case ButtonRelease:
6672 case ButtonPress:
6673 {
6674 /* If we decide we want to generate an event to be seen
6675 by the rest of Emacs, we put it here. */
6676 int tool_bar_p = 0;
6677
6678 bzero (&compose_status, sizeof (compose_status));
6679 last_mouse_glyph_frame = 0;
6680
6681 if (dpyinfo->grabbed
6682 && last_mouse_frame
6683 && FRAME_LIVE_P (last_mouse_frame))
6684 f = last_mouse_frame;
6685 else
6686 f = x_window_to_frame (dpyinfo, event.xbutton.window);
6687
6688 if (f)
6689 {
6690 /* Is this in the tool-bar? */
6691 if (WINDOWP (f->tool_bar_window)
6692 && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)))
6693 {
6694 Lisp_Object window;
6695 int x = event.xbutton.x;
6696 int y = event.xbutton.y;
6697
6698 window = window_from_coordinates (f, x, y, 0, 0, 0, 1);
6699 if (EQ (window, f->tool_bar_window))
6700 {
6701 if (event.xbutton.type == ButtonPress)
6702 handle_tool_bar_click (f, x, y, 1, 0);
6703 else
6704 handle_tool_bar_click (f, x, y, 0,
6705 x_x_to_emacs_modifiers (dpyinfo,
6706 event.xbutton.state));
6707 tool_bar_p = 1;
6708 }
6709 }
6710
6711 if (!tool_bar_p)
6712 if (!dpyinfo->x_focus_frame
6713 || f == dpyinfo->x_focus_frame)
6714 {
6715 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6716 if (! popup_activated ())
6717 #endif
6718 {
6719 if (ignore_next_mouse_click_timeout)
6720 {
6721 if (event.type == ButtonPress
6722 && (int)(event.xbutton.time - ignore_next_mouse_click_timeout) > 0)
6723 {
6724 ignore_next_mouse_click_timeout = 0;
6725 construct_mouse_click (&inev.ie, &event.xbutton, f);
6726 }
6727 if (event.type == ButtonRelease)
6728 ignore_next_mouse_click_timeout = 0;
6729 }
6730 else
6731 construct_mouse_click (&inev.ie, &event.xbutton, f);
6732 }
6733 }
6734 }
6735 else
6736 {
6737 struct scroll_bar *bar
6738 = x_window_to_scroll_bar (event.xbutton.display,
6739 event.xbutton.window);
6740
6741 #ifdef USE_TOOLKIT_SCROLL_BARS
6742 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6743 scroll bars. */
6744 if (bar && event.xbutton.state & ControlMask)
6745 {
6746 x_scroll_bar_handle_click (bar, &event, &inev.ie);
6747 *finish = X_EVENT_DROP;
6748 }
6749 #else /* not USE_TOOLKIT_SCROLL_BARS */
6750 if (bar)
6751 x_scroll_bar_handle_click (bar, &event, &inev.ie);
6752 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6753 }
6754
6755 if (event.type == ButtonPress)
6756 {
6757 dpyinfo->grabbed |= (1 << event.xbutton.button);
6758 last_mouse_frame = f;
6759
6760 if (!tool_bar_p)
6761 last_tool_bar_item = -1;
6762 }
6763 else
6764 dpyinfo->grabbed &= ~(1 << event.xbutton.button);
6765
6766 /* Ignore any mouse motion that happened before this event;
6767 any subsequent mouse-movement Emacs events should reflect
6768 only motion after the ButtonPress/Release. */
6769 if (f != 0)
6770 f->mouse_moved = 0;
6771
6772 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6773 f = x_menubar_window_to_frame (dpyinfo, event.xbutton.window);
6774 /* For a down-event in the menu bar,
6775 don't pass it to Xt right now.
6776 Instead, save it away
6777 and we will pass it to Xt from kbd_buffer_get_event.
6778 That way, we can run some Lisp code first. */
6779 if (
6780 #ifdef USE_GTK
6781 ! popup_activated ()
6782 &&
6783 #endif
6784 f && event.type == ButtonPress
6785 /* Verify the event is really within the menu bar
6786 and not just sent to it due to grabbing. */
6787 && event.xbutton.x >= 0
6788 && event.xbutton.x < FRAME_PIXEL_WIDTH (f)
6789 && event.xbutton.y >= 0
6790 && event.xbutton.y < f->output_data.x->menubar_height
6791 && event.xbutton.same_screen)
6792 {
6793 SET_SAVED_BUTTON_EVENT;
6794 XSETFRAME (last_mouse_press_frame, f);
6795 #ifdef USE_GTK
6796 *finish = X_EVENT_DROP;
6797 #endif
6798 }
6799 else if (event.type == ButtonPress)
6800 {
6801 last_mouse_press_frame = Qnil;
6802 goto OTHER;
6803 }
6804
6805 #ifdef USE_MOTIF /* This should do not harm for Lucid,
6806 but I am trying to be cautious. */
6807 else if (event.type == ButtonRelease)
6808 {
6809 if (!NILP (last_mouse_press_frame))
6810 {
6811 f = XFRAME (last_mouse_press_frame);
6812 if (f->output_data.x)
6813 SET_SAVED_BUTTON_EVENT;
6814 }
6815 else
6816 goto OTHER;
6817 }
6818 #endif /* USE_MOTIF */
6819 else
6820 goto OTHER;
6821 #endif /* USE_X_TOOLKIT || USE_GTK */
6822 }
6823 break;
6824
6825 case CirculateNotify:
6826 goto OTHER;
6827
6828 case CirculateRequest:
6829 goto OTHER;
6830
6831 case VisibilityNotify:
6832 goto OTHER;
6833
6834 case MappingNotify:
6835 /* Someone has changed the keyboard mapping - update the
6836 local cache. */
6837 switch (event.xmapping.request)
6838 {
6839 case MappingModifier:
6840 x_find_modifier_meanings (dpyinfo);
6841 /* This is meant to fall through. */
6842 case MappingKeyboard:
6843 XRefreshKeyboardMapping (&event.xmapping);
6844 }
6845 goto OTHER;
6846
6847 default:
6848 OTHER:
6849 #ifdef USE_X_TOOLKIT
6850 BLOCK_INPUT;
6851 if (*finish != X_EVENT_DROP)
6852 XtDispatchEvent (&event);
6853 UNBLOCK_INPUT;
6854 #endif /* USE_X_TOOLKIT */
6855 break;
6856 }
6857
6858 done:
6859 if (inev.ie.kind != NO_EVENT)
6860 {
6861 kbd_buffer_store_event_hold (&inev.ie, hold_quit);
6862 count++;
6863 }
6864
6865 if (do_help
6866 && !(hold_quit && hold_quit->kind != NO_EVENT))
6867 {
6868 Lisp_Object frame;
6869
6870 if (f)
6871 XSETFRAME (frame, f);
6872 else
6873 frame = Qnil;
6874
6875 if (do_help > 0)
6876 {
6877 any_help_event_p = 1;
6878 gen_help_event (help_echo_string, frame, help_echo_window,
6879 help_echo_object, help_echo_pos);
6880 }
6881 else
6882 {
6883 help_echo_string = Qnil;
6884 gen_help_event (Qnil, frame, Qnil, Qnil, 0);
6885 }
6886 count++;
6887 }
6888
6889 *eventp = event;
6890 return count;
6891 }
6892
6893
6894 /* Handles the XEvent EVENT on display DISPLAY.
6895 This is used for event loops outside the normal event handling,
6896 i.e. looping while a popup menu or a dialog is posted.
6897
6898 Returns the value handle_one_xevent sets in the finish argument. */
6899 int
6900 x_dispatch_event (event, display)
6901 XEvent *event;
6902 Display *display;
6903 {
6904 struct x_display_info *dpyinfo;
6905 int finish = X_EVENT_NORMAL;
6906
6907 dpyinfo = x_display_info_for_display (display);
6908
6909 if (dpyinfo)
6910 handle_one_xevent (dpyinfo, event, &finish, 0);
6911
6912 return finish;
6913 }
6914
6915
6916 /* Read events coming from the X server.
6917 This routine is called by the SIGIO handler.
6918 We return as soon as there are no more events to be read.
6919
6920 We return the number of characters stored into the buffer,
6921 thus pretending to be `read'.
6922
6923 EXPECTED is nonzero if the caller knows input is available. */
6924
6925 static int
6926 XTread_socket (device, expected, hold_quit)
6927 struct device *device;
6928 int expected;
6929 struct input_event *hold_quit;
6930 {
6931 int count = 0;
6932 XEvent event;
6933 int event_found = 0;
6934 struct x_display_info *dpyinfo;
6935
6936 if (interrupt_input_blocked)
6937 {
6938 interrupt_input_pending = 1;
6939 return -1;
6940 }
6941
6942 interrupt_input_pending = 0;
6943 BLOCK_INPUT;
6944
6945 /* So people can tell when we have read the available input. */
6946 input_signal_count++;
6947
6948 ++handling_signal;
6949
6950 /* Find the display we are supposed to read input for.
6951 It's the one communicating on descriptor SD. */
6952 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
6953 {
6954 #if 0 /* This ought to be unnecessary; let's verify it. */
6955 #ifdef FIOSNBIO
6956 /* If available, Xlib uses FIOSNBIO to make the socket
6957 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
6958 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
6959 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
6960 fcntl (dpyinfo->connection, F_SETFL, 0);
6961 #endif /* ! defined (FIOSNBIO) */
6962 #endif
6963
6964 #if 0 /* This code can't be made to work, with multiple displays,
6965 and appears not to be used on any system any more.
6966 Also keyboard.c doesn't turn O_NDELAY on and off
6967 for X connections. */
6968 #ifndef SIGIO
6969 #ifndef HAVE_SELECT
6970 if (! (fcntl (dpyinfo->connection, F_GETFL, 0) & O_NDELAY))
6971 {
6972 extern int read_alarm_should_throw;
6973 read_alarm_should_throw = 1;
6974 XPeekEvent (dpyinfo->display, &event);
6975 read_alarm_should_throw = 0;
6976 }
6977 #endif /* HAVE_SELECT */
6978 #endif /* SIGIO */
6979 #endif
6980
6981 /* For debugging, this gives a way to fake an I/O error. */
6982 if (dpyinfo == XTread_socket_fake_io_error)
6983 {
6984 XTread_socket_fake_io_error = 0;
6985 x_io_error_quitter (dpyinfo->display);
6986 }
6987
6988 #ifdef HAVE_X_SM
6989 /* Only check session manager input for the primary display. */
6990 if (device->id == 1 && x_session_have_connection ())
6991 {
6992 struct input_event inev;
6993 BLOCK_INPUT;
6994 /* We don't need to EVENT_INIT (inev) here, as
6995 x_session_check_input copies an entire input_event. */
6996 if (x_session_check_input (&inev))
6997 {
6998 kbd_buffer_store_event_hold (&inev, hold_quit);
6999 count++;
7000 }
7001 UNBLOCK_INPUT;
7002 }
7003 #endif
7004
7005 #ifndef USE_GTK
7006 while (XPending (dpyinfo->display))
7007 {
7008 int finish;
7009
7010 XNextEvent (dpyinfo->display, &event);
7011
7012 #ifdef HAVE_X_I18N
7013 /* Filter events for the current X input method. */
7014 if (x_filter_event (dpyinfo, &event))
7015 break;
7016 #endif
7017 event_found = 1;
7018
7019 count += handle_one_xevent (dpyinfo, &event, &finish, hold_quit);
7020
7021 if (finish == X_EVENT_GOTO_OUT)
7022 goto out;
7023 }
7024 #endif /* not USE_GTK */
7025 }
7026
7027 #ifdef USE_GTK
7028
7029 /* For GTK we must use the GTK event loop. But XEvents gets passed
7030 to our filter function above, and then to the big event switch.
7031 We use a bunch of globals to communicate with our filter function,
7032 that is kind of ugly, but it works.
7033
7034 There is no way to do one display at the time, GTK just does events
7035 from all displays. */
7036
7037 while (gtk_events_pending ())
7038 {
7039 current_count = count;
7040 current_hold_quit = hold_quit;
7041
7042 gtk_main_iteration ();
7043
7044 count = current_count;
7045 current_count = -1;
7046 current_hold_quit = 0;
7047
7048 if (current_finish == X_EVENT_GOTO_OUT)
7049 break;
7050 }
7051 #endif /* USE_GTK */
7052
7053 out:;
7054
7055 /* On some systems, an X bug causes Emacs to get no more events
7056 when the window is destroyed. Detect that. (1994.) */
7057 if (! event_found)
7058 {
7059 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7060 One XNOOP in 100 loops will make Emacs terminate.
7061 B. Bretthauer, 1994 */
7062 x_noop_count++;
7063 if (x_noop_count >= 100)
7064 {
7065 x_noop_count=0;
7066
7067 if (next_noop_dpyinfo == 0)
7068 next_noop_dpyinfo = x_display_list;
7069
7070 XNoOp (next_noop_dpyinfo->display);
7071
7072 /* Each time we get here, cycle through the displays now open. */
7073 next_noop_dpyinfo = next_noop_dpyinfo->next;
7074 }
7075 }
7076
7077 /* If the focus was just given to an auto-raising frame,
7078 raise it now. */
7079 /* ??? This ought to be able to handle more than one such frame. */
7080 if (pending_autoraise_frame)
7081 {
7082 x_raise_frame (pending_autoraise_frame);
7083 pending_autoraise_frame = 0;
7084 }
7085
7086 --handling_signal;
7087 UNBLOCK_INPUT;
7088
7089 return count;
7090 }
7091
7092
7093
7094 \f
7095 /***********************************************************************
7096 Text Cursor
7097 ***********************************************************************/
7098
7099 /* Set clipping for output in glyph row ROW. W is the window in which
7100 we operate. GC is the graphics context to set clipping in.
7101
7102 ROW may be a text row or, e.g., a mode line. Text rows must be
7103 clipped to the interior of the window dedicated to text display,
7104 mode lines must be clipped to the whole window. */
7105
7106 static void
7107 x_clip_to_row (w, row, area, gc)
7108 struct window *w;
7109 struct glyph_row *row;
7110 int area;
7111 GC gc;
7112 {
7113 struct frame *f = XFRAME (WINDOW_FRAME (w));
7114 XRectangle clip_rect;
7115 int window_x, window_y, window_width;
7116
7117 window_box (w, area, &window_x, &window_y, &window_width, 0);
7118
7119 clip_rect.x = window_x;
7120 clip_rect.y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, row->y));
7121 clip_rect.y = max (clip_rect.y, window_y);
7122 clip_rect.width = window_width;
7123 clip_rect.height = row->visible_height;
7124
7125 XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, &clip_rect, 1, Unsorted);
7126 }
7127
7128
7129 /* Draw a hollow box cursor on window W in glyph row ROW. */
7130
7131 static void
7132 x_draw_hollow_cursor (w, row)
7133 struct window *w;
7134 struct glyph_row *row;
7135 {
7136 struct frame *f = XFRAME (WINDOW_FRAME (w));
7137 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
7138 Display *dpy = FRAME_X_DISPLAY (f);
7139 int x, y, wd, h;
7140 XGCValues xgcv;
7141 struct glyph *cursor_glyph;
7142 GC gc;
7143
7144 /* Get the glyph the cursor is on. If we can't tell because
7145 the current matrix is invalid or such, give up. */
7146 cursor_glyph = get_phys_cursor_glyph (w);
7147 if (cursor_glyph == NULL)
7148 return;
7149
7150 /* Compute frame-relative coordinates for phys cursor. */
7151 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
7152 y = get_phys_cursor_geometry (w, row, cursor_glyph, &h);
7153 wd = w->phys_cursor_width;
7154
7155 /* The foreground of cursor_gc is typically the same as the normal
7156 background color, which can cause the cursor box to be invisible. */
7157 xgcv.foreground = f->output_data.x->cursor_pixel;
7158 if (dpyinfo->scratch_cursor_gc)
7159 XChangeGC (dpy, dpyinfo->scratch_cursor_gc, GCForeground, &xgcv);
7160 else
7161 dpyinfo->scratch_cursor_gc = XCreateGC (dpy, FRAME_X_WINDOW (f),
7162 GCForeground, &xgcv);
7163 gc = dpyinfo->scratch_cursor_gc;
7164
7165 /* Set clipping, draw the rectangle, and reset clipping again. */
7166 x_clip_to_row (w, row, TEXT_AREA, gc);
7167 XDrawRectangle (dpy, FRAME_X_WINDOW (f), gc, x, y, wd, h);
7168 XSetClipMask (dpy, gc, None);
7169 }
7170
7171
7172 /* Draw a bar cursor on window W in glyph row ROW.
7173
7174 Implementation note: One would like to draw a bar cursor with an
7175 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7176 Unfortunately, I didn't find a font yet that has this property set.
7177 --gerd. */
7178
7179 static void
7180 x_draw_bar_cursor (w, row, width, kind)
7181 struct window *w;
7182 struct glyph_row *row;
7183 int width;
7184 enum text_cursor_kinds kind;
7185 {
7186 struct frame *f = XFRAME (w->frame);
7187 struct glyph *cursor_glyph;
7188
7189 /* If cursor is out of bounds, don't draw garbage. This can happen
7190 in mini-buffer windows when switching between echo area glyphs
7191 and mini-buffer. */
7192 cursor_glyph = get_phys_cursor_glyph (w);
7193 if (cursor_glyph == NULL)
7194 return;
7195
7196 /* If on an image, draw like a normal cursor. That's usually better
7197 visible than drawing a bar, esp. if the image is large so that
7198 the bar might not be in the window. */
7199 if (cursor_glyph->type == IMAGE_GLYPH)
7200 {
7201 struct glyph_row *row;
7202 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
7203 draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
7204 }
7205 else
7206 {
7207 Display *dpy = FRAME_X_DISPLAY (f);
7208 Window window = FRAME_X_WINDOW (f);
7209 GC gc = FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc;
7210 unsigned long mask = GCForeground | GCBackground | GCGraphicsExposures;
7211 struct face *face = FACE_FROM_ID (f, cursor_glyph->face_id);
7212 XGCValues xgcv;
7213
7214 /* If the glyph's background equals the color we normally draw
7215 the bar cursor in, the bar cursor in its normal color is
7216 invisible. Use the glyph's foreground color instead in this
7217 case, on the assumption that the glyph's colors are chosen so
7218 that the glyph is legible. */
7219 if (face->background == f->output_data.x->cursor_pixel)
7220 xgcv.background = xgcv.foreground = face->foreground;
7221 else
7222 xgcv.background = xgcv.foreground = f->output_data.x->cursor_pixel;
7223 xgcv.graphics_exposures = 0;
7224
7225 if (gc)
7226 XChangeGC (dpy, gc, mask, &xgcv);
7227 else
7228 {
7229 gc = XCreateGC (dpy, window, mask, &xgcv);
7230 FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc = gc;
7231 }
7232
7233 if (width < 0)
7234 width = FRAME_CURSOR_WIDTH (f);
7235 width = min (cursor_glyph->pixel_width, width);
7236
7237 w->phys_cursor_width = width;
7238 x_clip_to_row (w, row, TEXT_AREA, gc);
7239
7240 if (kind == BAR_CURSOR)
7241 XFillRectangle (dpy, window, gc,
7242 WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
7243 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
7244 width, row->height);
7245 else
7246 XFillRectangle (dpy, window, gc,
7247 WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
7248 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y +
7249 row->height - width),
7250 cursor_glyph->pixel_width,
7251 width);
7252
7253 XSetClipMask (dpy, gc, None);
7254 }
7255 }
7256
7257
7258 /* RIF: Define cursor CURSOR on frame F. */
7259
7260 static void
7261 x_define_frame_cursor (f, cursor)
7262 struct frame *f;
7263 Cursor cursor;
7264 {
7265 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
7266 }
7267
7268
7269 /* RIF: Clear area on frame F. */
7270
7271 static void
7272 x_clear_frame_area (f, x, y, width, height)
7273 struct frame *f;
7274 int x, y, width, height;
7275 {
7276 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
7277 x, y, width, height, False);
7278 }
7279
7280
7281 /* RIF: Draw cursor on window W. */
7282
7283 static void
7284 x_draw_window_cursor (w, glyph_row, x, y, cursor_type, cursor_width, on_p, active_p)
7285 struct window *w;
7286 struct glyph_row *glyph_row;
7287 int x, y;
7288 int cursor_type, cursor_width;
7289 int on_p, active_p;
7290 {
7291 struct frame *f = XFRAME (WINDOW_FRAME (w));
7292
7293 if (on_p)
7294 {
7295 w->phys_cursor_type = cursor_type;
7296 w->phys_cursor_on_p = 1;
7297
7298 if (glyph_row->exact_window_width_line_p
7299 && w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])
7300 {
7301 glyph_row->cursor_in_fringe_p = 1;
7302 draw_fringe_bitmap (w, glyph_row, 0);
7303 }
7304 else
7305 switch (cursor_type)
7306 {
7307 case HOLLOW_BOX_CURSOR:
7308 x_draw_hollow_cursor (w, glyph_row);
7309 break;
7310
7311 case FILLED_BOX_CURSOR:
7312 draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
7313 break;
7314
7315 case BAR_CURSOR:
7316 x_draw_bar_cursor (w, glyph_row, cursor_width, BAR_CURSOR);
7317 break;
7318
7319 case HBAR_CURSOR:
7320 x_draw_bar_cursor (w, glyph_row, cursor_width, HBAR_CURSOR);
7321 break;
7322
7323 case NO_CURSOR:
7324 w->phys_cursor_width = 0;
7325 break;
7326
7327 default:
7328 abort ();
7329 }
7330
7331 #ifdef HAVE_X_I18N
7332 if (w == XWINDOW (f->selected_window))
7333 if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMPreeditPosition))
7334 xic_set_preeditarea (w, x, y);
7335 #endif
7336 }
7337
7338 #ifndef XFlush
7339 XFlush (FRAME_X_DISPLAY (f));
7340 #endif
7341 }
7342
7343 \f
7344 /* Icons. */
7345
7346 /* Make the x-window of frame F use the gnu icon bitmap. */
7347
7348 int
7349 x_bitmap_icon (f, file)
7350 struct frame *f;
7351 Lisp_Object file;
7352 {
7353 int bitmap_id;
7354
7355 if (FRAME_X_WINDOW (f) == 0)
7356 return 1;
7357
7358 /* Free up our existing icon bitmap and mask if any. */
7359 if (f->output_data.x->icon_bitmap > 0)
7360 x_destroy_bitmap (f, f->output_data.x->icon_bitmap);
7361 f->output_data.x->icon_bitmap = 0;
7362
7363 if (STRINGP (file))
7364 {
7365 #ifdef USE_GTK
7366 /* Use gtk_window_set_icon_from_file () if available,
7367 It's not restricted to bitmaps */
7368 if (xg_set_icon (f, file))
7369 return 0;
7370 #endif /* USE_GTK */
7371 bitmap_id = x_create_bitmap_from_file (f, file);
7372 x_create_bitmap_mask (f, bitmap_id);
7373 }
7374 else
7375 {
7376 /* Create the GNU bitmap and mask if necessary. */
7377 if (FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id < 0)
7378 {
7379 int rc = -1;
7380
7381 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7382 #ifdef USE_GTK
7383 if (xg_set_icon_from_xpm_data (f, gnu_xpm_bits))
7384 return 0;
7385 #else
7386 rc = x_create_bitmap_from_xpm_data (f, gnu_xpm_bits);
7387 if (rc != -1)
7388 FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id = rc;
7389 #endif /* USE_GTK */
7390 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
7391
7392 /* If all else fails, use the (black and white) xbm image. */
7393 if (rc == -1)
7394 {
7395 rc = x_create_bitmap_from_data (f, gnu_xbm_bits,
7396 gnu_xbm_width, gnu_xbm_height);
7397 if (rc == -1)
7398 return 1;
7399
7400 FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id = rc;
7401 x_create_bitmap_mask (f, FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id);
7402 }
7403 }
7404
7405 /* The first time we create the GNU bitmap and mask,
7406 this increments the ref-count one extra time.
7407 As a result, the GNU bitmap and mask are never freed.
7408 That way, we don't have to worry about allocating it again. */
7409 x_reference_bitmap (f, FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id);
7410
7411 bitmap_id = FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id;
7412 }
7413
7414 x_wm_set_icon_pixmap (f, bitmap_id);
7415 f->output_data.x->icon_bitmap = bitmap_id;
7416
7417 return 0;
7418 }
7419
7420
7421 /* Make the x-window of frame F use a rectangle with text.
7422 Use ICON_NAME as the text. */
7423
7424 int
7425 x_text_icon (f, icon_name)
7426 struct frame *f;
7427 char *icon_name;
7428 {
7429 if (FRAME_X_WINDOW (f) == 0)
7430 return 1;
7431
7432 #ifdef HAVE_X11R4
7433 {
7434 XTextProperty text;
7435 text.value = (unsigned char *) icon_name;
7436 text.encoding = XA_STRING;
7437 text.format = 8;
7438 text.nitems = strlen (icon_name);
7439 XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
7440 }
7441 #else /* not HAVE_X11R4 */
7442 XSetIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), icon_name);
7443 #endif /* not HAVE_X11R4 */
7444
7445 if (f->output_data.x->icon_bitmap > 0)
7446 x_destroy_bitmap (f, f->output_data.x->icon_bitmap);
7447 f->output_data.x->icon_bitmap = 0;
7448 x_wm_set_icon_pixmap (f, 0);
7449
7450 return 0;
7451 }
7452 \f
7453 #define X_ERROR_MESSAGE_SIZE 200
7454
7455 /* If non-nil, this should be a string.
7456 It means catch X errors and store the error message in this string. */
7457
7458 static Lisp_Object x_error_message_string;
7459
7460 /* An X error handler which stores the error message in
7461 x_error_message_string. This is called from x_error_handler if
7462 x_catch_errors is in effect. */
7463
7464 static void
7465 x_error_catcher (display, error)
7466 Display *display;
7467 XErrorEvent *error;
7468 {
7469 XGetErrorText (display, error->error_code,
7470 SDATA (x_error_message_string),
7471 X_ERROR_MESSAGE_SIZE);
7472 }
7473
7474 /* Begin trapping X errors for display DPY. Actually we trap X errors
7475 for all displays, but DPY should be the display you are actually
7476 operating on.
7477
7478 After calling this function, X protocol errors no longer cause
7479 Emacs to exit; instead, they are recorded in the string
7480 stored in x_error_message_string.
7481
7482 Calling x_check_errors signals an Emacs error if an X error has
7483 occurred since the last call to x_catch_errors or x_check_errors.
7484
7485 Calling x_uncatch_errors resumes the normal error handling. */
7486
7487 void x_check_errors ();
7488 static Lisp_Object x_catch_errors_unwind ();
7489
7490 int
7491 x_catch_errors (dpy)
7492 Display *dpy;
7493 {
7494 int count = SPECPDL_INDEX ();
7495
7496 /* Make sure any errors from previous requests have been dealt with. */
7497 XSync (dpy, False);
7498
7499 record_unwind_protect (x_catch_errors_unwind,
7500 Fcons (make_save_value (dpy, 0),
7501 x_error_message_string));
7502
7503 x_error_message_string = make_uninit_string (X_ERROR_MESSAGE_SIZE);
7504 SSET (x_error_message_string, 0, 0);
7505
7506 return count;
7507 }
7508
7509 /* Unbind the binding that we made to check for X errors. */
7510
7511 static Lisp_Object
7512 x_catch_errors_unwind (old_val)
7513 Lisp_Object old_val;
7514 {
7515 Lisp_Object first = XCAR (old_val);
7516 Display *dpy = XSAVE_VALUE (first)->pointer;
7517
7518 /* The display may have been closed before this function is called.
7519 Check if it is still open before calling XSync. */
7520 if (x_display_info_for_display (dpy) != 0)
7521 {
7522 BLOCK_INPUT;
7523 XSync (dpy, False);
7524 UNBLOCK_INPUT;
7525 }
7526
7527 x_error_message_string = XCDR (old_val);
7528 return Qnil;
7529 }
7530
7531 /* If any X protocol errors have arrived since the last call to
7532 x_catch_errors or x_check_errors, signal an Emacs error using
7533 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7534
7535 void
7536 x_check_errors (dpy, format)
7537 Display *dpy;
7538 char *format;
7539 {
7540 /* Make sure to catch any errors incurred so far. */
7541 XSync (dpy, False);
7542
7543 if (SREF (x_error_message_string, 0))
7544 error (format, SDATA (x_error_message_string));
7545 }
7546
7547 /* Nonzero if we had any X protocol errors
7548 since we did x_catch_errors on DPY. */
7549
7550 int
7551 x_had_errors_p (dpy)
7552 Display *dpy;
7553 {
7554 /* Make sure to catch any errors incurred so far. */
7555 XSync (dpy, False);
7556
7557 return SREF (x_error_message_string, 0) != 0;
7558 }
7559
7560 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7561
7562 void
7563 x_clear_errors (dpy)
7564 Display *dpy;
7565 {
7566 SSET (x_error_message_string, 0, 0);
7567 }
7568
7569 /* Stop catching X protocol errors and let them make Emacs die.
7570 DPY should be the display that was passed to x_catch_errors.
7571 COUNT should be the value that was returned by
7572 the corresponding call to x_catch_errors. */
7573
7574 void
7575 x_uncatch_errors (dpy, count)
7576 Display *dpy;
7577 int count;
7578 {
7579 unbind_to (count, Qnil);
7580 }
7581
7582 #if 0
7583 static unsigned int x_wire_count;
7584 x_trace_wire ()
7585 {
7586 fprintf (stderr, "Lib call: %d\n", ++x_wire_count);
7587 }
7588 #endif /* ! 0 */
7589
7590 \f
7591 /* Handle SIGPIPE, which can happen when the connection to a server
7592 simply goes away. SIGPIPE is handled by x_connection_signal.
7593 Don't need to do anything, because the write which caused the
7594 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7595 which will do the appropriate cleanup for us. */
7596
7597 static SIGTYPE
7598 x_connection_signal (signalnum) /* If we don't have an argument, */
7599 int signalnum; /* some compilers complain in signal calls. */
7600 {
7601 #ifdef USG
7602 /* USG systems forget handlers when they are used;
7603 must reestablish each time */
7604 signal (signalnum, x_connection_signal);
7605 #endif /* USG */
7606 }
7607
7608 \f
7609 /************************************************************************
7610 Handling X errors
7611 ************************************************************************/
7612
7613 /* Error message passed to x_connection_closed. */
7614
7615 static char *error_msg;
7616
7617 /* Function installed as fatal_error_signal_hook in
7618 x_connection_closed. Print the X error message, and exit normally,
7619 instead of dumping core when XtCloseDisplay fails. */
7620
7621 static void
7622 x_fatal_error_signal ()
7623 {
7624 fprintf (stderr, "%s\n", error_msg);
7625 exit (70);
7626 }
7627
7628 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7629 the text of an error message that lead to the connection loss. */
7630
7631 static SIGTYPE
7632 x_connection_closed (dpy, error_message)
7633 Display *dpy;
7634 char *error_message;
7635 {
7636 struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
7637 Lisp_Object frame, tail;
7638 int count;
7639 int index = SPECPDL_INDEX ();
7640
7641 error_msg = (char *) alloca (strlen (error_message) + 1);
7642 strcpy (error_msg, error_message);
7643 handling_signal = 0;
7644
7645 /* Prevent being called recursively because of an error condition
7646 below. Otherwise, we might end up with printing ``can't find per
7647 display information'' in the recursive call instead of printing
7648 the original message here. */
7649 count = x_catch_errors (dpy);
7650
7651 /* Inhibit redisplay while frames are being deleted. */
7652 specbind (Qinhibit_redisplay, Qt);
7653
7654 if (dpyinfo)
7655 {
7656 /* Protect display from being closed when we delete the last
7657 frame on it. */
7658 dpyinfo->reference_count++;
7659 dpyinfo->device->reference_count++;
7660 }
7661
7662 /* First delete frames whose mini-buffers are on frames
7663 that are on the dead display. */
7664 FOR_EACH_FRAME (tail, frame)
7665 {
7666 Lisp_Object minibuf_frame;
7667 minibuf_frame
7668 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame))));
7669 if (FRAME_X_P (XFRAME (frame))
7670 && FRAME_X_P (XFRAME (minibuf_frame))
7671 && ! EQ (frame, minibuf_frame)
7672 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame)) == dpyinfo)
7673 Fdelete_frame (frame, Qt);
7674 }
7675
7676 /* Now delete all remaining frames on the dead display.
7677 We are now sure none of these is used as the mini-buffer
7678 for another frame that we need to delete. */
7679 FOR_EACH_FRAME (tail, frame)
7680 if (FRAME_X_P (XFRAME (frame))
7681 && FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
7682 {
7683 /* Set this to t so that Fdelete_frame won't get confused
7684 trying to find a replacement. */
7685 FRAME_KBOARD (XFRAME (frame))->Vdefault_minibuffer_frame = Qt;
7686 Fdelete_frame (frame, Qt);
7687 }
7688
7689 /* We have to close the display to inform Xt that it doesn't
7690 exist anymore. If we don't, Xt will continue to wait for
7691 events from the display. As a consequence, a sequence of
7692
7693 M-x make-frame-on-display RET :1 RET
7694 ...kill the new frame, so that we get an IO error...
7695 M-x make-frame-on-display RET :1 RET
7696
7697 will indefinitely wait in Xt for events for display `:1', opened
7698 in the first class to make-frame-on-display.
7699
7700 Closing the display is reported to lead to a bus error on
7701 OpenWindows in certain situations. I suspect that is a bug
7702 in OpenWindows. I don't know how to cicumvent it here. */
7703
7704 #ifdef USE_X_TOOLKIT
7705 /* If DPYINFO is null, this means we didn't open the display
7706 in the first place, so don't try to close it. */
7707 if (dpyinfo)
7708 {
7709 extern void (*fatal_error_signal_hook) P_ ((void));
7710 fatal_error_signal_hook = x_fatal_error_signal;
7711 XtCloseDisplay (dpy);
7712 fatal_error_signal_hook = NULL;
7713 }
7714 #endif
7715
7716 #ifdef USE_GTK
7717 if (dpyinfo)
7718 xg_display_close (dpyinfo->display);
7719 #endif
7720
7721 if (dpyinfo)
7722 {
7723 /* Indicate that this display is dead. */
7724 dpyinfo->display = 0;
7725
7726 dpyinfo->reference_count--;
7727 dpyinfo->device->reference_count--;
7728 if (dpyinfo->reference_count != 0)
7729 /* We have just closed all frames on this display. */
7730 abort ();
7731
7732 x_delete_display (dpyinfo);
7733 }
7734
7735 x_uncatch_errors (dpy, count);
7736
7737 if (device_list == 0)
7738 {
7739 fprintf (stderr, "%s\n", error_msg);
7740 shut_down_emacs (0, 0, Qnil);
7741 exit (70);
7742 }
7743
7744 /* Ordinary stack unwind doesn't deal with these. */
7745 #ifdef SIGIO
7746 sigunblock (sigmask (SIGIO));
7747 #endif
7748 sigunblock (sigmask (SIGALRM));
7749 TOTALLY_UNBLOCK_INPUT;
7750
7751 unbind_to (index, Qnil);
7752 clear_waiting_for_input ();
7753 error ("%s", error_msg);
7754 }
7755
7756 /* We specifically use it before defining it, so that gcc doesn't inline it,
7757 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7758 static void x_error_quitter (Display *display, XErrorEvent *error);
7759
7760 /* This is the first-level handler for X protocol errors.
7761 It calls x_error_quitter or x_error_catcher. */
7762
7763 static int
7764 x_error_handler (display, error)
7765 Display *display;
7766 XErrorEvent *error;
7767 {
7768 if (! NILP (x_error_message_string))
7769 x_error_catcher (display, error);
7770 else
7771 x_error_quitter (display, error);
7772 return 0;
7773 }
7774
7775 /* This is the usual handler for X protocol errors.
7776 It kills all frames on the display that we got the error for.
7777 If that was the only one, it prints an error message and kills Emacs. */
7778
7779 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7780
7781 #if __GNUC__ >= 3 /* On GCC 3.0 we might get a warning. */
7782 #define NO_INLINE __attribute__((noinline))
7783 #else
7784 #define NO_INLINE
7785 #endif
7786
7787 /* Some versions of GNU/Linux define noinline in their headers. */
7788
7789 #ifdef noinline
7790 #undef noinline
7791 #endif
7792
7793 /* On older GCC versions, just putting x_error_quitter
7794 after x_error_handler prevents inlining into the former. */
7795
7796 static void NO_INLINE
7797 x_error_quitter (display, error)
7798 Display *display;
7799 XErrorEvent *error;
7800 {
7801 char buf[256], buf1[356];
7802
7803 /* Note that there is no real way portable across R3/R4 to get the
7804 original error handler. */
7805
7806 XGetErrorText (display, error->error_code, buf, sizeof (buf));
7807 sprintf (buf1, "X protocol error: %s on protocol request %d",
7808 buf, error->request_code);
7809 x_connection_closed (display, buf1);
7810 }
7811
7812
7813 /* This is the handler for X IO errors, always.
7814 It kills all frames on the display that we lost touch with.
7815 If that was the only one, it prints an error message and kills Emacs. */
7816
7817 static int
7818 x_io_error_quitter (display)
7819 Display *display;
7820 {
7821 char buf[256];
7822
7823 sprintf (buf, "Connection lost to X server `%s'", DisplayString (display));
7824 x_connection_closed (display, buf);
7825 return 0;
7826 }
7827 \f
7828 /* Changing the font of the frame. */
7829
7830 /* Give frame F the font named FONTNAME as its default font, and
7831 return the full name of that font. FONTNAME may be a wildcard
7832 pattern; in that case, we choose some font that fits the pattern.
7833 The return value shows which font we chose. */
7834
7835 Lisp_Object
7836 x_new_font (f, fontname)
7837 struct frame *f;
7838 register char *fontname;
7839 {
7840 struct font_info *fontp
7841 = FS_LOAD_FONT (f, 0, fontname, -1);
7842
7843 if (!fontp)
7844 return Qnil;
7845
7846 FRAME_FONT (f) = (XFontStruct *) (fontp->font);
7847 FRAME_BASELINE_OFFSET (f) = fontp->baseline_offset;
7848 FRAME_FONTSET (f) = -1;
7849
7850 FRAME_COLUMN_WIDTH (f) = fontp->average_width;
7851 FRAME_SPACE_WIDTH (f) = fontp->space_width;
7852 FRAME_LINE_HEIGHT (f) = FONT_HEIGHT (FRAME_FONT (f));
7853
7854 compute_fringe_widths (f, 1);
7855
7856 /* Compute the scroll bar width in character columns. */
7857 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0)
7858 {
7859 int wid = FRAME_COLUMN_WIDTH (f);
7860 FRAME_CONFIG_SCROLL_BAR_COLS (f)
7861 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) + wid-1) / wid;
7862 }
7863 else
7864 {
7865 int wid = FRAME_COLUMN_WIDTH (f);
7866 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
7867 }
7868
7869 /* Now make the frame display the given font. */
7870 if (FRAME_X_WINDOW (f) != 0)
7871 {
7872 XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc,
7873 FRAME_FONT (f)->fid);
7874 XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->reverse_gc,
7875 FRAME_FONT (f)->fid);
7876 XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->cursor_gc,
7877 FRAME_FONT (f)->fid);
7878
7879 /* Don't change the size of a tip frame; there's no point in
7880 doing it because it's done in Fx_show_tip, and it leads to
7881 problems because the tip frame has no widget. */
7882 if (NILP (tip_frame) || XFRAME (tip_frame) != f)
7883 x_set_window_size (f, 0, FRAME_COLS (f), FRAME_LINES (f));
7884 }
7885
7886 return build_string (fontp->full_name);
7887 }
7888
7889 /* Give frame F the fontset named FONTSETNAME as its default font, and
7890 return the full name of that fontset. FONTSETNAME may be a wildcard
7891 pattern; in that case, we choose some fontset that fits the pattern.
7892 The return value shows which fontset we chose. */
7893
7894 Lisp_Object
7895 x_new_fontset (f, fontsetname)
7896 struct frame *f;
7897 char *fontsetname;
7898 {
7899 int fontset = fs_query_fontset (build_string (fontsetname), 0);
7900 Lisp_Object result;
7901
7902 if (fontset < 0)
7903 return Qnil;
7904
7905 if (FRAME_FONTSET (f) == fontset)
7906 /* This fontset is already set in frame F. There's nothing more
7907 to do. */
7908 return fontset_name (fontset);
7909
7910 result = x_new_font (f, (SDATA (fontset_ascii (fontset))));
7911
7912 if (!STRINGP (result))
7913 /* Can't load ASCII font. */
7914 return Qnil;
7915
7916 /* Since x_new_font doesn't update any fontset information, do it now. */
7917 FRAME_FONTSET (f) = fontset;
7918
7919 #ifdef HAVE_X_I18N
7920 if (FRAME_XIC (f)
7921 && (FRAME_XIC_STYLE (f) & (XIMPreeditPosition | XIMStatusArea)))
7922 xic_set_xfontset (f, SDATA (fontset_ascii (fontset)));
7923 #endif
7924
7925 return build_string (fontsetname);
7926 }
7927
7928 \f
7929 /***********************************************************************
7930 X Input Methods
7931 ***********************************************************************/
7932
7933 #ifdef HAVE_X_I18N
7934
7935 #ifdef HAVE_X11R6
7936
7937 /* XIM destroy callback function, which is called whenever the
7938 connection to input method XIM dies. CLIENT_DATA contains a
7939 pointer to the x_display_info structure corresponding to XIM. */
7940
7941 static void
7942 xim_destroy_callback (xim, client_data, call_data)
7943 XIM xim;
7944 XPointer client_data;
7945 XPointer call_data;
7946 {
7947 struct x_display_info *dpyinfo = (struct x_display_info *) client_data;
7948 Lisp_Object frame, tail;
7949
7950 BLOCK_INPUT;
7951
7952 /* No need to call XDestroyIC.. */
7953 FOR_EACH_FRAME (tail, frame)
7954 {
7955 struct frame *f = XFRAME (frame);
7956 if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
7957 {
7958 FRAME_XIC (f) = NULL;
7959 xic_free_xfontset (f);
7960 }
7961 }
7962
7963 /* No need to call XCloseIM. */
7964 dpyinfo->xim = NULL;
7965 XFree (dpyinfo->xim_styles);
7966 UNBLOCK_INPUT;
7967 }
7968
7969 #endif /* HAVE_X11R6 */
7970
7971 #ifdef HAVE_X11R6
7972 /* This isn't prototyped in OSF 5.0 or 5.1a. */
7973 extern char *XSetIMValues P_ ((XIM, ...));
7974 #endif
7975
7976 /* Open the connection to the XIM server on display DPYINFO.
7977 RESOURCE_NAME is the resource name Emacs uses. */
7978
7979 static void
7980 xim_open_dpy (dpyinfo, resource_name)
7981 struct x_display_info *dpyinfo;
7982 char *resource_name;
7983 {
7984 XIM xim;
7985
7986 #ifdef HAVE_XIM
7987 if (use_xim)
7988 {
7989 xim = XOpenIM (dpyinfo->display, dpyinfo->xrdb, resource_name,
7990 EMACS_CLASS);
7991 dpyinfo->xim = xim;
7992
7993 if (xim)
7994 {
7995 #ifdef HAVE_X11R6
7996 XIMCallback destroy;
7997 #endif
7998
7999 /* Get supported styles and XIM values. */
8000 XGetIMValues (xim, XNQueryInputStyle, &dpyinfo->xim_styles, NULL);
8001
8002 #ifdef HAVE_X11R6
8003 destroy.callback = xim_destroy_callback;
8004 destroy.client_data = (XPointer)dpyinfo;
8005 XSetIMValues (xim, XNDestroyCallback, &destroy, NULL);
8006 #endif
8007 }
8008 }
8009
8010 else
8011 #endif /* HAVE_XIM */
8012 dpyinfo->xim = NULL;
8013 }
8014
8015
8016 #ifdef HAVE_X11R6_XIM
8017
8018 struct xim_inst_t
8019 {
8020 struct x_display_info *dpyinfo;
8021 char *resource_name;
8022 };
8023
8024 /* XIM instantiate callback function, which is called whenever an XIM
8025 server is available. DISPLAY is the display of the XIM.
8026 CLIENT_DATA contains a pointer to an xim_inst_t structure created
8027 when the callback was registered. */
8028
8029 static void
8030 xim_instantiate_callback (display, client_data, call_data)
8031 Display *display;
8032 XPointer client_data;
8033 XPointer call_data;
8034 {
8035 struct xim_inst_t *xim_inst = (struct xim_inst_t *) client_data;
8036 struct x_display_info *dpyinfo = xim_inst->dpyinfo;
8037
8038 /* We don't support multiple XIM connections. */
8039 if (dpyinfo->xim)
8040 return;
8041
8042 xim_open_dpy (dpyinfo, xim_inst->resource_name);
8043
8044 /* Create XIC for the existing frames on the same display, as long
8045 as they have no XIC. */
8046 if (dpyinfo->xim && dpyinfo->reference_count > 0)
8047 {
8048 Lisp_Object tail, frame;
8049
8050 BLOCK_INPUT;
8051 FOR_EACH_FRAME (tail, frame)
8052 {
8053 struct frame *f = XFRAME (frame);
8054
8055 if (FRAME_X_P (f)
8056 && FRAME_X_DISPLAY_INFO (f) == xim_inst->dpyinfo)
8057 if (FRAME_XIC (f) == NULL)
8058 {
8059 create_frame_xic (f);
8060 if (FRAME_XIC_STYLE (f) & XIMStatusArea)
8061 xic_set_statusarea (f);
8062 if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
8063 {
8064 struct window *w = XWINDOW (f->selected_window);
8065 xic_set_preeditarea (w, w->cursor.x, w->cursor.y);
8066 }
8067 }
8068 }
8069
8070 UNBLOCK_INPUT;
8071 }
8072 }
8073
8074 #endif /* HAVE_X11R6_XIM */
8075
8076
8077 /* Open a connection to the XIM server on display DPYINFO.
8078 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8079 connection only at the first time. On X11R6, open the connection
8080 in the XIM instantiate callback function. */
8081
8082 static void
8083 xim_initialize (dpyinfo, resource_name)
8084 struct x_display_info *dpyinfo;
8085 char *resource_name;
8086 {
8087 #ifdef HAVE_XIM
8088 if (use_xim)
8089 {
8090 #ifdef HAVE_X11R6_XIM
8091 struct xim_inst_t *xim_inst;
8092 int len;
8093
8094 dpyinfo->xim = NULL;
8095 xim_inst = (struct xim_inst_t *) xmalloc (sizeof (struct xim_inst_t));
8096 xim_inst->dpyinfo = dpyinfo;
8097 len = strlen (resource_name);
8098 xim_inst->resource_name = (char *) xmalloc (len + 1);
8099 bcopy (resource_name, xim_inst->resource_name, len + 1);
8100 XRegisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
8101 resource_name, EMACS_CLASS,
8102 xim_instantiate_callback,
8103 /* This is XPointer in XFree86
8104 but (XPointer *) on Tru64, at
8105 least, hence the configure test. */
8106 (XRegisterIMInstantiateCallback_arg6) xim_inst);
8107 #else /* not HAVE_X11R6_XIM */
8108 dpyinfo->xim = NULL;
8109 xim_open_dpy (dpyinfo, resource_name);
8110 #endif /* not HAVE_X11R6_XIM */
8111
8112 }
8113 else
8114 #endif /* HAVE_XIM */
8115 dpyinfo->xim = NULL;
8116 }
8117
8118
8119 /* Close the connection to the XIM server on display DPYINFO. */
8120
8121 static void
8122 xim_close_dpy (dpyinfo)
8123 struct x_display_info *dpyinfo;
8124 {
8125 #ifdef HAVE_XIM
8126 if (use_xim)
8127 {
8128 #ifdef HAVE_X11R6_XIM
8129 if (dpyinfo->display)
8130 XUnregisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
8131 NULL, EMACS_CLASS,
8132 xim_instantiate_callback, NULL);
8133 #endif /* not HAVE_X11R6_XIM */
8134 if (dpyinfo->display)
8135 XCloseIM (dpyinfo->xim);
8136 dpyinfo->xim = NULL;
8137 XFree (dpyinfo->xim_styles);
8138 }
8139 #endif /* HAVE_XIM */
8140 }
8141
8142 #endif /* not HAVE_X11R6_XIM */
8143
8144
8145 \f
8146 /* Calculate the absolute position in frame F
8147 from its current recorded position values and gravity. */
8148
8149 void
8150 x_calc_absolute_position (f)
8151 struct frame *f;
8152 {
8153 int flags = f->size_hint_flags;
8154
8155 /* We have nothing to do if the current position
8156 is already for the top-left corner. */
8157 if (! ((flags & XNegative) || (flags & YNegative)))
8158 return;
8159
8160 /* Treat negative positions as relative to the leftmost bottommost
8161 position that fits on the screen. */
8162 if (flags & XNegative)
8163 f->left_pos = (FRAME_X_DISPLAY_INFO (f)->width
8164 - FRAME_PIXEL_WIDTH (f) + f->left_pos);
8165
8166 {
8167 int height = FRAME_PIXEL_HEIGHT (f);
8168
8169 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8170 /* Something is fishy here. When using Motif, starting Emacs with
8171 `-g -0-0', the frame appears too low by a few pixels.
8172
8173 This seems to be so because initially, while Emacs is starting,
8174 the column widget's height and the frame's pixel height are
8175 different. The column widget's height is the right one. In
8176 later invocations, when Emacs is up, the frame's pixel height
8177 is right, though.
8178
8179 It's not obvious where the initial small difference comes from.
8180 2000-12-01, gerd. */
8181
8182 XtVaGetValues (f->output_data.x->column_widget, XtNheight, &height, NULL);
8183 #endif
8184
8185 if (flags & YNegative)
8186 f->top_pos = (FRAME_X_DISPLAY_INFO (f)->height - height + f->top_pos);
8187 }
8188
8189 /* The left_pos and top_pos
8190 are now relative to the top and left screen edges,
8191 so the flags should correspond. */
8192 f->size_hint_flags &= ~ (XNegative | YNegative);
8193 }
8194
8195 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8196 to really change the position, and 0 when calling from
8197 x_make_frame_visible (in that case, XOFF and YOFF are the current
8198 position values). It is -1 when calling from x_set_frame_parameters,
8199 which means, do adjust for borders but don't change the gravity. */
8200
8201 void
8202 x_set_offset (f, xoff, yoff, change_gravity)
8203 struct frame *f;
8204 register int xoff, yoff;
8205 int change_gravity;
8206 {
8207 int modified_top, modified_left;
8208
8209 if (change_gravity > 0)
8210 {
8211 f->top_pos = yoff;
8212 f->left_pos = xoff;
8213 f->size_hint_flags &= ~ (XNegative | YNegative);
8214 if (xoff < 0)
8215 f->size_hint_flags |= XNegative;
8216 if (yoff < 0)
8217 f->size_hint_flags |= YNegative;
8218 f->win_gravity = NorthWestGravity;
8219 }
8220 x_calc_absolute_position (f);
8221
8222 BLOCK_INPUT;
8223 x_wm_set_size_hint (f, (long) 0, 0);
8224
8225 modified_left = f->left_pos;
8226 modified_top = f->top_pos;
8227
8228 if (FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_A)
8229 {
8230 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8231 than the WM decorations. So we use the calculated offset instead
8232 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8233 modified_left += FRAME_X_OUTPUT (f)->move_offset_left;
8234 modified_top += FRAME_X_OUTPUT (f)->move_offset_top;
8235 }
8236
8237 XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
8238 modified_left, modified_top);
8239
8240 if (FRAME_VISIBLE_P (f)
8241 && FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_UNKNOWN)
8242 {
8243 FRAME_X_OUTPUT (f)->check_expected_move = 1;
8244 FRAME_X_OUTPUT (f)->expected_top = f->top_pos;
8245 FRAME_X_OUTPUT (f)->expected_left = f->left_pos;
8246 }
8247
8248 UNBLOCK_INPUT;
8249 }
8250
8251 /* Check if we need to resize the frame due to a fullscreen request.
8252 If so needed, resize the frame. */
8253 static void
8254 x_check_fullscreen (f)
8255 struct frame *f;
8256 {
8257 if (f->want_fullscreen & FULLSCREEN_BOTH)
8258 {
8259 int width, height, ign;
8260
8261 x_real_positions (f, &f->left_pos, &f->top_pos);
8262
8263 x_fullscreen_adjust (f, &width, &height, &ign, &ign);
8264
8265 /* We do not need to move the window, it shall be taken care of
8266 when setting WM manager hints.
8267 If the frame is visible already, the position is checked by
8268 x_check_expected_move. */
8269 if (FRAME_COLS (f) != width || FRAME_LINES (f) != height)
8270 {
8271 change_frame_size (f, height, width, 0, 1, 0);
8272 SET_FRAME_GARBAGED (f);
8273 cancel_mouse_face (f);
8274
8275 /* Wait for the change of frame size to occur */
8276 f->want_fullscreen |= FULLSCREEN_WAIT;
8277 }
8278 }
8279 }
8280
8281 /* If frame parameters are set after the frame is mapped, we need to move
8282 the window.
8283 Some window managers moves the window to the right position, some
8284 moves the outer window manager window to the specified position.
8285 Here we check that we are in the right spot. If not, make a second
8286 move, assuming we are dealing with the second kind of window manager. */
8287 static void
8288 x_check_expected_move (f)
8289 struct frame *f;
8290 {
8291 if (FRAME_X_OUTPUT (f)->check_expected_move)
8292 {
8293 int expect_top = FRAME_X_OUTPUT (f)->expected_top;
8294 int expect_left = FRAME_X_OUTPUT (f)->expected_left;
8295
8296 if (expect_top != f->top_pos || expect_left != f->left_pos)
8297 {
8298 FRAME_X_DISPLAY_INFO (f)->wm_type = X_WMTYPE_A;
8299 FRAME_X_OUTPUT (f)->move_offset_left = expect_left - f->left_pos;
8300 FRAME_X_OUTPUT (f)->move_offset_top = expect_top - f->top_pos;
8301
8302 f->left_pos = expect_left;
8303 f->top_pos = expect_top;
8304 x_set_offset (f, expect_left, expect_top, 0);
8305 }
8306 else if (FRAME_X_DISPLAY_INFO (f)->wm_type == X_WMTYPE_UNKNOWN)
8307 FRAME_X_DISPLAY_INFO (f)->wm_type = X_WMTYPE_B;
8308
8309 /* Just do this once */
8310 FRAME_X_OUTPUT (f)->check_expected_move = 0;
8311 }
8312 }
8313
8314
8315 /* Change the size of frame F's X window to COLS/ROWS in the case F
8316 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8317 top-left-corner window gravity for this size change and subsequent
8318 size changes. Otherwise we leave the window gravity unchanged. */
8319
8320 static void
8321 x_set_window_size_1 (f, change_gravity, cols, rows)
8322 struct frame *f;
8323 int change_gravity;
8324 int cols, rows;
8325 {
8326 int pixelwidth, pixelheight;
8327
8328 check_frame_size (f, &rows, &cols);
8329 f->scroll_bar_actual_width
8330 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f)
8331 ? 0
8332 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f) > 0
8333 ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f)
8334 : (FRAME_CONFIG_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f)));
8335
8336 compute_fringe_widths (f, 0);
8337
8338 pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols);
8339 pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
8340
8341 f->win_gravity = NorthWestGravity;
8342 x_wm_set_size_hint (f, (long) 0, 0);
8343
8344 XSync (FRAME_X_DISPLAY (f), False);
8345 XResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8346 pixelwidth, pixelheight);
8347
8348 /* Now, strictly speaking, we can't be sure that this is accurate,
8349 but the window manager will get around to dealing with the size
8350 change request eventually, and we'll hear how it went when the
8351 ConfigureNotify event gets here.
8352
8353 We could just not bother storing any of this information here,
8354 and let the ConfigureNotify event set everything up, but that
8355 might be kind of confusing to the Lisp code, since size changes
8356 wouldn't be reported in the frame parameters until some random
8357 point in the future when the ConfigureNotify event arrives.
8358
8359 We pass 1 for DELAY since we can't run Lisp code inside of
8360 a BLOCK_INPUT. */
8361 change_frame_size (f, rows, cols, 0, 1, 0);
8362 FRAME_PIXEL_WIDTH (f) = pixelwidth;
8363 FRAME_PIXEL_HEIGHT (f) = pixelheight;
8364
8365 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8366 receive in the ConfigureNotify event; if we get what we asked
8367 for, then the event won't cause the screen to become garbaged, so
8368 we have to make sure to do it here. */
8369 SET_FRAME_GARBAGED (f);
8370
8371 XFlush (FRAME_X_DISPLAY (f));
8372 }
8373
8374
8375 /* Call this to change the size of frame F's x-window.
8376 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8377 for this size change and subsequent size changes.
8378 Otherwise we leave the window gravity unchanged. */
8379
8380 void
8381 x_set_window_size (f, change_gravity, cols, rows)
8382 struct frame *f;
8383 int change_gravity;
8384 int cols, rows;
8385 {
8386 BLOCK_INPUT;
8387
8388 #ifdef USE_GTK
8389 if (FRAME_GTK_WIDGET (f))
8390 xg_frame_set_char_size (f, cols, rows);
8391 else
8392 x_set_window_size_1 (f, change_gravity, cols, rows);
8393 #elif USE_X_TOOLKIT
8394
8395 if (f->output_data.x->widget != NULL)
8396 {
8397 /* The x and y position of the widget is clobbered by the
8398 call to XtSetValues within EmacsFrameSetCharSize.
8399 This is a real kludge, but I don't understand Xt so I can't
8400 figure out a correct fix. Can anyone else tell me? -- rms. */
8401 int xpos = f->output_data.x->widget->core.x;
8402 int ypos = f->output_data.x->widget->core.y;
8403 EmacsFrameSetCharSize (f->output_data.x->edit_widget, cols, rows);
8404 f->output_data.x->widget->core.x = xpos;
8405 f->output_data.x->widget->core.y = ypos;
8406 }
8407 else
8408 x_set_window_size_1 (f, change_gravity, cols, rows);
8409
8410 #else /* not USE_X_TOOLKIT */
8411
8412 x_set_window_size_1 (f, change_gravity, cols, rows);
8413
8414 #endif /* not USE_X_TOOLKIT */
8415
8416 /* If cursor was outside the new size, mark it as off. */
8417 mark_window_cursors_off (XWINDOW (f->root_window));
8418
8419 /* Clear out any recollection of where the mouse highlighting was,
8420 since it might be in a place that's outside the new frame size.
8421 Actually checking whether it is outside is a pain in the neck,
8422 so don't try--just let the highlighting be done afresh with new size. */
8423 cancel_mouse_face (f);
8424
8425 UNBLOCK_INPUT;
8426 }
8427 \f
8428 /* Mouse warping. */
8429
8430 void
8431 x_set_mouse_position (f, x, y)
8432 struct frame *f;
8433 int x, y;
8434 {
8435 int pix_x, pix_y;
8436
8437 pix_x = FRAME_COL_TO_PIXEL_X (f, x) + FRAME_COLUMN_WIDTH (f) / 2;
8438 pix_y = FRAME_LINE_TO_PIXEL_Y (f, y) + FRAME_LINE_HEIGHT (f) / 2;
8439
8440 if (pix_x < 0) pix_x = 0;
8441 if (pix_x > FRAME_PIXEL_WIDTH (f)) pix_x = FRAME_PIXEL_WIDTH (f);
8442
8443 if (pix_y < 0) pix_y = 0;
8444 if (pix_y > FRAME_PIXEL_HEIGHT (f)) pix_y = FRAME_PIXEL_HEIGHT (f);
8445
8446 BLOCK_INPUT;
8447
8448 XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
8449 0, 0, 0, 0, pix_x, pix_y);
8450 UNBLOCK_INPUT;
8451 }
8452
8453 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8454
8455 void
8456 x_set_mouse_pixel_position (f, pix_x, pix_y)
8457 struct frame *f;
8458 int pix_x, pix_y;
8459 {
8460 BLOCK_INPUT;
8461
8462 XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
8463 0, 0, 0, 0, pix_x, pix_y);
8464 UNBLOCK_INPUT;
8465 }
8466 \f
8467 /* focus shifting, raising and lowering. */
8468
8469 void
8470 x_focus_on_frame (f)
8471 struct frame *f;
8472 {
8473 #if 0 /* This proves to be unpleasant. */
8474 x_raise_frame (f);
8475 #endif
8476 #if 0
8477 /* I don't think that the ICCCM allows programs to do things like this
8478 without the interaction of the window manager. Whatever you end up
8479 doing with this code, do it to x_unfocus_frame too. */
8480 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8481 RevertToPointerRoot, CurrentTime);
8482 #endif /* ! 0 */
8483 }
8484
8485 void
8486 x_unfocus_frame (f)
8487 struct frame *f;
8488 {
8489 #if 0
8490 /* Look at the remarks in x_focus_on_frame. */
8491 if (FRAME_X_DISPLAY_INFO (f)->x_focus_frame == f)
8492 XSetInputFocus (FRAME_X_DISPLAY (f), PointerRoot,
8493 RevertToPointerRoot, CurrentTime);
8494 #endif /* ! 0 */
8495 }
8496
8497 /* Raise frame F. */
8498
8499 void
8500 x_raise_frame (f)
8501 struct frame *f;
8502 {
8503 if (f->async_visible)
8504 {
8505 BLOCK_INPUT;
8506 XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
8507 XFlush (FRAME_X_DISPLAY (f));
8508 UNBLOCK_INPUT;
8509 }
8510 }
8511
8512 /* Lower frame F. */
8513
8514 void
8515 x_lower_frame (f)
8516 struct frame *f;
8517 {
8518 if (f->async_visible)
8519 {
8520 BLOCK_INPUT;
8521 XLowerWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
8522 XFlush (FRAME_X_DISPLAY (f));
8523 UNBLOCK_INPUT;
8524 }
8525 }
8526
8527 static void
8528 XTframe_raise_lower (f, raise_flag)
8529 FRAME_PTR f;
8530 int raise_flag;
8531 {
8532 if (raise_flag)
8533 x_raise_frame (f);
8534 else
8535 x_lower_frame (f);
8536 }
8537 \f
8538 /* Change of visibility. */
8539
8540 /* This tries to wait until the frame is really visible.
8541 However, if the window manager asks the user where to position
8542 the frame, this will return before the user finishes doing that.
8543 The frame will not actually be visible at that time,
8544 but it will become visible later when the window manager
8545 finishes with it. */
8546
8547 void
8548 x_make_frame_visible (f)
8549 struct frame *f;
8550 {
8551 Lisp_Object type;
8552 int original_top, original_left;
8553 int retry_count = 2;
8554
8555 retry:
8556
8557 BLOCK_INPUT;
8558
8559 type = x_icon_type (f);
8560 if (!NILP (type))
8561 x_bitmap_icon (f, type);
8562
8563 if (! FRAME_VISIBLE_P (f))
8564 {
8565 /* We test FRAME_GARBAGED_P here to make sure we don't
8566 call x_set_offset a second time
8567 if we get to x_make_frame_visible a second time
8568 before the window gets really visible. */
8569 if (! FRAME_ICONIFIED_P (f)
8570 && ! f->output_data.x->asked_for_visible)
8571 x_set_offset (f, f->left_pos, f->top_pos, 0);
8572
8573 f->output_data.x->asked_for_visible = 1;
8574
8575 if (! EQ (Vx_no_window_manager, Qt))
8576 x_wm_set_window_state (f, NormalState);
8577 #ifdef USE_X_TOOLKIT
8578 /* This was XtPopup, but that did nothing for an iconified frame. */
8579 XtMapWidget (f->output_data.x->widget);
8580 #else /* not USE_X_TOOLKIT */
8581 #ifdef USE_GTK
8582 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f));
8583 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
8584 #else
8585 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
8586 #endif /* not USE_GTK */
8587 #endif /* not USE_X_TOOLKIT */
8588 #if 0 /* This seems to bring back scroll bars in the wrong places
8589 if the window configuration has changed. They seem
8590 to come back ok without this. */
8591 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
8592 XMapSubwindows (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
8593 #endif
8594 }
8595
8596 XFlush (FRAME_X_DISPLAY (f));
8597
8598 /* Synchronize to ensure Emacs knows the frame is visible
8599 before we do anything else. We do this loop with input not blocked
8600 so that incoming events are handled. */
8601 {
8602 Lisp_Object frame;
8603 int count;
8604 /* This must be before UNBLOCK_INPUT
8605 since events that arrive in response to the actions above
8606 will set it when they are handled. */
8607 int previously_visible = f->output_data.x->has_been_visible;
8608
8609 original_left = f->left_pos;
8610 original_top = f->top_pos;
8611
8612 /* This must come after we set COUNT. */
8613 UNBLOCK_INPUT;
8614
8615 /* We unblock here so that arriving X events are processed. */
8616
8617 /* Now move the window back to where it was "supposed to be".
8618 But don't do it if the gravity is negative.
8619 When the gravity is negative, this uses a position
8620 that is 3 pixels too low. Perhaps that's really the border width.
8621
8622 Don't do this if the window has never been visible before,
8623 because the window manager may choose the position
8624 and we don't want to override it. */
8625
8626 if (! FRAME_VISIBLE_P (f) && ! FRAME_ICONIFIED_P (f)
8627 && f->win_gravity == NorthWestGravity
8628 && previously_visible)
8629 {
8630 Drawable rootw;
8631 int x, y;
8632 unsigned int width, height, border, depth;
8633
8634 BLOCK_INPUT;
8635
8636 /* On some window managers (such as FVWM) moving an existing
8637 window, even to the same place, causes the window manager
8638 to introduce an offset. This can cause the window to move
8639 to an unexpected location. Check the geometry (a little
8640 slow here) and then verify that the window is in the right
8641 place. If the window is not in the right place, move it
8642 there, and take the potential window manager hit. */
8643 XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
8644 &rootw, &x, &y, &width, &height, &border, &depth);
8645
8646 if (original_left != x || original_top != y)
8647 XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
8648 original_left, original_top);
8649
8650 UNBLOCK_INPUT;
8651 }
8652
8653 XSETFRAME (frame, f);
8654
8655 /* Wait until the frame is visible. Process X events until a
8656 MapNotify event has been seen, or until we think we won't get a
8657 MapNotify at all.. */
8658 for (count = input_signal_count + 10;
8659 input_signal_count < count && !FRAME_VISIBLE_P (f);)
8660 {
8661 /* Force processing of queued events. */
8662 x_sync (f);
8663
8664 /* Machines that do polling rather than SIGIO have been
8665 observed to go into a busy-wait here. So we'll fake an
8666 alarm signal to let the handler know that there's something
8667 to be read. We used to raise a real alarm, but it seems
8668 that the handler isn't always enabled here. This is
8669 probably a bug. */
8670 if (input_polling_used ())
8671 {
8672 /* It could be confusing if a real alarm arrives while
8673 processing the fake one. Turn it off and let the
8674 handler reset it. */
8675 extern void poll_for_input_1 P_ ((void));
8676 int old_poll_suppress_count = poll_suppress_count;
8677 poll_suppress_count = 1;
8678 poll_for_input_1 ();
8679 poll_suppress_count = old_poll_suppress_count;
8680 }
8681
8682 /* See if a MapNotify event has been processed. */
8683 FRAME_SAMPLE_VISIBILITY (f);
8684 }
8685
8686 /* 2000-09-28: In
8687
8688 (let ((f (selected-frame)))
8689 (iconify-frame f)
8690 (raise-frame f))
8691
8692 the frame is not raised with various window managers on
8693 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
8694 unknown reason, the call to XtMapWidget is completely ignored.
8695 Mapping the widget a second time works. */
8696
8697 if (!FRAME_VISIBLE_P (f) && --retry_count > 0)
8698 goto retry;
8699 }
8700 }
8701
8702 /* Change from mapped state to withdrawn state. */
8703
8704 /* Make the frame visible (mapped and not iconified). */
8705
8706 void
8707 x_make_frame_invisible (f)
8708 struct frame *f;
8709 {
8710 Window window;
8711
8712 /* Use the frame's outermost window, not the one we normally draw on. */
8713 window = FRAME_OUTER_WINDOW (f);
8714
8715 /* Don't keep the highlight on an invisible frame. */
8716 if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
8717 FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
8718
8719 #if 0/* This might add unreliability; I don't trust it -- rms. */
8720 if (! f->async_visible && ! f->async_iconified)
8721 return;
8722 #endif
8723
8724 BLOCK_INPUT;
8725
8726 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
8727 that the current position of the window is user-specified, rather than
8728 program-specified, so that when the window is mapped again, it will be
8729 placed at the same location, without forcing the user to position it
8730 by hand again (they have already done that once for this window.) */
8731 x_wm_set_size_hint (f, (long) 0, 1);
8732
8733 #ifdef USE_GTK
8734 if (FRAME_GTK_OUTER_WIDGET (f))
8735 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f));
8736 else
8737 #endif
8738 {
8739 #ifdef HAVE_X11R4
8740
8741 if (! XWithdrawWindow (FRAME_X_DISPLAY (f), window,
8742 DefaultScreen (FRAME_X_DISPLAY (f))))
8743 {
8744 UNBLOCK_INPUT_RESIGNAL;
8745 error ("Can't notify window manager of window withdrawal");
8746 }
8747 #else /* ! defined (HAVE_X11R4) */
8748
8749 /* Tell the window manager what we're going to do. */
8750 if (! EQ (Vx_no_window_manager, Qt))
8751 {
8752 XEvent unmap;
8753
8754 unmap.xunmap.type = UnmapNotify;
8755 unmap.xunmap.window = window;
8756 unmap.xunmap.event = DefaultRootWindow (FRAME_X_DISPLAY (f));
8757 unmap.xunmap.from_configure = False;
8758 if (! XSendEvent (FRAME_X_DISPLAY (f),
8759 DefaultRootWindow (FRAME_X_DISPLAY (f)),
8760 False,
8761 SubstructureRedirectMaskSubstructureNotifyMask,
8762 &unmap))
8763 {
8764 UNBLOCK_INPUT_RESIGNAL;
8765 error ("Can't notify window manager of withdrawal");
8766 }
8767 }
8768
8769 /* Unmap the window ourselves. Cheeky! */
8770 XUnmapWindow (FRAME_X_DISPLAY (f), window);
8771 #endif /* ! defined (HAVE_X11R4) */
8772 }
8773
8774 /* We can't distinguish this from iconification
8775 just by the event that we get from the server.
8776 So we can't win using the usual strategy of letting
8777 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
8778 and synchronize with the server to make sure we agree. */
8779 f->visible = 0;
8780 FRAME_ICONIFIED_P (f) = 0;
8781 f->async_visible = 0;
8782 f->async_iconified = 0;
8783
8784 x_sync (f);
8785
8786 UNBLOCK_INPUT;
8787 }
8788
8789 /* Change window state from mapped to iconified. */
8790
8791 void
8792 x_iconify_frame (f)
8793 struct frame *f;
8794 {
8795 int result;
8796 Lisp_Object type;
8797
8798 /* Don't keep the highlight on an invisible frame. */
8799 if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
8800 FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
8801
8802 if (f->async_iconified)
8803 return;
8804
8805 BLOCK_INPUT;
8806
8807 FRAME_SAMPLE_VISIBILITY (f);
8808
8809 type = x_icon_type (f);
8810 if (!NILP (type))
8811 x_bitmap_icon (f, type);
8812
8813 #ifdef USE_GTK
8814 if (FRAME_GTK_OUTER_WIDGET (f))
8815 {
8816 if (! FRAME_VISIBLE_P (f))
8817 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f));
8818
8819 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
8820 f->iconified = 1;
8821 f->visible = 1;
8822 f->async_iconified = 1;
8823 f->async_visible = 0;
8824 UNBLOCK_INPUT;
8825 return;
8826 }
8827 #endif
8828
8829 #ifdef USE_X_TOOLKIT
8830
8831 if (! FRAME_VISIBLE_P (f))
8832 {
8833 if (! EQ (Vx_no_window_manager, Qt))
8834 x_wm_set_window_state (f, IconicState);
8835 /* This was XtPopup, but that did nothing for an iconified frame. */
8836 XtMapWidget (f->output_data.x->widget);
8837 /* The server won't give us any event to indicate
8838 that an invisible frame was changed to an icon,
8839 so we have to record it here. */
8840 f->iconified = 1;
8841 f->visible = 1;
8842 f->async_iconified = 1;
8843 f->async_visible = 0;
8844 UNBLOCK_INPUT;
8845 return;
8846 }
8847
8848 result = XIconifyWindow (FRAME_X_DISPLAY (f),
8849 XtWindow (f->output_data.x->widget),
8850 DefaultScreen (FRAME_X_DISPLAY (f)));
8851 UNBLOCK_INPUT;
8852
8853 if (!result)
8854 error ("Can't notify window manager of iconification");
8855
8856 f->async_iconified = 1;
8857 f->async_visible = 0;
8858
8859
8860 BLOCK_INPUT;
8861 XFlush (FRAME_X_DISPLAY (f));
8862 UNBLOCK_INPUT;
8863 #else /* not USE_X_TOOLKIT */
8864
8865 /* Make sure the X server knows where the window should be positioned,
8866 in case the user deiconifies with the window manager. */
8867 if (! FRAME_VISIBLE_P (f) && !FRAME_ICONIFIED_P (f))
8868 x_set_offset (f, f->left_pos, f->top_pos, 0);
8869
8870 /* Since we don't know which revision of X we're running, we'll use both
8871 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
8872
8873 /* X11R4: send a ClientMessage to the window manager using the
8874 WM_CHANGE_STATE type. */
8875 {
8876 XEvent message;
8877
8878 message.xclient.window = FRAME_X_WINDOW (f);
8879 message.xclient.type = ClientMessage;
8880 message.xclient.message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_change_state;
8881 message.xclient.format = 32;
8882 message.xclient.data.l[0] = IconicState;
8883
8884 if (! XSendEvent (FRAME_X_DISPLAY (f),
8885 DefaultRootWindow (FRAME_X_DISPLAY (f)),
8886 False,
8887 SubstructureRedirectMask | SubstructureNotifyMask,
8888 &message))
8889 {
8890 UNBLOCK_INPUT_RESIGNAL;
8891 error ("Can't notify window manager of iconification");
8892 }
8893 }
8894
8895 /* X11R3: set the initial_state field of the window manager hints to
8896 IconicState. */
8897 x_wm_set_window_state (f, IconicState);
8898
8899 if (!FRAME_VISIBLE_P (f))
8900 {
8901 /* If the frame was withdrawn, before, we must map it. */
8902 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
8903 }
8904
8905 f->async_iconified = 1;
8906 f->async_visible = 0;
8907
8908 XFlush (FRAME_X_DISPLAY (f));
8909 UNBLOCK_INPUT;
8910 #endif /* not USE_X_TOOLKIT */
8911 }
8912
8913 \f
8914 /* Free X resources of frame F. */
8915
8916 void
8917 x_free_frame_resources (f)
8918 struct frame *f;
8919 {
8920 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
8921 Lisp_Object bar;
8922 struct scroll_bar *b;
8923
8924 BLOCK_INPUT;
8925
8926 /* If a display connection is dead, don't try sending more
8927 commands to the X server. */
8928 if (dpyinfo->display)
8929 {
8930 if (f->output_data.x->icon_desc)
8931 XDestroyWindow (FRAME_X_DISPLAY (f), f->output_data.x->icon_desc);
8932
8933 #ifdef USE_X_TOOLKIT
8934 /* Explicitly destroy the scroll bars of the frame. Without
8935 this, we get "BadDrawable" errors from the toolkit later on,
8936 presumably from expose events generated for the disappearing
8937 toolkit scroll bars. */
8938 for (bar = FRAME_SCROLL_BARS (f); !NILP (bar); bar = b->next)
8939 {
8940 b = XSCROLL_BAR (bar);
8941 x_scroll_bar_remove (b);
8942 }
8943 #endif
8944
8945 #ifdef HAVE_X_I18N
8946 if (FRAME_XIC (f))
8947 free_frame_xic (f);
8948 #endif
8949
8950 #ifdef USE_X_TOOLKIT
8951 if (f->output_data.x->widget)
8952 {
8953 XtDestroyWidget (f->output_data.x->widget);
8954 f->output_data.x->widget = NULL;
8955 }
8956 /* Tooltips don't have widgets, only a simple X window, even if
8957 we are using a toolkit. */
8958 else if (FRAME_X_WINDOW (f))
8959 XDestroyWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
8960
8961 free_frame_menubar (f);
8962 #else /* !USE_X_TOOLKIT */
8963
8964 #ifdef USE_GTK
8965 /* In the GTK version, tooltips are normal X
8966 frames. We must check and free both types. */
8967 if (FRAME_GTK_OUTER_WIDGET (f))
8968 {
8969 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f));
8970 FRAME_X_WINDOW (f) = 0; /* Set to avoid XDestroyWindow below */
8971 FRAME_GTK_OUTER_WIDGET (f) = 0;
8972 }
8973 #endif /* USE_GTK */
8974
8975 if (FRAME_X_WINDOW (f))
8976 XDestroyWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
8977 #endif /* !USE_X_TOOLKIT */
8978
8979 unload_color (f, f->output_data.x->foreground_pixel);
8980 unload_color (f, f->output_data.x->background_pixel);
8981 unload_color (f, f->output_data.x->cursor_pixel);
8982 unload_color (f, f->output_data.x->cursor_foreground_pixel);
8983 unload_color (f, f->output_data.x->border_pixel);
8984 unload_color (f, f->output_data.x->mouse_pixel);
8985
8986 if (f->output_data.x->scroll_bar_background_pixel != -1)
8987 unload_color (f, f->output_data.x->scroll_bar_background_pixel);
8988 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
8989 unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
8990 #ifdef USE_TOOLKIT_SCROLL_BARS
8991 /* Scrollbar shadow colors. */
8992 if (f->output_data.x->scroll_bar_top_shadow_pixel != -1)
8993 unload_color (f, f->output_data.x->scroll_bar_top_shadow_pixel);
8994 if (f->output_data.x->scroll_bar_bottom_shadow_pixel != -1)
8995 unload_color (f, f->output_data.x->scroll_bar_bottom_shadow_pixel);
8996 #endif /* USE_TOOLKIT_SCROLL_BARS */
8997 if (f->output_data.x->white_relief.allocated_p)
8998 unload_color (f, f->output_data.x->white_relief.pixel);
8999 if (f->output_data.x->black_relief.allocated_p)
9000 unload_color (f, f->output_data.x->black_relief.pixel);
9001
9002 if (FRAME_FACE_CACHE (f))
9003 free_frame_faces (f);
9004
9005 x_free_gcs (f);
9006 XFlush (FRAME_X_DISPLAY (f));
9007 }
9008
9009 if (f->output_data.x->saved_menu_event)
9010 xfree (f->output_data.x->saved_menu_event);
9011
9012 xfree (f->output_data.x);
9013 f->output_data.x = NULL;
9014
9015 if (f == dpyinfo->x_focus_frame)
9016 dpyinfo->x_focus_frame = 0;
9017 if (f == dpyinfo->x_focus_event_frame)
9018 dpyinfo->x_focus_event_frame = 0;
9019 if (f == dpyinfo->x_highlight_frame)
9020 dpyinfo->x_highlight_frame = 0;
9021
9022 if (f == dpyinfo->mouse_face_mouse_frame)
9023 {
9024 dpyinfo->mouse_face_beg_row
9025 = dpyinfo->mouse_face_beg_col = -1;
9026 dpyinfo->mouse_face_end_row
9027 = dpyinfo->mouse_face_end_col = -1;
9028 dpyinfo->mouse_face_window = Qnil;
9029 dpyinfo->mouse_face_deferred_gc = 0;
9030 dpyinfo->mouse_face_mouse_frame = 0;
9031 }
9032
9033 UNBLOCK_INPUT;
9034 }
9035
9036
9037 /* Destroy the X window of frame F. */
9038
9039 void
9040 x_destroy_window (f)
9041 struct frame *f;
9042 {
9043 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
9044
9045 /* If a display connection is dead, don't try sending more
9046 commands to the X server. */
9047 if (dpyinfo->display != 0)
9048 x_free_frame_resources (f);
9049
9050 dpyinfo->reference_count--;
9051 }
9052
9053 \f
9054 /* Setting window manager hints. */
9055
9056 /* Set the normal size hints for the window manager, for frame F.
9057 FLAGS is the flags word to use--or 0 meaning preserve the flags
9058 that the window now has.
9059 If USER_POSITION is nonzero, we set the USPosition
9060 flag (this is useful when FLAGS is 0).
9061 The GTK version is in gtkutils.c */
9062
9063 #ifndef USE_GTK
9064 void
9065 x_wm_set_size_hint (f, flags, user_position)
9066 struct frame *f;
9067 long flags;
9068 int user_position;
9069 {
9070 XSizeHints size_hints;
9071
9072 #ifdef USE_X_TOOLKIT
9073 Arg al[2];
9074 int ac = 0;
9075 Dimension widget_width, widget_height;
9076 #endif
9077
9078 Window window = FRAME_OUTER_WINDOW (f);
9079
9080 /* Setting PMaxSize caused various problems. */
9081 size_hints.flags = PResizeInc | PMinSize /* | PMaxSize */;
9082
9083 size_hints.x = f->left_pos;
9084 size_hints.y = f->top_pos;
9085
9086 #ifdef USE_X_TOOLKIT
9087 XtSetArg (al[ac], XtNwidth, &widget_width); ac++;
9088 XtSetArg (al[ac], XtNheight, &widget_height); ac++;
9089 XtGetValues (f->output_data.x->widget, al, ac);
9090 size_hints.height = widget_height;
9091 size_hints.width = widget_width;
9092 #else /* not USE_X_TOOLKIT */
9093 size_hints.height = FRAME_PIXEL_HEIGHT (f);
9094 size_hints.width = FRAME_PIXEL_WIDTH (f);
9095 #endif /* not USE_X_TOOLKIT */
9096
9097 size_hints.width_inc = FRAME_COLUMN_WIDTH (f);
9098 size_hints.height_inc = FRAME_LINE_HEIGHT (f);
9099 size_hints.max_width
9100 = FRAME_X_DISPLAY_INFO (f)->width - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0);
9101 size_hints.max_height
9102 = FRAME_X_DISPLAY_INFO (f)->height - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 0);
9103
9104 /* Calculate the base and minimum sizes.
9105
9106 (When we use the X toolkit, we don't do it here.
9107 Instead we copy the values that the widgets are using, below.) */
9108 #ifndef USE_X_TOOLKIT
9109 {
9110 int base_width, base_height;
9111 int min_rows = 0, min_cols = 0;
9112
9113 base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0);
9114 base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 0);
9115
9116 check_frame_size (f, &min_rows, &min_cols);
9117
9118 /* The window manager uses the base width hints to calculate the
9119 current number of rows and columns in the frame while
9120 resizing; min_width and min_height aren't useful for this
9121 purpose, since they might not give the dimensions for a
9122 zero-row, zero-column frame.
9123
9124 We use the base_width and base_height members if we have
9125 them; otherwise, we set the min_width and min_height members
9126 to the size for a zero x zero frame. */
9127
9128 #ifdef HAVE_X11R4
9129 size_hints.flags |= PBaseSize;
9130 size_hints.base_width = base_width;
9131 size_hints.base_height = base_height;
9132 size_hints.min_width = base_width + min_cols * size_hints.width_inc;
9133 size_hints.min_height = base_height + min_rows * size_hints.height_inc;
9134 #else
9135 size_hints.min_width = base_width;
9136 size_hints.min_height = base_height;
9137 #endif
9138 }
9139
9140 /* If we don't need the old flags, we don't need the old hint at all. */
9141 if (flags)
9142 {
9143 size_hints.flags |= flags;
9144 goto no_read;
9145 }
9146 #endif /* not USE_X_TOOLKIT */
9147
9148 {
9149 XSizeHints hints; /* Sometimes I hate X Windows... */
9150 long supplied_return;
9151 int value;
9152
9153 #ifdef HAVE_X11R4
9154 value = XGetWMNormalHints (FRAME_X_DISPLAY (f), window, &hints,
9155 &supplied_return);
9156 #else
9157 value = XGetNormalHints (FRAME_X_DISPLAY (f), window, &hints);
9158 #endif
9159
9160 #ifdef USE_X_TOOLKIT
9161 size_hints.base_height = hints.base_height;
9162 size_hints.base_width = hints.base_width;
9163 size_hints.min_height = hints.min_height;
9164 size_hints.min_width = hints.min_width;
9165 #endif
9166
9167 if (flags)
9168 size_hints.flags |= flags;
9169 else
9170 {
9171 if (value == 0)
9172 hints.flags = 0;
9173 if (hints.flags & PSize)
9174 size_hints.flags |= PSize;
9175 if (hints.flags & PPosition)
9176 size_hints.flags |= PPosition;
9177 if (hints.flags & USPosition)
9178 size_hints.flags |= USPosition;
9179 if (hints.flags & USSize)
9180 size_hints.flags |= USSize;
9181 }
9182 }
9183
9184 #ifndef USE_X_TOOLKIT
9185 no_read:
9186 #endif
9187
9188 #ifdef PWinGravity
9189 size_hints.win_gravity = f->win_gravity;
9190 size_hints.flags |= PWinGravity;
9191
9192 if (user_position)
9193 {
9194 size_hints.flags &= ~ PPosition;
9195 size_hints.flags |= USPosition;
9196 }
9197 #endif /* PWinGravity */
9198
9199 #ifdef HAVE_X11R4
9200 XSetWMNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
9201 #else
9202 XSetNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
9203 #endif
9204 }
9205 #endif /* not USE_GTK */
9206
9207 /* Used for IconicState or NormalState */
9208
9209 void
9210 x_wm_set_window_state (f, state)
9211 struct frame *f;
9212 int state;
9213 {
9214 #ifdef USE_X_TOOLKIT
9215 Arg al[1];
9216
9217 XtSetArg (al[0], XtNinitialState, state);
9218 XtSetValues (f->output_data.x->widget, al, 1);
9219 #else /* not USE_X_TOOLKIT */
9220 Window window = FRAME_X_WINDOW (f);
9221
9222 f->output_data.x->wm_hints.flags |= StateHint;
9223 f->output_data.x->wm_hints.initial_state = state;
9224
9225 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
9226 #endif /* not USE_X_TOOLKIT */
9227 }
9228
9229 void
9230 x_wm_set_icon_pixmap (f, pixmap_id)
9231 struct frame *f;
9232 int pixmap_id;
9233 {
9234 Pixmap icon_pixmap, icon_mask;
9235
9236 #ifndef USE_X_TOOLKIT
9237 Window window = FRAME_OUTER_WINDOW (f);
9238 #endif
9239
9240 if (pixmap_id > 0)
9241 {
9242 icon_pixmap = x_bitmap_pixmap (f, pixmap_id);
9243 f->output_data.x->wm_hints.icon_pixmap = icon_pixmap;
9244 icon_mask = x_bitmap_mask (f, pixmap_id);
9245 f->output_data.x->wm_hints.icon_mask = icon_mask;
9246 }
9247 else
9248 {
9249 /* It seems there is no way to turn off use of an icon pixmap.
9250 The following line does it, only if no icon has yet been created,
9251 for some window managers. But with mwm it crashes.
9252 Some people say it should clear the IconPixmapHint bit in this case,
9253 but that doesn't work, and the X consortium said it isn't the
9254 right thing at all. Since there is no way to win,
9255 best to explicitly give up. */
9256 #if 0
9257 f->output_data.x->wm_hints.icon_pixmap = None;
9258 f->output_data.x->wm_hints.icon_mask = None;
9259 #else
9260 return;
9261 #endif
9262 }
9263
9264
9265 #ifdef USE_GTK
9266 {
9267 xg_set_frame_icon (f, icon_pixmap, icon_mask);
9268 return;
9269 }
9270
9271 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9272
9273 {
9274 Arg al[1];
9275 XtSetArg (al[0], XtNiconPixmap, icon_pixmap);
9276 XtSetValues (f->output_data.x->widget, al, 1);
9277 XtSetArg (al[0], XtNiconMask, icon_mask);
9278 XtSetValues (f->output_data.x->widget, al, 1);
9279 }
9280
9281 #else /* not USE_X_TOOLKIT && not USE_GTK */
9282
9283 f->output_data.x->wm_hints.flags |= (IconPixmapHint | IconMaskHint);
9284 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
9285
9286 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9287 }
9288
9289 void
9290 x_wm_set_icon_position (f, icon_x, icon_y)
9291 struct frame *f;
9292 int icon_x, icon_y;
9293 {
9294 Window window = FRAME_OUTER_WINDOW (f);
9295
9296 f->output_data.x->wm_hints.flags |= IconPositionHint;
9297 f->output_data.x->wm_hints.icon_x = icon_x;
9298 f->output_data.x->wm_hints.icon_y = icon_y;
9299
9300 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
9301 }
9302
9303 \f
9304 /***********************************************************************
9305 Fonts
9306 ***********************************************************************/
9307
9308 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
9309
9310 struct font_info *
9311 x_get_font_info (f, font_idx)
9312 FRAME_PTR f;
9313 int font_idx;
9314 {
9315 return (FRAME_X_FONT_TABLE (f) + font_idx);
9316 }
9317
9318
9319 /* Return a list of names of available fonts matching PATTERN on frame F.
9320
9321 If SIZE is > 0, it is the size (maximum bounds width) of fonts
9322 to be listed.
9323
9324 SIZE < 0 means include scalable fonts.
9325
9326 Frame F null means we have not yet created any frame on X, and
9327 consult the first display in x_display_list. MAXNAMES sets a limit
9328 on how many fonts to match. */
9329
9330 Lisp_Object
9331 x_list_fonts (f, pattern, size, maxnames)
9332 struct frame *f;
9333 Lisp_Object pattern;
9334 int size;
9335 int maxnames;
9336 {
9337 Lisp_Object list = Qnil, patterns, newlist = Qnil, key = Qnil;
9338 Lisp_Object tem, second_best;
9339 struct x_display_info *dpyinfo
9340 = f ? FRAME_X_DISPLAY_INFO (f) : x_display_list;
9341 Display *dpy = dpyinfo->display;
9342 int try_XLoadQueryFont = 0;
9343 int count;
9344 int allow_auto_scaled_font = 0;
9345
9346 if (size < 0)
9347 {
9348 allow_auto_scaled_font = 1;
9349 size = 0;
9350 }
9351
9352 patterns = Fassoc (pattern, Valternate_fontname_alist);
9353 if (NILP (patterns))
9354 patterns = Fcons (pattern, Qnil);
9355
9356 if (maxnames == 1 && !size)
9357 /* We can return any single font matching PATTERN. */
9358 try_XLoadQueryFont = 1;
9359
9360 for (; CONSP (patterns); patterns = XCDR (patterns))
9361 {
9362 int num_fonts;
9363 char **names = NULL;
9364
9365 pattern = XCAR (patterns);
9366 /* See if we cached the result for this particular query.
9367 The cache is an alist of the form:
9368 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
9369 tem = XCDR (dpyinfo->name_list_element);
9370 key = Fcons (Fcons (pattern, make_number (maxnames)),
9371 allow_auto_scaled_font ? Qt : Qnil);
9372 list = Fassoc (key, tem);
9373 if (!NILP (list))
9374 {
9375 list = Fcdr_safe (list);
9376 /* We have a cashed list. Don't have to get the list again. */
9377 goto label_cached;
9378 }
9379
9380 /* At first, put PATTERN in the cache. */
9381
9382 BLOCK_INPUT;
9383 count = x_catch_errors (dpy);
9384
9385 if (try_XLoadQueryFont)
9386 {
9387 XFontStruct *font;
9388 unsigned long value;
9389
9390 font = XLoadQueryFont (dpy, SDATA (pattern));
9391 if (x_had_errors_p (dpy))
9392 {
9393 /* This error is perhaps due to insufficient memory on X
9394 server. Let's just ignore it. */
9395 font = NULL;
9396 x_clear_errors (dpy);
9397 }
9398
9399 if (font
9400 && XGetFontProperty (font, XA_FONT, &value))
9401 {
9402 char *name = (char *) XGetAtomName (dpy, (Atom) value);
9403 int len = strlen (name);
9404 char *tmp;
9405
9406 /* If DXPC (a Differential X Protocol Compressor)
9407 Ver.3.7 is running, XGetAtomName will return null
9408 string. We must avoid such a name. */
9409 if (len == 0)
9410 try_XLoadQueryFont = 0;
9411 else
9412 {
9413 num_fonts = 1;
9414 names = (char **) alloca (sizeof (char *));
9415 /* Some systems only allow alloca assigned to a
9416 simple var. */
9417 tmp = (char *) alloca (len + 1); names[0] = tmp;
9418 bcopy (name, names[0], len + 1);
9419 XFree (name);
9420 }
9421 }
9422 else
9423 try_XLoadQueryFont = 0;
9424
9425 if (font)
9426 XFreeFont (dpy, font);
9427 }
9428
9429 if (!try_XLoadQueryFont)
9430 {
9431 /* We try at least 10 fonts because XListFonts will return
9432 auto-scaled fonts at the head. */
9433 if (maxnames < 0)
9434 {
9435 int limit;
9436
9437 for (limit = 500;;)
9438 {
9439 names = XListFonts (dpy, SDATA (pattern), limit, &num_fonts);
9440 if (num_fonts == limit)
9441 {
9442 BLOCK_INPUT;
9443 XFreeFontNames (names);
9444 UNBLOCK_INPUT;
9445 limit *= 2;
9446 }
9447 else
9448 break;
9449 }
9450 }
9451 else
9452 names = XListFonts (dpy, SDATA (pattern), max (maxnames, 10),
9453 &num_fonts);
9454
9455 if (x_had_errors_p (dpy))
9456 {
9457 /* This error is perhaps due to insufficient memory on X
9458 server. Let's just ignore it. */
9459 names = NULL;
9460 x_clear_errors (dpy);
9461 }
9462 }
9463
9464 x_uncatch_errors (dpy, count);
9465 UNBLOCK_INPUT;
9466
9467 if (names)
9468 {
9469 int i;
9470
9471 /* Make a list of all the fonts we got back.
9472 Store that in the font cache for the display. */
9473 for (i = 0; i < num_fonts; i++)
9474 {
9475 int width = 0;
9476 char *p = names[i];
9477 int average_width = -1, resx = 0, dashes = 0;
9478
9479 /* Count the number of dashes in NAMES[I]. If there are
9480 14 dashes, the field value following 9th dash
9481 (RESOLUTION_X) is nonzero, and the field value
9482 following 12th dash (AVERAGE_WIDTH) is 0, this is a
9483 auto-scaled font which is usually too ugly to be used
9484 for editing. Let's ignore it. */
9485 while (*p)
9486 if (*p++ == '-')
9487 {
9488 dashes++;
9489 if (dashes == 7) /* PIXEL_SIZE field */
9490 width = atoi (p);
9491 else if (dashes == 9)
9492 resx = atoi (p);
9493 else if (dashes == 12) /* AVERAGE_WIDTH field */
9494 average_width = atoi (p);
9495 }
9496
9497 if (allow_auto_scaled_font
9498 || dashes < 14 || average_width != 0 || resx == 0)
9499 {
9500 tem = build_string (names[i]);
9501 if (NILP (Fassoc (tem, list)))
9502 {
9503 if (STRINGP (Vx_pixel_size_width_font_regexp)
9504 && ((fast_c_string_match_ignore_case
9505 (Vx_pixel_size_width_font_regexp, names[i]))
9506 >= 0))
9507 /* We can set the value of PIXEL_SIZE to the
9508 width of this font. */
9509 list = Fcons (Fcons (tem, make_number (width)), list);
9510 else
9511 /* For the moment, width is not known. */
9512 list = Fcons (Fcons (tem, Qnil), list);
9513 }
9514 }
9515 }
9516
9517 if (!try_XLoadQueryFont)
9518 {
9519 BLOCK_INPUT;
9520 XFreeFontNames (names);
9521 UNBLOCK_INPUT;
9522 }
9523 }
9524
9525 /* Now store the result in the cache. */
9526 XSETCDR (dpyinfo->name_list_element,
9527 Fcons (Fcons (key, list), XCDR (dpyinfo->name_list_element)));
9528
9529 label_cached:
9530 if (NILP (list)) continue; /* Try the remaining alternatives. */
9531
9532 newlist = second_best = Qnil;
9533 /* Make a list of the fonts that have the right width. */
9534 for (; CONSP (list); list = XCDR (list))
9535 {
9536 int found_size;
9537
9538 tem = XCAR (list);
9539
9540 if (!CONSP (tem) || NILP (XCAR (tem)))
9541 continue;
9542 if (!size)
9543 {
9544 newlist = Fcons (XCAR (tem), newlist);
9545 continue;
9546 }
9547
9548 if (!INTEGERP (XCDR (tem)))
9549 {
9550 /* Since we have not yet known the size of this font, we
9551 must try slow function call XLoadQueryFont. */
9552 XFontStruct *thisinfo;
9553
9554 BLOCK_INPUT;
9555 count = x_catch_errors (dpy);
9556 thisinfo = XLoadQueryFont (dpy,
9557 SDATA (XCAR (tem)));
9558 if (x_had_errors_p (dpy))
9559 {
9560 /* This error is perhaps due to insufficient memory on X
9561 server. Let's just ignore it. */
9562 thisinfo = NULL;
9563 x_clear_errors (dpy);
9564 }
9565 x_uncatch_errors (dpy, count);
9566 UNBLOCK_INPUT;
9567
9568 if (thisinfo)
9569 {
9570 XSETCDR (tem,
9571 (thisinfo->min_bounds.width == 0
9572 ? make_number (0)
9573 : make_number (thisinfo->max_bounds.width)));
9574 BLOCK_INPUT;
9575 XFreeFont (dpy, thisinfo);
9576 UNBLOCK_INPUT;
9577 }
9578 else
9579 /* For unknown reason, the previous call of XListFont had
9580 returned a font which can't be opened. Record the size
9581 as 0 not to try to open it again. */
9582 XSETCDR (tem, make_number (0));
9583 }
9584
9585 found_size = XINT (XCDR (tem));
9586 if (found_size == size)
9587 newlist = Fcons (XCAR (tem), newlist);
9588 else if (found_size > 0)
9589 {
9590 if (NILP (second_best))
9591 second_best = tem;
9592 else if (found_size < size)
9593 {
9594 if (XINT (XCDR (second_best)) > size
9595 || XINT (XCDR (second_best)) < found_size)
9596 second_best = tem;
9597 }
9598 else
9599 {
9600 if (XINT (XCDR (second_best)) > size
9601 && XINT (XCDR (second_best)) > found_size)
9602 second_best = tem;
9603 }
9604 }
9605 }
9606 if (!NILP (newlist))
9607 break;
9608 else if (!NILP (second_best))
9609 {
9610 newlist = Fcons (XCAR (second_best), Qnil);
9611 break;
9612 }
9613 }
9614
9615 return newlist;
9616 }
9617
9618
9619 #if GLYPH_DEBUG
9620
9621 /* Check that FONT is valid on frame F. It is if it can be found in F's
9622 font table. */
9623
9624 static void
9625 x_check_font (f, font)
9626 struct frame *f;
9627 XFontStruct *font;
9628 {
9629 int i;
9630 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
9631
9632 xassert (font != NULL);
9633
9634 for (i = 0; i < dpyinfo->n_fonts; i++)
9635 if (dpyinfo->font_table[i].name
9636 && font == dpyinfo->font_table[i].font)
9637 break;
9638
9639 xassert (i < dpyinfo->n_fonts);
9640 }
9641
9642 #endif /* GLYPH_DEBUG != 0 */
9643
9644 /* Set *W to the minimum width, *H to the minimum font height of FONT.
9645 Note: There are (broken) X fonts out there with invalid XFontStruct
9646 min_bounds contents. For example, handa@etl.go.jp reports that
9647 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
9648 have font->min_bounds.width == 0. */
9649
9650 static INLINE void
9651 x_font_min_bounds (font, w, h)
9652 XFontStruct *font;
9653 int *w, *h;
9654 {
9655 *h = FONT_HEIGHT (font);
9656 *w = font->min_bounds.width;
9657
9658 /* Try to handle the case where FONT->min_bounds has invalid
9659 contents. Since the only font known to have invalid min_bounds
9660 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
9661 if (*w <= 0)
9662 *w = font->max_bounds.width;
9663 }
9664
9665
9666 /* Compute the smallest character width and smallest font height over
9667 all fonts available on frame F. Set the members smallest_char_width
9668 and smallest_font_height in F's x_display_info structure to
9669 the values computed. Value is non-zero if smallest_font_height or
9670 smallest_char_width become smaller than they were before. */
9671
9672 static int
9673 x_compute_min_glyph_bounds (f)
9674 struct frame *f;
9675 {
9676 int i;
9677 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
9678 XFontStruct *font;
9679 int old_width = dpyinfo->smallest_char_width;
9680 int old_height = dpyinfo->smallest_font_height;
9681
9682 dpyinfo->smallest_font_height = 100000;
9683 dpyinfo->smallest_char_width = 100000;
9684
9685 for (i = 0; i < dpyinfo->n_fonts; ++i)
9686 if (dpyinfo->font_table[i].name)
9687 {
9688 struct font_info *fontp = dpyinfo->font_table + i;
9689 int w, h;
9690
9691 font = (XFontStruct *) fontp->font;
9692 xassert (font != (XFontStruct *) ~0);
9693 x_font_min_bounds (font, &w, &h);
9694
9695 dpyinfo->smallest_font_height = min (dpyinfo->smallest_font_height, h);
9696 dpyinfo->smallest_char_width = min (dpyinfo->smallest_char_width, w);
9697 }
9698
9699 xassert (dpyinfo->smallest_char_width > 0
9700 && dpyinfo->smallest_font_height > 0);
9701
9702 return (dpyinfo->n_fonts == 1
9703 || dpyinfo->smallest_char_width < old_width
9704 || dpyinfo->smallest_font_height < old_height);
9705 }
9706
9707
9708 /* Load font named FONTNAME of the size SIZE for frame F, and return a
9709 pointer to the structure font_info while allocating it dynamically.
9710 If SIZE is 0, load any size of font.
9711 If loading is failed, return NULL. */
9712
9713 struct font_info *
9714 x_load_font (f, fontname, size)
9715 struct frame *f;
9716 register char *fontname;
9717 int size;
9718 {
9719 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
9720 Lisp_Object font_names;
9721 int count;
9722
9723 /* Get a list of all the fonts that match this name. Once we
9724 have a list of matching fonts, we compare them against the fonts
9725 we already have by comparing names. */
9726 font_names = x_list_fonts (f, build_string (fontname), size, 1);
9727
9728 if (!NILP (font_names))
9729 {
9730 Lisp_Object tail;
9731 int i;
9732
9733 for (i = 0; i < dpyinfo->n_fonts; i++)
9734 for (tail = font_names; CONSP (tail); tail = XCDR (tail))
9735 if (dpyinfo->font_table[i].name
9736 && (!strcmp (dpyinfo->font_table[i].name,
9737 SDATA (XCAR (tail)))
9738 || !strcmp (dpyinfo->font_table[i].full_name,
9739 SDATA (XCAR (tail)))))
9740 return (dpyinfo->font_table + i);
9741 }
9742
9743 /* Load the font and add it to the table. */
9744 {
9745 char *full_name;
9746 XFontStruct *font;
9747 struct font_info *fontp;
9748 unsigned long value;
9749 int i;
9750
9751 /* If we have found fonts by x_list_font, load one of them. If
9752 not, we still try to load a font by the name given as FONTNAME
9753 because XListFonts (called in x_list_font) of some X server has
9754 a bug of not finding a font even if the font surely exists and
9755 is loadable by XLoadQueryFont. */
9756 if (size > 0 && !NILP (font_names))
9757 fontname = (char *) SDATA (XCAR (font_names));
9758
9759 BLOCK_INPUT;
9760 count = x_catch_errors (FRAME_X_DISPLAY (f));
9761 font = (XFontStruct *) XLoadQueryFont (FRAME_X_DISPLAY (f), fontname);
9762 if (x_had_errors_p (FRAME_X_DISPLAY (f)))
9763 {
9764 /* This error is perhaps due to insufficient memory on X
9765 server. Let's just ignore it. */
9766 font = NULL;
9767 x_clear_errors (FRAME_X_DISPLAY (f));
9768 }
9769 x_uncatch_errors (FRAME_X_DISPLAY (f), count);
9770 UNBLOCK_INPUT;
9771 if (!font)
9772 return NULL;
9773
9774 /* Find a free slot in the font table. */
9775 for (i = 0; i < dpyinfo->n_fonts; ++i)
9776 if (dpyinfo->font_table[i].name == NULL)
9777 break;
9778
9779 /* If no free slot found, maybe enlarge the font table. */
9780 if (i == dpyinfo->n_fonts
9781 && dpyinfo->n_fonts == dpyinfo->font_table_size)
9782 {
9783 int sz;
9784 dpyinfo->font_table_size = max (16, 2 * dpyinfo->font_table_size);
9785 sz = dpyinfo->font_table_size * sizeof *dpyinfo->font_table;
9786 dpyinfo->font_table
9787 = (struct font_info *) xrealloc (dpyinfo->font_table, sz);
9788 }
9789
9790 fontp = dpyinfo->font_table + i;
9791 if (i == dpyinfo->n_fonts)
9792 ++dpyinfo->n_fonts;
9793
9794 /* Now fill in the slots of *FONTP. */
9795 BLOCK_INPUT;
9796 bzero (fontp, sizeof (*fontp));
9797 fontp->font = font;
9798 fontp->font_idx = i;
9799 fontp->name = (char *) xmalloc (strlen (fontname) + 1);
9800 bcopy (fontname, fontp->name, strlen (fontname) + 1);
9801
9802 if (font->min_bounds.width == font->max_bounds.width)
9803 {
9804 /* Fixed width font. */
9805 fontp->average_width = fontp->space_width = font->min_bounds.width;
9806 }
9807 else
9808 {
9809 XChar2b char2b;
9810 XCharStruct *pcm;
9811
9812 char2b.byte1 = 0x00, char2b.byte2 = 0x20;
9813 pcm = x_per_char_metric (font, &char2b, 0);
9814 if (pcm)
9815 fontp->space_width = pcm->width;
9816 else
9817 fontp->space_width = FONT_WIDTH (font);
9818
9819 fontp->average_width
9820 = (XGetFontProperty (font, dpyinfo->Xatom_AVERAGE_WIDTH, &value)
9821 ? (long) value / 10 : 0);
9822 if (fontp->average_width < 0)
9823 fontp->average_width = - fontp->average_width;
9824 if (fontp->average_width == 0)
9825 {
9826 if (pcm)
9827 {
9828 int width = pcm->width;
9829 for (char2b.byte2 = 33; char2b.byte2 <= 126; char2b.byte2++)
9830 if ((pcm = x_per_char_metric (font, &char2b, 0)) != NULL)
9831 width += pcm->width;
9832 fontp->average_width = width / 95;
9833 }
9834 else
9835 fontp->average_width = FONT_WIDTH (font);
9836 }
9837 }
9838
9839 /* Try to get the full name of FONT. Put it in FULL_NAME. */
9840 full_name = 0;
9841 if (XGetFontProperty (font, XA_FONT, &value))
9842 {
9843 char *name = (char *) XGetAtomName (FRAME_X_DISPLAY (f), (Atom) value);
9844 char *p = name;
9845 int dashes = 0;
9846
9847 /* Count the number of dashes in the "full name".
9848 If it is too few, this isn't really the font's full name,
9849 so don't use it.
9850 In X11R4, the fonts did not come with their canonical names
9851 stored in them. */
9852 while (*p)
9853 {
9854 if (*p == '-')
9855 dashes++;
9856 p++;
9857 }
9858
9859 if (dashes >= 13)
9860 {
9861 full_name = (char *) xmalloc (p - name + 1);
9862 bcopy (name, full_name, p - name + 1);
9863 }
9864
9865 XFree (name);
9866 }
9867
9868 if (full_name != 0)
9869 fontp->full_name = full_name;
9870 else
9871 fontp->full_name = fontp->name;
9872
9873 fontp->size = font->max_bounds.width;
9874 fontp->height = FONT_HEIGHT (font);
9875
9876 if (NILP (font_names))
9877 {
9878 /* We come here because of a bug of XListFonts mentioned at
9879 the head of this block. Let's store this information in
9880 the cache for x_list_fonts. */
9881 Lisp_Object lispy_name = build_string (fontname);
9882 Lisp_Object lispy_full_name = build_string (fontp->full_name);
9883 Lisp_Object key = Fcons (Fcons (lispy_name, make_number (256)),
9884 Qnil);
9885
9886 XSETCDR (dpyinfo->name_list_element,
9887 Fcons (Fcons (key,
9888 Fcons (Fcons (lispy_full_name,
9889 make_number (fontp->size)),
9890 Qnil)),
9891 XCDR (dpyinfo->name_list_element)));
9892 if (full_name)
9893 {
9894 key = Fcons (Fcons (lispy_full_name, make_number (256)),
9895 Qnil);
9896 XSETCDR (dpyinfo->name_list_element,
9897 Fcons (Fcons (key,
9898 Fcons (Fcons (lispy_full_name,
9899 make_number (fontp->size)),
9900 Qnil)),
9901 XCDR (dpyinfo->name_list_element)));
9902 }
9903 }
9904
9905 /* The slot `encoding' specifies how to map a character
9906 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
9907 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
9908 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
9909 2:0xA020..0xFF7F). For the moment, we don't know which charset
9910 uses this font. So, we set information in fontp->encoding[1]
9911 which is never used by any charset. If mapping can't be
9912 decided, set FONT_ENCODING_NOT_DECIDED. */
9913 fontp->encoding[1]
9914 = (font->max_byte1 == 0
9915 /* 1-byte font */
9916 ? (font->min_char_or_byte2 < 0x80
9917 ? (font->max_char_or_byte2 < 0x80
9918 ? 0 /* 0x20..0x7F */
9919 : FONT_ENCODING_NOT_DECIDED) /* 0x20..0xFF */
9920 : 1) /* 0xA0..0xFF */
9921 /* 2-byte font */
9922 : (font->min_byte1 < 0x80
9923 ? (font->max_byte1 < 0x80
9924 ? (font->min_char_or_byte2 < 0x80
9925 ? (font->max_char_or_byte2 < 0x80
9926 ? 0 /* 0x2020..0x7F7F */
9927 : FONT_ENCODING_NOT_DECIDED) /* 0x2020..0x7FFF */
9928 : 3) /* 0x20A0..0x7FFF */
9929 : FONT_ENCODING_NOT_DECIDED) /* 0x20??..0xA0?? */
9930 : (font->min_char_or_byte2 < 0x80
9931 ? (font->max_char_or_byte2 < 0x80
9932 ? 2 /* 0xA020..0xFF7F */
9933 : FONT_ENCODING_NOT_DECIDED) /* 0xA020..0xFFFF */
9934 : 1))); /* 0xA0A0..0xFFFF */
9935
9936 fontp->baseline_offset
9937 = (XGetFontProperty (font, dpyinfo->Xatom_MULE_BASELINE_OFFSET, &value)
9938 ? (long) value : 0);
9939 fontp->relative_compose
9940 = (XGetFontProperty (font, dpyinfo->Xatom_MULE_RELATIVE_COMPOSE, &value)
9941 ? (long) value : 0);
9942 fontp->default_ascent
9943 = (XGetFontProperty (font, dpyinfo->Xatom_MULE_DEFAULT_ASCENT, &value)
9944 ? (long) value : 0);
9945
9946 /* Set global flag fonts_changed_p to non-zero if the font loaded
9947 has a character with a smaller width than any other character
9948 before, or if the font loaded has a smaller height than any
9949 other font loaded before. If this happens, it will make a
9950 glyph matrix reallocation necessary. */
9951 fonts_changed_p |= x_compute_min_glyph_bounds (f);
9952 UNBLOCK_INPUT;
9953 return fontp;
9954 }
9955 }
9956
9957
9958 /* Return a pointer to struct font_info of a font named FONTNAME for
9959 frame F. If no such font is loaded, return NULL. */
9960
9961 struct font_info *
9962 x_query_font (f, fontname)
9963 struct frame *f;
9964 register char *fontname;
9965 {
9966 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
9967 int i;
9968
9969 for (i = 0; i < dpyinfo->n_fonts; i++)
9970 if (dpyinfo->font_table[i].name
9971 && (!strcmp (dpyinfo->font_table[i].name, fontname)
9972 || !strcmp (dpyinfo->font_table[i].full_name, fontname)))
9973 return (dpyinfo->font_table + i);
9974 return NULL;
9975 }
9976
9977
9978 /* Find a CCL program for a font specified by FONTP, and set the member
9979 `encoder' of the structure. */
9980
9981 void
9982 x_find_ccl_program (fontp)
9983 struct font_info *fontp;
9984 {
9985 Lisp_Object list, elt;
9986
9987 elt = Qnil;
9988 for (list = Vfont_ccl_encoder_alist; CONSP (list); list = XCDR (list))
9989 {
9990 elt = XCAR (list);
9991 if (CONSP (elt)
9992 && STRINGP (XCAR (elt))
9993 && ((fast_c_string_match_ignore_case (XCAR (elt), fontp->name)
9994 >= 0)
9995 || (fast_c_string_match_ignore_case (XCAR (elt), fontp->full_name)
9996 >= 0)))
9997 break;
9998 }
9999
10000 if (! NILP (list))
10001 {
10002 struct ccl_program *ccl
10003 = (struct ccl_program *) xmalloc (sizeof (struct ccl_program));
10004
10005 if (setup_ccl_program (ccl, XCDR (elt)) < 0)
10006 xfree (ccl);
10007 else
10008 fontp->font_encoder = ccl;
10009 }
10010 }
10011
10012
10013 \f
10014 /***********************************************************************
10015 Initialization
10016 ***********************************************************************/
10017
10018 #ifdef USE_X_TOOLKIT
10019 static XrmOptionDescRec emacs_options[] = {
10020 {"-geometry", ".geometry", XrmoptionSepArg, NULL},
10021 {"-iconic", ".iconic", XrmoptionNoArg, (XtPointer) "yes"},
10022
10023 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
10024 XrmoptionSepArg, NULL},
10025 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg, NULL},
10026
10027 {"-T", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
10028 {"-wn", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
10029 {"-title", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
10030 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg, (XtPointer) NULL},
10031 {"-in", "*EmacsShell.iconName", XrmoptionSepArg, (XtPointer) NULL},
10032 {"-mc", "*pointerColor", XrmoptionSepArg, (XtPointer) NULL},
10033 {"-cr", "*cursorColor", XrmoptionSepArg, (XtPointer) NULL}
10034 };
10035 #endif /* USE_X_TOOLKIT */
10036
10037 static int x_initialized;
10038
10039 #ifdef MULTI_KBOARD
10040 /* Test whether two display-name strings agree up to the dot that separates
10041 the screen number from the server number. */
10042 static int
10043 same_x_server (name1, name2)
10044 const char *name1, *name2;
10045 {
10046 int seen_colon = 0;
10047 const unsigned char *system_name = SDATA (Vsystem_name);
10048 int system_name_length = strlen (system_name);
10049 int length_until_period = 0;
10050
10051 while (system_name[length_until_period] != 0
10052 && system_name[length_until_period] != '.')
10053 length_until_period++;
10054
10055 /* Treat `unix' like an empty host name. */
10056 if (! strncmp (name1, "unix:", 5))
10057 name1 += 4;
10058 if (! strncmp (name2, "unix:", 5))
10059 name2 += 4;
10060 /* Treat this host's name like an empty host name. */
10061 if (! strncmp (name1, system_name, system_name_length)
10062 && name1[system_name_length] == ':')
10063 name1 += system_name_length;
10064 if (! strncmp (name2, system_name, system_name_length)
10065 && name2[system_name_length] == ':')
10066 name2 += system_name_length;
10067 /* Treat this host's domainless name like an empty host name. */
10068 if (! strncmp (name1, system_name, length_until_period)
10069 && name1[length_until_period] == ':')
10070 name1 += length_until_period;
10071 if (! strncmp (name2, system_name, length_until_period)
10072 && name2[length_until_period] == ':')
10073 name2 += length_until_period;
10074
10075 for (; *name1 != '\0' && *name1 == *name2; name1++, name2++)
10076 {
10077 if (*name1 == ':')
10078 seen_colon++;
10079 if (seen_colon && *name1 == '.')
10080 return 1;
10081 }
10082 return (seen_colon
10083 && (*name1 == '.' || *name1 == '\0')
10084 && (*name2 == '.' || *name2 == '\0'));
10085 }
10086 #endif
10087
10088 /* Count number of set bits in mask and number of bits to shift to
10089 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
10090 to 5. */
10091 static void
10092 get_bits_and_offset (mask, bits, offset)
10093 unsigned long mask;
10094 int *bits;
10095 int *offset;
10096 {
10097 int nr = 0;
10098 int off = 0;
10099
10100 while (!(mask & 1))
10101 {
10102 off++;
10103 mask >>= 1;
10104 }
10105
10106 while (mask & 1)
10107 {
10108 nr++;
10109 mask >>= 1;
10110 }
10111
10112 *offset = off;
10113 *bits = nr;
10114 }
10115
10116 struct x_display_info *
10117 x_term_init (display_name, xrm_option, resource_name)
10118 Lisp_Object display_name;
10119 char *xrm_option;
10120 char *resource_name;
10121 {
10122 int connection;
10123 Display *dpy;
10124 struct device *device;
10125 struct x_display_info *dpyinfo;
10126 XrmDatabase xrdb;
10127
10128 BLOCK_INPUT;
10129
10130 if (!x_initialized)
10131 {
10132 x_initialize ();
10133 ++x_initialized;
10134 }
10135
10136 #ifdef USE_GTK
10137 {
10138 #define NUM_ARGV 10
10139 int argc;
10140 char *argv[NUM_ARGV];
10141 char **argv2 = argv;
10142 GdkAtom atom;
10143
10144 if (x_initialized++ > 1)
10145 {
10146 /* Opening another display. If xg_display_open returns less
10147 than zero, we are probably on GTK 2.0, which can only handle
10148 one display. GTK 2.2 or later can handle more than one. */
10149 if (xg_display_open (SDATA (display_name), &dpy) < 0)
10150 error ("Sorry, this version of GTK can only handle one display");
10151 }
10152 else
10153 {
10154 for (argc = 0; argc < NUM_ARGV; ++argc)
10155 argv[argc] = 0;
10156
10157 argc = 0;
10158 argv[argc++] = initial_argv[0];
10159
10160 if (! NILP (display_name))
10161 {
10162 argv[argc++] = "--display";
10163 argv[argc++] = SDATA (display_name);
10164 }
10165
10166 argv[argc++] = "--name";
10167 argv[argc++] = resource_name;
10168
10169 #ifdef HAVE_X11R5
10170 XSetLocaleModifiers ("");
10171 #endif
10172
10173 gtk_init (&argc, &argv2);
10174
10175 /* gtk_init does set_locale. We must fix locale after calling it. */
10176 fixup_locale ();
10177 xg_initialize ();
10178
10179 dpy = GDK_DISPLAY ();
10180
10181 /* NULL window -> events for all windows go to our function */
10182 gdk_window_add_filter (NULL, event_handler_gdk, NULL);
10183
10184 /* Load our own gtkrc if it exists. */
10185 {
10186 struct gcpro gcpro1, gcpro2;
10187 char *file = "~/.emacs.d/gtkrc";
10188 Lisp_Object s, abs_file;
10189
10190 GCPRO2 (s, abs_file);
10191 s = make_string (file, strlen (file));
10192 abs_file = Fexpand_file_name (s, Qnil);
10193
10194 if (! NILP (abs_file) && !NILP (Ffile_readable_p (abs_file)))
10195 gtk_rc_parse (SDATA (abs_file));
10196
10197 UNGCPRO;
10198 }
10199
10200 XSetErrorHandler (x_error_handler);
10201 XSetIOErrorHandler (x_io_error_quitter);
10202 }
10203 }
10204 #else /* not USE_GTK */
10205 #ifdef USE_X_TOOLKIT
10206 /* weiner@footloose.sps.mot.com reports that this causes
10207 errors with X11R5:
10208 X protocol error: BadAtom (invalid Atom parameter)
10209 on protocol request 18skiloaf.
10210 So let's not use it until R6. */
10211 #ifdef HAVE_X11XTR6
10212 XtSetLanguageProc (NULL, NULL, NULL);
10213 #endif
10214
10215 {
10216 int argc = 0;
10217 char *argv[3];
10218
10219 argv[0] = "";
10220 argc = 1;
10221 if (xrm_option)
10222 {
10223 argv[argc++] = "-xrm";
10224 argv[argc++] = xrm_option;
10225 }
10226 turn_on_atimers (0);
10227 dpy = XtOpenDisplay (Xt_app_con, SDATA (display_name),
10228 resource_name, EMACS_CLASS,
10229 emacs_options, XtNumber (emacs_options),
10230 &argc, argv);
10231 turn_on_atimers (1);
10232
10233 #ifdef HAVE_X11XTR6
10234 /* I think this is to compensate for XtSetLanguageProc. */
10235 fixup_locale ();
10236 #endif
10237 }
10238
10239 #else /* not USE_X_TOOLKIT */
10240 #ifdef HAVE_X11R5
10241 XSetLocaleModifiers ("");
10242 #endif
10243 dpy = XOpenDisplay (SDATA (display_name));
10244 #endif /* not USE_X_TOOLKIT */
10245 #endif /* not USE_GTK*/
10246
10247 /* Detect failure. */
10248 if (dpy == 0)
10249 {
10250 UNBLOCK_INPUT;
10251 return 0;
10252 }
10253
10254 /* We have definitely succeeded. Record the new connection. */
10255
10256 dpyinfo = (struct x_display_info *) xmalloc (sizeof (struct x_display_info));
10257 bzero (dpyinfo, sizeof *dpyinfo);
10258
10259 device = x_create_device (dpyinfo);
10260
10261 #ifdef MULTI_KBOARD
10262 {
10263 struct x_display_info *share;
10264 Lisp_Object tail;
10265
10266 for (share = x_display_list, tail = x_display_name_list; share;
10267 share = share->next, tail = XCDR (tail))
10268 if (same_x_server (SDATA (XCAR (XCAR (tail))),
10269 SDATA (display_name)))
10270 break;
10271 if (share)
10272 device->kboard = share->device->kboard;
10273 else
10274 {
10275 device->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
10276 init_kboard (device->kboard);
10277 if (!EQ (XSYMBOL (Qvendor_specific_keysyms)->function, Qunbound))
10278 {
10279 char *vendor = ServerVendor (dpy);
10280 UNBLOCK_INPUT;
10281 device->kboard->Vsystem_key_alist
10282 = call1 (Qvendor_specific_keysyms,
10283 build_string (vendor ? vendor : ""));
10284 BLOCK_INPUT;
10285 }
10286
10287 device->kboard->next_kboard = all_kboards;
10288 all_kboards = device->kboard;
10289 /* Don't let the initial kboard remain current longer than necessary.
10290 That would cause problems if a file loaded on startup tries to
10291 prompt in the mini-buffer. */
10292 if (current_kboard == initial_kboard)
10293 current_kboard = device->kboard;
10294 }
10295 device->kboard->reference_count++;
10296 }
10297 #endif
10298
10299 /* Put this display on the chain. */
10300 dpyinfo->next = x_display_list;
10301 x_display_list = dpyinfo;
10302
10303 /* Put it on x_display_name_list as well, to keep them parallel. */
10304 x_display_name_list = Fcons (Fcons (display_name, Qnil),
10305 x_display_name_list);
10306 dpyinfo->name_list_element = XCAR (x_display_name_list);
10307
10308 dpyinfo->display = dpy;
10309
10310 /* Set the name of the device. */
10311 device->name = (char *) xmalloc (SBYTES (display_name) + 1);
10312 strncpy (device->name, SDATA (display_name), SBYTES (display_name));
10313 device->name[SBYTES (display_name)] = 0;
10314
10315 #if 0
10316 XSetAfterFunction (x_current_display, x_trace_wire);
10317 #endif /* ! 0 */
10318
10319 dpyinfo->x_id_name
10320 = (char *) xmalloc (SBYTES (Vinvocation_name)
10321 + SBYTES (Vsystem_name)
10322 + 2);
10323 sprintf (dpyinfo->x_id_name, "%s@%s",
10324 SDATA (Vinvocation_name), SDATA (Vsystem_name));
10325
10326 /* Figure out which modifier bits mean what. */
10327 x_find_modifier_meanings (dpyinfo);
10328
10329 /* Get the scroll bar cursor. */
10330 #ifdef USE_GTK
10331 /* We must create a GTK cursor, it is required for GTK widgets. */
10332 dpyinfo->xg_cursor = xg_create_default_cursor (dpyinfo->display);
10333 #endif /* USE_GTK */
10334
10335 dpyinfo->vertical_scroll_bar_cursor
10336 = XCreateFontCursor (dpyinfo->display, XC_sb_v_double_arrow);
10337
10338 xrdb = x_load_resources (dpyinfo->display, xrm_option,
10339 resource_name, EMACS_CLASS);
10340 #ifdef HAVE_XRMSETDATABASE
10341 XrmSetDatabase (dpyinfo->display, xrdb);
10342 #else
10343 dpyinfo->display->db = xrdb;
10344 #endif
10345 /* Put the rdb where we can find it in a way that works on
10346 all versions. */
10347 dpyinfo->xrdb = xrdb;
10348
10349 dpyinfo->screen = ScreenOfDisplay (dpyinfo->display,
10350 DefaultScreen (dpyinfo->display));
10351 select_visual (dpyinfo);
10352 dpyinfo->cmap = DefaultColormapOfScreen (dpyinfo->screen);
10353 dpyinfo->height = HeightOfScreen (dpyinfo->screen);
10354 dpyinfo->width = WidthOfScreen (dpyinfo->screen);
10355 dpyinfo->root_window = RootWindowOfScreen (dpyinfo->screen);
10356 dpyinfo->client_leader_window = 0;
10357 dpyinfo->grabbed = 0;
10358 dpyinfo->reference_count = 0;
10359 dpyinfo->icon_bitmap_id = -1;
10360 dpyinfo->font_table = NULL;
10361 dpyinfo->n_fonts = 0;
10362 dpyinfo->font_table_size = 0;
10363 dpyinfo->bitmaps = 0;
10364 dpyinfo->bitmaps_size = 0;
10365 dpyinfo->bitmaps_last = 0;
10366 dpyinfo->scratch_cursor_gc = 0;
10367 dpyinfo->mouse_face_mouse_frame = 0;
10368 dpyinfo->mouse_face_deferred_gc = 0;
10369 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
10370 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
10371 dpyinfo->mouse_face_face_id = DEFAULT_FACE_ID;
10372 dpyinfo->mouse_face_window = Qnil;
10373 dpyinfo->mouse_face_overlay = Qnil;
10374 dpyinfo->mouse_face_mouse_x = dpyinfo->mouse_face_mouse_y = 0;
10375 dpyinfo->mouse_face_defer = 0;
10376 dpyinfo->mouse_face_hidden = 0;
10377 dpyinfo->x_focus_frame = 0;
10378 dpyinfo->x_focus_event_frame = 0;
10379 dpyinfo->x_highlight_frame = 0;
10380 dpyinfo->image_cache = make_image_cache ();
10381 dpyinfo->wm_type = X_WMTYPE_UNKNOWN;
10382
10383 /* See if we can construct pixel values from RGB values. */
10384 dpyinfo->red_bits = dpyinfo->blue_bits = dpyinfo->green_bits = 0;
10385 dpyinfo->red_offset = dpyinfo->blue_offset = dpyinfo->green_offset = 0;
10386
10387 if (dpyinfo->visual->class == TrueColor)
10388 {
10389 get_bits_and_offset (dpyinfo->visual->red_mask,
10390 &dpyinfo->red_bits, &dpyinfo->red_offset);
10391 get_bits_and_offset (dpyinfo->visual->blue_mask,
10392 &dpyinfo->blue_bits, &dpyinfo->blue_offset);
10393 get_bits_and_offset (dpyinfo->visual->green_mask,
10394 &dpyinfo->green_bits, &dpyinfo->green_offset);
10395 }
10396
10397 /* See if a private colormap is requested. */
10398 if (dpyinfo->visual == DefaultVisualOfScreen (dpyinfo->screen))
10399 {
10400 if (dpyinfo->visual->class == PseudoColor)
10401 {
10402 Lisp_Object value;
10403 value = display_x_get_resource (dpyinfo,
10404 build_string ("privateColormap"),
10405 build_string ("PrivateColormap"),
10406 Qnil, Qnil);
10407 if (STRINGP (value)
10408 && (!strcmp (SDATA (value), "true")
10409 || !strcmp (SDATA (value), "on")))
10410 dpyinfo->cmap = XCopyColormapAndFree (dpyinfo->display, dpyinfo->cmap);
10411 }
10412 }
10413 else
10414 dpyinfo->cmap = XCreateColormap (dpyinfo->display, dpyinfo->root_window,
10415 dpyinfo->visual, AllocNone);
10416
10417 {
10418 int screen_number = XScreenNumberOfScreen (dpyinfo->screen);
10419 double pixels = DisplayHeight (dpyinfo->display, screen_number);
10420 double mm = DisplayHeightMM (dpyinfo->display, screen_number);
10421 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10422 dpyinfo->resy = (mm < 1) ? 100 : pixels * 25.4 / mm;
10423 pixels = DisplayWidth (dpyinfo->display, screen_number);
10424 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10425 mm = DisplayWidthMM (dpyinfo->display, screen_number);
10426 dpyinfo->resx = (mm < 1) ? 100 : pixels * 25.4 / mm;
10427 }
10428
10429 dpyinfo->Xatom_wm_protocols
10430 = XInternAtom (dpyinfo->display, "WM_PROTOCOLS", False);
10431 dpyinfo->Xatom_wm_take_focus
10432 = XInternAtom (dpyinfo->display, "WM_TAKE_FOCUS", False);
10433 dpyinfo->Xatom_wm_save_yourself
10434 = XInternAtom (dpyinfo->display, "WM_SAVE_YOURSELF", False);
10435 dpyinfo->Xatom_wm_delete_window
10436 = XInternAtom (dpyinfo->display, "WM_DELETE_WINDOW", False);
10437 dpyinfo->Xatom_wm_change_state
10438 = XInternAtom (dpyinfo->display, "WM_CHANGE_STATE", False);
10439 dpyinfo->Xatom_wm_configure_denied
10440 = XInternAtom (dpyinfo->display, "WM_CONFIGURE_DENIED", False);
10441 dpyinfo->Xatom_wm_window_moved
10442 = XInternAtom (dpyinfo->display, "WM_MOVED", False);
10443 dpyinfo->Xatom_wm_client_leader
10444 = XInternAtom (dpyinfo->display, "WM_CLIENT_LEADER", False);
10445 dpyinfo->Xatom_editres
10446 = XInternAtom (dpyinfo->display, "Editres", False);
10447 dpyinfo->Xatom_CLIPBOARD
10448 = XInternAtom (dpyinfo->display, "CLIPBOARD", False);
10449 dpyinfo->Xatom_TIMESTAMP
10450 = XInternAtom (dpyinfo->display, "TIMESTAMP", False);
10451 dpyinfo->Xatom_TEXT
10452 = XInternAtom (dpyinfo->display, "TEXT", False);
10453 dpyinfo->Xatom_COMPOUND_TEXT
10454 = XInternAtom (dpyinfo->display, "COMPOUND_TEXT", False);
10455 dpyinfo->Xatom_UTF8_STRING
10456 = XInternAtom (dpyinfo->display, "UTF8_STRING", False);
10457 dpyinfo->Xatom_DELETE
10458 = XInternAtom (dpyinfo->display, "DELETE", False);
10459 dpyinfo->Xatom_MULTIPLE
10460 = XInternAtom (dpyinfo->display, "MULTIPLE", False);
10461 dpyinfo->Xatom_INCR
10462 = XInternAtom (dpyinfo->display, "INCR", False);
10463 dpyinfo->Xatom_EMACS_TMP
10464 = XInternAtom (dpyinfo->display, "_EMACS_TMP_", False);
10465 dpyinfo->Xatom_TARGETS
10466 = XInternAtom (dpyinfo->display, "TARGETS", False);
10467 dpyinfo->Xatom_NULL
10468 = XInternAtom (dpyinfo->display, "NULL", False);
10469 dpyinfo->Xatom_ATOM_PAIR
10470 = XInternAtom (dpyinfo->display, "ATOM_PAIR", False);
10471 /* For properties of font. */
10472 dpyinfo->Xatom_PIXEL_SIZE
10473 = XInternAtom (dpyinfo->display, "PIXEL_SIZE", False);
10474 dpyinfo->Xatom_AVERAGE_WIDTH
10475 = XInternAtom (dpyinfo->display, "AVERAGE_WIDTH", False);
10476 dpyinfo->Xatom_MULE_BASELINE_OFFSET
10477 = XInternAtom (dpyinfo->display, "_MULE_BASELINE_OFFSET", False);
10478 dpyinfo->Xatom_MULE_RELATIVE_COMPOSE
10479 = XInternAtom (dpyinfo->display, "_MULE_RELATIVE_COMPOSE", False);
10480 dpyinfo->Xatom_MULE_DEFAULT_ASCENT
10481 = XInternAtom (dpyinfo->display, "_MULE_DEFAULT_ASCENT", False);
10482
10483 /* Ghostscript support. */
10484 dpyinfo->Xatom_PAGE = XInternAtom (dpyinfo->display, "PAGE", False);
10485 dpyinfo->Xatom_DONE = XInternAtom (dpyinfo->display, "DONE", False);
10486
10487 dpyinfo->Xatom_Scrollbar = XInternAtom (dpyinfo->display, "SCROLLBAR",
10488 False);
10489
10490 dpyinfo->cut_buffers_initialized = 0;
10491
10492 connection = ConnectionNumber (dpyinfo->display);
10493 dpyinfo->connection = connection;
10494
10495 {
10496 char null_bits[1];
10497
10498 null_bits[0] = 0x00;
10499
10500 dpyinfo->null_pixel
10501 = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
10502 null_bits, 1, 1, (long) 0, (long) 0,
10503 1);
10504 }
10505
10506 {
10507 extern int gray_bitmap_width, gray_bitmap_height;
10508 extern char *gray_bitmap_bits;
10509 dpyinfo->gray
10510 = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
10511 gray_bitmap_bits,
10512 gray_bitmap_width, gray_bitmap_height,
10513 (unsigned long) 1, (unsigned long) 0, 1);
10514 }
10515
10516 #ifdef HAVE_X_I18N
10517 xim_initialize (dpyinfo, resource_name);
10518 #endif
10519
10520 #ifdef subprocesses
10521 /* This is only needed for distinguishing keyboard and process input. */
10522 if (connection != 0)
10523 add_keyboard_wait_descriptor (connection);
10524 #endif
10525
10526 #ifndef F_SETOWN_BUG
10527 #ifdef F_SETOWN
10528 #ifdef F_SETOWN_SOCK_NEG
10529 /* stdin is a socket here */
10530 fcntl (connection, F_SETOWN, -getpid ());
10531 #else /* ! defined (F_SETOWN_SOCK_NEG) */
10532 fcntl (connection, F_SETOWN, getpid ());
10533 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
10534 #endif /* ! defined (F_SETOWN) */
10535 #endif /* F_SETOWN_BUG */
10536
10537 #ifdef SIGIO
10538 if (interrupt_input)
10539 init_sigio (connection);
10540 #endif /* ! defined (SIGIO) */
10541
10542 #ifdef USE_LUCID
10543 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
10544 /* Make sure that we have a valid font for dialog boxes
10545 so that Xt does not crash. */
10546 {
10547 Display *dpy = dpyinfo->display;
10548 XrmValue d, fr, to;
10549 Font font;
10550 int count;
10551
10552 d.addr = (XPointer)&dpy;
10553 d.size = sizeof (Display *);
10554 fr.addr = XtDefaultFont;
10555 fr.size = sizeof (XtDefaultFont);
10556 to.size = sizeof (Font *);
10557 to.addr = (XPointer)&font;
10558 count = x_catch_errors (dpy);
10559 if (!XtCallConverter (dpy, XtCvtStringToFont, &d, 1, &fr, &to, NULL))
10560 abort ();
10561 if (x_had_errors_p (dpy) || !XQueryFont (dpy, font))
10562 XrmPutLineResource (&xrdb, "Emacs.dialog.*.font: 9x15");
10563 x_uncatch_errors (dpy, count);
10564 }
10565 #endif
10566 #endif
10567
10568 /* See if we should run in synchronous mode. This is useful
10569 for debugging X code. */
10570 {
10571 Lisp_Object value;
10572 value = display_x_get_resource (dpyinfo,
10573 build_string ("synchronous"),
10574 build_string ("Synchronous"),
10575 Qnil, Qnil);
10576 if (STRINGP (value)
10577 && (!strcmp (SDATA (value), "true")
10578 || !strcmp (SDATA (value), "on")))
10579 XSynchronize (dpyinfo->display, True);
10580 }
10581
10582 {
10583 Lisp_Object value;
10584 value = display_x_get_resource (dpyinfo,
10585 build_string ("useXIM"),
10586 build_string ("UseXIM"),
10587 Qnil, Qnil);
10588 #ifdef USE_XIM
10589 if (STRINGP (value)
10590 && (!strcmp (XSTRING (value)->data, "false")
10591 || !strcmp (XSTRING (value)->data, "off")))
10592 use_xim = 0;
10593 #else
10594 if (STRINGP (value)
10595 && (!strcmp (XSTRING (value)->data, "true")
10596 || !strcmp (XSTRING (value)->data, "on")))
10597 use_xim = 1;
10598 #endif
10599 }
10600
10601 #ifdef HAVE_X_SM
10602 /* Only do this for the very first display in the Emacs session.
10603 Ignore X session management when Emacs was first started on a
10604 tty. */
10605 if (device->id == 1)
10606 x_session_initialize (dpyinfo);
10607 #endif
10608
10609 UNBLOCK_INPUT;
10610
10611 return dpyinfo;
10612 }
10613 \f
10614 /* Get rid of display DPYINFO, assuming all frames are already gone,
10615 and without sending any more commands to the X server. */
10616
10617 void
10618 x_delete_display (dpyinfo)
10619 struct x_display_info *dpyinfo;
10620 {
10621 int i;
10622 struct device *d;
10623
10624 /* Delete the generic struct device for this X display. */
10625 for (d = device_list; d; d = d->next_device)
10626 if (d->type == output_x_window && d->display_info.x == dpyinfo)
10627 {
10628 /* Close X session management when we close its display. */
10629 if (d->id == 1 && x_session_have_connection ())
10630 x_session_close();
10631
10632 delete_device (d);
10633 break;
10634 }
10635
10636 delete_keyboard_wait_descriptor (dpyinfo->connection);
10637
10638 /* Discard this display from x_display_name_list and x_display_list.
10639 We can't use Fdelq because that can quit. */
10640 if (! NILP (x_display_name_list)
10641 && EQ (XCAR (x_display_name_list), dpyinfo->name_list_element))
10642 x_display_name_list = XCDR (x_display_name_list);
10643 else
10644 {
10645 Lisp_Object tail;
10646
10647 tail = x_display_name_list;
10648 while (CONSP (tail) && CONSP (XCDR (tail)))
10649 {
10650 if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
10651 {
10652 XSETCDR (tail, XCDR (XCDR (tail)));
10653 break;
10654 }
10655 tail = XCDR (tail);
10656 }
10657 }
10658
10659 if (next_noop_dpyinfo == dpyinfo)
10660 next_noop_dpyinfo = dpyinfo->next;
10661
10662 if (x_display_list == dpyinfo)
10663 x_display_list = dpyinfo->next;
10664 else
10665 {
10666 struct x_display_info *tail;
10667
10668 for (tail = x_display_list; tail; tail = tail->next)
10669 if (tail->next == dpyinfo)
10670 tail->next = tail->next->next;
10671 }
10672
10673 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
10674 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
10675 XrmDestroyDatabase (dpyinfo->xrdb);
10676 #endif
10677 #endif
10678 #ifdef HAVE_X_I18N
10679 if (dpyinfo->xim)
10680 xim_close_dpy (dpyinfo);
10681 #endif
10682
10683 /* Free the font names in the font table. */
10684 for (i = 0; i < dpyinfo->n_fonts; i++)
10685 if (dpyinfo->font_table[i].name)
10686 {
10687 if (dpyinfo->font_table[i].name != dpyinfo->font_table[i].full_name)
10688 xfree (dpyinfo->font_table[i].full_name);
10689 xfree (dpyinfo->font_table[i].name);
10690 }
10691
10692 if (dpyinfo->font_table && dpyinfo->font_table->font_encoder)
10693 xfree (dpyinfo->font_table->font_encoder);
10694
10695 if (dpyinfo->font_table)
10696 xfree (dpyinfo->font_table);
10697 xfree (dpyinfo->x_id_name);
10698 xfree (dpyinfo->color_cells);
10699 xfree (dpyinfo);
10700 }
10701
10702 #ifdef USE_X_TOOLKIT
10703
10704 /* Atimer callback function for TIMER. Called every 0.1s to process
10705 Xt timeouts, if needed. We must avoid calling XtAppPending as
10706 much as possible because that function does an implicit XFlush
10707 that slows us down. */
10708
10709 static void
10710 x_process_timeouts (timer)
10711 struct atimer *timer;
10712 {
10713 if (toolkit_scroll_bar_interaction || popup_activated ())
10714 {
10715 BLOCK_INPUT;
10716 while (XtAppPending (Xt_app_con) & XtIMTimer)
10717 XtAppProcessEvent (Xt_app_con, XtIMTimer);
10718 UNBLOCK_INPUT;
10719 }
10720 }
10721
10722 #endif /* USE_X_TOOLKIT */
10723
10724 \f
10725 /* Set up use of X before we make the first connection. */
10726
10727 extern frame_parm_handler x_frame_parm_handlers[];
10728
10729 static struct redisplay_interface x_redisplay_interface =
10730 {
10731 x_frame_parm_handlers,
10732 x_produce_glyphs,
10733 x_write_glyphs,
10734 x_insert_glyphs,
10735 x_clear_end_of_line,
10736 x_scroll_run,
10737 x_after_update_window_line,
10738 x_update_window_begin,
10739 x_update_window_end,
10740 x_cursor_to,
10741 x_flush,
10742 #ifdef XFlush
10743 x_flush,
10744 #else
10745 0, /* flush_display_optional */
10746 #endif
10747 x_clear_window_mouse_face,
10748 x_get_glyph_overhangs,
10749 x_fix_overlapping_area,
10750 x_draw_fringe_bitmap,
10751 0, /* define_fringe_bitmap */
10752 0, /* destroy_fringe_bitmap */
10753 x_per_char_metric,
10754 x_encode_char,
10755 x_compute_glyph_string_overhangs,
10756 x_draw_glyph_string,
10757 x_define_frame_cursor,
10758 x_clear_frame_area,
10759 x_draw_window_cursor,
10760 x_draw_vertical_window_border,
10761 x_shift_glyphs_for_insert
10762 };
10763
10764
10765 /* This function is called when the last frame on a display is deleted. */
10766 void
10767 x_delete_device (struct device *device)
10768 {
10769 struct x_display_info *dpyinfo = device->display_info.x;
10770 int i;
10771
10772 BLOCK_INPUT;
10773 /* Free the fonts in the font table. */
10774 for (i = 0; i < dpyinfo->n_fonts; i++)
10775 if (dpyinfo->font_table[i].name)
10776 {
10777 XFreeFont (dpyinfo->display, dpyinfo->font_table[i].font);
10778 }
10779
10780 x_destroy_all_bitmaps (dpyinfo);
10781 XSetCloseDownMode (dpyinfo->display, DestroyAll);
10782
10783 #ifdef USE_X_TOOLKIT
10784 XtCloseDisplay (dpyinfo->display);
10785 #else
10786 #ifdef USE_GTK
10787 xg_display_close (dpyinfo->display);
10788 #else
10789 XCloseDisplay (dpyinfo->display);
10790 #endif
10791 #endif
10792
10793 x_delete_display (dpyinfo);
10794 UNBLOCK_INPUT;
10795 }
10796
10797
10798 struct device *
10799 x_create_device (struct x_display_info *dpyinfo)
10800 {
10801 struct device *device;
10802
10803 device = create_device ();
10804
10805 device->type = output_x_window;
10806 device->display_info.x = dpyinfo;
10807 dpyinfo->device = device;
10808
10809 /* kboard is initialized in x_term_init. */
10810
10811 device->clear_frame_hook = x_clear_frame;
10812 device->ins_del_lines_hook = x_ins_del_lines;
10813 device->delete_glyphs_hook = x_delete_glyphs;
10814 device->ring_bell_hook = XTring_bell;
10815 device->reset_terminal_modes_hook = XTreset_terminal_modes;
10816 device->set_terminal_modes_hook = XTset_terminal_modes;
10817 device->update_begin_hook = x_update_begin;
10818 device->update_end_hook = x_update_end;
10819 device->set_terminal_window_hook = XTset_terminal_window;
10820 device->read_socket_hook = XTread_socket;
10821 device->frame_up_to_date_hook = XTframe_up_to_date;
10822 device->mouse_position_hook = XTmouse_position;
10823 device->frame_rehighlight_hook = XTframe_rehighlight;
10824 device->frame_raise_lower_hook = XTframe_raise_lower;
10825 device->set_vertical_scroll_bar_hook = XTset_vertical_scroll_bar;
10826 device->condemn_scroll_bars_hook = XTcondemn_scroll_bars;
10827 device->redeem_scroll_bar_hook = XTredeem_scroll_bar;
10828 device->judge_scroll_bars_hook = XTjudge_scroll_bars;
10829
10830 device->delete_frame_hook = x_destroy_window;
10831 device->delete_device_hook = x_delete_device;
10832
10833 device->rif = &x_redisplay_interface;
10834 device->scroll_region_ok = 1; /* We'll scroll partial frames. */
10835 device->char_ins_del_ok = 1;
10836 device->line_ins_del_ok = 1; /* We'll just blt 'em. */
10837 device->fast_clear_end_of_line = 1; /* X does this well. */
10838 device->memory_below_frame = 0; /* We don't remember what scrolls
10839 off the bottom. */
10840
10841 return device;
10842 }
10843
10844 void
10845 x_initialize ()
10846 {
10847 baud_rate = 19200;
10848
10849 x_noop_count = 0;
10850 last_tool_bar_item = -1;
10851 any_help_event_p = 0;
10852 ignore_next_mouse_click_timeout = 0;
10853
10854 #ifdef USE_GTK
10855 current_count = -1;
10856 #endif
10857
10858 /* Try to use interrupt input; if we can't, then start polling. */
10859 Fset_input_mode (Qt, Qnil, Qt, Qnil);
10860
10861 #ifdef USE_X_TOOLKIT
10862 XtToolkitInitialize ();
10863
10864 Xt_app_con = XtCreateApplicationContext ();
10865
10866 /* Register a converter from strings to pixels, which uses
10867 Emacs' color allocation infrastructure. */
10868 XtAppSetTypeConverter (Xt_app_con,
10869 XtRString, XtRPixel, cvt_string_to_pixel,
10870 cvt_string_to_pixel_args,
10871 XtNumber (cvt_string_to_pixel_args),
10872 XtCacheByDisplay, cvt_pixel_dtor);
10873
10874 XtAppSetFallbackResources (Xt_app_con, Xt_default_resources);
10875
10876 /* Install an asynchronous timer that processes Xt timeout events
10877 every 0.1s. This is necessary because some widget sets use
10878 timeouts internally, for example the LessTif menu bar, or the
10879 Xaw3d scroll bar. When Xt timouts aren't processed, these
10880 widgets don't behave normally. */
10881 {
10882 EMACS_TIME interval;
10883 EMACS_SET_SECS_USECS (interval, 0, 100000);
10884 start_atimer (ATIMER_CONTINUOUS, interval, x_process_timeouts, 0);
10885 }
10886 #endif
10887
10888 #ifdef USE_TOOLKIT_SCROLL_BARS
10889 #ifndef USE_GTK
10890 xaw3d_arrow_scroll = False;
10891 xaw3d_pick_top = True;
10892 #endif
10893 #endif
10894
10895 /* Note that there is no real way portable across R3/R4 to get the
10896 original error handler. */
10897 XSetErrorHandler (x_error_handler);
10898 XSetIOErrorHandler (x_io_error_quitter);
10899
10900 /* Disable Window Change signals; they are handled by X events. */
10901 #if 0 /* Don't. We may want to open tty frames later. */
10902 #ifdef SIGWINCH
10903 signal (SIGWINCH, SIG_DFL);
10904 #endif /* SIGWINCH */
10905 #endif
10906
10907 signal (SIGPIPE, x_connection_signal);
10908 }
10909
10910
10911 void
10912 syms_of_xterm ()
10913 {
10914 staticpro (&x_error_message_string);
10915 x_error_message_string = Qnil;
10916
10917 staticpro (&x_display_name_list);
10918 x_display_name_list = Qnil;
10919
10920 staticpro (&last_mouse_scroll_bar);
10921 last_mouse_scroll_bar = Qnil;
10922
10923 staticpro (&Qvendor_specific_keysyms);
10924 Qvendor_specific_keysyms = intern ("vendor-specific-keysyms");
10925
10926 staticpro (&Qutf_8);
10927 Qutf_8 = intern ("utf-8");
10928 staticpro (&Qlatin_1);
10929 Qlatin_1 = intern ("latin-1");
10930
10931 staticpro (&last_mouse_press_frame);
10932 last_mouse_press_frame = Qnil;
10933
10934 DEFVAR_BOOL ("x-use-underline-position-properties",
10935 &x_use_underline_position_properties,
10936 doc: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10937 nil means ignore them. If you encounter fonts with bogus
10938 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10939 to 4.1, set this to nil. */);
10940 x_use_underline_position_properties = 1;
10941
10942 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10943 &x_mouse_click_focus_ignore_position,
10944 doc: /* Non-nil means that a mouse click to focus a frame does not move point.
10945 This variable is only used when the window manager requires that you
10946 click on a frame to select it (give it focus). In that case, a value
10947 of nil, means that the selected window and cursor position changes to
10948 reflect the mouse click position, while a non-nil value means that the
10949 selected window or cursor position is preserved. */);
10950 x_mouse_click_focus_ignore_position = 0;
10951
10952 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
10953 doc: /* What X toolkit scroll bars Emacs uses.
10954 A value of nil means Emacs doesn't use X toolkit scroll bars.
10955 Otherwise, value is a symbol describing the X toolkit. */);
10956 #ifdef USE_TOOLKIT_SCROLL_BARS
10957 #ifdef USE_MOTIF
10958 Vx_toolkit_scroll_bars = intern ("motif");
10959 #elif defined HAVE_XAW3D
10960 Vx_toolkit_scroll_bars = intern ("xaw3d");
10961 #elif USE_GTK
10962 Vx_toolkit_scroll_bars = intern ("gtk");
10963 #else
10964 Vx_toolkit_scroll_bars = intern ("xaw");
10965 #endif
10966 #else
10967 Vx_toolkit_scroll_bars = Qnil;
10968 #endif
10969
10970 staticpro (&last_mouse_motion_frame);
10971 last_mouse_motion_frame = Qnil;
10972
10973 Qmodifier_value = intern ("modifier-value");
10974 Qalt = intern ("alt");
10975 Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
10976 Qhyper = intern ("hyper");
10977 Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
10978 Qmeta = intern ("meta");
10979 Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
10980 Qsuper = intern ("super");
10981 Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
10982
10983 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym,
10984 doc: /* Which keys Emacs uses for the alt modifier.
10985 This should be one of the symbols `alt', `hyper', `meta', `super'.
10986 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10987 is nil, which is the same as `alt'. */);
10988 Vx_alt_keysym = Qnil;
10989
10990 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym,
10991 doc: /* Which keys Emacs uses for the hyper modifier.
10992 This should be one of the symbols `alt', `hyper', `meta', `super'.
10993 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10994 default is nil, which is the same as `hyper'. */);
10995 Vx_hyper_keysym = Qnil;
10996
10997 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym,
10998 doc: /* Which keys Emacs uses for the meta modifier.
10999 This should be one of the symbols `alt', `hyper', `meta', `super'.
11000 For example, `meta' means use the Meta_L and Meta_R keysyms. The
11001 default is nil, which is the same as `meta'. */);
11002 Vx_meta_keysym = Qnil;
11003
11004 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym,
11005 doc: /* Which keys Emacs uses for the super modifier.
11006 This should be one of the symbols `alt', `hyper', `meta', `super'.
11007 For example, `super' means use the Super_L and Super_R keysyms. The
11008 default is nil, which is the same as `super'. */);
11009 Vx_super_keysym = Qnil;
11010
11011 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table,
11012 doc: /* Hash table of character codes indexed by X keysym codes. */);
11013 Vx_keysym_table = make_hash_table (Qeql, make_number (900),
11014 make_float (DEFAULT_REHASH_SIZE),
11015 make_float (DEFAULT_REHASH_THRESHOLD),
11016 Qnil, Qnil, Qnil);
11017 }
11018
11019 #endif /* HAVE_X_WINDOWS */
11020
11021 /* arch-tag: 6d4e4cb7-abc1-4302-9585-d84dcfb09d0f
11022 (do not change this comment) */