1 /* X Communication module for terminals which understand the X protocol.
3 Copyright (C) 1989, 1993-2016 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
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 (at
10 your option) any later version.
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.
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/>. */
20 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
21 /* Xt features made by Fred Pierresteguy. */
30 #include "blockinput.h"
32 /* This may include sys/types.h, and that somehow loses
33 if this is not done before the other system files. */
35 #include <X11/cursorfont.h>
37 /* If we have Xfixes extension, use it for pointer blanking. */
39 #include <X11/extensions/Xfixes.h>
42 /* Using Xft implies that XRender is available. */
44 #include <X11/extensions/Xrender.h>
47 /* Load sys/types.h if not already loaded.
48 In some systems loading it twice is suicidal. */
50 #include <sys/types.h>
53 #include <sys/ioctl.h>
60 #include "character.h"
62 #include "composite.h"
64 #include "dispextern.h"
67 #include "termhooks.h"
70 #include "emacs-icon.h"
76 #include "xsettings.h"
77 #include "sysselect.h"
81 #include <X11/Shell.h>
89 #include <X11/Xproto.h>
93 #if defined (USE_LUCID) || defined (USE_MOTIF)
94 #include "../lwlib/xlwmenu.h"
99 /* Include toolkit specific headers for the scroll bar widget. */
101 #ifdef USE_TOOLKIT_SCROLL_BARS
102 #if defined USE_MOTIF
103 #include <Xm/Xm.h> /* For LESSTIF_VERSION */
104 #include <Xm/ScrollBar.h>
105 #else /* !USE_MOTIF i.e. use Xaw */
108 #include <X11/Xaw3d/Simple.h>
109 #include <X11/Xaw3d/Scrollbar.h>
110 #include <X11/Xaw3d/ThreeD.h>
111 #else /* !HAVE_XAW3D */
112 #include <X11/Xaw/Simple.h>
113 #include <X11/Xaw/Scrollbar.h>
114 #endif /* !HAVE_XAW3D */
116 #define XtNpickTop "pickTop"
117 #endif /* !XtNpickTop */
118 #endif /* !USE_MOTIF */
119 #endif /* USE_TOOLKIT_SCROLL_BARS */
121 #endif /* USE_X_TOOLKIT */
125 #ifndef XtNinitialState
126 #define XtNinitialState "initialState"
130 #include "bitmaps/gray.xbm"
133 #include <X11/XKBlib.h>
136 /* Default to using XIM if available. */
140 bool use_xim
= false; /* configure --without-xim */
143 /* Non-zero means that a HELP_EVENT has been generated since Emacs
146 static bool any_help_event_p
;
148 /* This is a chain of structures for all the X displays currently in
151 struct x_display_info
*x_display_list
;
155 /* The application context for Xt use. */
156 XtAppContext Xt_app_con
;
157 static String Xt_default_resources
[] = {0};
159 /* Non-zero means user is interacting with a toolkit scroll bar. */
160 static bool toolkit_scroll_bar_interaction
;
162 #endif /* USE_X_TOOLKIT */
164 /* Non-zero timeout value means ignore next mouse click if it arrives
165 before that timeout elapses (i.e. as part of the same sequence of
166 events resulting from clicking on a frame to select it). */
168 static Time ignore_next_mouse_click_timeout
;
170 /* Used locally within XTread_socket. */
172 static int x_noop_count
;
175 /* The name of the Emacs icon file. */
176 static Lisp_Object xg_default_icon_file
;
179 /* Some functions take this as char *, not const char *. */
180 static char emacs_class
[] = EMACS_CLASS
;
184 XEMBED_MAPPED
= 1 << 0
189 XEMBED_EMBEDDED_NOTIFY
= 0,
190 XEMBED_WINDOW_ACTIVATE
= 1,
191 XEMBED_WINDOW_DEACTIVATE
= 2,
192 XEMBED_REQUEST_FOCUS
= 3,
194 XEMBED_FOCUS_OUT
= 5,
195 XEMBED_FOCUS_NEXT
= 6,
196 XEMBED_FOCUS_PREV
= 7,
198 XEMBED_MODALITY_ON
= 10,
199 XEMBED_MODALITY_OFF
= 11,
200 XEMBED_REGISTER_ACCELERATOR
= 12,
201 XEMBED_UNREGISTER_ACCELERATOR
= 13,
202 XEMBED_ACTIVATE_ACCELERATOR
= 14
205 static void x_free_cr_resources (struct frame
*);
206 static bool x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
207 static void x_raise_frame (struct frame
*);
208 static void x_lower_frame (struct frame
*);
209 static int x_io_error_quitter (Display
*);
210 static struct terminal
*x_create_terminal (struct x_display_info
*);
211 static void x_frame_rehighlight (struct x_display_info
*);
213 static void x_clip_to_row (struct window
*, struct glyph_row
*,
214 enum glyph_row_area
, GC
);
215 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
, int);
216 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
217 enum scroll_bar_part
*,
218 Lisp_Object
*, Lisp_Object
*,
220 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
221 enum scroll_bar_part
*,
222 Lisp_Object
*, Lisp_Object
*,
224 static bool x_handle_net_wm_state (struct frame
*, const XPropertyEvent
*);
225 static void x_check_fullscreen (struct frame
*);
226 static void x_check_expected_move (struct frame
*, int, int);
227 static void x_sync_with_move (struct frame
*, int, int, bool);
228 static int handle_one_xevent (struct x_display_info
*,
229 const XEvent
*, int *,
230 struct input_event
*);
231 #if ! (defined USE_X_TOOLKIT || defined USE_MOTIF)
232 static int x_dispatch_event (XEvent
*, Display
*);
234 static void x_wm_set_window_state (struct frame
*, int);
235 static void x_wm_set_icon_pixmap (struct frame
*, ptrdiff_t);
236 static void x_initialize (void);
238 static bool get_current_wm_state (struct frame
*, Window
, int *, bool *);
240 /* Flush display of frame F. */
243 x_flush (struct frame
*f
)
245 eassert (f
&& FRAME_X_P (f
));
246 /* Don't call XFlush when it is not safe to redisplay; the X
247 connection may be broken. */
248 if (!NILP (Vinhibit_redisplay
))
252 XFlush (FRAME_X_DISPLAY (f
));
257 /* Remove calls to XFlush by defining XFlush to an empty replacement.
258 Calls to XFlush should be unnecessary because the X output buffer
259 is flushed automatically as needed by calls to XPending,
260 XNextEvent, or XWindowEvent according to the XFlush man page.
261 XTread_socket calls XPending. Removing XFlush improves
264 #define XFlush(DISPLAY) (void) 0
267 /***********************************************************************
269 ***********************************************************************/
273 /* This is a function useful for recording debugging information about
274 the sequence of occurrences in this file. */
282 struct record event_record
[100];
284 int event_record_index
;
287 record_event (char *locus
, int type
)
289 if (event_record_index
== ARRAYELTS (event_record
))
290 event_record_index
= 0;
292 event_record
[event_record_index
].locus
= locus
;
293 event_record
[event_record_index
].type
= type
;
294 event_record_index
++;
301 #define FRAME_CR_CONTEXT(f) ((f)->output_data.x->cr_context)
302 #define FRAME_CR_SURFACE(f) ((f)->output_data.x->cr_surface)
304 static struct x_gc_ext_data
*
305 x_gc_get_ext_data (struct frame
*f
, GC gc
, int create_if_not_found_p
)
307 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
309 XExtData
**head
, *ext_data
;
312 head
= XEHeadOfExtensionList (object
);
313 ext_data
= XFindOnExtensionList (head
, dpyinfo
->ext_codes
->extension
);
314 if (ext_data
== NULL
)
316 if (!create_if_not_found_p
)
320 ext_data
= xzalloc (sizeof (*ext_data
));
321 ext_data
->number
= dpyinfo
->ext_codes
->extension
;
322 ext_data
->private_data
= xzalloc (sizeof (struct x_gc_ext_data
));
323 XAddToExtensionList (head
, ext_data
);
326 return (struct x_gc_ext_data
*) ext_data
->private_data
;
330 x_extension_initialize (struct x_display_info
*dpyinfo
)
332 XExtCodes
*ext_codes
= XAddExtension (dpyinfo
->display
);
334 dpyinfo
->ext_codes
= ext_codes
;
338 x_cr_destroy_surface (struct frame
*f
)
340 if (FRAME_CR_SURFACE (f
))
342 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
343 cairo_surface_destroy (FRAME_CR_SURFACE (f
));
344 FRAME_CR_SURFACE (f
) = 0;
345 if (cr
) cairo_destroy (cr
);
346 FRAME_CR_CONTEXT (f
) = NULL
;
351 x_begin_cr_clip (struct frame
*f
, GC gc
)
353 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
358 if (! FRAME_CR_SURFACE (f
))
360 cairo_surface_t
*surface
;
361 surface
= cairo_xlib_surface_create (FRAME_X_DISPLAY (f
),
363 FRAME_DISPLAY_INFO (f
)->visual
,
364 FRAME_PIXEL_WIDTH (f
),
365 FRAME_PIXEL_HEIGHT (f
));
366 cr
= cairo_create (surface
);
367 cairo_surface_destroy (surface
);
370 cr
= cairo_create (FRAME_CR_SURFACE (f
));
371 FRAME_CR_CONTEXT (f
) = cr
;
377 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 0);
379 if (gc_ext
&& gc_ext
->n_clip_rects
)
383 for (i
= 0; i
< gc_ext
->n_clip_rects
; i
++)
384 cairo_rectangle (cr
, gc_ext
->clip_rects
[i
].x
,
385 gc_ext
->clip_rects
[i
].y
,
386 gc_ext
->clip_rects
[i
].width
,
387 gc_ext
->clip_rects
[i
].height
);
396 x_end_cr_clip (struct frame
*f
)
398 cairo_restore (FRAME_CR_CONTEXT (f
));
402 x_set_cr_source_with_gc_foreground (struct frame
*f
, GC gc
)
407 XGetGCValues (FRAME_X_DISPLAY (f
), gc
, GCForeground
, &xgcv
);
408 color
.pixel
= xgcv
.foreground
;
409 x_query_color (f
, &color
);
410 cairo_set_source_rgb (FRAME_CR_CONTEXT (f
), color
.red
/ 65535.0,
411 color
.green
/ 65535.0, color
.blue
/ 65535.0);
415 x_set_cr_source_with_gc_background (struct frame
*f
, GC gc
)
420 XGetGCValues (FRAME_X_DISPLAY (f
), gc
, GCBackground
, &xgcv
);
421 color
.pixel
= xgcv
.background
;
422 x_query_color (f
, &color
);
423 cairo_set_source_rgb (FRAME_CR_CONTEXT (f
), color
.red
/ 65535.0,
424 color
.green
/ 65535.0, color
.blue
/ 65535.0);
427 /* Fringe bitmaps. */
429 static int max_fringe_bmp
= 0;
430 static cairo_pattern_t
**fringe_bmp
= 0;
433 x_cr_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
436 cairo_surface_t
*surface
;
438 cairo_pattern_t
*pattern
;
440 if (which
>= max_fringe_bmp
)
443 max_fringe_bmp
= which
+ 20;
444 fringe_bmp
= (cairo_pattern_t
**) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (cairo_pattern_t
*));
445 while (i
< max_fringe_bmp
)
451 surface
= cairo_image_surface_create (CAIRO_FORMAT_A1
, wd
, h
);
452 stride
= cairo_image_surface_get_stride (surface
);
453 data
= cairo_image_surface_get_data (surface
);
455 for (i
= 0; i
< h
; i
++)
457 *((unsigned short *) data
) = bits
[i
];
461 cairo_surface_mark_dirty (surface
);
462 pattern
= cairo_pattern_create_for_surface (surface
);
463 cairo_surface_destroy (surface
);
467 fringe_bmp
[which
] = pattern
;
471 x_cr_destroy_fringe_bitmap (int which
)
473 if (which
>= max_fringe_bmp
)
476 if (fringe_bmp
[which
])
479 cairo_pattern_destroy (fringe_bmp
[which
]);
482 fringe_bmp
[which
] = 0;
486 x_cr_draw_image (struct frame
*f
, GC gc
, cairo_pattern_t
*image
,
487 int src_x
, int src_y
, int width
, int height
,
488 int dest_x
, int dest_y
, bool overlay_p
)
491 cairo_matrix_t matrix
;
492 cairo_surface_t
*surface
;
493 cairo_format_t format
;
495 cr
= x_begin_cr_clip (f
, gc
);
497 cairo_rectangle (cr
, dest_x
, dest_y
, width
, height
);
500 x_set_cr_source_with_gc_background (f
, gc
);
501 cairo_rectangle (cr
, dest_x
, dest_y
, width
, height
);
502 cairo_fill_preserve (cr
);
505 cairo_matrix_init_translate (&matrix
, src_x
- dest_x
, src_y
- dest_y
);
506 cairo_pattern_set_matrix (image
, &matrix
);
507 cairo_pattern_get_surface (image
, &surface
);
508 format
= cairo_image_surface_get_format (surface
);
509 if (format
!= CAIRO_FORMAT_A8
&& format
!= CAIRO_FORMAT_A1
)
511 cairo_set_source (cr
, image
);
516 x_set_cr_source_with_gc_foreground (f
, gc
);
517 cairo_mask (cr
, image
);
523 x_cr_draw_frame (cairo_t
*cr
, struct frame
*f
)
527 width
= FRAME_PIXEL_WIDTH (f
);
528 height
= FRAME_PIXEL_HEIGHT (f
);
530 x_free_cr_resources (f
);
531 FRAME_CR_CONTEXT (f
) = cr
;
532 x_clear_area (f
, 0, 0, width
, height
);
533 expose_frame (f
, 0, 0, width
, height
);
534 FRAME_CR_CONTEXT (f
) = NULL
;
537 static cairo_status_t
538 x_cr_accumulate_data (void *closure
, const unsigned char *data
,
541 Lisp_Object
*acc
= (Lisp_Object
*) closure
;
543 *acc
= Fcons (make_unibyte_string ((char const *) data
, length
), *acc
);
545 return CAIRO_STATUS_SUCCESS
;
549 x_cr_destroy (Lisp_Object arg
)
551 cairo_t
*cr
= (cairo_t
*) XSAVE_POINTER (arg
, 0);
559 x_cr_export_frames (Lisp_Object frames
, cairo_surface_type_t surface_type
)
562 cairo_surface_t
*surface
;
565 void (*surface_set_size_func
) (cairo_surface_t
*, double, double) = NULL
;
566 Lisp_Object acc
= Qnil
;
567 int count
= SPECPDL_INDEX ();
569 specbind (Qredisplay_dont_pause
, Qt
);
570 redisplay_preserve_echo_area (31);
572 f
= XFRAME (XCAR (frames
));
573 frames
= XCDR (frames
);
574 width
= FRAME_PIXEL_WIDTH (f
);
575 height
= FRAME_PIXEL_HEIGHT (f
);
578 #ifdef CAIRO_HAS_PDF_SURFACE
579 if (surface_type
== CAIRO_SURFACE_TYPE_PDF
)
581 surface
= cairo_pdf_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
583 surface_set_size_func
= cairo_pdf_surface_set_size
;
587 #ifdef CAIRO_HAS_PNG_FUNCTIONS
588 if (surface_type
== CAIRO_SURFACE_TYPE_IMAGE
)
589 surface
= cairo_image_surface_create (CAIRO_FORMAT_RGB24
, width
, height
);
592 #ifdef CAIRO_HAS_PS_SURFACE
593 if (surface_type
== CAIRO_SURFACE_TYPE_PS
)
595 surface
= cairo_ps_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
597 surface_set_size_func
= cairo_ps_surface_set_size
;
601 #ifdef CAIRO_HAS_SVG_SURFACE
602 if (surface_type
== CAIRO_SURFACE_TYPE_SVG
)
603 surface
= cairo_svg_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
609 cr
= cairo_create (surface
);
610 cairo_surface_destroy (surface
);
611 record_unwind_protect (x_cr_destroy
, make_save_ptr (cr
));
615 x_free_cr_resources (f
);
616 FRAME_CR_CONTEXT (f
) = cr
;
617 x_clear_area (f
, 0, 0, width
, height
);
618 expose_frame (f
, 0, 0, width
, height
);
619 FRAME_CR_CONTEXT (f
) = NULL
;
624 cairo_surface_show_page (surface
);
625 f
= XFRAME (XCAR (frames
));
626 frames
= XCDR (frames
);
627 width
= FRAME_PIXEL_WIDTH (f
);
628 height
= FRAME_PIXEL_HEIGHT (f
);
629 if (surface_set_size_func
)
630 (*surface_set_size_func
) (surface
, width
, height
);
637 #ifdef CAIRO_HAS_PNG_FUNCTIONS
638 if (surface_type
== CAIRO_SURFACE_TYPE_IMAGE
)
640 cairo_surface_flush (surface
);
641 cairo_surface_write_to_png_stream (surface
, x_cr_accumulate_data
, &acc
);
646 unbind_to (count
, Qnil
);
648 return CALLN (Fapply
, intern ("concat"), Fnreverse (acc
));
651 #endif /* USE_CAIRO */
654 x_free_cr_resources (struct frame
*f
)
659 Lisp_Object rest
, frame
;
660 FOR_EACH_FRAME (rest
, frame
)
661 if (FRAME_X_P (XFRAME (frame
)))
662 x_free_cr_resources (XFRAME (frame
));
666 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
670 cairo_surface_t
*surface
= cairo_get_target (cr
);
672 if (cairo_surface_get_type (surface
) == CAIRO_SURFACE_TYPE_XLIB
)
675 FRAME_CR_CONTEXT (f
) = NULL
;
683 x_set_clip_rectangles (struct frame
*f
, GC gc
, XRectangle
*rectangles
, int n
)
685 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, rectangles
, n
, Unsorted
);
687 eassert (n
>= 0 && n
<= MAX_CLIP_RECTS
);
690 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 1);
692 gc_ext
->n_clip_rects
= n
;
693 memcpy (gc_ext
->clip_rects
, rectangles
, sizeof (XRectangle
) * n
);
699 x_reset_clip_rectangles (struct frame
*f
, GC gc
)
701 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
704 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 0);
707 gc_ext
->n_clip_rects
= 0;
713 x_fill_rectangle (struct frame
*f
, GC gc
, int x
, int y
, int width
, int height
)
718 cr
= x_begin_cr_clip (f
, gc
);
719 x_set_cr_source_with_gc_foreground (f
, gc
);
720 cairo_rectangle (cr
, x
, y
, width
, height
);
724 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
725 gc
, x
, y
, width
, height
);
730 x_draw_rectangle (struct frame
*f
, GC gc
, int x
, int y
, int width
, int height
)
735 cr
= x_begin_cr_clip (f
, gc
);
736 x_set_cr_source_with_gc_foreground (f
, gc
);
737 cairo_rectangle (cr
, x
+ 0.5, y
+ 0.5, width
, height
);
738 cairo_set_line_width (cr
, 1);
742 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
743 gc
, x
, y
, width
, height
);
748 x_clear_window (struct frame
*f
)
753 cr
= x_begin_cr_clip (f
, NULL
);
754 x_set_cr_source_with_gc_background (f
, f
->output_data
.x
->normal_gc
);
758 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
764 x_fill_trapezoid_for_relief (struct frame
*f
, GC gc
, int x
, int y
,
765 int width
, int height
, int top_p
)
769 cr
= x_begin_cr_clip (f
, gc
);
770 x_set_cr_source_with_gc_foreground (f
, gc
);
771 cairo_move_to (cr
, top_p
? x
: x
+ height
, y
);
772 cairo_line_to (cr
, x
, y
+ height
);
773 cairo_line_to (cr
, top_p
? x
+ width
- height
: x
+ width
, y
+ height
);
774 cairo_line_to (cr
, x
+ width
, y
);
781 CORNER_BOTTOM_RIGHT
, /* 0 -> pi/2 */
782 CORNER_BOTTOM_LEFT
, /* pi/2 -> pi */
783 CORNER_TOP_LEFT
, /* pi -> 3pi/2 */
784 CORNER_TOP_RIGHT
, /* 3pi/2 -> 2pi */
789 x_erase_corners_for_relief (struct frame
*f
, GC gc
, int x
, int y
,
790 int width
, int height
,
791 double radius
, double margin
, int corners
)
796 cr
= x_begin_cr_clip (f
, gc
);
797 x_set_cr_source_with_gc_background (f
, gc
);
798 for (i
= 0; i
< CORNER_LAST
; i
++)
799 if (corners
& (1 << i
))
801 double xm
, ym
, xc
, yc
;
803 if (i
== CORNER_TOP_LEFT
|| i
== CORNER_BOTTOM_LEFT
)
804 xm
= x
- margin
, xc
= xm
+ radius
;
806 xm
= x
+ width
+ margin
, xc
= xm
- radius
;
807 if (i
== CORNER_TOP_LEFT
|| i
== CORNER_TOP_RIGHT
)
808 ym
= y
- margin
, yc
= ym
+ radius
;
810 ym
= y
+ height
+ margin
, yc
= ym
- radius
;
812 cairo_move_to (cr
, xm
, ym
);
813 cairo_arc (cr
, xc
, yc
, radius
, i
* M_PI_2
, (i
+ 1) * M_PI_2
);
816 cairo_rectangle (cr
, x
, y
, width
, height
);
822 x_draw_horizontal_wave (struct frame
*f
, GC gc
, int x
, int y
,
823 int width
, int height
, int wave_length
)
826 double dx
= wave_length
, dy
= height
- 1;
829 cr
= x_begin_cr_clip (f
, gc
);
830 x_set_cr_source_with_gc_foreground (f
, gc
);
831 cairo_rectangle (cr
, x
, y
, width
, height
);
836 xoffset
= x
% (wave_length
* 2);
838 xoffset
= wave_length
* 2;
841 xoffset
= x
% (wave_length
* 2) + wave_length
* 2;
842 n
= (width
+ xoffset
) / wave_length
+ 1;
843 if (xoffset
> wave_length
)
845 xoffset
-= wave_length
;
851 cairo_move_to (cr
, x
- xoffset
+ 0.5, y
+ 0.5);
854 cairo_rel_line_to (cr
, dx
, dy
);
857 cairo_set_line_width (cr
, 1);
864 /* Return the struct x_display_info corresponding to DPY. */
866 struct x_display_info
*
867 x_display_info_for_display (Display
*dpy
)
869 struct x_display_info
*dpyinfo
;
871 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
872 if (dpyinfo
->display
== dpy
)
879 x_find_topmost_parent (struct frame
*f
)
881 struct x_output
*x
= f
->output_data
.x
;
882 Window win
= None
, wi
= x
->parent_desc
;
883 Display
*dpy
= FRAME_X_DISPLAY (f
);
885 while (wi
!= FRAME_DISPLAY_INFO (f
)->root_window
)
889 unsigned int nchildren
;
892 if (XQueryTree (dpy
, win
, &root
, &wi
, &children
, &nchildren
))
901 #define OPAQUE 0xffffffff
904 x_set_frame_alpha (struct frame
*f
)
906 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
907 Display
*dpy
= FRAME_X_DISPLAY (f
);
908 Window win
= FRAME_OUTER_WINDOW (f
);
910 double alpha_min
= 1.0;
914 if (dpyinfo
->x_highlight_frame
== f
)
919 if (FLOATP (Vframe_alpha_lower_limit
))
920 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
921 else if (INTEGERP (Vframe_alpha_lower_limit
))
922 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
926 else if (alpha
> 1.0)
928 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
931 opac
= alpha
* OPAQUE
;
933 x_catch_errors (dpy
);
935 /* If there is a parent from the window manager, put the property there
936 also, to work around broken window managers that fail to do that.
937 Do this unconditionally as this function is called on reparent when
938 alpha has not changed on the frame. */
940 parent
= x_find_topmost_parent (f
);
942 XChangeProperty (dpy
, parent
, dpyinfo
->Xatom_net_wm_window_opacity
,
943 XA_CARDINAL
, 32, PropModeReplace
,
944 (unsigned char *) &opac
, 1);
946 /* return unless necessary */
951 unsigned long n
, left
;
953 rc
= XGetWindowProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
954 0, 1, False
, XA_CARDINAL
,
955 &actual
, &format
, &n
, &left
,
958 if (rc
== Success
&& actual
!= None
)
960 unsigned long value
= *(unsigned long *)data
;
970 XChangeProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
971 XA_CARDINAL
, 32, PropModeReplace
,
972 (unsigned char *) &opac
, 1);
976 /***********************************************************************
977 Starting and ending an update
978 ***********************************************************************/
980 /* Start an update of frame F. This function is installed as a hook
981 for update_begin, i.e. it is called when update_begin is called.
982 This function is called prior to calls to x_update_window_begin for
983 each window being updated. Currently, there is nothing to do here
984 because all interesting stuff is done on a window basis. */
987 x_update_begin (struct frame
*f
)
990 if (FRAME_TOOLTIP_P (f
) && ! FRAME_VISIBLE_P (f
))
993 if (! FRAME_CR_SURFACE (f
))
997 if (FRAME_GTK_WIDGET (f
))
999 GdkWindow
*w
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
1000 width
= gdk_window_get_width (w
);
1001 height
= gdk_window_get_height (w
);
1006 width
= FRAME_PIXEL_WIDTH (f
);
1007 height
= FRAME_PIXEL_HEIGHT (f
);
1008 if (! FRAME_EXTERNAL_TOOL_BAR (f
))
1009 height
+= FRAME_TOOL_BAR_HEIGHT (f
);
1010 if (! FRAME_EXTERNAL_MENU_BAR (f
))
1011 height
+= FRAME_MENU_BAR_HEIGHT (f
);
1014 if (width
> 0 && height
> 0)
1017 FRAME_CR_SURFACE (f
) = cairo_image_surface_create
1018 (CAIRO_FORMAT_ARGB32
, width
, height
);
1022 #endif /* USE_CAIRO */
1025 /* Start update of window W. */
1028 x_update_window_begin (struct window
*w
)
1030 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1031 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
1033 w
->output_cursor
= w
->cursor
;
1037 if (f
== hlinfo
->mouse_face_mouse_frame
)
1039 /* Don't do highlighting for mouse motion during the update. */
1040 hlinfo
->mouse_face_defer
= true;
1042 /* If F needs to be redrawn, simply forget about any prior mouse
1044 if (FRAME_GARBAGED_P (f
))
1045 hlinfo
->mouse_face_window
= Qnil
;
1052 /* Draw a vertical window border from (x,y0) to (x,y1) */
1055 x_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
1057 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1060 face
= FACE_FROM_ID_OR_NULL (f
, VERTICAL_BORDER_FACE_ID
);
1062 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
1066 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
, x
, y0
, 1, y1
- y0
);
1068 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1069 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
1073 /* Draw a window divider from (x0,y0) to (x1,y1) */
1076 x_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
1078 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1079 struct face
*face
= FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_FACE_ID
);
1080 struct face
*face_first
1081 = FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
1082 struct face
*face_last
1083 = FACE_FROM_ID_OR_NULL (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
1084 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
1085 unsigned long color_first
= (face_first
1086 ? face_first
->foreground
1087 : FRAME_FOREGROUND_PIXEL (f
));
1088 unsigned long color_last
= (face_last
1089 ? face_last
->foreground
1090 : FRAME_FOREGROUND_PIXEL (f
));
1091 Display
*display
= FRAME_X_DISPLAY (f
);
1093 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
1096 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_first
);
1097 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1098 x0
, y0
, 1, y1
- y0
);
1099 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
1100 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1101 x0
+ 1, y0
, x1
- x0
- 2, y1
- y0
);
1102 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_last
);
1103 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1104 x1
- 1, y0
, 1, y1
- y0
);
1106 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
1109 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_first
);
1110 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1111 x0
, y0
, x1
- x0
, 1);
1112 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
1113 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1114 x0
, y0
+ 1, x1
- x0
, y1
- y0
- 2);
1115 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_last
);
1116 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1117 x0
, y1
- 1, x1
- x0
, 1);
1121 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
1122 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1123 x0
, y0
, x1
- x0
, y1
- y0
);
1127 /* End update of window W.
1129 Draw vertical borders between horizontally adjacent windows, and
1130 display W's cursor if CURSOR_ON_P is non-zero.
1132 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
1133 glyphs in mouse-face were overwritten. In that case we have to
1134 make sure that the mouse-highlight is properly redrawn.
1136 W may be a menu bar pseudo-window in case we don't have X toolkit
1137 support. Such windows don't have a cursor, so don't display it
1141 x_update_window_end (struct window
*w
, bool cursor_on_p
,
1142 bool mouse_face_overwritten_p
)
1144 if (!w
->pseudo_window_p
)
1149 display_and_set_cursor (w
, true,
1150 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
1151 w
->output_cursor
.x
, w
->output_cursor
.y
);
1153 if (draw_window_fringes (w
, true))
1155 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
1156 x_draw_right_divider (w
);
1158 x_draw_vertical_border (w
);
1164 /* If a row with mouse-face was overwritten, arrange for
1165 XTframe_up_to_date to redisplay the mouse highlight. */
1166 if (mouse_face_overwritten_p
)
1168 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
1170 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
1171 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
1172 hlinfo
->mouse_face_window
= Qnil
;
1177 /* End update of frame F. This function is installed as a hook in
1181 x_update_end (struct frame
*f
)
1183 /* Mouse highlight may be displayed again. */
1184 MOUSE_HL_INFO (f
)->mouse_face_defer
= false;
1187 if (FRAME_CR_SURFACE (f
))
1191 #if defined (USE_GTK) && defined (HAVE_GTK3)
1192 if (FRAME_GTK_WIDGET (f
))
1194 GdkWindow
*w
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
1195 cr
= gdk_cairo_create (w
);
1200 cairo_surface_t
*surface
;
1201 int width
= FRAME_PIXEL_WIDTH (f
);
1202 int height
= FRAME_PIXEL_HEIGHT (f
);
1203 if (! FRAME_EXTERNAL_TOOL_BAR (f
))
1204 height
+= FRAME_TOOL_BAR_HEIGHT (f
);
1205 if (! FRAME_EXTERNAL_MENU_BAR (f
))
1206 height
+= FRAME_MENU_BAR_HEIGHT (f
);
1207 surface
= cairo_xlib_surface_create (FRAME_X_DISPLAY (f
),
1209 FRAME_DISPLAY_INFO (f
)->visual
,
1212 cr
= cairo_create (surface
);
1213 cairo_surface_destroy (surface
);
1216 cairo_set_source_surface (cr
, FRAME_CR_SURFACE (f
), 0, 0);
1221 #endif /* USE_CAIRO */
1225 XFlush (FRAME_X_DISPLAY (f
));
1231 /* This function is called from various places in xdisp.c
1232 whenever a complete update has been performed. */
1235 XTframe_up_to_date (struct frame
*f
)
1238 FRAME_MOUSE_UPDATE (f
);
1242 /* Clear under internal border if any (GTK has its own version). */
1245 x_clear_under_internal_border (struct frame
*f
)
1247 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
1249 int border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1250 int width
= FRAME_PIXEL_WIDTH (f
);
1251 int height
= FRAME_PIXEL_HEIGHT (f
);
1252 int margin
= FRAME_TOP_MARGIN_HEIGHT (f
);
1255 x_clear_area (f
, 0, 0, border
, height
);
1256 x_clear_area (f
, 0, margin
, width
, border
);
1257 x_clear_area (f
, width
- border
, 0, border
, height
);
1258 x_clear_area (f
, 0, height
- border
, width
, border
);
1264 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
1265 arrow bitmaps, or clear the fringes if no bitmaps are required
1266 before DESIRED_ROW is made current. This function is called from
1267 update_window_line only if it is known that there are differences
1268 between bitmaps to be drawn between current row and DESIRED_ROW. */
1271 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
1275 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
1276 desired_row
->redraw_fringe_bitmaps_p
= true;
1278 #ifdef USE_X_TOOLKIT
1279 /* When a window has disappeared, make sure that no rest of
1280 full-width rows stays visible in the internal border. Could
1281 check here if updated window is the leftmost/rightmost window,
1282 but I guess it's not worth doing since vertically split windows
1283 are almost never used, internal border is rarely set, and the
1284 overhead is very small. */
1289 if (windows_or_buffers_changed
1290 && desired_row
->full_width_p
1291 && (f
= XFRAME (w
->frame
),
1292 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
1294 && (height
= desired_row
->visible_height
,
1297 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
1300 x_clear_area (f
, 0, y
, width
, height
);
1301 x_clear_area (f
, FRAME_PIXEL_WIDTH (f
) - width
, y
, width
, height
);
1309 x_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, struct draw_fringe_bitmap_params
*p
)
1311 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1312 Display
*display
= FRAME_X_DISPLAY (f
);
1313 GC gc
= f
->output_data
.x
->normal_gc
;
1314 struct face
*face
= p
->face
;
1316 /* Must clip because of partially visible lines. */
1317 x_clip_to_row (w
, row
, ANY_AREA
, gc
);
1319 if (p
->bx
>= 0 && !p
->overlay_p
)
1321 /* In case the same realized face is used for fringes and
1322 for something displayed in the text (e.g. face `region' on
1323 mono-displays, the fill style may have been changed to
1324 FillSolid in x_draw_glyph_string_background. */
1326 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
1328 XSetForeground (display
, face
->gc
, face
->background
);
1330 x_fill_rectangle (f
, face
->gc
, p
->bx
, p
->by
, p
->nx
, p
->ny
);
1333 XSetForeground (display
, face
->gc
, face
->foreground
);
1337 if (p
->which
&& p
->which
< max_fringe_bmp
)
1341 XGetGCValues (display
, gc
, GCForeground
| GCBackground
, &gcv
);
1342 XSetForeground (display
, gc
, (p
->cursor_p
1343 ? (p
->overlay_p
? face
->background
1344 : f
->output_data
.x
->cursor_pixel
)
1345 : face
->foreground
));
1346 XSetBackground (display
, gc
, face
->background
);
1347 x_cr_draw_image (f
, gc
, fringe_bmp
[p
->which
], 0, p
->dh
,
1348 p
->wd
, p
->h
, p
->x
, p
->y
, p
->overlay_p
);
1349 XSetForeground (display
, gc
, gcv
.foreground
);
1350 XSetBackground (display
, gc
, gcv
.background
);
1352 #else /* not USE_CAIRO */
1355 Window window
= FRAME_X_WINDOW (f
);
1357 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
1358 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
1362 bits
= (char *) (p
->bits
+ p
->dh
);
1364 bits
= (char *) p
->bits
+ p
->dh
;
1366 /* Draw the bitmap. I believe these small pixmaps can be cached
1368 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
1370 ? (p
->overlay_p
? face
->background
1371 : f
->output_data
.x
->cursor_pixel
)
1372 : face
->foreground
),
1373 face
->background
, depth
);
1377 clipmask
= XCreatePixmapFromBitmapData (display
,
1378 FRAME_DISPLAY_INFO (f
)->root_window
,
1381 gcv
.clip_mask
= clipmask
;
1382 gcv
.clip_x_origin
= p
->x
;
1383 gcv
.clip_y_origin
= p
->y
;
1384 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
1387 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
1388 p
->wd
, p
->h
, p
->x
, p
->y
);
1389 XFreePixmap (display
, pixmap
);
1393 gcv
.clip_mask
= (Pixmap
) 0;
1394 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
1395 XFreePixmap (display
, clipmask
);
1398 #endif /* not USE_CAIRO */
1400 x_reset_clip_rectangles (f
, gc
);
1403 /***********************************************************************
1405 ***********************************************************************/
1409 static void x_set_glyph_string_clipping (struct glyph_string
*);
1410 static void x_set_glyph_string_gc (struct glyph_string
*);
1411 static void x_draw_glyph_string_foreground (struct glyph_string
*);
1412 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
1413 static void x_draw_glyph_string_box (struct glyph_string
*);
1414 static void x_draw_glyph_string (struct glyph_string
*);
1415 static _Noreturn
void x_delete_glyphs (struct frame
*, int);
1416 static void x_compute_glyph_string_overhangs (struct glyph_string
*);
1417 static void x_set_cursor_gc (struct glyph_string
*);
1418 static void x_set_mode_line_face_gc (struct glyph_string
*);
1419 static void x_set_mouse_face_gc (struct glyph_string
*);
1420 static bool x_alloc_lighter_color (struct frame
*, Display
*, Colormap
,
1421 unsigned long *, double, int);
1422 static void x_setup_relief_color (struct frame
*, struct relief
*,
1423 double, int, unsigned long);
1424 static void x_setup_relief_colors (struct glyph_string
*);
1425 static void x_draw_image_glyph_string (struct glyph_string
*);
1426 static void x_draw_image_relief (struct glyph_string
*);
1427 static void x_draw_image_foreground (struct glyph_string
*);
1428 static void x_draw_image_foreground_1 (struct glyph_string
*, Pixmap
);
1429 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
1431 static void x_draw_relief_rect (struct frame
*, int, int, int, int,
1432 int, bool, bool, bool, bool, bool,
1434 static void x_draw_box_rect (struct glyph_string
*, int, int, int, int,
1435 int, bool, bool, XRectangle
*);
1436 static void x_scroll_bar_clear (struct frame
*);
1439 static void x_check_font (struct frame
*, struct font
*);
1443 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1447 x_set_cursor_gc (struct glyph_string
*s
)
1449 if (s
->font
== FRAME_FONT (s
->f
)
1450 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1451 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1453 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
1456 /* Cursor on non-default face: must merge. */
1460 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
1461 xgcv
.foreground
= s
->face
->background
;
1463 /* If the glyph would be invisible, try a different foreground. */
1464 if (xgcv
.foreground
== xgcv
.background
)
1465 xgcv
.foreground
= s
->face
->foreground
;
1466 if (xgcv
.foreground
== xgcv
.background
)
1467 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
1468 if (xgcv
.foreground
== xgcv
.background
)
1469 xgcv
.foreground
= s
->face
->foreground
;
1471 /* Make sure the cursor is distinct from text in this face. */
1472 if (xgcv
.background
== s
->face
->background
1473 && xgcv
.foreground
== s
->face
->foreground
)
1475 xgcv
.background
= s
->face
->foreground
;
1476 xgcv
.foreground
= s
->face
->background
;
1479 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1480 xgcv
.graphics_exposures
= False
;
1481 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
1483 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1484 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1487 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1488 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1490 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1495 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1498 x_set_mouse_face_gc (struct glyph_string
*s
)
1503 /* What face has to be used last for the mouse face? */
1504 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
1505 face
= FACE_FROM_ID_OR_NULL (s
->f
, face_id
);
1507 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1509 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1510 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1512 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1513 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1514 prepare_face_for_display (s
->f
, s
->face
);
1516 if (s
->font
== s
->face
->font
)
1517 s
->gc
= s
->face
->gc
;
1520 /* Otherwise construct scratch_cursor_gc with values from FACE
1525 xgcv
.background
= s
->face
->background
;
1526 xgcv
.foreground
= s
->face
->foreground
;
1527 xgcv
.graphics_exposures
= False
;
1528 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
1530 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1531 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1534 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1535 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1537 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1540 eassert (s
->gc
!= 0);
1544 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1545 Faces to use in the mode line have already been computed when the
1546 matrix was built, so there isn't much to do, here. */
1549 x_set_mode_line_face_gc (struct glyph_string
*s
)
1551 s
->gc
= s
->face
->gc
;
1555 /* Set S->gc of glyph string S for drawing that glyph string. Set
1556 S->stippled_p to a non-zero value if the face of S has a stipple
1560 x_set_glyph_string_gc (struct glyph_string
*s
)
1562 prepare_face_for_display (s
->f
, s
->face
);
1564 if (s
->hl
== DRAW_NORMAL_TEXT
)
1566 s
->gc
= s
->face
->gc
;
1567 s
->stippled_p
= s
->face
->stipple
!= 0;
1569 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1571 x_set_mode_line_face_gc (s
);
1572 s
->stippled_p
= s
->face
->stipple
!= 0;
1574 else if (s
->hl
== DRAW_CURSOR
)
1576 x_set_cursor_gc (s
);
1577 s
->stippled_p
= false;
1579 else if (s
->hl
== DRAW_MOUSE_FACE
)
1581 x_set_mouse_face_gc (s
);
1582 s
->stippled_p
= s
->face
->stipple
!= 0;
1584 else if (s
->hl
== DRAW_IMAGE_RAISED
1585 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1587 s
->gc
= s
->face
->gc
;
1588 s
->stippled_p
= s
->face
->stipple
!= 0;
1593 /* GC must have been set. */
1594 eassert (s
->gc
!= 0);
1598 /* Set clipping for output of glyph string S. S may be part of a mode
1599 line or menu if we don't have X toolkit support. */
1602 x_set_glyph_string_clipping (struct glyph_string
*s
)
1604 XRectangle
*r
= s
->clip
;
1605 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1608 x_set_clip_rectangles (s
->f
, s
->gc
, r
, n
);
1613 /* Set SRC's clipping for output of glyph string DST. This is called
1614 when we are drawing DST's left_overhang or right_overhang only in
1618 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
, struct glyph_string
*dst
)
1623 r
.width
= src
->width
;
1625 r
.height
= src
->height
;
1628 x_set_clip_rectangles (dst
->f
, dst
->gc
, &r
, 1);
1633 Compute left and right overhang of glyph string S. */
1636 x_compute_glyph_string_overhangs (struct glyph_string
*s
)
1639 && (s
->first_glyph
->type
== CHAR_GLYPH
1640 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
1642 struct font_metrics metrics
;
1644 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1646 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1647 struct font
*font
= s
->font
;
1650 for (i
= 0; i
< s
->nchars
; i
++)
1651 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
1652 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1656 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1658 composition_gstring_width (gstring
, s
->cmp_from
, s
->cmp_to
, &metrics
);
1660 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1661 ? metrics
.rbearing
- metrics
.width
: 0);
1662 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1666 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1667 s
->left_overhang
= - s
->cmp
->lbearing
;
1672 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1675 x_clear_glyph_string_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
1678 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1679 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1680 x_fill_rectangle (s
->f
, s
->gc
, x
, y
, w
, h
);
1681 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1685 /* Draw the background of glyph_string S. If S->background_filled_p
1686 is non-zero don't draw it. FORCE_P non-zero means draw the
1687 background even if it wouldn't be drawn normally. This is used
1688 when a string preceding S draws into the background of S, or S
1689 contains the first component of a composition. */
1692 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1694 /* Nothing to do if background has already been drawn or if it
1695 shouldn't be drawn in the first place. */
1696 if (!s
->background_filled_p
)
1698 int box_line_width
= max (s
->face
->box_line_width
, 0);
1702 /* Fill background with a stipple pattern. */
1703 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1704 x_fill_rectangle (s
->f
, s
->gc
, s
->x
,
1705 s
->y
+ box_line_width
,
1706 s
->background_width
,
1707 s
->height
- 2 * box_line_width
);
1708 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1709 s
->background_filled_p
= true;
1711 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1712 /* When xdisp.c ignores FONT_HEIGHT, we cannot trust
1713 font dimensions, since the actual glyphs might be
1714 much smaller. So in that case we always clear the
1715 rectangle with background color. */
1716 || FONT_TOO_HIGH (s
->font
)
1717 || s
->font_not_found_p
1718 || s
->extends_to_end_of_line_p
1721 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1722 s
->background_width
,
1723 s
->height
- 2 * box_line_width
);
1724 s
->background_filled_p
= true;
1730 /* Draw the foreground of glyph string S. */
1733 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1737 /* If first glyph of S has a left box line, start drawing the text
1738 of S to the right of that box line. */
1739 if (s
->face
->box
!= FACE_NO_BOX
1740 && s
->first_glyph
->left_box_line_p
)
1741 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1745 /* Draw characters of S as rectangles if S's font could not be
1747 if (s
->font_not_found_p
)
1749 for (i
= 0; i
< s
->nchars
; ++i
)
1751 struct glyph
*g
= s
->first_glyph
+ i
;
1752 x_draw_rectangle (s
->f
,
1753 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1755 x
+= g
->pixel_width
;
1760 struct font
*font
= s
->font
;
1761 int boff
= font
->baseline_offset
;
1764 if (font
->vertical_centering
)
1765 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1767 y
= s
->ybase
- boff
;
1769 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1770 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, false);
1772 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, true);
1773 if (s
->face
->overstrike
)
1774 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, false);
1778 /* Draw the foreground of composite glyph string S. */
1781 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1784 struct font
*font
= s
->font
;
1786 /* If first glyph of S has a left box line, start drawing the text
1787 of S to the right of that box line. */
1788 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1789 && s
->first_glyph
->left_box_line_p
)
1790 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1794 /* S is a glyph string for a composition. S->cmp_from is the index
1795 of the first character drawn for glyphs of this composition.
1796 S->cmp_from == 0 means we are drawing the very first character of
1797 this composition. */
1799 /* Draw a rectangle for the composition if the font for the very
1800 first character of the composition could not be loaded. */
1801 if (s
->font_not_found_p
)
1803 if (s
->cmp_from
== 0)
1804 x_draw_rectangle (s
->f
, s
->gc
, x
, s
->y
,
1805 s
->width
- 1, s
->height
- 1);
1807 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1811 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1812 /* TAB in a composition means display glyphs with padding
1813 space on the left or right. */
1814 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1816 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1817 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1819 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, false);
1820 if (s
->face
->overstrike
)
1821 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, false);
1826 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1831 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1833 glyph
= LGSTRING_GLYPH (gstring
, i
);
1834 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1835 width
+= LGLYPH_WIDTH (glyph
);
1838 int xoff
, yoff
, wadjust
;
1842 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1843 if (s
->face
->overstrike
)
1844 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, false);
1847 xoff
= LGLYPH_XOFF (glyph
);
1848 yoff
= LGLYPH_YOFF (glyph
);
1849 wadjust
= LGLYPH_WADJUST (glyph
);
1850 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, false);
1851 if (s
->face
->overstrike
)
1852 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
,
1861 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1862 if (s
->face
->overstrike
)
1863 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, false);
1869 /* Draw the foreground of glyph string S for glyphless characters. */
1872 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1874 struct glyph
*glyph
= s
->first_glyph
;
1878 /* If first glyph of S has a left box line, start drawing the text
1879 of S to the right of that box line. */
1880 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1881 && s
->first_glyph
->left_box_line_p
)
1882 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1888 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1890 char buf
[7], *str
= NULL
;
1891 int len
= glyph
->u
.glyphless
.len
;
1893 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1896 && CHAR_TABLE_P (Vglyphless_char_display
)
1897 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1901 = (! glyph
->u
.glyphless
.for_no_font
1902 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1903 glyph
->u
.glyphless
.ch
)
1904 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1905 if (STRINGP (acronym
))
1906 str
= SSDATA (acronym
);
1909 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1911 sprintf (buf
, "%0*X",
1912 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1913 glyph
->u
.glyphless
.ch
+ 0u);
1919 int upper_len
= (len
+ 1) / 2;
1922 /* It is assured that all LEN characters in STR is ASCII. */
1923 for (j
= 0; j
< len
; j
++)
1925 code
= s
->font
->driver
->encode_char (s
->font
, str
[j
]);
1926 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1928 s
->font
->driver
->draw (s
, 0, upper_len
,
1929 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1930 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1932 s
->font
->driver
->draw (s
, upper_len
, len
,
1933 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1934 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1937 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1938 x_draw_rectangle (s
->f
, s
->gc
,
1939 x
, s
->ybase
- glyph
->ascent
,
1940 glyph
->pixel_width
- 1,
1941 glyph
->ascent
+ glyph
->descent
- 1);
1942 x
+= glyph
->pixel_width
;
1946 #ifdef USE_X_TOOLKIT
1950 /* Return the frame on which widget WIDGET is used.. Abort if frame
1951 cannot be determined. */
1953 static struct frame
*
1954 x_frame_of_widget (Widget widget
)
1956 struct x_display_info
*dpyinfo
;
1957 Lisp_Object tail
, frame
;
1960 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1962 /* Find the top-level shell of the widget. Note that this function
1963 can be called when the widget is not yet realized, so XtWindow
1964 (widget) == 0. That's the reason we can't simply use
1965 x_any_window_to_frame. */
1966 while (!XtIsTopLevelShell (widget
))
1967 widget
= XtParent (widget
);
1969 /* Look for a frame with that top-level widget. Allocate the color
1970 on that frame to get the right gamma correction value. */
1971 FOR_EACH_FRAME (tail
, frame
)
1975 && f
->output_data
.nothing
!= 1
1976 && FRAME_DISPLAY_INFO (f
) == dpyinfo
1977 && f
->output_data
.x
->widget
== widget
)
1983 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1984 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1985 If this produces the same color as PIXEL, try a color where all RGB
1986 values have DELTA added. Return the allocated color in *PIXEL.
1987 DISPLAY is the X display, CMAP is the colormap to operate on.
1988 Value is true if successful. */
1991 x_alloc_lighter_color_for_widget (Widget widget
, Display
*display
, Colormap cmap
,
1992 unsigned long *pixel
, double factor
, int delta
)
1994 struct frame
*f
= x_frame_of_widget (widget
);
1995 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1998 #endif /* USE_LUCID */
2001 /* Structure specifying which arguments should be passed by Xt to
2002 cvt_string_to_pixel. We want the widget's screen and colormap. */
2004 static XtConvertArgRec cvt_string_to_pixel_args
[] =
2006 {XtWidgetBaseOffset
, (XtPointer
) offsetof (WidgetRec
, core
.screen
),
2008 {XtWidgetBaseOffset
, (XtPointer
) offsetof (WidgetRec
, core
.colormap
),
2013 /* The address of this variable is returned by
2014 cvt_string_to_pixel. */
2016 static Pixel cvt_string_to_pixel_value
;
2019 /* Convert a color name to a pixel color.
2021 DPY is the display we are working on.
2023 ARGS is an array of *NARGS XrmValue structures holding additional
2024 information about the widget for which the conversion takes place.
2025 The contents of this array are determined by the specification
2026 in cvt_string_to_pixel_args.
2028 FROM is a pointer to an XrmValue which points to the color name to
2029 convert. TO is an XrmValue in which to return the pixel color.
2031 CLOSURE_RET is a pointer to user-data, in which we record if
2032 we allocated the color or not.
2034 Value is True if successful, False otherwise. */
2037 cvt_string_to_pixel (Display
*dpy
, XrmValue
*args
, Cardinal
*nargs
,
2038 XrmValue
*from
, XrmValue
*to
,
2039 XtPointer
*closure_ret
)
2049 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
2050 "wrongParameters", "cvt_string_to_pixel",
2052 "Screen and colormap args required", NULL
, NULL
);
2056 screen
= *(Screen
**) args
[0].addr
;
2057 cmap
= *(Colormap
*) args
[1].addr
;
2058 color_name
= (String
) from
->addr
;
2060 if (strcmp (color_name
, XtDefaultBackground
) == 0)
2062 *closure_ret
= (XtPointer
) False
;
2063 pixel
= WhitePixelOfScreen (screen
);
2065 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
2067 *closure_ret
= (XtPointer
) False
;
2068 pixel
= BlackPixelOfScreen (screen
);
2070 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
2071 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
2073 pixel
= color
.pixel
;
2074 *closure_ret
= (XtPointer
) True
;
2079 Cardinal nparams
= 1;
2081 params
[0] = color_name
;
2082 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
2083 "badValue", "cvt_string_to_pixel",
2084 "XtToolkitError", "Invalid color '%s'",
2089 if (to
->addr
!= NULL
)
2091 if (to
->size
< sizeof (Pixel
))
2093 to
->size
= sizeof (Pixel
);
2097 *(Pixel
*) to
->addr
= pixel
;
2101 cvt_string_to_pixel_value
= pixel
;
2102 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
2105 to
->size
= sizeof (Pixel
);
2110 /* Free a pixel color which was previously allocated via
2111 cvt_string_to_pixel. This is registered as the destructor
2112 for this type of resource via XtSetTypeConverter.
2114 APP is the application context in which we work.
2116 TO is a pointer to an XrmValue holding the color to free.
2117 CLOSURE is the value we stored in CLOSURE_RET for this color
2118 in cvt_string_to_pixel.
2120 ARGS and NARGS are like for cvt_string_to_pixel. */
2123 cvt_pixel_dtor (XtAppContext app
, XrmValuePtr to
, XtPointer closure
, XrmValuePtr args
,
2128 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
2130 "Screen and colormap arguments required",
2133 else if (closure
!= NULL
)
2135 /* We did allocate the pixel, so free it. */
2136 Screen
*screen
= *(Screen
**) args
[0].addr
;
2137 Colormap cmap
= *(Colormap
*) args
[1].addr
;
2138 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
2139 (Pixel
*) to
->addr
, 1);
2144 #endif /* USE_X_TOOLKIT */
2147 /* Value is an array of XColor structures for the contents of the
2148 color map of display DPY. Set *NCELLS to the size of the array.
2149 Note that this probably shouldn't be called for large color maps,
2150 say a 24-bit TrueColor map. */
2152 static const XColor
*
2153 x_color_cells (Display
*dpy
, int *ncells
)
2155 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
2158 if (dpyinfo
->color_cells
== NULL
)
2160 Screen
*screen
= dpyinfo
->screen
;
2161 int ncolor_cells
= XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
2164 dpyinfo
->color_cells
= xnmalloc (ncolor_cells
,
2165 sizeof *dpyinfo
->color_cells
);
2166 dpyinfo
->ncolor_cells
= ncolor_cells
;
2168 for (i
= 0; i
< ncolor_cells
; ++i
)
2169 dpyinfo
->color_cells
[i
].pixel
= i
;
2171 XQueryColors (dpy
, dpyinfo
->cmap
,
2172 dpyinfo
->color_cells
, ncolor_cells
);
2175 *ncells
= dpyinfo
->ncolor_cells
;
2176 return dpyinfo
->color_cells
;
2180 /* On frame F, translate pixel colors to RGB values for the NCOLORS
2181 colors in COLORS. Use cached information, if available. */
2184 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
2186 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
2188 if (dpyinfo
->red_bits
> 0)
2190 /* For TrueColor displays, we can decompose the RGB value
2193 unsigned int rmult
, gmult
, bmult
;
2194 unsigned int rmask
, gmask
, bmask
;
2196 rmask
= (1 << dpyinfo
->red_bits
) - 1;
2197 gmask
= (1 << dpyinfo
->green_bits
) - 1;
2198 bmask
= (1 << dpyinfo
->blue_bits
) - 1;
2199 /* If we're widening, for example, 8 bits in the pixel value to
2200 16 bits for the separate-color representation, we want to
2201 extrapolate the lower bits based on those bits available --
2202 in other words, we'd like 0xff to become 0xffff instead of
2203 the 0xff00 we'd get by just zero-filling the lower bits.
2205 We generate a 32-bit scaled-up value and shift it, in case
2206 the bit count doesn't divide 16 evenly (e.g., when dealing
2207 with a 3-3-2 bit RGB display), to get more of the lower bits
2210 Should we cache the multipliers in dpyinfo? Maybe
2211 special-case the 8-8-8 common case? */
2212 rmult
= 0xffffffff / rmask
;
2213 gmult
= 0xffffffff / gmask
;
2214 bmult
= 0xffffffff / bmask
;
2216 for (i
= 0; i
< ncolors
; ++i
)
2218 unsigned int r
, g
, b
;
2219 unsigned long pixel
= colors
[i
].pixel
;
2221 r
= (pixel
>> dpyinfo
->red_offset
) & rmask
;
2222 g
= (pixel
>> dpyinfo
->green_offset
) & gmask
;
2223 b
= (pixel
>> dpyinfo
->blue_offset
) & bmask
;
2225 colors
[i
].red
= (r
* rmult
) >> 16;
2226 colors
[i
].green
= (g
* gmult
) >> 16;
2227 colors
[i
].blue
= (b
* bmult
) >> 16;
2232 if (dpyinfo
->color_cells
)
2235 for (i
= 0; i
< ncolors
; ++i
)
2237 unsigned long pixel
= colors
[i
].pixel
;
2238 eassert (pixel
< dpyinfo
->ncolor_cells
);
2239 eassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
2240 colors
[i
] = dpyinfo
->color_cells
[pixel
];
2245 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
2249 /* On frame F, translate pixel color to RGB values for the color in
2250 COLOR. Use cached information, if available. */
2253 x_query_color (struct frame
*f
, XColor
*color
)
2255 x_query_colors (f
, color
, 1);
2259 /* On frame F, translate the color name to RGB values. Use cached
2260 information, if possible.
2262 Note that there is currently no way to clean old entries out of the
2263 cache. However, it is limited to names in the server's database,
2264 and names we've actually looked up; list-colors-display is probably
2265 the most color-intensive case we're likely to hit. */
2267 Status
x_parse_color (struct frame
*f
, const char *color_name
,
2270 Display
*dpy
= FRAME_X_DISPLAY (f
);
2271 Colormap cmap
= FRAME_X_COLORMAP (f
);
2272 struct color_name_cache_entry
*cache_entry
;
2274 if (color_name
[0] == '#')
2276 /* The hex form is parsed directly by XParseColor without
2277 talking to the X server. No need for caching. */
2278 return XParseColor (dpy
, cmap
, color_name
, color
);
2281 for (cache_entry
= FRAME_DISPLAY_INFO (f
)->color_names
; cache_entry
;
2282 cache_entry
= cache_entry
->next
)
2284 if (!xstrcasecmp(cache_entry
->name
, color_name
))
2286 *color
= cache_entry
->rgb
;
2291 if (XParseColor (dpy
, cmap
, color_name
, color
) == 0)
2292 /* No caching of negative results, currently. */
2295 cache_entry
= xzalloc (sizeof *cache_entry
);
2296 cache_entry
->rgb
= *color
;
2297 cache_entry
->name
= xstrdup (color_name
);
2298 cache_entry
->next
= FRAME_DISPLAY_INFO (f
)->color_names
;
2299 FRAME_DISPLAY_INFO (f
)->color_names
= cache_entry
;
2304 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
2305 exact match can't be allocated, try the nearest color available.
2306 Value is true if successful. Set *COLOR to the color
2310 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
2314 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
2317 /* If we got to this point, the colormap is full, so we're going
2318 to try to get the next closest color. The algorithm used is
2319 a least-squares matching, which is what X uses for closest
2320 color matching with StaticColor visuals. */
2322 int max_color_delta
= 255;
2323 int max_delta
= 3 * max_color_delta
;
2324 int nearest_delta
= max_delta
+ 1;
2326 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
2328 for (nearest
= i
= 0; i
< ncells
; ++i
)
2330 int dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
2331 int dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
2332 int dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
2333 int delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
2335 if (delta
< nearest_delta
)
2338 nearest_delta
= delta
;
2342 color
->red
= cells
[nearest
].red
;
2343 color
->green
= cells
[nearest
].green
;
2344 color
->blue
= cells
[nearest
].blue
;
2345 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
2349 /* If allocation succeeded, and the allocated pixel color is not
2350 equal to a cached pixel color recorded earlier, there was a
2351 change in the colormap, so clear the color cache. */
2352 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
2355 if (dpyinfo
->color_cells
)
2357 XColor
*cached_color
= &dpyinfo
->color_cells
[color
->pixel
];
2358 if (cached_color
->red
!= color
->red
2359 || cached_color
->blue
!= color
->blue
2360 || cached_color
->green
!= color
->green
)
2362 xfree (dpyinfo
->color_cells
);
2363 dpyinfo
->color_cells
= NULL
;
2364 dpyinfo
->ncolor_cells
= 0;
2369 #ifdef DEBUG_X_COLORS
2371 register_color (color
->pixel
);
2372 #endif /* DEBUG_X_COLORS */
2378 /* Allocate the color COLOR->pixel on frame F, colormap CMAP, after
2379 gamma correction. If an exact match can't be allocated, try the
2380 nearest color available. Value is true if successful. Set *COLOR
2381 to the color allocated. */
2384 x_alloc_nearest_color (struct frame
*f
, Colormap cmap
, XColor
*color
)
2386 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
2388 gamma_correct (f
, color
);
2390 if (dpyinfo
->red_bits
> 0)
2392 color
->pixel
= x_make_truecolor_pixel (dpyinfo
,
2399 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
2403 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
2404 It's necessary to do this instead of just using PIXEL directly to
2405 get color reference counts right. */
2408 x_copy_color (struct frame
*f
, unsigned long pixel
)
2412 /* If display has an immutable color map, freeing colors is not
2413 necessary and some servers don't allow it. Since we won't free a
2414 color once we've allocated it, we don't need to re-allocate it to
2415 maintain the server's reference count. */
2416 if (!x_mutable_colormap (FRAME_X_VISUAL (f
)))
2419 color
.pixel
= pixel
;
2421 /* The color could still be found in the color_cells array. */
2422 x_query_color (f
, &color
);
2423 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
2425 #ifdef DEBUG_X_COLORS
2426 register_color (pixel
);
2432 /* Brightness beyond which a color won't have its highlight brightness
2435 Nominally, highlight colors for `3d' faces are calculated by
2436 brightening an object's color by a constant scale factor, but this
2437 doesn't yield good results for dark colors, so for colors who's
2438 brightness is less than this value (on a scale of 0-65535) have an
2439 use an additional additive factor.
2441 The value here is set so that the default menu-bar/mode-line color
2442 (grey75) will not have its highlights changed at all. */
2443 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
2446 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
2447 or DELTA. Try a color with RGB values multiplied by FACTOR first.
2448 If this produces the same color as PIXEL, try a color where all RGB
2449 values have DELTA added. Return the allocated color in *PIXEL.
2450 DISPLAY is the X display, CMAP is the colormap to operate on.
2451 Value is non-zero if successful. */
2454 x_alloc_lighter_color (struct frame
*f
, Display
*display
, Colormap cmap
,
2455 unsigned long *pixel
, double factor
, int delta
)
2461 /* Get RGB color values. */
2462 color
.pixel
= *pixel
;
2463 x_query_color (f
, &color
);
2465 /* Change RGB values by specified FACTOR. Avoid overflow! */
2466 eassert (factor
>= 0);
2467 new.red
= min (0xffff, factor
* color
.red
);
2468 new.green
= min (0xffff, factor
* color
.green
);
2469 new.blue
= min (0xffff, factor
* color
.blue
);
2471 /* Calculate brightness of COLOR. */
2472 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
2474 /* We only boost colors that are darker than
2475 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
2476 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
2477 /* Make an additive adjustment to NEW, because it's dark enough so
2478 that scaling by FACTOR alone isn't enough. */
2480 /* How far below the limit this color is (0 - 1, 1 being darker). */
2481 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
2482 /* The additive adjustment. */
2483 int min_delta
= delta
* dimness
* factor
/ 2;
2487 new.red
= max (0, new.red
- min_delta
);
2488 new.green
= max (0, new.green
- min_delta
);
2489 new.blue
= max (0, new.blue
- min_delta
);
2493 new.red
= min (0xffff, min_delta
+ new.red
);
2494 new.green
= min (0xffff, min_delta
+ new.green
);
2495 new.blue
= min (0xffff, min_delta
+ new.blue
);
2499 /* Try to allocate the color. */
2500 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
2503 if (new.pixel
== *pixel
)
2505 /* If we end up with the same color as before, try adding
2506 delta to the RGB values. */
2507 x_free_colors (f
, &new.pixel
, 1);
2509 new.red
= min (0xffff, delta
+ color
.red
);
2510 new.green
= min (0xffff, delta
+ color
.green
);
2511 new.blue
= min (0xffff, delta
+ color
.blue
);
2512 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
2523 /* Set up the foreground color for drawing relief lines of glyph
2524 string S. RELIEF is a pointer to a struct relief containing the GC
2525 with which lines will be drawn. Use a color that is FACTOR or
2526 DELTA lighter or darker than the relief's background which is found
2527 in S->f->output_data.x->relief_background. If such a color cannot
2528 be allocated, use DEFAULT_PIXEL, instead. */
2531 x_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
2532 int delta
, unsigned long default_pixel
)
2535 struct x_output
*di
= f
->output_data
.x
;
2536 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
2537 unsigned long pixel
;
2538 unsigned long background
= di
->relief_background
;
2539 Colormap cmap
= FRAME_X_COLORMAP (f
);
2540 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
2541 Display
*dpy
= FRAME_X_DISPLAY (f
);
2543 xgcv
.graphics_exposures
= False
;
2544 xgcv
.line_width
= 1;
2546 /* Free previously allocated color. The color cell will be reused
2547 when it has been freed as many times as it was allocated, so this
2548 doesn't affect faces using the same colors. */
2549 if (relief
->gc
&& relief
->pixel
!= -1)
2551 x_free_colors (f
, &relief
->pixel
, 1);
2555 /* Allocate new color. */
2556 xgcv
.foreground
= default_pixel
;
2558 if (dpyinfo
->n_planes
!= 1
2559 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
2560 xgcv
.foreground
= relief
->pixel
= pixel
;
2562 if (relief
->gc
== 0)
2564 xgcv
.stipple
= dpyinfo
->gray
;
2566 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
2569 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
2573 /* Set up colors for the relief lines around glyph string S. */
2576 x_setup_relief_colors (struct glyph_string
*s
)
2578 struct x_output
*di
= s
->f
->output_data
.x
;
2579 unsigned long color
;
2581 if (s
->face
->use_box_color_for_shadows_p
)
2582 color
= s
->face
->box_color
;
2583 else if (s
->first_glyph
->type
== IMAGE_GLYPH
2585 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
2586 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
2591 /* Get the background color of the face. */
2592 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
2593 color
= xgcv
.background
;
2596 if (di
->white_relief
.gc
== 0
2597 || color
!= di
->relief_background
)
2599 di
->relief_background
= color
;
2600 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
2601 WHITE_PIX_DEFAULT (s
->f
));
2602 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
2603 BLACK_PIX_DEFAULT (s
->f
));
2608 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2609 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2610 to draw, it must be >= 0. RAISED_P means draw a raised
2611 relief. LEFT_P means draw a relief on the left side of
2612 the rectangle. RIGHT_P means draw a relief on the right
2613 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2617 x_draw_relief_rect (struct frame
*f
,
2618 int left_x
, int top_y
, int right_x
, int bottom_y
,
2619 int width
, bool raised_p
, bool top_p
, bool bot_p
,
2620 bool left_p
, bool right_p
,
2621 XRectangle
*clip_rect
)
2624 GC top_left_gc
, bottom_right_gc
;
2629 top_left_gc
= f
->output_data
.x
->white_relief
.gc
;
2630 bottom_right_gc
= f
->output_data
.x
->black_relief
.gc
;
2634 top_left_gc
= f
->output_data
.x
->black_relief
.gc
;
2635 bottom_right_gc
= f
->output_data
.x
->white_relief
.gc
;
2638 x_set_clip_rectangles (f
, top_left_gc
, clip_rect
, 1);
2639 x_set_clip_rectangles (f
, bottom_right_gc
, clip_rect
, 1);
2643 x_fill_rectangle (f
, top_left_gc
, left_x
, top_y
,
2644 width
, bottom_y
+ 1 - top_y
);
2646 corners
|= 1 << CORNER_TOP_LEFT
;
2648 corners
|= 1 << CORNER_BOTTOM_LEFT
;
2652 x_fill_rectangle (f
, bottom_right_gc
, right_x
+ 1 - width
, top_y
,
2653 width
, bottom_y
+ 1 - top_y
);
2655 corners
|= 1 << CORNER_TOP_RIGHT
;
2657 corners
|= 1 << CORNER_BOTTOM_RIGHT
;
2662 x_fill_rectangle (f
, top_left_gc
, left_x
, top_y
,
2663 right_x
+ 1 - left_x
, width
);
2665 x_fill_trapezoid_for_relief (f
, top_left_gc
, left_x
, top_y
,
2666 right_x
+ 1 - left_x
, width
, 1);
2671 x_fill_rectangle (f
, bottom_right_gc
, left_x
, bottom_y
+ 1 - width
,
2672 right_x
+ 1 - left_x
, width
);
2674 x_fill_trapezoid_for_relief (f
, bottom_right_gc
,
2675 left_x
, bottom_y
+ 1 - width
,
2676 right_x
+ 1 - left_x
, width
, 0);
2678 if (left_p
&& width
!= 1)
2679 x_fill_rectangle (f
, bottom_right_gc
, left_x
, top_y
,
2680 1, bottom_y
+ 1 - top_y
);
2681 if (top_p
&& width
!= 1)
2682 x_fill_rectangle (f
, bottom_right_gc
, left_x
, top_y
,
2683 right_x
+ 1 - left_x
, 1);
2686 XSetBackground (FRAME_X_DISPLAY (f
), top_left_gc
,
2687 FRAME_BACKGROUND_PIXEL (f
));
2688 x_erase_corners_for_relief (f
, top_left_gc
, left_x
, top_y
,
2689 right_x
- left_x
+ 1, bottom_y
- top_y
+ 1,
2693 x_reset_clip_rectangles (f
, top_left_gc
);
2694 x_reset_clip_rectangles (f
, bottom_right_gc
);
2696 Display
*dpy
= FRAME_X_DISPLAY (f
);
2697 Window window
= FRAME_X_WINDOW (f
);
2702 gc
= f
->output_data
.x
->white_relief
.gc
;
2704 gc
= f
->output_data
.x
->black_relief
.gc
;
2705 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2707 /* This code is more complicated than it has to be, because of two
2708 minor hacks to make the boxes look nicer: (i) if width > 1, draw
2709 the outermost line using the black relief. (ii) Omit the four
2716 XDrawLine (dpy
, window
, gc
,
2717 left_x
+ left_p
, top_y
,
2718 right_x
+ !right_p
, top_y
);
2720 for (i
= 1; i
< width
; ++i
)
2721 XDrawLine (dpy
, window
, gc
,
2722 left_x
+ i
* left_p
, top_y
+ i
,
2723 right_x
+ 1 - i
* right_p
, top_y
+ i
);
2730 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
2732 XClearArea (dpy
, window
, left_x
, top_y
, 1, 1, False
);
2733 XClearArea (dpy
, window
, left_x
, bottom_y
, 1, 1, False
);
2735 for (i
= (width
> 1 ? 1 : 0); i
< width
; ++i
)
2736 XDrawLine (dpy
, window
, gc
,
2737 left_x
+ i
, top_y
+ (i
+ 1) * top_p
,
2738 left_x
+ i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
2741 XSetClipMask (dpy
, gc
, None
);
2743 gc
= f
->output_data
.x
->black_relief
.gc
;
2745 gc
= f
->output_data
.x
->white_relief
.gc
;
2746 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2750 /* Outermost top line. */
2752 XDrawLine (dpy
, window
, gc
,
2753 left_x
+ left_p
, top_y
,
2754 right_x
+ !right_p
, top_y
);
2756 /* Outermost left line. */
2758 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
2764 XDrawLine (dpy
, window
, gc
,
2765 left_x
+ left_p
, bottom_y
,
2766 right_x
+ !right_p
, bottom_y
);
2767 for (i
= 1; i
< width
; ++i
)
2768 XDrawLine (dpy
, window
, gc
,
2769 left_x
+ i
* left_p
, bottom_y
- i
,
2770 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2776 XClearArea (dpy
, window
, right_x
, top_y
, 1, 1, False
);
2777 XClearArea (dpy
, window
, right_x
, bottom_y
, 1, 1, False
);
2778 for (i
= 0; i
< width
; ++i
)
2779 XDrawLine (dpy
, window
, gc
,
2780 right_x
- i
, top_y
+ (i
+ 1) * top_p
,
2781 right_x
- i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
2784 x_reset_clip_rectangles (f
, gc
);
2790 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2791 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2792 draw, it must be >= 0. LEFT_P means draw a line on the
2793 left side of the rectangle. RIGHT_P means draw a line
2794 on the right side of the rectangle. CLIP_RECT is the clipping
2795 rectangle to use when drawing. */
2798 x_draw_box_rect (struct glyph_string
*s
,
2799 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
2800 bool left_p
, bool right_p
, XRectangle
*clip_rect
)
2804 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2805 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2806 x_set_clip_rectangles (s
->f
, s
->gc
, clip_rect
, 1);
2809 x_fill_rectangle (s
->f
, s
->gc
,
2810 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2814 x_fill_rectangle (s
->f
, s
->gc
,
2815 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2818 x_fill_rectangle (s
->f
, s
->gc
,
2819 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2823 x_fill_rectangle (s
->f
, s
->gc
,
2824 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2826 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2827 x_reset_clip_rectangles (s
->f
, s
->gc
);
2831 /* Draw a box around glyph string S. */
2834 x_draw_glyph_string_box (struct glyph_string
*s
)
2836 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
;
2837 bool raised_p
, left_p
, right_p
;
2838 struct glyph
*last_glyph
;
2839 XRectangle clip_rect
;
2841 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2842 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2843 : window_box_right (s
->w
, s
->area
));
2845 /* The glyph that may have a right box line. */
2846 last_glyph
= (s
->cmp
|| s
->img
2848 : s
->first_glyph
+ s
->nchars
- 1);
2850 width
= eabs (s
->face
->box_line_width
);
2851 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2853 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2855 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2857 bottom_y
= top_y
+ s
->height
- 1;
2859 left_p
= (s
->first_glyph
->left_box_line_p
2860 || (s
->hl
== DRAW_MOUSE_FACE
2862 || s
->prev
->hl
!= s
->hl
)));
2863 right_p
= (last_glyph
->right_box_line_p
2864 || (s
->hl
== DRAW_MOUSE_FACE
2866 || s
->next
->hl
!= s
->hl
)));
2868 get_glyph_string_clip_rect (s
, &clip_rect
);
2870 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2871 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2872 left_p
, right_p
, &clip_rect
);
2875 x_setup_relief_colors (s
);
2876 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2877 width
, raised_p
, true, true, left_p
, right_p
,
2883 /* Draw foreground of image glyph string S. */
2886 x_draw_image_foreground (struct glyph_string
*s
)
2889 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2891 /* If first glyph of S has a left box line, start drawing it to the
2892 right of that line. */
2893 if (s
->face
->box
!= FACE_NO_BOX
2894 && s
->first_glyph
->left_box_line_p
2896 x
+= eabs (s
->face
->box_line_width
);
2898 /* If there is a margin around the image, adjust x- and y-position
2900 if (s
->slice
.x
== 0)
2901 x
+= s
->img
->hmargin
;
2902 if (s
->slice
.y
== 0)
2903 y
+= s
->img
->vmargin
;
2909 /* We can't set both a clip mask and use XSetClipRectangles
2910 because the latter also sets a clip mask. We also can't
2911 trust on the shape extension to be available
2912 (XShapeCombineRegion). So, compute the rectangle to draw
2914 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2917 XRectangle clip_rect
, image_rect
, r
;
2919 xgcv
.clip_mask
= s
->img
->mask
;
2920 xgcv
.clip_x_origin
= x
;
2921 xgcv
.clip_y_origin
= y
;
2922 xgcv
.function
= GXcopy
;
2923 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2925 get_glyph_string_clip_rect (s
, &clip_rect
);
2928 image_rect
.width
= s
->slice
.width
;
2929 image_rect
.height
= s
->slice
.height
;
2930 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2931 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2932 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2933 r
.width
, r
.height
, r
.x
, r
.y
);
2937 XRectangle clip_rect
, image_rect
, r
;
2939 get_glyph_string_clip_rect (s
, &clip_rect
);
2942 image_rect
.width
= s
->slice
.width
;
2943 image_rect
.height
= s
->slice
.height
;
2944 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2945 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2946 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2947 r
.width
, r
.height
, r
.x
, r
.y
);
2949 /* When the image has a mask, we can expect that at
2950 least part of a mouse highlight or a block cursor will
2951 be visible. If the image doesn't have a mask, make
2952 a block cursor visible by drawing a rectangle around
2953 the image. I believe it's looking better if we do
2954 nothing here for mouse-face. */
2955 if (s
->hl
== DRAW_CURSOR
)
2957 int relief
= eabs (s
->img
->relief
);
2958 x_draw_rectangle (s
->f
, s
->gc
,
2959 x
- relief
, y
- relief
,
2960 s
->slice
.width
+ relief
*2 - 1,
2961 s
->slice
.height
+ relief
*2 - 1);
2966 /* Draw a rectangle if image could not be loaded. */
2967 x_draw_rectangle (s
->f
, s
->gc
, x
, y
,
2968 s
->slice
.width
- 1, s
->slice
.height
- 1);
2972 /* Draw a relief around the image glyph string S. */
2975 x_draw_image_relief (struct glyph_string
*s
)
2978 bool raised_p
, top_p
, bot_p
, left_p
, right_p
;
2979 int extra_x
, extra_y
;
2982 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2984 /* If first glyph of S has a left box line, start drawing it to the
2985 right of that line. */
2986 if (s
->face
->box
!= FACE_NO_BOX
2987 && s
->first_glyph
->left_box_line_p
2989 x
+= eabs (s
->face
->box_line_width
);
2991 /* If there is a margin around the image, adjust x- and y-position
2993 if (s
->slice
.x
== 0)
2994 x
+= s
->img
->hmargin
;
2995 if (s
->slice
.y
== 0)
2996 y
+= s
->img
->vmargin
;
2998 if (s
->hl
== DRAW_IMAGE_SUNKEN
2999 || s
->hl
== DRAW_IMAGE_RAISED
)
3001 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
3002 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
3006 thick
= eabs (s
->img
->relief
);
3007 raised_p
= s
->img
->relief
> 0;
3010 x1
= x
+ s
->slice
.width
- 1;
3011 y1
= y
+ s
->slice
.height
- 1;
3013 extra_x
= extra_y
= 0;
3014 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
3016 if (CONSP (Vtool_bar_button_margin
)
3017 && INTEGERP (XCAR (Vtool_bar_button_margin
))
3018 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
3020 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
3021 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
3023 else if (INTEGERP (Vtool_bar_button_margin
))
3024 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
3027 top_p
= bot_p
= left_p
= right_p
= false;
3029 if (s
->slice
.x
== 0)
3030 x
-= thick
+ extra_x
, left_p
= true;
3031 if (s
->slice
.y
== 0)
3032 y
-= thick
+ extra_y
, top_p
= true;
3033 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
3034 x1
+= thick
+ extra_x
, right_p
= true;
3035 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
3036 y1
+= thick
+ extra_y
, bot_p
= true;
3038 x_setup_relief_colors (s
);
3039 get_glyph_string_clip_rect (s
, &r
);
3040 x_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
3041 top_p
, bot_p
, left_p
, right_p
, &r
);
3045 /* Draw the foreground of image glyph string S to PIXMAP. */
3048 x_draw_image_foreground_1 (struct glyph_string
*s
, Pixmap pixmap
)
3051 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
3053 /* If first glyph of S has a left box line, start drawing it to the
3054 right of that line. */
3055 if (s
->face
->box
!= FACE_NO_BOX
3056 && s
->first_glyph
->left_box_line_p
3058 x
+= eabs (s
->face
->box_line_width
);
3060 /* If there is a margin around the image, adjust x- and y-position
3062 if (s
->slice
.x
== 0)
3063 x
+= s
->img
->hmargin
;
3064 if (s
->slice
.y
== 0)
3065 y
+= s
->img
->vmargin
;
3071 /* We can't set both a clip mask and use XSetClipRectangles
3072 because the latter also sets a clip mask. We also can't
3073 trust on the shape extension to be available
3074 (XShapeCombineRegion). So, compute the rectangle to draw
3076 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3080 xgcv
.clip_mask
= s
->img
->mask
;
3081 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
3082 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
3083 xgcv
.function
= GXcopy
;
3084 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3086 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3087 s
->slice
.x
, s
->slice
.y
,
3088 s
->slice
.width
, s
->slice
.height
, x
, y
);
3089 XSetClipMask (s
->display
, s
->gc
, None
);
3093 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3094 s
->slice
.x
, s
->slice
.y
,
3095 s
->slice
.width
, s
->slice
.height
, x
, y
);
3097 /* When the image has a mask, we can expect that at
3098 least part of a mouse highlight or a block cursor will
3099 be visible. If the image doesn't have a mask, make
3100 a block cursor visible by drawing a rectangle around
3101 the image. I believe it's looking better if we do
3102 nothing here for mouse-face. */
3103 if (s
->hl
== DRAW_CURSOR
)
3105 int r
= eabs (s
->img
->relief
);
3106 x_draw_rectangle (s
->f
, s
->gc
, x
- r
, y
- r
,
3107 s
->slice
.width
+ r
*2 - 1,
3108 s
->slice
.height
+ r
*2 - 1);
3113 /* Draw a rectangle if image could not be loaded. */
3114 x_draw_rectangle (s
->f
, s
->gc
, x
, y
,
3115 s
->slice
.width
- 1, s
->slice
.height
- 1);
3119 /* Draw part of the background of glyph string S. X, Y, W, and H
3120 give the rectangle to draw. */
3123 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
3127 /* Fill background with a stipple pattern. */
3128 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3129 x_fill_rectangle (s
->f
, s
->gc
, x
, y
, w
, h
);
3130 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3133 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
3137 /* Draw image glyph string S.
3140 s->x +-------------------------
3143 | +-------------------------
3146 | | +-------------------
3152 x_draw_image_glyph_string (struct glyph_string
*s
)
3154 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
3155 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
3157 Pixmap pixmap
= None
;
3160 if (s
->slice
.y
== 0)
3161 height
-= box_line_vwidth
;
3162 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
3163 height
-= box_line_vwidth
;
3165 /* Fill background with face under the image. Do it only if row is
3166 taller than image or if image has a clip mask to reduce
3168 s
->stippled_p
= s
->face
->stipple
!= 0;
3169 if (height
> s
->slice
.height
3173 || s
->img
->pixmap
== 0
3174 || s
->width
!= s
->background_width
)
3178 /* Create a pixmap as large as the glyph string. Fill it
3179 with the background color. Copy the image to it, using
3180 its mask. Copy the temporary pixmap to the display. */
3181 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
3182 int depth
= DefaultDepthOfScreen (screen
);
3184 /* Create a pixmap as large as the glyph string. */
3185 pixmap
= XCreatePixmap (s
->display
, s
->window
,
3186 s
->background_width
,
3189 /* Don't clip in the following because we're working on the
3191 XSetClipMask (s
->display
, s
->gc
, None
);
3193 /* Fill the pixmap with the background color/stipple. */
3196 /* Fill background with a stipple pattern. */
3197 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3198 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
3199 XFillRectangle (s
->display
, pixmap
, s
->gc
,
3200 0, 0, s
->background_width
, s
->height
);
3201 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3202 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
3207 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
3209 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3210 XFillRectangle (s
->display
, pixmap
, s
->gc
,
3211 0, 0, s
->background_width
, s
->height
);
3212 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3219 int width
= s
->background_width
;
3221 if (s
->first_glyph
->left_box_line_p
3224 x
+= box_line_hwidth
;
3225 width
-= box_line_hwidth
;
3228 if (s
->slice
.y
== 0)
3229 y
+= box_line_vwidth
;
3231 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
3234 s
->background_filled_p
= true;
3237 /* Draw the foreground. */
3239 if (s
->img
->cr_data
)
3241 cairo_t
*cr
= x_begin_cr_clip (s
->f
, s
->gc
);
3243 int x
= s
->x
+ s
->img
->hmargin
;
3244 int y
= s
->y
+ s
->img
->vmargin
;
3245 int width
= s
->background_width
;
3247 cairo_set_source_surface (cr
, s
->img
->cr_data
,
3250 cairo_rectangle (cr
, x
, y
, width
, height
);
3252 x_end_cr_clip (s
->f
);
3258 x_draw_image_foreground_1 (s
, pixmap
);
3259 x_set_glyph_string_clipping (s
);
3260 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
3261 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
3262 XFreePixmap (s
->display
, pixmap
);
3265 x_draw_image_foreground (s
);
3267 /* If we must draw a relief around the image, do it. */
3269 || s
->hl
== DRAW_IMAGE_RAISED
3270 || s
->hl
== DRAW_IMAGE_SUNKEN
)
3271 x_draw_image_relief (s
);
3275 /* Draw stretch glyph string S. */
3278 x_draw_stretch_glyph_string (struct glyph_string
*s
)
3280 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
3282 if (s
->hl
== DRAW_CURSOR
3283 && !x_stretch_cursor_p
)
3285 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
3286 wide as the stretch glyph. */
3287 int width
, background_width
= s
->background_width
;
3290 if (!s
->row
->reversed_p
)
3292 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
3296 background_width
-= left_x
- x
;
3302 /* In R2L rows, draw the cursor on the right edge of the
3304 int right_x
= window_box_right (s
->w
, TEXT_AREA
);
3306 if (x
+ background_width
> right_x
)
3307 background_width
-= x
- right_x
;
3308 x
+= background_width
;
3310 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
3311 if (s
->row
->reversed_p
)
3315 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
3317 /* Clear rest using the GC of the original non-cursor face. */
3318 if (width
< background_width
)
3321 int w
= background_width
- width
, h
= s
->height
;
3325 if (!s
->row
->reversed_p
)
3329 if (s
->row
->mouse_face_p
3330 && cursor_in_mouse_face_p (s
->w
))
3332 x_set_mouse_face_gc (s
);
3338 get_glyph_string_clip_rect (s
, &r
);
3339 x_set_clip_rectangles (s
->f
, gc
, &r
, 1);
3341 if (s
->face
->stipple
)
3343 /* Fill background with a stipple pattern. */
3344 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
3345 x_fill_rectangle (s
->f
, gc
, x
, y
, w
, h
);
3346 XSetFillStyle (s
->display
, gc
, FillSolid
);
3351 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
3352 XSetForeground (s
->display
, gc
, xgcv
.background
);
3353 x_fill_rectangle (s
->f
, gc
, x
, y
, w
, h
);
3354 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
3357 x_reset_clip_rectangles (s
->f
, gc
);
3360 else if (!s
->background_filled_p
)
3362 int background_width
= s
->background_width
;
3363 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
3365 /* Don't draw into left margin, fringe or scrollbar area
3366 except for header line and mode line. */
3367 if (x
< left_x
&& !s
->row
->mode_line_p
)
3369 background_width
-= left_x
- x
;
3372 if (background_width
> 0)
3373 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
3376 s
->background_filled_p
= true;
3380 Draw a wavy line under S. The wave fills wave_height pixels from y0.
3386 wave_height = 3 | * * * *
3391 x_draw_underwave (struct glyph_string
*s
)
3393 int wave_height
= 3, wave_length
= 2;
3395 x_draw_horizontal_wave (s
->f
, s
->gc
, s
->x
, s
->ybase
- wave_height
+ 3,
3396 s
->width
, wave_height
, wave_length
);
3397 #else /* not USE_CAIRO */
3398 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, xmax
;
3400 XRectangle wave_clip
, string_clip
, final_clip
;
3403 dy
= wave_height
- 1;
3405 y0
= s
->ybase
- wave_height
+ 3;
3409 /* Find and set clipping rectangle */
3413 wave_clip
.width
= width
;
3414 wave_clip
.height
= wave_height
;
3415 get_glyph_string_clip_rect (s
, &string_clip
);
3417 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
3420 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &final_clip
, 1, Unsorted
);
3422 /* Draw the waves */
3424 x1
= x0
- (x0
% dx
);
3426 odd
= (x1
/ dx
) & 1;
3434 if (INT_MAX
- dx
< xmax
)
3439 XDrawLine (s
->display
, s
->window
, s
->gc
, x1
, y1
, x2
, y2
);
3441 x2
+= dx
, y2
= y0
+ odd
*dy
;
3445 /* Restore previous clipping rectangle(s) */
3446 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, s
->clip
, s
->num_clips
, Unsorted
);
3447 #endif /* not USE_CAIRO */
3451 /* Draw glyph string S. */
3454 x_draw_glyph_string (struct glyph_string
*s
)
3456 bool relief_drawn_p
= false;
3458 /* If S draws into the background of its successors, draw the
3459 background of the successors first so that S can draw into it.
3460 This makes S->next use XDrawString instead of XDrawImageString. */
3461 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
3464 struct glyph_string
*next
;
3466 for (width
= 0, next
= s
->next
;
3467 next
&& width
< s
->right_overhang
;
3468 width
+= next
->width
, next
= next
->next
)
3469 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
3471 x_set_glyph_string_gc (next
);
3472 x_set_glyph_string_clipping (next
);
3473 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
3474 x_draw_stretch_glyph_string (next
);
3476 x_draw_glyph_string_background (next
, true);
3477 next
->num_clips
= 0;
3481 /* Set up S->gc, set clipping and draw S. */
3482 x_set_glyph_string_gc (s
);
3484 /* Draw relief (if any) in advance for char/composition so that the
3485 glyph string can be drawn over it. */
3486 if (!s
->for_overlaps
3487 && s
->face
->box
!= FACE_NO_BOX
3488 && (s
->first_glyph
->type
== CHAR_GLYPH
3489 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
3492 x_set_glyph_string_clipping (s
);
3493 x_draw_glyph_string_background (s
, true);
3494 x_draw_glyph_string_box (s
);
3495 x_set_glyph_string_clipping (s
);
3496 relief_drawn_p
= true;
3498 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
3500 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
3501 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
3502 /* We must clip just this glyph. left_overhang part has already
3503 drawn when s->prev was drawn, and right_overhang part will be
3504 drawn later when s->next is drawn. */
3505 x_set_glyph_string_clipping_exactly (s
, s
);
3507 x_set_glyph_string_clipping (s
);
3509 switch (s
->first_glyph
->type
)
3512 x_draw_image_glyph_string (s
);
3516 x_draw_xwidget_glyph_string (s
);
3520 x_draw_stretch_glyph_string (s
);
3524 if (s
->for_overlaps
)
3525 s
->background_filled_p
= true;
3527 x_draw_glyph_string_background (s
, false);
3528 x_draw_glyph_string_foreground (s
);
3531 case COMPOSITE_GLYPH
:
3532 if (s
->for_overlaps
|| (s
->cmp_from
> 0
3533 && ! s
->first_glyph
->u
.cmp
.automatic
))
3534 s
->background_filled_p
= true;
3536 x_draw_glyph_string_background (s
, true);
3537 x_draw_composite_glyph_string_foreground (s
);
3540 case GLYPHLESS_GLYPH
:
3541 if (s
->for_overlaps
)
3542 s
->background_filled_p
= true;
3544 x_draw_glyph_string_background (s
, true);
3545 x_draw_glyphless_glyph_string_foreground (s
);
3552 if (!s
->for_overlaps
)
3554 /* Draw underline. */
3555 if (s
->face
->underline_p
)
3557 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
3559 if (s
->face
->underline_defaulted_p
)
3560 x_draw_underwave (s
);
3564 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3565 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
3566 x_draw_underwave (s
);
3567 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3570 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
3572 unsigned long thickness
, position
;
3575 if (s
->prev
&& s
->prev
->face
->underline_p
3576 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
3578 /* We use the same underline style as the previous one. */
3579 thickness
= s
->prev
->underline_thickness
;
3580 position
= s
->prev
->underline_position
;
3584 /* Get the underline thickness. Default is 1 pixel. */
3585 if (s
->font
&& s
->font
->underline_thickness
> 0)
3586 thickness
= s
->font
->underline_thickness
;
3589 if (x_underline_at_descent_line
)
3590 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
3593 /* Get the underline position. This is the recommended
3594 vertical offset in pixels from the baseline to the top of
3595 the underline. This is a signed value according to the
3596 specs, and its default is
3598 ROUND ((maximum descent) / 2), with
3599 ROUND(x) = floor (x + 0.5) */
3601 if (x_use_underline_position_properties
3602 && s
->font
&& s
->font
->underline_position
>= 0)
3603 position
= s
->font
->underline_position
;
3605 position
= (s
->font
->descent
+ 1) / 2;
3607 position
= underline_minimum_offset
;
3609 position
= max (position
, underline_minimum_offset
);
3611 /* Check the sanity of thickness and position. We should
3612 avoid drawing underline out of the current line area. */
3613 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
3614 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
3615 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
3616 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
3617 s
->underline_thickness
= thickness
;
3618 s
->underline_position
= position
;
3619 y
= s
->ybase
+ position
;
3620 if (s
->face
->underline_defaulted_p
)
3621 x_fill_rectangle (s
->f
, s
->gc
,
3622 s
->x
, y
, s
->width
, thickness
);
3626 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3627 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
3628 x_fill_rectangle (s
->f
, s
->gc
,
3629 s
->x
, y
, s
->width
, thickness
);
3630 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3634 /* Draw overline. */
3635 if (s
->face
->overline_p
)
3637 unsigned long dy
= 0, h
= 1;
3639 if (s
->face
->overline_color_defaulted_p
)
3640 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3645 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3646 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
3647 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3649 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3653 /* Draw strike-through. */
3654 if (s
->face
->strike_through_p
)
3656 unsigned long h
= 1;
3657 unsigned long dy
= (s
->height
- h
) / 2;
3659 if (s
->face
->strike_through_color_defaulted_p
)
3660 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3665 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3666 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
3667 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3669 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3673 /* Draw relief if not yet drawn. */
3674 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
3675 x_draw_glyph_string_box (s
);
3679 struct glyph_string
*prev
;
3681 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
3682 if (prev
->hl
!= s
->hl
3683 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
3685 /* As prev was drawn while clipped to its own area, we
3686 must draw the right_overhang part using s->hl now. */
3687 enum draw_glyphs_face save
= prev
->hl
;
3690 x_set_glyph_string_gc (prev
);
3691 x_set_glyph_string_clipping_exactly (s
, prev
);
3692 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
3693 x_draw_glyph_string_foreground (prev
);
3695 x_draw_composite_glyph_string_foreground (prev
);
3696 x_reset_clip_rectangles (prev
->f
, prev
->gc
);
3698 prev
->num_clips
= 0;
3704 struct glyph_string
*next
;
3706 for (next
= s
->next
; next
; next
= next
->next
)
3707 if (next
->hl
!= s
->hl
3708 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
3710 /* As next will be drawn while clipped to its own area,
3711 we must draw the left_overhang part using s->hl now. */
3712 enum draw_glyphs_face save
= next
->hl
;
3715 x_set_glyph_string_gc (next
);
3716 x_set_glyph_string_clipping_exactly (s
, next
);
3717 if (next
->first_glyph
->type
== CHAR_GLYPH
)
3718 x_draw_glyph_string_foreground (next
);
3720 x_draw_composite_glyph_string_foreground (next
);
3721 x_reset_clip_rectangles (next
->f
, next
->gc
);
3723 next
->num_clips
= 0;
3724 next
->clip_head
= s
->next
;
3729 /* Reset clipping. */
3730 x_reset_clip_rectangles (s
->f
, s
->gc
);
3734 /* Shift display to make room for inserted glyphs. */
3737 x_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
, int width
, int height
, int shift_by
)
3739 /* Never called on a GUI frame, see
3740 http://lists.gnu.org/archive/html/emacs-devel/2015-05/msg00456.html
3742 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3743 f
->output_data
.x
->normal_gc
,
3744 x
, y
, width
, height
,
3748 /* Delete N glyphs at the nominal cursor position. Not implemented
3752 x_delete_glyphs (struct frame
*f
, register int n
)
3758 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
3759 If they are <= 0, this is probably an error. */
3761 static ATTRIBUTE_UNUSED
void
3762 x_clear_area1 (Display
*dpy
, Window window
,
3763 int x
, int y
, int width
, int height
, int exposures
)
3765 eassert (width
> 0 && height
> 0);
3766 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
3770 x_clear_area (struct frame
*f
, int x
, int y
, int width
, int height
)
3775 eassert (width
> 0 && height
> 0);
3777 cr
= x_begin_cr_clip (f
, NULL
);
3778 x_set_cr_source_with_gc_background (f
, f
->output_data
.x
->normal_gc
);
3779 cairo_rectangle (cr
, x
, y
, width
, height
);
3783 x_clear_area1 (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3784 x
, y
, width
, height
, False
);
3789 /* Clear an entire frame. */
3792 x_clear_frame (struct frame
*f
)
3794 /* Clearing the frame will erase any cursor, so mark them all as no
3796 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3802 /* We have to clear the scroll bars. If we have changed colors or
3803 something like that, then they should be notified. */
3804 x_scroll_bar_clear (f
);
3806 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3807 /* Make sure scroll bars are redrawn. As they aren't redrawn by
3808 redisplay, do it here. */
3809 if (FRAME_GTK_WIDGET (f
))
3810 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
3813 XFlush (FRAME_X_DISPLAY (f
));
3818 /* RIF: Show hourglass cursor on frame F. */
3821 x_show_hourglass (struct frame
*f
)
3823 Display
*dpy
= FRAME_X_DISPLAY (f
);
3827 struct x_output
*x
= FRAME_X_OUTPUT (f
);
3828 #ifdef USE_X_TOOLKIT
3831 if (FRAME_OUTER_WINDOW (f
))
3834 x
->hourglass_p
= true;
3836 if (!x
->hourglass_window
)
3838 unsigned long mask
= CWCursor
;
3839 XSetWindowAttributes attrs
;
3841 Window parent
= FRAME_X_WINDOW (f
);
3843 Window parent
= FRAME_OUTER_WINDOW (f
);
3845 attrs
.cursor
= x
->hourglass_cursor
;
3847 x
->hourglass_window
= XCreateWindow
3848 (dpy
, parent
, 0, 0, 32000, 32000, 0, 0,
3849 InputOnly
, CopyFromParent
, mask
, &attrs
);
3852 XMapRaised (dpy
, x
->hourglass_window
);
3858 /* RIF: Cancel hourglass cursor on frame F. */
3861 x_hide_hourglass (struct frame
*f
)
3863 struct x_output
*x
= FRAME_X_OUTPUT (f
);
3865 /* Watch out for newly created frames. */
3866 if (x
->hourglass_window
)
3868 XUnmapWindow (FRAME_X_DISPLAY (f
), x
->hourglass_window
);
3869 /* Sync here because XTread_socket looks at the
3870 hourglass_p flag that is reset to zero below. */
3871 XSync (FRAME_X_DISPLAY (f
), False
);
3872 x
->hourglass_p
= false;
3876 /* Invert the middle quarter of the frame for .15 sec. */
3879 XTflash (struct frame
*f
)
3885 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
3886 when the scroll bars and the edit widget share the same X window. */
3887 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
3889 cairo_t
*cr
= gdk_cairo_create (window
);
3890 cairo_set_source_rgb (cr
, 1, 1, 1);
3891 cairo_set_operator (cr
, CAIRO_OPERATOR_DIFFERENCE
);
3892 #define XFillRectangle(d, win, gc, x, y, w, h) \
3894 cairo_rectangle (cr, x, y, w, h); \
3898 #else /* ! HAVE_GTK3 */
3901 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
3902 ^ FRAME_BACKGROUND_PIXEL (f
));
3903 vals
.function
= GDK_XOR
;
3904 gc
= gdk_gc_new_with_values (window
,
3905 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
3906 #define XFillRectangle(d, win, gc, x, y, w, h) \
3907 gdk_draw_rectangle (window, gc, true, x, y, w, h)
3908 #endif /* ! HAVE_GTK3 */
3909 #else /* ! USE_GTK */
3912 /* Create a GC that will use the GXxor function to flip foreground
3913 pixels into background pixels. */
3917 values
.function
= GXxor
;
3918 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
3919 ^ FRAME_BACKGROUND_PIXEL (f
));
3921 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3922 GCFunction
| GCForeground
, &values
);
3926 /* Get the height not including a menu bar widget. */
3927 int height
= FRAME_PIXEL_HEIGHT (f
);
3928 /* Height of each line to flash. */
3929 int flash_height
= FRAME_LINE_HEIGHT (f
);
3930 /* These will be the left and right margins of the rectangles. */
3931 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3932 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
3933 int width
= flash_right
- flash_left
;
3935 /* If window is tall, flash top and bottom line. */
3936 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3938 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3940 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3941 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3942 width
, flash_height
);
3943 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3945 (height
- flash_height
3946 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3947 width
, flash_height
);
3951 /* If it is short, flash it all. */
3952 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3953 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3954 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3959 struct timespec delay
= make_timespec (0, 150 * 1000 * 1000);
3960 struct timespec wakeup
= timespec_add (current_timespec (), delay
);
3962 /* Keep waiting until past the time wakeup or any input gets
3964 while (! detect_input_pending ())
3966 struct timespec current
= current_timespec ();
3967 struct timespec timeout
;
3969 /* Break if result would not be positive. */
3970 if (timespec_cmp (wakeup
, current
) <= 0)
3973 /* How long `select' should wait. */
3974 timeout
= make_timespec (0, 10 * 1000 * 1000);
3976 /* Try to wait that long--but we might wake up sooner. */
3977 pselect (0, NULL
, NULL
, NULL
, &timeout
, NULL
);
3981 /* If window is tall, flash top and bottom line. */
3982 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3984 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3986 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3987 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3988 width
, flash_height
);
3989 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3991 (height
- flash_height
3992 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3993 width
, flash_height
);
3996 /* If it is short, flash it all. */
3997 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3998 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3999 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
4005 g_object_unref (G_OBJECT (gc
));
4007 #undef XFillRectangle
4009 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
4020 XTtoggle_invisible_pointer (struct frame
*f
, bool invisible
)
4023 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, invisible
);
4028 /* Make audible bell. */
4031 XTring_bell (struct frame
*f
)
4033 if (FRAME_X_DISPLAY (f
))
4041 XkbBell (FRAME_X_DISPLAY (f
), None
, 0, None
);
4043 XBell (FRAME_X_DISPLAY (f
), 0);
4045 XFlush (FRAME_X_DISPLAY (f
));
4051 /***********************************************************************
4053 ***********************************************************************/
4055 /* Perform an insert-lines or delete-lines operation, inserting N
4056 lines or deleting -N lines at vertical position VPOS. */
4059 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
4065 /* Scroll part of the display as described by RUN. */
4068 x_scroll_run (struct window
*w
, struct run
*run
)
4070 struct frame
*f
= XFRAME (w
->frame
);
4071 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
4073 /* Get frame-relative bounding box of the text display area of W,
4074 without mode lines. Include in this box the left and right
4076 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
4078 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
4079 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
4080 bottom_y
= y
+ height
;
4084 /* Scrolling up. Make sure we don't copy part of the mode
4085 line at the bottom. */
4086 if (from_y
+ run
->height
> bottom_y
)
4087 height
= bottom_y
- from_y
;
4089 height
= run
->height
;
4093 /* Scrolling down. Make sure we don't copy over the mode line.
4095 if (to_y
+ run
->height
> bottom_y
)
4096 height
= bottom_y
- to_y
;
4098 height
= run
->height
;
4103 /* Cursor off. Will be switched on again in x_update_window_end. */
4107 SET_FRAME_GARBAGED (f
);
4109 XCopyArea (FRAME_X_DISPLAY (f
),
4110 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
4111 f
->output_data
.x
->normal_gc
,
4122 /***********************************************************************
4124 ***********************************************************************/
4128 frame_highlight (struct frame
*f
)
4130 /* We used to only do this if Vx_no_window_manager was non-nil, but
4131 the ICCCM (section 4.1.6) says that the window's border pixmap
4132 and border pixel are window attributes which are "private to the
4133 client", so we can always change it to whatever we want. */
4135 /* I recently started to get errors in this XSetWindowBorder, depending on
4136 the window-manager in use, tho something more is at play since I've been
4137 using that same window-manager binary for ever. Let's not crash just
4138 because of this (bug#9310). */
4139 x_catch_errors (FRAME_X_DISPLAY (f
));
4140 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4141 f
->output_data
.x
->border_pixel
);
4142 x_uncatch_errors ();
4144 x_update_cursor (f
, true);
4145 x_set_frame_alpha (f
);
4149 frame_unhighlight (struct frame
*f
)
4151 /* We used to only do this if Vx_no_window_manager was non-nil, but
4152 the ICCCM (section 4.1.6) says that the window's border pixmap
4153 and border pixel are window attributes which are "private to the
4154 client", so we can always change it to whatever we want. */
4156 /* Same as above for XSetWindowBorder (bug#9310). */
4157 x_catch_errors (FRAME_X_DISPLAY (f
));
4158 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4159 f
->output_data
.x
->border_tile
);
4160 x_uncatch_errors ();
4162 x_update_cursor (f
, true);
4163 x_set_frame_alpha (f
);
4166 /* The focus has changed. Update the frames as necessary to reflect
4167 the new situation. Note that we can't change the selected frame
4168 here, because the Lisp code we are interrupting might become confused.
4169 Each event gets marked with the frame in which it occurred, so the
4170 Lisp code can tell when the switch took place by examining the events. */
4173 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
4175 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
4177 if (frame
!= dpyinfo
->x_focus_frame
)
4179 /* Set this before calling other routines, so that they see
4180 the correct value of x_focus_frame. */
4181 dpyinfo
->x_focus_frame
= frame
;
4183 if (old_focus
&& old_focus
->auto_lower
)
4184 x_lower_frame (old_focus
);
4186 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
4187 dpyinfo
->x_pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
4189 dpyinfo
->x_pending_autoraise_frame
= NULL
;
4192 x_frame_rehighlight (dpyinfo
);
4195 /* Handle FocusIn and FocusOut state changes for FRAME.
4196 If FRAME has focus and there exists more than one frame, puts
4197 a FOCUS_IN_EVENT into *BUFP. */
4200 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
4202 if (type
== FocusIn
)
4204 if (dpyinfo
->x_focus_event_frame
!= frame
)
4206 x_new_focus_frame (dpyinfo
, frame
);
4207 dpyinfo
->x_focus_event_frame
= frame
;
4209 /* Don't stop displaying the initial startup message
4210 for a switch-frame event we don't need. */
4211 /* When run as a daemon, Vterminal_frame is always NIL. */
4212 bufp
->arg
= (((NILP (Vterminal_frame
)
4213 || ! FRAME_X_P (XFRAME (Vterminal_frame
))
4214 || EQ (Fdaemonp (), Qt
))
4215 && CONSP (Vframe_list
)
4216 && !NILP (XCDR (Vframe_list
)))
4218 bufp
->kind
= FOCUS_IN_EVENT
;
4219 XSETFRAME (bufp
->frame_or_window
, frame
);
4222 frame
->output_data
.x
->focus_state
|= state
;
4225 if (FRAME_XIC (frame
))
4226 XSetICFocus (FRAME_XIC (frame
));
4229 else if (type
== FocusOut
)
4231 frame
->output_data
.x
->focus_state
&= ~state
;
4233 if (dpyinfo
->x_focus_event_frame
== frame
)
4235 dpyinfo
->x_focus_event_frame
= 0;
4236 x_new_focus_frame (dpyinfo
, 0);
4238 bufp
->kind
= FOCUS_OUT_EVENT
;
4239 XSETFRAME (bufp
->frame_or_window
, frame
);
4243 if (FRAME_XIC (frame
))
4244 XUnsetICFocus (FRAME_XIC (frame
));
4246 if (frame
->pointer_invisible
)
4247 XTtoggle_invisible_pointer (frame
, false);
4251 /* Return the Emacs frame-object corresponding to an X window.
4252 It could be the frame's main window or an icon window. */
4254 static struct frame
*
4255 x_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4257 Lisp_Object tail
, frame
;
4263 FOR_EACH_FRAME (tail
, frame
)
4266 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4268 if (f
->output_data
.x
->hourglass_window
== wdesc
)
4270 #ifdef USE_X_TOOLKIT
4271 if ((f
->output_data
.x
->edit_widget
4272 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
4273 /* A tooltip frame? */
4274 || (!f
->output_data
.x
->edit_widget
4275 && FRAME_X_WINDOW (f
) == wdesc
)
4276 || f
->output_data
.x
->icon_desc
== wdesc
)
4278 #else /* not USE_X_TOOLKIT */
4280 if (f
->output_data
.x
->edit_widget
)
4282 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4283 struct x_output
*x
= f
->output_data
.x
;
4284 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
4287 #endif /* USE_GTK */
4288 if (FRAME_X_WINDOW (f
) == wdesc
4289 || f
->output_data
.x
->icon_desc
== wdesc
)
4291 #endif /* not USE_X_TOOLKIT */
4296 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
4298 /* Like x_window_to_frame but also compares the window with the widget's
4301 static struct frame
*
4302 x_any_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4304 Lisp_Object tail
, frame
;
4305 struct frame
*f
, *found
= NULL
;
4311 FOR_EACH_FRAME (tail
, frame
)
4316 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
4318 /* This frame matches if the window is any of its widgets. */
4319 x
= f
->output_data
.x
;
4320 if (x
->hourglass_window
== wdesc
)
4325 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4327 && gtk_widget_get_toplevel (gwdesc
) == x
->widget
)
4330 if (wdesc
== XtWindow (x
->widget
)
4331 || wdesc
== XtWindow (x
->column_widget
)
4332 || wdesc
== XtWindow (x
->edit_widget
))
4334 /* Match if the window is this frame's menubar. */
4335 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
4339 else if (FRAME_X_WINDOW (f
) == wdesc
)
4340 /* A tooltip frame. */
4348 /* Likewise, but consider only the menu bar widget. */
4350 static struct frame
*
4351 x_menubar_window_to_frame (struct x_display_info
*dpyinfo
,
4352 const XEvent
*event
)
4354 Window wdesc
= event
->xany
.window
;
4355 Lisp_Object tail
, frame
;
4362 FOR_EACH_FRAME (tail
, frame
)
4365 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4367 x
= f
->output_data
.x
;
4369 if (x
->menubar_widget
&& xg_event_is_for_menubar (f
, event
))
4372 /* Match if the window is this frame's menubar. */
4373 if (x
->menubar_widget
4374 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
4381 /* Return the frame whose principal (outermost) window is WDESC.
4382 If WDESC is some other (smaller) window, we return 0. */
4385 x_top_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4387 Lisp_Object tail
, frame
;
4394 FOR_EACH_FRAME (tail
, frame
)
4397 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4399 x
= f
->output_data
.x
;
4403 /* This frame matches if the window is its topmost widget. */
4405 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4406 if (gwdesc
== x
->widget
)
4409 if (wdesc
== XtWindow (x
->widget
))
4413 else if (FRAME_X_WINDOW (f
) == wdesc
)
4414 /* Tooltip frame. */
4420 #else /* !USE_X_TOOLKIT && !USE_GTK */
4422 #define x_any_window_to_frame(d, i) x_window_to_frame (d, i)
4423 #define x_top_window_to_frame(d, i) x_window_to_frame (d, i)
4425 #endif /* USE_X_TOOLKIT || USE_GTK */
4427 /* The focus may have changed. Figure out if it is a real focus change,
4428 by checking both FocusIn/Out and Enter/LeaveNotify events.
4430 Returns FOCUS_IN_EVENT event in *BUFP. */
4433 x_detect_focus_change (struct x_display_info
*dpyinfo
, struct frame
*frame
,
4434 const XEvent
*event
, struct input_event
*bufp
)
4439 switch (event
->type
)
4444 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
4446 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
4448 if (event
->xcrossing
.detail
!= NotifyInferior
4449 && event
->xcrossing
.focus
4450 && ! (focus_state
& FOCUS_EXPLICIT
))
4451 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
4453 dpyinfo
, frame
, bufp
);
4459 x_focus_changed (event
->type
,
4460 (event
->xfocus
.detail
== NotifyPointer
?
4461 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
4462 dpyinfo
, frame
, bufp
);
4466 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
4468 enum xembed_message msg
= event
->xclient
.data
.l
[1];
4469 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
4470 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
4477 #if !defined USE_X_TOOLKIT && !defined USE_GTK
4478 /* Handle an event saying the mouse has moved out of an Emacs frame. */
4481 x_mouse_leave (struct x_display_info
*dpyinfo
)
4483 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
4487 /* The focus has changed, or we have redirected a frame's focus to
4488 another frame (this happens when a frame uses a surrogate
4489 mini-buffer frame). Shift the highlight as appropriate.
4491 The FRAME argument doesn't necessarily have anything to do with which
4492 frame is being highlighted or un-highlighted; we only use it to find
4493 the appropriate X display info. */
4496 XTframe_rehighlight (struct frame
*frame
)
4498 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
4502 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
4504 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
4506 if (dpyinfo
->x_focus_frame
)
4508 dpyinfo
->x_highlight_frame
4509 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
4510 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
4511 : dpyinfo
->x_focus_frame
);
4512 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
4514 fset_focus_frame (dpyinfo
->x_focus_frame
, Qnil
);
4515 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
4519 dpyinfo
->x_highlight_frame
= 0;
4521 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
4524 frame_unhighlight (old_highlight
);
4525 if (dpyinfo
->x_highlight_frame
)
4526 frame_highlight (dpyinfo
->x_highlight_frame
);
4532 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
4534 /* Initialize mode_switch_bit and modifier_meaning. */
4536 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
4538 int min_code
, max_code
;
4541 XModifierKeymap
*mods
;
4543 dpyinfo
->meta_mod_mask
= 0;
4544 dpyinfo
->shift_lock_mask
= 0;
4545 dpyinfo
->alt_mod_mask
= 0;
4546 dpyinfo
->super_mod_mask
= 0;
4547 dpyinfo
->hyper_mod_mask
= 0;
4549 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
4551 syms
= XGetKeyboardMapping (dpyinfo
->display
,
4552 min_code
, max_code
- min_code
+ 1,
4554 mods
= XGetModifierMapping (dpyinfo
->display
);
4556 /* Scan the modifier table to see which modifier bits the Meta and
4557 Alt keysyms are on. */
4559 int row
, col
; /* The row and column in the modifier table. */
4560 bool found_alt_or_meta
;
4562 for (row
= 3; row
< 8; row
++)
4564 found_alt_or_meta
= false;
4565 for (col
= 0; col
< mods
->max_keypermod
; col
++)
4567 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
4569 /* Zeroes are used for filler. Skip them. */
4573 /* Are any of this keycode's keysyms a meta key? */
4577 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
4579 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
4585 found_alt_or_meta
= true;
4586 dpyinfo
->meta_mod_mask
|= (1 << row
);
4591 found_alt_or_meta
= true;
4592 dpyinfo
->alt_mod_mask
|= (1 << row
);
4597 if (!found_alt_or_meta
)
4598 dpyinfo
->hyper_mod_mask
|= (1 << row
);
4599 code_col
= syms_per_code
;
4600 col
= mods
->max_keypermod
;
4605 if (!found_alt_or_meta
)
4606 dpyinfo
->super_mod_mask
|= (1 << row
);
4607 code_col
= syms_per_code
;
4608 col
= mods
->max_keypermod
;
4612 /* Ignore this if it's not on the lock modifier. */
4613 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
4614 dpyinfo
->shift_lock_mask
= LockMask
;
4615 code_col
= syms_per_code
;
4616 col
= mods
->max_keypermod
;
4625 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
4626 if (! dpyinfo
->meta_mod_mask
)
4628 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
4629 dpyinfo
->alt_mod_mask
= 0;
4632 /* If some keys are both alt and meta,
4633 make them just meta, not alt. */
4634 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
4636 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
4640 XFreeModifiermap (mods
);
4643 /* Convert between the modifier bits X uses and the modifier bits
4647 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, int state
)
4649 int mod_meta
= meta_modifier
;
4650 int mod_alt
= alt_modifier
;
4651 int mod_hyper
= hyper_modifier
;
4652 int mod_super
= super_modifier
;
4655 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
4656 if (INTEGERP (tem
)) mod_alt
= XINT (tem
) & INT_MAX
;
4657 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
4658 if (INTEGERP (tem
)) mod_meta
= XINT (tem
) & INT_MAX
;
4659 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
4660 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
) & INT_MAX
;
4661 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
4662 if (INTEGERP (tem
)) mod_super
= XINT (tem
) & INT_MAX
;
4664 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
4665 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
4666 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
4667 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
4668 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
4669 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
4673 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, EMACS_INT state
)
4675 EMACS_INT mod_meta
= meta_modifier
;
4676 EMACS_INT mod_alt
= alt_modifier
;
4677 EMACS_INT mod_hyper
= hyper_modifier
;
4678 EMACS_INT mod_super
= super_modifier
;
4682 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
4683 if (INTEGERP (tem
)) mod_alt
= XINT (tem
);
4684 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
4685 if (INTEGERP (tem
)) mod_meta
= XINT (tem
);
4686 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
4687 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
);
4688 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
4689 if (INTEGERP (tem
)) mod_super
= XINT (tem
);
4692 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
4693 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
4694 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
4695 | ((state
& shift_modifier
) ? ShiftMask
: 0)
4696 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
4697 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
4700 /* Convert a keysym to its name. */
4703 x_get_keysym_name (int keysym
)
4708 value
= XKeysymToString (keysym
);
4714 /* Mouse clicks and mouse movement. Rah.
4716 Formerly, we used PointerMotionHintMask (in standard_event_mask)
4717 so that we would have to call XQueryPointer after each MotionNotify
4718 event to ask for another such event. However, this made mouse tracking
4719 slow, and there was a bug that made it eventually stop.
4721 Simply asking for MotionNotify all the time seems to work better.
4723 In order to avoid asking for motion events and then throwing most
4724 of them away or busy-polling the server for mouse positions, we ask
4725 the server for pointer motion hints. This means that we get only
4726 one event per group of mouse movements. "Groups" are delimited by
4727 other kinds of events (focus changes and button clicks, for
4728 example), or by XQueryPointer calls; when one of these happens, we
4729 get another MotionNotify event the next time the mouse moves. This
4730 is at least as efficient as getting motion events when mouse
4731 tracking is on, and I suspect only negligibly worse when tracking
4734 /* Prepare a mouse-event in *RESULT for placement in the input queue.
4736 If the event is a button press, then note that we have grabbed
4740 construct_mouse_click (struct input_event
*result
,
4741 const XButtonEvent
*event
,
4744 /* Make the event type NO_EVENT; we'll change that when we decide
4746 result
->kind
= MOUSE_CLICK_EVENT
;
4747 result
->code
= event
->button
- Button1
;
4748 result
->timestamp
= event
->time
;
4749 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
),
4751 | (event
->type
== ButtonRelease
4755 XSETINT (result
->x
, event
->x
);
4756 XSETINT (result
->y
, event
->y
);
4757 XSETFRAME (result
->frame_or_window
, f
);
4762 /* Function to report a mouse movement to the mainstream Emacs code.
4763 The input handler calls this.
4765 We have received a mouse movement event, which is given in *event.
4766 If the mouse is over a different glyph than it was last time, tell
4767 the mainstream emacs code by setting mouse_moved. If not, ask for
4768 another motion event, so we can check again the next time it moves. */
4771 note_mouse_movement (struct frame
*frame
, const XMotionEvent
*event
)
4774 struct x_display_info
*dpyinfo
;
4776 if (!FRAME_X_OUTPUT (frame
))
4779 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
4780 dpyinfo
->last_mouse_movement_time
= event
->time
;
4781 dpyinfo
->last_mouse_motion_frame
= frame
;
4782 dpyinfo
->last_mouse_motion_x
= event
->x
;
4783 dpyinfo
->last_mouse_motion_y
= event
->y
;
4785 if (event
->window
!= FRAME_X_WINDOW (frame
))
4787 frame
->mouse_moved
= true;
4788 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4789 note_mouse_highlight (frame
, -1, -1);
4790 dpyinfo
->last_mouse_glyph_frame
= NULL
;
4795 /* Has the mouse moved off the glyph it was on at the last sighting? */
4796 r
= &dpyinfo
->last_mouse_glyph
;
4797 if (frame
!= dpyinfo
->last_mouse_glyph_frame
4798 || event
->x
< r
->x
|| event
->x
>= r
->x
+ r
->width
4799 || event
->y
< r
->y
|| event
->y
>= r
->y
+ r
->height
)
4801 frame
->mouse_moved
= true;
4802 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4803 note_mouse_highlight (frame
, event
->x
, event
->y
);
4804 /* Remember which glyph we're now on. */
4805 remember_mouse_glyph (frame
, event
->x
, event
->y
, r
);
4806 dpyinfo
->last_mouse_glyph_frame
= frame
;
4813 /* Return the current position of the mouse.
4814 *FP should be a frame which indicates which display to ask about.
4816 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
4817 and *PART to the frame, window, and scroll bar part that the mouse
4818 is over. Set *X and *Y to the portion and whole of the mouse's
4819 position on the scroll bar.
4821 If the mouse movement started elsewhere, set *FP to the frame the
4822 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
4825 Set *TIMESTAMP to the server time-stamp for the time at which the mouse
4826 was at this position.
4828 Don't store anything if we don't have a valid set of values to report.
4830 This clears the mouse_moved flag, so we can wait for the next mouse
4834 XTmouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
4835 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
4839 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4843 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
4845 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4847 if (bar
->horizontal
)
4848 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
4850 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
4857 Window dummy_window
;
4860 Lisp_Object frame
, tail
;
4862 /* Clear the mouse-moved flag for every frame on this display. */
4863 FOR_EACH_FRAME (tail
, frame
)
4864 if (FRAME_X_P (XFRAME (frame
))
4865 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
4866 XFRAME (frame
)->mouse_moved
= false;
4868 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4870 /* Figure out which root window we're on. */
4871 XQueryPointer (FRAME_X_DISPLAY (*fp
),
4872 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
4874 /* The root window which contains the pointer. */
4877 /* Trash which we can't trust if the pointer is on
4878 a different screen. */
4881 /* The position on that root window. */
4884 /* More trash we can't trust. */
4887 /* Modifier keys and pointer buttons, about which
4889 (unsigned int *) &dummy
);
4891 /* Now we have a position on the root; find the innermost window
4892 containing the pointer. */
4896 int parent_x
= 0, parent_y
= 0;
4900 /* XTranslateCoordinates can get errors if the window
4901 structure is changing at the same time this function
4902 is running. So at least we must not crash from them. */
4904 x_catch_errors (FRAME_X_DISPLAY (*fp
));
4906 if (x_mouse_grabbed (dpyinfo
))
4908 /* If mouse was grabbed on a frame, give coords for that frame
4909 even if the mouse is now outside it. */
4910 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4916 FRAME_X_WINDOW (dpyinfo
->last_mouse_frame
),
4918 /* From-position, to-position. */
4919 root_x
, root_y
, &win_x
, &win_y
,
4923 f1
= dpyinfo
->last_mouse_frame
;
4929 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4931 /* From-window, to-window. */
4934 /* From-position, to-position. */
4935 root_x
, root_y
, &win_x
, &win_y
,
4940 if (child
== None
|| child
== win
)
4943 /* We don't wan't to know the innermost window. We
4944 want the edit window. For non-Gtk+ the innermost
4945 window is the edit window. For Gtk+ it might not
4946 be. It might be the tool bar for example. */
4947 if (x_window_to_frame (dpyinfo
, win
))
4955 /* Now we know that:
4956 win is the innermost window containing the pointer
4957 (XTC says it has no child containing the pointer),
4958 win_x and win_y are the pointer's position in it
4959 (XTC did this the last time through), and
4960 parent_x and parent_y are the pointer's position in win's parent.
4961 (They are what win_x and win_y were when win was child.
4962 If win is the root window, it has no parent, and
4963 parent_{x,y} are invalid, but that's okay, because we'll
4964 never use them in that case.) */
4967 /* We don't wan't to know the innermost window. We
4968 want the edit window. */
4969 f1
= x_window_to_frame (dpyinfo
, win
);
4971 /* Is win one of our frames? */
4972 f1
= x_any_window_to_frame (dpyinfo
, win
);
4975 #ifdef USE_X_TOOLKIT
4976 /* If we end up with the menu bar window, say it's not
4979 && f1
->output_data
.x
->menubar_widget
4980 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
4982 #endif /* USE_X_TOOLKIT */
4985 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
4988 x_uncatch_errors_after_check ();
4990 /* If not, is it one of our scroll bars? */
4993 struct scroll_bar
*bar
;
4995 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
, 2);
4999 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5005 if (f1
== 0 && insist
> 0)
5006 f1
= SELECTED_FRAME ();
5010 /* Ok, we found a frame. Store all the values.
5011 last_mouse_glyph is a rectangle used to reduce the
5012 generation of mouse events. To not miss any motion
5013 events, we must divide the frame into rectangles of the
5014 size of the smallest character that could be displayed
5015 on it, i.e. into the same rectangles that matrices on
5016 the frame are divided into. */
5018 /* FIXME: what if F1 is not an X frame? */
5019 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
5020 remember_mouse_glyph (f1
, win_x
, win_y
, &dpyinfo
->last_mouse_glyph
);
5021 dpyinfo
->last_mouse_glyph_frame
= f1
;
5026 XSETINT (*x
, win_x
);
5027 XSETINT (*y
, win_y
);
5028 *timestamp
= dpyinfo
->last_mouse_movement_time
;
5038 /***********************************************************************
5040 ***********************************************************************/
5042 /* Scroll bar support. */
5044 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
5046 This can be called in GC, so we have to make sure to strip off mark
5049 static struct scroll_bar
*
5050 x_window_to_scroll_bar (Display
*display
, Window window_id
, int type
)
5052 Lisp_Object tail
, frame
;
5054 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
5055 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
5056 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
5058 FOR_EACH_FRAME (tail
, frame
)
5060 Lisp_Object bar
, condemned
;
5062 if (! FRAME_X_P (XFRAME (frame
)))
5065 /* Scan this frame's scroll bar list for a scroll bar with the
5067 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
5068 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
5069 /* This trick allows us to search both the ordinary and
5070 condemned scroll bar lists with one loop. */
5071 ! NILP (bar
) || (bar
= condemned
,
5074 bar
= XSCROLL_BAR (bar
)->next
)
5075 if (XSCROLL_BAR (bar
)->x_window
== window_id
5076 && FRAME_X_DISPLAY (XFRAME (frame
)) == display
5078 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
5079 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
5080 return XSCROLL_BAR (bar
);
5087 #if defined USE_LUCID
5089 /* Return the Lucid menu bar WINDOW is part of. Return null
5090 if WINDOW is not part of a menu bar. */
5093 x_window_to_menu_bar (Window window
)
5095 Lisp_Object tail
, frame
;
5097 FOR_EACH_FRAME (tail
, frame
)
5098 if (FRAME_X_P (XFRAME (frame
)))
5100 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
5102 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
5108 #endif /* USE_LUCID */
5111 /************************************************************************
5113 ************************************************************************/
5115 #ifdef USE_TOOLKIT_SCROLL_BARS
5117 static void x_send_scroll_bar_event (Lisp_Object
, enum scroll_bar_part
,
5120 /* Lisp window being scrolled. Set when starting to interact with
5121 a toolkit scroll bar, reset to nil when ending the interaction. */
5123 static Lisp_Object window_being_scrolled
;
5125 /* Whether this is an Xaw with arrow-scrollbars. This should imply
5126 that movements of 1/20 of the screen size are mapped to up/down. */
5129 /* Id of action hook installed for scroll bars. */
5131 static XtActionHookId action_hook_id
;
5132 static XtActionHookId horizontal_action_hook_id
;
5134 static Boolean xaw3d_arrow_scroll
;
5136 /* Whether the drag scrolling maintains the mouse at the top of the
5137 thumb. If not, resizing the thumb needs to be done more carefully
5138 to avoid jerkiness. */
5140 static Boolean xaw3d_pick_top
;
5142 /* Action hook installed via XtAppAddActionHook when toolkit scroll
5143 bars are used.. The hook is responsible for detecting when
5144 the user ends an interaction with the scroll bar, and generates
5145 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
5148 xt_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
5149 XEvent
*event
, String
*params
, Cardinal
*num_params
)
5152 const char *end_action
;
5155 scroll_bar_p
= XmIsScrollBar (widget
);
5156 end_action
= "Release";
5157 #else /* !USE_MOTIF i.e. use Xaw */
5158 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
5159 end_action
= "EndScroll";
5160 #endif /* USE_MOTIF */
5163 && strcmp (action_name
, end_action
) == 0
5164 && WINDOWP (window_being_scrolled
))
5167 struct scroll_bar
*bar
;
5169 x_send_scroll_bar_event (window_being_scrolled
,
5170 scroll_bar_end_scroll
, 0, 0, false);
5171 w
= XWINDOW (window_being_scrolled
);
5172 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5174 if (bar
->dragging
!= -1)
5177 /* The thumb size is incorrect while dragging: fix it. */
5178 set_vertical_scroll_bar (w
);
5180 window_being_scrolled
= Qnil
;
5181 #if defined (USE_LUCID)
5182 bar
->last_seen_part
= scroll_bar_nowhere
;
5184 /* Xt timeouts no longer needed. */
5185 toolkit_scroll_bar_interaction
= false;
5191 xt_horizontal_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
5192 XEvent
*event
, String
*params
, Cardinal
*num_params
)
5195 const char *end_action
;
5198 scroll_bar_p
= XmIsScrollBar (widget
);
5199 end_action
= "Release";
5200 #else /* !USE_MOTIF i.e. use Xaw */
5201 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
5202 end_action
= "EndScroll";
5203 #endif /* USE_MOTIF */
5206 && strcmp (action_name
, end_action
) == 0
5207 && WINDOWP (window_being_scrolled
))
5210 struct scroll_bar
*bar
;
5212 x_send_scroll_bar_event (window_being_scrolled
,
5213 scroll_bar_end_scroll
, 0, 0, true);
5214 w
= XWINDOW (window_being_scrolled
);
5215 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
5217 if (bar
->dragging
!= -1)
5220 /* The thumb size is incorrect while dragging: fix it. */
5221 set_horizontal_scroll_bar (w
);
5223 window_being_scrolled
= Qnil
;
5224 #if defined (USE_LUCID)
5225 bar
->last_seen_part
= scroll_bar_nowhere
;
5227 /* Xt timeouts no longer needed. */
5228 toolkit_scroll_bar_interaction
= false;
5231 #endif /* not USE_GTK */
5233 /* Send a client message with message type Xatom_Scrollbar for a
5234 scroll action to the frame of WINDOW. PART is a value identifying
5235 the part of the scroll bar that was clicked on. PORTION is the
5236 amount to scroll of a whole of WHOLE. */
5239 x_send_scroll_bar_event (Lisp_Object window
, enum scroll_bar_part part
,
5240 int portion
, int whole
, bool horizontal
)
5243 XClientMessageEvent
*ev
= &event
.xclient
;
5244 struct window
*w
= XWINDOW (window
);
5245 struct frame
*f
= XFRAME (w
->frame
);
5246 intptr_t iw
= (intptr_t) w
;
5247 enum { BITS_PER_INTPTR
= CHAR_BIT
* sizeof iw
};
5248 verify (BITS_PER_INTPTR
<= 64);
5249 int sign_shift
= BITS_PER_INTPTR
- 32;
5253 /* Construct a ClientMessage event to send to the frame. */
5254 ev
->type
= ClientMessage
;
5255 ev
->message_type
= (horizontal
5256 ? FRAME_DISPLAY_INFO (f
)->Xatom_Horizontal_Scrollbar
5257 : FRAME_DISPLAY_INFO (f
)->Xatom_Scrollbar
);
5258 ev
->display
= FRAME_X_DISPLAY (f
);
5259 ev
->window
= FRAME_X_WINDOW (f
);
5262 /* A 32-bit X client on a 64-bit X server can pass a window pointer
5263 as-is. A 64-bit client on a 32-bit X server is in trouble
5264 because a pointer does not fit and would be truncated while
5265 passing through the server. So use two slots and hope that X12
5266 will resolve such issues someday. */
5267 ev
->data
.l
[0] = iw
>> 31 >> 1;
5268 ev
->data
.l
[1] = sign_shift
<= 0 ? iw
: iw
<< sign_shift
>> sign_shift
;
5269 ev
->data
.l
[2] = part
;
5270 ev
->data
.l
[3] = portion
;
5271 ev
->data
.l
[4] = whole
;
5273 /* Make Xt timeouts work while the scroll bar is active. */
5274 #ifdef USE_X_TOOLKIT
5275 toolkit_scroll_bar_interaction
= true;
5276 x_activate_timeout_atimer ();
5279 /* Setting the event mask to zero means that the message will
5280 be sent to the client that created the window, and if that
5281 window no longer exists, no event will be sent. */
5282 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
5287 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
5291 x_scroll_bar_to_input_event (const XEvent
*event
,
5292 struct input_event
*ievent
)
5294 const XClientMessageEvent
*ev
= &event
->xclient
;
5298 /* See the comment in the function above. */
5299 intptr_t iw0
= ev
->data
.l
[0];
5300 intptr_t iw1
= ev
->data
.l
[1];
5301 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
5302 w
= (struct window
*) iw
;
5304 XSETWINDOW (window
, w
);
5306 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
5307 ievent
->frame_or_window
= window
;
5310 ievent
->timestamp
= CurrentTime
;
5313 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
5316 ievent
->part
= ev
->data
.l
[2];
5317 ievent
->x
= make_number (ev
->data
.l
[3]);
5318 ievent
->y
= make_number (ev
->data
.l
[4]);
5319 ievent
->modifiers
= 0;
5322 /* Transform a horizontal scroll bar ClientMessage EVENT to an Emacs
5323 input event in *IEVENT. */
5326 x_horizontal_scroll_bar_to_input_event (const XEvent
*event
,
5327 struct input_event
*ievent
)
5329 const XClientMessageEvent
*ev
= &event
->xclient
;
5333 /* See the comment in the function above. */
5334 intptr_t iw0
= ev
->data
.l
[0];
5335 intptr_t iw1
= ev
->data
.l
[1];
5336 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
5337 w
= (struct window
*) iw
;
5339 XSETWINDOW (window
, w
);
5341 ievent
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
5342 ievent
->frame_or_window
= window
;
5345 ievent
->timestamp
= CurrentTime
;
5348 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
5351 ievent
->part
= ev
->data
.l
[2];
5352 ievent
->x
= make_number (ev
->data
.l
[3]);
5353 ievent
->y
= make_number (ev
->data
.l
[4]);
5354 ievent
->modifiers
= 0;
5360 /* Minimum and maximum values used for Motif scroll bars. */
5362 #define XM_SB_MAX 10000000
5364 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
5365 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
5366 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
5369 xm_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5371 struct scroll_bar
*bar
= client_data
;
5372 XmScrollBarCallbackStruct
*cs
= call_data
;
5373 enum scroll_bar_part part
= scroll_bar_nowhere
;
5374 bool horizontal
= bar
->horizontal
;
5375 int whole
= 0, portion
= 0;
5379 case XmCR_DECREMENT
:
5381 part
= horizontal
? scroll_bar_left_arrow
: scroll_bar_up_arrow
;
5384 case XmCR_INCREMENT
:
5386 part
= horizontal
? scroll_bar_right_arrow
: scroll_bar_down_arrow
;
5389 case XmCR_PAGE_DECREMENT
:
5391 part
= horizontal
? scroll_bar_before_handle
: scroll_bar_above_handle
;
5394 case XmCR_PAGE_INCREMENT
:
5396 part
= horizontal
? scroll_bar_after_handle
: scroll_bar_below_handle
;
5401 part
= horizontal
? scroll_bar_to_leftmost
: scroll_bar_to_top
;
5404 case XmCR_TO_BOTTOM
:
5406 part
= horizontal
? scroll_bar_to_rightmost
: scroll_bar_to_bottom
;
5414 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
5419 portion
= bar
->whole
* ((float)cs
->value
/ XM_SB_MAX
);
5420 whole
= bar
->whole
* ((float)(XM_SB_MAX
- slider_size
) / XM_SB_MAX
);
5421 portion
= min (portion
, whole
);
5422 part
= scroll_bar_horizontal_handle
;
5426 whole
= XM_SB_MAX
- slider_size
;
5427 portion
= min (cs
->value
, whole
);
5428 part
= scroll_bar_handle
;
5431 bar
->dragging
= cs
->value
;
5435 case XmCR_VALUE_CHANGED
:
5439 if (part
!= scroll_bar_nowhere
)
5441 window_being_scrolled
= bar
->window
;
5442 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
,
5447 #elif defined USE_GTK
5449 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
5450 bar widget. DATA is a pointer to the scroll_bar structure. */
5453 xg_scroll_callback (GtkRange
*range
,
5454 GtkScrollType scroll
,
5458 int whole
= 0, portion
= 0;
5459 struct scroll_bar
*bar
= user_data
;
5460 enum scroll_bar_part part
= scroll_bar_nowhere
;
5461 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
5462 struct frame
*f
= g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
5464 if (xg_ignore_gtk_scrollbar
) return false;
5468 case GTK_SCROLL_JUMP
:
5469 /* Buttons 1 2 or 3 must be grabbed. */
5470 if (FRAME_DISPLAY_INFO (f
)->grabbed
!= 0
5471 && FRAME_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
5473 if (bar
->horizontal
)
5475 part
= scroll_bar_horizontal_handle
;
5476 whole
= (int)(gtk_adjustment_get_upper (adj
) -
5477 gtk_adjustment_get_page_size (adj
));
5478 portion
= min ((int)value
, whole
);
5479 bar
->dragging
= portion
;
5483 part
= scroll_bar_handle
;
5484 whole
= gtk_adjustment_get_upper (adj
) -
5485 gtk_adjustment_get_page_size (adj
);
5486 portion
= min ((int)value
, whole
);
5487 bar
->dragging
= portion
;
5491 case GTK_SCROLL_STEP_BACKWARD
:
5492 part
= (bar
->horizontal
5493 ? scroll_bar_left_arrow
: scroll_bar_up_arrow
);
5496 case GTK_SCROLL_STEP_FORWARD
:
5497 part
= (bar
->horizontal
5498 ? scroll_bar_right_arrow
: scroll_bar_down_arrow
);
5501 case GTK_SCROLL_PAGE_BACKWARD
:
5502 part
= (bar
->horizontal
5503 ? scroll_bar_before_handle
: scroll_bar_above_handle
);
5506 case GTK_SCROLL_PAGE_FORWARD
:
5507 part
= (bar
->horizontal
5508 ? scroll_bar_after_handle
: scroll_bar_below_handle
);
5515 if (part
!= scroll_bar_nowhere
)
5517 window_being_scrolled
= bar
->window
;
5518 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
,
5525 /* Callback for button release. Sets dragging to -1 when dragging is done. */
5528 xg_end_scroll_callback (GtkWidget
*widget
,
5529 GdkEventButton
*event
,
5532 struct scroll_bar
*bar
= user_data
;
5534 if (WINDOWP (window_being_scrolled
))
5536 x_send_scroll_bar_event (window_being_scrolled
,
5537 scroll_bar_end_scroll
, 0, 0, bar
->horizontal
);
5538 window_being_scrolled
= Qnil
;
5545 #else /* not USE_GTK and not USE_MOTIF */
5547 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
5548 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
5549 scroll bar struct. CALL_DATA is a pointer to a float saying where
5553 xaw_jump_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5555 struct scroll_bar
*bar
= client_data
;
5556 float *top_addr
= call_data
;
5557 float top
= *top_addr
;
5559 int whole
, portion
, height
, width
;
5560 enum scroll_bar_part part
;
5561 bool horizontal
= bar
->horizontal
;
5566 /* Get the size of the thumb, a value between 0 and 1. */
5568 XtVaGetValues (widget
, XtNshown
, &shown
, XtNwidth
, &width
, NULL
);
5573 whole
= bar
->whole
- (shown
* bar
->whole
);
5574 portion
= min (top
* bar
->whole
, whole
);
5582 part
= scroll_bar_horizontal_handle
;
5586 /* Get the size of the thumb, a value between 0 and 1. */
5588 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
5592 portion
= shown
< 1 ? top
* whole
: 0;
5594 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0f
/ height
))
5595 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
5596 the bottom, so we force the scrolling whenever we see that we're
5597 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
5598 we try to ensure that we always stay two pixels away from the
5600 part
= scroll_bar_down_arrow
;
5602 part
= scroll_bar_handle
;
5605 window_being_scrolled
= bar
->window
;
5606 bar
->dragging
= portion
;
5607 bar
->last_seen_part
= part
;
5608 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
, bar
->horizontal
);
5612 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
5613 i.e. line or page up or down. WIDGET is the Xaw scroll bar
5614 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
5615 the scroll bar. CALL_DATA is an integer specifying the action that
5616 has taken place. Its magnitude is in the range 0..height of the
5617 scroll bar. Negative values mean scroll towards buffer start.
5618 Values < height of scroll bar mean line-wise movement. */
5621 xaw_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5623 struct scroll_bar
*bar
= client_data
;
5624 /* The position really is stored cast to a pointer. */
5625 int position
= (intptr_t) call_data
;
5626 Dimension height
, width
;
5627 enum scroll_bar_part part
;
5629 if (bar
->horizontal
)
5631 /* Get the width of the scroll bar. */
5633 XtVaGetValues (widget
, XtNwidth
, &width
, NULL
);
5636 if (eabs (position
) >= width
)
5637 part
= (position
< 0) ? scroll_bar_before_handle
: scroll_bar_after_handle
;
5639 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
5640 it maps line-movement to call_data = max(5, height/20). */
5641 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, width
/ 20))
5642 part
= (position
< 0) ? scroll_bar_left_arrow
: scroll_bar_right_arrow
;
5644 part
= scroll_bar_move_ratio
;
5646 window_being_scrolled
= bar
->window
;
5648 bar
->last_seen_part
= part
;
5649 x_send_scroll_bar_event (bar
->window
, part
, position
, width
,
5655 /* Get the height of the scroll bar. */
5657 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
5660 if (eabs (position
) >= height
)
5661 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
5663 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
5664 it maps line-movement to call_data = max(5, height/20). */
5665 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
5666 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
5668 part
= scroll_bar_move_ratio
;
5670 window_being_scrolled
= bar
->window
;
5672 bar
->last_seen_part
= part
;
5673 x_send_scroll_bar_event (bar
->window
, part
, position
, height
,
5678 #endif /* not USE_GTK and not USE_MOTIF */
5680 #define SCROLL_BAR_NAME "verticalScrollBar"
5681 #define SCROLL_BAR_HORIZONTAL_NAME "horizontalScrollBar"
5683 /* Create the widget for scroll bar BAR on frame F. Record the widget
5684 and X window of the scroll bar in BAR. */
5688 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5690 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
5693 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
5694 G_CALLBACK (xg_end_scroll_callback
),
5700 x_create_horizontal_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5702 const char *scroll_bar_name
= SCROLL_BAR_HORIZONTAL_NAME
;
5705 xg_create_horizontal_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
5706 G_CALLBACK (xg_end_scroll_callback
),
5711 #else /* not USE_GTK */
5714 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5720 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
5721 unsigned long pixel
;
5726 /* Set resources. Create the widget. */
5727 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5728 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
5729 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
5730 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
5731 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
5732 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
5733 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
5735 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5738 XtSetArg (av
[ac
], XmNforeground
, pixel
);
5742 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5745 XtSetArg (av
[ac
], XmNbackground
, pixel
);
5749 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
5750 (char *) scroll_bar_name
, av
, ac
);
5752 /* Add one callback for everything that can happen. */
5753 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
5755 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
5757 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
5759 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
5761 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
5763 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
5765 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
5768 /* Realize the widget. Only after that is the X window created. */
5769 XtRealizeWidget (widget
);
5771 /* Set the cursor to an arrow. I didn't find a resource to do that.
5772 And I'm wondering why it hasn't an arrow cursor by default. */
5773 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
5774 f
->output_data
.x
->nontext_cursor
);
5776 #else /* !USE_MOTIF i.e. use Xaw */
5778 /* Set resources. Create the widget. The background of the
5779 Xaw3d scroll bar widget is a little bit light for my taste.
5780 We don't alter it here to let users change it according
5781 to their taste with `emacs*verticalScrollBar.background: xxx'. */
5782 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5783 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
5784 /* For smoother scrolling with Xaw3d -sm */
5785 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
5787 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5790 XtSetArg (av
[ac
], XtNforeground
, pixel
);
5794 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5797 XtSetArg (av
[ac
], XtNbackground
, pixel
);
5801 /* Top/bottom shadow colors. */
5803 /* Allocate them, if necessary. */
5804 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
5806 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5809 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5810 FRAME_X_COLORMAP (f
),
5811 &pixel
, 1.2, 0x8000))
5813 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
5816 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5818 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5821 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5822 FRAME_X_COLORMAP (f
),
5823 &pixel
, 0.6, 0x4000))
5825 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
5829 #ifdef XtNbeNiceToColormap
5830 /* Tell the toolkit about them. */
5831 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
5832 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5833 /* We tried to allocate a color for the top/bottom shadow, and
5834 failed, so tell Xaw3d to use dithering instead. */
5835 /* But only if we have a small colormap. Xaw3d can allocate nice
5838 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
5839 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
5843 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
5844 be more consistent with other emacs 3d colors, and since Xaw3d is
5845 not good at dealing with allocation failure. */
5847 /* This tells Xaw3d to use real colors instead of dithering for
5849 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
5852 /* Specify the colors. */
5853 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
5856 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
5859 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
5862 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
5868 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
5869 f
->output_data
.x
->edit_widget
, av
, ac
);
5872 char const *initial
= "";
5873 char const *val
= initial
;
5874 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
5875 #ifdef XtNarrowScrollbars
5876 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
5878 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
5879 if (xaw3d_arrow_scroll
|| val
== initial
)
5880 { /* ARROW_SCROLL */
5881 xaw3d_arrow_scroll
= True
;
5882 /* Isn't that just a personal preference ? --Stef */
5883 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
5887 /* Define callbacks. */
5888 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
5889 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
5892 /* Realize the widget. Only after that is the X window created. */
5893 XtRealizeWidget (widget
);
5895 #endif /* !USE_MOTIF */
5897 /* Install an action hook that lets us detect when the user
5898 finishes interacting with a scroll bar. */
5899 if (action_hook_id
== 0)
5900 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
5902 /* Remember X window and widget in the scroll bar vector. */
5903 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
5904 xwindow
= XtWindow (widget
);
5905 bar
->x_window
= xwindow
;
5907 bar
->horizontal
= false;
5913 x_create_horizontal_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5919 const char *scroll_bar_name
= SCROLL_BAR_HORIZONTAL_NAME
;
5920 unsigned long pixel
;
5925 /* Set resources. Create the widget. */
5926 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5927 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
5928 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
5929 XtSetArg (av
[ac
], XmNorientation
, XmHORIZONTAL
); ++ac
;
5930 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_RIGHT
), ++ac
;
5931 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
5932 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
5934 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5937 XtSetArg (av
[ac
], XmNforeground
, pixel
);
5941 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5944 XtSetArg (av
[ac
], XmNbackground
, pixel
);
5948 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
5949 (char *) scroll_bar_name
, av
, ac
);
5951 /* Add one callback for everything that can happen. */
5952 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
5954 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
5956 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
5958 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
5960 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
5962 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
5964 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
5967 /* Realize the widget. Only after that is the X window created. */
5968 XtRealizeWidget (widget
);
5970 /* Set the cursor to an arrow. I didn't find a resource to do that.
5971 And I'm wondering why it hasn't an arrow cursor by default. */
5972 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
5973 f
->output_data
.x
->nontext_cursor
);
5975 #else /* !USE_MOTIF i.e. use Xaw */
5977 /* Set resources. Create the widget. The background of the
5978 Xaw3d scroll bar widget is a little bit light for my taste.
5979 We don't alter it here to let users change it according
5980 to their taste with `emacs*verticalScrollBar.background: xxx'. */
5981 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5982 XtSetArg (av
[ac
], XtNorientation
, XtorientHorizontal
); ++ac
;
5983 /* For smoother scrolling with Xaw3d -sm */
5984 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
5986 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5989 XtSetArg (av
[ac
], XtNforeground
, pixel
);
5993 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5996 XtSetArg (av
[ac
], XtNbackground
, pixel
);
6000 /* Top/bottom shadow colors. */
6002 /* Allocate them, if necessary. */
6003 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
6005 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
6008 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
6009 FRAME_X_COLORMAP (f
),
6010 &pixel
, 1.2, 0x8000))
6012 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
6015 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
6017 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
6020 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
6021 FRAME_X_COLORMAP (f
),
6022 &pixel
, 0.6, 0x4000))
6024 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
6028 #ifdef XtNbeNiceToColormap
6029 /* Tell the toolkit about them. */
6030 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
6031 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
6032 /* We tried to allocate a color for the top/bottom shadow, and
6033 failed, so tell Xaw3d to use dithering instead. */
6034 /* But only if we have a small colormap. Xaw3d can allocate nice
6037 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
6038 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
6042 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
6043 be more consistent with other emacs 3d colors, and since Xaw3d is
6044 not good at dealing with allocation failure. */
6046 /* This tells Xaw3d to use real colors instead of dithering for
6048 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
6051 /* Specify the colors. */
6052 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
6055 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
6058 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
6061 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
6067 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
6068 f
->output_data
.x
->edit_widget
, av
, ac
);
6071 char const *initial
= "";
6072 char const *val
= initial
;
6073 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
6074 #ifdef XtNarrowScrollbars
6075 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
6077 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
6078 if (xaw3d_arrow_scroll
|| val
== initial
)
6079 { /* ARROW_SCROLL */
6080 xaw3d_arrow_scroll
= True
;
6081 /* Isn't that just a personal preference ? --Stef */
6082 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
6086 /* Define callbacks. */
6087 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
6088 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
6091 /* Realize the widget. Only after that is the X window created. */
6092 XtRealizeWidget (widget
);
6094 #endif /* !USE_MOTIF */
6096 /* Install an action hook that lets us detect when the user
6097 finishes interacting with a scroll bar. */
6098 if (horizontal_action_hook_id
== 0)
6099 horizontal_action_hook_id
6100 = XtAppAddActionHook (Xt_app_con
, xt_horizontal_action_hook
, 0);
6102 /* Remember X window and widget in the scroll bar vector. */
6103 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
6104 xwindow
= XtWindow (widget
);
6105 bar
->x_window
= xwindow
;
6107 bar
->horizontal
= true;
6111 #endif /* not USE_GTK */
6114 /* Set the thumb size and position of scroll bar BAR. We are currently
6115 displaying PORTION out of a whole WHOLE, and our position POSITION. */
6119 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
6121 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
6125 x_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
6127 xg_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
6130 #else /* not USE_GTK */
6132 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
6135 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6136 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6143 if (scroll_bar_adjust_thumb_portion_p
)
6145 /* We use an estimate of 30 chars per line rather than the real
6146 `portion' value. This has the disadvantage that the thumb size
6147 is not very representative, but it makes our life a lot easier.
6148 Otherwise, we have to constantly adjust the thumb size, which
6149 we can't always do quickly enough: while dragging, the size of
6150 the thumb might prevent the user from dragging the thumb all the
6151 way to the end. but Motif and some versions of Xaw3d don't allow
6152 updating the thumb size while dragging. Also, even if we can update
6153 its size, the update will often happen too late.
6154 If you don't believe it, check out revision 1.650 of xterm.c to see
6155 what hoops we were going through and the still poor behavior we got. */
6156 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
6157 /* When the thumb is at the bottom, position == whole.
6158 So we need to increase `whole' to make space for the thumb. */
6166 top
= (float) position
/ whole
;
6167 shown
= (float) portion
/ whole
;
6170 if (bar
->dragging
== -1)
6174 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
6175 is the scroll bar's maximum and MIN is the scroll bar's minimum
6177 size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
6179 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
6180 value
= top
* XM_SB_MAX
;
6181 value
= min (value
, XM_SB_MAX
- size
);
6183 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
6185 #else /* !USE_MOTIF i.e. use Xaw */
6191 top
= (float) position
/ whole
;
6192 shown
= (float) portion
/ whole
;
6196 float old_top
, old_shown
;
6198 XtVaGetValues (widget
,
6199 XtNtopOfThumb
, &old_top
,
6200 XtNshown
, &old_shown
,
6204 /* Massage the top+shown values. */
6205 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
6206 top
= max (0, min (1, top
));
6209 #if ! defined (HAVE_XAW3D)
6210 /* With Xaw, 'top' values too closer to 1.0 may
6211 cause the thumb to disappear. Fix that. */
6212 top
= min (top
, 0.99f
);
6214 /* Keep two pixels available for moving the thumb down. */
6215 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
6216 #if ! defined (HAVE_XAW3D)
6217 /* Likewise with too small 'shown'. */
6218 shown
= max (shown
, 0.01f
);
6221 /* If the call to XawScrollbarSetThumb below doesn't seem to
6222 work, check that 'NARROWPROTO' is defined in src/config.h.
6223 If this is not so, most likely you need to fix configure. */
6224 if (top
!= old_top
|| shown
!= old_shown
)
6226 if (bar
->dragging
== -1)
6227 XawScrollbarSetThumb (widget
, top
, shown
);
6230 /* Try to make the scrolling a tad smoother. */
6231 if (!xaw3d_pick_top
)
6232 shown
= min (shown
, old_shown
);
6234 XawScrollbarSetThumb (widget
, top
, shown
);
6238 #endif /* !USE_MOTIF */
6244 x_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
6247 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6248 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6255 shown
= (float) portion
/ whole
;
6256 top
= (float) position
/ (whole
- portion
);
6258 int size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
6259 int value
= clip_to_bounds (0, top
* (XM_SB_MAX
- size
), XM_SB_MAX
- size
);
6261 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
6263 #else /* !USE_MOTIF i.e. use Xaw */
6269 top
= (float) position
/ whole
;
6270 shown
= (float) portion
/ whole
;
6274 float old_top
, old_shown
;
6276 XtVaGetValues (widget
,
6277 XtNtopOfThumb
, &old_top
,
6278 XtNshown
, &old_shown
,
6283 /* Massage the top+shown values. */
6284 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
6285 top
= max (0, min (1, top
));
6288 #if ! defined (HAVE_XAW3D)
6289 /* With Xaw, 'top' values too closer to 1.0 may
6290 cause the thumb to disappear. Fix that. */
6291 top
= min (top
, 0.99f
);
6293 /* Keep two pixels available for moving the thumb down. */
6294 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
6295 #if ! defined (HAVE_XAW3D)
6296 /* Likewise with too small 'shown'. */
6297 shown
= max (shown
, 0.01f
);
6301 /* If the call to XawScrollbarSetThumb below doesn't seem to
6302 work, check that 'NARROWPROTO' is defined in src/config.h.
6303 If this is not so, most likely you need to fix configure. */
6304 XawScrollbarSetThumb (widget
, top
, shown
);
6306 if (top
!= old_top
|| shown
!= old_shown
)
6308 if (bar
->dragging
== -1)
6309 XawScrollbarSetThumb (widget
, top
, shown
);
6312 /* Try to make the scrolling a tad smoother. */
6313 if (!xaw3d_pick_top
)
6314 shown
= min (shown
, old_shown
);
6316 XawScrollbarSetThumb (widget
, top
, shown
);
6321 #endif /* !USE_MOTIF */
6325 #endif /* not USE_GTK */
6327 #endif /* USE_TOOLKIT_SCROLL_BARS */
6331 /************************************************************************
6332 Scroll bars, general
6333 ************************************************************************/
6335 /* Create a scroll bar and return the scroll bar vector for it. W is
6336 the Emacs window on which to create the scroll bar. TOP, LEFT,
6337 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
6340 static struct scroll_bar
*
6341 x_scroll_bar_create (struct window
*w
, int top
, int left
,
6342 int width
, int height
, bool horizontal
)
6344 struct frame
*f
= XFRAME (w
->frame
);
6345 struct scroll_bar
*bar
6346 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
6351 #ifdef USE_TOOLKIT_SCROLL_BARS
6353 x_create_horizontal_toolkit_scroll_bar (f
, bar
);
6355 x_create_toolkit_scroll_bar (f
, bar
);
6356 #else /* not USE_TOOLKIT_SCROLL_BARS */
6358 XSetWindowAttributes a
;
6362 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
6363 if (a
.background_pixel
== -1)
6364 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
6366 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
6367 | ButtonMotionMask
| PointerMotionHintMask
6369 a
.cursor
= FRAME_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
6371 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
6373 /* Clear the area of W that will serve as a scroll bar. This is
6374 for the case that a window has been split horizontally. In
6375 this case, no clear_frame is generated to reduce flickering. */
6376 if (width
> 0 && window_box_height (w
) > 0)
6377 x_clear_area (f
, left
, top
, width
, window_box_height (w
));
6379 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6380 /* Position and size of scroll bar. */
6381 left
, top
, width
, height
,
6382 /* Border width, depth, class, and visual. */
6389 bar
->x_window
= window
;
6391 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6393 XSETWINDOW (bar
->window
, w
);
6397 bar
->height
= height
;
6401 bar
->horizontal
= horizontal
;
6402 #if defined (USE_TOOLKIT_SCROLL_BARS) && defined (USE_LUCID)
6403 bar
->last_seen_part
= scroll_bar_nowhere
;
6406 /* Add bar to its frame's list of scroll bars. */
6407 bar
->next
= FRAME_SCROLL_BARS (f
);
6409 XSETVECTOR (barobj
, bar
);
6410 fset_scroll_bars (f
, barobj
);
6411 if (!NILP (bar
->next
))
6412 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6414 /* Map the window/widget. */
6415 #ifdef USE_TOOLKIT_SCROLL_BARS
6419 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
,
6420 left
, width
, max (height
, 1));
6422 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
6423 left
, width
, max (height
, 1));
6424 #else /* not USE_GTK */
6425 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6426 XtConfigureWidget (scroll_bar
, left
, top
, width
, max (height
, 1), 0);
6427 XtMapWidget (scroll_bar
);
6428 #endif /* not USE_GTK */
6430 #else /* not USE_TOOLKIT_SCROLL_BARS */
6431 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
6432 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6439 #ifndef USE_TOOLKIT_SCROLL_BARS
6441 /* Draw BAR's handle in the proper position.
6443 If the handle is already drawn from START to END, don't bother
6444 redrawing it, unless REBUILD; in that case, always
6445 redraw it. (REBUILD is handy for drawing the handle after expose
6448 Normally, we want to constrain the start and end of the handle to
6449 fit inside its rectangle, but if the user is dragging the scroll
6450 bar handle, we want to let them drag it down all the way, so that
6451 the bar's top is as far down as it goes; otherwise, there's no way
6452 to move to the very end of the buffer. */
6455 x_scroll_bar_set_handle (struct scroll_bar
*bar
, int start
, int end
,
6458 bool dragging
= bar
->dragging
!= -1;
6459 Window w
= bar
->x_window
;
6460 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6461 GC gc
= f
->output_data
.x
->normal_gc
;
6463 /* If the display is already accurate, do nothing. */
6465 && start
== bar
->start
6472 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
6473 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
6474 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
6476 /* Make sure the values are reasonable, and try to preserve
6477 the distance between start and end. */
6479 int length
= end
- start
;
6483 else if (start
> top_range
)
6485 end
= start
+ length
;
6489 else if (end
> top_range
&& ! dragging
)
6493 /* Store the adjusted setting in the scroll bar. */
6497 /* Clip the end position, just for display. */
6498 if (end
> top_range
)
6501 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
6502 below top positions, to make sure the handle is always at least
6503 that many pixels tall. */
6504 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
6506 /* Draw the empty space above the handle. Note that we can't clear
6507 zero-height areas; that means "clear to end of window." */
6508 if ((inside_width
> 0) && (start
> 0))
6509 x_clear_area1 (FRAME_X_DISPLAY (f
), w
,
6510 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6511 VERTICAL_SCROLL_BAR_TOP_BORDER
,
6512 inside_width
, start
, False
);
6514 /* Change to proper foreground color if one is specified. */
6515 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6516 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6517 f
->output_data
.x
->scroll_bar_foreground_pixel
);
6519 /* Draw the handle itself. */
6520 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
6521 /* x, y, width, height */
6522 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6523 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
6524 inside_width
, end
- start
);
6526 /* Restore the foreground color of the GC if we changed it above. */
6527 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6528 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6529 FRAME_FOREGROUND_PIXEL (f
));
6531 /* Draw the empty space below the handle. Note that we can't
6532 clear zero-height areas; that means "clear to end of window." */
6533 if ((inside_width
> 0) && (end
< inside_height
))
6534 x_clear_area1 (FRAME_X_DISPLAY (f
), w
,
6535 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6536 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
6537 inside_width
, inside_height
- end
, False
);
6543 #endif /* !USE_TOOLKIT_SCROLL_BARS */
6545 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
6549 x_scroll_bar_remove (struct scroll_bar
*bar
)
6551 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6554 #ifdef USE_TOOLKIT_SCROLL_BARS
6556 xg_remove_scroll_bar (f
, bar
->x_window
);
6557 #else /* not USE_GTK */
6558 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
6559 #endif /* not USE_GTK */
6561 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
6564 /* Dissociate this scroll bar from its window. */
6565 if (bar
->horizontal
)
6566 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
6568 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
6574 /* Set the handle of the vertical scroll bar for WINDOW to indicate
6575 that we are displaying PORTION characters out of a total of WHOLE
6576 characters, starting at POSITION. If WINDOW has no scroll bar,
6580 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
6582 struct frame
*f
= XFRAME (w
->frame
);
6584 struct scroll_bar
*bar
;
6585 int top
, height
, left
, width
;
6586 int window_y
, window_height
;
6588 /* Get window dimensions. */
6589 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
6591 height
= window_height
;
6592 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
6593 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
6595 /* Does the scroll bar exist yet? */
6596 if (NILP (w
->vertical_scroll_bar
))
6598 if (width
> 0 && height
> 0)
6601 x_clear_area (f
, left
, top
, width
, height
);
6605 bar
= x_scroll_bar_create (w
, top
, left
, width
, max (height
, 1), false);
6609 /* It may just need to be moved and resized. */
6610 unsigned int mask
= 0;
6612 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
6616 if (left
!= bar
->left
)
6618 if (top
!= bar
->top
)
6620 if (width
!= bar
->width
)
6622 if (height
!= bar
->height
)
6625 #ifdef USE_TOOLKIT_SCROLL_BARS
6627 /* Move/size the scroll bar widget. */
6630 /* Since toolkit scroll bars are smaller than the space reserved
6631 for them on the frame, we have to clear "under" them. */
6632 if (width
> 0 && height
> 0)
6633 x_clear_area (f
, left
, top
, width
, height
);
6635 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
6636 left
, width
, max (height
, 1));
6637 #else /* not USE_GTK */
6638 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
6639 left
, top
, width
, max (height
, 1), 0);
6640 #endif /* not USE_GTK */
6642 #else /* not USE_TOOLKIT_SCROLL_BARS */
6644 /* Move/size the scroll bar window. */
6653 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
6657 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6659 /* Remember new settings. */
6663 bar
->height
= height
;
6668 #ifdef USE_TOOLKIT_SCROLL_BARS
6669 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
6670 #else /* not USE_TOOLKIT_SCROLL_BARS */
6671 /* Set the scroll bar's current state, unless we're currently being
6673 if (bar
->dragging
== -1)
6675 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
6678 x_scroll_bar_set_handle (bar
, 0, top_range
, false);
6681 int start
= ((double) position
* top_range
) / whole
;
6682 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
6683 x_scroll_bar_set_handle (bar
, start
, end
, false);
6686 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6688 XSETVECTOR (barobj
, bar
);
6689 wset_vertical_scroll_bar (w
, barobj
);
6694 XTset_horizontal_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
6696 struct frame
*f
= XFRAME (w
->frame
);
6698 struct scroll_bar
*bar
;
6699 int top
, height
, left
, width
;
6700 int window_x
, window_width
;
6701 int pixel_width
= WINDOW_PIXEL_WIDTH (w
);
6703 /* Get window dimensions. */
6704 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
6706 width
= window_width
;
6707 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
6708 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
6710 /* Does the scroll bar exist yet? */
6711 if (NILP (w
->horizontal_scroll_bar
))
6713 if (width
> 0 && height
> 0)
6717 /* Clear also part between window_width and
6718 WINDOW_PIXEL_WIDTH. */
6719 x_clear_area (f
, left
, top
, pixel_width
, height
);
6723 bar
= x_scroll_bar_create (w
, top
, left
, width
, height
, true);
6727 /* It may just need to be moved and resized. */
6728 unsigned int mask
= 0;
6730 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
6734 if (left
!= bar
->left
)
6736 if (top
!= bar
->top
)
6738 if (width
!= bar
->width
)
6740 if (height
!= bar
->height
)
6743 #ifdef USE_TOOLKIT_SCROLL_BARS
6744 /* Move/size the scroll bar widget. */
6747 /* Since toolkit scroll bars are smaller than the space reserved
6748 for them on the frame, we have to clear "under" them. */
6749 if (width
> 0 && height
> 0)
6751 WINDOW_LEFT_EDGE_X (w
), top
,
6752 pixel_width
- WINDOW_RIGHT_DIVIDER_WIDTH (w
), height
);
6754 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
, left
,
6756 #else /* not USE_GTK */
6757 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
6758 left
, top
, width
, height
, 0);
6759 #endif /* not USE_GTK */
6761 #else /* not USE_TOOLKIT_SCROLL_BARS */
6763 /* Clear areas not covered by the scroll bar because it's not as
6764 wide as the area reserved for it. This makes sure a
6765 previous mode line display is cleared after C-x 2 C-x 1, for
6768 int area_height
= WINDOW_CONFIG_SCROLL_BAR_HEIGHT (w
);
6769 int rest
= area_height
- height
;
6770 if (rest
> 0 && width
> 0)
6771 x_clear_area (f
, left
, top
, width
, rest
);
6774 /* Move/size the scroll bar window. */
6783 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
6787 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6789 /* Remember new settings. */
6793 bar
->height
= height
;
6798 #ifdef USE_TOOLKIT_SCROLL_BARS
6799 x_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
6800 #else /* not USE_TOOLKIT_SCROLL_BARS */
6801 /* Set the scroll bar's current state, unless we're currently being
6803 if (bar
->dragging
== -1)
6805 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
);
6808 x_scroll_bar_set_handle (bar
, 0, left_range
, false);
6811 int start
= ((double) position
* left_range
) / whole
;
6812 int end
= ((double) (position
+ portion
) * left_range
) / whole
;
6813 x_scroll_bar_set_handle (bar
, start
, end
, false);
6816 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6818 XSETVECTOR (barobj
, bar
);
6819 wset_horizontal_scroll_bar (w
, barobj
);
6823 /* The following three hooks are used when we're doing a thorough
6824 redisplay of the frame. We don't explicitly know which scroll bars
6825 are going to be deleted, because keeping track of when windows go
6826 away is a real pain - "Can you say set-window-configuration, boys
6827 and girls?" Instead, we just assert at the beginning of redisplay
6828 that *all* scroll bars are to be removed, and then save a scroll bar
6829 from the fiery pit when we actually redisplay its window. */
6831 /* Arrange for all scroll bars on FRAME to be removed at the next call
6832 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
6833 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
6836 XTcondemn_scroll_bars (struct frame
*frame
)
6838 if (!NILP (FRAME_SCROLL_BARS (frame
)))
6840 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
6842 /* Prepend scrollbars to already condemned ones. */
6843 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
6845 while (!NILP (XSCROLL_BAR (last
)->next
))
6846 last
= XSCROLL_BAR (last
)->next
;
6848 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
6849 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
6852 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
6853 fset_scroll_bars (frame
, Qnil
);
6858 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
6859 Note that WINDOW isn't necessarily condemned at all. */
6862 XTredeem_scroll_bar (struct window
*w
)
6864 struct scroll_bar
*bar
;
6868 /* We can't redeem this window's scroll bar if it doesn't have one. */
6869 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
6872 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
6874 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
6875 /* Unlink it from the condemned list. */
6876 f
= XFRAME (WINDOW_FRAME (w
));
6877 if (NILP (bar
->prev
))
6879 /* If the prev pointer is nil, it must be the first in one of
6881 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
6882 /* It's not condemned. Everything's fine. */
6884 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
6885 w
->vertical_scroll_bar
))
6886 fset_condemned_scroll_bars (f
, bar
->next
);
6888 /* If its prev pointer is nil, it must be at the front of
6889 one or the other! */
6893 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
6895 if (! NILP (bar
->next
))
6896 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
6898 bar
->next
= FRAME_SCROLL_BARS (f
);
6900 XSETVECTOR (barobj
, bar
);
6901 fset_scroll_bars (f
, barobj
);
6902 if (! NILP (bar
->next
))
6903 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6907 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
6909 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
6910 /* Unlink it from the condemned list. */
6911 f
= XFRAME (WINDOW_FRAME (w
));
6912 if (NILP (bar
->prev
))
6914 /* If the prev pointer is nil, it must be the first in one of
6916 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
6917 /* It's not condemned. Everything's fine. */
6919 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
6920 w
->horizontal_scroll_bar
))
6921 fset_condemned_scroll_bars (f
, bar
->next
);
6923 /* If its prev pointer is nil, it must be at the front of
6924 one or the other! */
6928 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
6930 if (! NILP (bar
->next
))
6931 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
6933 bar
->next
= FRAME_SCROLL_BARS (f
);
6935 XSETVECTOR (barobj
, bar
);
6936 fset_scroll_bars (f
, barobj
);
6937 if (! NILP (bar
->next
))
6938 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6942 /* Remove all scroll bars on FRAME that haven't been saved since the
6943 last call to `*condemn_scroll_bars_hook'. */
6946 XTjudge_scroll_bars (struct frame
*f
)
6948 Lisp_Object bar
, next
;
6950 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
6952 /* Clear out the condemned list now so we won't try to process any
6953 more events on the hapless scroll bars. */
6954 fset_condemned_scroll_bars (f
, Qnil
);
6956 for (; ! NILP (bar
); bar
= next
)
6958 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
6960 x_scroll_bar_remove (b
);
6963 b
->next
= b
->prev
= Qnil
;
6966 /* Now there should be no references to the condemned scroll bars,
6967 and they should get garbage-collected. */
6971 #ifndef USE_TOOLKIT_SCROLL_BARS
6972 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
6973 is a no-op when using toolkit scroll bars.
6975 This may be called from a signal handler, so we have to ignore GC
6979 x_scroll_bar_expose (struct scroll_bar
*bar
, const XEvent
*event
)
6981 Window w
= bar
->x_window
;
6982 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6983 GC gc
= f
->output_data
.x
->normal_gc
;
6987 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, true);
6989 /* Switch to scroll bar foreground color. */
6990 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6991 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6992 f
->output_data
.x
->scroll_bar_foreground_pixel
);
6994 /* Draw a one-pixel border just inside the edges of the scroll bar. */
6995 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
6996 /* x, y, width, height */
6997 0, 0, bar
->width
- 1, bar
->height
- 1);
6999 /* Restore the foreground color of the GC if we changed it above. */
7000 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
7001 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
7002 FRAME_FOREGROUND_PIXEL (f
));
7007 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7009 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
7010 is set to something other than NO_EVENT, it is enqueued.
7012 This may be called from a signal handler, so we have to ignore GC
7017 x_scroll_bar_handle_click (struct scroll_bar
*bar
,
7018 const XEvent
*event
,
7019 struct input_event
*emacs_event
)
7021 if (! WINDOWP (bar
->window
))
7024 emacs_event
->kind
= (bar
->horizontal
7025 ? HORIZONTAL_SCROLL_BAR_CLICK_EVENT
7026 : SCROLL_BAR_CLICK_EVENT
);
7027 emacs_event
->code
= event
->xbutton
.button
- Button1
;
7028 emacs_event
->modifiers
7029 = (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO
7030 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
7031 event
->xbutton
.state
)
7032 | (event
->type
== ButtonRelease
7035 emacs_event
->frame_or_window
= bar
->window
;
7036 emacs_event
->arg
= Qnil
;
7037 emacs_event
->timestamp
= event
->xbutton
.time
;
7038 if (bar
->horizontal
)
7041 = HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
7042 int x
= event
->xbutton
.x
- HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
7045 if (x
> left_range
) x
= left_range
;
7048 emacs_event
->part
= scroll_bar_before_handle
;
7049 else if (x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
7050 emacs_event
->part
= scroll_bar_horizontal_handle
;
7052 emacs_event
->part
= scroll_bar_after_handle
;
7054 #ifndef USE_TOOLKIT_SCROLL_BARS
7055 /* If the user has released the handle, set it to its final position. */
7056 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
7058 int new_start
= - bar
->dragging
;
7059 int new_end
= new_start
+ bar
->end
- bar
->start
;
7061 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
7066 XSETINT (emacs_event
->x
, left_range
);
7067 XSETINT (emacs_event
->y
, x
);
7072 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
7073 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
7076 if (y
> top_range
) y
= top_range
;
7079 emacs_event
->part
= scroll_bar_above_handle
;
7080 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
7081 emacs_event
->part
= scroll_bar_handle
;
7083 emacs_event
->part
= scroll_bar_below_handle
;
7085 #ifndef USE_TOOLKIT_SCROLL_BARS
7086 /* If the user has released the handle, set it to its final position. */
7087 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
7089 int new_start
= y
- bar
->dragging
;
7090 int new_end
= new_start
+ bar
->end
- bar
->start
;
7092 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
7097 XSETINT (emacs_event
->x
, y
);
7098 XSETINT (emacs_event
->y
, top_range
);
7102 #ifndef USE_TOOLKIT_SCROLL_BARS
7104 /* Handle some mouse motion while someone is dragging the scroll bar.
7106 This may be called from a signal handler, so we have to ignore GC
7110 x_scroll_bar_note_movement (struct scroll_bar
*bar
,
7111 const XMotionEvent
*event
)
7113 struct frame
*f
= XFRAME (XWINDOW (bar
->window
)->frame
);
7114 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
7116 dpyinfo
->last_mouse_movement_time
= event
->time
;
7117 dpyinfo
->last_mouse_scroll_bar
= bar
;
7118 f
->mouse_moved
= true;
7120 /* If we're dragging the bar, display it. */
7121 if (bar
->dragging
!= -1)
7123 /* Where should the handle be now? */
7124 int new_start
= event
->y
- bar
->dragging
;
7126 if (new_start
!= bar
->start
)
7128 int new_end
= new_start
+ bar
->end
- bar
->start
;
7130 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
7135 #endif /* !USE_TOOLKIT_SCROLL_BARS */
7137 /* Return information to the user about the current position of the mouse
7138 on the scroll bar. */
7141 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
7142 enum scroll_bar_part
*part
, Lisp_Object
*x
,
7143 Lisp_Object
*y
, Time
*timestamp
)
7145 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
7146 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
7147 Window w
= bar
->x_window
;
7148 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7150 Window dummy_window
;
7152 unsigned int dummy_mask
;
7156 /* Get the mouse's position relative to the scroll bar window, and
7158 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
7160 /* Root, child, root x and root y. */
7161 &dummy_window
, &dummy_window
,
7162 &dummy_coord
, &dummy_coord
,
7164 /* Position relative to scroll bar. */
7167 /* Mouse buttons and modifier keys. */
7170 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
7172 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
7174 if (bar
->dragging
!= -1)
7175 win_y
-= bar
->dragging
;
7179 if (win_y
> top_range
)
7183 *bar_window
= bar
->window
;
7185 if (bar
->dragging
!= -1)
7186 *part
= scroll_bar_handle
;
7187 else if (win_y
< bar
->start
)
7188 *part
= scroll_bar_above_handle
;
7189 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
7190 *part
= scroll_bar_handle
;
7192 *part
= scroll_bar_below_handle
;
7194 XSETINT (*x
, win_y
);
7195 XSETINT (*y
, top_range
);
7197 f
->mouse_moved
= false;
7198 dpyinfo
->last_mouse_scroll_bar
= NULL
;
7199 *timestamp
= dpyinfo
->last_mouse_movement_time
;
7206 /* Return information to the user about the current position of the mouse
7207 on the scroll bar. */
7210 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
7211 enum scroll_bar_part
*part
, Lisp_Object
*x
,
7212 Lisp_Object
*y
, Time
*timestamp
)
7214 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
7215 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
7216 Window w
= bar
->x_window
;
7217 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7219 Window dummy_window
;
7221 unsigned int dummy_mask
;
7225 /* Get the mouse's position relative to the scroll bar window, and
7227 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
7229 /* Root, child, root x and root y. */
7230 &dummy_window
, &dummy_window
,
7231 &dummy_coord
, &dummy_coord
,
7233 /* Position relative to scroll bar. */
7236 /* Mouse buttons and modifier keys. */
7239 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
7241 win_x
-= HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
7243 if (bar
->dragging
!= -1)
7244 win_x
-= bar
->dragging
;
7248 if (win_x
> left_range
)
7252 *bar_window
= bar
->window
;
7254 if (bar
->dragging
!= -1)
7255 *part
= scroll_bar_horizontal_handle
;
7256 else if (win_x
< bar
->start
)
7257 *part
= scroll_bar_before_handle
;
7258 else if (win_x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
7259 *part
= scroll_bar_handle
;
7261 *part
= scroll_bar_after_handle
;
7263 XSETINT (*y
, win_x
);
7264 XSETINT (*x
, left_range
);
7266 f
->mouse_moved
= false;
7267 dpyinfo
->last_mouse_scroll_bar
= NULL
;
7268 *timestamp
= dpyinfo
->last_mouse_movement_time
;
7275 /* The screen has been cleared so we may have changed foreground or
7276 background colors, and the scroll bars may need to be redrawn.
7277 Clear out the scroll bars, and ask for expose events, so we can
7281 x_scroll_bar_clear (struct frame
*f
)
7283 #ifndef USE_TOOLKIT_SCROLL_BARS
7286 /* We can have scroll bars even if this is 0,
7287 if we just turned off scroll bar mode.
7288 But in that case we should not clear them. */
7289 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
7290 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
7291 bar
= XSCROLL_BAR (bar
)->next
)
7292 XClearArea (FRAME_X_DISPLAY (f
),
7293 XSCROLL_BAR (bar
)->x_window
,
7295 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7298 #ifdef ENABLE_CHECKING
7300 /* Record the last 100 characters stored
7301 to help debug the loss-of-chars-during-GC problem. */
7303 static int temp_index
;
7304 static short temp_buffer
[100];
7306 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
7307 if (temp_index == ARRAYELTS (temp_buffer)) \
7309 temp_buffer[temp_index++] = (keysym)
7311 #else /* not ENABLE_CHECKING */
7313 #define STORE_KEYSYM_FOR_DEBUG(keysym) ((void)0)
7315 #endif /* ENABLE_CHECKING */
7317 /* Set this to nonzero to fake an "X I/O error"
7318 on a particular display. */
7320 static struct x_display_info
*XTread_socket_fake_io_error
;
7322 /* When we find no input here, we occasionally do a no-op command
7323 to verify that the X server is still running and we can still talk with it.
7324 We try all the open displays, one by one.
7325 This variable is used for cycling thru the displays. */
7327 static struct x_display_info
*next_noop_dpyinfo
;
7336 /* Filter events for the current X input method.
7337 DPYINFO is the display this event is for.
7338 EVENT is the X event to filter.
7340 Returns non-zero if the event was filtered, caller shall not process
7342 Returns zero if event is wasn't filtered. */
7346 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
7348 /* XFilterEvent returns non-zero if the input method has
7349 consumed the event. We pass the frame's X window to
7350 XFilterEvent because that's the one for which the IC
7353 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
7354 event
->xclient
.window
);
7356 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
7361 static int current_count
;
7362 static int current_finish
;
7363 static struct input_event
*current_hold_quit
;
7365 /* This is the filter function invoked by the GTK event loop.
7366 It is invoked before the XEvent is translated to a GdkEvent,
7367 so we have a chance to act on the event before GTK. */
7368 static GdkFilterReturn
7369 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
7371 XEvent
*xev
= (XEvent
*) gxev
;
7374 if (current_count
>= 0)
7376 struct x_display_info
*dpyinfo
;
7378 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
7381 /* Filter events for the current X input method.
7382 GTK calls XFilterEvent but not for key press and release,
7383 so we do it here. */
7384 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
7386 && x_filter_event (dpyinfo
, xev
))
7389 return GDK_FILTER_REMOVE
;
7394 current_finish
= X_EVENT_NORMAL
;
7397 += handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
7401 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
7405 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
7406 return GDK_FILTER_REMOVE
;
7408 return GDK_FILTER_CONTINUE
;
7410 #endif /* USE_GTK */
7413 static void xembed_send_message (struct frame
*f
, Time
,
7414 enum xembed_message
,
7415 long detail
, long data1
, long data2
);
7418 x_net_wm_state (struct frame
*f
, Window window
)
7420 int value
= FULLSCREEN_NONE
;
7421 Lisp_Object lval
= Qnil
;
7422 bool sticky
= false;
7424 get_current_wm_state (f
, window
, &value
, &sticky
);
7428 case FULLSCREEN_WIDTH
:
7431 case FULLSCREEN_HEIGHT
:
7434 case FULLSCREEN_BOTH
:
7437 case FULLSCREEN_MAXIMIZED
:
7442 frame_size_history_add
7443 (f
, Qx_net_wm_state
, 0, 0,
7444 list2 (get_frame_param (f
, Qfullscreen
), lval
));
7446 store_frame_param (f
, Qfullscreen
, lval
);
7447 /** store_frame_param (f, Qsticky, sticky ? Qt : Qnil); **/
7450 /* Handles the XEvent EVENT on display DPYINFO.
7452 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
7453 *FINISH is zero if caller should continue reading events.
7454 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
7455 *EVENT is unchanged unless we're processing KeyPress event.
7457 We return the number of characters stored into the buffer. */
7460 handle_one_xevent (struct x_display_info
*dpyinfo
,
7461 const XEvent
*event
,
7462 int *finish
, struct input_event
*hold_quit
)
7464 union buffered_input_event inev
;
7467 ptrdiff_t nbytes
= 0;
7468 struct frame
*any
, *f
= NULL
;
7469 struct coding_system coding
;
7470 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
7471 /* This holds the state XLookupString needs to implement dead keys
7472 and other tricks known as "compose processing". _X Window System_
7473 says that a portable program can't use this, but Stephen Gildea assures
7474 me that letting the compiler initialize it to zeros will work okay. */
7475 static XComposeStatus compose_status
;
7476 XEvent configureEvent
;
7481 *finish
= X_EVENT_NORMAL
;
7483 EVENT_INIT (inev
.ie
);
7484 inev
.ie
.kind
= NO_EVENT
;
7487 any
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
7489 if (any
&& any
->wait_event_type
== event
->type
)
7490 any
->wait_event_type
= 0; /* Indicates we got it. */
7492 switch (event
->type
)
7496 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_protocols
7497 && event
->xclient
.format
== 32)
7499 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_take_focus
)
7501 /* Use the value returned by x_any_window_to_frame
7502 because this could be the shell widget window
7503 if the frame has no title bar. */
7506 /* Not quite sure this is needed -pd */
7507 if (f
&& FRAME_XIC (f
))
7508 XSetICFocus (FRAME_XIC (f
));
7511 /* Emacs sets WM hints whose `input' field is `true'. This
7512 instructs the WM to set the input focus automatically for
7513 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
7514 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
7515 it has set the focus. So, XSetInputFocus below is not
7518 The call to XSetInputFocus below has also caused trouble. In
7519 cases where the XSetInputFocus done by the WM and the one
7520 below are temporally close (on a fast machine), the call
7521 below can generate additional FocusIn events which confuse
7524 /* Since we set WM_TAKE_FOCUS, we must call
7525 XSetInputFocus explicitly. But not if f is null,
7526 since that might be an event for a deleted frame. */
7529 Display
*d
= event
->xclient
.display
;
7530 /* Catch and ignore errors, in case window has been
7531 iconified by a window manager such as GWM. */
7533 XSetInputFocus (d
, event
->xclient
.window
,
7534 /* The ICCCM says this is
7535 the only valid choice. */
7537 event
->xclient
.data
.l
[1]);
7538 x_uncatch_errors ();
7540 /* Not certain about handling scroll bars here */
7545 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_save_yourself
)
7547 /* Save state modify the WM_COMMAND property to
7548 something which can reinstate us. This notifies
7549 the session manager, who's looking for such a
7550 PropertyNotify. Can restart processing when
7551 a keyboard or mouse event arrives. */
7552 /* If we have a session manager, don't set this.
7553 KDE will then start two Emacsen, one for the
7554 session manager and one for this. */
7556 if (! x_session_have_connection ())
7559 f
= x_top_window_to_frame (dpyinfo
,
7560 event
->xclient
.window
);
7561 /* This is just so we only give real data once
7562 for a single Emacs process. */
7563 if (f
== SELECTED_FRAME ())
7564 XSetCommand (FRAME_X_DISPLAY (f
),
7565 event
->xclient
.window
,
7566 initial_argv
, initial_argc
);
7568 XSetCommand (FRAME_X_DISPLAY (f
),
7569 event
->xclient
.window
,
7575 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_delete_window
)
7579 goto OTHER
; /* May be a dialog that is to be removed */
7581 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
7582 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7589 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_configure_denied
)
7592 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_window_moved
)
7595 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
7597 new_x
= event
->xclient
.data
.s
[0];
7598 new_y
= event
->xclient
.data
.s
[1];
7602 f
->left_pos
= new_x
;
7608 #ifdef X_TOOLKIT_EDITRES
7609 if (event
->xclient
.message_type
== dpyinfo
->Xatom_editres
)
7613 _XEditResCheckMessages (f
->output_data
.x
->widget
,
7614 NULL
, (XEvent
*) event
, NULL
);
7617 #endif /* X_TOOLKIT_EDITRES */
7619 if (event
->xclient
.message_type
== dpyinfo
->Xatom_DONE
7620 || event
->xclient
.message_type
== dpyinfo
->Xatom_PAGE
)
7622 /* Ghostview job completed. Kill it. We could
7623 reply with "Next" if we received "Page", but we
7624 currently never do because we are interested in
7625 images, only, which should have 1 page. */
7626 Pixmap pixmap
= (Pixmap
) event
->xclient
.data
.l
[1];
7627 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
7630 x_kill_gs_process (pixmap
, f
);
7631 expose_frame (f
, 0, 0, 0, 0);
7635 #ifdef USE_TOOLKIT_SCROLL_BARS
7636 /* Scroll bar callbacks send a ClientMessage from which
7637 we construct an input_event. */
7638 if (event
->xclient
.message_type
== dpyinfo
->Xatom_Scrollbar
)
7640 x_scroll_bar_to_input_event (event
, &inev
.ie
);
7641 *finish
= X_EVENT_GOTO_OUT
;
7644 else if (event
->xclient
.message_type
== dpyinfo
->Xatom_Horizontal_Scrollbar
)
7646 x_horizontal_scroll_bar_to_input_event (event
, &inev
.ie
);
7647 *finish
= X_EVENT_GOTO_OUT
;
7650 #endif /* USE_TOOLKIT_SCROLL_BARS */
7652 /* XEmbed messages from the embedder (if any). */
7653 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
7655 enum xembed_message msg
= event
->xclient
.data
.l
[1];
7656 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
7657 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7659 *finish
= X_EVENT_GOTO_OUT
;
7663 xft_settings_event (dpyinfo
, event
);
7668 if (x_handle_dnd_message (f
, &event
->xclient
, dpyinfo
, &inev
.ie
))
7669 *finish
= X_EVENT_DROP
;
7673 case SelectionNotify
:
7674 x_display_set_last_user_time (dpyinfo
, event
->xselection
.time
);
7675 #ifdef USE_X_TOOLKIT
7676 if (! x_window_to_frame (dpyinfo
, event
->xselection
.requestor
))
7678 #endif /* not USE_X_TOOLKIT */
7679 x_handle_selection_notify (&event
->xselection
);
7682 case SelectionClear
: /* Someone has grabbed ownership. */
7683 x_display_set_last_user_time (dpyinfo
, event
->xselectionclear
.time
);
7684 #ifdef USE_X_TOOLKIT
7685 if (! x_window_to_frame (dpyinfo
, event
->xselectionclear
.window
))
7687 #endif /* USE_X_TOOLKIT */
7689 const XSelectionClearEvent
*eventp
= &event
->xselectionclear
;
7691 inev
.sie
.kind
= SELECTION_CLEAR_EVENT
;
7692 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
7693 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
7694 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
7698 case SelectionRequest
: /* Someone wants our selection. */
7699 x_display_set_last_user_time (dpyinfo
, event
->xselectionrequest
.time
);
7700 #ifdef USE_X_TOOLKIT
7701 if (!x_window_to_frame (dpyinfo
, event
->xselectionrequest
.owner
))
7703 #endif /* USE_X_TOOLKIT */
7705 const XSelectionRequestEvent
*eventp
= &event
->xselectionrequest
;
7707 inev
.sie
.kind
= SELECTION_REQUEST_EVENT
;
7708 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
7709 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
7710 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
7711 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
7712 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
7713 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
7717 case PropertyNotify
:
7718 x_display_set_last_user_time (dpyinfo
, event
->xproperty
.time
);
7719 f
= x_top_window_to_frame (dpyinfo
, event
->xproperty
.window
);
7720 if (f
&& event
->xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
7722 bool not_hidden
= x_handle_net_wm_state (f
, &event
->xproperty
);
7723 if (not_hidden
&& FRAME_ICONIFIED_P (f
))
7725 /* Gnome shell does not iconify us when C-z is pressed.
7726 It hides the frame. So if our state says we aren't
7727 hidden anymore, treat it as deiconified. */
7728 SET_FRAME_VISIBLE (f
, 1);
7729 SET_FRAME_ICONIFIED (f
, false);
7730 f
->output_data
.x
->has_been_visible
= true;
7731 inev
.ie
.kind
= DEICONIFY_EVENT
;
7732 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7734 else if (! not_hidden
&& ! FRAME_ICONIFIED_P (f
))
7736 SET_FRAME_VISIBLE (f
, 0);
7737 SET_FRAME_ICONIFIED (f
, true);
7738 inev
.ie
.kind
= ICONIFY_EVENT
;
7739 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7743 x_handle_property_notify (&event
->xproperty
);
7744 xft_settings_event (dpyinfo
, event
);
7747 case ReparentNotify
:
7748 f
= x_top_window_to_frame (dpyinfo
, event
->xreparent
.window
);
7751 f
->output_data
.x
->parent_desc
= event
->xreparent
.parent
;
7752 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
7754 /* Perhaps reparented due to a WM restart. Reset this. */
7755 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
7756 FRAME_DISPLAY_INFO (f
)->net_supported_window
= 0;
7758 x_set_frame_alpha (f
);
7763 f
= x_window_to_frame (dpyinfo
, event
->xexpose
.window
);
7766 if (!FRAME_VISIBLE_P (f
))
7768 SET_FRAME_VISIBLE (f
, 1);
7769 SET_FRAME_ICONIFIED (f
, false);
7770 f
->output_data
.x
->has_been_visible
= true;
7771 SET_FRAME_GARBAGED (f
);
7776 /* This seems to be needed for GTK 2.6 and later, see
7777 http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15398. */
7779 event
->xexpose
.x
, event
->xexpose
.y
,
7780 event
->xexpose
.width
, event
->xexpose
.height
);
7782 expose_frame (f
, event
->xexpose
.x
, event
->xexpose
.y
,
7783 event
->xexpose
.width
, event
->xexpose
.height
);
7788 #ifndef USE_TOOLKIT_SCROLL_BARS
7789 struct scroll_bar
*bar
;
7791 #if defined USE_LUCID
7792 /* Submenus of the Lucid menu bar aren't widgets
7793 themselves, so there's no way to dispatch events
7794 to them. Recognize this case separately. */
7796 Widget widget
= x_window_to_menu_bar (event
->xexpose
.window
);
7798 xlwmenu_redisplay (widget
);
7800 #endif /* USE_LUCID */
7802 #ifdef USE_TOOLKIT_SCROLL_BARS
7803 /* Dispatch event to the widget. */
7805 #else /* not USE_TOOLKIT_SCROLL_BARS */
7806 bar
= x_window_to_scroll_bar (event
->xexpose
.display
,
7807 event
->xexpose
.window
, 2);
7810 x_scroll_bar_expose (bar
, event
);
7811 #ifdef USE_X_TOOLKIT
7814 #endif /* USE_X_TOOLKIT */
7815 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7819 case GraphicsExpose
: /* This occurs when an XCopyArea's
7820 source area was obscured or not
7822 f
= x_window_to_frame (dpyinfo
, event
->xgraphicsexpose
.drawable
);
7824 expose_frame (f
, event
->xgraphicsexpose
.x
,
7825 event
->xgraphicsexpose
.y
,
7826 event
->xgraphicsexpose
.width
,
7827 event
->xgraphicsexpose
.height
);
7828 #ifdef USE_X_TOOLKIT
7831 #endif /* USE_X_TOOLKIT */
7834 case NoExpose
: /* This occurs when an XCopyArea's
7835 source area was completely
7840 /* Redo the mouse-highlight after the tooltip has gone. */
7841 if (dpyinfo
->x_tooltip_frame
7842 && FRAME_X_WINDOW (dpyinfo
->x_tooltip_frame
) == event
->xunmap
.window
)
7843 x_redo_mouse_highlight (dpyinfo
);
7845 f
= x_top_window_to_frame (dpyinfo
, event
->xunmap
.window
);
7846 if (f
) /* F may no longer exist if
7847 the frame was deleted. */
7849 bool visible
= FRAME_VISIBLE_P (f
);
7850 /* While a frame is unmapped, display generation is
7851 disabled; you don't want to spend time updating a
7852 display that won't ever be seen. */
7853 SET_FRAME_VISIBLE (f
, 0);
7854 /* We can't distinguish, from the event, whether the window
7855 has become iconified or invisible. So assume, if it
7856 was previously visible, than now it is iconified.
7857 But x_make_frame_invisible clears both
7858 the visible flag and the iconified flag;
7859 and that way, we know the window is not iconified now. */
7860 if (visible
|| FRAME_ICONIFIED_P (f
))
7862 SET_FRAME_ICONIFIED (f
, true);
7863 inev
.ie
.kind
= ICONIFY_EVENT
;
7864 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7870 /* We use x_top_window_to_frame because map events can
7871 come for sub-windows and they don't mean that the
7872 frame is visible. */
7873 f
= x_top_window_to_frame (dpyinfo
, event
->xmap
.window
);
7876 bool iconified
= FRAME_ICONIFIED_P (f
);
7878 /* Check if fullscreen was specified before we where mapped the
7879 first time, i.e. from the command line. */
7880 if (!f
->output_data
.x
->has_been_visible
)
7881 x_check_fullscreen (f
);
7883 SET_FRAME_VISIBLE (f
, 1);
7884 SET_FRAME_ICONIFIED (f
, false);
7885 f
->output_data
.x
->has_been_visible
= true;
7889 inev
.ie
.kind
= DEICONIFY_EVENT
;
7890 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7892 else if (! NILP (Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
7893 /* Force a redisplay sooner or later to update the
7894 frame titles in case this is the second frame. */
7895 record_asynch_buffer_change ();
7901 x_display_set_last_user_time (dpyinfo
, event
->xkey
.time
);
7902 ignore_next_mouse_click_timeout
= 0;
7904 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
7905 /* Dispatch KeyPress events when in menu. */
7906 if (popup_activated ())
7912 /* If mouse-highlight is an integer, input clears out
7913 mouse highlighting. */
7914 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
7915 #if ! defined (USE_GTK)
7917 || !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
7921 clear_mouse_face (hlinfo
);
7922 hlinfo
->mouse_face_hidden
= true;
7925 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
7928 /* Scroll bars consume key events, but we want
7929 the keys to go to the scroll bar's frame. */
7930 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
7931 event
->xkey
.window
);
7932 if (widget
&& XmIsScrollBar (widget
))
7934 widget
= XtParent (widget
);
7935 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
7938 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
7942 KeySym keysym
, orig_keysym
;
7943 /* al%imercury@uunet.uu.net says that making this 81
7944 instead of 80 fixed a bug whereby meta chars made
7947 It seems that some version of XmbLookupString has
7948 a bug of not returning XBufferOverflow in
7949 status_return even if the input is too long to
7950 fit in 81 bytes. So, we must prepare sufficient
7951 bytes for copy_buffer. 513 bytes (256 chars for
7952 two-byte character set) seems to be a fairly good
7953 approximation. -- 2000.8.10 handa@etl.go.jp */
7954 unsigned char copy_buffer
[513];
7955 unsigned char *copy_bufptr
= copy_buffer
;
7956 int copy_bufsiz
= sizeof (copy_buffer
);
7958 Lisp_Object coding_system
= Qlatin_1
;
7960 /* Event will be modified. */
7961 XKeyEvent xkey
= event
->xkey
;
7964 /* Don't pass keys to GTK. A Tab will shift focus to the
7965 tool bar in GTK 2.4. Keys will still go to menus and
7966 dialogs because in that case popup_activated is nonzero
7968 *finish
= X_EVENT_DROP
;
7971 xkey
.state
|= x_emacs_to_x_modifiers (FRAME_DISPLAY_INFO (f
),
7972 extra_keyboard_modifiers
);
7973 modifiers
= xkey
.state
;
7975 /* This will have to go some day... */
7977 /* make_lispy_event turns chars into control chars.
7978 Don't do it here because XLookupString is too eager. */
7979 xkey
.state
&= ~ControlMask
;
7980 xkey
.state
&= ~(dpyinfo
->meta_mod_mask
7981 | dpyinfo
->super_mod_mask
7982 | dpyinfo
->hyper_mod_mask
7983 | dpyinfo
->alt_mod_mask
);
7985 /* In case Meta is ComposeCharacter,
7986 clear its status. According to Markus Ehrnsperger
7987 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
7988 this enables ComposeCharacter to work whether or
7989 not it is combined with Meta. */
7990 if (modifiers
& dpyinfo
->meta_mod_mask
)
7991 memset (&compose_status
, 0, sizeof (compose_status
));
7996 Status status_return
;
7998 coding_system
= Vlocale_coding_system
;
7999 nbytes
= XmbLookupString (FRAME_XIC (f
),
8000 &xkey
, (char *) copy_bufptr
,
8001 copy_bufsiz
, &keysym
,
8003 if (status_return
== XBufferOverflow
)
8005 copy_bufsiz
= nbytes
+ 1;
8006 copy_bufptr
= alloca (copy_bufsiz
);
8007 nbytes
= XmbLookupString (FRAME_XIC (f
),
8008 &xkey
, (char *) copy_bufptr
,
8009 copy_bufsiz
, &keysym
,
8012 /* Xutf8LookupString is a new but already deprecated interface. -stef */
8013 if (status_return
== XLookupNone
)
8015 else if (status_return
== XLookupChars
)
8020 else if (status_return
!= XLookupKeySym
8021 && status_return
!= XLookupBoth
)
8025 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
8026 copy_bufsiz
, &keysym
,
8029 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
8030 copy_bufsiz
, &keysym
,
8034 /* If not using XIM/XIC, and a compose sequence is in progress,
8035 we break here. Otherwise, chars_matched is always 0. */
8036 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
8039 memset (&compose_status
, 0, sizeof (compose_status
));
8040 orig_keysym
= keysym
;
8042 /* Common for all keysym input events. */
8043 XSETFRAME (inev
.ie
.frame_or_window
, f
);
8045 = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), modifiers
);
8046 inev
.ie
.timestamp
= xkey
.time
;
8048 /* First deal with keysyms which have defined
8049 translations to characters. */
8050 if (keysym
>= 32 && keysym
< 128)
8051 /* Avoid explicitly decoding each ASCII character. */
8053 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
8054 inev
.ie
.code
= keysym
;
8058 /* Keysyms directly mapped to Unicode characters. */
8059 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
8061 if (keysym
< 0x01000080)
8062 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
8064 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
8065 inev
.ie
.code
= keysym
& 0xFFFFFF;
8069 /* Now non-ASCII. */
8070 if (HASH_TABLE_P (Vx_keysym_table
)
8071 && (c
= Fgethash (make_number (keysym
),
8076 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
8077 ? ASCII_KEYSTROKE_EVENT
8078 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
8079 inev
.ie
.code
= XFASTINT (c
);
8083 /* Random non-modifier sorts of keysyms. */
8084 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
8085 || keysym
== XK_Delete
8086 #ifdef XK_ISO_Left_Tab
8087 || (keysym
>= XK_ISO_Left_Tab
8088 && keysym
<= XK_ISO_Enter
)
8090 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
8091 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
8093 /* This recognizes the "extended function
8094 keys". It seems there's no cleaner way.
8095 Test IsModifierKey to avoid handling
8096 mode_switch incorrectly. */
8097 || (XK_Select
<= keysym
&& keysym
< XK_KP_Space
)
8099 #ifdef XK_dead_circumflex
8100 || orig_keysym
== XK_dead_circumflex
8102 #ifdef XK_dead_grave
8103 || orig_keysym
== XK_dead_grave
8105 #ifdef XK_dead_tilde
8106 || orig_keysym
== XK_dead_tilde
8108 #ifdef XK_dead_diaeresis
8109 || orig_keysym
== XK_dead_diaeresis
8111 #ifdef XK_dead_macron
8112 || orig_keysym
== XK_dead_macron
8114 #ifdef XK_dead_degree
8115 || orig_keysym
== XK_dead_degree
8117 #ifdef XK_dead_acute
8118 || orig_keysym
== XK_dead_acute
8120 #ifdef XK_dead_cedilla
8121 || orig_keysym
== XK_dead_cedilla
8123 #ifdef XK_dead_breve
8124 || orig_keysym
== XK_dead_breve
8126 #ifdef XK_dead_ogonek
8127 || orig_keysym
== XK_dead_ogonek
8129 #ifdef XK_dead_caron
8130 || orig_keysym
== XK_dead_caron
8132 #ifdef XK_dead_doubleacute
8133 || orig_keysym
== XK_dead_doubleacute
8135 #ifdef XK_dead_abovedot
8136 || orig_keysym
== XK_dead_abovedot
8138 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
8139 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
8140 /* Any "vendor-specific" key is ok. */
8141 || (orig_keysym
& (1 << 28))
8142 || (keysym
!= NoSymbol
&& nbytes
== 0))
8143 && ! (IsModifierKey (orig_keysym
)
8144 /* The symbols from XK_ISO_Lock
8145 to XK_ISO_Last_Group_Lock
8146 don't have real modifiers but
8147 should be treated similarly to
8148 Mode_switch by Emacs. */
8149 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
8150 || (XK_ISO_Lock
<= orig_keysym
8151 && orig_keysym
<= XK_ISO_Last_Group_Lock
)
8155 STORE_KEYSYM_FOR_DEBUG (keysym
);
8156 /* make_lispy_event will convert this to a symbolic
8158 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
8159 inev
.ie
.code
= keysym
;
8163 { /* Raw bytes, not keysym. */
8167 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
8169 if (ASCII_CHAR_P (copy_bufptr
[i
]))
8171 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
8174 if (nchars
< nbytes
)
8176 /* Decode the input data. */
8178 /* The input should be decoded with `coding_system'
8179 which depends on which X*LookupString function
8180 we used just above and the locale. */
8181 setup_coding_system (coding_system
, &coding
);
8182 coding
.src_multibyte
= false;
8183 coding
.dst_multibyte
= true;
8184 /* The input is converted to events, thus we can't
8185 handle composition. Anyway, there's no XIM that
8186 gives us composition information. */
8187 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
8189 SAFE_NALLOCA (coding
.destination
, MAX_MULTIBYTE_LENGTH
,
8191 coding
.dst_bytes
= MAX_MULTIBYTE_LENGTH
* nbytes
;
8192 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8193 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
8194 nbytes
= coding
.produced
;
8195 nchars
= coding
.produced_char
;
8196 copy_bufptr
= coding
.destination
;
8199 /* Convert the input data to a sequence of
8200 character events. */
8201 for (i
= 0; i
< nbytes
; i
+= len
)
8204 if (nchars
== nbytes
)
8205 ch
= copy_bufptr
[i
], len
= 1;
8207 ch
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
8208 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (ch
)
8209 ? ASCII_KEYSTROKE_EVENT
8210 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
8212 kbd_buffer_store_buffered_event (&inev
, hold_quit
);
8217 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
8219 if (keysym
== NoSymbol
)
8222 /* FIXME: check side effects and remove this. */
8223 ((XEvent
*) event
)->xkey
= xkey
;
8227 /* Don't dispatch this event since XtDispatchEvent calls
8228 XFilterEvent, and two calls in a row may freeze the
8236 x_display_set_last_user_time (dpyinfo
, event
->xkey
.time
);
8238 /* Don't dispatch this event since XtDispatchEvent calls
8239 XFilterEvent, and two calls in a row may freeze the
8247 x_display_set_last_user_time (dpyinfo
, event
->xcrossing
.time
);
8248 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8252 if (f
&& x_mouse_click_focus_ignore_position
)
8253 ignore_next_mouse_click_timeout
= event
->xmotion
.time
+ 200;
8255 /* EnterNotify counts as mouse movement,
8256 so update things that depend on mouse position. */
8257 if (f
&& !f
->output_data
.x
->hourglass_p
)
8258 note_mouse_movement (f
, &event
->xmotion
);
8260 /* We may get an EnterNotify on the buttons in the toolbar. In that
8261 case we moved out of any highlighted area and need to note this. */
8262 if (!f
&& dpyinfo
->last_mouse_glyph_frame
)
8263 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
8268 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8272 x_display_set_last_user_time (dpyinfo
, event
->xcrossing
.time
);
8273 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8275 f
= x_top_window_to_frame (dpyinfo
, event
->xcrossing
.window
);
8278 if (f
== hlinfo
->mouse_face_mouse_frame
)
8280 /* If we move outside the frame, then we're
8281 certainly no longer on any text in the frame. */
8282 clear_mouse_face (hlinfo
);
8283 hlinfo
->mouse_face_mouse_frame
= 0;
8286 /* Generate a nil HELP_EVENT to cancel a help-echo.
8287 Do it only if there's something to cancel.
8288 Otherwise, the startup message is cleared when
8289 the mouse leaves the frame. */
8290 if (any_help_event_p
)
8294 /* See comment in EnterNotify above */
8295 else if (dpyinfo
->last_mouse_glyph_frame
)
8296 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
8301 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8306 x_display_set_last_user_time (dpyinfo
, event
->xmotion
.time
);
8307 previous_help_echo_string
= help_echo_string
;
8308 help_echo_string
= Qnil
;
8310 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
8311 : x_window_to_frame (dpyinfo
, event
->xmotion
.window
));
8313 if (hlinfo
->mouse_face_hidden
)
8315 hlinfo
->mouse_face_hidden
= false;
8316 clear_mouse_face (hlinfo
);
8320 if (f
&& xg_event_is_for_scrollbar (f
, event
))
8326 /* Generate SELECT_WINDOW_EVENTs when needed.
8327 Don't let popup menus influence things (bug#1261). */
8328 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
8330 static Lisp_Object last_mouse_window
;
8331 Lisp_Object window
= window_from_coordinates
8332 (f
, event
->xmotion
.x
, event
->xmotion
.y
, 0, false);
8334 /* Window will be selected only when it is not selected now and
8335 last mouse movement event was not in it. Minibuffer window
8336 will be selected only when it is active. */
8337 if (WINDOWP (window
)
8338 && !EQ (window
, last_mouse_window
)
8339 && !EQ (window
, selected_window
)
8340 /* For click-to-focus window managers
8341 create event iff we don't leave the
8343 && (focus_follows_mouse
8344 || (EQ (XWINDOW (window
)->frame
,
8345 XWINDOW (selected_window
)->frame
))))
8347 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
8348 inev
.ie
.frame_or_window
= window
;
8350 /* Remember the last window where we saw the mouse. */
8351 last_mouse_window
= window
;
8353 if (!note_mouse_movement (f
, &event
->xmotion
))
8354 help_echo_string
= previous_help_echo_string
;
8358 #ifndef USE_TOOLKIT_SCROLL_BARS
8359 struct scroll_bar
*bar
8360 = x_window_to_scroll_bar (event
->xmotion
.display
,
8361 event
->xmotion
.window
, 2);
8364 x_scroll_bar_note_movement (bar
, &event
->xmotion
);
8365 #endif /* USE_TOOLKIT_SCROLL_BARS */
8367 /* If we move outside the frame, then we're
8368 certainly no longer on any text in the frame. */
8369 clear_mouse_face (hlinfo
);
8372 /* If the contents of the global variable help_echo_string
8373 has changed, generate a HELP_EVENT. */
8374 if (!NILP (help_echo_string
)
8375 || !NILP (previous_help_echo_string
))
8380 case ConfigureNotify
:
8381 /* An opaque move can generate a stream of events as the window
8382 is dragged around. If the connection round trip time isn't
8383 really short, they may come faster than we can respond to
8384 them, given the multiple queries we can do to check window
8385 manager state, translate coordinates, etc.
8387 So if this ConfigureNotify is immediately followed by another
8388 for the same window, use the info from the latest update, and
8389 consider the events all handled. */
8390 /* Opaque resize may be trickier; ConfigureNotify events are
8391 mixed with Expose events for multiple windows. */
8392 configureEvent
= *event
;
8393 while (XPending (dpyinfo
->display
))
8395 XNextEvent (dpyinfo
->display
, &next_event
);
8396 if (next_event
.type
!= ConfigureNotify
8397 || next_event
.xconfigure
.window
!= event
->xconfigure
.window
8398 /* Skipping events with different sizes can lead to a
8399 mispositioned mode line at initial window creation.
8400 Only drop window motion events for now. */
8401 || next_event
.xconfigure
.width
!= event
->xconfigure
.width
8402 || next_event
.xconfigure
.height
!= event
->xconfigure
.height
)
8404 XPutBackEvent (dpyinfo
->display
, &next_event
);
8408 configureEvent
= next_event
;
8410 f
= x_top_window_to_frame (dpyinfo
, configureEvent
.xconfigure
.window
);
8412 if (f
) x_cr_destroy_surface (f
);
8417 && configureEvent
.xconfigure
.window
== FRAME_X_WINDOW (f
))
8419 xg_frame_resized (f
, configureEvent
.xconfigure
.width
,
8420 configureEvent
.xconfigure
.height
);
8422 x_cr_destroy_surface (f
);
8429 x_net_wm_state (f
, configureEvent
.xconfigure
.window
);
8431 #ifdef USE_X_TOOLKIT
8432 /* Tip frames are pure X window, set size for them. */
8433 if (FRAME_TOOLTIP_P (f
))
8435 if (FRAME_PIXEL_HEIGHT (f
) != configureEvent
.xconfigure
.height
8436 || FRAME_PIXEL_WIDTH (f
) != configureEvent
.xconfigure
.width
)
8437 SET_FRAME_GARBAGED (f
);
8438 FRAME_PIXEL_HEIGHT (f
) = configureEvent
.xconfigure
.height
;
8439 FRAME_PIXEL_WIDTH (f
) = configureEvent
.xconfigure
.width
;
8443 #ifndef USE_X_TOOLKIT
8446 FRAME_PIXEL_TO_TEXT_WIDTH (f
, configureEvent
.xconfigure
.width
);
8448 FRAME_PIXEL_TO_TEXT_HEIGHT (f
, configureEvent
.xconfigure
.height
);
8450 /* In the toolkit version, change_frame_size
8451 is called by the code that handles resizing
8452 of the EmacsFrame widget. */
8454 /* Even if the number of character rows and columns has
8455 not changed, the font size may have changed, so we need
8456 to check the pixel dimensions as well. */
8457 if (width
!= FRAME_TEXT_WIDTH (f
)
8458 || height
!= FRAME_TEXT_HEIGHT (f
)
8459 || configureEvent
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
8460 || configureEvent
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
8462 change_frame_size (f
, width
, height
, false, true, false, true);
8463 x_clear_under_internal_border (f
);
8464 SET_FRAME_GARBAGED (f
);
8465 cancel_mouse_face (f
);
8467 #endif /* not USE_GTK */
8471 /* GTK creates windows but doesn't map them.
8472 Only get real positions when mapped. */
8473 if (FRAME_GTK_OUTER_WIDGET (f
)
8474 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
8476 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
8479 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
8480 xic_set_statusarea (f
);
8489 /* If we decide we want to generate an event to be seen
8490 by the rest of Emacs, we put it here. */
8491 bool tool_bar_p
= false;
8493 memset (&compose_status
, 0, sizeof (compose_status
));
8494 dpyinfo
->last_mouse_glyph_frame
= NULL
;
8495 x_display_set_last_user_time (dpyinfo
, event
->xbutton
.time
);
8497 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
8498 : x_window_to_frame (dpyinfo
, event
->xbutton
.window
));
8501 if (f
&& xg_event_is_for_scrollbar (f
, event
))
8506 #if ! defined (USE_GTK)
8507 /* Is this in the tool-bar? */
8508 if (WINDOWP (f
->tool_bar_window
)
8509 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
8512 int x
= event
->xbutton
.x
;
8513 int y
= event
->xbutton
.y
;
8515 window
= window_from_coordinates (f
, x
, y
, 0, true);
8516 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
8518 if (tool_bar_p
&& event
->xbutton
.button
< 4)
8519 handle_tool_bar_click
8520 (f
, x
, y
, event
->xbutton
.type
== ButtonPress
,
8521 x_x_to_emacs_modifiers (dpyinfo
, event
->xbutton
.state
));
8523 #endif /* !USE_GTK */
8526 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
8527 if (! popup_activated ())
8530 if (ignore_next_mouse_click_timeout
)
8532 if (event
->type
== ButtonPress
8533 && event
->xbutton
.time
> ignore_next_mouse_click_timeout
)
8535 ignore_next_mouse_click_timeout
= 0;
8536 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
8538 if (event
->type
== ButtonRelease
)
8539 ignore_next_mouse_click_timeout
= 0;
8542 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
8544 if (FRAME_X_EMBEDDED_P (f
))
8545 xembed_send_message (f
, event
->xbutton
.time
,
8546 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
8550 struct scroll_bar
*bar
8551 = x_window_to_scroll_bar (event
->xbutton
.display
,
8552 event
->xbutton
.window
, 2);
8554 #ifdef USE_TOOLKIT_SCROLL_BARS
8555 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
8557 if (bar
&& event
->xbutton
.state
& ControlMask
)
8559 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
8560 *finish
= X_EVENT_DROP
;
8562 #else /* not USE_TOOLKIT_SCROLL_BARS */
8564 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
8565 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8568 if (event
->type
== ButtonPress
)
8570 dpyinfo
->grabbed
|= (1 << event
->xbutton
.button
);
8571 dpyinfo
->last_mouse_frame
= f
;
8572 #if ! defined (USE_GTK)
8573 if (f
&& !tool_bar_p
)
8574 f
->last_tool_bar_item
= -1;
8575 #endif /* not USE_GTK */
8578 dpyinfo
->grabbed
&= ~(1 << event
->xbutton
.button
);
8580 /* Ignore any mouse motion that happened before this event;
8581 any subsequent mouse-movement Emacs events should reflect
8582 only motion after the ButtonPress/Release. */
8584 f
->mouse_moved
= false;
8586 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
8587 f
= x_menubar_window_to_frame (dpyinfo
, event
);
8588 /* For a down-event in the menu bar,
8589 don't pass it to Xt right now.
8590 Instead, save it away
8591 and we will pass it to Xt from kbd_buffer_get_event.
8592 That way, we can run some Lisp code first. */
8593 if (! popup_activated ()
8595 /* Gtk+ menus only react to the first three buttons. */
8596 && event
->xbutton
.button
< 3
8598 && f
&& event
->type
== ButtonPress
8599 /* Verify the event is really within the menu bar
8600 and not just sent to it due to grabbing. */
8601 && event
->xbutton
.x
>= 0
8602 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
8603 && event
->xbutton
.y
>= 0
8604 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
8605 && event
->xbutton
.same_screen
)
8607 if (!f
->output_data
.x
->saved_menu_event
)
8608 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof *event
);
8609 *f
->output_data
.x
->saved_menu_event
= *event
;
8610 inev
.ie
.kind
= MENU_BAR_ACTIVATE_EVENT
;
8611 XSETFRAME (inev
.ie
.frame_or_window
, f
);
8612 *finish
= X_EVENT_DROP
;
8616 #endif /* USE_X_TOOLKIT || USE_GTK */
8620 case CirculateNotify
:
8623 case CirculateRequest
:
8626 case VisibilityNotify
:
8630 /* Someone has changed the keyboard mapping - update the
8632 switch (event
->xmapping
.request
)
8634 case MappingModifier
:
8635 x_find_modifier_meanings (dpyinfo
);
8636 /* This is meant to fall through. */
8637 case MappingKeyboard
:
8638 XRefreshKeyboardMapping ((XMappingEvent
*) &event
->xmapping
);
8643 xft_settings_event (dpyinfo
, event
);
8648 #ifdef USE_X_TOOLKIT
8650 if (*finish
!= X_EVENT_DROP
)
8651 XtDispatchEvent ((XEvent
*) event
);
8653 #endif /* USE_X_TOOLKIT */
8658 if (inev
.ie
.kind
!= NO_EVENT
)
8660 kbd_buffer_store_buffered_event (&inev
, hold_quit
);
8665 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
8670 XSETFRAME (frame
, f
);
8676 any_help_event_p
= true;
8677 gen_help_event (help_echo_string
, frame
, help_echo_window
,
8678 help_echo_object
, help_echo_pos
);
8682 help_echo_string
= Qnil
;
8683 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
8692 /* Handles the XEvent EVENT on display DISPLAY.
8693 This is used for event loops outside the normal event handling,
8694 i.e. looping while a popup menu or a dialog is posted.
8696 Returns the value handle_one_xevent sets in the finish argument. */
8698 x_dispatch_event (XEvent
*event
, Display
*display
)
8700 struct x_display_info
*dpyinfo
;
8701 int finish
= X_EVENT_NORMAL
;
8703 dpyinfo
= x_display_info_for_display (display
);
8706 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
8711 /* Read events coming from the X server.
8712 Return as soon as there are no more events to be read.
8714 Return the number of characters stored into the buffer,
8715 thus pretending to be `read' (except the characters we store
8716 in the keyboard buffer can be multibyte, so are not necessarily
8720 XTread_socket (struct terminal
*terminal
, struct input_event
*hold_quit
)
8723 bool event_found
= false;
8724 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
8728 /* For debugging, this gives a way to fake an I/O error. */
8729 if (dpyinfo
== XTread_socket_fake_io_error
)
8731 XTread_socket_fake_io_error
= 0;
8732 x_io_error_quitter (dpyinfo
->display
);
8736 while (XPending (dpyinfo
->display
))
8741 XNextEvent (dpyinfo
->display
, &event
);
8744 /* Filter events for the current X input method. */
8745 if (x_filter_event (dpyinfo
, &event
))
8750 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
8752 if (finish
== X_EVENT_GOTO_OUT
)
8758 /* For GTK we must use the GTK event loop. But XEvents gets passed
8759 to our filter function above, and then to the big event switch.
8760 We use a bunch of globals to communicate with our filter function,
8761 that is kind of ugly, but it works.
8763 There is no way to do one display at the time, GTK just does events
8764 from all displays. */
8766 while (gtk_events_pending ())
8768 current_count
= count
;
8769 current_hold_quit
= hold_quit
;
8771 gtk_main_iteration ();
8773 count
= current_count
;
8775 current_hold_quit
= 0;
8777 if (current_finish
== X_EVENT_GOTO_OUT
)
8780 #endif /* USE_GTK */
8782 /* On some systems, an X bug causes Emacs to get no more events
8783 when the window is destroyed. Detect that. (1994.) */
8786 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
8787 One XNOOP in 100 loops will make Emacs terminate.
8788 B. Bretthauer, 1994 */
8790 if (x_noop_count
>= 100)
8794 if (next_noop_dpyinfo
== 0)
8795 next_noop_dpyinfo
= x_display_list
;
8797 XNoOp (next_noop_dpyinfo
->display
);
8799 /* Each time we get here, cycle through the displays now open. */
8800 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
8804 /* If the focus was just given to an auto-raising frame,
8805 raise it now. FIXME: handle more than one such frame. */
8806 if (dpyinfo
->x_pending_autoraise_frame
)
8808 x_raise_frame (dpyinfo
->x_pending_autoraise_frame
);
8809 dpyinfo
->x_pending_autoraise_frame
= NULL
;
8820 /***********************************************************************
8822 ***********************************************************************/
8824 /* Set clipping for output in glyph row ROW. W is the window in which
8825 we operate. GC is the graphics context to set clipping in.
8827 ROW may be a text row or, e.g., a mode line. Text rows must be
8828 clipped to the interior of the window dedicated to text display,
8829 mode lines must be clipped to the whole window. */
8832 x_clip_to_row (struct window
*w
, struct glyph_row
*row
,
8833 enum glyph_row_area area
, GC gc
)
8835 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8836 XRectangle clip_rect
;
8837 int window_x
, window_y
, window_width
;
8839 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
8841 clip_rect
.x
= window_x
;
8842 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
8843 clip_rect
.y
= max (clip_rect
.y
, window_y
);
8844 clip_rect
.width
= window_width
;
8845 clip_rect
.height
= row
->visible_height
;
8847 x_set_clip_rectangles (f
, gc
, &clip_rect
, 1);
8851 /* Draw a hollow box cursor on window W in glyph row ROW. */
8854 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
8856 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8857 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8858 Display
*dpy
= FRAME_X_DISPLAY (f
);
8861 struct glyph
*cursor_glyph
;
8864 /* Get the glyph the cursor is on. If we can't tell because
8865 the current matrix is invalid or such, give up. */
8866 cursor_glyph
= get_phys_cursor_glyph (w
);
8867 if (cursor_glyph
== NULL
)
8870 /* Compute frame-relative coordinates for phys cursor. */
8871 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
8872 wd
= w
->phys_cursor_width
- 1;
8874 /* The foreground of cursor_gc is typically the same as the normal
8875 background color, which can cause the cursor box to be invisible. */
8876 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
8877 if (dpyinfo
->scratch_cursor_gc
)
8878 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
8880 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
8881 GCForeground
, &xgcv
);
8882 gc
= dpyinfo
->scratch_cursor_gc
;
8884 /* When on R2L character, show cursor at the right edge of the
8885 glyph, unless the cursor box is as wide as the glyph or wider
8886 (the latter happens when x-stretch-cursor is non-nil). */
8887 if ((cursor_glyph
->resolved_level
& 1) != 0
8888 && cursor_glyph
->pixel_width
> wd
)
8890 x
+= cursor_glyph
->pixel_width
- wd
;
8894 /* Set clipping, draw the rectangle, and reset clipping again. */
8895 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
8896 x_draw_rectangle (f
, gc
, x
, y
, wd
, h
- 1);
8897 x_reset_clip_rectangles (f
, gc
);
8901 /* Draw a bar cursor on window W in glyph row ROW.
8903 Implementation note: One would like to draw a bar cursor with an
8904 angle equal to the one given by the font property XA_ITALIC_ANGLE.
8905 Unfortunately, I didn't find a font yet that has this property set.
8909 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
8911 struct frame
*f
= XFRAME (w
->frame
);
8912 struct glyph
*cursor_glyph
;
8914 /* If cursor is out of bounds, don't draw garbage. This can happen
8915 in mini-buffer windows when switching between echo area glyphs
8917 cursor_glyph
= get_phys_cursor_glyph (w
);
8918 if (cursor_glyph
== NULL
)
8921 /* Experimental avoidance of cursor on xwidget. */
8922 if (cursor_glyph
->type
== XWIDGET_GLYPH
)
8925 /* If on an image, draw like a normal cursor. That's usually better
8926 visible than drawing a bar, esp. if the image is large so that
8927 the bar might not be in the window. */
8928 if (cursor_glyph
->type
== IMAGE_GLYPH
)
8930 struct glyph_row
*r
;
8931 r
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
8932 draw_phys_cursor_glyph (w
, r
, DRAW_CURSOR
);
8936 Display
*dpy
= FRAME_X_DISPLAY (f
);
8937 Window window
= FRAME_X_WINDOW (f
);
8938 GC gc
= FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
;
8939 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
8940 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
8943 /* If the glyph's background equals the color we normally draw
8944 the bars cursor in, the bar cursor in its normal color is
8945 invisible. Use the glyph's foreground color instead in this
8946 case, on the assumption that the glyph's colors are chosen so
8947 that the glyph is legible. */
8948 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
8949 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
8951 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
8952 xgcv
.graphics_exposures
= False
;
8955 XChangeGC (dpy
, gc
, mask
, &xgcv
);
8958 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
8959 FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
8962 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
8964 if (kind
== BAR_CURSOR
)
8966 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8969 width
= FRAME_CURSOR_WIDTH (f
);
8970 width
= min (cursor_glyph
->pixel_width
, width
);
8972 w
->phys_cursor_width
= width
;
8974 /* If the character under cursor is R2L, draw the bar cursor
8975 on the right of its glyph, rather than on the left. */
8976 if ((cursor_glyph
->resolved_level
& 1) != 0)
8977 x
+= cursor_glyph
->pixel_width
- width
;
8979 x_fill_rectangle (f
, gc
, x
,
8980 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
8981 width
, row
->height
);
8983 else /* HBAR_CURSOR */
8985 int dummy_x
, dummy_y
, dummy_h
;
8986 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8989 width
= row
->height
;
8991 width
= min (row
->height
, width
);
8993 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
8994 &dummy_y
, &dummy_h
);
8996 if ((cursor_glyph
->resolved_level
& 1) != 0
8997 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
- 1)
8998 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
+ 1;
8999 x_fill_rectangle (f
, gc
, x
,
9000 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
9001 row
->height
- width
),
9002 w
->phys_cursor_width
- 1, width
);
9005 x_reset_clip_rectangles (f
, gc
);
9010 /* RIF: Define cursor CURSOR on frame F. */
9013 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
9015 if (!f
->pointer_invisible
9016 && f
->output_data
.x
->current_cursor
!= cursor
)
9017 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
9018 f
->output_data
.x
->current_cursor
= cursor
;
9022 /* RIF: Clear area on frame F. */
9025 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
9027 x_clear_area (f
, x
, y
, width
, height
);
9029 /* Must queue a redraw, because scroll bars might have been cleared. */
9030 if (FRAME_GTK_WIDGET (f
))
9031 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
9036 /* RIF: Draw cursor on window W. */
9039 x_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
, int x
,
9040 int y
, enum text_cursor_kinds cursor_type
,
9041 int cursor_width
, bool on_p
, bool active_p
)
9043 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
9047 w
->phys_cursor_type
= cursor_type
;
9048 w
->phys_cursor_on_p
= true;
9050 if (glyph_row
->exact_window_width_line_p
9051 && (glyph_row
->reversed_p
9052 ? (w
->phys_cursor
.hpos
< 0)
9053 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
9055 glyph_row
->cursor_in_fringe_p
= true;
9056 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
9060 switch (cursor_type
)
9062 case HOLLOW_BOX_CURSOR
:
9063 x_draw_hollow_cursor (w
, glyph_row
);
9066 case FILLED_BOX_CURSOR
:
9067 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
9071 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
9075 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
9079 w
->phys_cursor_width
= 0;
9088 if (w
== XWINDOW (f
->selected_window
))
9089 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
9090 xic_set_preeditarea (w
, x
, y
);
9094 XFlush (FRAME_X_DISPLAY (f
));
9100 /* Make the x-window of frame F use the gnu icon bitmap. */
9103 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
9105 ptrdiff_t bitmap_id
;
9107 if (FRAME_X_WINDOW (f
) == 0)
9110 /* Free up our existing icon bitmap and mask if any. */
9111 if (f
->output_data
.x
->icon_bitmap
> 0)
9112 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
9113 f
->output_data
.x
->icon_bitmap
= 0;
9118 /* Use gtk_window_set_icon_from_file () if available,
9119 It's not restricted to bitmaps */
9120 if (xg_set_icon (f
, file
))
9122 #endif /* USE_GTK */
9123 bitmap_id
= x_create_bitmap_from_file (f
, file
);
9124 x_create_bitmap_mask (f
, bitmap_id
);
9128 /* Create the GNU bitmap and mask if necessary. */
9129 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
9135 if (xg_set_icon (f
, xg_default_icon_file
)
9136 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
9138 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= -2;
9142 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
9144 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
9146 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
9150 /* If all else fails, use the (black and white) xbm image. */
9153 rc
= x_create_bitmap_from_data (f
, (char *) gnu_xbm_bits
,
9154 gnu_xbm_width
, gnu_xbm_height
);
9158 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
9159 x_create_bitmap_mask (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
9163 /* The first time we create the GNU bitmap and mask,
9164 this increments the ref-count one extra time.
9165 As a result, the GNU bitmap and mask are never freed.
9166 That way, we don't have to worry about allocating it again. */
9167 x_reference_bitmap (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
9169 bitmap_id
= FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
;
9172 x_wm_set_icon_pixmap (f
, bitmap_id
);
9173 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
9179 /* Make the x-window of frame F use a rectangle with text.
9180 Use ICON_NAME as the text. */
9183 x_text_icon (struct frame
*f
, const char *icon_name
)
9185 if (FRAME_X_WINDOW (f
) == 0)
9190 text
.value
= (unsigned char *) icon_name
;
9191 text
.encoding
= XA_STRING
;
9193 text
.nitems
= strlen (icon_name
);
9194 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
9197 if (f
->output_data
.x
->icon_bitmap
> 0)
9198 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
9199 f
->output_data
.x
->icon_bitmap
= 0;
9200 x_wm_set_icon_pixmap (f
, 0);
9205 #define X_ERROR_MESSAGE_SIZE 200
9207 /* If non-nil, this should be a string.
9208 It means catch X errors and store the error message in this string.
9210 The reason we use a stack is that x_catch_error/x_uncatch_error can
9211 be called from a signal handler.
9214 struct x_error_message_stack
{
9215 char string
[X_ERROR_MESSAGE_SIZE
];
9217 x_special_error_handler handler
;
9219 struct x_error_message_stack
*prev
;
9221 static struct x_error_message_stack
*x_error_message
;
9223 /* An X error handler which stores the error message in
9224 *x_error_message. This is called from x_error_handler if
9225 x_catch_errors is in effect. */
9228 x_error_catcher (Display
*display
, XErrorEvent
*event
)
9230 XGetErrorText (display
, event
->error_code
,
9231 x_error_message
->string
,
9232 X_ERROR_MESSAGE_SIZE
);
9233 if (x_error_message
->handler
)
9234 x_error_message
->handler (display
, event
, x_error_message
->string
,
9235 x_error_message
->handler_data
);
9238 /* Begin trapping X errors for display DPY. Actually we trap X errors
9239 for all displays, but DPY should be the display you are actually
9242 After calling this function, X protocol errors no longer cause
9243 Emacs to exit; instead, they are recorded in the string
9244 stored in *x_error_message.
9246 Calling x_check_errors signals an Emacs error if an X error has
9247 occurred since the last call to x_catch_errors or x_check_errors.
9249 Calling x_uncatch_errors resumes the normal error handling.
9250 Calling x_uncatch_errors_after_check is similar, but skips an XSync
9251 to the server, and should be used only immediately after
9252 x_had_errors_p or x_check_errors. */
9255 x_catch_errors_with_handler (Display
*dpy
, x_special_error_handler handler
,
9258 struct x_error_message_stack
*data
= xmalloc (sizeof *data
);
9260 /* Make sure any errors from previous requests have been dealt with. */
9264 data
->string
[0] = 0;
9265 data
->handler
= handler
;
9266 data
->handler_data
= handler_data
;
9267 data
->prev
= x_error_message
;
9268 x_error_message
= data
;
9272 x_catch_errors (Display
*dpy
)
9274 x_catch_errors_with_handler (dpy
, NULL
, NULL
);
9277 /* Undo the last x_catch_errors call.
9278 DPY should be the display that was passed to x_catch_errors.
9280 This version should be used only if the immediately preceding
9281 X-protocol-related thing was x_check_errors or x_had_error_p, both
9282 of which issue XSync calls, so we don't need to re-sync here. */
9285 x_uncatch_errors_after_check (void)
9287 struct x_error_message_stack
*tmp
;
9290 tmp
= x_error_message
;
9291 x_error_message
= x_error_message
->prev
;
9296 /* Undo the last x_catch_errors call.
9297 DPY should be the display that was passed to x_catch_errors. */
9300 x_uncatch_errors (void)
9302 struct x_error_message_stack
*tmp
;
9306 /* The display may have been closed before this function is called.
9307 Check if it is still open before calling XSync. */
9308 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
9309 XSync (x_error_message
->dpy
, False
);
9311 tmp
= x_error_message
;
9312 x_error_message
= x_error_message
->prev
;
9317 /* If any X protocol errors have arrived since the last call to
9318 x_catch_errors or x_check_errors, signal an Emacs error using
9319 sprintf (a buffer, FORMAT, the x error message text) as the text. */
9322 x_check_errors (Display
*dpy
, const char *format
)
9324 /* Make sure to catch any errors incurred so far. */
9327 if (x_error_message
->string
[0])
9329 char string
[X_ERROR_MESSAGE_SIZE
];
9330 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
9331 x_uncatch_errors ();
9332 error (format
, string
);
9336 /* Nonzero if we had any X protocol errors
9337 since we did x_catch_errors on DPY. */
9340 x_had_errors_p (Display
*dpy
)
9342 /* Make sure to catch any errors incurred so far. */
9345 return x_error_message
->string
[0] != 0;
9348 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
9351 x_clear_errors (Display
*dpy
)
9353 x_error_message
->string
[0] = 0;
9357 /* See comment in unwind_to_catch why calling this is a bad
9358 * idea. --lorentey */
9359 /* Close off all unclosed x_catch_errors calls. */
9362 x_fully_uncatch_errors (void)
9364 while (x_error_message
)
9365 x_uncatch_errors ();
9370 static unsigned int x_wire_count
;
9373 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
9378 /************************************************************************
9380 ************************************************************************/
9382 /* Error message passed to x_connection_closed. */
9384 static char *error_msg
;
9386 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
9387 the text of an error message that lead to the connection loss. */
9389 static _Noreturn
void
9390 x_connection_closed (Display
*dpy
, const char *error_message
, bool ioerror
)
9392 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
9393 Lisp_Object frame
, tail
;
9394 ptrdiff_t idx
= SPECPDL_INDEX ();
9396 error_msg
= alloca (strlen (error_message
) + 1);
9397 strcpy (error_msg
, error_message
);
9399 /* Inhibit redisplay while frames are being deleted. */
9400 specbind (Qinhibit_redisplay
, Qt
);
9404 /* Protect display from being closed when we delete the last
9406 dpyinfo
->reference_count
++;
9407 dpyinfo
->terminal
->reference_count
++;
9409 if (ioerror
) dpyinfo
->display
= 0;
9411 /* First delete frames whose mini-buffers are on frames
9412 that are on the dead display. */
9413 FOR_EACH_FRAME (tail
, frame
)
9415 Lisp_Object minibuf_frame
;
9417 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
9418 if (FRAME_X_P (XFRAME (frame
))
9419 && FRAME_X_P (XFRAME (minibuf_frame
))
9420 && ! EQ (frame
, minibuf_frame
)
9421 && FRAME_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
9422 delete_frame (frame
, Qnoelisp
);
9425 /* Now delete all remaining frames on the dead display.
9426 We are now sure none of these is used as the mini-buffer
9427 for another frame that we need to delete. */
9428 FOR_EACH_FRAME (tail
, frame
)
9429 if (FRAME_X_P (XFRAME (frame
))
9430 && FRAME_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
9432 /* Set this to t so that delete_frame won't get confused
9433 trying to find a replacement. */
9434 kset_default_minibuffer_frame (FRAME_KBOARD (XFRAME (frame
)), Qt
);
9435 delete_frame (frame
, Qnoelisp
);
9438 /* If DPYINFO is null, this means we didn't open the display in the
9439 first place, so don't try to close it. */
9442 /* We can not call XtCloseDisplay here because it calls XSync.
9443 XSync inside the error handler apparently hangs Emacs. On
9444 current Xt versions, this isn't needed either. */
9446 /* A long-standing GTK bug prevents proper disconnect handling
9447 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Once,
9448 the resulting Glib error message loop filled a user's disk.
9449 To avoid this, kill Emacs unconditionally on disconnect. */
9450 shut_down_emacs (0, Qnil
);
9451 fprintf (stderr
, "%s\n\
9452 When compiled with GTK, Emacs cannot recover from X disconnects.\n\
9453 This is a GTK bug: https://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
9454 For details, see etc/PROBLEMS.\n",
9457 #endif /* USE_GTK */
9459 /* Indicate that this display is dead. */
9460 dpyinfo
->display
= 0;
9462 dpyinfo
->reference_count
--;
9463 dpyinfo
->terminal
->reference_count
--;
9464 if (dpyinfo
->reference_count
!= 0)
9465 /* We have just closed all frames on this display. */
9470 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
9471 Fdelete_terminal (tmp
, Qnoelisp
);
9475 if (terminal_list
== 0)
9477 fprintf (stderr
, "%s\n", error_msg
);
9478 Fkill_emacs (make_number (70));
9482 totally_unblock_input ();
9484 unbind_to (idx
, Qnil
);
9485 clear_waiting_for_input ();
9487 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
9488 longjmp), because returning from this function would get us back into
9489 Xlib's code which will directly call `exit'. */
9490 error ("%s", error_msg
);
9493 /* We specifically use it before defining it, so that gcc doesn't inline it,
9494 otherwise gdb doesn't know how to properly put a breakpoint on it. */
9495 static void x_error_quitter (Display
*, XErrorEvent
*);
9497 /* This is the first-level handler for X protocol errors.
9498 It calls x_error_quitter or x_error_catcher. */
9501 x_error_handler (Display
*display
, XErrorEvent
*event
)
9503 #if defined USE_GTK && defined HAVE_GTK3
9504 if ((event
->error_code
== BadMatch
|| event
->error_code
== BadWindow
)
9505 && event
->request_code
== X_SetInputFocus
)
9511 if (x_error_message
)
9512 x_error_catcher (display
, event
);
9514 x_error_quitter (display
, event
);
9518 /* This is the usual handler for X protocol errors.
9519 It kills all frames on the display that we got the error for.
9520 If that was the only one, it prints an error message and kills Emacs. */
9522 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
9524 /* On older GCC versions, just putting x_error_quitter
9525 after x_error_handler prevents inlining into the former. */
9527 static void NO_INLINE
9528 x_error_quitter (Display
*display
, XErrorEvent
*event
)
9530 char buf
[256], buf1
[356];
9532 /* Ignore BadName errors. They can happen because of fonts
9533 or colors that are not defined. */
9535 if (event
->error_code
== BadName
)
9538 /* Note that there is no real way portable across R3/R4 to get the
9539 original error handler. */
9541 XGetErrorText (display
, event
->error_code
, buf
, sizeof (buf
));
9542 sprintf (buf1
, "X protocol error: %s on protocol request %d",
9543 buf
, event
->request_code
);
9544 x_connection_closed (display
, buf1
, false);
9548 /* This is the handler for X IO errors, always.
9549 It kills all frames on the display that we lost touch with.
9550 If that was the only one, it prints an error message and kills Emacs. */
9552 static _Noreturn
int
9553 x_io_error_quitter (Display
*display
)
9557 snprintf (buf
, sizeof buf
, "Connection lost to X server '%s'",
9558 DisplayString (display
));
9559 x_connection_closed (display
, buf
, true);
9563 /* Changing the font of the frame. */
9565 /* Give frame F the font FONT-OBJECT as its default font. The return
9566 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
9567 frame. If it is negative, generate a new fontset from
9571 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
9573 struct font
*font
= XFONT_OBJECT (font_object
);
9574 int unit
, font_ascent
, font_descent
;
9575 #ifndef USE_X_TOOLKIT
9576 int old_menu_bar_height
= FRAME_MENU_BAR_HEIGHT (f
);
9577 Lisp_Object fullscreen
;
9581 fontset
= fontset_from_font (font_object
);
9582 FRAME_FONTSET (f
) = fontset
;
9583 if (FRAME_FONT (f
) == font
)
9584 /* This font is already set in frame F. There's nothing more to
9588 FRAME_FONT (f
) = font
;
9589 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
9590 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
9591 get_font_ascent_descent (font
, &font_ascent
, &font_descent
);
9592 FRAME_LINE_HEIGHT (f
) = font_ascent
+ font_descent
;
9594 #ifndef USE_X_TOOLKIT
9595 FRAME_MENU_BAR_HEIGHT (f
) = FRAME_MENU_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
);
9598 /* Compute character columns occupied by scrollbar.
9600 Don't do things differently for non-toolkit scrollbars
9602 unit
= FRAME_COLUMN_WIDTH (f
);
9603 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
9604 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
9605 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
9607 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
9609 if (FRAME_X_WINDOW (f
) != 0)
9611 /* Don't change the size of a tip frame; there's no point in
9612 doing it because it's done in Fx_show_tip, and it leads to
9613 problems because the tip frame has no widget. */
9614 if (!FRAME_TOOLTIP_P (f
))
9616 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
9617 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
9619 #ifndef USE_X_TOOLKIT
9620 if (FRAME_MENU_BAR_HEIGHT (f
) != old_menu_bar_height
9621 && !f
->after_make_frame
9622 && (EQ (frame_inhibit_implied_resize
, Qt
)
9623 || (CONSP (frame_inhibit_implied_resize
)
9624 && NILP (Fmemq (Qfont
, frame_inhibit_implied_resize
))))
9625 && (NILP (fullscreen
= get_frame_param (f
, Qfullscreen
))
9626 || EQ (fullscreen
, Qfullwidth
)))
9627 /* If the menu bar height changes, try to keep text height
9630 (f
, -1, FRAME_TEXT_HEIGHT (f
) + FRAME_MENU_BAR_HEIGHT (f
)
9631 - old_menu_bar_height
, 1, false, Qfont
);
9632 #endif /* USE_X_TOOLKIT */
9638 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
9641 xic_set_xfontset (f
, SSDATA (fontset_ascii (fontset
)));
9650 /***********************************************************************
9652 ***********************************************************************/
9658 /* XIM destroy callback function, which is called whenever the
9659 connection to input method XIM dies. CLIENT_DATA contains a
9660 pointer to the x_display_info structure corresponding to XIM. */
9663 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
9665 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
9666 Lisp_Object frame
, tail
;
9670 /* No need to call XDestroyIC.. */
9671 FOR_EACH_FRAME (tail
, frame
)
9673 struct frame
*f
= XFRAME (frame
);
9674 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
9676 FRAME_XIC (f
) = NULL
;
9677 xic_free_xfontset (f
);
9681 /* No need to call XCloseIM. */
9682 dpyinfo
->xim
= NULL
;
9683 XFree (dpyinfo
->xim_styles
);
9687 #endif /* HAVE_X11R6 */
9689 /* Open the connection to the XIM server on display DPYINFO.
9690 RESOURCE_NAME is the resource name Emacs uses. */
9693 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
9701 XCloseIM (dpyinfo
->xim
);
9702 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
9709 XIMCallback destroy
;
9712 /* Get supported styles and XIM values. */
9713 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
9716 destroy
.callback
= xim_destroy_callback
;
9717 destroy
.client_data
= (XPointer
)dpyinfo
;
9718 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
9724 #endif /* HAVE_XIM */
9725 dpyinfo
->xim
= NULL
;
9729 #ifdef HAVE_X11R6_XIM
9731 /* XIM instantiate callback function, which is called whenever an XIM
9732 server is available. DISPLAY is the display of the XIM.
9733 CLIENT_DATA contains a pointer to an xim_inst_t structure created
9734 when the callback was registered. */
9737 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
9739 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
9740 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
9742 /* We don't support multiple XIM connections. */
9746 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
9748 /* Create XIC for the existing frames on the same display, as long
9749 as they have no XIC. */
9750 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
9752 Lisp_Object tail
, frame
;
9755 FOR_EACH_FRAME (tail
, frame
)
9757 struct frame
*f
= XFRAME (frame
);
9760 && FRAME_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
9761 if (FRAME_XIC (f
) == NULL
)
9763 create_frame_xic (f
);
9764 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
9765 xic_set_statusarea (f
);
9766 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
9768 struct window
*w
= XWINDOW (f
->selected_window
);
9769 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
9778 #endif /* HAVE_X11R6_XIM */
9781 /* Open a connection to the XIM server on display DPYINFO.
9782 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
9783 connection only at the first time. On X11R6, open the connection
9784 in the XIM instantiate callback function. */
9787 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
9789 dpyinfo
->xim
= NULL
;
9793 #ifdef HAVE_X11R6_XIM
9794 struct xim_inst_t
*xim_inst
= xmalloc (sizeof *xim_inst
);
9797 dpyinfo
->xim_callback_data
= xim_inst
;
9798 xim_inst
->dpyinfo
= dpyinfo
;
9799 xim_inst
->resource_name
= xstrdup (resource_name
);
9800 ret
= XRegisterIMInstantiateCallback
9801 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
9802 emacs_class
, xim_instantiate_callback
,
9803 /* This is XPointer in XFree86 but (XPointer *)
9804 on Tru64, at least, hence the configure test. */
9805 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
9806 eassert (ret
== True
);
9807 #else /* not HAVE_X11R6_XIM */
9808 xim_open_dpy (dpyinfo
, resource_name
);
9809 #endif /* not HAVE_X11R6_XIM */
9811 #endif /* HAVE_XIM */
9815 /* Close the connection to the XIM server on display DPYINFO. */
9818 xim_close_dpy (struct x_display_info
*dpyinfo
)
9823 #ifdef HAVE_X11R6_XIM
9824 struct xim_inst_t
*xim_inst
= dpyinfo
->xim_callback_data
;
9826 if (dpyinfo
->display
)
9828 Bool ret
= XUnregisterIMInstantiateCallback
9829 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
9830 emacs_class
, xim_instantiate_callback
,
9831 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
9832 eassert (ret
== True
);
9834 xfree (xim_inst
->resource_name
);
9836 #endif /* HAVE_X11R6_XIM */
9837 if (dpyinfo
->display
)
9838 XCloseIM (dpyinfo
->xim
);
9839 dpyinfo
->xim
= NULL
;
9840 XFree (dpyinfo
->xim_styles
);
9842 #endif /* HAVE_XIM */
9845 #endif /* not HAVE_X11R6_XIM */
9849 /* Calculate the absolute position in frame F
9850 from its current recorded position values and gravity. */
9853 x_calc_absolute_position (struct frame
*f
)
9855 int flags
= f
->size_hint_flags
;
9857 /* We have nothing to do if the current position
9858 is already for the top-left corner. */
9859 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
9862 /* Treat negative positions as relative to the leftmost bottommost
9863 position that fits on the screen. */
9864 if (flags
& XNegative
)
9865 f
->left_pos
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
9866 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
9869 int height
= FRAME_PIXEL_HEIGHT (f
);
9871 #if defined USE_X_TOOLKIT && defined USE_MOTIF
9872 /* Something is fishy here. When using Motif, starting Emacs with
9873 `-g -0-0', the frame appears too low by a few pixels.
9875 This seems to be so because initially, while Emacs is starting,
9876 the column widget's height and the frame's pixel height are
9877 different. The column widget's height is the right one. In
9878 later invocations, when Emacs is up, the frame's pixel height
9881 It's not obvious where the initial small difference comes from.
9882 2000-12-01, gerd. */
9884 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
9887 if (flags
& YNegative
)
9888 f
->top_pos
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
9889 - height
+ f
->top_pos
;
9892 /* The left_pos and top_pos
9893 are now relative to the top and left screen edges,
9894 so the flags should correspond. */
9895 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9898 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
9899 to really change the position, and 0 when calling from
9900 x_make_frame_visible (in that case, XOFF and YOFF are the current
9901 position values). It is -1 when calling from x_set_frame_parameters,
9902 which means, do adjust for borders but don't change the gravity. */
9905 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
9907 int modified_top
, modified_left
;
9909 if (change_gravity
> 0)
9913 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9915 f
->size_hint_flags
|= XNegative
;
9917 f
->size_hint_flags
|= YNegative
;
9918 f
->win_gravity
= NorthWestGravity
;
9920 x_calc_absolute_position (f
);
9923 x_wm_set_size_hint (f
, 0, false);
9925 modified_left
= f
->left_pos
;
9926 modified_top
= f
->top_pos
;
9928 if (change_gravity
!= 0 && FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
9930 /* Some WMs (twm, wmaker at least) has an offset that is smaller
9931 than the WM decorations. So we use the calculated offset instead
9932 of the WM decoration sizes here (x/y_pixels_outer_diff). */
9933 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
9934 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
9937 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9938 modified_left
, modified_top
);
9940 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
9941 FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
);
9943 /* change_gravity is non-zero when this function is called from Lisp to
9944 programmatically move a frame. In that case, we call
9945 x_check_expected_move to discover if we have a "Type A" or "Type B"
9946 window manager, and, for a "Type A" window manager, adjust the position
9949 We call x_check_expected_move if a programmatic move occurred, and
9950 either the window manager type (A/B) is unknown or it is Type A but we
9951 need to compute the top/left offset adjustment for this frame. */
9953 if (change_gravity
!= 0
9954 && (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
9955 || (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
9956 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
9957 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
9958 x_check_expected_move (f
, modified_left
, modified_top
);
9963 /* Return true if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
9964 on the root window for frame F contains ATOMNAME.
9965 This is how a WM check shall be done according to the Window Manager
9966 Specification/Extended Window Manager Hints at
9967 http://freedesktop.org/wiki/Specifications/wm-spec. */
9970 x_wm_supports (struct frame
*f
, Atom want_atom
)
9973 unsigned long actual_size
, bytes_remaining
;
9974 int i
, rc
, actual_format
;
9976 Window wmcheck_window
;
9977 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9978 Window target_window
= dpyinfo
->root_window
;
9979 int max_len
= 65536;
9980 Display
*dpy
= FRAME_X_DISPLAY (f
);
9981 unsigned char *tmp_data
= NULL
;
9982 Atom target_type
= XA_WINDOW
;
9986 x_catch_errors (dpy
);
9987 rc
= XGetWindowProperty (dpy
, target_window
,
9988 dpyinfo
->Xatom_net_supporting_wm_check
,
9989 0, max_len
, False
, target_type
,
9990 &actual_type
, &actual_format
, &actual_size
,
9991 &bytes_remaining
, &tmp_data
);
9993 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
9995 if (tmp_data
) XFree (tmp_data
);
9996 x_uncatch_errors ();
10001 wmcheck_window
= *(Window
*) tmp_data
;
10004 /* Check if window exists. */
10005 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
10006 if (x_had_errors_p (dpy
))
10008 x_uncatch_errors_after_check ();
10013 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
10015 /* Window changed, reload atoms */
10016 if (dpyinfo
->net_supported_atoms
!= NULL
)
10017 XFree (dpyinfo
->net_supported_atoms
);
10018 dpyinfo
->net_supported_atoms
= NULL
;
10019 dpyinfo
->nr_net_supported_atoms
= 0;
10020 dpyinfo
->net_supported_window
= 0;
10022 target_type
= XA_ATOM
;
10024 rc
= XGetWindowProperty (dpy
, target_window
,
10025 dpyinfo
->Xatom_net_supported
,
10026 0, max_len
, False
, target_type
,
10027 &actual_type
, &actual_format
, &actual_size
,
10028 &bytes_remaining
, &tmp_data
);
10030 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
10032 if (tmp_data
) XFree (tmp_data
);
10033 x_uncatch_errors ();
10038 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
10039 dpyinfo
->nr_net_supported_atoms
= actual_size
;
10040 dpyinfo
->net_supported_window
= wmcheck_window
;
10045 for (i
= 0; !ret
&& i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
10046 ret
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
10048 x_uncatch_errors ();
10055 set_wm_state (Lisp_Object frame
, bool add
, Atom atom
, Atom value
)
10057 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (XFRAME (frame
));
10059 x_send_client_event (frame
, make_number (0), frame
,
10060 dpyinfo
->Xatom_net_wm_state
,
10062 /* 1 = add, 0 = remove */
10064 (make_number (add
),
10066 (make_fixnum_or_float (atom
),
10068 ? list1 (make_fixnum_or_float (value
))
10073 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
10076 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10078 XSETFRAME (frame
, f
);
10080 set_wm_state (frame
, !NILP (new_value
),
10081 dpyinfo
->Xatom_net_wm_state_sticky
, None
);
10084 /* Return the current _NET_WM_STATE.
10085 SIZE_STATE is set to one of the FULLSCREEN_* values.
10086 Set *STICKY to the sticky state.
10088 Return true iff we are not hidden. */
10091 get_current_wm_state (struct frame
*f
,
10096 unsigned long actual_size
;
10098 bool is_hidden
= false;
10099 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10100 long max_len
= 65536;
10101 Atom target_type
= XA_ATOM
;
10102 /* If XCB is available, we can avoid three XSync calls. */
10104 xcb_get_property_cookie_t prop_cookie
;
10105 xcb_get_property_reply_t
*prop
;
10106 xcb_atom_t
*reply_data
;
10108 Display
*dpy
= FRAME_X_DISPLAY (f
);
10109 unsigned long bytes_remaining
;
10110 int rc
, actual_format
;
10112 unsigned char *tmp_data
= NULL
;
10117 *size_state
= FULLSCREEN_NONE
;
10122 prop_cookie
= xcb_get_property (dpyinfo
->xcb_connection
, 0, window
,
10123 dpyinfo
->Xatom_net_wm_state
,
10124 target_type
, 0, max_len
);
10125 prop
= xcb_get_property_reply (dpyinfo
->xcb_connection
, prop_cookie
, NULL
);
10126 if (prop
&& prop
->type
== target_type
)
10128 int actual_bytes
= xcb_get_property_value_length (prop
);
10129 eassume (0 <= actual_bytes
);
10130 actual_size
= actual_bytes
/ sizeof *reply_data
;
10131 reply_data
= xcb_get_property_value (prop
);
10136 is_hidden
= FRAME_ICONIFIED_P (f
);
10139 x_catch_errors (dpy
);
10140 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
10141 0, max_len
, False
, target_type
,
10142 &actual_type
, &actual_format
, &actual_size
,
10143 &bytes_remaining
, &tmp_data
);
10145 if (rc
== Success
&& actual_type
== target_type
&& ! x_had_errors_p (dpy
))
10146 reply_data
= (Atom
*) tmp_data
;
10150 is_hidden
= FRAME_ICONIFIED_P (f
);
10153 x_uncatch_errors ();
10156 for (i
= 0; i
< actual_size
; ++i
)
10158 Atom a
= reply_data
[i
];
10159 if (a
== dpyinfo
->Xatom_net_wm_state_hidden
)
10161 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
10163 if (*size_state
== FULLSCREEN_HEIGHT
)
10164 *size_state
= FULLSCREEN_MAXIMIZED
;
10166 *size_state
= FULLSCREEN_WIDTH
;
10168 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
10170 if (*size_state
== FULLSCREEN_WIDTH
)
10171 *size_state
= FULLSCREEN_MAXIMIZED
;
10173 *size_state
= FULLSCREEN_HEIGHT
;
10175 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen
)
10176 *size_state
= FULLSCREEN_BOTH
;
10177 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
10184 if (tmp_data
) XFree (tmp_data
);
10188 return ! is_hidden
;
10191 /* Do fullscreen as specified in extended window manager hints */
10194 do_ewmh_fullscreen (struct frame
*f
)
10196 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10197 bool have_net_atom
= x_wm_supports (f
, dpyinfo
->Xatom_net_wm_state
);
10201 get_current_wm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
10203 /* Some window managers don't say they support _NET_WM_STATE, but they do say
10204 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
10205 if (!have_net_atom
)
10206 have_net_atom
= x_wm_supports (f
, dpyinfo
->Xatom_net_wm_state_fullscreen
);
10208 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
10212 XSETFRAME (frame
, f
);
10214 /* Keep number of calls to set_wm_state as low as possible.
10215 Some window managers, or possible Gtk+, hangs when too many
10216 are sent at once. */
10217 switch (f
->want_fullscreen
)
10219 case FULLSCREEN_BOTH
:
10220 if (cur
!= FULLSCREEN_BOTH
)
10221 set_wm_state (frame
, true, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10224 case FULLSCREEN_WIDTH
:
10225 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_MAXIMIZED
)
10227 set_wm_state (frame
, false,
10228 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10229 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10230 set_wm_state (frame
, true,
10231 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10235 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
10236 || cur
== FULLSCREEN_MAXIMIZED
)
10237 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10238 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10239 if (cur
!= FULLSCREEN_MAXIMIZED
|| x_frame_normalize_before_maximize
)
10240 set_wm_state (frame
, true,
10241 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10244 case FULLSCREEN_HEIGHT
:
10245 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_MAXIMIZED
)
10247 set_wm_state (frame
, false,
10248 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10249 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10250 set_wm_state (frame
, true,
10251 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
10255 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
10256 || cur
== FULLSCREEN_MAXIMIZED
)
10257 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10258 dpyinfo
->Xatom_net_wm_state_maximized_horz
);
10259 if (cur
!= FULLSCREEN_MAXIMIZED
|| x_frame_normalize_before_maximize
)
10260 set_wm_state (frame
, true,
10261 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
10264 case FULLSCREEN_MAXIMIZED
:
10265 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_BOTH
)
10267 set_wm_state (frame
, false,
10268 dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
10269 set_wm_state (frame
, true,
10270 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10271 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10273 else if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_WIDTH
)
10275 set_wm_state (frame
, false,
10276 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10277 set_wm_state (frame
, true,
10278 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10279 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10281 else if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_HEIGHT
)
10283 set_wm_state (frame
, false,
10284 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
10285 set_wm_state (frame
, true,
10286 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10287 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10291 if (cur
== FULLSCREEN_BOTH
)
10292 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10294 else if (cur
== FULLSCREEN_HEIGHT
)
10295 set_wm_state (frame
, true,
10296 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10297 else if (cur
== FULLSCREEN_WIDTH
)
10298 set_wm_state (frame
, true, None
,
10299 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10301 set_wm_state (frame
, true,
10302 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10303 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10306 case FULLSCREEN_NONE
:
10307 if (cur
== FULLSCREEN_BOTH
)
10308 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10311 set_wm_state (frame
, false,
10312 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10313 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10316 f
->want_fullscreen
= FULLSCREEN_NONE
;
10320 return have_net_atom
;
10324 XTfullscreen_hook (struct frame
*f
)
10326 if (FRAME_VISIBLE_P (f
))
10329 x_check_fullscreen (f
);
10337 x_handle_net_wm_state (struct frame
*f
, const XPropertyEvent
*event
)
10339 int value
= FULLSCREEN_NONE
;
10341 bool sticky
= false;
10342 bool not_hidden
= get_current_wm_state (f
, event
->window
, &value
, &sticky
);
10347 case FULLSCREEN_WIDTH
:
10350 case FULLSCREEN_HEIGHT
:
10351 lval
= Qfullheight
;
10353 case FULLSCREEN_BOTH
:
10356 case FULLSCREEN_MAXIMIZED
:
10361 frame_size_history_add
10362 (f
, Qx_handle_net_wm_state
, 0, 0,
10363 list2 (get_frame_param (f
, Qfullscreen
), lval
));
10365 store_frame_param (f
, Qfullscreen
, lval
);
10366 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
10371 /* Check if we need to resize the frame due to a fullscreen request.
10372 If so needed, resize the frame. */
10374 x_check_fullscreen (struct frame
*f
)
10376 Lisp_Object lval
= Qnil
;
10378 if (do_ewmh_fullscreen (f
))
10381 if (f
->output_data
.x
->parent_desc
!= FRAME_DISPLAY_INFO (f
)->root_window
)
10382 return; /* Only fullscreen without WM or with EWM hints (above). */
10384 /* Setting fullscreen to nil doesn't do anything. We could save the
10385 last non-fullscreen size and restore it, but it seems like a
10386 lot of work for this unusual case (no window manager running). */
10388 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
10390 int width
= FRAME_PIXEL_WIDTH (f
), height
= FRAME_PIXEL_HEIGHT (f
);
10391 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10393 switch (f
->want_fullscreen
)
10395 /* No difference between these two when there is no WM */
10396 case FULLSCREEN_MAXIMIZED
:
10398 width
= x_display_pixel_width (dpyinfo
);
10399 height
= x_display_pixel_height (dpyinfo
);
10401 case FULLSCREEN_BOTH
:
10403 width
= x_display_pixel_width (dpyinfo
);
10404 height
= x_display_pixel_height (dpyinfo
);
10406 case FULLSCREEN_WIDTH
:
10408 width
= x_display_pixel_width (dpyinfo
);
10409 height
= height
+ FRAME_MENUBAR_HEIGHT (f
);
10411 case FULLSCREEN_HEIGHT
:
10412 lval
= Qfullheight
;
10413 height
= x_display_pixel_height (dpyinfo
);
10419 frame_size_history_add
10420 (f
, Qx_check_fullscreen
, width
, height
, Qnil
);
10422 x_wm_set_size_hint (f
, 0, false);
10424 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10427 if (FRAME_VISIBLE_P (f
))
10428 x_wait_for_event (f
, ConfigureNotify
);
10431 change_frame_size (f
, width
, height
- FRAME_MENUBAR_HEIGHT (f
),
10432 false, true, false, true);
10437 /* `x_net_wm_state' might have reset the fullscreen frame parameter,
10439 store_frame_param (f
, Qfullscreen
, lval
);
10442 /* This function is called by x_set_offset to determine whether the window
10443 manager interfered with the positioning of the frame. Type A window
10444 managers position the surrounding window manager decorations a small
10445 amount above and left of the user-supplied position. Type B window
10446 managers position the surrounding window manager decorations at the
10447 user-specified position. If we detect a Type A window manager, we
10448 compensate by moving the window right and down by the proper amount. */
10451 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
10453 int current_left
= 0, current_top
= 0;
10455 /* x_real_positions returns the left and top offsets of the outermost
10456 window manager window around the frame. */
10458 x_real_positions (f
, ¤t_left
, ¤t_top
);
10460 if (current_left
!= expected_left
|| current_top
!= expected_top
)
10462 /* It's a "Type A" window manager. */
10467 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
10468 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
10469 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
10471 /* Now fix the mispositioned frame's location. */
10473 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
10474 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
10476 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10477 adjusted_left
, adjusted_top
);
10479 x_sync_with_move (f
, expected_left
, expected_top
, false);
10482 /* It's a "Type B" window manager. We don't have to adjust the
10483 frame's position. */
10485 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
10489 /* Wait for XGetGeometry to return up-to-date position information for a
10490 recently-moved frame. Call this immediately after calling XMoveWindow.
10491 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
10492 frame has been moved to, so we use a fuzzy position comparison instead
10493 of an exact comparison. */
10496 x_sync_with_move (struct frame
*f
, int left
, int top
, bool fuzzy
)
10500 while (count
++ < 50)
10502 int current_left
= 0, current_top
= 0;
10504 /* In theory, this call to XSync only needs to happen once, but in
10505 practice, it doesn't seem to work, hence the need for the surrounding
10508 XSync (FRAME_X_DISPLAY (f
), False
);
10509 x_real_positions (f
, ¤t_left
, ¤t_top
);
10513 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
10516 if (eabs (current_left
- left
) <= 10
10517 && eabs (current_top
- top
) <= 40)
10520 else if (current_left
== left
&& current_top
== top
)
10524 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
10525 will then return up-to-date position info. */
10527 wait_reading_process_output (0, 500000000, 0, false, Qnil
, NULL
, 0);
10531 /* Wait for an event on frame F matching EVENTTYPE. */
10533 x_wait_for_event (struct frame
*f
, int eventtype
)
10535 int level
= interrupt_input_blocked
;
10538 struct timespec tmo
, tmo_at
, time_now
;
10539 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
10541 f
->wait_event_type
= eventtype
;
10543 /* Set timeout to 0.1 second. Hopefully not noticeable.
10544 Maybe it should be configurable. */
10545 tmo
= make_timespec (0, 100 * 1000 * 1000);
10546 tmo_at
= timespec_add (current_timespec (), tmo
);
10548 while (f
->wait_event_type
)
10550 pending_signals
= true;
10551 totally_unblock_input ();
10552 /* XTread_socket is called after unblock. */
10554 interrupt_input_blocked
= level
;
10559 time_now
= current_timespec ();
10560 if (timespec_cmp (tmo_at
, time_now
) < 0)
10563 tmo
= timespec_sub (tmo_at
, time_now
);
10564 if (pselect (fd
+ 1, &fds
, NULL
, NULL
, &tmo
, NULL
) == 0)
10565 break; /* Timeout */
10568 f
->wait_event_type
= 0;
10572 /* Change the size of frame F's X window to WIDTH/HEIGHT in the case F
10573 doesn't have a widget. If CHANGE_GRAVITY, change to
10574 top-left-corner window gravity for this size change and subsequent
10575 size changes. Otherwise leave the window gravity unchanged. */
10578 x_set_window_size_1 (struct frame
*f
, bool change_gravity
,
10579 int width
, int height
)
10581 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
10582 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
10583 int old_width
= FRAME_PIXEL_WIDTH (f
);
10584 int old_height
= FRAME_PIXEL_HEIGHT (f
);
10585 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
10587 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
10588 x_wm_set_size_hint (f
, 0, false);
10590 /* When the frame is fullheight and we only want to change the width
10591 or it is fullwidth and we only want to change the height we should
10592 be able to preserve the fullscreen property. However, due to the
10593 fact that we have to send a resize request anyway, the window
10594 manager will abolish it. At least the respective size should
10595 remain unchanged but giving the frame back its normal size will
10597 if (EQ (fullscreen
, Qfullwidth
) && width
== FRAME_TEXT_WIDTH (f
))
10599 frame_size_history_add
10600 (f
, Qx_set_window_size_1
, width
, height
,
10601 list2 (make_number (old_height
),
10602 make_number (pixelheight
+ FRAME_MENUBAR_HEIGHT (f
))));
10604 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10605 old_width
, pixelheight
+ FRAME_MENUBAR_HEIGHT (f
));
10607 else if (EQ (fullscreen
, Qfullheight
) && height
== FRAME_TEXT_HEIGHT (f
))
10609 frame_size_history_add
10610 (f
, Qx_set_window_size_2
, width
, height
,
10611 list2 (make_number (old_width
), make_number (pixelwidth
)));
10613 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10614 pixelwidth
, old_height
);
10619 frame_size_history_add
10620 (f
, Qx_set_window_size_3
, width
, height
,
10621 list3 (make_number (pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
)),
10622 make_number (pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
10623 + FRAME_MENUBAR_HEIGHT (f
)),
10624 make_number (FRAME_MENUBAR_HEIGHT (f
))));
10626 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10627 pixelwidth
, pixelheight
+ FRAME_MENUBAR_HEIGHT (f
));
10633 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
10634 receive in the ConfigureNotify event; if we get what we asked
10635 for, then the event won't cause the screen to become garbaged, so
10636 we have to make sure to do it here. */
10637 SET_FRAME_GARBAGED (f
);
10639 /* Now, strictly speaking, we can't be sure that this is accurate,
10640 but the window manager will get around to dealing with the size
10641 change request eventually, and we'll hear how it went when the
10642 ConfigureNotify event gets here.
10644 We could just not bother storing any of this information here,
10645 and let the ConfigureNotify event set everything up, but that
10646 might be kind of confusing to the Lisp code, since size changes
10647 wouldn't be reported in the frame parameters until some random
10648 point in the future when the ConfigureNotify event arrives.
10650 Pass true for DELAY since we can't run Lisp code inside of
10653 /* But the ConfigureNotify may in fact never arrive, and then this is
10654 not right if the frame is visible. Instead wait (with timeout)
10655 for the ConfigureNotify. */
10656 if (FRAME_VISIBLE_P (f
))
10658 x_wait_for_event (f
, ConfigureNotify
);
10660 if (!NILP (fullscreen
))
10661 /* Try to restore fullscreen state. */
10663 store_frame_param (f
, Qfullscreen
, fullscreen
);
10664 x_set_fullscreen (f
, fullscreen
, fullscreen
);
10669 change_frame_size (f
, width
, height
, false, true, false, true);
10675 /* Call this to change the size of frame F's x-window.
10676 If CHANGE_GRAVITY, change to top-left-corner window gravity
10677 for this size change and subsequent size changes.
10678 Otherwise we leave the window gravity unchanged. */
10681 x_set_window_size (struct frame
*f
, bool change_gravity
,
10682 int width
, int height
, bool pixelwise
)
10686 /* The following breaks our calculations. If it's really needed,
10687 think of something else. */
10689 if (!FRAME_TOOLTIP_P (f
))
10691 int text_width
, text_height
;
10693 /* When the frame is maximized/fullscreen or running under for
10694 example Xmonad, x_set_window_size_1 will be a no-op.
10695 In that case, the right thing to do is extend rows/width to
10696 the current frame size. We do that first if x_set_window_size_1
10697 turns out to not be a no-op (there is no way to know).
10698 The size will be adjusted again if the frame gets a
10699 ConfigureNotify event as a result of x_set_window_size. */
10700 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
10701 #ifdef USE_X_TOOLKIT
10702 /* The menu bar is not part of text lines. The tool bar
10704 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
10706 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, FRAME_PIXEL_WIDTH (f
));
10707 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelh
);
10709 change_frame_size (f
, text_width
, text_height
, false, true, false, true);
10713 /* Pixelize width and height, if necessary. */
10716 width
= width
* FRAME_COLUMN_WIDTH (f
);
10717 height
= height
* FRAME_LINE_HEIGHT (f
);
10721 if (FRAME_GTK_WIDGET (f
))
10722 xg_frame_set_char_size (f
, width
, height
);
10724 x_set_window_size_1 (f
, change_gravity
, width
, height
);
10725 #else /* not USE_GTK */
10726 x_set_window_size_1 (f
, change_gravity
, width
, height
);
10727 x_clear_under_internal_border (f
);
10728 #endif /* not USE_GTK */
10730 /* If cursor was outside the new size, mark it as off. */
10731 mark_window_cursors_off (XWINDOW (f
->root_window
));
10733 /* Clear out any recollection of where the mouse highlighting was,
10734 since it might be in a place that's outside the new frame size.
10735 Actually checking whether it is outside is a pain in the neck,
10736 so don't try--just let the highlighting be done afresh with new size. */
10737 cancel_mouse_face (f
);
10741 do_pending_window_change (false);
10744 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
10747 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
10751 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
10752 0, 0, 0, 0, pix_x
, pix_y
);
10756 /* Raise frame F. */
10759 x_raise_frame (struct frame
*f
)
10762 if (FRAME_VISIBLE_P (f
))
10763 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
10764 XFlush (FRAME_X_DISPLAY (f
));
10768 /* Lower frame F. */
10771 x_lower_frame (struct frame
*f
)
10773 if (FRAME_VISIBLE_P (f
))
10776 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
10777 XFlush (FRAME_X_DISPLAY (f
));
10782 /* Request focus with XEmbed */
10785 xembed_request_focus (struct frame
*f
)
10787 /* See XEmbed Protocol Specification at
10788 http://freedesktop.org/wiki/Specifications/xembed-spec */
10789 if (FRAME_VISIBLE_P (f
))
10790 xembed_send_message (f
, CurrentTime
,
10791 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
10794 /* Activate frame with Extended Window Manager Hints */
10797 x_ewmh_activate_frame (struct frame
*f
)
10799 /* See Window Manager Specification/Extended Window Manager Hints at
10800 http://freedesktop.org/wiki/Specifications/wm-spec */
10802 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10804 if (FRAME_VISIBLE_P (f
) && x_wm_supports (f
, dpyinfo
->Xatom_net_active_window
))
10807 XSETFRAME (frame
, f
);
10808 x_send_client_event (frame
, make_number (0), frame
,
10809 dpyinfo
->Xatom_net_active_window
,
10811 list2i (1, dpyinfo
->last_user_time
));
10816 XTframe_raise_lower (struct frame
*f
, bool raise_flag
)
10824 /* XEmbed implementation. */
10826 #if defined USE_X_TOOLKIT || ! defined USE_GTK
10828 /* XEmbed implementation. */
10830 #define XEMBED_VERSION 0
10833 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
10835 unsigned long data
[2];
10836 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10838 data
[0] = XEMBED_VERSION
;
10841 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10842 dpyinfo
->Xatom_XEMBED_INFO
, dpyinfo
->Xatom_XEMBED_INFO
,
10843 32, PropModeReplace
, (unsigned char *) data
, 2);
10845 #endif /* defined USE_X_TOOLKIT || ! defined USE_GTK */
10848 xembed_send_message (struct frame
*f
, Time t
, enum xembed_message msg
,
10849 long int detail
, long int data1
, long int data2
)
10853 event
.xclient
.type
= ClientMessage
;
10854 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
10855 event
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_XEMBED
;
10856 event
.xclient
.format
= 32;
10857 event
.xclient
.data
.l
[0] = t
;
10858 event
.xclient
.data
.l
[1] = msg
;
10859 event
.xclient
.data
.l
[2] = detail
;
10860 event
.xclient
.data
.l
[3] = data1
;
10861 event
.xclient
.data
.l
[4] = data2
;
10863 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
10864 False
, NoEventMask
, &event
);
10865 XSync (FRAME_X_DISPLAY (f
), False
);
10868 /* Change of visibility. */
10870 /* This tries to wait until the frame is really visible.
10871 However, if the window manager asks the user where to position
10872 the frame, this will return before the user finishes doing that.
10873 The frame will not actually be visible at that time,
10874 but it will become visible later when the window manager
10875 finishes with it. */
10878 x_make_frame_visible (struct frame
*f
)
10880 int original_top
, original_left
;
10885 x_set_bitmap_icon (f
);
10887 if (! FRAME_VISIBLE_P (f
))
10889 /* We test FRAME_GARBAGED_P here to make sure we don't
10890 call x_set_offset a second time
10891 if we get to x_make_frame_visible a second time
10892 before the window gets really visible. */
10893 if (! FRAME_ICONIFIED_P (f
)
10894 && ! FRAME_X_EMBEDDED_P (f
)
10895 && ! f
->output_data
.x
->asked_for_visible
)
10896 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
10898 f
->output_data
.x
->asked_for_visible
= true;
10900 if (! EQ (Vx_no_window_manager
, Qt
))
10901 x_wm_set_window_state (f
, NormalState
);
10902 #ifdef USE_X_TOOLKIT
10903 if (FRAME_X_EMBEDDED_P (f
))
10904 xembed_set_info (f
, XEMBED_MAPPED
);
10907 /* This was XtPopup, but that did nothing for an iconified frame. */
10908 XtMapWidget (f
->output_data
.x
->widget
);
10910 #else /* not USE_X_TOOLKIT */
10912 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
10913 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
10915 if (FRAME_X_EMBEDDED_P (f
))
10916 xembed_set_info (f
, XEMBED_MAPPED
);
10918 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10919 #endif /* not USE_GTK */
10920 #endif /* not USE_X_TOOLKIT */
10923 XFlush (FRAME_X_DISPLAY (f
));
10925 /* Synchronize to ensure Emacs knows the frame is visible
10926 before we do anything else. We do this loop with input not blocked
10927 so that incoming events are handled. */
10930 /* This must be before UNBLOCK_INPUT
10931 since events that arrive in response to the actions above
10932 will set it when they are handled. */
10933 bool previously_visible
= f
->output_data
.x
->has_been_visible
;
10935 original_left
= f
->left_pos
;
10936 original_top
= f
->top_pos
;
10938 /* This must come after we set COUNT. */
10941 /* We unblock here so that arriving X events are processed. */
10943 /* Now move the window back to where it was "supposed to be".
10944 But don't do it if the gravity is negative.
10945 When the gravity is negative, this uses a position
10946 that is 3 pixels too low. Perhaps that's really the border width.
10948 Don't do this if the window has never been visible before,
10949 because the window manager may choose the position
10950 and we don't want to override it. */
10952 if (! FRAME_VISIBLE_P (f
)
10953 && ! FRAME_ICONIFIED_P (f
)
10954 && ! FRAME_X_EMBEDDED_P (f
)
10955 && f
->win_gravity
== NorthWestGravity
10956 && previously_visible
)
10960 unsigned int width
, height
, border
, depth
;
10964 /* On some window managers (such as FVWM) moving an existing
10965 window, even to the same place, causes the window manager
10966 to introduce an offset. This can cause the window to move
10967 to an unexpected location. Check the geometry (a little
10968 slow here) and then verify that the window is in the right
10969 place. If the window is not in the right place, move it
10970 there, and take the potential window manager hit. */
10971 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10972 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
10974 if (original_left
!= x
|| original_top
!= y
)
10975 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10976 original_left
, original_top
);
10981 XSETFRAME (frame
, f
);
10983 /* Process X events until a MapNotify event has been seen. */
10984 while (!FRAME_VISIBLE_P (f
))
10986 /* Force processing of queued events. */
10989 /* If on another desktop, the deiconify/map may be ignored and the
10990 frame never becomes visible. XMonad does this.
10991 Prevent an endless loop. */
10992 if (FRAME_ICONIFIED_P (f
) && ++tries
> 100)
10995 /* This hack is still in use at least for Cygwin. See
10996 http://lists.gnu.org/archive/html/emacs-devel/2013-12/msg00351.html.
10998 Machines that do polling rather than SIGIO have been
10999 observed to go into a busy-wait here. So we'll fake an
11000 alarm signal to let the handler know that there's something
11001 to be read. We used to raise a real alarm, but it seems
11002 that the handler isn't always enabled here. This is
11004 if (input_polling_used ())
11006 /* It could be confusing if a real alarm arrives while
11007 processing the fake one. Turn it off and let the
11008 handler reset it. */
11009 int old_poll_suppress_count
= poll_suppress_count
;
11010 poll_suppress_count
= 1;
11011 poll_for_input_1 ();
11012 poll_suppress_count
= old_poll_suppress_count
;
11015 if (XPending (FRAME_X_DISPLAY (f
)))
11018 XNextEvent (FRAME_X_DISPLAY (f
), &xev
);
11019 x_dispatch_event (&xev
, FRAME_X_DISPLAY (f
));
11025 /* Change from mapped state to withdrawn state. */
11027 /* Make the frame visible (mapped and not iconified). */
11030 x_make_frame_invisible (struct frame
*f
)
11034 /* Use the frame's outermost window, not the one we normally draw on. */
11035 window
= FRAME_OUTER_WINDOW (f
);
11037 /* Don't keep the highlight on an invisible frame. */
11038 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
11039 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
11043 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
11044 that the current position of the window is user-specified, rather than
11045 program-specified, so that when the window is mapped again, it will be
11046 placed at the same location, without forcing the user to position it
11047 by hand again (they have already done that once for this window.) */
11048 x_wm_set_size_hint (f
, 0, true);
11051 if (FRAME_GTK_OUTER_WIDGET (f
))
11052 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
11055 if (FRAME_X_EMBEDDED_P (f
))
11056 xembed_set_info (f
, 0);
11061 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
11062 DefaultScreen (FRAME_X_DISPLAY (f
))))
11065 error ("Can't notify window manager of window withdrawal");
11069 /* We can't distinguish this from iconification
11070 just by the event that we get from the server.
11071 So we can't win using the usual strategy of letting
11072 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
11073 and synchronize with the server to make sure we agree. */
11074 SET_FRAME_VISIBLE (f
, 0);
11075 SET_FRAME_ICONIFIED (f
, false);
11082 /* Change window state from mapped to iconified. */
11085 x_iconify_frame (struct frame
*f
)
11087 #ifdef USE_X_TOOLKIT
11091 /* Don't keep the highlight on an invisible frame. */
11092 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
11093 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
11095 if (FRAME_ICONIFIED_P (f
))
11100 x_set_bitmap_icon (f
);
11102 #if defined (USE_GTK)
11103 if (FRAME_GTK_OUTER_WIDGET (f
))
11105 if (! FRAME_VISIBLE_P (f
))
11106 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
11108 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
11109 SET_FRAME_VISIBLE (f
, 0);
11110 SET_FRAME_ICONIFIED (f
, true);
11116 #ifdef USE_X_TOOLKIT
11118 if (! FRAME_VISIBLE_P (f
))
11120 if (! EQ (Vx_no_window_manager
, Qt
))
11121 x_wm_set_window_state (f
, IconicState
);
11122 /* This was XtPopup, but that did nothing for an iconified frame. */
11123 XtMapWidget (f
->output_data
.x
->widget
);
11124 /* The server won't give us any event to indicate
11125 that an invisible frame was changed to an icon,
11126 so we have to record it here. */
11127 SET_FRAME_VISIBLE (f
, 0);
11128 SET_FRAME_ICONIFIED (f
, true);
11133 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
11134 XtWindow (f
->output_data
.x
->widget
),
11135 DefaultScreen (FRAME_X_DISPLAY (f
)));
11139 error ("Can't notify window manager of iconification");
11141 SET_FRAME_ICONIFIED (f
, true);
11142 SET_FRAME_VISIBLE (f
, 0);
11145 XFlush (FRAME_X_DISPLAY (f
));
11147 #else /* not USE_X_TOOLKIT */
11149 /* Make sure the X server knows where the window should be positioned,
11150 in case the user deiconifies with the window manager. */
11151 if (! FRAME_VISIBLE_P (f
)
11152 && ! FRAME_ICONIFIED_P (f
)
11153 && ! FRAME_X_EMBEDDED_P (f
))
11154 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
11156 /* Since we don't know which revision of X we're running, we'll use both
11157 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
11159 /* X11R4: send a ClientMessage to the window manager using the
11160 WM_CHANGE_STATE type. */
11164 msg
.xclient
.window
= FRAME_X_WINDOW (f
);
11165 msg
.xclient
.type
= ClientMessage
;
11166 msg
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
11167 msg
.xclient
.format
= 32;
11168 msg
.xclient
.data
.l
[0] = IconicState
;
11170 if (! XSendEvent (FRAME_X_DISPLAY (f
),
11171 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
11173 SubstructureRedirectMask
| SubstructureNotifyMask
,
11177 error ("Can't notify window manager of iconification");
11181 /* X11R3: set the initial_state field of the window manager hints to
11183 x_wm_set_window_state (f
, IconicState
);
11185 if (!FRAME_VISIBLE_P (f
))
11187 /* If the frame was withdrawn, before, we must map it. */
11188 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11191 SET_FRAME_ICONIFIED (f
, true);
11192 SET_FRAME_VISIBLE (f
, 0);
11194 XFlush (FRAME_X_DISPLAY (f
));
11196 #endif /* not USE_X_TOOLKIT */
11200 /* Free X resources of frame F. */
11203 x_free_frame_resources (struct frame
*f
)
11205 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
11206 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
11207 #ifdef USE_X_TOOLKIT
11209 struct scroll_bar
*b
;
11214 /* If a display connection is dead, don't try sending more
11215 commands to the X server. */
11216 if (dpyinfo
->display
)
11218 /* Always exit with visible pointer to avoid weird issue
11219 with Xfixes (Bug#17609). */
11220 if (f
->pointer_invisible
)
11221 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, 0);
11223 /* We must free faces before destroying windows because some
11224 font-driver (e.g. xft) access a window while finishing a
11226 free_frame_faces (f
);
11228 if (f
->output_data
.x
->icon_desc
)
11229 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
11231 #ifdef USE_X_TOOLKIT
11232 /* Explicitly destroy the scroll bars of the frame. Without
11233 this, we get "BadDrawable" errors from the toolkit later on,
11234 presumably from expose events generated for the disappearing
11235 toolkit scroll bars. */
11236 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
11238 b
= XSCROLL_BAR (bar
);
11239 x_scroll_bar_remove (b
);
11245 free_frame_xic (f
);
11248 x_free_cr_resources (f
);
11249 #ifdef USE_X_TOOLKIT
11250 if (f
->output_data
.x
->widget
)
11252 XtDestroyWidget (f
->output_data
.x
->widget
);
11253 f
->output_data
.x
->widget
= NULL
;
11255 /* Tooltips don't have widgets, only a simple X window, even if
11256 we are using a toolkit. */
11257 else if (FRAME_X_WINDOW (f
))
11258 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11260 free_frame_menubar (f
);
11262 if (f
->shell_position
)
11263 xfree (f
->shell_position
);
11264 #else /* !USE_X_TOOLKIT */
11267 xg_free_frame_widgets (f
);
11268 #endif /* USE_GTK */
11270 if (FRAME_X_WINDOW (f
))
11271 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11272 #endif /* !USE_X_TOOLKIT */
11274 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
11275 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
11276 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
11277 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
11278 unload_color (f
, f
->output_data
.x
->border_pixel
);
11279 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
11281 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
11282 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
11283 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
11284 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
11285 #if defined (USE_LUCID) && defined (USE_TOOLKIT_SCROLL_BARS)
11286 /* Scrollbar shadow colors. */
11287 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
11288 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
11289 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
11290 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
11291 #endif /* USE_LUCID && USE_TOOLKIT_SCROLL_BARS */
11292 if (f
->output_data
.x
->white_relief
.pixel
!= -1)
11293 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
11294 if (f
->output_data
.x
->black_relief
.pixel
!= -1)
11295 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
11299 /* Free extra GCs allocated by x_setup_relief_colors. */
11300 if (f
->output_data
.x
->white_relief
.gc
)
11302 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->white_relief
.gc
);
11303 f
->output_data
.x
->white_relief
.gc
= 0;
11305 if (f
->output_data
.x
->black_relief
.gc
)
11307 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->black_relief
.gc
);
11308 f
->output_data
.x
->black_relief
.gc
= 0;
11311 /* Free cursors. */
11312 if (f
->output_data
.x
->text_cursor
!= 0)
11313 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->text_cursor
);
11314 if (f
->output_data
.x
->nontext_cursor
!= 0)
11315 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->nontext_cursor
);
11316 if (f
->output_data
.x
->modeline_cursor
!= 0)
11317 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->modeline_cursor
);
11318 if (f
->output_data
.x
->hand_cursor
!= 0)
11319 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hand_cursor
);
11320 if (f
->output_data
.x
->hourglass_cursor
!= 0)
11321 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hourglass_cursor
);
11322 if (f
->output_data
.x
->horizontal_drag_cursor
!= 0)
11323 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->horizontal_drag_cursor
);
11324 if (f
->output_data
.x
->vertical_drag_cursor
!= 0)
11325 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->vertical_drag_cursor
);
11327 XFlush (FRAME_X_DISPLAY (f
));
11330 xfree (f
->output_data
.x
->saved_menu_event
);
11331 xfree (f
->output_data
.x
);
11332 f
->output_data
.x
= NULL
;
11334 if (f
== dpyinfo
->x_focus_frame
)
11335 dpyinfo
->x_focus_frame
= 0;
11336 if (f
== dpyinfo
->x_focus_event_frame
)
11337 dpyinfo
->x_focus_event_frame
= 0;
11338 if (f
== dpyinfo
->x_highlight_frame
)
11339 dpyinfo
->x_highlight_frame
= 0;
11340 if (f
== dpyinfo
->x_tooltip_frame
)
11341 dpyinfo
->x_tooltip_frame
= 0;
11342 if (f
== hlinfo
->mouse_face_mouse_frame
)
11343 reset_mouse_highlight (hlinfo
);
11349 /* Destroy the X window of frame F. */
11352 x_destroy_window (struct frame
*f
)
11354 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
11356 /* If a display connection is dead, don't try sending more
11357 commands to the X server. */
11358 if (dpyinfo
->display
!= 0)
11359 x_free_frame_resources (f
);
11361 dpyinfo
->reference_count
--;
11365 /* Setting window manager hints. */
11367 /* Set the normal size hints for the window manager, for frame F.
11368 FLAGS is the flags word to use--or 0 meaning preserve the flags
11369 that the window now has.
11370 If USER_POSITION, set the USPosition
11371 flag (this is useful when FLAGS is 0).
11372 The GTK version is in gtkutils.c. */
11376 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
11378 XSizeHints size_hints
;
11379 Window window
= FRAME_OUTER_WINDOW (f
);
11384 #ifdef USE_X_TOOLKIT
11385 if (f
->output_data
.x
->widget
)
11387 widget_update_wm_size_hints (f
->output_data
.x
->widget
);
11392 /* Setting PMaxSize caused various problems. */
11393 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
11395 size_hints
.x
= f
->left_pos
;
11396 size_hints
.y
= f
->top_pos
;
11398 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
11399 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
11401 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
11402 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
11404 size_hints
.max_width
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
11405 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
11406 size_hints
.max_height
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
11407 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
11409 /* Calculate the base and minimum sizes. */
11411 int base_width
, base_height
;
11413 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
11414 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
11416 /* The window manager uses the base width hints to calculate the
11417 current number of rows and columns in the frame while
11418 resizing; min_width and min_height aren't useful for this
11419 purpose, since they might not give the dimensions for a
11420 zero-row, zero-column frame. */
11422 size_hints
.flags
|= PBaseSize
;
11423 size_hints
.base_width
= base_width
;
11424 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
11425 size_hints
.min_width
= base_width
;
11426 size_hints
.min_height
= base_height
;
11429 /* If we don't need the old flags, we don't need the old hint at all. */
11432 size_hints
.flags
|= flags
;
11437 XSizeHints hints
; /* Sometimes I hate X Windows... */
11438 long supplied_return
;
11441 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
11445 size_hints
.flags
|= flags
;
11450 if (hints
.flags
& PSize
)
11451 size_hints
.flags
|= PSize
;
11452 if (hints
.flags
& PPosition
)
11453 size_hints
.flags
|= PPosition
;
11454 if (hints
.flags
& USPosition
)
11455 size_hints
.flags
|= USPosition
;
11456 if (hints
.flags
& USSize
)
11457 size_hints
.flags
|= USSize
;
11464 size_hints
.win_gravity
= f
->win_gravity
;
11465 size_hints
.flags
|= PWinGravity
;
11469 size_hints
.flags
&= ~ PPosition
;
11470 size_hints
.flags
|= USPosition
;
11472 #endif /* PWinGravity */
11474 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
11476 #endif /* not USE_GTK */
11478 /* Used for IconicState or NormalState */
11481 x_wm_set_window_state (struct frame
*f
, int state
)
11483 #ifdef USE_X_TOOLKIT
11486 XtSetArg (al
[0], XtNinitialState
, state
);
11487 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11488 #else /* not USE_X_TOOLKIT */
11489 Window window
= FRAME_X_WINDOW (f
);
11491 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
11492 f
->output_data
.x
->wm_hints
.initial_state
= state
;
11494 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11495 #endif /* not USE_X_TOOLKIT */
11499 x_wm_set_icon_pixmap (struct frame
*f
, ptrdiff_t pixmap_id
)
11501 Pixmap icon_pixmap
, icon_mask
;
11503 #if !defined USE_X_TOOLKIT && !defined USE_GTK
11504 Window window
= FRAME_OUTER_WINDOW (f
);
11509 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
11510 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
11511 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
11512 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
11516 /* It seems there is no way to turn off use of an icon
11524 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
11528 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
11532 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
11533 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11534 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
11535 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11538 #else /* not USE_X_TOOLKIT && not USE_GTK */
11540 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
11541 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11543 #endif /* not USE_X_TOOLKIT && not USE_GTK */
11547 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
11549 Window window
= FRAME_OUTER_WINDOW (f
);
11551 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
11552 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
11553 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
11555 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11559 /***********************************************************************
11561 ***********************************************************************/
11565 /* Check that FONT is valid on frame F. It is if it can be found in F's
11569 x_check_font (struct frame
*f
, struct font
*font
)
11571 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
11572 if (font
->driver
->check
)
11573 eassert (font
->driver
->check (f
, font
) == 0);
11576 #endif /* GLYPH_DEBUG */
11579 /***********************************************************************
11581 ***********************************************************************/
11583 #ifdef USE_X_TOOLKIT
11584 static XrmOptionDescRec emacs_options
[] = {
11585 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
11586 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
11588 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
11589 XrmoptionSepArg
, NULL
},
11590 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
11592 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11593 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11594 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11595 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
11596 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
11597 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
11598 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
11601 /* Whether atimer for Xt timeouts is activated or not. */
11603 static bool x_timeout_atimer_activated_flag
;
11605 #endif /* USE_X_TOOLKIT */
11607 static int x_initialized
;
11609 /* Test whether two display-name strings agree up to the dot that separates
11610 the screen number from the server number. */
11612 same_x_server (const char *name1
, const char *name2
)
11614 bool seen_colon
= false;
11615 Lisp_Object sysname
= Fsystem_name ();
11616 const char *system_name
= SSDATA (sysname
);
11617 ptrdiff_t system_name_length
= SBYTES (sysname
);
11618 ptrdiff_t length_until_period
= 0;
11620 while (system_name
[length_until_period
] != 0
11621 && system_name
[length_until_period
] != '.')
11622 length_until_period
++;
11624 /* Treat `unix' like an empty host name. */
11625 if (! strncmp (name1
, "unix:", 5))
11627 if (! strncmp (name2
, "unix:", 5))
11629 /* Treat this host's name like an empty host name. */
11630 if (! strncmp (name1
, system_name
, system_name_length
)
11631 && name1
[system_name_length
] == ':')
11632 name1
+= system_name_length
;
11633 if (! strncmp (name2
, system_name
, system_name_length
)
11634 && name2
[system_name_length
] == ':')
11635 name2
+= system_name_length
;
11636 /* Treat this host's domainless name like an empty host name. */
11637 if (! strncmp (name1
, system_name
, length_until_period
)
11638 && name1
[length_until_period
] == ':')
11639 name1
+= length_until_period
;
11640 if (! strncmp (name2
, system_name
, length_until_period
)
11641 && name2
[length_until_period
] == ':')
11642 name2
+= length_until_period
;
11644 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
11648 if (seen_colon
&& *name1
== '.')
11652 && (*name1
== '.' || *name1
== '\0')
11653 && (*name2
== '.' || *name2
== '\0'));
11656 /* Count number of set bits in mask and number of bits to shift to
11657 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
11660 get_bits_and_offset (unsigned long mask
, int *bits
, int *offset
)
11665 while (!(mask
& 1))
11681 /* Return true iff display DISPLAY is available for use.
11682 But don't permanently open it, just test its availability. */
11685 x_display_ok (const char *display
)
11687 /* XOpenDisplay fails if it gets a signal. Block SIGIO which may arrive. */
11688 unrequest_sigio ();
11689 Display
*dpy
= XOpenDisplay (display
);
11693 XCloseDisplay (dpy
);
11699 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
11700 const gchar
*msg
, gpointer user_data
)
11702 if (!strstr (msg
, "g_set_prgname"))
11703 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, msg
);
11707 /* Create invisible cursor on X display referred by DPYINFO. */
11710 make_invisible_cursor (struct x_display_info
*dpyinfo
)
11712 Display
*dpy
= dpyinfo
->display
;
11713 static char const no_data
[] = { 0 };
11718 x_catch_errors (dpy
);
11719 pix
= XCreateBitmapFromData (dpy
, dpyinfo
->root_window
, no_data
, 1, 1);
11720 if (! x_had_errors_p (dpy
) && pix
!= None
)
11724 col
.red
= col
.green
= col
.blue
= 0;
11725 col
.flags
= DoRed
| DoGreen
| DoBlue
;
11726 pixc
= XCreatePixmapCursor (dpy
, pix
, pix
, &col
, &col
, 0, 0);
11727 if (! x_had_errors_p (dpy
) && pixc
!= None
)
11729 XFreePixmap (dpy
, pix
);
11732 x_uncatch_errors ();
11737 /* True if DPY supports Xfixes extension >= 4. */
11740 x_probe_xfixes_extension (Display
*dpy
)
11744 return XFixesQueryVersion (dpy
, &major
, &minor
) && major
>= 4;
11747 #endif /* HAVE_XFIXES */
11750 /* Toggle mouse pointer visibility on frame F by using Xfixes functions. */
11753 xfixes_toggle_visible_pointer (struct frame
*f
, bool invisible
)
11757 XFixesHideCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11759 XFixesShowCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11760 f
->pointer_invisible
= invisible
;
11763 #endif /* HAVE_XFIXES */
11766 /* Toggle mouse pointer visibility on frame F by using invisible cursor. */
11769 x_toggle_visible_pointer (struct frame
*f
, bool invisible
)
11771 eassert (FRAME_DISPLAY_INFO (f
)->invisible_cursor
!= 0);
11773 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11774 FRAME_DISPLAY_INFO (f
)->invisible_cursor
);
11776 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11777 f
->output_data
.x
->current_cursor
);
11778 f
->pointer_invisible
= invisible
;
11781 /* Setup pointer blanking, prefer Xfixes if available. */
11784 x_setup_pointer_blanking (struct x_display_info
*dpyinfo
)
11786 /* FIXME: the brave tester should set EMACS_XFIXES because we're suspecting
11787 X server bug, see http://debbugs.gnu.org/cgi/bugreport.cgi?bug=17609. */
11788 if (egetenv ("EMACS_XFIXES") && x_probe_xfixes_extension (dpyinfo
->display
))
11789 dpyinfo
->toggle_visible_pointer
= xfixes_toggle_visible_pointer
;
11792 dpyinfo
->toggle_visible_pointer
= x_toggle_visible_pointer
;
11793 dpyinfo
->invisible_cursor
= make_invisible_cursor (dpyinfo
);
11797 /* Current X display connection identifier. Incremented for each next
11798 connection established. */
11799 static unsigned x_display_id
;
11801 /* Open a connection to X display DISPLAY_NAME, and return
11802 the structure that describes the open display.
11803 If we cannot contact the display, return null. */
11805 struct x_display_info
*
11806 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
11809 struct terminal
*terminal
;
11810 struct x_display_info
*dpyinfo
;
11813 xcb_connection_t
*xcb_conn
;
11818 if (!x_initialized
)
11824 if (! x_display_ok (SSDATA (display_name
)))
11825 error ("Display %s can't be opened", SSDATA (display_name
));
11829 #define NUM_ARGV 10
11831 char *argv
[NUM_ARGV
];
11832 char **argv2
= argv
;
11835 if (x_initialized
++ > 1)
11837 xg_display_open (SSDATA (display_name
), &dpy
);
11841 static char display_opt
[] = "--display";
11842 static char name_opt
[] = "--name";
11844 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
11848 argv
[argc
++] = initial_argv
[0];
11850 if (! NILP (display_name
))
11852 argv
[argc
++] = display_opt
;
11853 argv
[argc
++] = SSDATA (display_name
);
11856 argv
[argc
++] = name_opt
;
11857 argv
[argc
++] = resource_name
;
11859 XSetLocaleModifiers ("");
11861 /* Work around GLib bug that outputs a faulty warning. See
11862 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
11863 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
11864 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
11866 /* NULL window -> events for all windows go to our function.
11867 Call before gtk_init so Gtk+ event filters comes after our. */
11868 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
11870 /* gtk_init does set_locale. Fix locale before and after. */
11872 unrequest_sigio (); /* See comment in x_display_ok. */
11873 gtk_init (&argc
, &argv2
);
11877 g_log_remove_handler ("GLib", id
);
11881 dpy
= DEFAULT_GDK_DISPLAY ();
11883 #if ! GTK_CHECK_VERSION (2, 90, 0)
11884 /* Load our own gtkrc if it exists. */
11886 const char *file
= "~/.emacs.d/gtkrc";
11887 Lisp_Object s
, abs_file
;
11889 s
= build_string (file
);
11890 abs_file
= Fexpand_file_name (s
, Qnil
);
11892 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
11893 gtk_rc_parse (SSDATA (abs_file
));
11897 XSetErrorHandler (x_error_handler
);
11898 XSetIOErrorHandler (x_io_error_quitter
);
11901 #else /* not USE_GTK */
11902 #ifdef USE_X_TOOLKIT
11903 /* weiner@footloose.sps.mot.com reports that this causes
11905 X protocol error: BadAtom (invalid Atom parameter)
11906 on protocol request 18skiloaf.
11907 So let's not use it until R6. */
11908 #ifdef HAVE_X11XTR6
11909 XtSetLanguageProc (NULL
, NULL
, NULL
);
11920 argv
[argc
++] = "-xrm";
11921 argv
[argc
++] = xrm_option
;
11923 turn_on_atimers (false);
11924 unrequest_sigio (); /* See comment in x_display_ok. */
11925 dpy
= XtOpenDisplay (Xt_app_con
, SSDATA (display_name
),
11926 resource_name
, EMACS_CLASS
,
11927 emacs_options
, XtNumber (emacs_options
),
11930 turn_on_atimers (true);
11932 #ifdef HAVE_X11XTR6
11933 /* I think this is to compensate for XtSetLanguageProc. */
11938 #else /* not USE_X_TOOLKIT */
11939 XSetLocaleModifiers ("");
11940 unrequest_sigio (); // See comment in x_display_ok.
11941 dpy
= XOpenDisplay (SSDATA (display_name
));
11943 #endif /* not USE_X_TOOLKIT */
11944 #endif /* not USE_GTK*/
11946 /* Detect failure. */
11954 xcb_conn
= XGetXCBConnection (dpy
);
11958 xg_display_close (dpy
);
11960 #ifdef USE_X_TOOLKIT
11961 XtCloseDisplay (dpy
);
11963 XCloseDisplay (dpy
);
11965 #endif /* ! USE_GTK */
11972 /* We have definitely succeeded. Record the new connection. */
11974 dpyinfo
= xzalloc (sizeof *dpyinfo
);
11975 terminal
= x_create_terminal (dpyinfo
);
11978 struct x_display_info
*share
;
11980 for (share
= x_display_list
; share
; share
= share
->next
)
11981 if (same_x_server (SSDATA (XCAR (share
->name_list_element
)),
11982 SSDATA (display_name
)))
11985 terminal
->kboard
= share
->terminal
->kboard
;
11988 terminal
->kboard
= allocate_kboard (Qx
);
11990 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
11992 char *vendor
= ServerVendor (dpy
);
11994 /* Temporarily hide the partially initialized terminal. */
11995 terminal_list
= terminal
->next_terminal
;
11997 kset_system_key_alist
11999 call1 (Qvendor_specific_keysyms
,
12000 vendor
? build_string (vendor
) : empty_unibyte_string
));
12002 terminal
->next_terminal
= terminal_list
;
12003 terminal_list
= terminal
;
12006 /* Don't let the initial kboard remain current longer than necessary.
12007 That would cause problems if a file loaded on startup tries to
12008 prompt in the mini-buffer. */
12009 if (current_kboard
== initial_kboard
)
12010 current_kboard
= terminal
->kboard
;
12012 terminal
->kboard
->reference_count
++;
12015 /* Put this display on the chain. */
12016 dpyinfo
->next
= x_display_list
;
12017 x_display_list
= dpyinfo
;
12019 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
12020 dpyinfo
->display
= dpy
;
12021 dpyinfo
->connection
= ConnectionNumber (dpyinfo
->display
);
12023 dpyinfo
->xcb_connection
= xcb_conn
;
12026 /* http://lists.gnu.org/archive/html/emacs-devel/2015-11/msg00194.html */
12027 dpyinfo
->smallest_font_height
= 1;
12028 dpyinfo
->smallest_char_width
= 1;
12030 /* Set the name of the terminal. */
12031 terminal
->name
= xlispstrdup (display_name
);
12034 XSetAfterFunction (x_current_display
, x_trace_wire
);
12037 Lisp_Object system_name
= Fsystem_name ();
12039 if (INT_ADD_WRAPV (SBYTES (Vinvocation_name
), SBYTES (system_name
) + 2,
12041 memory_full (SIZE_MAX
);
12042 dpyinfo
->x_id
= ++x_display_id
;
12043 dpyinfo
->x_id_name
= xmalloc (nbytes
);
12044 char *nametail
= lispstpcpy (dpyinfo
->x_id_name
, Vinvocation_name
);
12046 lispstpcpy (nametail
, system_name
);
12048 /* Figure out which modifier bits mean what. */
12049 x_find_modifier_meanings (dpyinfo
);
12051 /* Get the scroll bar cursor. */
12053 /* We must create a GTK cursor, it is required for GTK widgets. */
12054 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
12055 #endif /* USE_GTK */
12057 dpyinfo
->vertical_scroll_bar_cursor
12058 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
12060 dpyinfo
->horizontal_scroll_bar_cursor
12061 = XCreateFontCursor (dpyinfo
->display
, XC_sb_h_double_arrow
);
12063 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
12064 resource_name
, EMACS_CLASS
);
12065 #ifdef HAVE_XRMSETDATABASE
12066 XrmSetDatabase (dpyinfo
->display
, xrdb
);
12068 dpyinfo
->display
->db
= xrdb
;
12070 /* Put the rdb where we can find it in a way that works on
12072 dpyinfo
->xrdb
= xrdb
;
12074 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
12075 DefaultScreen (dpyinfo
->display
));
12076 select_visual (dpyinfo
);
12077 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
12078 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
12079 dpyinfo
->icon_bitmap_id
= -1;
12080 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
12082 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
12084 /* See if we can construct pixel values from RGB values. */
12085 if (dpyinfo
->visual
->class == TrueColor
)
12087 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
12088 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
12089 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
12090 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
12091 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
12092 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
12095 /* See if a private colormap is requested. */
12096 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
12098 if (dpyinfo
->visual
->class == PseudoColor
)
12100 AUTO_STRING (privateColormap
, "privateColormap");
12101 AUTO_STRING (PrivateColormap
, "PrivateColormap");
12103 = display_x_get_resource (dpyinfo
, privateColormap
,
12104 PrivateColormap
, Qnil
, Qnil
);
12105 if (STRINGP (value
)
12106 && (!strcmp (SSDATA (value
), "true")
12107 || !strcmp (SSDATA (value
), "on")))
12108 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
12112 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
12113 dpyinfo
->visual
, AllocNone
);
12117 /* If we are using Xft, the following precautions should be made:
12119 1. Make sure that the Xrender extension is added before the Xft one.
12120 Otherwise, the close-display hook set by Xft is called after the one
12121 for Xrender, and the former tries to re-add the latter. This results
12122 in inconsistency of internal states and leads to X protocol error when
12123 one reconnects to the same X server (Bug#1696).
12125 2. Check dpi value in X resources. It is better we use it as well,
12126 since Xft will use it, as will all Gnome applications. If our real DPI
12127 is smaller or larger than the one Xft uses, our font will look smaller
12128 or larger than other for other applications, even if it is the same
12129 font name (monospace-10 for example). */
12131 int event_base
, error_base
;
12135 XRenderQueryExtension (dpyinfo
->display
, &event_base
, &error_base
);
12137 v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
12138 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
12139 dpyinfo
->resy
= dpyinfo
->resx
= d
;
12143 if (dpyinfo
->resy
< 1)
12145 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
12146 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
12147 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
12148 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
12149 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
12150 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
12151 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
12152 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
12153 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
12157 static const struct
12162 #define ATOM_REFS_INIT(string, member) \
12163 { string, offsetof (struct x_display_info, member) },
12164 ATOM_REFS_INIT ("WM_PROTOCOLS", Xatom_wm_protocols
)
12165 ATOM_REFS_INIT ("WM_TAKE_FOCUS", Xatom_wm_take_focus
)
12166 ATOM_REFS_INIT ("WM_SAVE_YOURSELF", Xatom_wm_save_yourself
)
12167 ATOM_REFS_INIT ("WM_DELETE_WINDOW", Xatom_wm_delete_window
)
12168 ATOM_REFS_INIT ("WM_CHANGE_STATE", Xatom_wm_change_state
)
12169 ATOM_REFS_INIT ("WM_CONFIGURE_DENIED", Xatom_wm_configure_denied
)
12170 ATOM_REFS_INIT ("WM_MOVED", Xatom_wm_window_moved
)
12171 ATOM_REFS_INIT ("WM_CLIENT_LEADER", Xatom_wm_client_leader
)
12172 ATOM_REFS_INIT ("Editres", Xatom_editres
)
12173 ATOM_REFS_INIT ("CLIPBOARD", Xatom_CLIPBOARD
)
12174 ATOM_REFS_INIT ("TIMESTAMP", Xatom_TIMESTAMP
)
12175 ATOM_REFS_INIT ("TEXT", Xatom_TEXT
)
12176 ATOM_REFS_INIT ("COMPOUND_TEXT", Xatom_COMPOUND_TEXT
)
12177 ATOM_REFS_INIT ("UTF8_STRING", Xatom_UTF8_STRING
)
12178 ATOM_REFS_INIT ("DELETE", Xatom_DELETE
)
12179 ATOM_REFS_INIT ("MULTIPLE", Xatom_MULTIPLE
)
12180 ATOM_REFS_INIT ("INCR", Xatom_INCR
)
12181 ATOM_REFS_INIT ("_EMACS_TMP_", Xatom_EMACS_TMP
)
12182 ATOM_REFS_INIT ("TARGETS", Xatom_TARGETS
)
12183 ATOM_REFS_INIT ("NULL", Xatom_NULL
)
12184 ATOM_REFS_INIT ("ATOM", Xatom_ATOM
)
12185 ATOM_REFS_INIT ("ATOM_PAIR", Xatom_ATOM_PAIR
)
12186 ATOM_REFS_INIT ("CLIPBOARD_MANAGER", Xatom_CLIPBOARD_MANAGER
)
12187 ATOM_REFS_INIT ("_XEMBED_INFO", Xatom_XEMBED_INFO
)
12188 /* For properties of font. */
12189 ATOM_REFS_INIT ("PIXEL_SIZE", Xatom_PIXEL_SIZE
)
12190 ATOM_REFS_INIT ("AVERAGE_WIDTH", Xatom_AVERAGE_WIDTH
)
12191 ATOM_REFS_INIT ("_MULE_BASELINE_OFFSET", Xatom_MULE_BASELINE_OFFSET
)
12192 ATOM_REFS_INIT ("_MULE_RELATIVE_COMPOSE", Xatom_MULE_RELATIVE_COMPOSE
)
12193 ATOM_REFS_INIT ("_MULE_DEFAULT_ASCENT", Xatom_MULE_DEFAULT_ASCENT
)
12194 /* Ghostscript support. */
12195 ATOM_REFS_INIT ("DONE", Xatom_DONE
)
12196 ATOM_REFS_INIT ("PAGE", Xatom_PAGE
)
12197 ATOM_REFS_INIT ("SCROLLBAR", Xatom_Scrollbar
)
12198 ATOM_REFS_INIT ("HORIZONTAL_SCROLLBAR", Xatom_Horizontal_Scrollbar
)
12199 ATOM_REFS_INIT ("_XEMBED", Xatom_XEMBED
)
12201 ATOM_REFS_INIT ("_NET_WM_STATE", Xatom_net_wm_state
)
12202 ATOM_REFS_INIT ("_NET_WM_STATE_FULLSCREEN", Xatom_net_wm_state_fullscreen
)
12203 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_HORZ",
12204 Xatom_net_wm_state_maximized_horz
)
12205 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_VERT",
12206 Xatom_net_wm_state_maximized_vert
)
12207 ATOM_REFS_INIT ("_NET_WM_STATE_STICKY", Xatom_net_wm_state_sticky
)
12208 ATOM_REFS_INIT ("_NET_WM_STATE_HIDDEN", Xatom_net_wm_state_hidden
)
12209 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE", Xatom_net_window_type
)
12210 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE_TOOLTIP",
12211 Xatom_net_window_type_tooltip
)
12212 ATOM_REFS_INIT ("_NET_WM_ICON_NAME", Xatom_net_wm_icon_name
)
12213 ATOM_REFS_INIT ("_NET_WM_NAME", Xatom_net_wm_name
)
12214 ATOM_REFS_INIT ("_NET_SUPPORTED", Xatom_net_supported
)
12215 ATOM_REFS_INIT ("_NET_SUPPORTING_WM_CHECK", Xatom_net_supporting_wm_check
)
12216 ATOM_REFS_INIT ("_NET_WM_WINDOW_OPACITY", Xatom_net_wm_window_opacity
)
12217 ATOM_REFS_INIT ("_NET_ACTIVE_WINDOW", Xatom_net_active_window
)
12218 ATOM_REFS_INIT ("_NET_FRAME_EXTENTS", Xatom_net_frame_extents
)
12219 ATOM_REFS_INIT ("_NET_CURRENT_DESKTOP", Xatom_net_current_desktop
)
12220 ATOM_REFS_INIT ("_NET_WORKAREA", Xatom_net_workarea
)
12221 /* Session management */
12222 ATOM_REFS_INIT ("SM_CLIENT_ID", Xatom_SM_CLIENT_ID
)
12223 ATOM_REFS_INIT ("_XSETTINGS_SETTINGS", Xatom_xsettings_prop
)
12224 ATOM_REFS_INIT ("MANAGER", Xatom_xsettings_mgr
)
12228 enum { atom_count
= ARRAYELTS (atom_refs
) };
12229 /* 1 for _XSETTINGS_SN. */
12230 enum { total_atom_count
= 1 + atom_count
};
12231 Atom atoms_return
[total_atom_count
];
12232 char *atom_names
[total_atom_count
];
12233 static char const xsettings_fmt
[] = "_XSETTINGS_S%d";
12234 char xsettings_atom_name
[sizeof xsettings_fmt
- 2
12235 + INT_STRLEN_BOUND (int)];
12237 for (i
= 0; i
< atom_count
; i
++)
12238 atom_names
[i
] = (char *) atom_refs
[i
].name
;
12240 /* Build _XSETTINGS_SN atom name. */
12241 sprintf (xsettings_atom_name
, xsettings_fmt
,
12242 XScreenNumberOfScreen (dpyinfo
->screen
));
12243 atom_names
[i
] = xsettings_atom_name
;
12245 XInternAtoms (dpyinfo
->display
, atom_names
, total_atom_count
,
12246 False
, atoms_return
);
12248 for (i
= 0; i
< atom_count
; i
++)
12249 *(Atom
*) ((char *) dpyinfo
+ atom_refs
[i
].offset
) = atoms_return
[i
];
12251 /* Manually copy last atom. */
12252 dpyinfo
->Xatom_xsettings_sel
= atoms_return
[i
];
12255 dpyinfo
->x_dnd_atoms_size
= 8;
12256 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof *dpyinfo
->x_dnd_atoms
12257 * dpyinfo
->x_dnd_atoms_size
);
12259 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
12260 gray_bits
, gray_width
, gray_height
,
12263 x_setup_pointer_blanking (dpyinfo
);
12266 xim_initialize (dpyinfo
, resource_name
);
12269 xsettings_initialize (dpyinfo
);
12271 /* This is only needed for distinguishing keyboard and process input. */
12272 if (dpyinfo
->connection
!= 0)
12273 add_keyboard_wait_descriptor (dpyinfo
->connection
);
12276 fcntl (dpyinfo
->connection
, F_SETOWN
, getpid ());
12277 #endif /* ! defined (F_SETOWN) */
12279 if (interrupt_input
)
12280 init_sigio (dpyinfo
->connection
);
12284 XrmValue d
, fr
, to
;
12287 dpy
= dpyinfo
->display
;
12288 d
.addr
= (XPointer
)&dpy
;
12289 d
.size
= sizeof (Display
*);
12290 fr
.addr
= XtDefaultFont
;
12291 fr
.size
= sizeof (XtDefaultFont
);
12292 to
.size
= sizeof (Font
*);
12293 to
.addr
= (XPointer
)&font
;
12294 x_catch_errors (dpy
);
12295 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
12297 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
12298 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
12299 /* Do not free XFontStruct returned by the above call to XQueryFont.
12300 This leads to X protocol errors at XtCloseDisplay (Bug#18403). */
12301 x_uncatch_errors ();
12305 /* See if we should run in synchronous mode. This is useful
12306 for debugging X code. */
12308 AUTO_STRING (synchronous
, "synchronous");
12309 AUTO_STRING (Synchronous
, "Synchronous");
12310 Lisp_Object value
= display_x_get_resource (dpyinfo
, synchronous
,
12311 Synchronous
, Qnil
, Qnil
);
12312 if (STRINGP (value
)
12313 && (!strcmp (SSDATA (value
), "true")
12314 || !strcmp (SSDATA (value
), "on")))
12315 XSynchronize (dpyinfo
->display
, True
);
12319 AUTO_STRING (useXIM
, "useXIM");
12320 AUTO_STRING (UseXIM
, "UseXIM");
12321 Lisp_Object value
= display_x_get_resource (dpyinfo
, useXIM
, UseXIM
,
12324 if (STRINGP (value
)
12325 && (!strcmp (SSDATA (value
), "false")
12326 || !strcmp (SSDATA (value
), "off")))
12329 if (STRINGP (value
)
12330 && (!strcmp (SSDATA (value
), "true")
12331 || !strcmp (SSDATA (value
), "on")))
12337 /* Only do this for the very first display in the Emacs session.
12338 Ignore X session management when Emacs was first started on a
12339 tty or started as a daemon. */
12340 if (terminal
->id
== 1 && ! IS_DAEMON
)
12341 x_session_initialize (dpyinfo
);
12345 x_extension_initialize (dpyinfo
);
12353 /* Get rid of display DPYINFO, deleting all frames on it,
12354 and without sending any more commands to the X server. */
12357 x_delete_display (struct x_display_info
*dpyinfo
)
12359 struct terminal
*t
;
12360 struct color_name_cache_entry
*color_entry
, *next_color_entry
;
12362 /* Close all frames and delete the generic struct terminal for this
12364 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
12365 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
12368 /* Close X session management when we close its display. */
12369 if (t
->id
== 1 && x_session_have_connection ())
12370 x_session_close ();
12372 delete_terminal (t
);
12376 if (next_noop_dpyinfo
== dpyinfo
)
12377 next_noop_dpyinfo
= dpyinfo
->next
;
12379 if (x_display_list
== dpyinfo
)
12380 x_display_list
= dpyinfo
->next
;
12383 struct x_display_info
*tail
;
12385 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
12386 if (tail
->next
== dpyinfo
)
12387 tail
->next
= tail
->next
->next
;
12390 for (color_entry
= dpyinfo
->color_names
;
12392 color_entry
= next_color_entry
)
12394 next_color_entry
= color_entry
->next
;
12395 xfree (color_entry
->name
);
12396 xfree (color_entry
);
12399 xfree (dpyinfo
->x_id_name
);
12400 xfree (dpyinfo
->x_dnd_atoms
);
12401 xfree (dpyinfo
->color_cells
);
12405 #ifdef USE_X_TOOLKIT
12407 /* Atimer callback function for TIMER. Called every 0.1s to process
12408 Xt timeouts, if needed. We must avoid calling XtAppPending as
12409 much as possible because that function does an implicit XFlush
12410 that slows us down. */
12413 x_process_timeouts (struct atimer
*timer
)
12416 x_timeout_atimer_activated_flag
= false;
12417 if (toolkit_scroll_bar_interaction
|| popup_activated ())
12419 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
12420 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
12421 /* Reactivate the atimer for next time. */
12422 x_activate_timeout_atimer ();
12427 /* Install an asynchronous timer that processes Xt timeout events
12428 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
12429 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
12430 function whenever these variables are set. This is necessary
12431 because some widget sets use timeouts internally, for example the
12432 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
12433 processed, these widgets don't behave normally. */
12436 x_activate_timeout_atimer (void)
12439 if (!x_timeout_atimer_activated_flag
)
12441 struct timespec interval
= make_timespec (0, 100 * 1000 * 1000);
12442 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
12443 x_timeout_atimer_activated_flag
= true;
12448 #endif /* USE_X_TOOLKIT */
12451 /* Set up use of X before we make the first connection. */
12453 static struct redisplay_interface x_redisplay_interface
=
12455 x_frame_parm_handlers
,
12459 x_clear_end_of_line
,
12461 x_after_update_window_line
,
12462 x_update_window_begin
,
12463 x_update_window_end
,
12465 x_clear_window_mouse_face
,
12466 x_get_glyph_overhangs
,
12467 x_fix_overlapping_area
,
12468 x_draw_fringe_bitmap
,
12470 x_cr_define_fringe_bitmap
,
12471 x_cr_destroy_fringe_bitmap
,
12473 0, /* define_fringe_bitmap */
12474 0, /* destroy_fringe_bitmap */
12476 x_compute_glyph_string_overhangs
,
12477 x_draw_glyph_string
,
12478 x_define_frame_cursor
,
12479 x_clear_frame_area
,
12480 x_draw_window_cursor
,
12481 x_draw_vertical_window_border
,
12482 x_draw_window_divider
,
12483 x_shift_glyphs_for_insert
, /* Never called; see comment in function. */
12489 /* This function is called when the last frame on a display is deleted. */
12491 x_delete_terminal (struct terminal
*terminal
)
12493 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
12495 /* Protect against recursive calls. delete_frame in
12496 delete_terminal calls us back when it deletes our last frame. */
12497 if (!terminal
->name
)
12502 /* We must close our connection to the XIM server before closing the
12505 xim_close_dpy (dpyinfo
);
12508 /* Normally, the display is available... */
12509 if (dpyinfo
->display
)
12511 x_destroy_all_bitmaps (dpyinfo
);
12512 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
12514 /* Whether or not XCloseDisplay destroys the associated resource
12515 database depends on the version of libX11. To avoid both
12516 crash and memory leak, we dissociate the database from the
12517 display and then destroy dpyinfo->xrdb ourselves.
12519 Unfortunately, the above strategy does not work in some
12520 situations due to a bug in newer versions of libX11: because
12521 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
12522 dpy->db is NULL, XCloseDisplay destroys the associated
12523 database whereas it has not been created by XGetDefault
12524 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
12525 don't destroy the database here in order to avoid the crash
12526 in the above situations for now, though that may cause memory
12527 leaks in other situations. */
12529 #ifdef HAVE_XRMSETDATABASE
12530 XrmSetDatabase (dpyinfo
->display
, NULL
);
12532 dpyinfo
->display
->db
= NULL
;
12534 /* We used to call XrmDestroyDatabase from x_delete_display, but
12535 some older versions of libX11 crash if we call it after
12536 closing all the displays. */
12537 XrmDestroyDatabase (dpyinfo
->xrdb
);
12541 xg_display_close (dpyinfo
->display
);
12543 #ifdef USE_X_TOOLKIT
12544 XtCloseDisplay (dpyinfo
->display
);
12546 XCloseDisplay (dpyinfo
->display
);
12548 #endif /* ! USE_GTK */
12549 /* Do not close the connection here because it's already closed
12550 by X(t)CloseDisplay (Bug#18403). */
12551 dpyinfo
->display
= NULL
;
12554 /* ...but if called from x_connection_closed, the display may already
12555 be closed and dpyinfo->display was set to 0 to indicate that. Since
12556 X server is most likely gone, explicit close is the only reliable
12557 way to continue and avoid Bug#19147. */
12558 else if (dpyinfo
->connection
>= 0)
12559 emacs_close (dpyinfo
->connection
);
12561 /* No more input on this descriptor. */
12562 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
12563 /* Mark as dead. */
12564 dpyinfo
->connection
= -1;
12566 x_delete_display (dpyinfo
);
12570 /* Create a struct terminal, initialize it with the X11 specific
12571 functions and make DISPLAY->TERMINAL point to it. */
12573 static struct terminal
*
12574 x_create_terminal (struct x_display_info
*dpyinfo
)
12576 struct terminal
*terminal
;
12578 terminal
= create_terminal (output_x_window
, &x_redisplay_interface
);
12580 terminal
->display_info
.x
= dpyinfo
;
12581 dpyinfo
->terminal
= terminal
;
12583 /* kboard is initialized in x_term_init. */
12585 terminal
->clear_frame_hook
= x_clear_frame
;
12586 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
12587 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
12588 terminal
->ring_bell_hook
= XTring_bell
;
12589 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
12590 terminal
->update_begin_hook
= x_update_begin
;
12591 terminal
->update_end_hook
= x_update_end
;
12592 terminal
->read_socket_hook
= XTread_socket
;
12593 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
12594 terminal
->mouse_position_hook
= XTmouse_position
;
12595 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
12596 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
12597 terminal
->fullscreen_hook
= XTfullscreen_hook
;
12598 terminal
->menu_show_hook
= x_menu_show
;
12599 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
12600 terminal
->popup_dialog_hook
= xw_popup_dialog
;
12602 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
12603 terminal
->set_horizontal_scroll_bar_hook
= XTset_horizontal_scroll_bar
;
12604 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
12605 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
12606 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
12607 terminal
->delete_frame_hook
= x_destroy_window
;
12608 terminal
->delete_terminal_hook
= x_delete_terminal
;
12609 /* Other hooks are NULL by default. */
12615 x_initialize (void)
12620 any_help_event_p
= false;
12621 ignore_next_mouse_click_timeout
= 0;
12624 current_count
= -1;
12627 /* Try to use interrupt input; if we can't, then start polling. */
12628 Fset_input_interrupt_mode (Qt
);
12630 #ifdef USE_X_TOOLKIT
12631 XtToolkitInitialize ();
12633 Xt_app_con
= XtCreateApplicationContext ();
12635 /* Register a converter from strings to pixels, which uses
12636 Emacs' color allocation infrastructure. */
12637 XtAppSetTypeConverter (Xt_app_con
,
12638 XtRString
, XtRPixel
, cvt_string_to_pixel
,
12639 cvt_string_to_pixel_args
,
12640 XtNumber (cvt_string_to_pixel_args
),
12641 XtCacheByDisplay
, cvt_pixel_dtor
);
12643 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
12646 #ifdef USE_TOOLKIT_SCROLL_BARS
12648 xaw3d_arrow_scroll
= False
;
12649 xaw3d_pick_top
= True
;
12654 x_cr_init_fringe (&x_redisplay_interface
);
12657 /* Note that there is no real way portable across R3/R4 to get the
12658 original error handler. */
12659 XSetErrorHandler (x_error_handler
);
12660 XSetIOErrorHandler (x_io_error_quitter
);
12667 /* Emacs can handle only core input events, so make sure
12668 Gtk doesn't use Xinput or Xinput2 extensions. */
12669 xputenv ("GDK_CORE_DEVICE_EVENTS=1");
12674 syms_of_xterm (void)
12676 x_error_message
= NULL
;
12678 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
12679 DEFSYM (Qlatin_1
, "latin-1");
12682 xg_default_icon_file
= build_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
12683 staticpro (&xg_default_icon_file
);
12685 DEFSYM (Qx_gtk_map_stock
, "x-gtk-map-stock");
12688 DEFVAR_BOOL ("x-use-underline-position-properties",
12689 x_use_underline_position_properties
,
12690 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
12691 A value of nil means ignore them. If you encounter fonts with bogus
12692 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
12693 to 4.1, set this to nil. You can also use `underline-minimum-offset'
12694 to override the font's UNDERLINE_POSITION for small font display
12696 x_use_underline_position_properties
= true;
12698 DEFVAR_BOOL ("x-underline-at-descent-line",
12699 x_underline_at_descent_line
,
12700 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
12701 A value of nil means to draw the underline according to the value of the
12702 variable `x-use-underline-position-properties', which is usually at the
12703 baseline level. The default value is nil. */);
12704 x_underline_at_descent_line
= false;
12706 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
12707 x_mouse_click_focus_ignore_position
,
12708 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
12709 This variable is only used when the window manager requires that you
12710 click on a frame to select it (give it focus). In that case, a value
12711 of nil, means that the selected window and cursor position changes to
12712 reflect the mouse click position, while a non-nil value means that the
12713 selected window or cursor position is preserved. */);
12714 x_mouse_click_focus_ignore_position
= false;
12716 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
12717 doc
: /* Which toolkit scroll bars Emacs uses, if any.
12718 A value of nil means Emacs doesn't use toolkit scroll bars.
12719 With the X Window system, the value is a symbol describing the
12720 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
12721 With MS Windows or Nextstep, the value is t. */);
12722 #ifdef USE_TOOLKIT_SCROLL_BARS
12724 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
12725 #elif defined HAVE_XAW3D
12726 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
12728 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
12730 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
12733 Vx_toolkit_scroll_bars
= Qnil
;
12736 DEFSYM (Qmodifier_value
, "modifier-value");
12737 DEFSYM (Qalt
, "alt");
12738 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
12739 DEFSYM (Qhyper
, "hyper");
12740 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
12741 DEFSYM (Qmeta
, "meta");
12742 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
12743 DEFSYM (Qsuper
, "super");
12744 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
12746 DEFVAR_LISP ("x-alt-keysym", Vx_alt_keysym
,
12747 doc
: /* Which keys Emacs uses for the alt modifier.
12748 This should be one of the symbols `alt', `hyper', `meta', `super'.
12749 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
12750 is nil, which is the same as `alt'. */);
12751 Vx_alt_keysym
= Qnil
;
12753 DEFVAR_LISP ("x-hyper-keysym", Vx_hyper_keysym
,
12754 doc
: /* Which keys Emacs uses for the hyper modifier.
12755 This should be one of the symbols `alt', `hyper', `meta', `super'.
12756 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
12757 default is nil, which is the same as `hyper'. */);
12758 Vx_hyper_keysym
= Qnil
;
12760 DEFVAR_LISP ("x-meta-keysym", Vx_meta_keysym
,
12761 doc
: /* Which keys Emacs uses for the meta modifier.
12762 This should be one of the symbols `alt', `hyper', `meta', `super'.
12763 For example, `meta' means use the Meta_L and Meta_R keysyms. The
12764 default is nil, which is the same as `meta'. */);
12765 Vx_meta_keysym
= Qnil
;
12767 DEFVAR_LISP ("x-super-keysym", Vx_super_keysym
,
12768 doc
: /* Which keys Emacs uses for the super modifier.
12769 This should be one of the symbols `alt', `hyper', `meta', `super'.
12770 For example, `super' means use the Super_L and Super_R keysyms. The
12771 default is nil, which is the same as `super'. */);
12772 Vx_super_keysym
= Qnil
;
12774 DEFVAR_LISP ("x-keysym-table", Vx_keysym_table
,
12775 doc
: /* Hash table of character codes indexed by X keysym codes. */);
12776 Vx_keysym_table
= make_hash_table (hashtest_eql
, make_number (900),
12777 make_float (DEFAULT_REHASH_SIZE
),
12778 make_float (DEFAULT_REHASH_THRESHOLD
),
12781 DEFVAR_BOOL ("x-frame-normalize-before-maximize",
12782 x_frame_normalize_before_maximize
,
12783 doc
: /* Non-nil means normalize frame before maximizing.
12784 If this variable is t, Emacs first asks the window manager to give the
12785 frame its normal size, and only then the final state, whenever changing
12786 from a full-height, full-width or full-both state to the maximized one
12787 or when changing from the maximized to the full-height or full-width
12790 Set this variable only if your window manager cannot handle the
12791 transition between the various maximization states. */);
12792 x_frame_normalize_before_maximize
= false;