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