; Fix more-recent commit messages too
[emacs.git] / src / xterm.c
1 /* X Communication module for terminals which understand the X protocol.
2
3 Copyright (C) 1989, 1993-2015 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 3 of the License, or
10 (at your option) 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. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
21 /* Xt features made by Fred Pierresteguy. */
22
23 #include <config.h>
24 #include <stdio.h>
25
26 #include "lisp.h"
27 #include "blockinput.h"
28 #include "syssignal.h"
29
30 /* This may include sys/types.h, and that somehow loses
31 if this is not done before the other system files. */
32 #include "xterm.h"
33 #include <X11/cursorfont.h>
34
35 /* If we have Xfixes extension, use it for pointer blanking. */
36 #ifdef HAVE_XFIXES
37 #include <X11/extensions/Xfixes.h>
38 #endif
39
40 /* Using Xft implies that XRender is available. */
41 #ifdef HAVE_XFT
42 #include <X11/extensions/Xrender.h>
43 #endif
44
45 /* Load sys/types.h if not already loaded.
46 In some systems loading it twice is suicidal. */
47 #ifndef makedev
48 #include <sys/types.h>
49 #endif /* makedev */
50
51 #include <sys/ioctl.h>
52
53 #include "systime.h"
54
55 #include <fcntl.h>
56 #include <errno.h>
57 #include <sys/stat.h>
58 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
59 /* #include <sys/param.h> */
60
61 #include "charset.h"
62 #include "character.h"
63 #include "coding.h"
64 #include "frame.h"
65 #include "dispextern.h"
66 #include "fontset.h"
67 #include "termhooks.h"
68 #include "termopts.h"
69 #include "termchar.h"
70 #include "emacs-icon.h"
71 #include "disptab.h"
72 #include "buffer.h"
73 #include "window.h"
74 #include "keyboard.h"
75 #include "intervals.h"
76 #include "process.h"
77 #include "atimer.h"
78 #include "keymap.h"
79 #include "font.h"
80 #include "xsettings.h"
81 #include "xgselect.h"
82 #include "sysselect.h"
83 #include "menu.h"
84
85 #ifdef USE_X_TOOLKIT
86 #include <X11/Shell.h>
87 #endif
88
89 #include <unistd.h>
90
91 #ifdef USE_GTK
92 #include "gtkutil.h"
93 #ifdef HAVE_GTK3
94 #include <X11/Xproto.h>
95 #endif
96 #endif
97
98 #if defined (USE_LUCID) || defined (USE_MOTIF)
99 #include "../lwlib/xlwmenu.h"
100 #endif
101
102 #ifdef USE_X_TOOLKIT
103 #if !defined (NO_EDITRES)
104 #define HACK_EDITRES
105 extern void _XEditResCheckMessages (Widget, XtPointer, XEvent *, Boolean *);
106 #endif /* not NO_EDITRES */
107
108 /* Include toolkit specific headers for the scroll bar widget. */
109
110 #ifdef USE_TOOLKIT_SCROLL_BARS
111 #if defined USE_MOTIF
112 #include <Xm/Xm.h> /* For LESSTIF_VERSION */
113 #include <Xm/ScrollBar.h>
114 #else /* !USE_MOTIF i.e. use Xaw */
115
116 #ifdef HAVE_XAW3D
117 #include <X11/Xaw3d/Simple.h>
118 #include <X11/Xaw3d/Scrollbar.h>
119 #include <X11/Xaw3d/ThreeD.h>
120 #else /* !HAVE_XAW3D */
121 #include <X11/Xaw/Simple.h>
122 #include <X11/Xaw/Scrollbar.h>
123 #endif /* !HAVE_XAW3D */
124 #ifndef XtNpickTop
125 #define XtNpickTop "pickTop"
126 #endif /* !XtNpickTop */
127 #endif /* !USE_MOTIF */
128 #endif /* USE_TOOLKIT_SCROLL_BARS */
129
130 #endif /* USE_X_TOOLKIT */
131
132 #ifdef USE_X_TOOLKIT
133 #include "widget.h"
134 #ifndef XtNinitialState
135 #define XtNinitialState "initialState"
136 #endif
137 #endif
138
139 #include "bitmaps/gray.xbm"
140
141 #ifdef HAVE_XKB
142 #include <X11/XKBlib.h>
143 #endif
144
145 /* Default to using XIM if available. */
146 #ifdef USE_XIM
147 bool use_xim = true;
148 #else
149 bool use_xim = false; /* configure --without-xim */
150 #endif
151
152 /* Non-zero means that a HELP_EVENT has been generated since Emacs
153 start. */
154
155 static bool any_help_event_p;
156
157 /* This is a chain of structures for all the X displays currently in
158 use. */
159
160 struct x_display_info *x_display_list;
161
162 #ifdef USE_X_TOOLKIT
163
164 /* The application context for Xt use. */
165 XtAppContext Xt_app_con;
166 static String Xt_default_resources[] = {0};
167
168 /* Non-zero means user is interacting with a toolkit scroll bar. */
169 static bool toolkit_scroll_bar_interaction;
170
171 #endif /* USE_X_TOOLKIT */
172
173 /* Non-zero timeout value means ignore next mouse click if it arrives
174 before that timeout elapses (i.e. as part of the same sequence of
175 events resulting from clicking on a frame to select it). */
176
177 static Time ignore_next_mouse_click_timeout;
178
179 /* Used locally within XTread_socket. */
180
181 static int x_noop_count;
182
183 #ifdef USE_GTK
184 /* The name of the Emacs icon file. */
185 static Lisp_Object xg_default_icon_file;
186 #endif
187
188 /* Some functions take this as char *, not const char *. */
189 static char emacs_class[] = EMACS_CLASS;
190
191 enum xembed_info
192 {
193 XEMBED_MAPPED = 1 << 0
194 };
195
196 enum xembed_message
197 {
198 XEMBED_EMBEDDED_NOTIFY = 0,
199 XEMBED_WINDOW_ACTIVATE = 1,
200 XEMBED_WINDOW_DEACTIVATE = 2,
201 XEMBED_REQUEST_FOCUS = 3,
202 XEMBED_FOCUS_IN = 4,
203 XEMBED_FOCUS_OUT = 5,
204 XEMBED_FOCUS_NEXT = 6,
205 XEMBED_FOCUS_PREV = 7,
206
207 XEMBED_MODALITY_ON = 10,
208 XEMBED_MODALITY_OFF = 11,
209 XEMBED_REGISTER_ACCELERATOR = 12,
210 XEMBED_UNREGISTER_ACCELERATOR = 13,
211 XEMBED_ACTIVATE_ACCELERATOR = 14
212 };
213
214 static bool x_alloc_nearest_color_1 (Display *, Colormap, XColor *);
215 static void x_set_window_size_1 (struct frame *, bool, int, int);
216 static void x_raise_frame (struct frame *);
217 static void x_lower_frame (struct frame *);
218 static const XColor *x_color_cells (Display *, int *);
219 static int x_io_error_quitter (Display *);
220 static struct terminal *x_create_terminal (struct x_display_info *);
221 static void x_update_end (struct frame *);
222 static void XTframe_up_to_date (struct frame *);
223 static void x_clear_frame (struct frame *);
224 static _Noreturn void x_ins_del_lines (struct frame *, int, int);
225 static void frame_highlight (struct frame *);
226 static void frame_unhighlight (struct frame *);
227 static void x_new_focus_frame (struct x_display_info *, struct frame *);
228 static void x_focus_changed (int, int, struct x_display_info *,
229 struct frame *, struct input_event *);
230 static void XTframe_rehighlight (struct frame *);
231 static void x_frame_rehighlight (struct x_display_info *);
232 static void x_draw_hollow_cursor (struct window *, struct glyph_row *);
233 static void x_draw_bar_cursor (struct window *, struct glyph_row *, int,
234 enum text_cursor_kinds);
235
236 static void x_clip_to_row (struct window *, struct glyph_row *,
237 enum glyph_row_area, GC);
238 static void x_flush (struct frame *f);
239 static void x_update_begin (struct frame *);
240 static void x_update_window_begin (struct window *);
241 static struct scroll_bar *x_window_to_scroll_bar (Display *, Window, int);
242 static void x_scroll_bar_report_motion (struct frame **, Lisp_Object *,
243 enum scroll_bar_part *,
244 Lisp_Object *, Lisp_Object *,
245 Time *);
246 static void x_horizontal_scroll_bar_report_motion (struct frame **, Lisp_Object *,
247 enum scroll_bar_part *,
248 Lisp_Object *, Lisp_Object *,
249 Time *);
250 static bool x_handle_net_wm_state (struct frame *, const XPropertyEvent *);
251 static void x_check_fullscreen (struct frame *);
252 static void x_check_expected_move (struct frame *, int, int);
253 static void x_sync_with_move (struct frame *, int, int, bool);
254 static int handle_one_xevent (struct x_display_info *,
255 const XEvent *, int *,
256 struct input_event *);
257 #if ! (defined USE_X_TOOLKIT || defined USE_MOTIF)
258 static int x_dispatch_event (XEvent *, Display *);
259 #endif
260 /* Don't declare this _Noreturn because we want no
261 interference with debugging failing X calls. */
262 static void x_connection_closed (Display *, const char *);
263 static void x_wm_set_window_state (struct frame *, int);
264 static void x_wm_set_icon_pixmap (struct frame *, ptrdiff_t);
265 static void x_initialize (void);
266
267 static bool get_current_wm_state (struct frame *, Window, int *, bool *);
268
269 /* Flush display of frame F. */
270
271 static void
272 x_flush (struct frame *f)
273 {
274 eassert (f && FRAME_X_P (f));
275 /* Don't call XFlush when it is not safe to redisplay; the X
276 connection may be broken. */
277 if (!NILP (Vinhibit_redisplay))
278 return;
279
280 block_input ();
281 XFlush (FRAME_X_DISPLAY (f));
282 unblock_input ();
283 }
284
285
286 /* Remove calls to XFlush by defining XFlush to an empty replacement.
287 Calls to XFlush should be unnecessary because the X output buffer
288 is flushed automatically as needed by calls to XPending,
289 XNextEvent, or XWindowEvent according to the XFlush man page.
290 XTread_socket calls XPending. Removing XFlush improves
291 performance. */
292
293 #define XFlush(DISPLAY) (void) 0
294
295 \f
296 /***********************************************************************
297 Debugging
298 ***********************************************************************/
299
300 #if false
301
302 /* This is a function useful for recording debugging information about
303 the sequence of occurrences in this file. */
304
305 struct record
306 {
307 char *locus;
308 int type;
309 };
310
311 struct record event_record[100];
312
313 int event_record_index;
314
315 void
316 record_event (char *locus, int type)
317 {
318 if (event_record_index == ARRAYELTS (event_record))
319 event_record_index = 0;
320
321 event_record[event_record_index].locus = locus;
322 event_record[event_record_index].type = type;
323 event_record_index++;
324 }
325
326 #endif
327
328
329 \f
330 /* Return the struct x_display_info corresponding to DPY. */
331
332 struct x_display_info *
333 x_display_info_for_display (Display *dpy)
334 {
335 struct x_display_info *dpyinfo;
336
337 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
338 if (dpyinfo->display == dpy)
339 return dpyinfo;
340
341 return 0;
342 }
343
344 static Window
345 x_find_topmost_parent (struct frame *f)
346 {
347 struct x_output *x = f->output_data.x;
348 Window win = None, wi = x->parent_desc;
349 Display *dpy = FRAME_X_DISPLAY (f);
350
351 while (wi != FRAME_DISPLAY_INFO (f)->root_window)
352 {
353 Window root;
354 Window *children;
355 unsigned int nchildren;
356
357 win = wi;
358 if (XQueryTree (dpy, win, &root, &wi, &children, &nchildren))
359 XFree (children);
360 else
361 break;
362 }
363
364 return win;
365 }
366
367 #define OPAQUE 0xffffffff
368
369 void
370 x_set_frame_alpha (struct frame *f)
371 {
372 struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
373 Display *dpy = FRAME_X_DISPLAY (f);
374 Window win = FRAME_OUTER_WINDOW (f);
375 double alpha = 1.0;
376 double alpha_min = 1.0;
377 unsigned long opac;
378 Window parent;
379
380 if (dpyinfo->x_highlight_frame == f)
381 alpha = f->alpha[0];
382 else
383 alpha = f->alpha[1];
384
385 if (FLOATP (Vframe_alpha_lower_limit))
386 alpha_min = XFLOAT_DATA (Vframe_alpha_lower_limit);
387 else if (INTEGERP (Vframe_alpha_lower_limit))
388 alpha_min = (XINT (Vframe_alpha_lower_limit)) / 100.0;
389
390 if (alpha < 0.0)
391 return;
392 else if (alpha > 1.0)
393 alpha = 1.0;
394 else if (0.0 <= alpha && alpha < alpha_min && alpha_min <= 1.0)
395 alpha = alpha_min;
396
397 opac = alpha * OPAQUE;
398
399 x_catch_errors (dpy);
400
401 /* If there is a parent from the window manager, put the property there
402 also, to work around broken window managers that fail to do that.
403 Do this unconditionally as this function is called on reparent when
404 alpha has not changed on the frame. */
405
406 parent = x_find_topmost_parent (f);
407 if (parent != None)
408 XChangeProperty (dpy, parent, dpyinfo->Xatom_net_wm_window_opacity,
409 XA_CARDINAL, 32, PropModeReplace,
410 (unsigned char *) &opac, 1);
411
412 /* return unless necessary */
413 {
414 unsigned char *data;
415 Atom actual;
416 int rc, format;
417 unsigned long n, left;
418
419 rc = XGetWindowProperty (dpy, win, dpyinfo->Xatom_net_wm_window_opacity,
420 0, 1, False, XA_CARDINAL,
421 &actual, &format, &n, &left,
422 &data);
423
424 if (rc == Success && actual != None)
425 {
426 unsigned long value = *(unsigned long *)data;
427 XFree (data);
428 if (value == opac)
429 {
430 x_uncatch_errors ();
431 return;
432 }
433 }
434 }
435
436 XChangeProperty (dpy, win, dpyinfo->Xatom_net_wm_window_opacity,
437 XA_CARDINAL, 32, PropModeReplace,
438 (unsigned char *) &opac, 1);
439 x_uncatch_errors ();
440 }
441
442 /***********************************************************************
443 Starting and ending an update
444 ***********************************************************************/
445
446 /* Start an update of frame F. This function is installed as a hook
447 for update_begin, i.e. it is called when update_begin is called.
448 This function is called prior to calls to x_update_window_begin for
449 each window being updated. Currently, there is nothing to do here
450 because all interesting stuff is done on a window basis. */
451
452 static void
453 x_update_begin (struct frame *f)
454 {
455 /* Nothing to do. */
456 }
457
458
459 /* Start update of window W. */
460
461 static void
462 x_update_window_begin (struct window *w)
463 {
464 struct frame *f = XFRAME (WINDOW_FRAME (w));
465 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
466
467 w->output_cursor = w->cursor;
468
469 block_input ();
470
471 if (f == hlinfo->mouse_face_mouse_frame)
472 {
473 /* Don't do highlighting for mouse motion during the update. */
474 hlinfo->mouse_face_defer = true;
475
476 /* If F needs to be redrawn, simply forget about any prior mouse
477 highlighting. */
478 if (FRAME_GARBAGED_P (f))
479 hlinfo->mouse_face_window = Qnil;
480 }
481
482 unblock_input ();
483 }
484
485
486 /* Draw a vertical window border from (x,y0) to (x,y1) */
487
488 static void
489 x_draw_vertical_window_border (struct window *w, int x, int y0, int y1)
490 {
491 struct frame *f = XFRAME (WINDOW_FRAME (w));
492 struct face *face;
493
494 face = FACE_FROM_ID (f, VERTICAL_BORDER_FACE_ID);
495 if (face)
496 XSetForeground (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc,
497 face->foreground);
498
499 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
500 f->output_data.x->normal_gc, x, y0, x, y1);
501 }
502
503 /* Draw a window divider from (x0,y0) to (x1,y1) */
504
505 static void
506 x_draw_window_divider (struct window *w, int x0, int x1, int y0, int y1)
507 {
508 struct frame *f = XFRAME (WINDOW_FRAME (w));
509 struct face *face = FACE_FROM_ID (f, WINDOW_DIVIDER_FACE_ID);
510 struct face *face_first = FACE_FROM_ID (f, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID);
511 struct face *face_last = FACE_FROM_ID (f, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID);
512 unsigned long color = face ? face->foreground : FRAME_FOREGROUND_PIXEL (f);
513 unsigned long color_first = (face_first
514 ? face_first->foreground
515 : FRAME_FOREGROUND_PIXEL (f));
516 unsigned long color_last = (face_last
517 ? face_last->foreground
518 : FRAME_FOREGROUND_PIXEL (f));
519 Display *display = FRAME_X_DISPLAY (f);
520 Window window = FRAME_X_WINDOW (f);
521
522 if (y1 - y0 > x1 - x0 && x1 - x0 > 2)
523 /* Vertical. */
524 {
525 XSetForeground (display, f->output_data.x->normal_gc, color_first);
526 XFillRectangle (display, window, f->output_data.x->normal_gc,
527 x0, y0, 1, y1 - y0);
528 XSetForeground (display, f->output_data.x->normal_gc, color);
529 XFillRectangle (display, window, f->output_data.x->normal_gc,
530 x0 + 1, y0, x1 - x0 - 2, y1 - y0);
531 XSetForeground (display, f->output_data.x->normal_gc, color_last);
532 XFillRectangle (display, window, f->output_data.x->normal_gc,
533 x1 - 1, y0, 1, y1 - y0);
534 }
535 else if (x1 - x0 > y1 - y0 && y1 - y0 > 3)
536 /* Horizontal. */
537 {
538 XSetForeground (display, f->output_data.x->normal_gc, color_first);
539 XFillRectangle (display, window, f->output_data.x->normal_gc,
540 x0, y0, x1 - x0, 1);
541 XSetForeground (display, f->output_data.x->normal_gc, color);
542 XFillRectangle (display, window, f->output_data.x->normal_gc,
543 x0, y0 + 1, x1 - x0, y1 - y0 - 2);
544 XSetForeground (display, f->output_data.x->normal_gc, color_last);
545 XFillRectangle (display, window, f->output_data.x->normal_gc,
546 x0, y1 - 1, x1 - x0, 1);
547 }
548 else
549 {
550 XSetForeground (display, f->output_data.x->normal_gc, color);
551 XFillRectangle (display, window, f->output_data.x->normal_gc,
552 x0, y0, x1 - x0, y1 - y0);
553 }
554 }
555
556 /* End update of window W.
557
558 Draw vertical borders between horizontally adjacent windows, and
559 display W's cursor if CURSOR_ON_P is non-zero.
560
561 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
562 glyphs in mouse-face were overwritten. In that case we have to
563 make sure that the mouse-highlight is properly redrawn.
564
565 W may be a menu bar pseudo-window in case we don't have X toolkit
566 support. Such windows don't have a cursor, so don't display it
567 here. */
568
569 static void
570 x_update_window_end (struct window *w, bool cursor_on_p,
571 bool mouse_face_overwritten_p)
572 {
573 if (!w->pseudo_window_p)
574 {
575 block_input ();
576
577 if (cursor_on_p)
578 display_and_set_cursor (w, true,
579 w->output_cursor.hpos, w->output_cursor.vpos,
580 w->output_cursor.x, w->output_cursor.y);
581
582 if (draw_window_fringes (w, true))
583 {
584 if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
585 x_draw_right_divider (w);
586 else
587 x_draw_vertical_border (w);
588 }
589
590 unblock_input ();
591 }
592
593 /* If a row with mouse-face was overwritten, arrange for
594 XTframe_up_to_date to redisplay the mouse highlight. */
595 if (mouse_face_overwritten_p)
596 {
597 Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
598
599 hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
600 hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
601 hlinfo->mouse_face_window = Qnil;
602 }
603 }
604
605
606 /* End update of frame F. This function is installed as a hook in
607 update_end. */
608
609 static void
610 x_update_end (struct frame *f)
611 {
612 /* Mouse highlight may be displayed again. */
613 MOUSE_HL_INFO (f)->mouse_face_defer = false;
614
615 #ifndef XFlush
616 block_input ();
617 XFlush (FRAME_X_DISPLAY (f));
618 unblock_input ();
619 #endif
620 }
621
622
623 /* This function is called from various places in xdisp.c
624 whenever a complete update has been performed. */
625
626 static void
627 XTframe_up_to_date (struct frame *f)
628 {
629 if (FRAME_X_P (f))
630 FRAME_MOUSE_UPDATE (f);
631 }
632
633
634 /* Clear under internal border if any (GTK has its own version). */
635 #ifndef USE_GTK
636 void
637 x_clear_under_internal_border (struct frame *f)
638 {
639 if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0)
640 {
641 Display *display = FRAME_X_DISPLAY (f);
642 Window window = FRAME_X_WINDOW (f);
643 int border = FRAME_INTERNAL_BORDER_WIDTH (f);
644 int width = FRAME_PIXEL_WIDTH (f);
645 int height = FRAME_PIXEL_HEIGHT (f);
646 int margin = FRAME_TOP_MARGIN_HEIGHT (f);
647
648 block_input ();
649 x_clear_area (display, window, 0, 0, border, height);
650 x_clear_area (display, window, 0, margin, width, border);
651 x_clear_area (display, window, width - border, 0, border, height);
652 x_clear_area (display, window, 0, height - border, width, border);
653 unblock_input ();
654 }
655 }
656 #endif
657
658 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
659 arrow bitmaps, or clear the fringes if no bitmaps are required
660 before DESIRED_ROW is made current. This function is called from
661 update_window_line only if it is known that there are differences
662 between bitmaps to be drawn between current row and DESIRED_ROW. */
663
664 static void
665 x_after_update_window_line (struct window *w, struct glyph_row *desired_row)
666 {
667 eassert (w);
668
669 if (!desired_row->mode_line_p && !w->pseudo_window_p)
670 desired_row->redraw_fringe_bitmaps_p = true;
671
672 #ifdef USE_X_TOOLKIT
673 /* When a window has disappeared, make sure that no rest of
674 full-width rows stays visible in the internal border. Could
675 check here if updated window is the leftmost/rightmost window,
676 but I guess it's not worth doing since vertically split windows
677 are almost never used, internal border is rarely set, and the
678 overhead is very small. */
679 {
680 struct frame *f;
681 int width, height;
682
683 if (windows_or_buffers_changed
684 && desired_row->full_width_p
685 && (f = XFRAME (w->frame),
686 width = FRAME_INTERNAL_BORDER_WIDTH (f),
687 width != 0)
688 && (height = desired_row->visible_height,
689 height > 0))
690 {
691 int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
692
693 block_input ();
694 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
695 0, y, width, height);
696 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
697 FRAME_PIXEL_WIDTH (f) - width,
698 y, width, height);
699 unblock_input ();
700 }
701 }
702 #endif
703 }
704
705 static void
706 x_draw_fringe_bitmap (struct window *w, struct glyph_row *row, struct draw_fringe_bitmap_params *p)
707 {
708 struct frame *f = XFRAME (WINDOW_FRAME (w));
709 Display *display = FRAME_X_DISPLAY (f);
710 Window window = FRAME_X_WINDOW (f);
711 GC gc = f->output_data.x->normal_gc;
712 struct face *face = p->face;
713
714 /* Must clip because of partially visible lines. */
715 x_clip_to_row (w, row, ANY_AREA, gc);
716
717 if (p->bx >= 0 && !p->overlay_p)
718 {
719 /* In case the same realized face is used for fringes and
720 for something displayed in the text (e.g. face `region' on
721 mono-displays, the fill style may have been changed to
722 FillSolid in x_draw_glyph_string_background. */
723 if (face->stipple)
724 XSetFillStyle (display, face->gc, FillOpaqueStippled);
725 else
726 XSetForeground (display, face->gc, face->background);
727
728 XFillRectangle (display, window, face->gc,
729 p->bx, p->by, p->nx, p->ny);
730
731 if (!face->stipple)
732 XSetForeground (display, face->gc, face->foreground);
733 }
734
735 if (p->which)
736 {
737 char *bits;
738 Pixmap pixmap, clipmask = (Pixmap) 0;
739 int depth = DefaultDepthOfScreen (FRAME_X_SCREEN (f));
740 XGCValues gcv;
741
742 if (p->wd > 8)
743 bits = (char *) (p->bits + p->dh);
744 else
745 bits = (char *) p->bits + p->dh;
746
747 /* Draw the bitmap. I believe these small pixmaps can be cached
748 by the server. */
749 pixmap = XCreatePixmapFromBitmapData (display, window, bits, p->wd, p->h,
750 (p->cursor_p
751 ? (p->overlay_p ? face->background
752 : f->output_data.x->cursor_pixel)
753 : face->foreground),
754 face->background, depth);
755
756 if (p->overlay_p)
757 {
758 clipmask = XCreatePixmapFromBitmapData (display,
759 FRAME_DISPLAY_INFO (f)->root_window,
760 bits, p->wd, p->h,
761 1, 0, 1);
762 gcv.clip_mask = clipmask;
763 gcv.clip_x_origin = p->x;
764 gcv.clip_y_origin = p->y;
765 XChangeGC (display, gc, GCClipMask | GCClipXOrigin | GCClipYOrigin, &gcv);
766 }
767
768 XCopyArea (display, pixmap, window, gc, 0, 0,
769 p->wd, p->h, p->x, p->y);
770 XFreePixmap (display, pixmap);
771
772 if (p->overlay_p)
773 {
774 gcv.clip_mask = (Pixmap) 0;
775 XChangeGC (display, gc, GCClipMask, &gcv);
776 XFreePixmap (display, clipmask);
777 }
778 }
779
780 XSetClipMask (display, gc, None);
781 }
782
783 /***********************************************************************
784 Glyph display
785 ***********************************************************************/
786
787
788
789 static void x_set_glyph_string_clipping (struct glyph_string *);
790 static void x_set_glyph_string_gc (struct glyph_string *);
791 static void x_draw_glyph_string_foreground (struct glyph_string *);
792 static void x_draw_composite_glyph_string_foreground (struct glyph_string *);
793 static void x_draw_glyph_string_box (struct glyph_string *);
794 static void x_draw_glyph_string (struct glyph_string *);
795 static _Noreturn void x_delete_glyphs (struct frame *, int);
796 static void x_compute_glyph_string_overhangs (struct glyph_string *);
797 static void x_set_cursor_gc (struct glyph_string *);
798 static void x_set_mode_line_face_gc (struct glyph_string *);
799 static void x_set_mouse_face_gc (struct glyph_string *);
800 static bool x_alloc_lighter_color (struct frame *, Display *, Colormap,
801 unsigned long *, double, int);
802 static void x_setup_relief_color (struct frame *, struct relief *,
803 double, int, unsigned long);
804 static void x_setup_relief_colors (struct glyph_string *);
805 static void x_draw_image_glyph_string (struct glyph_string *);
806 static void x_draw_image_relief (struct glyph_string *);
807 static void x_draw_image_foreground (struct glyph_string *);
808 static void x_draw_image_foreground_1 (struct glyph_string *, Pixmap);
809 static void x_clear_glyph_string_rect (struct glyph_string *, int,
810 int, int, int);
811 static void x_draw_relief_rect (struct frame *, int, int, int, int,
812 int, bool, bool, bool, bool, bool,
813 XRectangle *);
814 static void x_draw_box_rect (struct glyph_string *, int, int, int, int,
815 int, bool, bool, XRectangle *);
816 static void x_scroll_bar_clear (struct frame *);
817
818 #ifdef GLYPH_DEBUG
819 static void x_check_font (struct frame *, struct font *);
820 #endif
821
822
823 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
824 face. */
825
826 static void
827 x_set_cursor_gc (struct glyph_string *s)
828 {
829 if (s->font == FRAME_FONT (s->f)
830 && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
831 && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
832 && !s->cmp)
833 s->gc = s->f->output_data.x->cursor_gc;
834 else
835 {
836 /* Cursor on non-default face: must merge. */
837 XGCValues xgcv;
838 unsigned long mask;
839
840 xgcv.background = s->f->output_data.x->cursor_pixel;
841 xgcv.foreground = s->face->background;
842
843 /* If the glyph would be invisible, try a different foreground. */
844 if (xgcv.foreground == xgcv.background)
845 xgcv.foreground = s->face->foreground;
846 if (xgcv.foreground == xgcv.background)
847 xgcv.foreground = s->f->output_data.x->cursor_foreground_pixel;
848 if (xgcv.foreground == xgcv.background)
849 xgcv.foreground = s->face->foreground;
850
851 /* Make sure the cursor is distinct from text in this face. */
852 if (xgcv.background == s->face->background
853 && xgcv.foreground == s->face->foreground)
854 {
855 xgcv.background = s->face->foreground;
856 xgcv.foreground = s->face->background;
857 }
858
859 IF_DEBUG (x_check_font (s->f, s->font));
860 xgcv.graphics_exposures = False;
861 mask = GCForeground | GCBackground | GCGraphicsExposures;
862
863 if (FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc)
864 XChangeGC (s->display, FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc,
865 mask, &xgcv);
866 else
867 FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc
868 = XCreateGC (s->display, s->window, mask, &xgcv);
869
870 s->gc = FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc;
871 }
872 }
873
874
875 /* Set up S->gc of glyph string S for drawing text in mouse face. */
876
877 static void
878 x_set_mouse_face_gc (struct glyph_string *s)
879 {
880 int face_id;
881 struct face *face;
882
883 /* What face has to be used last for the mouse face? */
884 face_id = MOUSE_HL_INFO (s->f)->mouse_face_face_id;
885 face = FACE_FROM_ID (s->f, face_id);
886 if (face == NULL)
887 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
888
889 if (s->first_glyph->type == CHAR_GLYPH)
890 face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch, -1, Qnil);
891 else
892 face_id = FACE_FOR_CHAR (s->f, face, 0, -1, Qnil);
893 s->face = FACE_FROM_ID (s->f, face_id);
894 prepare_face_for_display (s->f, s->face);
895
896 if (s->font == s->face->font)
897 s->gc = s->face->gc;
898 else
899 {
900 /* Otherwise construct scratch_cursor_gc with values from FACE
901 except for FONT. */
902 XGCValues xgcv;
903 unsigned long mask;
904
905 xgcv.background = s->face->background;
906 xgcv.foreground = s->face->foreground;
907 xgcv.graphics_exposures = False;
908 mask = GCForeground | GCBackground | GCGraphicsExposures;
909
910 if (FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc)
911 XChangeGC (s->display, FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc,
912 mask, &xgcv);
913 else
914 FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc
915 = XCreateGC (s->display, s->window, mask, &xgcv);
916
917 s->gc = FRAME_DISPLAY_INFO (s->f)->scratch_cursor_gc;
918
919 }
920 eassert (s->gc != 0);
921 }
922
923
924 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
925 Faces to use in the mode line have already been computed when the
926 matrix was built, so there isn't much to do, here. */
927
928 static void
929 x_set_mode_line_face_gc (struct glyph_string *s)
930 {
931 s->gc = s->face->gc;
932 }
933
934
935 /* Set S->gc of glyph string S for drawing that glyph string. Set
936 S->stippled_p to a non-zero value if the face of S has a stipple
937 pattern. */
938
939 static void
940 x_set_glyph_string_gc (struct glyph_string *s)
941 {
942 prepare_face_for_display (s->f, s->face);
943
944 if (s->hl == DRAW_NORMAL_TEXT)
945 {
946 s->gc = s->face->gc;
947 s->stippled_p = s->face->stipple != 0;
948 }
949 else if (s->hl == DRAW_INVERSE_VIDEO)
950 {
951 x_set_mode_line_face_gc (s);
952 s->stippled_p = s->face->stipple != 0;
953 }
954 else if (s->hl == DRAW_CURSOR)
955 {
956 x_set_cursor_gc (s);
957 s->stippled_p = false;
958 }
959 else if (s->hl == DRAW_MOUSE_FACE)
960 {
961 x_set_mouse_face_gc (s);
962 s->stippled_p = s->face->stipple != 0;
963 }
964 else if (s->hl == DRAW_IMAGE_RAISED
965 || s->hl == DRAW_IMAGE_SUNKEN)
966 {
967 s->gc = s->face->gc;
968 s->stippled_p = s->face->stipple != 0;
969 }
970 else
971 emacs_abort ();
972
973 /* GC must have been set. */
974 eassert (s->gc != 0);
975 }
976
977
978 /* Set clipping for output of glyph string S. S may be part of a mode
979 line or menu if we don't have X toolkit support. */
980
981 static void
982 x_set_glyph_string_clipping (struct glyph_string *s)
983 {
984 XRectangle *r = s->clip;
985 int n = get_glyph_string_clip_rects (s, r, 2);
986
987 if (n > 0)
988 XSetClipRectangles (s->display, s->gc, 0, 0, r, n, Unsorted);
989 s->num_clips = n;
990 }
991
992
993 /* Set SRC's clipping for output of glyph string DST. This is called
994 when we are drawing DST's left_overhang or right_overhang only in
995 the area of SRC. */
996
997 static void
998 x_set_glyph_string_clipping_exactly (struct glyph_string *src, struct glyph_string *dst)
999 {
1000 XRectangle r;
1001
1002 r.x = src->x;
1003 r.width = src->width;
1004 r.y = src->y;
1005 r.height = src->height;
1006 dst->clip[0] = r;
1007 dst->num_clips = 1;
1008 XSetClipRectangles (dst->display, dst->gc, 0, 0, &r, 1, Unsorted);
1009 }
1010
1011
1012 /* RIF:
1013 Compute left and right overhang of glyph string S. */
1014
1015 static void
1016 x_compute_glyph_string_overhangs (struct glyph_string *s)
1017 {
1018 if (s->cmp == NULL
1019 && (s->first_glyph->type == CHAR_GLYPH
1020 || s->first_glyph->type == COMPOSITE_GLYPH))
1021 {
1022 struct font_metrics metrics;
1023
1024 if (s->first_glyph->type == CHAR_GLYPH)
1025 {
1026 unsigned *code = alloca (sizeof (unsigned) * s->nchars);
1027 struct font *font = s->font;
1028 int i;
1029
1030 for (i = 0; i < s->nchars; i++)
1031 code[i] = (s->char2b[i].byte1 << 8) | s->char2b[i].byte2;
1032 font->driver->text_extents (font, code, s->nchars, &metrics);
1033 }
1034 else
1035 {
1036 Lisp_Object gstring = composition_gstring_from_id (s->cmp_id);
1037
1038 composition_gstring_width (gstring, s->cmp_from, s->cmp_to, &metrics);
1039 }
1040 s->right_overhang = (metrics.rbearing > metrics.width
1041 ? metrics.rbearing - metrics.width : 0);
1042 s->left_overhang = metrics.lbearing < 0 ? - metrics.lbearing : 0;
1043 }
1044 else if (s->cmp)
1045 {
1046 s->right_overhang = s->cmp->rbearing - s->cmp->pixel_width;
1047 s->left_overhang = - s->cmp->lbearing;
1048 }
1049 }
1050
1051
1052 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1053
1054 static void
1055 x_clear_glyph_string_rect (struct glyph_string *s, int x, int y, int w, int h)
1056 {
1057 XGCValues xgcv;
1058 XGetGCValues (s->display, s->gc, GCForeground | GCBackground, &xgcv);
1059 XSetForeground (s->display, s->gc, xgcv.background);
1060 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
1061 XSetForeground (s->display, s->gc, xgcv.foreground);
1062 }
1063
1064
1065 /* Draw the background of glyph_string S. If S->background_filled_p
1066 is non-zero don't draw it. FORCE_P non-zero means draw the
1067 background even if it wouldn't be drawn normally. This is used
1068 when a string preceding S draws into the background of S, or S
1069 contains the first component of a composition. */
1070
1071 static void
1072 x_draw_glyph_string_background (struct glyph_string *s, bool force_p)
1073 {
1074 /* Nothing to do if background has already been drawn or if it
1075 shouldn't be drawn in the first place. */
1076 if (!s->background_filled_p)
1077 {
1078 int box_line_width = max (s->face->box_line_width, 0);
1079
1080 if (s->stippled_p)
1081 {
1082 /* Fill background with a stipple pattern. */
1083 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
1084 XFillRectangle (s->display, s->window, s->gc, s->x,
1085 s->y + box_line_width,
1086 s->background_width,
1087 s->height - 2 * box_line_width);
1088 XSetFillStyle (s->display, s->gc, FillSolid);
1089 s->background_filled_p = true;
1090 }
1091 else if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
1092 || s->font_not_found_p
1093 || s->extends_to_end_of_line_p
1094 || force_p)
1095 {
1096 x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
1097 s->background_width,
1098 s->height - 2 * box_line_width);
1099 s->background_filled_p = true;
1100 }
1101 }
1102 }
1103
1104
1105 /* Draw the foreground of glyph string S. */
1106
1107 static void
1108 x_draw_glyph_string_foreground (struct glyph_string *s)
1109 {
1110 int i, x;
1111
1112 /* If first glyph of S has a left box line, start drawing the text
1113 of S to the right of that box line. */
1114 if (s->face->box != FACE_NO_BOX
1115 && s->first_glyph->left_box_line_p)
1116 x = s->x + eabs (s->face->box_line_width);
1117 else
1118 x = s->x;
1119
1120 /* Draw characters of S as rectangles if S's font could not be
1121 loaded. */
1122 if (s->font_not_found_p)
1123 {
1124 for (i = 0; i < s->nchars; ++i)
1125 {
1126 struct glyph *g = s->first_glyph + i;
1127 XDrawRectangle (s->display, s->window,
1128 s->gc, x, s->y, g->pixel_width - 1,
1129 s->height - 1);
1130 x += g->pixel_width;
1131 }
1132 }
1133 else
1134 {
1135 struct font *font = s->font;
1136 int boff = font->baseline_offset;
1137 int y;
1138
1139 if (font->vertical_centering)
1140 boff = VCENTER_BASELINE_OFFSET (font, s->f) - boff;
1141
1142 y = s->ybase - boff;
1143 if (s->for_overlaps
1144 || (s->background_filled_p && s->hl != DRAW_CURSOR))
1145 font->driver->draw (s, 0, s->nchars, x, y, false);
1146 else
1147 font->driver->draw (s, 0, s->nchars, x, y, true);
1148 if (s->face->overstrike)
1149 font->driver->draw (s, 0, s->nchars, x + 1, y, false);
1150 }
1151 }
1152
1153 /* Draw the foreground of composite glyph string S. */
1154
1155 static void
1156 x_draw_composite_glyph_string_foreground (struct glyph_string *s)
1157 {
1158 int i, j, x;
1159 struct font *font = s->font;
1160
1161 /* If first glyph of S has a left box line, start drawing the text
1162 of S to the right of that box line. */
1163 if (s->face && s->face->box != FACE_NO_BOX
1164 && s->first_glyph->left_box_line_p)
1165 x = s->x + eabs (s->face->box_line_width);
1166 else
1167 x = s->x;
1168
1169 /* S is a glyph string for a composition. S->cmp_from is the index
1170 of the first character drawn for glyphs of this composition.
1171 S->cmp_from == 0 means we are drawing the very first character of
1172 this composition. */
1173
1174 /* Draw a rectangle for the composition if the font for the very
1175 first character of the composition could not be loaded. */
1176 if (s->font_not_found_p)
1177 {
1178 if (s->cmp_from == 0)
1179 XDrawRectangle (s->display, s->window, s->gc, x, s->y,
1180 s->width - 1, s->height - 1);
1181 }
1182 else if (! s->first_glyph->u.cmp.automatic)
1183 {
1184 int y = s->ybase;
1185
1186 for (i = 0, j = s->cmp_from; i < s->nchars; i++, j++)
1187 /* TAB in a composition means display glyphs with padding
1188 space on the left or right. */
1189 if (COMPOSITION_GLYPH (s->cmp, j) != '\t')
1190 {
1191 int xx = x + s->cmp->offsets[j * 2];
1192 int yy = y - s->cmp->offsets[j * 2 + 1];
1193
1194 font->driver->draw (s, j, j + 1, xx, yy, false);
1195 if (s->face->overstrike)
1196 font->driver->draw (s, j, j + 1, xx + 1, yy, false);
1197 }
1198 }
1199 else
1200 {
1201 Lisp_Object gstring = composition_gstring_from_id (s->cmp_id);
1202 Lisp_Object glyph;
1203 int y = s->ybase;
1204 int width = 0;
1205
1206 for (i = j = s->cmp_from; i < s->cmp_to; i++)
1207 {
1208 glyph = LGSTRING_GLYPH (gstring, i);
1209 if (NILP (LGLYPH_ADJUSTMENT (glyph)))
1210 width += LGLYPH_WIDTH (glyph);
1211 else
1212 {
1213 int xoff, yoff, wadjust;
1214
1215 if (j < i)
1216 {
1217 font->driver->draw (s, j, i, x, y, false);
1218 if (s->face->overstrike)
1219 font->driver->draw (s, j, i, x + 1, y, false);
1220 x += width;
1221 }
1222 xoff = LGLYPH_XOFF (glyph);
1223 yoff = LGLYPH_YOFF (glyph);
1224 wadjust = LGLYPH_WADJUST (glyph);
1225 font->driver->draw (s, i, i + 1, x + xoff, y + yoff, false);
1226 if (s->face->overstrike)
1227 font->driver->draw (s, i, i + 1, x + xoff + 1, y + yoff,
1228 false);
1229 x += wadjust;
1230 j = i + 1;
1231 width = 0;
1232 }
1233 }
1234 if (j < i)
1235 {
1236 font->driver->draw (s, j, i, x, y, false);
1237 if (s->face->overstrike)
1238 font->driver->draw (s, j, i, x + 1, y, false);
1239 }
1240 }
1241 }
1242
1243
1244 /* Draw the foreground of glyph string S for glyphless characters. */
1245
1246 static void
1247 x_draw_glyphless_glyph_string_foreground (struct glyph_string *s)
1248 {
1249 struct glyph *glyph = s->first_glyph;
1250 XChar2b char2b[8];
1251 int x, i, j;
1252
1253 /* If first glyph of S has a left box line, start drawing the text
1254 of S to the right of that box line. */
1255 if (s->face && s->face->box != FACE_NO_BOX
1256 && s->first_glyph->left_box_line_p)
1257 x = s->x + eabs (s->face->box_line_width);
1258 else
1259 x = s->x;
1260
1261 s->char2b = char2b;
1262
1263 for (i = 0; i < s->nchars; i++, glyph++)
1264 {
1265 char buf[7], *str = NULL;
1266 int len = glyph->u.glyphless.len;
1267
1268 if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_ACRONYM)
1269 {
1270 if (len > 0
1271 && CHAR_TABLE_P (Vglyphless_char_display)
1272 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display))
1273 >= 1))
1274 {
1275 Lisp_Object acronym
1276 = (! glyph->u.glyphless.for_no_font
1277 ? CHAR_TABLE_REF (Vglyphless_char_display,
1278 glyph->u.glyphless.ch)
1279 : XCHAR_TABLE (Vglyphless_char_display)->extras[0]);
1280 if (STRINGP (acronym))
1281 str = SSDATA (acronym);
1282 }
1283 }
1284 else if (glyph->u.glyphless.method == GLYPHLESS_DISPLAY_HEX_CODE)
1285 {
1286 sprintf (buf, "%0*X",
1287 glyph->u.glyphless.ch < 0x10000 ? 4 : 6,
1288 glyph->u.glyphless.ch);
1289 str = buf;
1290 }
1291
1292 if (str)
1293 {
1294 int upper_len = (len + 1) / 2;
1295 unsigned code;
1296
1297 /* It is assured that all LEN characters in STR is ASCII. */
1298 for (j = 0; j < len; j++)
1299 {
1300 code = s->font->driver->encode_char (s->font, str[j]);
1301 STORE_XCHAR2B (char2b + j, code >> 8, code & 0xFF);
1302 }
1303 s->font->driver->draw (s, 0, upper_len,
1304 x + glyph->slice.glyphless.upper_xoff,
1305 s->ybase + glyph->slice.glyphless.upper_yoff,
1306 false);
1307 s->font->driver->draw (s, upper_len, len,
1308 x + glyph->slice.glyphless.lower_xoff,
1309 s->ybase + glyph->slice.glyphless.lower_yoff,
1310 false);
1311 }
1312 if (glyph->u.glyphless.method != GLYPHLESS_DISPLAY_THIN_SPACE)
1313 XDrawRectangle (s->display, s->window, s->gc,
1314 x, s->ybase - glyph->ascent,
1315 glyph->pixel_width - 1,
1316 glyph->ascent + glyph->descent - 1);
1317 x += glyph->pixel_width;
1318 }
1319 }
1320
1321 #ifdef USE_X_TOOLKIT
1322
1323 #ifdef USE_LUCID
1324
1325 /* Return the frame on which widget WIDGET is used.. Abort if frame
1326 cannot be determined. */
1327
1328 static struct frame *
1329 x_frame_of_widget (Widget widget)
1330 {
1331 struct x_display_info *dpyinfo;
1332 Lisp_Object tail, frame;
1333 struct frame *f;
1334
1335 dpyinfo = x_display_info_for_display (XtDisplay (widget));
1336
1337 /* Find the top-level shell of the widget. Note that this function
1338 can be called when the widget is not yet realized, so XtWindow
1339 (widget) == 0. That's the reason we can't simply use
1340 x_any_window_to_frame. */
1341 while (!XtIsTopLevelShell (widget))
1342 widget = XtParent (widget);
1343
1344 /* Look for a frame with that top-level widget. Allocate the color
1345 on that frame to get the right gamma correction value. */
1346 FOR_EACH_FRAME (tail, frame)
1347 {
1348 f = XFRAME (frame);
1349 if (FRAME_X_P (f)
1350 && f->output_data.nothing != 1
1351 && FRAME_DISPLAY_INFO (f) == dpyinfo
1352 && f->output_data.x->widget == widget)
1353 return f;
1354 }
1355 emacs_abort ();
1356 }
1357
1358 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1359 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1360 If this produces the same color as PIXEL, try a color where all RGB
1361 values have DELTA added. Return the allocated color in *PIXEL.
1362 DISPLAY is the X display, CMAP is the colormap to operate on.
1363 Value is true if successful. */
1364
1365 bool
1366 x_alloc_lighter_color_for_widget (Widget widget, Display *display, Colormap cmap,
1367 unsigned long *pixel, double factor, int delta)
1368 {
1369 struct frame *f = x_frame_of_widget (widget);
1370 return x_alloc_lighter_color (f, display, cmap, pixel, factor, delta);
1371 }
1372
1373 #endif /* USE_LUCID */
1374
1375
1376 /* Structure specifying which arguments should be passed by Xt to
1377 cvt_string_to_pixel. We want the widget's screen and colormap. */
1378
1379 static XtConvertArgRec cvt_string_to_pixel_args[] =
1380 {
1381 {XtWidgetBaseOffset, (XtPointer) offsetof (WidgetRec, core.screen),
1382 sizeof (Screen *)},
1383 {XtWidgetBaseOffset, (XtPointer) offsetof (WidgetRec, core.colormap),
1384 sizeof (Colormap)}
1385 };
1386
1387
1388 /* The address of this variable is returned by
1389 cvt_string_to_pixel. */
1390
1391 static Pixel cvt_string_to_pixel_value;
1392
1393
1394 /* Convert a color name to a pixel color.
1395
1396 DPY is the display we are working on.
1397
1398 ARGS is an array of *NARGS XrmValue structures holding additional
1399 information about the widget for which the conversion takes place.
1400 The contents of this array are determined by the specification
1401 in cvt_string_to_pixel_args.
1402
1403 FROM is a pointer to an XrmValue which points to the color name to
1404 convert. TO is an XrmValue in which to return the pixel color.
1405
1406 CLOSURE_RET is a pointer to user-data, in which we record if
1407 we allocated the color or not.
1408
1409 Value is True if successful, False otherwise. */
1410
1411 static Boolean
1412 cvt_string_to_pixel (Display *dpy, XrmValue *args, Cardinal *nargs,
1413 XrmValue *from, XrmValue *to,
1414 XtPointer *closure_ret)
1415 {
1416 Screen *screen;
1417 Colormap cmap;
1418 Pixel pixel;
1419 String color_name;
1420 XColor color;
1421
1422 if (*nargs != 2)
1423 {
1424 XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
1425 "wrongParameters", "cvt_string_to_pixel",
1426 "XtToolkitError",
1427 "Screen and colormap args required", NULL, NULL);
1428 return False;
1429 }
1430
1431 screen = *(Screen **) args[0].addr;
1432 cmap = *(Colormap *) args[1].addr;
1433 color_name = (String) from->addr;
1434
1435 if (strcmp (color_name, XtDefaultBackground) == 0)
1436 {
1437 *closure_ret = (XtPointer) False;
1438 pixel = WhitePixelOfScreen (screen);
1439 }
1440 else if (strcmp (color_name, XtDefaultForeground) == 0)
1441 {
1442 *closure_ret = (XtPointer) False;
1443 pixel = BlackPixelOfScreen (screen);
1444 }
1445 else if (XParseColor (dpy, cmap, color_name, &color)
1446 && x_alloc_nearest_color_1 (dpy, cmap, &color))
1447 {
1448 pixel = color.pixel;
1449 *closure_ret = (XtPointer) True;
1450 }
1451 else
1452 {
1453 String params[1];
1454 Cardinal nparams = 1;
1455
1456 params[0] = color_name;
1457 XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
1458 "badValue", "cvt_string_to_pixel",
1459 "XtToolkitError", "Invalid color `%s'",
1460 params, &nparams);
1461 return False;
1462 }
1463
1464 if (to->addr != NULL)
1465 {
1466 if (to->size < sizeof (Pixel))
1467 {
1468 to->size = sizeof (Pixel);
1469 return False;
1470 }
1471
1472 *(Pixel *) to->addr = pixel;
1473 }
1474 else
1475 {
1476 cvt_string_to_pixel_value = pixel;
1477 to->addr = (XtPointer) &cvt_string_to_pixel_value;
1478 }
1479
1480 to->size = sizeof (Pixel);
1481 return True;
1482 }
1483
1484
1485 /* Free a pixel color which was previously allocated via
1486 cvt_string_to_pixel. This is registered as the destructor
1487 for this type of resource via XtSetTypeConverter.
1488
1489 APP is the application context in which we work.
1490
1491 TO is a pointer to an XrmValue holding the color to free.
1492 CLOSURE is the value we stored in CLOSURE_RET for this color
1493 in cvt_string_to_pixel.
1494
1495 ARGS and NARGS are like for cvt_string_to_pixel. */
1496
1497 static void
1498 cvt_pixel_dtor (XtAppContext app, XrmValuePtr to, XtPointer closure, XrmValuePtr args,
1499 Cardinal *nargs)
1500 {
1501 if (*nargs != 2)
1502 {
1503 XtAppWarningMsg (app, "wrongParameters", "cvt_pixel_dtor",
1504 "XtToolkitError",
1505 "Screen and colormap arguments required",
1506 NULL, NULL);
1507 }
1508 else if (closure != NULL)
1509 {
1510 /* We did allocate the pixel, so free it. */
1511 Screen *screen = *(Screen **) args[0].addr;
1512 Colormap cmap = *(Colormap *) args[1].addr;
1513 x_free_dpy_colors (DisplayOfScreen (screen), screen, cmap,
1514 (Pixel *) to->addr, 1);
1515 }
1516 }
1517
1518
1519 #endif /* USE_X_TOOLKIT */
1520
1521
1522 /* Value is an array of XColor structures for the contents of the
1523 color map of display DPY. Set *NCELLS to the size of the array.
1524 Note that this probably shouldn't be called for large color maps,
1525 say a 24-bit TrueColor map. */
1526
1527 static const XColor *
1528 x_color_cells (Display *dpy, int *ncells)
1529 {
1530 struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
1531
1532 if (dpyinfo->color_cells == NULL)
1533 {
1534 Screen *screen = dpyinfo->screen;
1535 int ncolor_cells = XDisplayCells (dpy, XScreenNumberOfScreen (screen));
1536 int i;
1537
1538 dpyinfo->color_cells = xnmalloc (ncolor_cells,
1539 sizeof *dpyinfo->color_cells);
1540 dpyinfo->ncolor_cells = ncolor_cells;
1541
1542 for (i = 0; i < ncolor_cells; ++i)
1543 dpyinfo->color_cells[i].pixel = i;
1544
1545 XQueryColors (dpy, dpyinfo->cmap,
1546 dpyinfo->color_cells, ncolor_cells);
1547 }
1548
1549 *ncells = dpyinfo->ncolor_cells;
1550 return dpyinfo->color_cells;
1551 }
1552
1553
1554 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1555 colors in COLORS. Use cached information, if available. */
1556
1557 void
1558 x_query_colors (struct frame *f, XColor *colors, int ncolors)
1559 {
1560 struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
1561
1562 if (dpyinfo->color_cells)
1563 {
1564 int i;
1565 for (i = 0; i < ncolors; ++i)
1566 {
1567 unsigned long pixel = colors[i].pixel;
1568 eassert (pixel < dpyinfo->ncolor_cells);
1569 eassert (dpyinfo->color_cells[pixel].pixel == pixel);
1570 colors[i] = dpyinfo->color_cells[pixel];
1571 }
1572 }
1573 else
1574 XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), colors, ncolors);
1575 }
1576
1577
1578 /* On frame F, translate pixel color to RGB values for the color in
1579 COLOR. Use cached information, if available. */
1580
1581 void
1582 x_query_color (struct frame *f, XColor *color)
1583 {
1584 x_query_colors (f, color, 1);
1585 }
1586
1587
1588 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1589 exact match can't be allocated, try the nearest color available.
1590 Value is true if successful. Set *COLOR to the color
1591 allocated. */
1592
1593 static bool
1594 x_alloc_nearest_color_1 (Display *dpy, Colormap cmap, XColor *color)
1595 {
1596 bool rc;
1597
1598 rc = XAllocColor (dpy, cmap, color) != 0;
1599 if (rc == 0)
1600 {
1601 /* If we got to this point, the colormap is full, so we're going
1602 to try to get the next closest color. The algorithm used is
1603 a least-squares matching, which is what X uses for closest
1604 color matching with StaticColor visuals. */
1605 int nearest, i;
1606 int max_color_delta = 255;
1607 int max_delta = 3 * max_color_delta;
1608 int nearest_delta = max_delta + 1;
1609 int ncells;
1610 const XColor *cells = x_color_cells (dpy, &ncells);
1611
1612 for (nearest = i = 0; i < ncells; ++i)
1613 {
1614 int dred = (color->red >> 8) - (cells[i].red >> 8);
1615 int dgreen = (color->green >> 8) - (cells[i].green >> 8);
1616 int dblue = (color->blue >> 8) - (cells[i].blue >> 8);
1617 int delta = dred * dred + dgreen * dgreen + dblue * dblue;
1618
1619 if (delta < nearest_delta)
1620 {
1621 nearest = i;
1622 nearest_delta = delta;
1623 }
1624 }
1625
1626 color->red = cells[nearest].red;
1627 color->green = cells[nearest].green;
1628 color->blue = cells[nearest].blue;
1629 rc = XAllocColor (dpy, cmap, color) != 0;
1630 }
1631 else
1632 {
1633 /* If allocation succeeded, and the allocated pixel color is not
1634 equal to a cached pixel color recorded earlier, there was a
1635 change in the colormap, so clear the color cache. */
1636 struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
1637 XColor *cached_color;
1638
1639 if (dpyinfo->color_cells
1640 && (cached_color = &dpyinfo->color_cells[color->pixel],
1641 (cached_color->red != color->red
1642 || cached_color->blue != color->blue
1643 || cached_color->green != color->green)))
1644 {
1645 xfree (dpyinfo->color_cells);
1646 dpyinfo->color_cells = NULL;
1647 dpyinfo->ncolor_cells = 0;
1648 }
1649 }
1650
1651 #ifdef DEBUG_X_COLORS
1652 if (rc)
1653 register_color (color->pixel);
1654 #endif /* DEBUG_X_COLORS */
1655
1656 return rc;
1657 }
1658
1659
1660 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1661 exact match can't be allocated, try the nearest color available.
1662 Value is true if successful. Set *COLOR to the color
1663 allocated. */
1664
1665 bool
1666 x_alloc_nearest_color (struct frame *f, Colormap cmap, XColor *color)
1667 {
1668 gamma_correct (f, color);
1669 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f), cmap, color);
1670 }
1671
1672
1673 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1674 It's necessary to do this instead of just using PIXEL directly to
1675 get color reference counts right. */
1676
1677 unsigned long
1678 x_copy_color (struct frame *f, unsigned long pixel)
1679 {
1680 XColor color;
1681
1682 color.pixel = pixel;
1683 block_input ();
1684 x_query_color (f, &color);
1685 XAllocColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), &color);
1686 unblock_input ();
1687 #ifdef DEBUG_X_COLORS
1688 register_color (pixel);
1689 #endif
1690 return color.pixel;
1691 }
1692
1693
1694 /* Brightness beyond which a color won't have its highlight brightness
1695 boosted.
1696
1697 Nominally, highlight colors for `3d' faces are calculated by
1698 brightening an object's color by a constant scale factor, but this
1699 doesn't yield good results for dark colors, so for colors who's
1700 brightness is less than this value (on a scale of 0-65535) have an
1701 use an additional additive factor.
1702
1703 The value here is set so that the default menu-bar/mode-line color
1704 (grey75) will not have its highlights changed at all. */
1705 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1706
1707
1708 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1709 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1710 If this produces the same color as PIXEL, try a color where all RGB
1711 values have DELTA added. Return the allocated color in *PIXEL.
1712 DISPLAY is the X display, CMAP is the colormap to operate on.
1713 Value is non-zero if successful. */
1714
1715 static bool
1716 x_alloc_lighter_color (struct frame *f, Display *display, Colormap cmap,
1717 unsigned long *pixel, double factor, int delta)
1718 {
1719 XColor color, new;
1720 long bright;
1721 bool success_p;
1722
1723 /* Get RGB color values. */
1724 color.pixel = *pixel;
1725 x_query_color (f, &color);
1726
1727 /* Change RGB values by specified FACTOR. Avoid overflow! */
1728 eassert (factor >= 0);
1729 new.red = min (0xffff, factor * color.red);
1730 new.green = min (0xffff, factor * color.green);
1731 new.blue = min (0xffff, factor * color.blue);
1732
1733 /* Calculate brightness of COLOR. */
1734 bright = (2 * color.red + 3 * color.green + color.blue) / 6;
1735
1736 /* We only boost colors that are darker than
1737 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1738 if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
1739 /* Make an additive adjustment to NEW, because it's dark enough so
1740 that scaling by FACTOR alone isn't enough. */
1741 {
1742 /* How far below the limit this color is (0 - 1, 1 being darker). */
1743 double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
1744 /* The additive adjustment. */
1745 int min_delta = delta * dimness * factor / 2;
1746
1747 if (factor < 1)
1748 {
1749 new.red = max (0, new.red - min_delta);
1750 new.green = max (0, new.green - min_delta);
1751 new.blue = max (0, new.blue - min_delta);
1752 }
1753 else
1754 {
1755 new.red = min (0xffff, min_delta + new.red);
1756 new.green = min (0xffff, min_delta + new.green);
1757 new.blue = min (0xffff, min_delta + new.blue);
1758 }
1759 }
1760
1761 /* Try to allocate the color. */
1762 success_p = x_alloc_nearest_color (f, cmap, &new);
1763 if (success_p)
1764 {
1765 if (new.pixel == *pixel)
1766 {
1767 /* If we end up with the same color as before, try adding
1768 delta to the RGB values. */
1769 x_free_colors (f, &new.pixel, 1);
1770
1771 new.red = min (0xffff, delta + color.red);
1772 new.green = min (0xffff, delta + color.green);
1773 new.blue = min (0xffff, delta + color.blue);
1774 success_p = x_alloc_nearest_color (f, cmap, &new);
1775 }
1776 else
1777 success_p = true;
1778 *pixel = new.pixel;
1779 }
1780
1781 return success_p;
1782 }
1783
1784
1785 /* Set up the foreground color for drawing relief lines of glyph
1786 string S. RELIEF is a pointer to a struct relief containing the GC
1787 with which lines will be drawn. Use a color that is FACTOR or
1788 DELTA lighter or darker than the relief's background which is found
1789 in S->f->output_data.x->relief_background. If such a color cannot
1790 be allocated, use DEFAULT_PIXEL, instead. */
1791
1792 static void
1793 x_setup_relief_color (struct frame *f, struct relief *relief, double factor,
1794 int delta, unsigned long default_pixel)
1795 {
1796 XGCValues xgcv;
1797 struct x_output *di = f->output_data.x;
1798 unsigned long mask = GCForeground | GCLineWidth | GCGraphicsExposures;
1799 unsigned long pixel;
1800 unsigned long background = di->relief_background;
1801 Colormap cmap = FRAME_X_COLORMAP (f);
1802 struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
1803 Display *dpy = FRAME_X_DISPLAY (f);
1804
1805 xgcv.graphics_exposures = False;
1806 xgcv.line_width = 1;
1807
1808 /* Free previously allocated color. The color cell will be reused
1809 when it has been freed as many times as it was allocated, so this
1810 doesn't affect faces using the same colors. */
1811 if (relief->gc && relief->pixel != -1)
1812 {
1813 x_free_colors (f, &relief->pixel, 1);
1814 relief->pixel = -1;
1815 }
1816
1817 /* Allocate new color. */
1818 xgcv.foreground = default_pixel;
1819 pixel = background;
1820 if (dpyinfo->n_planes != 1
1821 && x_alloc_lighter_color (f, dpy, cmap, &pixel, factor, delta))
1822 xgcv.foreground = relief->pixel = pixel;
1823
1824 if (relief->gc == 0)
1825 {
1826 xgcv.stipple = dpyinfo->gray;
1827 mask |= GCStipple;
1828 relief->gc = XCreateGC (dpy, FRAME_X_WINDOW (f), mask, &xgcv);
1829 }
1830 else
1831 XChangeGC (dpy, relief->gc, mask, &xgcv);
1832 }
1833
1834
1835 /* Set up colors for the relief lines around glyph string S. */
1836
1837 static void
1838 x_setup_relief_colors (struct glyph_string *s)
1839 {
1840 struct x_output *di = s->f->output_data.x;
1841 unsigned long color;
1842
1843 if (s->face->use_box_color_for_shadows_p)
1844 color = s->face->box_color;
1845 else if (s->first_glyph->type == IMAGE_GLYPH
1846 && s->img->pixmap
1847 && !IMAGE_BACKGROUND_TRANSPARENT (s->img, s->f, 0))
1848 color = IMAGE_BACKGROUND (s->img, s->f, 0);
1849 else
1850 {
1851 XGCValues xgcv;
1852
1853 /* Get the background color of the face. */
1854 XGetGCValues (s->display, s->gc, GCBackground, &xgcv);
1855 color = xgcv.background;
1856 }
1857
1858 if (di->white_relief.gc == 0
1859 || color != di->relief_background)
1860 {
1861 di->relief_background = color;
1862 x_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
1863 WHITE_PIX_DEFAULT (s->f));
1864 x_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
1865 BLACK_PIX_DEFAULT (s->f));
1866 }
1867 }
1868
1869
1870 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1871 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1872 to draw, it must be >= 0. RAISED_P means draw a raised
1873 relief. LEFT_P means draw a relief on the left side of
1874 the rectangle. RIGHT_P means draw a relief on the right
1875 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1876 when drawing. */
1877
1878 static void
1879 x_draw_relief_rect (struct frame *f,
1880 int left_x, int top_y, int right_x, int bottom_y,
1881 int width, bool raised_p, bool top_p, bool bot_p,
1882 bool left_p, bool right_p,
1883 XRectangle *clip_rect)
1884 {
1885 Display *dpy = FRAME_X_DISPLAY (f);
1886 Window window = FRAME_X_WINDOW (f);
1887 int i;
1888 GC gc;
1889
1890 if (raised_p)
1891 gc = f->output_data.x->white_relief.gc;
1892 else
1893 gc = f->output_data.x->black_relief.gc;
1894 XSetClipRectangles (dpy, gc, 0, 0, clip_rect, 1, Unsorted);
1895
1896 /* This code is more complicated than it has to be, because of two
1897 minor hacks to make the boxes look nicer: (i) if width > 1, draw
1898 the outermost line using the black relief. (ii) Omit the four
1899 corner pixels. */
1900
1901 /* Top. */
1902 if (top_p)
1903 {
1904 if (width == 1)
1905 XDrawLine (dpy, window, gc,
1906 left_x + left_p, top_y,
1907 right_x + !right_p, top_y);
1908
1909 for (i = 1; i < width; ++i)
1910 XDrawLine (dpy, window, gc,
1911 left_x + i * left_p, top_y + i,
1912 right_x + 1 - i * right_p, top_y + i);
1913 }
1914
1915 /* Left. */
1916 if (left_p)
1917 {
1918 if (width == 1)
1919 XDrawLine (dpy, window, gc, left_x, top_y + 1, left_x, bottom_y);
1920
1921 XClearArea (dpy, window, left_x, top_y, 1, 1, False);
1922 XClearArea (dpy, window, left_x, bottom_y, 1, 1, False);
1923
1924 for (i = (width > 1 ? 1 : 0); i < width; ++i)
1925 XDrawLine (dpy, window, gc,
1926 left_x + i, top_y + (i + 1) * top_p,
1927 left_x + i, bottom_y + 1 - (i + 1) * bot_p);
1928 }
1929
1930 XSetClipMask (dpy, gc, None);
1931 if (raised_p)
1932 gc = f->output_data.x->black_relief.gc;
1933 else
1934 gc = f->output_data.x->white_relief.gc;
1935 XSetClipRectangles (dpy, gc, 0, 0, clip_rect, 1, Unsorted);
1936
1937 if (width > 1)
1938 {
1939 /* Outermost top line. */
1940 if (top_p)
1941 XDrawLine (dpy, window, gc,
1942 left_x + left_p, top_y,
1943 right_x + !right_p, top_y);
1944
1945 /* Outermost left line. */
1946 if (left_p)
1947 XDrawLine (dpy, window, gc, left_x, top_y + 1, left_x, bottom_y);
1948 }
1949
1950 /* Bottom. */
1951 if (bot_p)
1952 {
1953 XDrawLine (dpy, window, gc,
1954 left_x + left_p, bottom_y,
1955 right_x + !right_p, bottom_y);
1956 for (i = 1; i < width; ++i)
1957 XDrawLine (dpy, window, gc,
1958 left_x + i * left_p, bottom_y - i,
1959 right_x + 1 - i * right_p, bottom_y - i);
1960 }
1961
1962 /* Right. */
1963 if (right_p)
1964 {
1965 XClearArea (dpy, window, right_x, top_y, 1, 1, False);
1966 XClearArea (dpy, window, right_x, bottom_y, 1, 1, False);
1967 for (i = 0; i < width; ++i)
1968 XDrawLine (dpy, window, gc,
1969 right_x - i, top_y + (i + 1) * top_p,
1970 right_x - i, bottom_y + 1 - (i + 1) * bot_p);
1971 }
1972
1973 XSetClipMask (dpy, gc, None);
1974 }
1975
1976
1977 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1978 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1979 draw, it must be >= 0. LEFT_P means draw a line on the
1980 left side of the rectangle. RIGHT_P means draw a line
1981 on the right side of the rectangle. CLIP_RECT is the clipping
1982 rectangle to use when drawing. */
1983
1984 static void
1985 x_draw_box_rect (struct glyph_string *s,
1986 int left_x, int top_y, int right_x, int bottom_y, int width,
1987 bool left_p, bool right_p, XRectangle *clip_rect)
1988 {
1989 XGCValues xgcv;
1990
1991 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
1992 XSetForeground (s->display, s->gc, s->face->box_color);
1993 XSetClipRectangles (s->display, s->gc, 0, 0, clip_rect, 1, Unsorted);
1994
1995 /* Top. */
1996 XFillRectangle (s->display, s->window, s->gc,
1997 left_x, top_y, right_x - left_x + 1, width);
1998
1999 /* Left. */
2000 if (left_p)
2001 XFillRectangle (s->display, s->window, s->gc,
2002 left_x, top_y, width, bottom_y - top_y + 1);
2003
2004 /* Bottom. */
2005 XFillRectangle (s->display, s->window, s->gc,
2006 left_x, bottom_y - width + 1, right_x - left_x + 1, width);
2007
2008 /* Right. */
2009 if (right_p)
2010 XFillRectangle (s->display, s->window, s->gc,
2011 right_x - width + 1, top_y, width, bottom_y - top_y + 1);
2012
2013 XSetForeground (s->display, s->gc, xgcv.foreground);
2014 XSetClipMask (s->display, s->gc, None);
2015 }
2016
2017
2018 /* Draw a box around glyph string S. */
2019
2020 static void
2021 x_draw_glyph_string_box (struct glyph_string *s)
2022 {
2023 int width, left_x, right_x, top_y, bottom_y, last_x;
2024 bool raised_p, left_p, right_p;
2025 struct glyph *last_glyph;
2026 XRectangle clip_rect;
2027
2028 last_x = ((s->row->full_width_p && !s->w->pseudo_window_p)
2029 ? WINDOW_RIGHT_EDGE_X (s->w)
2030 : window_box_right (s->w, s->area));
2031
2032 /* The glyph that may have a right box line. */
2033 last_glyph = (s->cmp || s->img
2034 ? s->first_glyph
2035 : s->first_glyph + s->nchars - 1);
2036
2037 width = eabs (s->face->box_line_width);
2038 raised_p = s->face->box == FACE_RAISED_BOX;
2039 left_x = s->x;
2040 right_x = (s->row->full_width_p && s->extends_to_end_of_line_p
2041 ? last_x - 1
2042 : min (last_x, s->x + s->background_width) - 1);
2043 top_y = s->y;
2044 bottom_y = top_y + s->height - 1;
2045
2046 left_p = (s->first_glyph->left_box_line_p
2047 || (s->hl == DRAW_MOUSE_FACE
2048 && (s->prev == NULL
2049 || s->prev->hl != s->hl)));
2050 right_p = (last_glyph->right_box_line_p
2051 || (s->hl == DRAW_MOUSE_FACE
2052 && (s->next == NULL
2053 || s->next->hl != s->hl)));
2054
2055 get_glyph_string_clip_rect (s, &clip_rect);
2056
2057 if (s->face->box == FACE_SIMPLE_BOX)
2058 x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
2059 left_p, right_p, &clip_rect);
2060 else
2061 {
2062 x_setup_relief_colors (s);
2063 x_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
2064 width, raised_p, true, true, left_p, right_p,
2065 &clip_rect);
2066 }
2067 }
2068
2069
2070 /* Draw foreground of image glyph string S. */
2071
2072 static void
2073 x_draw_image_foreground (struct glyph_string *s)
2074 {
2075 int x = s->x;
2076 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
2077
2078 /* If first glyph of S has a left box line, start drawing it to the
2079 right of that line. */
2080 if (s->face->box != FACE_NO_BOX
2081 && s->first_glyph->left_box_line_p
2082 && s->slice.x == 0)
2083 x += eabs (s->face->box_line_width);
2084
2085 /* If there is a margin around the image, adjust x- and y-position
2086 by that margin. */
2087 if (s->slice.x == 0)
2088 x += s->img->hmargin;
2089 if (s->slice.y == 0)
2090 y += s->img->vmargin;
2091
2092 if (s->img->pixmap)
2093 {
2094 if (s->img->mask)
2095 {
2096 /* We can't set both a clip mask and use XSetClipRectangles
2097 because the latter also sets a clip mask. We also can't
2098 trust on the shape extension to be available
2099 (XShapeCombineRegion). So, compute the rectangle to draw
2100 manually. */
2101 unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
2102 | GCFunction);
2103 XGCValues xgcv;
2104 XRectangle clip_rect, image_rect, r;
2105
2106 xgcv.clip_mask = s->img->mask;
2107 xgcv.clip_x_origin = x;
2108 xgcv.clip_y_origin = y;
2109 xgcv.function = GXcopy;
2110 XChangeGC (s->display, s->gc, mask, &xgcv);
2111
2112 get_glyph_string_clip_rect (s, &clip_rect);
2113 image_rect.x = x;
2114 image_rect.y = y;
2115 image_rect.width = s->slice.width;
2116 image_rect.height = s->slice.height;
2117 if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
2118 XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
2119 s->slice.x + r.x - x, s->slice.y + r.y - y,
2120 r.width, r.height, r.x, r.y);
2121 }
2122 else
2123 {
2124 XRectangle clip_rect, image_rect, r;
2125
2126 get_glyph_string_clip_rect (s, &clip_rect);
2127 image_rect.x = x;
2128 image_rect.y = y;
2129 image_rect.width = s->slice.width;
2130 image_rect.height = s->slice.height;
2131 if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
2132 XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
2133 s->slice.x + r.x - x, s->slice.y + r.y - y,
2134 r.width, r.height, r.x, r.y);
2135
2136 /* When the image has a mask, we can expect that at
2137 least part of a mouse highlight or a block cursor will
2138 be visible. If the image doesn't have a mask, make
2139 a block cursor visible by drawing a rectangle around
2140 the image. I believe it's looking better if we do
2141 nothing here for mouse-face. */
2142 if (s->hl == DRAW_CURSOR)
2143 {
2144 int relief = eabs (s->img->relief);
2145 XDrawRectangle (s->display, s->window, s->gc,
2146 x - relief, y - relief,
2147 s->slice.width + relief*2 - 1,
2148 s->slice.height + relief*2 - 1);
2149 }
2150 }
2151 }
2152 else
2153 /* Draw a rectangle if image could not be loaded. */
2154 XDrawRectangle (s->display, s->window, s->gc, x, y,
2155 s->slice.width - 1, s->slice.height - 1);
2156 }
2157
2158
2159 /* Draw a relief around the image glyph string S. */
2160
2161 static void
2162 x_draw_image_relief (struct glyph_string *s)
2163 {
2164 int x1, y1, thick;
2165 bool raised_p, top_p, bot_p, left_p, right_p;
2166 int extra_x, extra_y;
2167 XRectangle r;
2168 int x = s->x;
2169 int y = s->ybase - image_ascent (s->img, s->face, &s->slice);
2170
2171 /* If first glyph of S has a left box line, start drawing it to the
2172 right of that line. */
2173 if (s->face->box != FACE_NO_BOX
2174 && s->first_glyph->left_box_line_p
2175 && s->slice.x == 0)
2176 x += eabs (s->face->box_line_width);
2177
2178 /* If there is a margin around the image, adjust x- and y-position
2179 by that margin. */
2180 if (s->slice.x == 0)
2181 x += s->img->hmargin;
2182 if (s->slice.y == 0)
2183 y += s->img->vmargin;
2184
2185 if (s->hl == DRAW_IMAGE_SUNKEN
2186 || s->hl == DRAW_IMAGE_RAISED)
2187 {
2188 thick = tool_bar_button_relief >= 0 ? tool_bar_button_relief : DEFAULT_TOOL_BAR_BUTTON_RELIEF;
2189 raised_p = s->hl == DRAW_IMAGE_RAISED;
2190 }
2191 else
2192 {
2193 thick = eabs (s->img->relief);
2194 raised_p = s->img->relief > 0;
2195 }
2196
2197 x1 = x + s->slice.width - 1;
2198 y1 = y + s->slice.height - 1;
2199
2200 extra_x = extra_y = 0;
2201 if (s->face->id == TOOL_BAR_FACE_ID)
2202 {
2203 if (CONSP (Vtool_bar_button_margin)
2204 && INTEGERP (XCAR (Vtool_bar_button_margin))
2205 && INTEGERP (XCDR (Vtool_bar_button_margin)))
2206 {
2207 extra_x = XINT (XCAR (Vtool_bar_button_margin));
2208 extra_y = XINT (XCDR (Vtool_bar_button_margin));
2209 }
2210 else if (INTEGERP (Vtool_bar_button_margin))
2211 extra_x = extra_y = XINT (Vtool_bar_button_margin);
2212 }
2213
2214 top_p = bot_p = left_p = right_p = false;
2215
2216 if (s->slice.x == 0)
2217 x -= thick + extra_x, left_p = true;
2218 if (s->slice.y == 0)
2219 y -= thick + extra_y, top_p = true;
2220 if (s->slice.x + s->slice.width == s->img->width)
2221 x1 += thick + extra_x, right_p = true;
2222 if (s->slice.y + s->slice.height == s->img->height)
2223 y1 += thick + extra_y, bot_p = true;
2224
2225 x_setup_relief_colors (s);
2226 get_glyph_string_clip_rect (s, &r);
2227 x_draw_relief_rect (s->f, x, y, x1, y1, thick, raised_p,
2228 top_p, bot_p, left_p, right_p, &r);
2229 }
2230
2231
2232 /* Draw the foreground of image glyph string S to PIXMAP. */
2233
2234 static void
2235 x_draw_image_foreground_1 (struct glyph_string *s, Pixmap pixmap)
2236 {
2237 int x = 0;
2238 int y = s->ybase - s->y - image_ascent (s->img, s->face, &s->slice);
2239
2240 /* If first glyph of S has a left box line, start drawing it to the
2241 right of that line. */
2242 if (s->face->box != FACE_NO_BOX
2243 && s->first_glyph->left_box_line_p
2244 && s->slice.x == 0)
2245 x += eabs (s->face->box_line_width);
2246
2247 /* If there is a margin around the image, adjust x- and y-position
2248 by that margin. */
2249 if (s->slice.x == 0)
2250 x += s->img->hmargin;
2251 if (s->slice.y == 0)
2252 y += s->img->vmargin;
2253
2254 if (s->img->pixmap)
2255 {
2256 if (s->img->mask)
2257 {
2258 /* We can't set both a clip mask and use XSetClipRectangles
2259 because the latter also sets a clip mask. We also can't
2260 trust on the shape extension to be available
2261 (XShapeCombineRegion). So, compute the rectangle to draw
2262 manually. */
2263 unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
2264 | GCFunction);
2265 XGCValues xgcv;
2266
2267 xgcv.clip_mask = s->img->mask;
2268 xgcv.clip_x_origin = x - s->slice.x;
2269 xgcv.clip_y_origin = y - s->slice.y;
2270 xgcv.function = GXcopy;
2271 XChangeGC (s->display, s->gc, mask, &xgcv);
2272
2273 XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
2274 s->slice.x, s->slice.y,
2275 s->slice.width, s->slice.height, x, y);
2276 XSetClipMask (s->display, s->gc, None);
2277 }
2278 else
2279 {
2280 XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
2281 s->slice.x, s->slice.y,
2282 s->slice.width, s->slice.height, x, y);
2283
2284 /* When the image has a mask, we can expect that at
2285 least part of a mouse highlight or a block cursor will
2286 be visible. If the image doesn't have a mask, make
2287 a block cursor visible by drawing a rectangle around
2288 the image. I believe it's looking better if we do
2289 nothing here for mouse-face. */
2290 if (s->hl == DRAW_CURSOR)
2291 {
2292 int r = eabs (s->img->relief);
2293 XDrawRectangle (s->display, s->window, s->gc, x - r, y - r,
2294 s->slice.width + r*2 - 1,
2295 s->slice.height + r*2 - 1);
2296 }
2297 }
2298 }
2299 else
2300 /* Draw a rectangle if image could not be loaded. */
2301 XDrawRectangle (s->display, pixmap, s->gc, x, y,
2302 s->slice.width - 1, s->slice.height - 1);
2303 }
2304
2305
2306 /* Draw part of the background of glyph string S. X, Y, W, and H
2307 give the rectangle to draw. */
2308
2309 static void
2310 x_draw_glyph_string_bg_rect (struct glyph_string *s, int x, int y, int w, int h)
2311 {
2312 if (s->stippled_p)
2313 {
2314 /* Fill background with a stipple pattern. */
2315 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2316 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
2317 XSetFillStyle (s->display, s->gc, FillSolid);
2318 }
2319 else
2320 x_clear_glyph_string_rect (s, x, y, w, h);
2321 }
2322
2323
2324 /* Draw image glyph string S.
2325
2326 s->y
2327 s->x +-------------------------
2328 | s->face->box
2329 |
2330 | +-------------------------
2331 | | s->img->margin
2332 | |
2333 | | +-------------------
2334 | | | the image
2335
2336 */
2337
2338 static void
2339 x_draw_image_glyph_string (struct glyph_string *s)
2340 {
2341 int box_line_hwidth = eabs (s->face->box_line_width);
2342 int box_line_vwidth = max (s->face->box_line_width, 0);
2343 int height;
2344 Pixmap pixmap = None;
2345
2346 height = s->height;
2347 if (s->slice.y == 0)
2348 height -= box_line_vwidth;
2349 if (s->slice.y + s->slice.height >= s->img->height)
2350 height -= box_line_vwidth;
2351
2352 /* Fill background with face under the image. Do it only if row is
2353 taller than image or if image has a clip mask to reduce
2354 flickering. */
2355 s->stippled_p = s->face->stipple != 0;
2356 if (height > s->slice.height
2357 || s->img->hmargin
2358 || s->img->vmargin
2359 || s->img->mask
2360 || s->img->pixmap == 0
2361 || s->width != s->background_width)
2362 {
2363 if (s->img->mask)
2364 {
2365 /* Create a pixmap as large as the glyph string. Fill it
2366 with the background color. Copy the image to it, using
2367 its mask. Copy the temporary pixmap to the display. */
2368 Screen *screen = FRAME_X_SCREEN (s->f);
2369 int depth = DefaultDepthOfScreen (screen);
2370
2371 /* Create a pixmap as large as the glyph string. */
2372 pixmap = XCreatePixmap (s->display, s->window,
2373 s->background_width,
2374 s->height, depth);
2375
2376 /* Don't clip in the following because we're working on the
2377 pixmap. */
2378 XSetClipMask (s->display, s->gc, None);
2379
2380 /* Fill the pixmap with the background color/stipple. */
2381 if (s->stippled_p)
2382 {
2383 /* Fill background with a stipple pattern. */
2384 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
2385 XSetTSOrigin (s->display, s->gc, - s->x, - s->y);
2386 XFillRectangle (s->display, pixmap, s->gc,
2387 0, 0, s->background_width, s->height);
2388 XSetFillStyle (s->display, s->gc, FillSolid);
2389 XSetTSOrigin (s->display, s->gc, 0, 0);
2390 }
2391 else
2392 {
2393 XGCValues xgcv;
2394 XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
2395 &xgcv);
2396 XSetForeground (s->display, s->gc, xgcv.background);
2397 XFillRectangle (s->display, pixmap, s->gc,
2398 0, 0, s->background_width, s->height);
2399 XSetForeground (s->display, s->gc, xgcv.foreground);
2400 }
2401 }
2402 else
2403 {
2404 int x = s->x;
2405 int y = s->y;
2406 int width = s->background_width;
2407
2408 if (s->first_glyph->left_box_line_p
2409 && s->slice.x == 0)
2410 {
2411 x += box_line_hwidth;
2412 width -= box_line_hwidth;
2413 }
2414
2415 if (s->slice.y == 0)
2416 y += box_line_vwidth;
2417
2418 x_draw_glyph_string_bg_rect (s, x, y, width, height);
2419 }
2420
2421 s->background_filled_p = true;
2422 }
2423
2424 /* Draw the foreground. */
2425 if (pixmap != None)
2426 {
2427 x_draw_image_foreground_1 (s, pixmap);
2428 x_set_glyph_string_clipping (s);
2429 XCopyArea (s->display, pixmap, s->window, s->gc,
2430 0, 0, s->background_width, s->height, s->x, s->y);
2431 XFreePixmap (s->display, pixmap);
2432 }
2433 else
2434 x_draw_image_foreground (s);
2435
2436 /* If we must draw a relief around the image, do it. */
2437 if (s->img->relief
2438 || s->hl == DRAW_IMAGE_RAISED
2439 || s->hl == DRAW_IMAGE_SUNKEN)
2440 x_draw_image_relief (s);
2441 }
2442
2443
2444 /* Draw stretch glyph string S. */
2445
2446 static void
2447 x_draw_stretch_glyph_string (struct glyph_string *s)
2448 {
2449 eassert (s->first_glyph->type == STRETCH_GLYPH);
2450
2451 if (s->hl == DRAW_CURSOR
2452 && !x_stretch_cursor_p)
2453 {
2454 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2455 wide as the stretch glyph. */
2456 int width, background_width = s->background_width;
2457 int x = s->x;
2458
2459 if (!s->row->reversed_p)
2460 {
2461 int left_x = window_box_left_offset (s->w, TEXT_AREA);
2462
2463 if (x < left_x)
2464 {
2465 background_width -= left_x - x;
2466 x = left_x;
2467 }
2468 }
2469 else
2470 {
2471 /* In R2L rows, draw the cursor on the right edge of the
2472 stretch glyph. */
2473 int right_x = window_box_right (s->w, TEXT_AREA);
2474
2475 if (x + background_width > right_x)
2476 background_width -= x - right_x;
2477 x += background_width;
2478 }
2479 width = min (FRAME_COLUMN_WIDTH (s->f), background_width);
2480 if (s->row->reversed_p)
2481 x -= width;
2482
2483 /* Draw cursor. */
2484 x_draw_glyph_string_bg_rect (s, x, s->y, width, s->height);
2485
2486 /* Clear rest using the GC of the original non-cursor face. */
2487 if (width < background_width)
2488 {
2489 int y = s->y;
2490 int w = background_width - width, h = s->height;
2491 XRectangle r;
2492 GC gc;
2493
2494 if (!s->row->reversed_p)
2495 x += width;
2496 else
2497 x = s->x;
2498 if (s->row->mouse_face_p
2499 && cursor_in_mouse_face_p (s->w))
2500 {
2501 x_set_mouse_face_gc (s);
2502 gc = s->gc;
2503 }
2504 else
2505 gc = s->face->gc;
2506
2507 get_glyph_string_clip_rect (s, &r);
2508 XSetClipRectangles (s->display, gc, 0, 0, &r, 1, Unsorted);
2509
2510 if (s->face->stipple)
2511 {
2512 /* Fill background with a stipple pattern. */
2513 XSetFillStyle (s->display, gc, FillOpaqueStippled);
2514 XFillRectangle (s->display, s->window, gc, x, y, w, h);
2515 XSetFillStyle (s->display, gc, FillSolid);
2516 }
2517 else
2518 {
2519 XGCValues xgcv;
2520 XGetGCValues (s->display, gc, GCForeground | GCBackground, &xgcv);
2521 XSetForeground (s->display, gc, xgcv.background);
2522 XFillRectangle (s->display, s->window, gc, x, y, w, h);
2523 XSetForeground (s->display, gc, xgcv.foreground);
2524 }
2525
2526 XSetClipMask (s->display, gc, None);
2527 }
2528 }
2529 else if (!s->background_filled_p)
2530 {
2531 int background_width = s->background_width;
2532 int x = s->x, left_x = window_box_left_offset (s->w, TEXT_AREA);
2533
2534 /* Don't draw into left margin, fringe or scrollbar area
2535 except for header line and mode line. */
2536 if (x < left_x && !s->row->mode_line_p)
2537 {
2538 background_width -= left_x - x;
2539 x = left_x;
2540 }
2541 if (background_width > 0)
2542 x_draw_glyph_string_bg_rect (s, x, s->y, background_width, s->height);
2543 }
2544
2545 s->background_filled_p = true;
2546 }
2547
2548 /*
2549 Draw a wavy line under S. The wave fills wave_height pixels from y0.
2550
2551 x0 wave_length = 2
2552 --
2553 y0 * * * * *
2554 |* * * * * * * * *
2555 wave_height = 3 | * * * *
2556
2557 */
2558
2559 static void
2560 x_draw_underwave (struct glyph_string *s)
2561 {
2562 int wave_height = 3, wave_length = 2;
2563 int dx, dy, x0, y0, width, x1, y1, x2, y2, xmax;
2564 bool odd;
2565 XRectangle wave_clip, string_clip, final_clip;
2566
2567 dx = wave_length;
2568 dy = wave_height - 1;
2569 x0 = s->x;
2570 y0 = s->ybase - wave_height + 3;
2571 width = s->width;
2572 xmax = x0 + width;
2573
2574 /* Find and set clipping rectangle */
2575
2576 wave_clip.x = x0;
2577 wave_clip.y = y0;
2578 wave_clip.width = width;
2579 wave_clip.height = wave_height;
2580 get_glyph_string_clip_rect (s, &string_clip);
2581
2582 if (!x_intersect_rectangles (&wave_clip, &string_clip, &final_clip))
2583 return;
2584
2585 XSetClipRectangles (s->display, s->gc, 0, 0, &final_clip, 1, Unsorted);
2586
2587 /* Draw the waves */
2588
2589 x1 = x0 - (x0 % dx);
2590 x2 = x1 + dx;
2591 odd = (x1 / dx) & 1;
2592 y1 = y2 = y0;
2593
2594 if (odd)
2595 y1 += dy;
2596 else
2597 y2 += dy;
2598
2599 if (INT_MAX - dx < xmax)
2600 emacs_abort ();
2601
2602 while (x1 <= xmax)
2603 {
2604 XDrawLine (s->display, s->window, s->gc, x1, y1, x2, y2);
2605 x1 = x2, y1 = y2;
2606 x2 += dx, y2 = y0 + odd*dy;
2607 odd = !odd;
2608 }
2609
2610 /* Restore previous clipping rectangle(s) */
2611 XSetClipRectangles (s->display, s->gc, 0, 0, s->clip, s->num_clips, Unsorted);
2612 }
2613
2614
2615 /* Draw glyph string S. */
2616
2617 static void
2618 x_draw_glyph_string (struct glyph_string *s)
2619 {
2620 bool relief_drawn_p = false;
2621
2622 /* If S draws into the background of its successors, draw the
2623 background of the successors first so that S can draw into it.
2624 This makes S->next use XDrawString instead of XDrawImageString. */
2625 if (s->next && s->right_overhang && !s->for_overlaps)
2626 {
2627 int width;
2628 struct glyph_string *next;
2629
2630 for (width = 0, next = s->next;
2631 next && width < s->right_overhang;
2632 width += next->width, next = next->next)
2633 if (next->first_glyph->type != IMAGE_GLYPH)
2634 {
2635 x_set_glyph_string_gc (next);
2636 x_set_glyph_string_clipping (next);
2637 if (next->first_glyph->type == STRETCH_GLYPH)
2638 x_draw_stretch_glyph_string (next);
2639 else
2640 x_draw_glyph_string_background (next, true);
2641 next->num_clips = 0;
2642 }
2643 }
2644
2645 /* Set up S->gc, set clipping and draw S. */
2646 x_set_glyph_string_gc (s);
2647
2648 /* Draw relief (if any) in advance for char/composition so that the
2649 glyph string can be drawn over it. */
2650 if (!s->for_overlaps
2651 && s->face->box != FACE_NO_BOX
2652 && (s->first_glyph->type == CHAR_GLYPH
2653 || s->first_glyph->type == COMPOSITE_GLYPH))
2654
2655 {
2656 x_set_glyph_string_clipping (s);
2657 x_draw_glyph_string_background (s, true);
2658 x_draw_glyph_string_box (s);
2659 x_set_glyph_string_clipping (s);
2660 relief_drawn_p = true;
2661 }
2662 else if (!s->clip_head /* draw_glyphs didn't specify a clip mask. */
2663 && !s->clip_tail
2664 && ((s->prev && s->prev->hl != s->hl && s->left_overhang)
2665 || (s->next && s->next->hl != s->hl && s->right_overhang)))
2666 /* We must clip just this glyph. left_overhang part has already
2667 drawn when s->prev was drawn, and right_overhang part will be
2668 drawn later when s->next is drawn. */
2669 x_set_glyph_string_clipping_exactly (s, s);
2670 else
2671 x_set_glyph_string_clipping (s);
2672
2673 switch (s->first_glyph->type)
2674 {
2675 case IMAGE_GLYPH:
2676 x_draw_image_glyph_string (s);
2677 break;
2678
2679 case STRETCH_GLYPH:
2680 x_draw_stretch_glyph_string (s);
2681 break;
2682
2683 case CHAR_GLYPH:
2684 if (s->for_overlaps)
2685 s->background_filled_p = true;
2686 else
2687 x_draw_glyph_string_background (s, false);
2688 x_draw_glyph_string_foreground (s);
2689 break;
2690
2691 case COMPOSITE_GLYPH:
2692 if (s->for_overlaps || (s->cmp_from > 0
2693 && ! s->first_glyph->u.cmp.automatic))
2694 s->background_filled_p = true;
2695 else
2696 x_draw_glyph_string_background (s, true);
2697 x_draw_composite_glyph_string_foreground (s);
2698 break;
2699
2700 case GLYPHLESS_GLYPH:
2701 if (s->for_overlaps)
2702 s->background_filled_p = true;
2703 else
2704 x_draw_glyph_string_background (s, true);
2705 x_draw_glyphless_glyph_string_foreground (s);
2706 break;
2707
2708 default:
2709 emacs_abort ();
2710 }
2711
2712 if (!s->for_overlaps)
2713 {
2714 /* Draw underline. */
2715 if (s->face->underline_p)
2716 {
2717 if (s->face->underline_type == FACE_UNDER_WAVE)
2718 {
2719 if (s->face->underline_defaulted_p)
2720 x_draw_underwave (s);
2721 else
2722 {
2723 XGCValues xgcv;
2724 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
2725 XSetForeground (s->display, s->gc, s->face->underline_color);
2726 x_draw_underwave (s);
2727 XSetForeground (s->display, s->gc, xgcv.foreground);
2728 }
2729 }
2730 else if (s->face->underline_type == FACE_UNDER_LINE)
2731 {
2732 unsigned long thickness, position;
2733 int y;
2734
2735 if (s->prev && s->prev->face->underline_p
2736 && s->prev->face->underline_type == FACE_UNDER_LINE)
2737 {
2738 /* We use the same underline style as the previous one. */
2739 thickness = s->prev->underline_thickness;
2740 position = s->prev->underline_position;
2741 }
2742 else
2743 {
2744 /* Get the underline thickness. Default is 1 pixel. */
2745 if (s->font && s->font->underline_thickness > 0)
2746 thickness = s->font->underline_thickness;
2747 else
2748 thickness = 1;
2749 if (x_underline_at_descent_line)
2750 position = (s->height - thickness) - (s->ybase - s->y);
2751 else
2752 {
2753 /* Get the underline position. This is the recommended
2754 vertical offset in pixels from the baseline to the top of
2755 the underline. This is a signed value according to the
2756 specs, and its default is
2757
2758 ROUND ((maximum descent) / 2), with
2759 ROUND(x) = floor (x + 0.5) */
2760
2761 if (x_use_underline_position_properties
2762 && s->font && s->font->underline_position >= 0)
2763 position = s->font->underline_position;
2764 else if (s->font)
2765 position = (s->font->descent + 1) / 2;
2766 else
2767 position = underline_minimum_offset;
2768 }
2769 position = max (position, underline_minimum_offset);
2770 }
2771 /* Check the sanity of thickness and position. We should
2772 avoid drawing underline out of the current line area. */
2773 if (s->y + s->height <= s->ybase + position)
2774 position = (s->height - 1) - (s->ybase - s->y);
2775 if (s->y + s->height < s->ybase + position + thickness)
2776 thickness = (s->y + s->height) - (s->ybase + position);
2777 s->underline_thickness = thickness;
2778 s->underline_position = position;
2779 y = s->ybase + position;
2780 if (s->face->underline_defaulted_p)
2781 XFillRectangle (s->display, s->window, s->gc,
2782 s->x, y, s->width, thickness);
2783 else
2784 {
2785 XGCValues xgcv;
2786 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
2787 XSetForeground (s->display, s->gc, s->face->underline_color);
2788 XFillRectangle (s->display, s->window, s->gc,
2789 s->x, y, s->width, thickness);
2790 XSetForeground (s->display, s->gc, xgcv.foreground);
2791 }
2792 }
2793 }
2794 /* Draw overline. */
2795 if (s->face->overline_p)
2796 {
2797 unsigned long dy = 0, h = 1;
2798
2799 if (s->face->overline_color_defaulted_p)
2800 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
2801 s->width, h);
2802 else
2803 {
2804 XGCValues xgcv;
2805 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
2806 XSetForeground (s->display, s->gc, s->face->overline_color);
2807 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
2808 s->width, h);
2809 XSetForeground (s->display, s->gc, xgcv.foreground);
2810 }
2811 }
2812
2813 /* Draw strike-through. */
2814 if (s->face->strike_through_p)
2815 {
2816 unsigned long h = 1;
2817 unsigned long dy = (s->height - h) / 2;
2818
2819 if (s->face->strike_through_color_defaulted_p)
2820 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
2821 s->width, h);
2822 else
2823 {
2824 XGCValues xgcv;
2825 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
2826 XSetForeground (s->display, s->gc, s->face->strike_through_color);
2827 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
2828 s->width, h);
2829 XSetForeground (s->display, s->gc, xgcv.foreground);
2830 }
2831 }
2832
2833 /* Draw relief if not yet drawn. */
2834 if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
2835 x_draw_glyph_string_box (s);
2836
2837 if (s->prev)
2838 {
2839 struct glyph_string *prev;
2840
2841 for (prev = s->prev; prev; prev = prev->prev)
2842 if (prev->hl != s->hl
2843 && prev->x + prev->width + prev->right_overhang > s->x)
2844 {
2845 /* As prev was drawn while clipped to its own area, we
2846 must draw the right_overhang part using s->hl now. */
2847 enum draw_glyphs_face save = prev->hl;
2848
2849 prev->hl = s->hl;
2850 x_set_glyph_string_gc (prev);
2851 x_set_glyph_string_clipping_exactly (s, prev);
2852 if (prev->first_glyph->type == CHAR_GLYPH)
2853 x_draw_glyph_string_foreground (prev);
2854 else
2855 x_draw_composite_glyph_string_foreground (prev);
2856 XSetClipMask (prev->display, prev->gc, None);
2857 prev->hl = save;
2858 prev->num_clips = 0;
2859 }
2860 }
2861
2862 if (s->next)
2863 {
2864 struct glyph_string *next;
2865
2866 for (next = s->next; next; next = next->next)
2867 if (next->hl != s->hl
2868 && next->x - next->left_overhang < s->x + s->width)
2869 {
2870 /* As next will be drawn while clipped to its own area,
2871 we must draw the left_overhang part using s->hl now. */
2872 enum draw_glyphs_face save = next->hl;
2873
2874 next->hl = s->hl;
2875 x_set_glyph_string_gc (next);
2876 x_set_glyph_string_clipping_exactly (s, next);
2877 if (next->first_glyph->type == CHAR_GLYPH)
2878 x_draw_glyph_string_foreground (next);
2879 else
2880 x_draw_composite_glyph_string_foreground (next);
2881 XSetClipMask (next->display, next->gc, None);
2882 next->hl = save;
2883 next->num_clips = 0;
2884 next->clip_head = s->next;
2885 }
2886 }
2887 }
2888
2889 /* Reset clipping. */
2890 XSetClipMask (s->display, s->gc, None);
2891 s->num_clips = 0;
2892 }
2893
2894 /* Shift display to make room for inserted glyphs. */
2895
2896 static void
2897 x_shift_glyphs_for_insert (struct frame *f, int x, int y, int width, int height, int shift_by)
2898 {
2899 XCopyArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
2900 f->output_data.x->normal_gc,
2901 x, y, width, height,
2902 x + shift_by, y);
2903 }
2904
2905 /* Delete N glyphs at the nominal cursor position. Not implemented
2906 for X frames. */
2907
2908 static void
2909 x_delete_glyphs (struct frame *f, register int n)
2910 {
2911 emacs_abort ();
2912 }
2913
2914
2915 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2916 If they are <= 0, this is probably an error. */
2917
2918 void
2919 x_clear_area (Display *dpy, Window window, int x, int y, int width, int height)
2920 {
2921 eassert (width > 0 && height > 0);
2922 XClearArea (dpy, window, x, y, width, height, False);
2923 }
2924
2925
2926 /* Clear an entire frame. */
2927
2928 static void
2929 x_clear_frame (struct frame *f)
2930 {
2931 /* Clearing the frame will erase any cursor, so mark them all as no
2932 longer visible. */
2933 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
2934
2935 block_input ();
2936
2937 XClearWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
2938
2939 /* We have to clear the scroll bars. If we have changed colors or
2940 something like that, then they should be notified. */
2941 x_scroll_bar_clear (f);
2942
2943 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
2944 /* Make sure scroll bars are redrawn. As they aren't redrawn by
2945 redisplay, do it here. */
2946 if (FRAME_GTK_WIDGET (f))
2947 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f));
2948 #endif
2949
2950 XFlush (FRAME_X_DISPLAY (f));
2951
2952 unblock_input ();
2953 }
2954
2955 /* RIF: Show hourglass cursor on frame F. */
2956
2957 static void
2958 x_show_hourglass (struct frame *f)
2959 {
2960 Display *dpy = FRAME_X_DISPLAY (f);
2961
2962 if (dpy)
2963 {
2964 struct x_output *x = FRAME_X_OUTPUT (f);
2965 #ifdef USE_X_TOOLKIT
2966 if (x->widget)
2967 #else
2968 if (FRAME_OUTER_WINDOW (f))
2969 #endif
2970 {
2971 x->hourglass_p = true;
2972
2973 if (!x->hourglass_window)
2974 {
2975 unsigned long mask = CWCursor;
2976 XSetWindowAttributes attrs;
2977 #ifdef USE_GTK
2978 Window parent = FRAME_X_WINDOW (f);
2979 #else
2980 Window parent = FRAME_OUTER_WINDOW (f);
2981 #endif
2982 attrs.cursor = x->hourglass_cursor;
2983
2984 x->hourglass_window = XCreateWindow
2985 (dpy, parent, 0, 0, 32000, 32000, 0, 0,
2986 InputOnly, CopyFromParent, mask, &attrs);
2987 }
2988
2989 XMapRaised (dpy, x->hourglass_window);
2990 XFlush (dpy);
2991 }
2992 }
2993 }
2994
2995 /* RIF: Cancel hourglass cursor on frame F. */
2996
2997 static void
2998 x_hide_hourglass (struct frame *f)
2999 {
3000 struct x_output *x = FRAME_X_OUTPUT (f);
3001
3002 /* Watch out for newly created frames. */
3003 if (x->hourglass_window)
3004 {
3005 XUnmapWindow (FRAME_X_DISPLAY (f), x->hourglass_window);
3006 /* Sync here because XTread_socket looks at the
3007 hourglass_p flag that is reset to zero below. */
3008 XSync (FRAME_X_DISPLAY (f), False);
3009 x->hourglass_p = false;
3010 }
3011 }
3012
3013 /* Invert the middle quarter of the frame for .15 sec. */
3014
3015 static void
3016 XTflash (struct frame *f)
3017 {
3018 block_input ();
3019
3020 {
3021 #ifdef USE_GTK
3022 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
3023 when the scroll bars and the edit widget share the same X window. */
3024 GdkWindow *window = gtk_widget_get_window (FRAME_GTK_WIDGET (f));
3025 #ifdef HAVE_GTK3
3026 cairo_t *cr = gdk_cairo_create (window);
3027 cairo_set_source_rgb (cr, 1, 1, 1);
3028 cairo_set_operator (cr, CAIRO_OPERATOR_DIFFERENCE);
3029 #define XFillRectangle(d, win, gc, x, y, w, h) \
3030 do { \
3031 cairo_rectangle (cr, x, y, w, h); \
3032 cairo_fill (cr); \
3033 } \
3034 while (false)
3035 #else /* ! HAVE_GTK3 */
3036 GdkGCValues vals;
3037 GdkGC *gc;
3038 vals.foreground.pixel = (FRAME_FOREGROUND_PIXEL (f)
3039 ^ FRAME_BACKGROUND_PIXEL (f));
3040 vals.function = GDK_XOR;
3041 gc = gdk_gc_new_with_values (window,
3042 &vals, GDK_GC_FUNCTION | GDK_GC_FOREGROUND);
3043 #define XFillRectangle(d, win, gc, x, y, w, h) \
3044 gdk_draw_rectangle (window, gc, true, x, y, w, h)
3045 #endif /* ! HAVE_GTK3 */
3046 #else /* ! USE_GTK */
3047 GC gc;
3048
3049 /* Create a GC that will use the GXxor function to flip foreground
3050 pixels into background pixels. */
3051 {
3052 XGCValues values;
3053
3054 values.function = GXxor;
3055 values.foreground = (FRAME_FOREGROUND_PIXEL (f)
3056 ^ FRAME_BACKGROUND_PIXEL (f));
3057
3058 gc = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3059 GCFunction | GCForeground, &values);
3060 }
3061 #endif
3062 {
3063 /* Get the height not including a menu bar widget. */
3064 int height = FRAME_PIXEL_HEIGHT (f);
3065 /* Height of each line to flash. */
3066 int flash_height = FRAME_LINE_HEIGHT (f);
3067 /* These will be the left and right margins of the rectangles. */
3068 int flash_left = FRAME_INTERNAL_BORDER_WIDTH (f);
3069 int flash_right = FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f);
3070 int width = flash_right - flash_left;
3071
3072 /* If window is tall, flash top and bottom line. */
3073 if (height > 3 * FRAME_LINE_HEIGHT (f))
3074 {
3075 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3076 flash_left,
3077 (FRAME_INTERNAL_BORDER_WIDTH (f)
3078 + FRAME_TOP_MARGIN_HEIGHT (f)),
3079 width, flash_height);
3080 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3081 flash_left,
3082 (height - flash_height
3083 - FRAME_INTERNAL_BORDER_WIDTH (f)),
3084 width, flash_height);
3085
3086 }
3087 else
3088 /* If it is short, flash it all. */
3089 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3090 flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
3091 width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
3092
3093 x_flush (f);
3094
3095 {
3096 struct timespec delay = make_timespec (0, 150 * 1000 * 1000);
3097 struct timespec wakeup = timespec_add (current_timespec (), delay);
3098
3099 /* Keep waiting until past the time wakeup or any input gets
3100 available. */
3101 while (! detect_input_pending ())
3102 {
3103 struct timespec current = current_timespec ();
3104 struct timespec timeout;
3105
3106 /* Break if result would not be positive. */
3107 if (timespec_cmp (wakeup, current) <= 0)
3108 break;
3109
3110 /* How long `select' should wait. */
3111 timeout = make_timespec (0, 10 * 1000 * 1000);
3112
3113 /* Try to wait that long--but we might wake up sooner. */
3114 pselect (0, NULL, NULL, NULL, &timeout, NULL);
3115 }
3116 }
3117
3118 /* If window is tall, flash top and bottom line. */
3119 if (height > 3 * FRAME_LINE_HEIGHT (f))
3120 {
3121 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3122 flash_left,
3123 (FRAME_INTERNAL_BORDER_WIDTH (f)
3124 + FRAME_TOP_MARGIN_HEIGHT (f)),
3125 width, flash_height);
3126 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3127 flash_left,
3128 (height - flash_height
3129 - FRAME_INTERNAL_BORDER_WIDTH (f)),
3130 width, flash_height);
3131 }
3132 else
3133 /* If it is short, flash it all. */
3134 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3135 flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
3136 width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
3137
3138 #ifdef USE_GTK
3139 #ifdef HAVE_GTK3
3140 cairo_destroy (cr);
3141 #else
3142 g_object_unref (G_OBJECT (gc));
3143 #endif
3144 #undef XFillRectangle
3145 #else
3146 XFreeGC (FRAME_X_DISPLAY (f), gc);
3147 #endif
3148 x_flush (f);
3149 }
3150 }
3151
3152 unblock_input ();
3153 }
3154
3155
3156 static void
3157 XTtoggle_invisible_pointer (struct frame *f, bool invisible)
3158 {
3159 block_input ();
3160 FRAME_DISPLAY_INFO (f)->toggle_visible_pointer (f, invisible);
3161 unblock_input ();
3162 }
3163
3164
3165 /* Make audible bell. */
3166
3167 static void
3168 XTring_bell (struct frame *f)
3169 {
3170 if (FRAME_X_DISPLAY (f))
3171 {
3172 if (visible_bell)
3173 XTflash (f);
3174 else
3175 {
3176 block_input ();
3177 #ifdef HAVE_XKB
3178 XkbBell (FRAME_X_DISPLAY (f), None, 0, None);
3179 #else
3180 XBell (FRAME_X_DISPLAY (f), 0);
3181 #endif
3182 XFlush (FRAME_X_DISPLAY (f));
3183 unblock_input ();
3184 }
3185 }
3186 }
3187
3188 /***********************************************************************
3189 Line Dance
3190 ***********************************************************************/
3191
3192 /* Perform an insert-lines or delete-lines operation, inserting N
3193 lines or deleting -N lines at vertical position VPOS. */
3194
3195 static void
3196 x_ins_del_lines (struct frame *f, int vpos, int n)
3197 {
3198 emacs_abort ();
3199 }
3200
3201
3202 /* Scroll part of the display as described by RUN. */
3203
3204 static void
3205 x_scroll_run (struct window *w, struct run *run)
3206 {
3207 struct frame *f = XFRAME (w->frame);
3208 int x, y, width, height, from_y, to_y, bottom_y;
3209
3210 /* Get frame-relative bounding box of the text display area of W,
3211 without mode lines. Include in this box the left and right
3212 fringe of W. */
3213 window_box (w, ANY_AREA, &x, &y, &width, &height);
3214
3215 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
3216 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
3217 bottom_y = y + height;
3218
3219 if (to_y < from_y)
3220 {
3221 /* Scrolling up. Make sure we don't copy part of the mode
3222 line at the bottom. */
3223 if (from_y + run->height > bottom_y)
3224 height = bottom_y - from_y;
3225 else
3226 height = run->height;
3227 }
3228 else
3229 {
3230 /* Scrolling down. Make sure we don't copy over the mode line.
3231 at the bottom. */
3232 if (to_y + run->height > bottom_y)
3233 height = bottom_y - to_y;
3234 else
3235 height = run->height;
3236 }
3237
3238 block_input ();
3239
3240 /* Cursor off. Will be switched on again in x_update_window_end. */
3241 x_clear_cursor (w);
3242
3243 XCopyArea (FRAME_X_DISPLAY (f),
3244 FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
3245 f->output_data.x->normal_gc,
3246 x, from_y,
3247 width, height,
3248 x, to_y);
3249
3250 unblock_input ();
3251 }
3252
3253
3254 \f
3255 /***********************************************************************
3256 Exposure Events
3257 ***********************************************************************/
3258
3259 \f
3260 static void
3261 frame_highlight (struct frame *f)
3262 {
3263 /* We used to only do this if Vx_no_window_manager was non-nil, but
3264 the ICCCM (section 4.1.6) says that the window's border pixmap
3265 and border pixel are window attributes which are "private to the
3266 client", so we can always change it to whatever we want. */
3267 block_input ();
3268 /* I recently started to get errors in this XSetWindowBorder, depending on
3269 the window-manager in use, tho something more is at play since I've been
3270 using that same window-manager binary for ever. Let's not crash just
3271 because of this (bug#9310). */
3272 x_catch_errors (FRAME_X_DISPLAY (f));
3273 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3274 f->output_data.x->border_pixel);
3275 x_uncatch_errors ();
3276 unblock_input ();
3277 x_update_cursor (f, true);
3278 x_set_frame_alpha (f);
3279 }
3280
3281 static void
3282 frame_unhighlight (struct frame *f)
3283 {
3284 /* We used to only do this if Vx_no_window_manager was non-nil, but
3285 the ICCCM (section 4.1.6) says that the window's border pixmap
3286 and border pixel are window attributes which are "private to the
3287 client", so we can always change it to whatever we want. */
3288 block_input ();
3289 /* Same as above for XSetWindowBorder (bug#9310). */
3290 x_catch_errors (FRAME_X_DISPLAY (f));
3291 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3292 f->output_data.x->border_tile);
3293 x_uncatch_errors ();
3294 unblock_input ();
3295 x_update_cursor (f, true);
3296 x_set_frame_alpha (f);
3297 }
3298
3299 /* The focus has changed. Update the frames as necessary to reflect
3300 the new situation. Note that we can't change the selected frame
3301 here, because the Lisp code we are interrupting might become confused.
3302 Each event gets marked with the frame in which it occurred, so the
3303 Lisp code can tell when the switch took place by examining the events. */
3304
3305 static void
3306 x_new_focus_frame (struct x_display_info *dpyinfo, struct frame *frame)
3307 {
3308 struct frame *old_focus = dpyinfo->x_focus_frame;
3309
3310 if (frame != dpyinfo->x_focus_frame)
3311 {
3312 /* Set this before calling other routines, so that they see
3313 the correct value of x_focus_frame. */
3314 dpyinfo->x_focus_frame = frame;
3315
3316 if (old_focus && old_focus->auto_lower)
3317 x_lower_frame (old_focus);
3318
3319 if (dpyinfo->x_focus_frame && dpyinfo->x_focus_frame->auto_raise)
3320 dpyinfo->x_pending_autoraise_frame = dpyinfo->x_focus_frame;
3321 else
3322 dpyinfo->x_pending_autoraise_frame = NULL;
3323 }
3324
3325 x_frame_rehighlight (dpyinfo);
3326 }
3327
3328 /* Handle FocusIn and FocusOut state changes for FRAME.
3329 If FRAME has focus and there exists more than one frame, puts
3330 a FOCUS_IN_EVENT into *BUFP. */
3331
3332 static void
3333 x_focus_changed (int type, int state, struct x_display_info *dpyinfo, struct frame *frame, struct input_event *bufp)
3334 {
3335 if (type == FocusIn)
3336 {
3337 if (dpyinfo->x_focus_event_frame != frame)
3338 {
3339 x_new_focus_frame (dpyinfo, frame);
3340 dpyinfo->x_focus_event_frame = frame;
3341
3342 /* Don't stop displaying the initial startup message
3343 for a switch-frame event we don't need. */
3344 /* When run as a daemon, Vterminal_frame is always NIL. */
3345 bufp->arg = (((NILP (Vterminal_frame)
3346 || ! FRAME_X_P (XFRAME (Vterminal_frame))
3347 || EQ (Fdaemonp (), Qt))
3348 && CONSP (Vframe_list)
3349 && !NILP (XCDR (Vframe_list)))
3350 ? Qt : Qnil);
3351 bufp->kind = FOCUS_IN_EVENT;
3352 XSETFRAME (bufp->frame_or_window, frame);
3353 }
3354
3355 frame->output_data.x->focus_state |= state;
3356
3357 #ifdef HAVE_X_I18N
3358 if (FRAME_XIC (frame))
3359 XSetICFocus (FRAME_XIC (frame));
3360 #endif
3361 }
3362 else if (type == FocusOut)
3363 {
3364 frame->output_data.x->focus_state &= ~state;
3365
3366 if (dpyinfo->x_focus_event_frame == frame)
3367 {
3368 dpyinfo->x_focus_event_frame = 0;
3369 x_new_focus_frame (dpyinfo, 0);
3370
3371 bufp->kind = FOCUS_OUT_EVENT;
3372 XSETFRAME (bufp->frame_or_window, frame);
3373 }
3374
3375 #ifdef HAVE_X_I18N
3376 if (FRAME_XIC (frame))
3377 XUnsetICFocus (FRAME_XIC (frame));
3378 #endif
3379 if (frame->pointer_invisible)
3380 XTtoggle_invisible_pointer (frame, false);
3381 }
3382 }
3383
3384 /* Return the Emacs frame-object corresponding to an X window.
3385 It could be the frame's main window or an icon window. */
3386
3387 static struct frame *
3388 x_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
3389 {
3390 Lisp_Object tail, frame;
3391 struct frame *f;
3392
3393 if (wdesc == None)
3394 return NULL;
3395
3396 FOR_EACH_FRAME (tail, frame)
3397 {
3398 f = XFRAME (frame);
3399 if (!FRAME_X_P (f) || FRAME_DISPLAY_INFO (f) != dpyinfo)
3400 continue;
3401 if (f->output_data.x->hourglass_window == wdesc)
3402 return f;
3403 #ifdef USE_X_TOOLKIT
3404 if ((f->output_data.x->edit_widget
3405 && XtWindow (f->output_data.x->edit_widget) == wdesc)
3406 /* A tooltip frame? */
3407 || (!f->output_data.x->edit_widget
3408 && FRAME_X_WINDOW (f) == wdesc)
3409 || f->output_data.x->icon_desc == wdesc)
3410 return f;
3411 #else /* not USE_X_TOOLKIT */
3412 #ifdef USE_GTK
3413 if (f->output_data.x->edit_widget)
3414 {
3415 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
3416 struct x_output *x = f->output_data.x;
3417 if (gwdesc != 0 && gwdesc == x->edit_widget)
3418 return f;
3419 }
3420 #endif /* USE_GTK */
3421 if (FRAME_X_WINDOW (f) == wdesc
3422 || f->output_data.x->icon_desc == wdesc)
3423 return f;
3424 #endif /* not USE_X_TOOLKIT */
3425 }
3426 return 0;
3427 }
3428
3429 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3430
3431 /* Like x_window_to_frame but also compares the window with the widget's
3432 windows. */
3433
3434 static struct frame *
3435 x_any_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
3436 {
3437 Lisp_Object tail, frame;
3438 struct frame *f, *found = NULL;
3439 struct x_output *x;
3440
3441 if (wdesc == None)
3442 return NULL;
3443
3444 FOR_EACH_FRAME (tail, frame)
3445 {
3446 if (found)
3447 break;
3448 f = XFRAME (frame);
3449 if (FRAME_X_P (f) && FRAME_DISPLAY_INFO (f) == dpyinfo)
3450 {
3451 /* This frame matches if the window is any of its widgets. */
3452 x = f->output_data.x;
3453 if (x->hourglass_window == wdesc)
3454 found = f;
3455 else if (x->widget)
3456 {
3457 #ifdef USE_GTK
3458 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
3459 if (gwdesc != 0
3460 && gtk_widget_get_toplevel (gwdesc) == x->widget)
3461 found = f;
3462 #else
3463 if (wdesc == XtWindow (x->widget)
3464 || wdesc == XtWindow (x->column_widget)
3465 || wdesc == XtWindow (x->edit_widget))
3466 found = f;
3467 /* Match if the window is this frame's menubar. */
3468 else if (lw_window_is_in_menubar (wdesc, x->menubar_widget))
3469 found = f;
3470 #endif
3471 }
3472 else if (FRAME_X_WINDOW (f) == wdesc)
3473 /* A tooltip frame. */
3474 found = f;
3475 }
3476 }
3477
3478 return found;
3479 }
3480
3481 /* Likewise, but consider only the menu bar widget. */
3482
3483 static struct frame *
3484 x_menubar_window_to_frame (struct x_display_info *dpyinfo,
3485 const XEvent *event)
3486 {
3487 Window wdesc = event->xany.window;
3488 Lisp_Object tail, frame;
3489 struct frame *f;
3490 struct x_output *x;
3491
3492 if (wdesc == None)
3493 return NULL;
3494
3495 FOR_EACH_FRAME (tail, frame)
3496 {
3497 f = XFRAME (frame);
3498 if (!FRAME_X_P (f) || FRAME_DISPLAY_INFO (f) != dpyinfo)
3499 continue;
3500 x = f->output_data.x;
3501 #ifdef USE_GTK
3502 if (x->menubar_widget && xg_event_is_for_menubar (f, event))
3503 return f;
3504 #else
3505 /* Match if the window is this frame's menubar. */
3506 if (x->menubar_widget
3507 && lw_window_is_in_menubar (wdesc, x->menubar_widget))
3508 return f;
3509 #endif
3510 }
3511 return 0;
3512 }
3513
3514 /* Return the frame whose principal (outermost) window is WDESC.
3515 If WDESC is some other (smaller) window, we return 0. */
3516
3517 struct frame *
3518 x_top_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
3519 {
3520 Lisp_Object tail, frame;
3521 struct frame *f;
3522 struct x_output *x;
3523
3524 if (wdesc == None)
3525 return NULL;
3526
3527 FOR_EACH_FRAME (tail, frame)
3528 {
3529 f = XFRAME (frame);
3530 if (!FRAME_X_P (f) || FRAME_DISPLAY_INFO (f) != dpyinfo)
3531 continue;
3532 x = f->output_data.x;
3533
3534 if (x->widget)
3535 {
3536 /* This frame matches if the window is its topmost widget. */
3537 #ifdef USE_GTK
3538 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
3539 if (gwdesc == x->widget)
3540 return f;
3541 #else
3542 if (wdesc == XtWindow (x->widget))
3543 return f;
3544 #endif
3545 }
3546 else if (FRAME_X_WINDOW (f) == wdesc)
3547 /* Tooltip frame. */
3548 return f;
3549 }
3550 return 0;
3551 }
3552
3553 #else /* !USE_X_TOOLKIT && !USE_GTK */
3554
3555 #define x_any_window_to_frame(d, i) x_window_to_frame (d, i)
3556 #define x_top_window_to_frame(d, i) x_window_to_frame (d, i)
3557
3558 #endif /* USE_X_TOOLKIT || USE_GTK */
3559
3560 /* The focus may have changed. Figure out if it is a real focus change,
3561 by checking both FocusIn/Out and Enter/LeaveNotify events.
3562
3563 Returns FOCUS_IN_EVENT event in *BUFP. */
3564
3565 static void
3566 x_detect_focus_change (struct x_display_info *dpyinfo, struct frame *frame,
3567 const XEvent *event, struct input_event *bufp)
3568 {
3569 if (!frame)
3570 return;
3571
3572 switch (event->type)
3573 {
3574 case EnterNotify:
3575 case LeaveNotify:
3576 {
3577 struct frame *focus_frame = dpyinfo->x_focus_event_frame;
3578 int focus_state
3579 = focus_frame ? focus_frame->output_data.x->focus_state : 0;
3580
3581 if (event->xcrossing.detail != NotifyInferior
3582 && event->xcrossing.focus
3583 && ! (focus_state & FOCUS_EXPLICIT))
3584 x_focus_changed ((event->type == EnterNotify ? FocusIn : FocusOut),
3585 FOCUS_IMPLICIT,
3586 dpyinfo, frame, bufp);
3587 }
3588 break;
3589
3590 case FocusIn:
3591 case FocusOut:
3592 x_focus_changed (event->type,
3593 (event->xfocus.detail == NotifyPointer ?
3594 FOCUS_IMPLICIT : FOCUS_EXPLICIT),
3595 dpyinfo, frame, bufp);
3596 break;
3597
3598 case ClientMessage:
3599 if (event->xclient.message_type == dpyinfo->Xatom_XEMBED)
3600 {
3601 enum xembed_message msg = event->xclient.data.l[1];
3602 x_focus_changed ((msg == XEMBED_FOCUS_IN ? FocusIn : FocusOut),
3603 FOCUS_EXPLICIT, dpyinfo, frame, bufp);
3604 }
3605 break;
3606 }
3607 }
3608
3609
3610 #if !defined USE_X_TOOLKIT && !defined USE_GTK
3611 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3612
3613 void
3614 x_mouse_leave (struct x_display_info *dpyinfo)
3615 {
3616 x_new_focus_frame (dpyinfo, dpyinfo->x_focus_event_frame);
3617 }
3618 #endif
3619
3620 /* The focus has changed, or we have redirected a frame's focus to
3621 another frame (this happens when a frame uses a surrogate
3622 mini-buffer frame). Shift the highlight as appropriate.
3623
3624 The FRAME argument doesn't necessarily have anything to do with which
3625 frame is being highlighted or un-highlighted; we only use it to find
3626 the appropriate X display info. */
3627
3628 static void
3629 XTframe_rehighlight (struct frame *frame)
3630 {
3631 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame));
3632 }
3633
3634 static void
3635 x_frame_rehighlight (struct x_display_info *dpyinfo)
3636 {
3637 struct frame *old_highlight = dpyinfo->x_highlight_frame;
3638
3639 if (dpyinfo->x_focus_frame)
3640 {
3641 dpyinfo->x_highlight_frame
3642 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame)))
3643 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame))
3644 : dpyinfo->x_focus_frame);
3645 if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
3646 {
3647 fset_focus_frame (dpyinfo->x_focus_frame, Qnil);
3648 dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
3649 }
3650 }
3651 else
3652 dpyinfo->x_highlight_frame = 0;
3653
3654 if (dpyinfo->x_highlight_frame != old_highlight)
3655 {
3656 if (old_highlight)
3657 frame_unhighlight (old_highlight);
3658 if (dpyinfo->x_highlight_frame)
3659 frame_highlight (dpyinfo->x_highlight_frame);
3660 }
3661 }
3662
3663
3664 \f
3665 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3666
3667 /* Initialize mode_switch_bit and modifier_meaning. */
3668 static void
3669 x_find_modifier_meanings (struct x_display_info *dpyinfo)
3670 {
3671 int min_code, max_code;
3672 KeySym *syms;
3673 int syms_per_code;
3674 XModifierKeymap *mods;
3675
3676 dpyinfo->meta_mod_mask = 0;
3677 dpyinfo->shift_lock_mask = 0;
3678 dpyinfo->alt_mod_mask = 0;
3679 dpyinfo->super_mod_mask = 0;
3680 dpyinfo->hyper_mod_mask = 0;
3681
3682 XDisplayKeycodes (dpyinfo->display, &min_code, &max_code);
3683
3684 syms = XGetKeyboardMapping (dpyinfo->display,
3685 min_code, max_code - min_code + 1,
3686 &syms_per_code);
3687 mods = XGetModifierMapping (dpyinfo->display);
3688
3689 /* Scan the modifier table to see which modifier bits the Meta and
3690 Alt keysyms are on. */
3691 {
3692 int row, col; /* The row and column in the modifier table. */
3693 bool found_alt_or_meta;
3694
3695 for (row = 3; row < 8; row++)
3696 {
3697 found_alt_or_meta = false;
3698 for (col = 0; col < mods->max_keypermod; col++)
3699 {
3700 KeyCode code = mods->modifiermap[(row * mods->max_keypermod) + col];
3701
3702 /* Zeroes are used for filler. Skip them. */
3703 if (code == 0)
3704 continue;
3705
3706 /* Are any of this keycode's keysyms a meta key? */
3707 {
3708 int code_col;
3709
3710 for (code_col = 0; code_col < syms_per_code; code_col++)
3711 {
3712 int sym = syms[((code - min_code) * syms_per_code) + code_col];
3713
3714 switch (sym)
3715 {
3716 case XK_Meta_L:
3717 case XK_Meta_R:
3718 found_alt_or_meta = true;
3719 dpyinfo->meta_mod_mask |= (1 << row);
3720 break;
3721
3722 case XK_Alt_L:
3723 case XK_Alt_R:
3724 found_alt_or_meta = true;
3725 dpyinfo->alt_mod_mask |= (1 << row);
3726 break;
3727
3728 case XK_Hyper_L:
3729 case XK_Hyper_R:
3730 if (!found_alt_or_meta)
3731 dpyinfo->hyper_mod_mask |= (1 << row);
3732 code_col = syms_per_code;
3733 col = mods->max_keypermod;
3734 break;
3735
3736 case XK_Super_L:
3737 case XK_Super_R:
3738 if (!found_alt_or_meta)
3739 dpyinfo->super_mod_mask |= (1 << row);
3740 code_col = syms_per_code;
3741 col = mods->max_keypermod;
3742 break;
3743
3744 case XK_Shift_Lock:
3745 /* Ignore this if it's not on the lock modifier. */
3746 if (!found_alt_or_meta && ((1 << row) == LockMask))
3747 dpyinfo->shift_lock_mask = LockMask;
3748 code_col = syms_per_code;
3749 col = mods->max_keypermod;
3750 break;
3751 }
3752 }
3753 }
3754 }
3755 }
3756 }
3757
3758 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3759 if (! dpyinfo->meta_mod_mask)
3760 {
3761 dpyinfo->meta_mod_mask = dpyinfo->alt_mod_mask;
3762 dpyinfo->alt_mod_mask = 0;
3763 }
3764
3765 /* If some keys are both alt and meta,
3766 make them just meta, not alt. */
3767 if (dpyinfo->alt_mod_mask & dpyinfo->meta_mod_mask)
3768 {
3769 dpyinfo->alt_mod_mask &= ~dpyinfo->meta_mod_mask;
3770 }
3771
3772 XFree (syms);
3773 XFreeModifiermap (mods);
3774 }
3775
3776 /* Convert between the modifier bits X uses and the modifier bits
3777 Emacs uses. */
3778
3779 int
3780 x_x_to_emacs_modifiers (struct x_display_info *dpyinfo, int state)
3781 {
3782 int mod_meta = meta_modifier;
3783 int mod_alt = alt_modifier;
3784 int mod_hyper = hyper_modifier;
3785 int mod_super = super_modifier;
3786 Lisp_Object tem;
3787
3788 tem = Fget (Vx_alt_keysym, Qmodifier_value);
3789 if (INTEGERP (tem)) mod_alt = XINT (tem) & INT_MAX;
3790 tem = Fget (Vx_meta_keysym, Qmodifier_value);
3791 if (INTEGERP (tem)) mod_meta = XINT (tem) & INT_MAX;
3792 tem = Fget (Vx_hyper_keysym, Qmodifier_value);
3793 if (INTEGERP (tem)) mod_hyper = XINT (tem) & INT_MAX;
3794 tem = Fget (Vx_super_keysym, Qmodifier_value);
3795 if (INTEGERP (tem)) mod_super = XINT (tem) & INT_MAX;
3796
3797 return ( ((state & (ShiftMask | dpyinfo->shift_lock_mask)) ? shift_modifier : 0)
3798 | ((state & ControlMask) ? ctrl_modifier : 0)
3799 | ((state & dpyinfo->meta_mod_mask) ? mod_meta : 0)
3800 | ((state & dpyinfo->alt_mod_mask) ? mod_alt : 0)
3801 | ((state & dpyinfo->super_mod_mask) ? mod_super : 0)
3802 | ((state & dpyinfo->hyper_mod_mask) ? mod_hyper : 0));
3803 }
3804
3805 static int
3806 x_emacs_to_x_modifiers (struct x_display_info *dpyinfo, EMACS_INT state)
3807 {
3808 EMACS_INT mod_meta = meta_modifier;
3809 EMACS_INT mod_alt = alt_modifier;
3810 EMACS_INT mod_hyper = hyper_modifier;
3811 EMACS_INT mod_super = super_modifier;
3812
3813 Lisp_Object tem;
3814
3815 tem = Fget (Vx_alt_keysym, Qmodifier_value);
3816 if (INTEGERP (tem)) mod_alt = XINT (tem);
3817 tem = Fget (Vx_meta_keysym, Qmodifier_value);
3818 if (INTEGERP (tem)) mod_meta = XINT (tem);
3819 tem = Fget (Vx_hyper_keysym, Qmodifier_value);
3820 if (INTEGERP (tem)) mod_hyper = XINT (tem);
3821 tem = Fget (Vx_super_keysym, Qmodifier_value);
3822 if (INTEGERP (tem)) mod_super = XINT (tem);
3823
3824
3825 return ( ((state & mod_alt) ? dpyinfo->alt_mod_mask : 0)
3826 | ((state & mod_super) ? dpyinfo->super_mod_mask : 0)
3827 | ((state & mod_hyper) ? dpyinfo->hyper_mod_mask : 0)
3828 | ((state & shift_modifier) ? ShiftMask : 0)
3829 | ((state & ctrl_modifier) ? ControlMask : 0)
3830 | ((state & mod_meta) ? dpyinfo->meta_mod_mask : 0));
3831 }
3832
3833 /* Convert a keysym to its name. */
3834
3835 char *
3836 x_get_keysym_name (int keysym)
3837 {
3838 char *value;
3839
3840 block_input ();
3841 value = XKeysymToString (keysym);
3842 unblock_input ();
3843
3844 return value;
3845 }
3846
3847 /* Mouse clicks and mouse movement. Rah.
3848
3849 Formerly, we used PointerMotionHintMask (in standard_event_mask)
3850 so that we would have to call XQueryPointer after each MotionNotify
3851 event to ask for another such event. However, this made mouse tracking
3852 slow, and there was a bug that made it eventually stop.
3853
3854 Simply asking for MotionNotify all the time seems to work better.
3855
3856 In order to avoid asking for motion events and then throwing most
3857 of them away or busy-polling the server for mouse positions, we ask
3858 the server for pointer motion hints. This means that we get only
3859 one event per group of mouse movements. "Groups" are delimited by
3860 other kinds of events (focus changes and button clicks, for
3861 example), or by XQueryPointer calls; when one of these happens, we
3862 get another MotionNotify event the next time the mouse moves. This
3863 is at least as efficient as getting motion events when mouse
3864 tracking is on, and I suspect only negligibly worse when tracking
3865 is off. */
3866
3867 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3868
3869 If the event is a button press, then note that we have grabbed
3870 the mouse. */
3871
3872 static Lisp_Object
3873 construct_mouse_click (struct input_event *result,
3874 const XButtonEvent *event,
3875 struct frame *f)
3876 {
3877 /* Make the event type NO_EVENT; we'll change that when we decide
3878 otherwise. */
3879 result->kind = MOUSE_CLICK_EVENT;
3880 result->code = event->button - Button1;
3881 result->timestamp = event->time;
3882 result->modifiers = (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f),
3883 event->state)
3884 | (event->type == ButtonRelease
3885 ? up_modifier
3886 : down_modifier));
3887
3888 XSETINT (result->x, event->x);
3889 XSETINT (result->y, event->y);
3890 XSETFRAME (result->frame_or_window, f);
3891 result->arg = Qnil;
3892 return Qnil;
3893 }
3894
3895 /* Function to report a mouse movement to the mainstream Emacs code.
3896 The input handler calls this.
3897
3898 We have received a mouse movement event, which is given in *event.
3899 If the mouse is over a different glyph than it was last time, tell
3900 the mainstream emacs code by setting mouse_moved. If not, ask for
3901 another motion event, so we can check again the next time it moves. */
3902
3903 static bool
3904 note_mouse_movement (struct frame *frame, const XMotionEvent *event)
3905 {
3906 XRectangle *r;
3907 struct x_display_info *dpyinfo;
3908
3909 if (!FRAME_X_OUTPUT (frame))
3910 return false;
3911
3912 dpyinfo = FRAME_DISPLAY_INFO (frame);
3913 dpyinfo->last_mouse_movement_time = event->time;
3914 dpyinfo->last_mouse_motion_frame = frame;
3915 dpyinfo->last_mouse_motion_x = event->x;
3916 dpyinfo->last_mouse_motion_y = event->y;
3917
3918 if (event->window != FRAME_X_WINDOW (frame))
3919 {
3920 frame->mouse_moved = true;
3921 dpyinfo->last_mouse_scroll_bar = NULL;
3922 note_mouse_highlight (frame, -1, -1);
3923 dpyinfo->last_mouse_glyph_frame = NULL;
3924 return true;
3925 }
3926
3927
3928 /* Has the mouse moved off the glyph it was on at the last sighting? */
3929 r = &dpyinfo->last_mouse_glyph;
3930 if (frame != dpyinfo->last_mouse_glyph_frame
3931 || event->x < r->x || event->x >= r->x + r->width
3932 || event->y < r->y || event->y >= r->y + r->height)
3933 {
3934 frame->mouse_moved = true;
3935 dpyinfo->last_mouse_scroll_bar = NULL;
3936 note_mouse_highlight (frame, event->x, event->y);
3937 /* Remember which glyph we're now on. */
3938 remember_mouse_glyph (frame, event->x, event->y, r);
3939 dpyinfo->last_mouse_glyph_frame = frame;
3940 return true;
3941 }
3942
3943 return false;
3944 }
3945
3946 /* Return the current position of the mouse.
3947 *FP should be a frame which indicates which display to ask about.
3948
3949 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3950 and *PART to the frame, window, and scroll bar part that the mouse
3951 is over. Set *X and *Y to the portion and whole of the mouse's
3952 position on the scroll bar.
3953
3954 If the mouse movement started elsewhere, set *FP to the frame the
3955 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3956 the mouse is over.
3957
3958 Set *TIMESTAMP to the server time-stamp for the time at which the mouse
3959 was at this position.
3960
3961 Don't store anything if we don't have a valid set of values to report.
3962
3963 This clears the mouse_moved flag, so we can wait for the next mouse
3964 movement. */
3965
3966 static void
3967 XTmouse_position (struct frame **fp, int insist, Lisp_Object *bar_window,
3968 enum scroll_bar_part *part, Lisp_Object *x, Lisp_Object *y,
3969 Time *timestamp)
3970 {
3971 struct frame *f1;
3972 struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (*fp);
3973
3974 block_input ();
3975
3976 if (dpyinfo->last_mouse_scroll_bar && insist == 0)
3977 {
3978 struct scroll_bar *bar = dpyinfo->last_mouse_scroll_bar;
3979
3980 if (bar->horizontal)
3981 x_horizontal_scroll_bar_report_motion (fp, bar_window, part, x, y, timestamp);
3982 else
3983 x_scroll_bar_report_motion (fp, bar_window, part, x, y, timestamp);
3984 }
3985 else
3986 {
3987 Window root;
3988 int root_x, root_y;
3989
3990 Window dummy_window;
3991 int dummy;
3992
3993 Lisp_Object frame, tail;
3994
3995 /* Clear the mouse-moved flag for every frame on this display. */
3996 FOR_EACH_FRAME (tail, frame)
3997 if (FRAME_X_P (XFRAME (frame))
3998 && FRAME_X_DISPLAY (XFRAME (frame)) == FRAME_X_DISPLAY (*fp))
3999 XFRAME (frame)->mouse_moved = false;
4000
4001 dpyinfo->last_mouse_scroll_bar = NULL;
4002
4003 /* Figure out which root window we're on. */
4004 XQueryPointer (FRAME_X_DISPLAY (*fp),
4005 DefaultRootWindow (FRAME_X_DISPLAY (*fp)),
4006
4007 /* The root window which contains the pointer. */
4008 &root,
4009
4010 /* Trash which we can't trust if the pointer is on
4011 a different screen. */
4012 &dummy_window,
4013
4014 /* The position on that root window. */
4015 &root_x, &root_y,
4016
4017 /* More trash we can't trust. */
4018 &dummy, &dummy,
4019
4020 /* Modifier keys and pointer buttons, about which
4021 we don't care. */
4022 (unsigned int *) &dummy);
4023
4024 /* Now we have a position on the root; find the innermost window
4025 containing the pointer. */
4026 {
4027 Window win, child;
4028 int win_x, win_y;
4029 int parent_x = 0, parent_y = 0;
4030
4031 win = root;
4032
4033 /* XTranslateCoordinates can get errors if the window
4034 structure is changing at the same time this function
4035 is running. So at least we must not crash from them. */
4036
4037 x_catch_errors (FRAME_X_DISPLAY (*fp));
4038
4039 if (x_mouse_grabbed (dpyinfo))
4040 {
4041 /* If mouse was grabbed on a frame, give coords for that frame
4042 even if the mouse is now outside it. */
4043 XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
4044
4045 /* From-window. */
4046 root,
4047
4048 /* To-window. */
4049 FRAME_X_WINDOW (dpyinfo->last_mouse_frame),
4050
4051 /* From-position, to-position. */
4052 root_x, root_y, &win_x, &win_y,
4053
4054 /* Child of win. */
4055 &child);
4056 f1 = dpyinfo->last_mouse_frame;
4057 }
4058 else
4059 {
4060 while (true)
4061 {
4062 XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
4063
4064 /* From-window, to-window. */
4065 root, win,
4066
4067 /* From-position, to-position. */
4068 root_x, root_y, &win_x, &win_y,
4069
4070 /* Child of win. */
4071 &child);
4072
4073 if (child == None || child == win)
4074 break;
4075 #ifdef USE_GTK
4076 /* We don't wan't to know the innermost window. We
4077 want the edit window. For non-Gtk+ the innermost
4078 window is the edit window. For Gtk+ it might not
4079 be. It might be the tool bar for example. */
4080 if (x_window_to_frame (dpyinfo, win))
4081 break;
4082 #endif
4083 win = child;
4084 parent_x = win_x;
4085 parent_y = win_y;
4086 }
4087
4088 /* Now we know that:
4089 win is the innermost window containing the pointer
4090 (XTC says it has no child containing the pointer),
4091 win_x and win_y are the pointer's position in it
4092 (XTC did this the last time through), and
4093 parent_x and parent_y are the pointer's position in win's parent.
4094 (They are what win_x and win_y were when win was child.
4095 If win is the root window, it has no parent, and
4096 parent_{x,y} are invalid, but that's okay, because we'll
4097 never use them in that case.) */
4098
4099 #ifdef USE_GTK
4100 /* We don't wan't to know the innermost window. We
4101 want the edit window. */
4102 f1 = x_window_to_frame (dpyinfo, win);
4103 #else
4104 /* Is win one of our frames? */
4105 f1 = x_any_window_to_frame (dpyinfo, win);
4106 #endif
4107
4108 #ifdef USE_X_TOOLKIT
4109 /* If we end up with the menu bar window, say it's not
4110 on the frame. */
4111 if (f1 != NULL
4112 && f1->output_data.x->menubar_widget
4113 && win == XtWindow (f1->output_data.x->menubar_widget))
4114 f1 = NULL;
4115 #endif /* USE_X_TOOLKIT */
4116 }
4117
4118 if (x_had_errors_p (FRAME_X_DISPLAY (*fp)))
4119 f1 = 0;
4120
4121 x_uncatch_errors ();
4122
4123 /* If not, is it one of our scroll bars? */
4124 if (! f1)
4125 {
4126 struct scroll_bar *bar;
4127
4128 bar = x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp), win, 2);
4129
4130 if (bar)
4131 {
4132 f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
4133 win_x = parent_x;
4134 win_y = parent_y;
4135 }
4136 }
4137
4138 if (f1 == 0 && insist > 0)
4139 f1 = SELECTED_FRAME ();
4140
4141 if (f1)
4142 {
4143 /* Ok, we found a frame. Store all the values.
4144 last_mouse_glyph is a rectangle used to reduce the
4145 generation of mouse events. To not miss any motion
4146 events, we must divide the frame into rectangles of the
4147 size of the smallest character that could be displayed
4148 on it, i.e. into the same rectangles that matrices on
4149 the frame are divided into. */
4150
4151 /* FIXME: what if F1 is not an X frame? */
4152 dpyinfo = FRAME_DISPLAY_INFO (f1);
4153 remember_mouse_glyph (f1, win_x, win_y, &dpyinfo->last_mouse_glyph);
4154 dpyinfo->last_mouse_glyph_frame = f1;
4155
4156 *bar_window = Qnil;
4157 *part = scroll_bar_above_handle;
4158 *fp = f1;
4159 XSETINT (*x, win_x);
4160 XSETINT (*y, win_y);
4161 *timestamp = dpyinfo->last_mouse_movement_time;
4162 }
4163 }
4164 }
4165
4166 unblock_input ();
4167 }
4168
4169
4170 \f
4171 /***********************************************************************
4172 Scroll bars
4173 ***********************************************************************/
4174
4175 /* Scroll bar support. */
4176
4177 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
4178 manages it.
4179 This can be called in GC, so we have to make sure to strip off mark
4180 bits. */
4181
4182 static struct scroll_bar *
4183 x_window_to_scroll_bar (Display *display, Window window_id, int type)
4184 {
4185 Lisp_Object tail, frame;
4186
4187 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
4188 window_id = (Window) xg_get_scroll_id_for_window (display, window_id);
4189 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
4190
4191 FOR_EACH_FRAME (tail, frame)
4192 {
4193 Lisp_Object bar, condemned;
4194
4195 if (! FRAME_X_P (XFRAME (frame)))
4196 continue;
4197
4198 /* Scan this frame's scroll bar list for a scroll bar with the
4199 right window ID. */
4200 condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
4201 for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
4202 /* This trick allows us to search both the ordinary and
4203 condemned scroll bar lists with one loop. */
4204 ! NILP (bar) || (bar = condemned,
4205 condemned = Qnil,
4206 ! NILP (bar));
4207 bar = XSCROLL_BAR (bar)->next)
4208 if (XSCROLL_BAR (bar)->x_window == window_id
4209 && FRAME_X_DISPLAY (XFRAME (frame)) == display
4210 && (type = 2
4211 || (type == 1 && XSCROLL_BAR (bar)->horizontal)
4212 || (type == 0 && !XSCROLL_BAR (bar)->horizontal)))
4213 return XSCROLL_BAR (bar);
4214 }
4215
4216 return NULL;
4217 }
4218
4219
4220 #if defined USE_LUCID
4221
4222 /* Return the Lucid menu bar WINDOW is part of. Return null
4223 if WINDOW is not part of a menu bar. */
4224
4225 static Widget
4226 x_window_to_menu_bar (Window window)
4227 {
4228 Lisp_Object tail, frame;
4229
4230 FOR_EACH_FRAME (tail, frame)
4231 if (FRAME_X_P (XFRAME (frame)))
4232 {
4233 Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
4234
4235 if (menu_bar && xlwmenu_window_p (menu_bar, window))
4236 return menu_bar;
4237 }
4238 return NULL;
4239 }
4240
4241 #endif /* USE_LUCID */
4242
4243 \f
4244 /************************************************************************
4245 Toolkit scroll bars
4246 ************************************************************************/
4247
4248 #ifdef USE_TOOLKIT_SCROLL_BARS
4249
4250 static void x_send_scroll_bar_event (Lisp_Object, enum scroll_bar_part,
4251 int, int, bool);
4252
4253 /* Lisp window being scrolled. Set when starting to interact with
4254 a toolkit scroll bar, reset to nil when ending the interaction. */
4255
4256 static Lisp_Object window_being_scrolled;
4257
4258 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4259 that movements of 1/20 of the screen size are mapped to up/down. */
4260
4261 #ifndef USE_GTK
4262 /* Id of action hook installed for scroll bars. */
4263
4264 static XtActionHookId action_hook_id;
4265 static XtActionHookId horizontal_action_hook_id;
4266
4267 static Boolean xaw3d_arrow_scroll;
4268
4269 /* Whether the drag scrolling maintains the mouse at the top of the
4270 thumb. If not, resizing the thumb needs to be done more carefully
4271 to avoid jerkiness. */
4272
4273 static Boolean xaw3d_pick_top;
4274
4275 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4276 bars are used.. The hook is responsible for detecting when
4277 the user ends an interaction with the scroll bar, and generates
4278 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4279
4280 static void
4281 xt_action_hook (Widget widget, XtPointer client_data, String action_name,
4282 XEvent *event, String *params, Cardinal *num_params)
4283 {
4284 bool scroll_bar_p;
4285 const char *end_action;
4286
4287 #ifdef USE_MOTIF
4288 scroll_bar_p = XmIsScrollBar (widget);
4289 end_action = "Release";
4290 #else /* !USE_MOTIF i.e. use Xaw */
4291 scroll_bar_p = XtIsSubclass (widget, scrollbarWidgetClass);
4292 end_action = "EndScroll";
4293 #endif /* USE_MOTIF */
4294
4295 if (scroll_bar_p
4296 && strcmp (action_name, end_action) == 0
4297 && WINDOWP (window_being_scrolled))
4298 {
4299 struct window *w;
4300 struct scroll_bar *bar;
4301
4302 x_send_scroll_bar_event (window_being_scrolled,
4303 scroll_bar_end_scroll, 0, 0, false);
4304 w = XWINDOW (window_being_scrolled);
4305 bar = XSCROLL_BAR (w->vertical_scroll_bar);
4306
4307 if (bar->dragging != -1)
4308 {
4309 bar->dragging = -1;
4310 /* The thumb size is incorrect while dragging: fix it. */
4311 set_vertical_scroll_bar (w);
4312 }
4313 window_being_scrolled = Qnil;
4314 #if defined (USE_LUCID)
4315 bar->last_seen_part = scroll_bar_nowhere;
4316 #endif
4317 /* Xt timeouts no longer needed. */
4318 toolkit_scroll_bar_interaction = false;
4319 }
4320 }
4321
4322
4323 static void
4324 xt_horizontal_action_hook (Widget widget, XtPointer client_data, String action_name,
4325 XEvent *event, String *params, Cardinal *num_params)
4326 {
4327 bool scroll_bar_p;
4328 const char *end_action;
4329
4330 #ifdef USE_MOTIF
4331 scroll_bar_p = XmIsScrollBar (widget);
4332 end_action = "Release";
4333 #else /* !USE_MOTIF i.e. use Xaw */
4334 scroll_bar_p = XtIsSubclass (widget, scrollbarWidgetClass);
4335 end_action = "EndScroll";
4336 #endif /* USE_MOTIF */
4337
4338 if (scroll_bar_p
4339 && strcmp (action_name, end_action) == 0
4340 && WINDOWP (window_being_scrolled))
4341 {
4342 struct window *w;
4343 struct scroll_bar *bar;
4344
4345 x_send_scroll_bar_event (window_being_scrolled,
4346 scroll_bar_end_scroll, 0, 0, true);
4347 w = XWINDOW (window_being_scrolled);
4348 bar = XSCROLL_BAR (w->horizontal_scroll_bar);
4349
4350 if (bar->dragging != -1)
4351 {
4352 bar->dragging = -1;
4353 /* The thumb size is incorrect while dragging: fix it. */
4354 set_horizontal_scroll_bar (w);
4355 }
4356 window_being_scrolled = Qnil;
4357 #if defined (USE_LUCID)
4358 bar->last_seen_part = scroll_bar_nowhere;
4359 #endif
4360 /* Xt timeouts no longer needed. */
4361 toolkit_scroll_bar_interaction = false;
4362 }
4363 }
4364 #endif /* not USE_GTK */
4365
4366 /* Send a client message with message type Xatom_Scrollbar for a
4367 scroll action to the frame of WINDOW. PART is a value identifying
4368 the part of the scroll bar that was clicked on. PORTION is the
4369 amount to scroll of a whole of WHOLE. */
4370
4371 static void
4372 x_send_scroll_bar_event (Lisp_Object window, enum scroll_bar_part part,
4373 int portion, int whole, bool horizontal)
4374 {
4375 XEvent event;
4376 XClientMessageEvent *ev = &event.xclient;
4377 struct window *w = XWINDOW (window);
4378 struct frame *f = XFRAME (w->frame);
4379 intptr_t iw = (intptr_t) w;
4380 enum { BITS_PER_INTPTR = CHAR_BIT * sizeof iw };
4381 verify (BITS_PER_INTPTR <= 64);
4382 int sign_shift = BITS_PER_INTPTR - 32;
4383
4384 block_input ();
4385
4386 /* Construct a ClientMessage event to send to the frame. */
4387 ev->type = ClientMessage;
4388 ev->message_type = (horizontal
4389 ? FRAME_DISPLAY_INFO (f)->Xatom_Horizontal_Scrollbar
4390 : FRAME_DISPLAY_INFO (f)->Xatom_Scrollbar);
4391 ev->display = FRAME_X_DISPLAY (f);
4392 ev->window = FRAME_X_WINDOW (f);
4393 ev->format = 32;
4394
4395 /* A 32-bit X client on a 64-bit X server can pass a window pointer
4396 as-is. A 64-bit client on a 32-bit X server is in trouble
4397 because a pointer does not fit and would be truncated while
4398 passing through the server. So use two slots and hope that X12
4399 will resolve such issues someday. */
4400 ev->data.l[0] = iw >> 31 >> 1;
4401 ev->data.l[1] = sign_shift <= 0 ? iw : iw << sign_shift >> sign_shift;
4402 ev->data.l[2] = part;
4403 ev->data.l[3] = portion;
4404 ev->data.l[4] = whole;
4405
4406 /* Make Xt timeouts work while the scroll bar is active. */
4407 #ifdef USE_X_TOOLKIT
4408 toolkit_scroll_bar_interaction = true;
4409 x_activate_timeout_atimer ();
4410 #endif
4411
4412 /* Setting the event mask to zero means that the message will
4413 be sent to the client that created the window, and if that
4414 window no longer exists, no event will be sent. */
4415 XSendEvent (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), False, 0, &event);
4416 unblock_input ();
4417 }
4418
4419
4420 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4421 in *IEVENT. */
4422
4423 static void
4424 x_scroll_bar_to_input_event (const XEvent *event,
4425 struct input_event *ievent)
4426 {
4427 const XClientMessageEvent *ev = &event->xclient;
4428 Lisp_Object window;
4429 struct window *w;
4430
4431 /* See the comment in the function above. */
4432 intptr_t iw0 = ev->data.l[0];
4433 intptr_t iw1 = ev->data.l[1];
4434 intptr_t iw = (iw0 << 31 << 1) + (iw1 & 0xffffffffu);
4435 w = (struct window *) iw;
4436
4437 XSETWINDOW (window, w);
4438
4439 ievent->kind = SCROLL_BAR_CLICK_EVENT;
4440 ievent->frame_or_window = window;
4441 ievent->arg = Qnil;
4442 #ifdef USE_GTK
4443 ievent->timestamp = CurrentTime;
4444 #else
4445 ievent->timestamp =
4446 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w->frame)));
4447 #endif
4448 ievent->code = 0;
4449 ievent->part = ev->data.l[2];
4450 ievent->x = make_number (ev->data.l[3]);
4451 ievent->y = make_number (ev->data.l[4]);
4452 ievent->modifiers = 0;
4453 }
4454
4455 /* Transform a horizontal scroll bar ClientMessage EVENT to an Emacs
4456 input event in *IEVENT. */
4457
4458 static void
4459 x_horizontal_scroll_bar_to_input_event (const XEvent *event,
4460 struct input_event *ievent)
4461 {
4462 const XClientMessageEvent *ev = &event->xclient;
4463 Lisp_Object window;
4464 struct window *w;
4465
4466 /* See the comment in the function above. */
4467 intptr_t iw0 = ev->data.l[0];
4468 intptr_t iw1 = ev->data.l[1];
4469 intptr_t iw = (iw0 << 31 << 1) + (iw1 & 0xffffffffu);
4470 w = (struct window *) iw;
4471
4472 XSETWINDOW (window, w);
4473
4474 ievent->kind = HORIZONTAL_SCROLL_BAR_CLICK_EVENT;
4475 ievent->frame_or_window = window;
4476 ievent->arg = Qnil;
4477 #ifdef USE_GTK
4478 ievent->timestamp = CurrentTime;
4479 #else
4480 ievent->timestamp =
4481 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w->frame)));
4482 #endif
4483 ievent->code = 0;
4484 ievent->part = ev->data.l[2];
4485 ievent->x = make_number (ev->data.l[3]);
4486 ievent->y = make_number (ev->data.l[4]);
4487 ievent->modifiers = 0;
4488 }
4489
4490
4491 #ifdef USE_MOTIF
4492
4493 /* Minimum and maximum values used for Motif scroll bars. */
4494
4495 #define XM_SB_MAX 10000000
4496
4497 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4498 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4499 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4500
4501 static void
4502 xm_scroll_callback (Widget widget, XtPointer client_data, XtPointer call_data)
4503 {
4504 struct scroll_bar *bar = client_data;
4505 XmScrollBarCallbackStruct *cs = call_data;
4506 enum scroll_bar_part part = scroll_bar_nowhere;
4507 bool horizontal = bar->horizontal;
4508 int whole = 0, portion = 0;
4509
4510 switch (cs->reason)
4511 {
4512 case XmCR_DECREMENT:
4513 bar->dragging = -1;
4514 part = horizontal ? scroll_bar_left_arrow : scroll_bar_up_arrow;
4515 break;
4516
4517 case XmCR_INCREMENT:
4518 bar->dragging = -1;
4519 part = horizontal ? scroll_bar_right_arrow : scroll_bar_down_arrow;
4520 break;
4521
4522 case XmCR_PAGE_DECREMENT:
4523 bar->dragging = -1;
4524 part = horizontal ? scroll_bar_before_handle : scroll_bar_above_handle;
4525 break;
4526
4527 case XmCR_PAGE_INCREMENT:
4528 bar->dragging = -1;
4529 part = horizontal ? scroll_bar_after_handle : scroll_bar_below_handle;
4530 break;
4531
4532 case XmCR_TO_TOP:
4533 bar->dragging = -1;
4534 part = horizontal ? scroll_bar_to_leftmost : scroll_bar_to_top;
4535 break;
4536
4537 case XmCR_TO_BOTTOM:
4538 bar->dragging = -1;
4539 part = horizontal ? scroll_bar_to_rightmost : scroll_bar_to_bottom;
4540 break;
4541
4542 case XmCR_DRAG:
4543 {
4544 int slider_size;
4545
4546 block_input ();
4547 XtVaGetValues (widget, XmNsliderSize, &slider_size, NULL);
4548 unblock_input ();
4549
4550 if (horizontal)
4551 {
4552 portion = bar->whole * ((float)cs->value / XM_SB_MAX);
4553 whole = bar->whole * ((float)(XM_SB_MAX - slider_size) / XM_SB_MAX);
4554 portion = min (portion, whole);
4555 part = scroll_bar_horizontal_handle;
4556 }
4557 else
4558 {
4559 whole = XM_SB_MAX - slider_size;
4560 portion = min (cs->value, whole);
4561 part = scroll_bar_handle;
4562 }
4563
4564 bar->dragging = cs->value;
4565 }
4566 break;
4567
4568 case XmCR_VALUE_CHANGED:
4569 break;
4570 };
4571
4572 if (part != scroll_bar_nowhere)
4573 {
4574 window_being_scrolled = bar->window;
4575 x_send_scroll_bar_event (bar->window, part, portion, whole,
4576 bar->horizontal);
4577 }
4578 }
4579
4580 #elif defined USE_GTK
4581
4582 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4583 bar widget. DATA is a pointer to the scroll_bar structure. */
4584
4585 static gboolean
4586 xg_scroll_callback (GtkRange *range,
4587 GtkScrollType scroll,
4588 gdouble value,
4589 gpointer user_data)
4590 {
4591 int whole = 0, portion = 0;
4592 struct scroll_bar *bar = user_data;
4593 enum scroll_bar_part part = scroll_bar_nowhere;
4594 GtkAdjustment *adj = GTK_ADJUSTMENT (gtk_range_get_adjustment (range));
4595 struct frame *f = g_object_get_data (G_OBJECT (range), XG_FRAME_DATA);
4596
4597 if (xg_ignore_gtk_scrollbar) return false;
4598
4599 switch (scroll)
4600 {
4601 case GTK_SCROLL_JUMP:
4602 /* Buttons 1 2 or 3 must be grabbed. */
4603 if (FRAME_DISPLAY_INFO (f)->grabbed != 0
4604 && FRAME_DISPLAY_INFO (f)->grabbed < (1 << 4))
4605 {
4606 if (bar->horizontal)
4607 {
4608 part = scroll_bar_horizontal_handle;
4609 whole = (int)(gtk_adjustment_get_upper (adj) -
4610 gtk_adjustment_get_page_size (adj));
4611 portion = min ((int)value, whole);
4612 bar->dragging = portion;
4613 }
4614 else
4615 {
4616 part = scroll_bar_handle;
4617 whole = gtk_adjustment_get_upper (adj) -
4618 gtk_adjustment_get_page_size (adj);
4619 portion = min ((int)value, whole);
4620 bar->dragging = portion;
4621 }
4622 }
4623 break;
4624 case GTK_SCROLL_STEP_BACKWARD:
4625 part = (bar->horizontal
4626 ? scroll_bar_left_arrow : scroll_bar_up_arrow);
4627 bar->dragging = -1;
4628 break;
4629 case GTK_SCROLL_STEP_FORWARD:
4630 part = (bar->horizontal
4631 ? scroll_bar_right_arrow : scroll_bar_down_arrow);
4632 bar->dragging = -1;
4633 break;
4634 case GTK_SCROLL_PAGE_BACKWARD:
4635 part = (bar->horizontal
4636 ? scroll_bar_before_handle : scroll_bar_above_handle);
4637 bar->dragging = -1;
4638 break;
4639 case GTK_SCROLL_PAGE_FORWARD:
4640 part = (bar->horizontal
4641 ? scroll_bar_after_handle : scroll_bar_below_handle);
4642 bar->dragging = -1;
4643 break;
4644 }
4645
4646 if (part != scroll_bar_nowhere)
4647 {
4648 window_being_scrolled = bar->window;
4649 x_send_scroll_bar_event (bar->window, part, portion, whole,
4650 bar->horizontal);
4651 }
4652
4653 return false;
4654 }
4655
4656 /* Callback for button release. Sets dragging to -1 when dragging is done. */
4657
4658 static gboolean
4659 xg_end_scroll_callback (GtkWidget *widget,
4660 GdkEventButton *event,
4661 gpointer user_data)
4662 {
4663 struct scroll_bar *bar = user_data;
4664 bar->dragging = -1;
4665 if (WINDOWP (window_being_scrolled))
4666 {
4667 x_send_scroll_bar_event (window_being_scrolled,
4668 scroll_bar_end_scroll, 0, 0, bar->horizontal);
4669 window_being_scrolled = Qnil;
4670 }
4671
4672 return false;
4673 }
4674
4675
4676 #else /* not USE_GTK and not USE_MOTIF */
4677
4678 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4679 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4680 scroll bar struct. CALL_DATA is a pointer to a float saying where
4681 the thumb is. */
4682
4683 static void
4684 xaw_jump_callback (Widget widget, XtPointer client_data, XtPointer call_data)
4685 {
4686 struct scroll_bar *bar = client_data;
4687 float *top_addr = call_data;
4688 float top = *top_addr;
4689 float shown;
4690 int whole, portion, height, width;
4691 enum scroll_bar_part part;
4692 bool horizontal = bar->horizontal;
4693
4694
4695 if (horizontal)
4696 {
4697 /* Get the size of the thumb, a value between 0 and 1. */
4698 block_input ();
4699 XtVaGetValues (widget, XtNshown, &shown, XtNwidth, &width, NULL);
4700 unblock_input ();
4701
4702 if (shown < 1)
4703 {
4704 whole = bar->whole - (shown * bar->whole);
4705 portion = min (top * bar->whole, whole);
4706 }
4707 else
4708 {
4709 whole = bar->whole;
4710 portion = 0;
4711 }
4712
4713 part = scroll_bar_horizontal_handle;
4714 }
4715 else
4716 {
4717 /* Get the size of the thumb, a value between 0 and 1. */
4718 block_input ();
4719 XtVaGetValues (widget, XtNshown, &shown, XtNheight, &height, NULL);
4720 unblock_input ();
4721
4722 whole = 10000000;
4723 portion = shown < 1 ? top * whole : 0;
4724
4725 if (shown < 1 && (eabs (top + shown - 1) < 1.0f / height))
4726 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4727 the bottom, so we force the scrolling whenever we see that we're
4728 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4729 we try to ensure that we always stay two pixels away from the
4730 bottom). */
4731 part = scroll_bar_down_arrow;
4732 else
4733 part = scroll_bar_handle;
4734 }
4735
4736 window_being_scrolled = bar->window;
4737 bar->dragging = portion;
4738 bar->last_seen_part = part;
4739 x_send_scroll_bar_event (bar->window, part, portion, whole, bar->horizontal);
4740 }
4741
4742
4743 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4744 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4745 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4746 the scroll bar. CALL_DATA is an integer specifying the action that
4747 has taken place. Its magnitude is in the range 0..height of the
4748 scroll bar. Negative values mean scroll towards buffer start.
4749 Values < height of scroll bar mean line-wise movement. */
4750
4751 static void
4752 xaw_scroll_callback (Widget widget, XtPointer client_data, XtPointer call_data)
4753 {
4754 struct scroll_bar *bar = client_data;