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
10 (at 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"
98 #if !defined (NO_EDITRES)
100 extern void _XEditResCheckMessages (Widget
, XtPointer
, XEvent
*, Boolean
*);
101 #endif /* not NO_EDITRES */
103 /* Include toolkit specific headers for the scroll bar widget. */
105 #ifdef USE_TOOLKIT_SCROLL_BARS
106 #if defined USE_MOTIF
107 #include <Xm/Xm.h> /* For LESSTIF_VERSION */
108 #include <Xm/ScrollBar.h>
109 #else /* !USE_MOTIF i.e. use Xaw */
112 #include <X11/Xaw3d/Simple.h>
113 #include <X11/Xaw3d/Scrollbar.h>
114 #include <X11/Xaw3d/ThreeD.h>
115 #else /* !HAVE_XAW3D */
116 #include <X11/Xaw/Simple.h>
117 #include <X11/Xaw/Scrollbar.h>
118 #endif /* !HAVE_XAW3D */
120 #define XtNpickTop "pickTop"
121 #endif /* !XtNpickTop */
122 #endif /* !USE_MOTIF */
123 #endif /* USE_TOOLKIT_SCROLL_BARS */
125 #endif /* USE_X_TOOLKIT */
129 #ifndef XtNinitialState
130 #define XtNinitialState "initialState"
134 #include "bitmaps/gray.xbm"
137 #include <X11/XKBlib.h>
140 /* Default to using XIM if available. */
144 bool use_xim
= false; /* configure --without-xim */
147 /* Non-zero means that a HELP_EVENT has been generated since Emacs
150 static bool any_help_event_p
;
152 /* This is a chain of structures for all the X displays currently in
155 struct x_display_info
*x_display_list
;
159 /* The application context for Xt use. */
160 XtAppContext Xt_app_con
;
161 static String Xt_default_resources
[] = {0};
163 /* Non-zero means user is interacting with a toolkit scroll bar. */
164 static bool toolkit_scroll_bar_interaction
;
166 #endif /* USE_X_TOOLKIT */
168 /* Non-zero timeout value means ignore next mouse click if it arrives
169 before that timeout elapses (i.e. as part of the same sequence of
170 events resulting from clicking on a frame to select it). */
172 static Time ignore_next_mouse_click_timeout
;
174 /* Used locally within XTread_socket. */
176 static int x_noop_count
;
179 /* The name of the Emacs icon file. */
180 static Lisp_Object xg_default_icon_file
;
183 /* Some functions take this as char *, not const char *. */
184 static char emacs_class
[] = EMACS_CLASS
;
188 XEMBED_MAPPED
= 1 << 0
193 XEMBED_EMBEDDED_NOTIFY
= 0,
194 XEMBED_WINDOW_ACTIVATE
= 1,
195 XEMBED_WINDOW_DEACTIVATE
= 2,
196 XEMBED_REQUEST_FOCUS
= 3,
198 XEMBED_FOCUS_OUT
= 5,
199 XEMBED_FOCUS_NEXT
= 6,
200 XEMBED_FOCUS_PREV
= 7,
202 XEMBED_MODALITY_ON
= 10,
203 XEMBED_MODALITY_OFF
= 11,
204 XEMBED_REGISTER_ACCELERATOR
= 12,
205 XEMBED_UNREGISTER_ACCELERATOR
= 13,
206 XEMBED_ACTIVATE_ACCELERATOR
= 14
209 static void x_free_cr_resources (struct frame
*);
210 static bool x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
211 static void x_raise_frame (struct frame
*);
212 static void x_lower_frame (struct frame
*);
213 static int x_io_error_quitter (Display
*);
214 static struct terminal
*x_create_terminal (struct x_display_info
*);
215 static void x_frame_rehighlight (struct x_display_info
*);
217 static void x_clip_to_row (struct window
*, struct glyph_row
*,
218 enum glyph_row_area
, GC
);
219 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
, int);
220 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
221 enum scroll_bar_part
*,
222 Lisp_Object
*, Lisp_Object
*,
224 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
225 enum scroll_bar_part
*,
226 Lisp_Object
*, Lisp_Object
*,
228 static bool x_handle_net_wm_state (struct frame
*, const XPropertyEvent
*);
229 static void x_check_fullscreen (struct frame
*);
230 static void x_check_expected_move (struct frame
*, int, int);
231 static void x_sync_with_move (struct frame
*, int, int, bool);
232 static int handle_one_xevent (struct x_display_info
*,
233 const XEvent
*, int *,
234 struct input_event
*);
235 #if ! (defined USE_X_TOOLKIT || defined USE_MOTIF)
236 static int x_dispatch_event (XEvent
*, Display
*);
238 static void x_wm_set_window_state (struct frame
*, int);
239 static void x_wm_set_icon_pixmap (struct frame
*, ptrdiff_t);
240 static void x_initialize (void);
242 static bool get_current_wm_state (struct frame
*, Window
, int *, bool *);
244 /* Flush display of frame F. */
247 x_flush (struct frame
*f
)
249 eassert (f
&& FRAME_X_P (f
));
250 /* Don't call XFlush when it is not safe to redisplay; the X
251 connection may be broken. */
252 if (!NILP (Vinhibit_redisplay
))
256 XFlush (FRAME_X_DISPLAY (f
));
261 /* Remove calls to XFlush by defining XFlush to an empty replacement.
262 Calls to XFlush should be unnecessary because the X output buffer
263 is flushed automatically as needed by calls to XPending,
264 XNextEvent, or XWindowEvent according to the XFlush man page.
265 XTread_socket calls XPending. Removing XFlush improves
268 #define XFlush(DISPLAY) (void) 0
271 /***********************************************************************
273 ***********************************************************************/
277 /* This is a function useful for recording debugging information about
278 the sequence of occurrences in this file. */
286 struct record event_record
[100];
288 int event_record_index
;
291 record_event (char *locus
, int type
)
293 if (event_record_index
== ARRAYELTS (event_record
))
294 event_record_index
= 0;
296 event_record
[event_record_index
].locus
= locus
;
297 event_record
[event_record_index
].type
= type
;
298 event_record_index
++;
305 #define FRAME_CR_CONTEXT(f) ((f)->output_data.x->cr_context)
306 #define FRAME_CR_SURFACE(f) ((f)->output_data.x->cr_surface)
308 static struct x_gc_ext_data
*
309 x_gc_get_ext_data (struct frame
*f
, GC gc
, int create_if_not_found_p
)
311 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
313 XExtData
**head
, *ext_data
;
316 head
= XEHeadOfExtensionList (object
);
317 ext_data
= XFindOnExtensionList (head
, dpyinfo
->ext_codes
->extension
);
318 if (ext_data
== NULL
)
320 if (!create_if_not_found_p
)
324 ext_data
= xzalloc (sizeof (*ext_data
));
325 ext_data
->number
= dpyinfo
->ext_codes
->extension
;
326 ext_data
->private_data
= xzalloc (sizeof (struct x_gc_ext_data
));
327 XAddToExtensionList (head
, ext_data
);
330 return (struct x_gc_ext_data
*) ext_data
->private_data
;
334 x_extension_initialize (struct x_display_info
*dpyinfo
)
336 XExtCodes
*ext_codes
= XAddExtension (dpyinfo
->display
);
338 dpyinfo
->ext_codes
= ext_codes
;
342 x_cr_destroy_surface (struct frame
*f
)
344 if (FRAME_CR_SURFACE (f
))
346 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
347 cairo_surface_destroy (FRAME_CR_SURFACE (f
));
348 FRAME_CR_SURFACE (f
) = 0;
349 if (cr
) cairo_destroy (cr
);
350 FRAME_CR_CONTEXT (f
) = NULL
;
355 x_begin_cr_clip (struct frame
*f
, GC gc
)
357 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
362 if (! FRAME_CR_SURFACE (f
))
364 cairo_surface_t
*surface
;
365 surface
= cairo_xlib_surface_create (FRAME_X_DISPLAY (f
),
367 FRAME_DISPLAY_INFO (f
)->visual
,
368 FRAME_PIXEL_WIDTH (f
),
369 FRAME_PIXEL_HEIGHT (f
));
370 cr
= cairo_create (surface
);
371 cairo_surface_destroy (surface
);
374 cr
= cairo_create (FRAME_CR_SURFACE (f
));
375 FRAME_CR_CONTEXT (f
) = cr
;
381 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 0);
383 if (gc_ext
&& gc_ext
->n_clip_rects
)
387 for (i
= 0; i
< gc_ext
->n_clip_rects
; i
++)
388 cairo_rectangle (cr
, gc_ext
->clip_rects
[i
].x
,
389 gc_ext
->clip_rects
[i
].y
,
390 gc_ext
->clip_rects
[i
].width
,
391 gc_ext
->clip_rects
[i
].height
);
400 x_end_cr_clip (struct frame
*f
)
402 cairo_restore (FRAME_CR_CONTEXT (f
));
406 x_set_cr_source_with_gc_foreground (struct frame
*f
, GC gc
)
411 XGetGCValues (FRAME_X_DISPLAY (f
), gc
, GCForeground
, &xgcv
);
412 color
.pixel
= xgcv
.foreground
;
413 x_query_color (f
, &color
);
414 cairo_set_source_rgb (FRAME_CR_CONTEXT (f
), color
.red
/ 65535.0,
415 color
.green
/ 65535.0, color
.blue
/ 65535.0);
419 x_set_cr_source_with_gc_background (struct frame
*f
, GC gc
)
424 XGetGCValues (FRAME_X_DISPLAY (f
), gc
, GCBackground
, &xgcv
);
425 color
.pixel
= xgcv
.background
;
426 x_query_color (f
, &color
);
427 cairo_set_source_rgb (FRAME_CR_CONTEXT (f
), color
.red
/ 65535.0,
428 color
.green
/ 65535.0, color
.blue
/ 65535.0);
431 /* Fringe bitmaps. */
433 static int max_fringe_bmp
= 0;
434 static cairo_pattern_t
**fringe_bmp
= 0;
437 x_cr_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
440 cairo_surface_t
*surface
;
442 cairo_pattern_t
*pattern
;
444 if (which
>= max_fringe_bmp
)
447 max_fringe_bmp
= which
+ 20;
448 fringe_bmp
= (cairo_pattern_t
**) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (cairo_pattern_t
*));
449 while (i
< max_fringe_bmp
)
455 surface
= cairo_image_surface_create (CAIRO_FORMAT_A1
, wd
, h
);
456 stride
= cairo_image_surface_get_stride (surface
);
457 data
= cairo_image_surface_get_data (surface
);
459 for (i
= 0; i
< h
; i
++)
461 *((unsigned short *) data
) = bits
[i
];
465 cairo_surface_mark_dirty (surface
);
466 pattern
= cairo_pattern_create_for_surface (surface
);
467 cairo_surface_destroy (surface
);
471 fringe_bmp
[which
] = pattern
;
475 x_cr_destroy_fringe_bitmap (int which
)
477 if (which
>= max_fringe_bmp
)
480 if (fringe_bmp
[which
])
483 cairo_pattern_destroy (fringe_bmp
[which
]);
486 fringe_bmp
[which
] = 0;
490 x_cr_draw_image (struct frame
*f
, GC gc
, cairo_pattern_t
*image
,
491 int src_x
, int src_y
, int width
, int height
,
492 int dest_x
, int dest_y
, bool overlay_p
)
495 cairo_matrix_t matrix
;
496 cairo_surface_t
*surface
;
497 cairo_format_t format
;
499 cr
= x_begin_cr_clip (f
, gc
);
501 cairo_rectangle (cr
, dest_x
, dest_y
, width
, height
);
504 x_set_cr_source_with_gc_background (f
, gc
);
505 cairo_rectangle (cr
, dest_x
, dest_y
, width
, height
);
506 cairo_fill_preserve (cr
);
509 cairo_matrix_init_translate (&matrix
, src_x
- dest_x
, src_y
- dest_y
);
510 cairo_pattern_set_matrix (image
, &matrix
);
511 cairo_pattern_get_surface (image
, &surface
);
512 format
= cairo_image_surface_get_format (surface
);
513 if (format
!= CAIRO_FORMAT_A8
&& format
!= CAIRO_FORMAT_A1
)
515 cairo_set_source (cr
, image
);
520 x_set_cr_source_with_gc_foreground (f
, gc
);
521 cairo_mask (cr
, image
);
527 x_cr_draw_frame (cairo_t
*cr
, struct frame
*f
)
531 width
= FRAME_PIXEL_WIDTH (f
);
532 height
= FRAME_PIXEL_HEIGHT (f
);
534 x_free_cr_resources (f
);
535 FRAME_CR_CONTEXT (f
) = cr
;
536 x_clear_area (f
, 0, 0, width
, height
);
537 expose_frame (f
, 0, 0, width
, height
);
538 FRAME_CR_CONTEXT (f
) = NULL
;
541 static cairo_status_t
542 x_cr_accumulate_data (void *closure
, const unsigned char *data
,
545 Lisp_Object
*acc
= (Lisp_Object
*) closure
;
547 *acc
= Fcons (make_unibyte_string ((char const *) data
, length
), *acc
);
549 return CAIRO_STATUS_SUCCESS
;
553 x_cr_destroy (Lisp_Object arg
)
555 cairo_t
*cr
= (cairo_t
*) XSAVE_POINTER (arg
, 0);
563 x_cr_export_frames (Lisp_Object frames
, cairo_surface_type_t surface_type
)
566 cairo_surface_t
*surface
;
569 void (*surface_set_size_func
) (cairo_surface_t
*, double, double) = NULL
;
570 Lisp_Object acc
= Qnil
;
571 int count
= SPECPDL_INDEX ();
573 specbind (Qredisplay_dont_pause
, Qt
);
574 redisplay_preserve_echo_area (31);
576 f
= XFRAME (XCAR (frames
));
577 frames
= XCDR (frames
);
578 width
= FRAME_PIXEL_WIDTH (f
);
579 height
= FRAME_PIXEL_HEIGHT (f
);
582 #ifdef CAIRO_HAS_PDF_SURFACE
583 if (surface_type
== CAIRO_SURFACE_TYPE_PDF
)
585 surface
= cairo_pdf_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
587 surface_set_size_func
= cairo_pdf_surface_set_size
;
591 #ifdef CAIRO_HAS_PNG_FUNCTIONS
592 if (surface_type
== CAIRO_SURFACE_TYPE_IMAGE
)
593 surface
= cairo_image_surface_create (CAIRO_FORMAT_RGB24
, width
, height
);
596 #ifdef CAIRO_HAS_PS_SURFACE
597 if (surface_type
== CAIRO_SURFACE_TYPE_PS
)
599 surface
= cairo_ps_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
601 surface_set_size_func
= cairo_ps_surface_set_size
;
605 #ifdef CAIRO_HAS_SVG_SURFACE
606 if (surface_type
== CAIRO_SURFACE_TYPE_SVG
)
607 surface
= cairo_svg_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
613 cr
= cairo_create (surface
);
614 cairo_surface_destroy (surface
);
615 record_unwind_protect (x_cr_destroy
, make_save_ptr (cr
));
619 x_free_cr_resources (f
);
620 FRAME_CR_CONTEXT (f
) = cr
;
621 x_clear_area (f
, 0, 0, width
, height
);
622 expose_frame (f
, 0, 0, width
, height
);
623 FRAME_CR_CONTEXT (f
) = NULL
;
628 cairo_surface_show_page (surface
);
629 f
= XFRAME (XCAR (frames
));
630 frames
= XCDR (frames
);
631 width
= FRAME_PIXEL_WIDTH (f
);
632 height
= FRAME_PIXEL_HEIGHT (f
);
633 if (surface_set_size_func
)
634 (*surface_set_size_func
) (surface
, width
, height
);
641 #ifdef CAIRO_HAS_PNG_FUNCTIONS
642 if (surface_type
== CAIRO_SURFACE_TYPE_IMAGE
)
644 cairo_surface_flush (surface
);
645 cairo_surface_write_to_png_stream (surface
, x_cr_accumulate_data
, &acc
);
650 unbind_to (count
, Qnil
);
652 return CALLN (Fapply
, intern ("concat"), Fnreverse (acc
));
655 #endif /* USE_CAIRO */
658 x_free_cr_resources (struct frame
*f
)
663 Lisp_Object rest
, frame
;
664 FOR_EACH_FRAME (rest
, frame
)
665 if (FRAME_X_P (XFRAME (frame
)))
666 x_free_cr_resources (XFRAME (frame
));
670 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
674 cairo_surface_t
*surface
= cairo_get_target (cr
);
676 if (cairo_surface_get_type (surface
) == CAIRO_SURFACE_TYPE_XLIB
)
679 FRAME_CR_CONTEXT (f
) = NULL
;
687 x_set_clip_rectangles (struct frame
*f
, GC gc
, XRectangle
*rectangles
, int n
)
689 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, rectangles
, n
, Unsorted
);
691 eassert (n
>= 0 && n
<= MAX_CLIP_RECTS
);
694 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 1);
696 gc_ext
->n_clip_rects
= n
;
697 memcpy (gc_ext
->clip_rects
, rectangles
, sizeof (XRectangle
) * n
);
703 x_reset_clip_rectangles (struct frame
*f
, GC gc
)
705 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
708 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 0);
711 gc_ext
->n_clip_rects
= 0;
717 x_fill_rectangle (struct frame
*f
, GC gc
, int x
, int y
, int width
, int height
)
722 cr
= x_begin_cr_clip (f
, gc
);
723 x_set_cr_source_with_gc_foreground (f
, gc
);
724 cairo_rectangle (cr
, x
, y
, width
, height
);
728 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
729 gc
, x
, y
, width
, height
);
734 x_draw_rectangle (struct frame
*f
, GC gc
, int x
, int y
, int width
, int height
)
739 cr
= x_begin_cr_clip (f
, gc
);
740 x_set_cr_source_with_gc_foreground (f
, gc
);
741 cairo_rectangle (cr
, x
+ 0.5, y
+ 0.5, width
, height
);
742 cairo_set_line_width (cr
, 1);
746 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
747 gc
, x
, y
, width
, height
);
752 x_clear_window (struct frame
*f
)
757 cr
= x_begin_cr_clip (f
, NULL
);
758 x_set_cr_source_with_gc_background (f
, f
->output_data
.x
->normal_gc
);
762 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
768 x_fill_trapezoid_for_relief (struct frame
*f
, GC gc
, int x
, int y
,
769 int width
, int height
, int top_p
)
773 cr
= x_begin_cr_clip (f
, gc
);
774 x_set_cr_source_with_gc_foreground (f
, gc
);
775 cairo_move_to (cr
, top_p
? x
: x
+ height
, y
);
776 cairo_line_to (cr
, x
, y
+ height
);
777 cairo_line_to (cr
, top_p
? x
+ width
- height
: x
+ width
, y
+ height
);
778 cairo_line_to (cr
, x
+ width
, y
);
785 CORNER_BOTTOM_RIGHT
, /* 0 -> pi/2 */
786 CORNER_BOTTOM_LEFT
, /* pi/2 -> pi */
787 CORNER_TOP_LEFT
, /* pi -> 3pi/2 */
788 CORNER_TOP_RIGHT
, /* 3pi/2 -> 2pi */
793 x_erase_corners_for_relief (struct frame
*f
, GC gc
, int x
, int y
,
794 int width
, int height
,
795 double radius
, double margin
, int corners
)
800 cr
= x_begin_cr_clip (f
, gc
);
801 x_set_cr_source_with_gc_background (f
, gc
);
802 for (i
= 0; i
< CORNER_LAST
; i
++)
803 if (corners
& (1 << i
))
805 double xm
, ym
, xc
, yc
;
807 if (i
== CORNER_TOP_LEFT
|| i
== CORNER_BOTTOM_LEFT
)
808 xm
= x
- margin
, xc
= xm
+ radius
;
810 xm
= x
+ width
+ margin
, xc
= xm
- radius
;
811 if (i
== CORNER_TOP_LEFT
|| i
== CORNER_TOP_RIGHT
)
812 ym
= y
- margin
, yc
= ym
+ radius
;
814 ym
= y
+ height
+ margin
, yc
= ym
- radius
;
816 cairo_move_to (cr
, xm
, ym
);
817 cairo_arc (cr
, xc
, yc
, radius
, i
* M_PI_2
, (i
+ 1) * M_PI_2
);
820 cairo_rectangle (cr
, x
, y
, width
, height
);
826 x_draw_horizontal_wave (struct frame
*f
, GC gc
, int x
, int y
,
827 int width
, int height
, int wave_length
)
830 double dx
= wave_length
, dy
= height
- 1;
833 cr
= x_begin_cr_clip (f
, gc
);
834 x_set_cr_source_with_gc_foreground (f
, gc
);
835 cairo_rectangle (cr
, x
, y
, width
, height
);
840 xoffset
= x
% (wave_length
* 2);
842 xoffset
= wave_length
* 2;
845 xoffset
= x
% (wave_length
* 2) + wave_length
* 2;
846 n
= (width
+ xoffset
) / wave_length
+ 1;
847 if (xoffset
> wave_length
)
849 xoffset
-= wave_length
;
855 cairo_move_to (cr
, x
- xoffset
+ 0.5, y
+ 0.5);
858 cairo_rel_line_to (cr
, dx
, dy
);
861 cairo_set_line_width (cr
, 1);
868 /* Return the struct x_display_info corresponding to DPY. */
870 struct x_display_info
*
871 x_display_info_for_display (Display
*dpy
)
873 struct x_display_info
*dpyinfo
;
875 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
876 if (dpyinfo
->display
== dpy
)
883 x_find_topmost_parent (struct frame
*f
)
885 struct x_output
*x
= f
->output_data
.x
;
886 Window win
= None
, wi
= x
->parent_desc
;
887 Display
*dpy
= FRAME_X_DISPLAY (f
);
889 while (wi
!= FRAME_DISPLAY_INFO (f
)->root_window
)
893 unsigned int nchildren
;
896 if (XQueryTree (dpy
, win
, &root
, &wi
, &children
, &nchildren
))
905 #define OPAQUE 0xffffffff
908 x_set_frame_alpha (struct frame
*f
)
910 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
911 Display
*dpy
= FRAME_X_DISPLAY (f
);
912 Window win
= FRAME_OUTER_WINDOW (f
);
914 double alpha_min
= 1.0;
918 if (dpyinfo
->x_highlight_frame
== f
)
923 if (FLOATP (Vframe_alpha_lower_limit
))
924 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
925 else if (INTEGERP (Vframe_alpha_lower_limit
))
926 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
930 else if (alpha
> 1.0)
932 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
935 opac
= alpha
* OPAQUE
;
937 x_catch_errors (dpy
);
939 /* If there is a parent from the window manager, put the property there
940 also, to work around broken window managers that fail to do that.
941 Do this unconditionally as this function is called on reparent when
942 alpha has not changed on the frame. */
944 parent
= x_find_topmost_parent (f
);
946 XChangeProperty (dpy
, parent
, dpyinfo
->Xatom_net_wm_window_opacity
,
947 XA_CARDINAL
, 32, PropModeReplace
,
948 (unsigned char *) &opac
, 1);
950 /* return unless necessary */
955 unsigned long n
, left
;
957 rc
= XGetWindowProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
958 0, 1, False
, XA_CARDINAL
,
959 &actual
, &format
, &n
, &left
,
962 if (rc
== Success
&& actual
!= None
)
964 unsigned long value
= *(unsigned long *)data
;
974 XChangeProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
975 XA_CARDINAL
, 32, PropModeReplace
,
976 (unsigned char *) &opac
, 1);
980 /***********************************************************************
981 Starting and ending an update
982 ***********************************************************************/
984 /* Start an update of frame F. This function is installed as a hook
985 for update_begin, i.e. it is called when update_begin is called.
986 This function is called prior to calls to x_update_window_begin for
987 each window being updated. Currently, there is nothing to do here
988 because all interesting stuff is done on a window basis. */
991 x_update_begin (struct frame
*f
)
994 if (! NILP (tip_frame
) && XFRAME (tip_frame
) == f
995 && ! FRAME_VISIBLE_P (f
))
998 if (! FRAME_CR_SURFACE (f
))
1002 if (FRAME_GTK_WIDGET (f
))
1004 GdkWindow
*w
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
1005 width
= gdk_window_get_width (w
);
1006 height
= gdk_window_get_height (w
);
1011 width
= FRAME_PIXEL_WIDTH (f
);
1012 height
= FRAME_PIXEL_HEIGHT (f
);
1013 if (! FRAME_EXTERNAL_TOOL_BAR (f
))
1014 height
+= FRAME_TOOL_BAR_HEIGHT (f
);
1015 if (! FRAME_EXTERNAL_MENU_BAR (f
))
1016 height
+= FRAME_MENU_BAR_HEIGHT (f
);
1019 if (width
> 0 && height
> 0)
1022 FRAME_CR_SURFACE (f
) = cairo_image_surface_create
1023 (CAIRO_FORMAT_ARGB32
, width
, height
);
1027 #endif /* USE_CAIRO */
1030 /* Start update of window W. */
1033 x_update_window_begin (struct window
*w
)
1035 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1036 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
1038 w
->output_cursor
= w
->cursor
;
1042 if (f
== hlinfo
->mouse_face_mouse_frame
)
1044 /* Don't do highlighting for mouse motion during the update. */
1045 hlinfo
->mouse_face_defer
= true;
1047 /* If F needs to be redrawn, simply forget about any prior mouse
1049 if (FRAME_GARBAGED_P (f
))
1050 hlinfo
->mouse_face_window
= Qnil
;
1057 /* Draw a vertical window border from (x,y0) to (x,y1) */
1060 x_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
1062 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1065 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
1067 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
1071 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
, x
, y0
, 1, y1
- y0
);
1073 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1074 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
1078 /* Draw a window divider from (x0,y0) to (x1,y1) */
1081 x_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
1083 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1084 struct face
*face
= FACE_FROM_ID (f
, WINDOW_DIVIDER_FACE_ID
);
1085 struct face
*face_first
= FACE_FROM_ID (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
1086 struct face
*face_last
= FACE_FROM_ID (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
1087 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
1088 unsigned long color_first
= (face_first
1089 ? face_first
->foreground
1090 : FRAME_FOREGROUND_PIXEL (f
));
1091 unsigned long color_last
= (face_last
1092 ? face_last
->foreground
1093 : FRAME_FOREGROUND_PIXEL (f
));
1094 Display
*display
= FRAME_X_DISPLAY (f
);
1096 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
1099 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_first
);
1100 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1101 x0
, y0
, 1, y1
- y0
);
1102 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
1103 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1104 x0
+ 1, y0
, x1
- x0
- 2, y1
- y0
);
1105 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_last
);
1106 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1107 x1
- 1, y0
, 1, y1
- y0
);
1109 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
1112 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_first
);
1113 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1114 x0
, y0
, x1
- x0
, 1);
1115 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
1116 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1117 x0
, y0
+ 1, x1
- x0
, y1
- y0
- 2);
1118 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_last
);
1119 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1120 x0
, y1
- 1, x1
- x0
, 1);
1124 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
1125 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1126 x0
, y0
, x1
- x0
, y1
- y0
);
1130 /* End update of window W.
1132 Draw vertical borders between horizontally adjacent windows, and
1133 display W's cursor if CURSOR_ON_P is non-zero.
1135 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
1136 glyphs in mouse-face were overwritten. In that case we have to
1137 make sure that the mouse-highlight is properly redrawn.
1139 W may be a menu bar pseudo-window in case we don't have X toolkit
1140 support. Such windows don't have a cursor, so don't display it
1144 x_update_window_end (struct window
*w
, bool cursor_on_p
,
1145 bool mouse_face_overwritten_p
)
1147 if (!w
->pseudo_window_p
)
1152 display_and_set_cursor (w
, true,
1153 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
1154 w
->output_cursor
.x
, w
->output_cursor
.y
);
1156 if (draw_window_fringes (w
, true))
1158 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
1159 x_draw_right_divider (w
);
1161 x_draw_vertical_border (w
);
1167 /* If a row with mouse-face was overwritten, arrange for
1168 XTframe_up_to_date to redisplay the mouse highlight. */
1169 if (mouse_face_overwritten_p
)
1171 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
1173 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
1174 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
1175 hlinfo
->mouse_face_window
= Qnil
;
1180 /* End update of frame F. This function is installed as a hook in
1184 x_update_end (struct frame
*f
)
1186 /* Mouse highlight may be displayed again. */
1187 MOUSE_HL_INFO (f
)->mouse_face_defer
= false;
1190 if (FRAME_CR_SURFACE (f
))
1194 #if defined (USE_GTK) && defined (HAVE_GTK3)
1195 if (FRAME_GTK_WIDGET (f
))
1197 GdkWindow
*w
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
1198 cr
= gdk_cairo_create (w
);
1203 cairo_surface_t
*surface
;
1204 int width
= FRAME_PIXEL_WIDTH (f
);
1205 int height
= FRAME_PIXEL_HEIGHT (f
);
1206 if (! FRAME_EXTERNAL_TOOL_BAR (f
))
1207 height
+= FRAME_TOOL_BAR_HEIGHT (f
);
1208 if (! FRAME_EXTERNAL_MENU_BAR (f
))
1209 height
+= FRAME_MENU_BAR_HEIGHT (f
);
1210 surface
= cairo_xlib_surface_create (FRAME_X_DISPLAY (f
),
1212 FRAME_DISPLAY_INFO (f
)->visual
,
1215 cr
= cairo_create (surface
);
1216 cairo_surface_destroy (surface
);
1219 cairo_set_source_surface (cr
, FRAME_CR_SURFACE (f
), 0, 0);
1224 #endif /* USE_CAIRO */
1228 XFlush (FRAME_X_DISPLAY (f
));
1234 /* This function is called from various places in xdisp.c
1235 whenever a complete update has been performed. */
1238 XTframe_up_to_date (struct frame
*f
)
1241 FRAME_MOUSE_UPDATE (f
);
1245 /* Clear under internal border if any (GTK has its own version). */
1248 x_clear_under_internal_border (struct frame
*f
)
1250 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
1252 int border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1253 int width
= FRAME_PIXEL_WIDTH (f
);
1254 int height
= FRAME_PIXEL_HEIGHT (f
);
1255 int margin
= FRAME_TOP_MARGIN_HEIGHT (f
);
1258 x_clear_area (f
, 0, 0, border
, height
);
1259 x_clear_area (f
, 0, margin
, width
, border
);
1260 x_clear_area (f
, width
- border
, 0, border
, height
);
1261 x_clear_area (f
, 0, height
- border
, width
, border
);
1267 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
1268 arrow bitmaps, or clear the fringes if no bitmaps are required
1269 before DESIRED_ROW is made current. This function is called from
1270 update_window_line only if it is known that there are differences
1271 between bitmaps to be drawn between current row and DESIRED_ROW. */
1274 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
1278 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
1279 desired_row
->redraw_fringe_bitmaps_p
= true;
1281 #ifdef USE_X_TOOLKIT
1282 /* When a window has disappeared, make sure that no rest of
1283 full-width rows stays visible in the internal border. Could
1284 check here if updated window is the leftmost/rightmost window,
1285 but I guess it's not worth doing since vertically split windows
1286 are almost never used, internal border is rarely set, and the
1287 overhead is very small. */
1292 if (windows_or_buffers_changed
1293 && desired_row
->full_width_p
1294 && (f
= XFRAME (w
->frame
),
1295 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
1297 && (height
= desired_row
->visible_height
,
1300 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
1303 x_clear_area (f
, 0, y
, width
, height
);
1304 x_clear_area (f
, FRAME_PIXEL_WIDTH (f
) - width
, y
, width
, height
);
1312 x_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, struct draw_fringe_bitmap_params
*p
)
1314 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1315 Display
*display
= FRAME_X_DISPLAY (f
);
1316 Window window
= FRAME_X_WINDOW (f
);
1317 GC gc
= f
->output_data
.x
->normal_gc
;
1318 struct face
*face
= p
->face
;
1320 /* Must clip because of partially visible lines. */
1321 x_clip_to_row (w
, row
, ANY_AREA
, gc
);
1323 if (p
->bx
>= 0 && !p
->overlay_p
)
1325 /* In case the same realized face is used for fringes and
1326 for something displayed in the text (e.g. face `region' on
1327 mono-displays, the fill style may have been changed to
1328 FillSolid in x_draw_glyph_string_background. */
1330 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
1332 XSetForeground (display
, face
->gc
, face
->background
);
1334 x_fill_rectangle (f
, face
->gc
, p
->bx
, p
->by
, p
->nx
, p
->ny
);
1337 XSetForeground (display
, face
->gc
, face
->foreground
);
1341 if (p
->which
&& p
->which
< max_fringe_bmp
)
1345 XGetGCValues (display
, gc
, GCForeground
| GCBackground
, &gcv
);
1346 XSetForeground (display
, gc
, (p
->cursor_p
1347 ? (p
->overlay_p
? face
->background
1348 : f
->output_data
.x
->cursor_pixel
)
1349 : face
->foreground
));
1350 XSetBackground (display
, gc
, face
->background
);
1351 x_cr_draw_image (f
, gc
, fringe_bmp
[p
->which
], 0, p
->dh
,
1352 p
->wd
, p
->h
, p
->x
, p
->y
, p
->overlay_p
);
1353 XSetForeground (display
, gc
, gcv
.foreground
);
1354 XSetBackground (display
, gc
, gcv
.background
);
1356 #else /* not USE_CAIRO */
1360 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
1361 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
1365 bits
= (char *) (p
->bits
+ p
->dh
);
1367 bits
= (char *) p
->bits
+ p
->dh
;
1369 /* Draw the bitmap. I believe these small pixmaps can be cached
1371 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
1373 ? (p
->overlay_p
? face
->background
1374 : f
->output_data
.x
->cursor_pixel
)
1375 : face
->foreground
),
1376 face
->background
, depth
);
1380 clipmask
= XCreatePixmapFromBitmapData (display
,
1381 FRAME_DISPLAY_INFO (f
)->root_window
,
1384 gcv
.clip_mask
= clipmask
;
1385 gcv
.clip_x_origin
= p
->x
;
1386 gcv
.clip_y_origin
= p
->y
;
1387 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
1390 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
1391 p
->wd
, p
->h
, p
->x
, p
->y
);
1392 XFreePixmap (display
, pixmap
);
1396 gcv
.clip_mask
= (Pixmap
) 0;
1397 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
1398 XFreePixmap (display
, clipmask
);
1401 #endif /* not USE_CAIRO */
1403 x_reset_clip_rectangles (f
, gc
);
1406 /***********************************************************************
1408 ***********************************************************************/
1412 static void x_set_glyph_string_clipping (struct glyph_string
*);
1413 static void x_set_glyph_string_gc (struct glyph_string
*);
1414 static void x_draw_glyph_string_foreground (struct glyph_string
*);
1415 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
1416 static void x_draw_glyph_string_box (struct glyph_string
*);
1417 static void x_draw_glyph_string (struct glyph_string
*);
1418 static _Noreturn
void x_delete_glyphs (struct frame
*, int);
1419 static void x_compute_glyph_string_overhangs (struct glyph_string
*);
1420 static void x_set_cursor_gc (struct glyph_string
*);
1421 static void x_set_mode_line_face_gc (struct glyph_string
*);
1422 static void x_set_mouse_face_gc (struct glyph_string
*);
1423 static bool x_alloc_lighter_color (struct frame
*, Display
*, Colormap
,
1424 unsigned long *, double, int);
1425 static void x_setup_relief_color (struct frame
*, struct relief
*,
1426 double, int, unsigned long);
1427 static void x_setup_relief_colors (struct glyph_string
*);
1428 static void x_draw_image_glyph_string (struct glyph_string
*);
1429 static void x_draw_image_relief (struct glyph_string
*);
1430 static void x_draw_image_foreground (struct glyph_string
*);
1431 static void x_draw_image_foreground_1 (struct glyph_string
*, Pixmap
);
1432 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
1434 static void x_draw_relief_rect (struct frame
*, int, int, int, int,
1435 int, bool, bool, bool, bool, bool,
1437 static void x_draw_box_rect (struct glyph_string
*, int, int, int, int,
1438 int, bool, bool, XRectangle
*);
1439 static void x_scroll_bar_clear (struct frame
*);
1442 static void x_check_font (struct frame
*, struct font
*);
1446 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1450 x_set_cursor_gc (struct glyph_string
*s
)
1452 if (s
->font
== FRAME_FONT (s
->f
)
1453 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1454 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1456 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
1459 /* Cursor on non-default face: must merge. */
1463 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
1464 xgcv
.foreground
= s
->face
->background
;
1466 /* If the glyph would be invisible, try a different foreground. */
1467 if (xgcv
.foreground
== xgcv
.background
)
1468 xgcv
.foreground
= s
->face
->foreground
;
1469 if (xgcv
.foreground
== xgcv
.background
)
1470 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
1471 if (xgcv
.foreground
== xgcv
.background
)
1472 xgcv
.foreground
= s
->face
->foreground
;
1474 /* Make sure the cursor is distinct from text in this face. */
1475 if (xgcv
.background
== s
->face
->background
1476 && xgcv
.foreground
== s
->face
->foreground
)
1478 xgcv
.background
= s
->face
->foreground
;
1479 xgcv
.foreground
= s
->face
->background
;
1482 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1483 xgcv
.graphics_exposures
= False
;
1484 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
1486 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1487 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1490 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1491 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1493 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1498 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1501 x_set_mouse_face_gc (struct glyph_string
*s
)
1506 /* What face has to be used last for the mouse face? */
1507 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
1508 face
= FACE_FROM_ID (s
->f
, face_id
);
1510 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1512 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1513 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1515 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1516 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1517 prepare_face_for_display (s
->f
, s
->face
);
1519 if (s
->font
== s
->face
->font
)
1520 s
->gc
= s
->face
->gc
;
1523 /* Otherwise construct scratch_cursor_gc with values from FACE
1528 xgcv
.background
= s
->face
->background
;
1529 xgcv
.foreground
= s
->face
->foreground
;
1530 xgcv
.graphics_exposures
= False
;
1531 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
1533 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1534 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1537 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1538 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1540 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1543 eassert (s
->gc
!= 0);
1547 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1548 Faces to use in the mode line have already been computed when the
1549 matrix was built, so there isn't much to do, here. */
1552 x_set_mode_line_face_gc (struct glyph_string
*s
)
1554 s
->gc
= s
->face
->gc
;
1558 /* Set S->gc of glyph string S for drawing that glyph string. Set
1559 S->stippled_p to a non-zero value if the face of S has a stipple
1563 x_set_glyph_string_gc (struct glyph_string
*s
)
1565 prepare_face_for_display (s
->f
, s
->face
);
1567 if (s
->hl
== DRAW_NORMAL_TEXT
)
1569 s
->gc
= s
->face
->gc
;
1570 s
->stippled_p
= s
->face
->stipple
!= 0;
1572 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1574 x_set_mode_line_face_gc (s
);
1575 s
->stippled_p
= s
->face
->stipple
!= 0;
1577 else if (s
->hl
== DRAW_CURSOR
)
1579 x_set_cursor_gc (s
);
1580 s
->stippled_p
= false;
1582 else if (s
->hl
== DRAW_MOUSE_FACE
)
1584 x_set_mouse_face_gc (s
);
1585 s
->stippled_p
= s
->face
->stipple
!= 0;
1587 else if (s
->hl
== DRAW_IMAGE_RAISED
1588 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1590 s
->gc
= s
->face
->gc
;
1591 s
->stippled_p
= s
->face
->stipple
!= 0;
1596 /* GC must have been set. */
1597 eassert (s
->gc
!= 0);
1601 /* Set clipping for output of glyph string S. S may be part of a mode
1602 line or menu if we don't have X toolkit support. */
1605 x_set_glyph_string_clipping (struct glyph_string
*s
)
1607 XRectangle
*r
= s
->clip
;
1608 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1611 x_set_clip_rectangles (s
->f
, s
->gc
, r
, n
);
1616 /* Set SRC's clipping for output of glyph string DST. This is called
1617 when we are drawing DST's left_overhang or right_overhang only in
1621 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
, struct glyph_string
*dst
)
1626 r
.width
= src
->width
;
1628 r
.height
= src
->height
;
1631 x_set_clip_rectangles (dst
->f
, dst
->gc
, &r
, 1);
1636 Compute left and right overhang of glyph string S. */
1639 x_compute_glyph_string_overhangs (struct glyph_string
*s
)
1642 && (s
->first_glyph
->type
== CHAR_GLYPH
1643 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
1645 struct font_metrics metrics
;
1647 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1649 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1650 struct font
*font
= s
->font
;
1653 for (i
= 0; i
< s
->nchars
; i
++)
1654 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
1655 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1659 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1661 composition_gstring_width (gstring
, s
->cmp_from
, s
->cmp_to
, &metrics
);
1663 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1664 ? metrics
.rbearing
- metrics
.width
: 0);
1665 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1669 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1670 s
->left_overhang
= - s
->cmp
->lbearing
;
1675 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1678 x_clear_glyph_string_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
1681 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1682 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1683 x_fill_rectangle (s
->f
, s
->gc
, x
, y
, w
, h
);
1684 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1688 /* Draw the background of glyph_string S. If S->background_filled_p
1689 is non-zero don't draw it. FORCE_P non-zero means draw the
1690 background even if it wouldn't be drawn normally. This is used
1691 when a string preceding S draws into the background of S, or S
1692 contains the first component of a composition. */
1695 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1697 /* Nothing to do if background has already been drawn or if it
1698 shouldn't be drawn in the first place. */
1699 if (!s
->background_filled_p
)
1701 int box_line_width
= max (s
->face
->box_line_width
, 0);
1705 /* Fill background with a stipple pattern. */
1706 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1707 x_fill_rectangle (s
->f
, s
->gc
, s
->x
,
1708 s
->y
+ box_line_width
,
1709 s
->background_width
,
1710 s
->height
- 2 * box_line_width
);
1711 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1712 s
->background_filled_p
= true;
1714 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1715 /* When xdisp.c ignores FONT_HEIGHT, we cannot trust
1716 font dimensions, since the actual glyphs might be
1717 much smaller. So in that case we always clear the
1718 rectangle with background color. */
1719 || FONT_TOO_HIGH (s
->font
)
1720 || s
->font_not_found_p
1721 || s
->extends_to_end_of_line_p
1724 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1725 s
->background_width
,
1726 s
->height
- 2 * box_line_width
);
1727 s
->background_filled_p
= true;
1733 /* Draw the foreground of glyph string S. */
1736 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1740 /* If first glyph of S has a left box line, start drawing the text
1741 of S to the right of that box line. */
1742 if (s
->face
->box
!= FACE_NO_BOX
1743 && s
->first_glyph
->left_box_line_p
)
1744 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1748 /* Draw characters of S as rectangles if S's font could not be
1750 if (s
->font_not_found_p
)
1752 for (i
= 0; i
< s
->nchars
; ++i
)
1754 struct glyph
*g
= s
->first_glyph
+ i
;
1755 x_draw_rectangle (s
->f
,
1756 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1758 x
+= g
->pixel_width
;
1763 struct font
*font
= s
->font
;
1764 int boff
= font
->baseline_offset
;
1767 if (font
->vertical_centering
)
1768 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1770 y
= s
->ybase
- boff
;
1772 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1773 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, false);
1775 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, true);
1776 if (s
->face
->overstrike
)
1777 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, false);
1781 /* Draw the foreground of composite glyph string S. */
1784 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1787 struct font
*font
= s
->font
;
1789 /* If first glyph of S has a left box line, start drawing the text
1790 of S to the right of that box line. */
1791 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1792 && s
->first_glyph
->left_box_line_p
)
1793 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1797 /* S is a glyph string for a composition. S->cmp_from is the index
1798 of the first character drawn for glyphs of this composition.
1799 S->cmp_from == 0 means we are drawing the very first character of
1800 this composition. */
1802 /* Draw a rectangle for the composition if the font for the very
1803 first character of the composition could not be loaded. */
1804 if (s
->font_not_found_p
)
1806 if (s
->cmp_from
== 0)
1807 x_draw_rectangle (s
->f
, s
->gc
, x
, s
->y
,
1808 s
->width
- 1, s
->height
- 1);
1810 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1814 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1815 /* TAB in a composition means display glyphs with padding
1816 space on the left or right. */
1817 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1819 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1820 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1822 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, false);
1823 if (s
->face
->overstrike
)
1824 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, false);
1829 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1834 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1836 glyph
= LGSTRING_GLYPH (gstring
, i
);
1837 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1838 width
+= LGLYPH_WIDTH (glyph
);
1841 int xoff
, yoff
, wadjust
;
1845 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1846 if (s
->face
->overstrike
)
1847 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, false);
1850 xoff
= LGLYPH_XOFF (glyph
);
1851 yoff
= LGLYPH_YOFF (glyph
);
1852 wadjust
= LGLYPH_WADJUST (glyph
);
1853 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, false);
1854 if (s
->face
->overstrike
)
1855 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
,
1864 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1865 if (s
->face
->overstrike
)
1866 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, false);
1872 /* Draw the foreground of glyph string S for glyphless characters. */
1875 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1877 struct glyph
*glyph
= s
->first_glyph
;
1881 /* If first glyph of S has a left box line, start drawing the text
1882 of S to the right of that box line. */
1883 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1884 && s
->first_glyph
->left_box_line_p
)
1885 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1891 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1893 char buf
[7], *str
= NULL
;
1894 int len
= glyph
->u
.glyphless
.len
;
1896 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1899 && CHAR_TABLE_P (Vglyphless_char_display
)
1900 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1904 = (! glyph
->u
.glyphless
.for_no_font
1905 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1906 glyph
->u
.glyphless
.ch
)
1907 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1908 if (STRINGP (acronym
))
1909 str
= SSDATA (acronym
);
1912 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1914 sprintf (buf
, "%0*X",
1915 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1916 glyph
->u
.glyphless
.ch
+ 0u);
1922 int upper_len
= (len
+ 1) / 2;
1925 /* It is assured that all LEN characters in STR is ASCII. */
1926 for (j
= 0; j
< len
; j
++)
1928 code
= s
->font
->driver
->encode_char (s
->font
, str
[j
]);
1929 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1931 s
->font
->driver
->draw (s
, 0, upper_len
,
1932 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1933 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1935 s
->font
->driver
->draw (s
, upper_len
, len
,
1936 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1937 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1940 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1941 x_draw_rectangle (s
->f
, s
->gc
,
1942 x
, s
->ybase
- glyph
->ascent
,
1943 glyph
->pixel_width
- 1,
1944 glyph
->ascent
+ glyph
->descent
- 1);
1945 x
+= glyph
->pixel_width
;
1949 #ifdef USE_X_TOOLKIT
1953 /* Return the frame on which widget WIDGET is used.. Abort if frame
1954 cannot be determined. */
1956 static struct frame
*
1957 x_frame_of_widget (Widget widget
)
1959 struct x_display_info
*dpyinfo
;
1960 Lisp_Object tail
, frame
;
1963 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1965 /* Find the top-level shell of the widget. Note that this function
1966 can be called when the widget is not yet realized, so XtWindow
1967 (widget) == 0. That's the reason we can't simply use
1968 x_any_window_to_frame. */
1969 while (!XtIsTopLevelShell (widget
))
1970 widget
= XtParent (widget
);
1972 /* Look for a frame with that top-level widget. Allocate the color
1973 on that frame to get the right gamma correction value. */
1974 FOR_EACH_FRAME (tail
, frame
)
1978 && f
->output_data
.nothing
!= 1
1979 && FRAME_DISPLAY_INFO (f
) == dpyinfo
1980 && f
->output_data
.x
->widget
== widget
)
1986 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1987 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1988 If this produces the same color as PIXEL, try a color where all RGB
1989 values have DELTA added. Return the allocated color in *PIXEL.
1990 DISPLAY is the X display, CMAP is the colormap to operate on.
1991 Value is true if successful. */
1994 x_alloc_lighter_color_for_widget (Widget widget
, Display
*display
, Colormap cmap
,
1995 unsigned long *pixel
, double factor
, int delta
)
1997 struct frame
*f
= x_frame_of_widget (widget
);
1998 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
2001 #endif /* USE_LUCID */
2004 /* Structure specifying which arguments should be passed by Xt to
2005 cvt_string_to_pixel. We want the widget's screen and colormap. */
2007 static XtConvertArgRec cvt_string_to_pixel_args
[] =
2009 {XtWidgetBaseOffset
, (XtPointer
) offsetof (WidgetRec
, core
.screen
),
2011 {XtWidgetBaseOffset
, (XtPointer
) offsetof (WidgetRec
, core
.colormap
),
2016 /* The address of this variable is returned by
2017 cvt_string_to_pixel. */
2019 static Pixel cvt_string_to_pixel_value
;
2022 /* Convert a color name to a pixel color.
2024 DPY is the display we are working on.
2026 ARGS is an array of *NARGS XrmValue structures holding additional
2027 information about the widget for which the conversion takes place.
2028 The contents of this array are determined by the specification
2029 in cvt_string_to_pixel_args.
2031 FROM is a pointer to an XrmValue which points to the color name to
2032 convert. TO is an XrmValue in which to return the pixel color.
2034 CLOSURE_RET is a pointer to user-data, in which we record if
2035 we allocated the color or not.
2037 Value is True if successful, False otherwise. */
2040 cvt_string_to_pixel (Display
*dpy
, XrmValue
*args
, Cardinal
*nargs
,
2041 XrmValue
*from
, XrmValue
*to
,
2042 XtPointer
*closure_ret
)
2052 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
2053 "wrongParameters", "cvt_string_to_pixel",
2055 "Screen and colormap args required", NULL
, NULL
);
2059 screen
= *(Screen
**) args
[0].addr
;
2060 cmap
= *(Colormap
*) args
[1].addr
;
2061 color_name
= (String
) from
->addr
;
2063 if (strcmp (color_name
, XtDefaultBackground
) == 0)
2065 *closure_ret
= (XtPointer
) False
;
2066 pixel
= WhitePixelOfScreen (screen
);
2068 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
2070 *closure_ret
= (XtPointer
) False
;
2071 pixel
= BlackPixelOfScreen (screen
);
2073 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
2074 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
2076 pixel
= color
.pixel
;
2077 *closure_ret
= (XtPointer
) True
;
2082 Cardinal nparams
= 1;
2084 params
[0] = color_name
;
2085 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
2086 "badValue", "cvt_string_to_pixel",
2087 "XtToolkitError", "Invalid color '%s'",
2092 if (to
->addr
!= NULL
)
2094 if (to
->size
< sizeof (Pixel
))
2096 to
->size
= sizeof (Pixel
);
2100 *(Pixel
*) to
->addr
= pixel
;
2104 cvt_string_to_pixel_value
= pixel
;
2105 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
2108 to
->size
= sizeof (Pixel
);
2113 /* Free a pixel color which was previously allocated via
2114 cvt_string_to_pixel. This is registered as the destructor
2115 for this type of resource via XtSetTypeConverter.
2117 APP is the application context in which we work.
2119 TO is a pointer to an XrmValue holding the color to free.
2120 CLOSURE is the value we stored in CLOSURE_RET for this color
2121 in cvt_string_to_pixel.
2123 ARGS and NARGS are like for cvt_string_to_pixel. */
2126 cvt_pixel_dtor (XtAppContext app
, XrmValuePtr to
, XtPointer closure
, XrmValuePtr args
,
2131 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
2133 "Screen and colormap arguments required",
2136 else if (closure
!= NULL
)
2138 /* We did allocate the pixel, so free it. */
2139 Screen
*screen
= *(Screen
**) args
[0].addr
;
2140 Colormap cmap
= *(Colormap
*) args
[1].addr
;
2141 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
2142 (Pixel
*) to
->addr
, 1);
2147 #endif /* USE_X_TOOLKIT */
2150 /* Value is an array of XColor structures for the contents of the
2151 color map of display DPY. Set *NCELLS to the size of the array.
2152 Note that this probably shouldn't be called for large color maps,
2153 say a 24-bit TrueColor map. */
2155 static const XColor
*
2156 x_color_cells (Display
*dpy
, int *ncells
)
2158 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
2160 if (dpyinfo
->color_cells
== NULL
)
2162 Screen
*screen
= dpyinfo
->screen
;
2163 int ncolor_cells
= XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
2166 dpyinfo
->color_cells
= xnmalloc (ncolor_cells
,
2167 sizeof *dpyinfo
->color_cells
);
2168 dpyinfo
->ncolor_cells
= ncolor_cells
;
2170 for (i
= 0; i
< ncolor_cells
; ++i
)
2171 dpyinfo
->color_cells
[i
].pixel
= i
;
2173 XQueryColors (dpy
, dpyinfo
->cmap
,
2174 dpyinfo
->color_cells
, ncolor_cells
);
2177 *ncells
= dpyinfo
->ncolor_cells
;
2178 return dpyinfo
->color_cells
;
2182 /* On frame F, translate pixel colors to RGB values for the NCOLORS
2183 colors in COLORS. Use cached information, if available. */
2186 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
2188 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
2190 if (dpyinfo
->red_bits
> 0)
2192 /* For TrueColor displays, we can decompose the RGB value
2195 unsigned int rmult
, gmult
, bmult
;
2196 unsigned int rmask
, gmask
, bmask
;
2198 rmask
= (1 << dpyinfo
->red_bits
) - 1;
2199 gmask
= (1 << dpyinfo
->green_bits
) - 1;
2200 bmask
= (1 << dpyinfo
->blue_bits
) - 1;
2201 /* If we're widening, for example, 8 bits in the pixel value to
2202 16 bits for the separate-color representation, we want to
2203 extrapolate the lower bits based on those bits available --
2204 in other words, we'd like 0xff to become 0xffff instead of
2205 the 0xff00 we'd get by just zero-filling the lower bits.
2207 We generate a 32-bit scaled-up value and shift it, in case
2208 the bit count doesn't divide 16 evenly (e.g., when dealing
2209 with a 3-3-2 bit RGB display), to get more of the lower bits
2212 Should we cache the multipliers in dpyinfo? Maybe
2213 special-case the 8-8-8 common case? */
2214 rmult
= 0xffffffff / rmask
;
2215 gmult
= 0xffffffff / gmask
;
2216 bmult
= 0xffffffff / bmask
;
2218 for (i
= 0; i
< ncolors
; ++i
)
2220 unsigned int r
, g
, b
;
2221 unsigned long pixel
= colors
[i
].pixel
;
2223 r
= (pixel
>> dpyinfo
->red_offset
) & rmask
;
2224 g
= (pixel
>> dpyinfo
->green_offset
) & gmask
;
2225 b
= (pixel
>> dpyinfo
->blue_offset
) & bmask
;
2227 colors
[i
].red
= (r
* rmult
) >> 16;
2228 colors
[i
].green
= (g
* gmult
) >> 16;
2229 colors
[i
].blue
= (b
* bmult
) >> 16;
2234 if (dpyinfo
->color_cells
)
2237 for (i
= 0; i
< ncolors
; ++i
)
2239 unsigned long pixel
= colors
[i
].pixel
;
2240 eassert (pixel
< dpyinfo
->ncolor_cells
);
2241 eassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
2242 colors
[i
] = dpyinfo
->color_cells
[pixel
];
2247 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
2251 /* On frame F, translate pixel color to RGB values for the color in
2252 COLOR. Use cached information, if available. */
2255 x_query_color (struct frame
*f
, XColor
*color
)
2257 x_query_colors (f
, color
, 1);
2261 /* On frame F, translate the color name to RGB values. Use cached
2262 information, if possible.
2264 Note that there is currently no way to clean old entries out of the
2265 cache. However, it is limited to names in the server's database,
2266 and names we've actually looked up; list-colors-display is probably
2267 the most color-intensive case we're likely to hit. */
2269 Status
x_parse_color (struct frame
*f
, const char *color_name
,
2272 Display
*dpy
= FRAME_X_DISPLAY (f
);
2273 Colormap cmap
= FRAME_X_COLORMAP (f
);
2274 struct color_name_cache_entry
*cache_entry
;
2276 if (color_name
[0] == '#')
2278 /* The hex form is parsed directly by XParseColor without
2279 talking to the X server. No need for caching. */
2280 return XParseColor (dpy
, cmap
, color_name
, color
);
2283 for (cache_entry
= FRAME_DISPLAY_INFO (f
)->color_names
; cache_entry
;
2284 cache_entry
= cache_entry
->next
)
2286 if (!xstrcasecmp(cache_entry
->name
, color_name
))
2288 *color
= cache_entry
->rgb
;
2293 if (XParseColor (dpy
, cmap
, color_name
, color
) == 0)
2294 /* No caching of negative results, currently. */
2297 cache_entry
= xzalloc (sizeof *cache_entry
);
2298 cache_entry
->rgb
= *color
;
2299 cache_entry
->name
= xstrdup (color_name
);
2300 cache_entry
->next
= FRAME_DISPLAY_INFO (f
)->color_names
;
2301 FRAME_DISPLAY_INFO (f
)->color_names
= cache_entry
;
2306 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
2307 exact match can't be allocated, try the nearest color available.
2308 Value is true if successful. Set *COLOR to the color
2312 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
2316 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
2319 /* If we got to this point, the colormap is full, so we're going
2320 to try to get the next closest color. The algorithm used is
2321 a least-squares matching, which is what X uses for closest
2322 color matching with StaticColor visuals. */
2324 int max_color_delta
= 255;
2325 int max_delta
= 3 * max_color_delta
;
2326 int nearest_delta
= max_delta
+ 1;
2328 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
2330 for (nearest
= i
= 0; i
< ncells
; ++i
)
2332 int dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
2333 int dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
2334 int dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
2335 int delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
2337 if (delta
< nearest_delta
)
2340 nearest_delta
= delta
;
2344 color
->red
= cells
[nearest
].red
;
2345 color
->green
= cells
[nearest
].green
;
2346 color
->blue
= cells
[nearest
].blue
;
2347 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
2351 /* If allocation succeeded, and the allocated pixel color is not
2352 equal to a cached pixel color recorded earlier, there was a
2353 change in the colormap, so clear the color cache. */
2354 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
2355 XColor
*cached_color
;
2357 if (dpyinfo
->color_cells
2358 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
2359 (cached_color
->red
!= color
->red
2360 || cached_color
->blue
!= color
->blue
2361 || cached_color
->green
!= color
->green
)))
2363 xfree (dpyinfo
->color_cells
);
2364 dpyinfo
->color_cells
= NULL
;
2365 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. */
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
);
3771 x_clear_area (struct frame
*f
, int x
, int y
, int width
, int height
)
3776 eassert (width
> 0 && height
> 0);
3778 cr
= x_begin_cr_clip (f
, NULL
);
3779 x_set_cr_source_with_gc_background (f
, f
->output_data
.x
->normal_gc
);
3780 cairo_rectangle (cr
, x
, y
, width
, height
);
3784 x_clear_area1 (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3785 x
, y
, width
, height
, False
);
3790 /* Clear an entire frame. */
3793 x_clear_frame (struct frame
*f
)
3795 /* Clearing the frame will erase any cursor, so mark them all as no
3797 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3803 /* We have to clear the scroll bars. If we have changed colors or
3804 something like that, then they should be notified. */
3805 x_scroll_bar_clear (f
);
3807 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3808 /* Make sure scroll bars are redrawn. As they aren't redrawn by
3809 redisplay, do it here. */
3810 if (FRAME_GTK_WIDGET (f
))
3811 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
3814 XFlush (FRAME_X_DISPLAY (f
));
3819 /* RIF: Show hourglass cursor on frame F. */
3822 x_show_hourglass (struct frame
*f
)
3824 Display
*dpy
= FRAME_X_DISPLAY (f
);
3828 struct x_output
*x
= FRAME_X_OUTPUT (f
);
3829 #ifdef USE_X_TOOLKIT
3832 if (FRAME_OUTER_WINDOW (f
))
3835 x
->hourglass_p
= true;
3837 if (!x
->hourglass_window
)
3839 unsigned long mask
= CWCursor
;
3840 XSetWindowAttributes attrs
;
3842 Window parent
= FRAME_X_WINDOW (f
);
3844 Window parent
= FRAME_OUTER_WINDOW (f
);
3846 attrs
.cursor
= x
->hourglass_cursor
;
3848 x
->hourglass_window
= XCreateWindow
3849 (dpy
, parent
, 0, 0, 32000, 32000, 0, 0,
3850 InputOnly
, CopyFromParent
, mask
, &attrs
);
3853 XMapRaised (dpy
, x
->hourglass_window
);
3859 /* RIF: Cancel hourglass cursor on frame F. */
3862 x_hide_hourglass (struct frame
*f
)
3864 struct x_output
*x
= FRAME_X_OUTPUT (f
);
3866 /* Watch out for newly created frames. */
3867 if (x
->hourglass_window
)
3869 XUnmapWindow (FRAME_X_DISPLAY (f
), x
->hourglass_window
);
3870 /* Sync here because XTread_socket looks at the
3871 hourglass_p flag that is reset to zero below. */
3872 XSync (FRAME_X_DISPLAY (f
), False
);
3873 x
->hourglass_p
= false;
3877 /* Invert the middle quarter of the frame for .15 sec. */
3880 XTflash (struct frame
*f
)
3886 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
3887 when the scroll bars and the edit widget share the same X window. */
3888 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
3890 cairo_t
*cr
= gdk_cairo_create (window
);
3891 cairo_set_source_rgb (cr
, 1, 1, 1);
3892 cairo_set_operator (cr
, CAIRO_OPERATOR_DIFFERENCE
);
3893 #define XFillRectangle(d, win, gc, x, y, w, h) \
3895 cairo_rectangle (cr, x, y, w, h); \
3899 #else /* ! HAVE_GTK3 */
3902 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
3903 ^ FRAME_BACKGROUND_PIXEL (f
));
3904 vals
.function
= GDK_XOR
;
3905 gc
= gdk_gc_new_with_values (window
,
3906 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
3907 #define XFillRectangle(d, win, gc, x, y, w, h) \
3908 gdk_draw_rectangle (window, gc, true, x, y, w, h)
3909 #endif /* ! HAVE_GTK3 */
3910 #else /* ! USE_GTK */
3913 /* Create a GC that will use the GXxor function to flip foreground
3914 pixels into background pixels. */
3918 values
.function
= GXxor
;
3919 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
3920 ^ FRAME_BACKGROUND_PIXEL (f
));
3922 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3923 GCFunction
| GCForeground
, &values
);
3927 /* Get the height not including a menu bar widget. */
3928 int height
= FRAME_PIXEL_HEIGHT (f
);
3929 /* Height of each line to flash. */
3930 int flash_height
= FRAME_LINE_HEIGHT (f
);
3931 /* These will be the left and right margins of the rectangles. */
3932 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3933 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
3934 int width
= flash_right
- flash_left
;
3936 /* If window is tall, flash top and bottom line. */
3937 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3939 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3941 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3942 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3943 width
, flash_height
);
3944 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3946 (height
- flash_height
3947 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3948 width
, flash_height
);
3952 /* If it is short, flash it all. */
3953 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3954 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3955 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3960 struct timespec delay
= make_timespec (0, 150 * 1000 * 1000);
3961 struct timespec wakeup
= timespec_add (current_timespec (), delay
);
3963 /* Keep waiting until past the time wakeup or any input gets
3965 while (! detect_input_pending ())
3967 struct timespec current
= current_timespec ();
3968 struct timespec timeout
;
3970 /* Break if result would not be positive. */
3971 if (timespec_cmp (wakeup
, current
) <= 0)
3974 /* How long `select' should wait. */
3975 timeout
= make_timespec (0, 10 * 1000 * 1000);
3977 /* Try to wait that long--but we might wake up sooner. */
3978 pselect (0, NULL
, NULL
, NULL
, &timeout
, NULL
);
3982 /* If window is tall, flash top and bottom line. */
3983 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3985 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3987 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3988 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3989 width
, flash_height
);
3990 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3992 (height
- flash_height
3993 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3994 width
, flash_height
);
3997 /* If it is short, flash it all. */
3998 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3999 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
4000 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
4006 g_object_unref (G_OBJECT (gc
));
4008 #undef XFillRectangle
4010 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
4021 XTtoggle_invisible_pointer (struct frame
*f
, bool invisible
)
4024 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, invisible
);
4029 /* Make audible bell. */
4032 XTring_bell (struct frame
*f
)
4034 if (FRAME_X_DISPLAY (f
))
4042 XkbBell (FRAME_X_DISPLAY (f
), None
, 0, None
);
4044 XBell (FRAME_X_DISPLAY (f
), 0);
4046 XFlush (FRAME_X_DISPLAY (f
));
4052 /***********************************************************************
4054 ***********************************************************************/
4056 /* Perform an insert-lines or delete-lines operation, inserting N
4057 lines or deleting -N lines at vertical position VPOS. */
4060 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
4066 /* Scroll part of the display as described by RUN. */
4069 x_scroll_run (struct window
*w
, struct run
*run
)
4071 struct frame
*f
= XFRAME (w
->frame
);
4072 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
4074 /* Get frame-relative bounding box of the text display area of W,
4075 without mode lines. Include in this box the left and right
4077 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
4079 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
4080 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
4081 bottom_y
= y
+ height
;
4085 /* Scrolling up. Make sure we don't copy part of the mode
4086 line at the bottom. */
4087 if (from_y
+ run
->height
> bottom_y
)
4088 height
= bottom_y
- from_y
;
4090 height
= run
->height
;
4094 /* Scrolling down. Make sure we don't copy over the mode line.
4096 if (to_y
+ run
->height
> bottom_y
)
4097 height
= bottom_y
- to_y
;
4099 height
= run
->height
;
4104 /* Cursor off. Will be switched on again in x_update_window_end. */
4108 SET_FRAME_GARBAGED (f
);
4110 XCopyArea (FRAME_X_DISPLAY (f
),
4111 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
4112 f
->output_data
.x
->normal_gc
,
4123 /***********************************************************************
4125 ***********************************************************************/
4129 frame_highlight (struct frame
*f
)
4131 /* We used to only do this if Vx_no_window_manager was non-nil, but
4132 the ICCCM (section 4.1.6) says that the window's border pixmap
4133 and border pixel are window attributes which are "private to the
4134 client", so we can always change it to whatever we want. */
4136 /* I recently started to get errors in this XSetWindowBorder, depending on
4137 the window-manager in use, tho something more is at play since I've been
4138 using that same window-manager binary for ever. Let's not crash just
4139 because of this (bug#9310). */
4140 x_catch_errors (FRAME_X_DISPLAY (f
));
4141 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4142 f
->output_data
.x
->border_pixel
);
4143 x_uncatch_errors ();
4145 x_update_cursor (f
, true);
4146 x_set_frame_alpha (f
);
4150 frame_unhighlight (struct frame
*f
)
4152 /* We used to only do this if Vx_no_window_manager was non-nil, but
4153 the ICCCM (section 4.1.6) says that the window's border pixmap
4154 and border pixel are window attributes which are "private to the
4155 client", so we can always change it to whatever we want. */
4157 /* Same as above for XSetWindowBorder (bug#9310). */
4158 x_catch_errors (FRAME_X_DISPLAY (f
));
4159 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4160 f
->output_data
.x
->border_tile
);
4161 x_uncatch_errors ();
4163 x_update_cursor (f
, true);
4164 x_set_frame_alpha (f
);
4167 /* The focus has changed. Update the frames as necessary to reflect
4168 the new situation. Note that we can't change the selected frame
4169 here, because the Lisp code we are interrupting might become confused.
4170 Each event gets marked with the frame in which it occurred, so the
4171 Lisp code can tell when the switch took place by examining the events. */
4174 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
4176 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
4178 if (frame
!= dpyinfo
->x_focus_frame
)
4180 /* Set this before calling other routines, so that they see
4181 the correct value of x_focus_frame. */
4182 dpyinfo
->x_focus_frame
= frame
;
4184 if (old_focus
&& old_focus
->auto_lower
)
4185 x_lower_frame (old_focus
);
4187 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
4188 dpyinfo
->x_pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
4190 dpyinfo
->x_pending_autoraise_frame
= NULL
;
4193 x_frame_rehighlight (dpyinfo
);
4196 /* Handle FocusIn and FocusOut state changes for FRAME.
4197 If FRAME has focus and there exists more than one frame, puts
4198 a FOCUS_IN_EVENT into *BUFP. */
4201 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
4203 if (type
== FocusIn
)
4205 if (dpyinfo
->x_focus_event_frame
!= frame
)
4207 x_new_focus_frame (dpyinfo
, frame
);
4208 dpyinfo
->x_focus_event_frame
= frame
;
4210 /* Don't stop displaying the initial startup message
4211 for a switch-frame event we don't need. */
4212 /* When run as a daemon, Vterminal_frame is always NIL. */
4213 bufp
->arg
= (((NILP (Vterminal_frame
)
4214 || ! FRAME_X_P (XFRAME (Vterminal_frame
))
4215 || EQ (Fdaemonp (), Qt
))
4216 && CONSP (Vframe_list
)
4217 && !NILP (XCDR (Vframe_list
)))
4219 bufp
->kind
= FOCUS_IN_EVENT
;
4220 XSETFRAME (bufp
->frame_or_window
, frame
);
4223 frame
->output_data
.x
->focus_state
|= state
;
4226 if (FRAME_XIC (frame
))
4227 XSetICFocus (FRAME_XIC (frame
));
4230 else if (type
== FocusOut
)
4232 frame
->output_data
.x
->focus_state
&= ~state
;
4234 if (dpyinfo
->x_focus_event_frame
== frame
)
4236 dpyinfo
->x_focus_event_frame
= 0;
4237 x_new_focus_frame (dpyinfo
, 0);
4239 bufp
->kind
= FOCUS_OUT_EVENT
;
4240 XSETFRAME (bufp
->frame_or_window
, frame
);
4244 if (FRAME_XIC (frame
))
4245 XUnsetICFocus (FRAME_XIC (frame
));
4247 if (frame
->pointer_invisible
)
4248 XTtoggle_invisible_pointer (frame
, false);
4252 /* Return the Emacs frame-object corresponding to an X window.
4253 It could be the frame's main window or an icon window. */
4255 static struct frame
*
4256 x_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4258 Lisp_Object tail
, frame
;
4264 FOR_EACH_FRAME (tail
, frame
)
4267 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4269 if (f
->output_data
.x
->hourglass_window
== wdesc
)
4271 #ifdef USE_X_TOOLKIT
4272 if ((f
->output_data
.x
->edit_widget
4273 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
4274 /* A tooltip frame? */
4275 || (!f
->output_data
.x
->edit_widget
4276 && FRAME_X_WINDOW (f
) == wdesc
)
4277 || f
->output_data
.x
->icon_desc
== wdesc
)
4279 #else /* not USE_X_TOOLKIT */
4281 if (f
->output_data
.x
->edit_widget
)
4283 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4284 struct x_output
*x
= f
->output_data
.x
;
4285 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
4288 #endif /* USE_GTK */
4289 if (FRAME_X_WINDOW (f
) == wdesc
4290 || f
->output_data
.x
->icon_desc
== wdesc
)
4292 #endif /* not USE_X_TOOLKIT */
4297 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
4299 /* Like x_window_to_frame but also compares the window with the widget's
4302 static struct frame
*
4303 x_any_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4305 Lisp_Object tail
, frame
;
4306 struct frame
*f
, *found
= NULL
;
4312 FOR_EACH_FRAME (tail
, frame
)
4317 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
4319 /* This frame matches if the window is any of its widgets. */
4320 x
= f
->output_data
.x
;
4321 if (x
->hourglass_window
== wdesc
)
4326 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4328 && gtk_widget_get_toplevel (gwdesc
) == x
->widget
)
4331 if (wdesc
== XtWindow (x
->widget
)
4332 || wdesc
== XtWindow (x
->column_widget
)
4333 || wdesc
== XtWindow (x
->edit_widget
))
4335 /* Match if the window is this frame's menubar. */
4336 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
4340 else if (FRAME_X_WINDOW (f
) == wdesc
)
4341 /* A tooltip frame. */
4349 /* Likewise, but consider only the menu bar widget. */
4351 static struct frame
*
4352 x_menubar_window_to_frame (struct x_display_info
*dpyinfo
,
4353 const XEvent
*event
)
4355 Window wdesc
= event
->xany
.window
;
4356 Lisp_Object tail
, frame
;
4363 FOR_EACH_FRAME (tail
, frame
)
4366 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4368 x
= f
->output_data
.x
;
4370 if (x
->menubar_widget
&& xg_event_is_for_menubar (f
, event
))
4373 /* Match if the window is this frame's menubar. */
4374 if (x
->menubar_widget
4375 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
4382 /* Return the frame whose principal (outermost) window is WDESC.
4383 If WDESC is some other (smaller) window, we return 0. */
4386 x_top_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4388 Lisp_Object tail
, frame
;
4395 FOR_EACH_FRAME (tail
, frame
)
4398 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4400 x
= f
->output_data
.x
;
4404 /* This frame matches if the window is its topmost widget. */
4406 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4407 if (gwdesc
== x
->widget
)
4410 if (wdesc
== XtWindow (x
->widget
))
4414 else if (FRAME_X_WINDOW (f
) == wdesc
)
4415 /* Tooltip frame. */
4421 #else /* !USE_X_TOOLKIT && !USE_GTK */
4423 #define x_any_window_to_frame(d, i) x_window_to_frame (d, i)
4424 #define x_top_window_to_frame(d, i) x_window_to_frame (d, i)
4426 #endif /* USE_X_TOOLKIT || USE_GTK */
4428 /* The focus may have changed. Figure out if it is a real focus change,
4429 by checking both FocusIn/Out and Enter/LeaveNotify events.
4431 Returns FOCUS_IN_EVENT event in *BUFP. */
4434 x_detect_focus_change (struct x_display_info
*dpyinfo
, struct frame
*frame
,
4435 const XEvent
*event
, struct input_event
*bufp
)
4440 switch (event
->type
)
4445 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
4447 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
4449 if (event
->xcrossing
.detail
!= NotifyInferior
4450 && event
->xcrossing
.focus
4451 && ! (focus_state
& FOCUS_EXPLICIT
))
4452 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
4454 dpyinfo
, frame
, bufp
);
4460 x_focus_changed (event
->type
,
4461 (event
->xfocus
.detail
== NotifyPointer
?
4462 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
4463 dpyinfo
, frame
, bufp
);
4467 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
4469 enum xembed_message msg
= event
->xclient
.data
.l
[1];
4470 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
4471 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
4478 #if !defined USE_X_TOOLKIT && !defined USE_GTK
4479 /* Handle an event saying the mouse has moved out of an Emacs frame. */
4482 x_mouse_leave (struct x_display_info
*dpyinfo
)
4484 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
4488 /* The focus has changed, or we have redirected a frame's focus to
4489 another frame (this happens when a frame uses a surrogate
4490 mini-buffer frame). Shift the highlight as appropriate.
4492 The FRAME argument doesn't necessarily have anything to do with which
4493 frame is being highlighted or un-highlighted; we only use it to find
4494 the appropriate X display info. */
4497 XTframe_rehighlight (struct frame
*frame
)
4499 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
4503 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
4505 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
4507 if (dpyinfo
->x_focus_frame
)
4509 dpyinfo
->x_highlight_frame
4510 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
4511 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
4512 : dpyinfo
->x_focus_frame
);
4513 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
4515 fset_focus_frame (dpyinfo
->x_focus_frame
, Qnil
);
4516 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
4520 dpyinfo
->x_highlight_frame
= 0;
4522 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
4525 frame_unhighlight (old_highlight
);
4526 if (dpyinfo
->x_highlight_frame
)
4527 frame_highlight (dpyinfo
->x_highlight_frame
);
4533 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
4535 /* Initialize mode_switch_bit and modifier_meaning. */
4537 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
4539 int min_code
, max_code
;
4542 XModifierKeymap
*mods
;
4544 dpyinfo
->meta_mod_mask
= 0;
4545 dpyinfo
->shift_lock_mask
= 0;
4546 dpyinfo
->alt_mod_mask
= 0;
4547 dpyinfo
->super_mod_mask
= 0;
4548 dpyinfo
->hyper_mod_mask
= 0;
4550 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
4552 syms
= XGetKeyboardMapping (dpyinfo
->display
,
4553 min_code
, max_code
- min_code
+ 1,
4555 mods
= XGetModifierMapping (dpyinfo
->display
);
4557 /* Scan the modifier table to see which modifier bits the Meta and
4558 Alt keysyms are on. */
4560 int row
, col
; /* The row and column in the modifier table. */
4561 bool found_alt_or_meta
;
4563 for (row
= 3; row
< 8; row
++)
4565 found_alt_or_meta
= false;
4566 for (col
= 0; col
< mods
->max_keypermod
; col
++)
4568 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
4570 /* Zeroes are used for filler. Skip them. */
4574 /* Are any of this keycode's keysyms a meta key? */
4578 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
4580 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
4586 found_alt_or_meta
= true;
4587 dpyinfo
->meta_mod_mask
|= (1 << row
);
4592 found_alt_or_meta
= true;
4593 dpyinfo
->alt_mod_mask
|= (1 << row
);
4598 if (!found_alt_or_meta
)
4599 dpyinfo
->hyper_mod_mask
|= (1 << row
);
4600 code_col
= syms_per_code
;
4601 col
= mods
->max_keypermod
;
4606 if (!found_alt_or_meta
)
4607 dpyinfo
->super_mod_mask
|= (1 << row
);
4608 code_col
= syms_per_code
;
4609 col
= mods
->max_keypermod
;
4613 /* Ignore this if it's not on the lock modifier. */
4614 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
4615 dpyinfo
->shift_lock_mask
= LockMask
;
4616 code_col
= syms_per_code
;
4617 col
= mods
->max_keypermod
;
4626 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
4627 if (! dpyinfo
->meta_mod_mask
)
4629 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
4630 dpyinfo
->alt_mod_mask
= 0;
4633 /* If some keys are both alt and meta,
4634 make them just meta, not alt. */
4635 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
4637 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
4641 XFreeModifiermap (mods
);
4644 /* Convert between the modifier bits X uses and the modifier bits
4648 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, int state
)
4650 int mod_meta
= meta_modifier
;
4651 int mod_alt
= alt_modifier
;
4652 int mod_hyper
= hyper_modifier
;
4653 int mod_super
= super_modifier
;
4656 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
4657 if (INTEGERP (tem
)) mod_alt
= XINT (tem
) & INT_MAX
;
4658 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
4659 if (INTEGERP (tem
)) mod_meta
= XINT (tem
) & INT_MAX
;
4660 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
4661 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
) & INT_MAX
;
4662 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
4663 if (INTEGERP (tem
)) mod_super
= XINT (tem
) & INT_MAX
;
4665 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
4666 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
4667 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
4668 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
4669 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
4670 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
4674 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, EMACS_INT state
)
4676 EMACS_INT mod_meta
= meta_modifier
;
4677 EMACS_INT mod_alt
= alt_modifier
;
4678 EMACS_INT mod_hyper
= hyper_modifier
;
4679 EMACS_INT mod_super
= super_modifier
;
4683 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
4684 if (INTEGERP (tem
)) mod_alt
= XINT (tem
);
4685 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
4686 if (INTEGERP (tem
)) mod_meta
= XINT (tem
);
4687 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
4688 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
);
4689 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
4690 if (INTEGERP (tem
)) mod_super
= XINT (tem
);
4693 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
4694 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
4695 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
4696 | ((state
& shift_modifier
) ? ShiftMask
: 0)
4697 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
4698 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
4701 /* Convert a keysym to its name. */
4704 x_get_keysym_name (int keysym
)
4709 value
= XKeysymToString (keysym
);
4715 /* Mouse clicks and mouse movement. Rah.
4717 Formerly, we used PointerMotionHintMask (in standard_event_mask)
4718 so that we would have to call XQueryPointer after each MotionNotify
4719 event to ask for another such event. However, this made mouse tracking
4720 slow, and there was a bug that made it eventually stop.
4722 Simply asking for MotionNotify all the time seems to work better.
4724 In order to avoid asking for motion events and then throwing most
4725 of them away or busy-polling the server for mouse positions, we ask
4726 the server for pointer motion hints. This means that we get only
4727 one event per group of mouse movements. "Groups" are delimited by
4728 other kinds of events (focus changes and button clicks, for
4729 example), or by XQueryPointer calls; when one of these happens, we
4730 get another MotionNotify event the next time the mouse moves. This
4731 is at least as efficient as getting motion events when mouse
4732 tracking is on, and I suspect only negligibly worse when tracking
4735 /* Prepare a mouse-event in *RESULT for placement in the input queue.
4737 If the event is a button press, then note that we have grabbed
4741 construct_mouse_click (struct input_event
*result
,
4742 const XButtonEvent
*event
,
4745 /* Make the event type NO_EVENT; we'll change that when we decide
4747 result
->kind
= MOUSE_CLICK_EVENT
;
4748 result
->code
= event
->button
- Button1
;
4749 result
->timestamp
= event
->time
;
4750 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
),
4752 | (event
->type
== ButtonRelease
4756 XSETINT (result
->x
, event
->x
);
4757 XSETINT (result
->y
, event
->y
);
4758 XSETFRAME (result
->frame_or_window
, f
);
4763 /* Function to report a mouse movement to the mainstream Emacs code.
4764 The input handler calls this.
4766 We have received a mouse movement event, which is given in *event.
4767 If the mouse is over a different glyph than it was last time, tell
4768 the mainstream emacs code by setting mouse_moved. If not, ask for
4769 another motion event, so we can check again the next time it moves. */
4772 note_mouse_movement (struct frame
*frame
, const XMotionEvent
*event
)
4775 struct x_display_info
*dpyinfo
;
4777 if (!FRAME_X_OUTPUT (frame
))
4780 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
4781 dpyinfo
->last_mouse_movement_time
= event
->time
;
4782 dpyinfo
->last_mouse_motion_frame
= frame
;
4783 dpyinfo
->last_mouse_motion_x
= event
->x
;
4784 dpyinfo
->last_mouse_motion_y
= event
->y
;
4786 if (event
->window
!= FRAME_X_WINDOW (frame
))
4788 frame
->mouse_moved
= true;
4789 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4790 note_mouse_highlight (frame
, -1, -1);
4791 dpyinfo
->last_mouse_glyph_frame
= NULL
;
4796 /* Has the mouse moved off the glyph it was on at the last sighting? */
4797 r
= &dpyinfo
->last_mouse_glyph
;
4798 if (frame
!= dpyinfo
->last_mouse_glyph_frame
4799 || event
->x
< r
->x
|| event
->x
>= r
->x
+ r
->width
4800 || event
->y
< r
->y
|| event
->y
>= r
->y
+ r
->height
)
4802 frame
->mouse_moved
= true;
4803 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4804 note_mouse_highlight (frame
, event
->x
, event
->y
);
4805 /* Remember which glyph we're now on. */
4806 remember_mouse_glyph (frame
, event
->x
, event
->y
, r
);
4807 dpyinfo
->last_mouse_glyph_frame
= frame
;
4814 /* Return the current position of the mouse.
4815 *FP should be a frame which indicates which display to ask about.
4817 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
4818 and *PART to the frame, window, and scroll bar part that the mouse
4819 is over. Set *X and *Y to the portion and whole of the mouse's
4820 position on the scroll bar.
4822 If the mouse movement started elsewhere, set *FP to the frame the
4823 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
4826 Set *TIMESTAMP to the server time-stamp for the time at which the mouse
4827 was at this position.
4829 Don't store anything if we don't have a valid set of values to report.
4831 This clears the mouse_moved flag, so we can wait for the next mouse
4835 XTmouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
4836 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
4840 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4844 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
4846 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4848 if (bar
->horizontal
)
4849 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
4851 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
4858 Window dummy_window
;
4861 Lisp_Object frame
, tail
;
4863 /* Clear the mouse-moved flag for every frame on this display. */
4864 FOR_EACH_FRAME (tail
, frame
)
4865 if (FRAME_X_P (XFRAME (frame
))
4866 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
4867 XFRAME (frame
)->mouse_moved
= false;
4869 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4871 /* Figure out which root window we're on. */
4872 XQueryPointer (FRAME_X_DISPLAY (*fp
),
4873 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
4875 /* The root window which contains the pointer. */
4878 /* Trash which we can't trust if the pointer is on
4879 a different screen. */
4882 /* The position on that root window. */
4885 /* More trash we can't trust. */
4888 /* Modifier keys and pointer buttons, about which
4890 (unsigned int *) &dummy
);
4892 /* Now we have a position on the root; find the innermost window
4893 containing the pointer. */
4897 int parent_x
= 0, parent_y
= 0;
4901 /* XTranslateCoordinates can get errors if the window
4902 structure is changing at the same time this function
4903 is running. So at least we must not crash from them. */
4905 x_catch_errors (FRAME_X_DISPLAY (*fp
));
4907 if (x_mouse_grabbed (dpyinfo
))
4909 /* If mouse was grabbed on a frame, give coords for that frame
4910 even if the mouse is now outside it. */
4911 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4917 FRAME_X_WINDOW (dpyinfo
->last_mouse_frame
),
4919 /* From-position, to-position. */
4920 root_x
, root_y
, &win_x
, &win_y
,
4924 f1
= dpyinfo
->last_mouse_frame
;
4930 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4932 /* From-window, to-window. */
4935 /* From-position, to-position. */
4936 root_x
, root_y
, &win_x
, &win_y
,
4941 if (child
== None
|| child
== win
)
4944 /* We don't wan't to know the innermost window. We
4945 want the edit window. For non-Gtk+ the innermost
4946 window is the edit window. For Gtk+ it might not
4947 be. It might be the tool bar for example. */
4948 if (x_window_to_frame (dpyinfo
, win
))
4956 /* Now we know that:
4957 win is the innermost window containing the pointer
4958 (XTC says it has no child containing the pointer),
4959 win_x and win_y are the pointer's position in it
4960 (XTC did this the last time through), and
4961 parent_x and parent_y are the pointer's position in win's parent.
4962 (They are what win_x and win_y were when win was child.
4963 If win is the root window, it has no parent, and
4964 parent_{x,y} are invalid, but that's okay, because we'll
4965 never use them in that case.) */
4968 /* We don't wan't to know the innermost window. We
4969 want the edit window. */
4970 f1
= x_window_to_frame (dpyinfo
, win
);
4972 /* Is win one of our frames? */
4973 f1
= x_any_window_to_frame (dpyinfo
, win
);
4976 #ifdef USE_X_TOOLKIT
4977 /* If we end up with the menu bar window, say it's not
4980 && f1
->output_data
.x
->menubar_widget
4981 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
4983 #endif /* USE_X_TOOLKIT */
4986 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
4989 x_uncatch_errors_after_check ();
4991 /* If not, is it one of our scroll bars? */
4994 struct scroll_bar
*bar
;
4996 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
, 2);
5000 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5006 if (f1
== 0 && insist
> 0)
5007 f1
= SELECTED_FRAME ();
5011 /* Ok, we found a frame. Store all the values.
5012 last_mouse_glyph is a rectangle used to reduce the
5013 generation of mouse events. To not miss any motion
5014 events, we must divide the frame into rectangles of the
5015 size of the smallest character that could be displayed
5016 on it, i.e. into the same rectangles that matrices on
5017 the frame are divided into. */
5019 /* FIXME: what if F1 is not an X frame? */
5020 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
5021 remember_mouse_glyph (f1
, win_x
, win_y
, &dpyinfo
->last_mouse_glyph
);
5022 dpyinfo
->last_mouse_glyph_frame
= f1
;
5027 XSETINT (*x
, win_x
);
5028 XSETINT (*y
, win_y
);
5029 *timestamp
= dpyinfo
->last_mouse_movement_time
;
5039 /***********************************************************************
5041 ***********************************************************************/
5043 /* Scroll bar support. */
5045 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
5047 This can be called in GC, so we have to make sure to strip off mark
5050 static struct scroll_bar
*
5051 x_window_to_scroll_bar (Display
*display
, Window window_id
, int type
)
5053 Lisp_Object tail
, frame
;
5055 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
5056 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
5057 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
5059 FOR_EACH_FRAME (tail
, frame
)
5061 Lisp_Object bar
, condemned
;
5063 if (! FRAME_X_P (XFRAME (frame
)))
5066 /* Scan this frame's scroll bar list for a scroll bar with the
5068 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
5069 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
5070 /* This trick allows us to search both the ordinary and
5071 condemned scroll bar lists with one loop. */
5072 ! NILP (bar
) || (bar
= condemned
,
5075 bar
= XSCROLL_BAR (bar
)->next
)
5076 if (XSCROLL_BAR (bar
)->x_window
== window_id
5077 && FRAME_X_DISPLAY (XFRAME (frame
)) == display
5079 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
5080 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
5081 return XSCROLL_BAR (bar
);
5088 #if defined USE_LUCID
5090 /* Return the Lucid menu bar WINDOW is part of. Return null
5091 if WINDOW is not part of a menu bar. */
5094 x_window_to_menu_bar (Window window
)
5096 Lisp_Object tail
, frame
;
5098 FOR_EACH_FRAME (tail
, frame
)
5099 if (FRAME_X_P (XFRAME (frame
)))
5101 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
5103 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
5109 #endif /* USE_LUCID */
5112 /************************************************************************
5114 ************************************************************************/
5116 #ifdef USE_TOOLKIT_SCROLL_BARS
5118 static void x_send_scroll_bar_event (Lisp_Object
, enum scroll_bar_part
,
5121 /* Lisp window being scrolled. Set when starting to interact with
5122 a toolkit scroll bar, reset to nil when ending the interaction. */
5124 static Lisp_Object window_being_scrolled
;
5126 /* Whether this is an Xaw with arrow-scrollbars. This should imply
5127 that movements of 1/20 of the screen size are mapped to up/down. */
5130 /* Id of action hook installed for scroll bars. */
5132 static XtActionHookId action_hook_id
;
5133 static XtActionHookId horizontal_action_hook_id
;
5135 static Boolean xaw3d_arrow_scroll
;
5137 /* Whether the drag scrolling maintains the mouse at the top of the
5138 thumb. If not, resizing the thumb needs to be done more carefully
5139 to avoid jerkiness. */
5141 static Boolean xaw3d_pick_top
;
5143 /* Action hook installed via XtAppAddActionHook when toolkit scroll
5144 bars are used.. The hook is responsible for detecting when
5145 the user ends an interaction with the scroll bar, and generates
5146 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
5149 xt_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
5150 XEvent
*event
, String
*params
, Cardinal
*num_params
)
5153 const char *end_action
;
5156 scroll_bar_p
= XmIsScrollBar (widget
);
5157 end_action
= "Release";
5158 #else /* !USE_MOTIF i.e. use Xaw */
5159 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
5160 end_action
= "EndScroll";
5161 #endif /* USE_MOTIF */
5164 && strcmp (action_name
, end_action
) == 0
5165 && WINDOWP (window_being_scrolled
))
5168 struct scroll_bar
*bar
;
5170 x_send_scroll_bar_event (window_being_scrolled
,
5171 scroll_bar_end_scroll
, 0, 0, false);
5172 w
= XWINDOW (window_being_scrolled
);
5173 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5175 if (bar
->dragging
!= -1)
5178 /* The thumb size is incorrect while dragging: fix it. */
5179 set_vertical_scroll_bar (w
);
5181 window_being_scrolled
= Qnil
;
5182 #if defined (USE_LUCID)
5183 bar
->last_seen_part
= scroll_bar_nowhere
;
5185 /* Xt timeouts no longer needed. */
5186 toolkit_scroll_bar_interaction
= false;
5192 xt_horizontal_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
5193 XEvent
*event
, String
*params
, Cardinal
*num_params
)
5196 const char *end_action
;
5199 scroll_bar_p
= XmIsScrollBar (widget
);
5200 end_action
= "Release";
5201 #else /* !USE_MOTIF i.e. use Xaw */
5202 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
5203 end_action
= "EndScroll";
5204 #endif /* USE_MOTIF */
5207 && strcmp (action_name
, end_action
) == 0
5208 && WINDOWP (window_being_scrolled
))
5211 struct scroll_bar
*bar
;
5213 x_send_scroll_bar_event (window_being_scrolled
,
5214 scroll_bar_end_scroll
, 0, 0, true);
5215 w
= XWINDOW (window_being_scrolled
);
5216 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
5218 if (bar
->dragging
!= -1)
5221 /* The thumb size is incorrect while dragging: fix it. */
5222 set_horizontal_scroll_bar (w
);
5224 window_being_scrolled
= Qnil
;
5225 #if defined (USE_LUCID)
5226 bar
->last_seen_part
= scroll_bar_nowhere
;
5228 /* Xt timeouts no longer needed. */
5229 toolkit_scroll_bar_interaction
= false;
5232 #endif /* not USE_GTK */
5234 /* Send a client message with message type Xatom_Scrollbar for a
5235 scroll action to the frame of WINDOW. PART is a value identifying
5236 the part of the scroll bar that was clicked on. PORTION is the
5237 amount to scroll of a whole of WHOLE. */
5240 x_send_scroll_bar_event (Lisp_Object window
, enum scroll_bar_part part
,
5241 int portion
, int whole
, bool horizontal
)
5244 XClientMessageEvent
*ev
= &event
.xclient
;
5245 struct window
*w
= XWINDOW (window
);
5246 struct frame
*f
= XFRAME (w
->frame
);
5247 intptr_t iw
= (intptr_t) w
;
5248 enum { BITS_PER_INTPTR
= CHAR_BIT
* sizeof iw
};
5249 verify (BITS_PER_INTPTR
<= 64);
5250 int sign_shift
= BITS_PER_INTPTR
- 32;
5254 /* Construct a ClientMessage event to send to the frame. */
5255 ev
->type
= ClientMessage
;
5256 ev
->message_type
= (horizontal
5257 ? FRAME_DISPLAY_INFO (f
)->Xatom_Horizontal_Scrollbar
5258 : FRAME_DISPLAY_INFO (f
)->Xatom_Scrollbar
);
5259 ev
->display
= FRAME_X_DISPLAY (f
);
5260 ev
->window
= FRAME_X_WINDOW (f
);
5263 /* A 32-bit X client on a 64-bit X server can pass a window pointer
5264 as-is. A 64-bit client on a 32-bit X server is in trouble
5265 because a pointer does not fit and would be truncated while
5266 passing through the server. So use two slots and hope that X12
5267 will resolve such issues someday. */
5268 ev
->data
.l
[0] = iw
>> 31 >> 1;
5269 ev
->data
.l
[1] = sign_shift
<= 0 ? iw
: iw
<< sign_shift
>> sign_shift
;
5270 ev
->data
.l
[2] = part
;
5271 ev
->data
.l
[3] = portion
;
5272 ev
->data
.l
[4] = whole
;
5274 /* Make Xt timeouts work while the scroll bar is active. */
5275 #ifdef USE_X_TOOLKIT
5276 toolkit_scroll_bar_interaction
= true;
5277 x_activate_timeout_atimer ();
5280 /* Setting the event mask to zero means that the message will
5281 be sent to the client that created the window, and if that
5282 window no longer exists, no event will be sent. */
5283 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
5288 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
5292 x_scroll_bar_to_input_event (const XEvent
*event
,
5293 struct input_event
*ievent
)
5295 const XClientMessageEvent
*ev
= &event
->xclient
;
5299 /* See the comment in the function above. */
5300 intptr_t iw0
= ev
->data
.l
[0];
5301 intptr_t iw1
= ev
->data
.l
[1];
5302 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
5303 w
= (struct window
*) iw
;
5305 XSETWINDOW (window
, w
);
5307 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
5308 ievent
->frame_or_window
= window
;
5311 ievent
->timestamp
= CurrentTime
;
5314 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
5317 ievent
->part
= ev
->data
.l
[2];
5318 ievent
->x
= make_number (ev
->data
.l
[3]);
5319 ievent
->y
= make_number (ev
->data
.l
[4]);
5320 ievent
->modifiers
= 0;
5323 /* Transform a horizontal scroll bar ClientMessage EVENT to an Emacs
5324 input event in *IEVENT. */
5327 x_horizontal_scroll_bar_to_input_event (const XEvent
*event
,
5328 struct input_event
*ievent
)
5330 const XClientMessageEvent
*ev
= &event
->xclient
;
5334 /* See the comment in the function above. */
5335 intptr_t iw0
= ev
->data
.l
[0];
5336 intptr_t iw1
= ev
->data
.l
[1];
5337 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
5338 w
= (struct window
*) iw
;
5340 XSETWINDOW (window
, w
);
5342 ievent
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
5343 ievent
->frame_or_window
= window
;
5346 ievent
->timestamp
= CurrentTime
;
5349 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
5352 ievent
->part
= ev
->data
.l
[2];
5353 ievent
->x
= make_number (ev
->data
.l
[3]);
5354 ievent
->y
= make_number (ev
->data
.l
[4]);
5355 ievent
->modifiers
= 0;
5361 /* Minimum and maximum values used for Motif scroll bars. */
5363 #define XM_SB_MAX 10000000
5365 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
5366 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
5367 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
5370 xm_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5372 struct scroll_bar
*bar
= client_data
;
5373 XmScrollBarCallbackStruct
*cs
= call_data
;
5374 enum scroll_bar_part part
= scroll_bar_nowhere
;
5375 bool horizontal
= bar
->horizontal
;
5376 int whole
= 0, portion
= 0;
5380 case XmCR_DECREMENT
:
5382 part
= horizontal
? scroll_bar_left_arrow
: scroll_bar_up_arrow
;
5385 case XmCR_INCREMENT
:
5387 part
= horizontal
? scroll_bar_right_arrow
: scroll_bar_down_arrow
;
5390 case XmCR_PAGE_DECREMENT
:
5392 part
= horizontal
? scroll_bar_before_handle
: scroll_bar_above_handle
;
5395 case XmCR_PAGE_INCREMENT
:
5397 part
= horizontal
? scroll_bar_after_handle
: scroll_bar_below_handle
;
5402 part
= horizontal
? scroll_bar_to_leftmost
: scroll_bar_to_top
;
5405 case XmCR_TO_BOTTOM
:
5407 part
= horizontal
? scroll_bar_to_rightmost
: scroll_bar_to_bottom
;
5415 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
5420 portion
= bar
->whole
* ((float)cs
->value
/ XM_SB_MAX
);
5421 whole
= bar
->whole
* ((float)(XM_SB_MAX
- slider_size
) / XM_SB_MAX
);
5422 portion
= min (portion
, whole
);
5423 part
= scroll_bar_horizontal_handle
;
5427 whole
= XM_SB_MAX
- slider_size
;
5428 portion
= min (cs
->value
, whole
);
5429 part
= scroll_bar_handle
;
5432 bar
->dragging
= cs
->value
;
5436 case XmCR_VALUE_CHANGED
:
5440 if (part
!= scroll_bar_nowhere
)
5442 window_being_scrolled
= bar
->window
;
5443 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
,
5448 #elif defined USE_GTK
5450 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
5451 bar widget. DATA is a pointer to the scroll_bar structure. */
5454 xg_scroll_callback (GtkRange
*range
,
5455 GtkScrollType scroll
,
5459 int whole
= 0, portion
= 0;
5460 struct scroll_bar
*bar
= user_data
;
5461 enum scroll_bar_part part
= scroll_bar_nowhere
;
5462 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
5463 struct frame
*f
= g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
5465 if (xg_ignore_gtk_scrollbar
) return false;
5469 case GTK_SCROLL_JUMP
:
5470 /* Buttons 1 2 or 3 must be grabbed. */
5471 if (FRAME_DISPLAY_INFO (f
)->grabbed
!= 0
5472 && FRAME_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
5474 if (bar
->horizontal
)
5476 part
= scroll_bar_horizontal_handle
;
5477 whole
= (int)(gtk_adjustment_get_upper (adj
) -
5478 gtk_adjustment_get_page_size (adj
));
5479 portion
= min ((int)value
, whole
);
5480 bar
->dragging
= portion
;
5484 part
= scroll_bar_handle
;
5485 whole
= gtk_adjustment_get_upper (adj
) -
5486 gtk_adjustment_get_page_size (adj
);
5487 portion
= min ((int)value
, whole
);
5488 bar
->dragging
= portion
;
5492 case GTK_SCROLL_STEP_BACKWARD
:
5493 part
= (bar
->horizontal
5494 ? scroll_bar_left_arrow
: scroll_bar_up_arrow
);
5497 case GTK_SCROLL_STEP_FORWARD
:
5498 part
= (bar
->horizontal
5499 ? scroll_bar_right_arrow
: scroll_bar_down_arrow
);
5502 case GTK_SCROLL_PAGE_BACKWARD
:
5503 part
= (bar
->horizontal
5504 ? scroll_bar_before_handle
: scroll_bar_above_handle
);
5507 case GTK_SCROLL_PAGE_FORWARD
:
5508 part
= (bar
->horizontal
5509 ? scroll_bar_after_handle
: scroll_bar_below_handle
);
5516 if (part
!= scroll_bar_nowhere
)
5518 window_being_scrolled
= bar
->window
;
5519 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
,
5526 /* Callback for button release. Sets dragging to -1 when dragging is done. */
5529 xg_end_scroll_callback (GtkWidget
*widget
,
5530 GdkEventButton
*event
,
5533 struct scroll_bar
*bar
= user_data
;
5535 if (WINDOWP (window_being_scrolled
))
5537 x_send_scroll_bar_event (window_being_scrolled
,
5538 scroll_bar_end_scroll
, 0, 0, bar
->horizontal
);
5539 window_being_scrolled
= Qnil
;
5546 #else /* not USE_GTK and not USE_MOTIF */
5548 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
5549 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
5550 scroll bar struct. CALL_DATA is a pointer to a float saying where
5554 xaw_jump_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5556 struct scroll_bar
*bar
= client_data
;
5557 float *top_addr
= call_data
;
5558 float top
= *top_addr
;
5560 int whole
, portion
, height
, width
;
5561 enum scroll_bar_part part
;
5562 bool horizontal
= bar
->horizontal
;
5567 /* Get the size of the thumb, a value between 0 and 1. */
5569 XtVaGetValues (widget
, XtNshown
, &shown
, XtNwidth
, &width
, NULL
);
5574 whole
= bar
->whole
- (shown
* bar
->whole
);
5575 portion
= min (top
* bar
->whole
, whole
);
5583 part
= scroll_bar_horizontal_handle
;
5587 /* Get the size of the thumb, a value between 0 and 1. */
5589 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
5593 portion
= shown
< 1 ? top
* whole
: 0;
5595 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0f
/ height
))
5596 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
5597 the bottom, so we force the scrolling whenever we see that we're
5598 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
5599 we try to ensure that we always stay two pixels away from the
5601 part
= scroll_bar_down_arrow
;
5603 part
= scroll_bar_handle
;
5606 window_being_scrolled
= bar
->window
;
5607 bar
->dragging
= portion
;
5608 bar
->last_seen_part
= part
;
5609 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
, bar
->horizontal
);
5613 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
5614 i.e. line or page up or down. WIDGET is the Xaw scroll bar
5615 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
5616 the scroll bar. CALL_DATA is an integer specifying the action that
5617 has taken place. Its magnitude is in the range 0..height of the
5618 scroll bar. Negative values mean scroll towards buffer start.
5619 Values < height of scroll bar mean line-wise movement. */
5622 xaw_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5624 struct scroll_bar
*bar
= client_data
;
5625 /* The position really is stored cast to a pointer. */
5626 int position
= (intptr_t) call_data
;
5627 Dimension height
, width
;
5628 enum scroll_bar_part part
;
5630 if (bar
->horizontal
)
5632 /* Get the width of the scroll bar. */
5634 XtVaGetValues (widget
, XtNwidth
, &width
, NULL
);
5637 if (eabs (position
) >= width
)
5638 part
= (position
< 0) ? scroll_bar_before_handle
: scroll_bar_after_handle
;
5640 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
5641 it maps line-movement to call_data = max(5, height/20). */
5642 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, width
/ 20))
5643 part
= (position
< 0) ? scroll_bar_left_arrow
: scroll_bar_right_arrow
;
5645 part
= scroll_bar_move_ratio
;
5647 window_being_scrolled
= bar
->window
;
5649 bar
->last_seen_part
= part
;
5650 x_send_scroll_bar_event (bar
->window
, part
, position
, width
,
5656 /* Get the height of the scroll bar. */
5658 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
5661 if (eabs (position
) >= height
)
5662 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
5664 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
5665 it maps line-movement to call_data = max(5, height/20). */
5666 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
5667 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
5669 part
= scroll_bar_move_ratio
;
5671 window_being_scrolled
= bar
->window
;
5673 bar
->last_seen_part
= part
;
5674 x_send_scroll_bar_event (bar
->window
, part
, position
, height
,
5679 #endif /* not USE_GTK and not USE_MOTIF */
5681 #define SCROLL_BAR_NAME "verticalScrollBar"
5682 #define SCROLL_BAR_HORIZONTAL_NAME "horizontalScrollBar"
5684 /* Create the widget for scroll bar BAR on frame F. Record the widget
5685 and X window of the scroll bar in BAR. */
5689 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5691 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
5694 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
5695 G_CALLBACK (xg_end_scroll_callback
),
5701 x_create_horizontal_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5703 const char *scroll_bar_name
= SCROLL_BAR_HORIZONTAL_NAME
;
5706 xg_create_horizontal_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
5707 G_CALLBACK (xg_end_scroll_callback
),
5712 #else /* not USE_GTK */
5715 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5721 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
5722 unsigned long pixel
;
5727 /* Set resources. Create the widget. */
5728 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5729 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
5730 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
5731 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
5732 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
5733 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
5734 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
5736 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5739 XtSetArg (av
[ac
], XmNforeground
, pixel
);
5743 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5746 XtSetArg (av
[ac
], XmNbackground
, pixel
);
5750 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
5751 (char *) scroll_bar_name
, av
, ac
);
5753 /* Add one callback for everything that can happen. */
5754 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
5756 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
5758 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
5760 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
5762 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
5764 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
5766 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
5769 /* Realize the widget. Only after that is the X window created. */
5770 XtRealizeWidget (widget
);
5772 /* Set the cursor to an arrow. I didn't find a resource to do that.
5773 And I'm wondering why it hasn't an arrow cursor by default. */
5774 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
5775 f
->output_data
.x
->nontext_cursor
);
5777 #else /* !USE_MOTIF i.e. use Xaw */
5779 /* Set resources. Create the widget. The background of the
5780 Xaw3d scroll bar widget is a little bit light for my taste.
5781 We don't alter it here to let users change it according
5782 to their taste with `emacs*verticalScrollBar.background: xxx'. */
5783 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5784 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
5785 /* For smoother scrolling with Xaw3d -sm */
5786 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
5788 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5791 XtSetArg (av
[ac
], XtNforeground
, pixel
);
5795 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5798 XtSetArg (av
[ac
], XtNbackground
, pixel
);
5802 /* Top/bottom shadow colors. */
5804 /* Allocate them, if necessary. */
5805 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
5807 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5810 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5811 FRAME_X_COLORMAP (f
),
5812 &pixel
, 1.2, 0x8000))
5814 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
5817 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5819 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5822 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5823 FRAME_X_COLORMAP (f
),
5824 &pixel
, 0.6, 0x4000))
5826 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
5830 #ifdef XtNbeNiceToColormap
5831 /* Tell the toolkit about them. */
5832 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
5833 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5834 /* We tried to allocate a color for the top/bottom shadow, and
5835 failed, so tell Xaw3d to use dithering instead. */
5836 /* But only if we have a small colormap. Xaw3d can allocate nice
5839 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
5840 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
5844 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
5845 be more consistent with other emacs 3d colors, and since Xaw3d is
5846 not good at dealing with allocation failure. */
5848 /* This tells Xaw3d to use real colors instead of dithering for
5850 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
5853 /* Specify the colors. */
5854 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
5857 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
5860 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
5863 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
5869 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
5870 f
->output_data
.x
->edit_widget
, av
, ac
);
5873 char const *initial
= "";
5874 char const *val
= initial
;
5875 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
5876 #ifdef XtNarrowScrollbars
5877 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
5879 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
5880 if (xaw3d_arrow_scroll
|| val
== initial
)
5881 { /* ARROW_SCROLL */
5882 xaw3d_arrow_scroll
= True
;
5883 /* Isn't that just a personal preference ? --Stef */
5884 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
5888 /* Define callbacks. */
5889 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
5890 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
5893 /* Realize the widget. Only after that is the X window created. */
5894 XtRealizeWidget (widget
);
5896 #endif /* !USE_MOTIF */
5898 /* Install an action hook that lets us detect when the user
5899 finishes interacting with a scroll bar. */
5900 if (action_hook_id
== 0)
5901 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
5903 /* Remember X window and widget in the scroll bar vector. */
5904 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
5905 xwindow
= XtWindow (widget
);
5906 bar
->x_window
= xwindow
;
5908 bar
->horizontal
= false;
5914 x_create_horizontal_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5920 const char *scroll_bar_name
= SCROLL_BAR_HORIZONTAL_NAME
;
5921 unsigned long pixel
;
5926 /* Set resources. Create the widget. */
5927 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5928 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
5929 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
5930 XtSetArg (av
[ac
], XmNorientation
, XmHORIZONTAL
); ++ac
;
5931 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_RIGHT
), ++ac
;
5932 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
5933 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
5935 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5938 XtSetArg (av
[ac
], XmNforeground
, pixel
);
5942 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5945 XtSetArg (av
[ac
], XmNbackground
, pixel
);
5949 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
5950 (char *) scroll_bar_name
, av
, ac
);
5952 /* Add one callback for everything that can happen. */
5953 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
5955 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
5957 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
5959 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
5961 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
5963 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
5965 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
5968 /* Realize the widget. Only after that is the X window created. */
5969 XtRealizeWidget (widget
);
5971 /* Set the cursor to an arrow. I didn't find a resource to do that.
5972 And I'm wondering why it hasn't an arrow cursor by default. */
5973 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
5974 f
->output_data
.x
->nontext_cursor
);
5976 #else /* !USE_MOTIF i.e. use Xaw */
5978 /* Set resources. Create the widget. The background of the
5979 Xaw3d scroll bar widget is a little bit light for my taste.
5980 We don't alter it here to let users change it according
5981 to their taste with `emacs*verticalScrollBar.background: xxx'. */
5982 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5983 XtSetArg (av
[ac
], XtNorientation
, XtorientHorizontal
); ++ac
;
5984 /* For smoother scrolling with Xaw3d -sm */
5985 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
5987 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5990 XtSetArg (av
[ac
], XtNforeground
, pixel
);
5994 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5997 XtSetArg (av
[ac
], XtNbackground
, pixel
);
6001 /* Top/bottom shadow colors. */
6003 /* Allocate them, if necessary. */
6004 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
6006 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
6009 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
6010 FRAME_X_COLORMAP (f
),
6011 &pixel
, 1.2, 0x8000))
6013 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
6016 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
6018 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
6021 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
6022 FRAME_X_COLORMAP (f
),
6023 &pixel
, 0.6, 0x4000))
6025 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
6029 #ifdef XtNbeNiceToColormap
6030 /* Tell the toolkit about them. */
6031 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
6032 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
6033 /* We tried to allocate a color for the top/bottom shadow, and
6034 failed, so tell Xaw3d to use dithering instead. */
6035 /* But only if we have a small colormap. Xaw3d can allocate nice
6038 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
6039 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
6043 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
6044 be more consistent with other emacs 3d colors, and since Xaw3d is
6045 not good at dealing with allocation failure. */
6047 /* This tells Xaw3d to use real colors instead of dithering for
6049 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
6052 /* Specify the colors. */
6053 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
6056 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
6059 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
6062 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
6068 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
6069 f
->output_data
.x
->edit_widget
, av
, ac
);
6072 char const *initial
= "";
6073 char const *val
= initial
;
6074 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
6075 #ifdef XtNarrowScrollbars
6076 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
6078 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
6079 if (xaw3d_arrow_scroll
|| val
== initial
)
6080 { /* ARROW_SCROLL */
6081 xaw3d_arrow_scroll
= True
;
6082 /* Isn't that just a personal preference ? --Stef */
6083 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
6087 /* Define callbacks. */
6088 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
6089 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
6092 /* Realize the widget. Only after that is the X window created. */
6093 XtRealizeWidget (widget
);
6095 #endif /* !USE_MOTIF */
6097 /* Install an action hook that lets us detect when the user
6098 finishes interacting with a scroll bar. */
6099 if (horizontal_action_hook_id
== 0)
6100 horizontal_action_hook_id
6101 = XtAppAddActionHook (Xt_app_con
, xt_horizontal_action_hook
, 0);
6103 /* Remember X window and widget in the scroll bar vector. */
6104 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
6105 xwindow
= XtWindow (widget
);
6106 bar
->x_window
= xwindow
;
6108 bar
->horizontal
= true;
6112 #endif /* not USE_GTK */
6115 /* Set the thumb size and position of scroll bar BAR. We are currently
6116 displaying PORTION out of a whole WHOLE, and our position POSITION. */
6120 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
6122 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
6126 x_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
6128 xg_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
6131 #else /* not USE_GTK */
6133 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
6136 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6137 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6144 if (scroll_bar_adjust_thumb_portion_p
)
6146 /* We use an estimate of 30 chars per line rather than the real
6147 `portion' value. This has the disadvantage that the thumb size
6148 is not very representative, but it makes our life a lot easier.
6149 Otherwise, we have to constantly adjust the thumb size, which
6150 we can't always do quickly enough: while dragging, the size of
6151 the thumb might prevent the user from dragging the thumb all the
6152 way to the end. but Motif and some versions of Xaw3d don't allow
6153 updating the thumb size while dragging. Also, even if we can update
6154 its size, the update will often happen too late.
6155 If you don't believe it, check out revision 1.650 of xterm.c to see
6156 what hoops we were going through and the still poor behavior we got. */
6157 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
6158 /* When the thumb is at the bottom, position == whole.
6159 So we need to increase `whole' to make space for the thumb. */
6167 top
= (float) position
/ whole
;
6168 shown
= (float) portion
/ whole
;
6171 if (bar
->dragging
== -1)
6175 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
6176 is the scroll bar's maximum and MIN is the scroll bar's minimum
6178 size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
6180 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
6181 value
= top
* XM_SB_MAX
;
6182 value
= min (value
, XM_SB_MAX
- size
);
6184 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
6186 #else /* !USE_MOTIF i.e. use Xaw */
6192 top
= (float) position
/ whole
;
6193 shown
= (float) portion
/ whole
;
6197 float old_top
, old_shown
;
6199 XtVaGetValues (widget
,
6200 XtNtopOfThumb
, &old_top
,
6201 XtNshown
, &old_shown
,
6205 /* Massage the top+shown values. */
6206 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
6207 top
= max (0, min (1, top
));
6210 #if ! defined (HAVE_XAW3D)
6211 /* With Xaw, 'top' values too closer to 1.0 may
6212 cause the thumb to disappear. Fix that. */
6213 top
= min (top
, 0.99f
);
6215 /* Keep two pixels available for moving the thumb down. */
6216 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
6217 #if ! defined (HAVE_XAW3D)
6218 /* Likewise with too small 'shown'. */
6219 shown
= max (shown
, 0.01f
);
6222 /* If the call to XawScrollbarSetThumb below doesn't seem to
6223 work, check that 'NARROWPROTO' is defined in src/config.h.
6224 If this is not so, most likely you need to fix configure. */
6225 if (top
!= old_top
|| shown
!= old_shown
)
6227 if (bar
->dragging
== -1)
6228 XawScrollbarSetThumb (widget
, top
, shown
);
6231 /* Try to make the scrolling a tad smoother. */
6232 if (!xaw3d_pick_top
)
6233 shown
= min (shown
, old_shown
);
6235 XawScrollbarSetThumb (widget
, top
, shown
);
6239 #endif /* !USE_MOTIF */
6245 x_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
6248 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6249 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6256 shown
= (float) portion
/ whole
;
6257 top
= (float) position
/ (whole
- portion
);
6259 int size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
6260 int value
= clip_to_bounds (0, top
* (XM_SB_MAX
- size
), XM_SB_MAX
- size
);
6262 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
6264 #else /* !USE_MOTIF i.e. use Xaw */
6270 top
= (float) position
/ whole
;
6271 shown
= (float) portion
/ whole
;
6275 float old_top
, old_shown
;
6277 XtVaGetValues (widget
,
6278 XtNtopOfThumb
, &old_top
,
6279 XtNshown
, &old_shown
,
6284 /* Massage the top+shown values. */
6285 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
6286 top
= max (0, min (1, top
));
6289 #if ! defined (HAVE_XAW3D)
6290 /* With Xaw, 'top' values too closer to 1.0 may
6291 cause the thumb to disappear. Fix that. */
6292 top
= min (top
, 0.99f
);
6294 /* Keep two pixels available for moving the thumb down. */
6295 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
6296 #if ! defined (HAVE_XAW3D)
6297 /* Likewise with too small 'shown'. */
6298 shown
= max (shown
, 0.01f
);
6302 /* If the call to XawScrollbarSetThumb below doesn't seem to
6303 work, check that 'NARROWPROTO' is defined in src/config.h.
6304 If this is not so, most likely you need to fix configure. */
6305 XawScrollbarSetThumb (widget
, top
, shown
);
6307 if (top
!= old_top
|| shown
!= old_shown
)
6309 if (bar
->dragging
== -1)
6310 XawScrollbarSetThumb (widget
, top
, shown
);
6313 /* Try to make the scrolling a tad smoother. */
6314 if (!xaw3d_pick_top
)
6315 shown
= min (shown
, old_shown
);
6317 XawScrollbarSetThumb (widget
, top
, shown
);
6322 #endif /* !USE_MOTIF */
6326 #endif /* not USE_GTK */
6328 #endif /* USE_TOOLKIT_SCROLL_BARS */
6332 /************************************************************************
6333 Scroll bars, general
6334 ************************************************************************/
6336 /* Create a scroll bar and return the scroll bar vector for it. W is
6337 the Emacs window on which to create the scroll bar. TOP, LEFT,
6338 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
6341 static struct scroll_bar
*
6342 x_scroll_bar_create (struct window
*w
, int top
, int left
,
6343 int width
, int height
, bool horizontal
)
6345 struct frame
*f
= XFRAME (w
->frame
);
6346 struct scroll_bar
*bar
6347 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
6352 #ifdef USE_TOOLKIT_SCROLL_BARS
6354 x_create_horizontal_toolkit_scroll_bar (f
, bar
);
6356 x_create_toolkit_scroll_bar (f
, bar
);
6357 #else /* not USE_TOOLKIT_SCROLL_BARS */
6359 XSetWindowAttributes a
;
6363 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
6364 if (a
.background_pixel
== -1)
6365 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
6367 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
6368 | ButtonMotionMask
| PointerMotionHintMask
6370 a
.cursor
= FRAME_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
6372 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
6374 /* Clear the area of W that will serve as a scroll bar. This is
6375 for the case that a window has been split horizontally. In
6376 this case, no clear_frame is generated to reduce flickering. */
6377 if (width
> 0 && window_box_height (w
) > 0)
6378 x_clear_area (f
, left
, top
, width
, window_box_height (w
));
6380 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6381 /* Position and size of scroll bar. */
6382 left
, top
, width
, height
,
6383 /* Border width, depth, class, and visual. */
6390 bar
->x_window
= window
;
6392 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6394 XSETWINDOW (bar
->window
, w
);
6398 bar
->height
= height
;
6402 bar
->horizontal
= horizontal
;
6403 #if defined (USE_TOOLKIT_SCROLL_BARS) && defined (USE_LUCID)
6404 bar
->last_seen_part
= scroll_bar_nowhere
;
6407 /* Add bar to its frame's list of scroll bars. */
6408 bar
->next
= FRAME_SCROLL_BARS (f
);
6410 XSETVECTOR (barobj
, bar
);
6411 fset_scroll_bars (f
, barobj
);
6412 if (!NILP (bar
->next
))
6413 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6415 /* Map the window/widget. */
6416 #ifdef USE_TOOLKIT_SCROLL_BARS
6420 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
,
6421 left
, width
, max (height
, 1));
6423 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
6424 left
, width
, max (height
, 1));
6425 #else /* not USE_GTK */
6426 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6427 XtConfigureWidget (scroll_bar
, left
, top
, width
, max (height
, 1), 0);
6428 XtMapWidget (scroll_bar
);
6429 #endif /* not USE_GTK */
6431 #else /* not USE_TOOLKIT_SCROLL_BARS */
6432 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
6433 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6440 #ifndef USE_TOOLKIT_SCROLL_BARS
6442 /* Draw BAR's handle in the proper position.
6444 If the handle is already drawn from START to END, don't bother
6445 redrawing it, unless REBUILD; in that case, always
6446 redraw it. (REBUILD is handy for drawing the handle after expose
6449 Normally, we want to constrain the start and end of the handle to
6450 fit inside its rectangle, but if the user is dragging the scroll
6451 bar handle, we want to let them drag it down all the way, so that
6452 the bar's top is as far down as it goes; otherwise, there's no way
6453 to move to the very end of the buffer. */
6456 x_scroll_bar_set_handle (struct scroll_bar
*bar
, int start
, int end
,
6459 bool dragging
= bar
->dragging
!= -1;
6460 Window w
= bar
->x_window
;
6461 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6462 GC gc
= f
->output_data
.x
->normal_gc
;
6464 /* If the display is already accurate, do nothing. */
6466 && start
== bar
->start
6473 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
6474 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
6475 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
6477 /* Make sure the values are reasonable, and try to preserve
6478 the distance between start and end. */
6480 int length
= end
- start
;
6484 else if (start
> top_range
)
6486 end
= start
+ length
;
6490 else if (end
> top_range
&& ! dragging
)
6494 /* Store the adjusted setting in the scroll bar. */
6498 /* Clip the end position, just for display. */
6499 if (end
> top_range
)
6502 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
6503 below top positions, to make sure the handle is always at least
6504 that many pixels tall. */
6505 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
6507 /* Draw the empty space above the handle. Note that we can't clear
6508 zero-height areas; that means "clear to end of window." */
6509 if ((inside_width
> 0) && (start
> 0))
6510 x_clear_area1 (FRAME_X_DISPLAY (f
), w
,
6511 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6512 VERTICAL_SCROLL_BAR_TOP_BORDER
,
6513 inside_width
, start
, False
);
6515 /* Change to proper foreground color if one is specified. */
6516 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6517 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6518 f
->output_data
.x
->scroll_bar_foreground_pixel
);
6520 /* Draw the handle itself. */
6521 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
6522 /* x, y, width, height */
6523 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6524 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
6525 inside_width
, end
- start
);
6527 /* Restore the foreground color of the GC if we changed it above. */
6528 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6529 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6530 FRAME_FOREGROUND_PIXEL (f
));
6532 /* Draw the empty space below the handle. Note that we can't
6533 clear zero-height areas; that means "clear to end of window." */
6534 if ((inside_width
> 0) && (end
< inside_height
))
6535 x_clear_area1 (FRAME_X_DISPLAY (f
), w
,
6536 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6537 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
6538 inside_width
, inside_height
- end
, False
);
6544 #endif /* !USE_TOOLKIT_SCROLL_BARS */
6546 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
6550 x_scroll_bar_remove (struct scroll_bar
*bar
)
6552 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6555 #ifdef USE_TOOLKIT_SCROLL_BARS
6557 xg_remove_scroll_bar (f
, bar
->x_window
);
6558 #else /* not USE_GTK */
6559 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
6560 #endif /* not USE_GTK */
6562 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
6565 /* Dissociate this scroll bar from its window. */
6566 if (bar
->horizontal
)
6567 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
6569 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
6575 /* Set the handle of the vertical scroll bar for WINDOW to indicate
6576 that we are displaying PORTION characters out of a total of WHOLE
6577 characters, starting at POSITION. If WINDOW has no scroll bar,
6581 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
6583 struct frame
*f
= XFRAME (w
->frame
);
6585 struct scroll_bar
*bar
;
6586 int top
, height
, left
, width
;
6587 int window_y
, window_height
;
6589 /* Get window dimensions. */
6590 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
6592 height
= window_height
;
6593 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
6594 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
6596 /* Does the scroll bar exist yet? */
6597 if (NILP (w
->vertical_scroll_bar
))
6599 if (width
> 0 && height
> 0)
6602 x_clear_area (f
, left
, top
, width
, height
);
6606 bar
= x_scroll_bar_create (w
, top
, left
, width
, max (height
, 1), false);
6610 /* It may just need to be moved and resized. */
6611 unsigned int mask
= 0;
6613 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
6617 if (left
!= bar
->left
)
6619 if (top
!= bar
->top
)
6621 if (width
!= bar
->width
)
6623 if (height
!= bar
->height
)
6626 #ifdef USE_TOOLKIT_SCROLL_BARS
6628 /* Move/size the scroll bar widget. */
6631 /* Since toolkit scroll bars are smaller than the space reserved
6632 for them on the frame, we have to clear "under" them. */
6633 if (width
> 0 && height
> 0)
6634 x_clear_area (f
, left
, top
, width
, height
);
6636 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
6637 left
, width
, max (height
, 1));
6638 #else /* not USE_GTK */
6639 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
6640 left
, top
, width
, max (height
, 1), 0);
6641 #endif /* not USE_GTK */
6643 #else /* not USE_TOOLKIT_SCROLL_BARS */
6645 /* Move/size the scroll bar window. */
6654 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
6658 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6660 /* Remember new settings. */
6664 bar
->height
= height
;
6669 #ifdef USE_TOOLKIT_SCROLL_BARS
6670 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
6671 #else /* not USE_TOOLKIT_SCROLL_BARS */
6672 /* Set the scroll bar's current state, unless we're currently being
6674 if (bar
->dragging
== -1)
6676 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
6679 x_scroll_bar_set_handle (bar
, 0, top_range
, false);
6682 int start
= ((double) position
* top_range
) / whole
;
6683 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
6684 x_scroll_bar_set_handle (bar
, start
, end
, false);
6687 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6689 XSETVECTOR (barobj
, bar
);
6690 wset_vertical_scroll_bar (w
, barobj
);
6695 XTset_horizontal_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
6697 struct frame
*f
= XFRAME (w
->frame
);
6699 struct scroll_bar
*bar
;
6700 int top
, height
, left
, width
;
6701 int window_x
, window_width
;
6702 int pixel_width
= WINDOW_PIXEL_WIDTH (w
);
6704 /* Get window dimensions. */
6705 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
6707 width
= window_width
;
6708 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
6709 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
6711 /* Does the scroll bar exist yet? */
6712 if (NILP (w
->horizontal_scroll_bar
))
6714 if (width
> 0 && height
> 0)
6718 /* Clear also part between window_width and
6719 WINDOW_PIXEL_WIDTH. */
6720 x_clear_area (f
, left
, top
, pixel_width
, height
);
6724 bar
= x_scroll_bar_create (w
, top
, left
, width
, height
, true);
6728 /* It may just need to be moved and resized. */
6729 unsigned int mask
= 0;
6731 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
6735 if (left
!= bar
->left
)
6737 if (top
!= bar
->top
)
6739 if (width
!= bar
->width
)
6741 if (height
!= bar
->height
)
6744 #ifdef USE_TOOLKIT_SCROLL_BARS
6745 /* Move/size the scroll bar widget. */
6748 /* Since toolkit scroll bars are smaller than the space reserved
6749 for them on the frame, we have to clear "under" them. */
6750 if (width
> 0 && height
> 0)
6752 WINDOW_LEFT_EDGE_X (w
), top
,
6753 pixel_width
- WINDOW_RIGHT_DIVIDER_WIDTH (w
), height
);
6755 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
, left
,
6757 #else /* not USE_GTK */
6758 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
6759 left
, top
, width
, height
, 0);
6760 #endif /* not USE_GTK */
6762 #else /* not USE_TOOLKIT_SCROLL_BARS */
6764 /* Clear areas not covered by the scroll bar because it's not as
6765 wide as the area reserved for it. This makes sure a
6766 previous mode line display is cleared after C-x 2 C-x 1, for
6769 int area_height
= WINDOW_CONFIG_SCROLL_BAR_HEIGHT (w
);
6770 int rest
= area_height
- height
;
6771 if (rest
> 0 && width
> 0)
6772 x_clear_area (f
, left
, top
, width
, rest
);
6775 /* Move/size the scroll bar window. */
6784 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
6788 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6790 /* Remember new settings. */
6794 bar
->height
= height
;
6799 #ifdef USE_TOOLKIT_SCROLL_BARS
6800 x_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
6801 #else /* not USE_TOOLKIT_SCROLL_BARS */
6802 /* Set the scroll bar's current state, unless we're currently being
6804 if (bar
->dragging
== -1)
6806 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
);
6809 x_scroll_bar_set_handle (bar
, 0, left_range
, false);
6812 int start
= ((double) position
* left_range
) / whole
;
6813 int end
= ((double) (position
+ portion
) * left_range
) / whole
;
6814 x_scroll_bar_set_handle (bar
, start
, end
, false);
6817 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6819 XSETVECTOR (barobj
, bar
);
6820 wset_horizontal_scroll_bar (w
, barobj
);
6824 /* The following three hooks are used when we're doing a thorough
6825 redisplay of the frame. We don't explicitly know which scroll bars
6826 are going to be deleted, because keeping track of when windows go
6827 away is a real pain - "Can you say set-window-configuration, boys
6828 and girls?" Instead, we just assert at the beginning of redisplay
6829 that *all* scroll bars are to be removed, and then save a scroll bar
6830 from the fiery pit when we actually redisplay its window. */
6832 /* Arrange for all scroll bars on FRAME to be removed at the next call
6833 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
6834 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
6837 XTcondemn_scroll_bars (struct frame
*frame
)
6839 if (!NILP (FRAME_SCROLL_BARS (frame
)))
6841 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
6843 /* Prepend scrollbars to already condemned ones. */
6844 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
6846 while (!NILP (XSCROLL_BAR (last
)->next
))
6847 last
= XSCROLL_BAR (last
)->next
;
6849 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
6850 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
6853 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
6854 fset_scroll_bars (frame
, Qnil
);
6859 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
6860 Note that WINDOW isn't necessarily condemned at all. */
6863 XTredeem_scroll_bar (struct window
*w
)
6865 struct scroll_bar
*bar
;
6869 /* We can't redeem this window's scroll bar if it doesn't have one. */
6870 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
6873 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
6875 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
6876 /* Unlink it from the condemned list. */
6877 f
= XFRAME (WINDOW_FRAME (w
));
6878 if (NILP (bar
->prev
))
6880 /* If the prev pointer is nil, it must be the first in one of
6882 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
6883 /* It's not condemned. Everything's fine. */
6885 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
6886 w
->vertical_scroll_bar
))
6887 fset_condemned_scroll_bars (f
, bar
->next
);
6889 /* If its prev pointer is nil, it must be at the front of
6890 one or the other! */
6894 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
6896 if (! NILP (bar
->next
))
6897 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
6899 bar
->next
= FRAME_SCROLL_BARS (f
);
6901 XSETVECTOR (barobj
, bar
);
6902 fset_scroll_bars (f
, barobj
);
6903 if (! NILP (bar
->next
))
6904 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6908 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
6910 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
6911 /* Unlink it from the condemned list. */
6912 f
= XFRAME (WINDOW_FRAME (w
));
6913 if (NILP (bar
->prev
))
6915 /* If the prev pointer is nil, it must be the first in one of
6917 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
6918 /* It's not condemned. Everything's fine. */
6920 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
6921 w
->horizontal_scroll_bar
))
6922 fset_condemned_scroll_bars (f
, bar
->next
);
6924 /* If its prev pointer is nil, it must be at the front of
6925 one or the other! */
6929 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
6931 if (! NILP (bar
->next
))
6932 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
6934 bar
->next
= FRAME_SCROLL_BARS (f
);
6936 XSETVECTOR (barobj
, bar
);
6937 fset_scroll_bars (f
, barobj
);
6938 if (! NILP (bar
->next
))
6939 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6943 /* Remove all scroll bars on FRAME that haven't been saved since the
6944 last call to `*condemn_scroll_bars_hook'. */
6947 XTjudge_scroll_bars (struct frame
*f
)
6949 Lisp_Object bar
, next
;
6951 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
6953 /* Clear out the condemned list now so we won't try to process any
6954 more events on the hapless scroll bars. */
6955 fset_condemned_scroll_bars (f
, Qnil
);
6957 for (; ! NILP (bar
); bar
= next
)
6959 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
6961 x_scroll_bar_remove (b
);
6964 b
->next
= b
->prev
= Qnil
;
6967 /* Now there should be no references to the condemned scroll bars,
6968 and they should get garbage-collected. */
6972 #ifndef USE_TOOLKIT_SCROLL_BARS
6973 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
6974 is a no-op when using toolkit scroll bars.
6976 This may be called from a signal handler, so we have to ignore GC
6980 x_scroll_bar_expose (struct scroll_bar
*bar
, const XEvent
*event
)
6982 Window w
= bar
->x_window
;
6983 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6984 GC gc
= f
->output_data
.x
->normal_gc
;
6988 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, true);
6990 /* Switch to scroll bar foreground color. */
6991 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6992 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6993 f
->output_data
.x
->scroll_bar_foreground_pixel
);
6995 /* Draw a one-pixel border just inside the edges of the scroll bar. */
6996 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
6997 /* x, y, width, height */
6998 0, 0, bar
->width
- 1, bar
->height
- 1);
7000 /* Restore the foreground color of the GC if we changed it above. */
7001 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
7002 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
7003 FRAME_FOREGROUND_PIXEL (f
));
7008 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7010 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
7011 is set to something other than NO_EVENT, it is enqueued.
7013 This may be called from a signal handler, so we have to ignore GC
7018 x_scroll_bar_handle_click (struct scroll_bar
*bar
,
7019 const XEvent
*event
,
7020 struct input_event
*emacs_event
)
7022 if (! WINDOWP (bar
->window
))
7025 emacs_event
->kind
= (bar
->horizontal
7026 ? HORIZONTAL_SCROLL_BAR_CLICK_EVENT
7027 : SCROLL_BAR_CLICK_EVENT
);
7028 emacs_event
->code
= event
->xbutton
.button
- Button1
;
7029 emacs_event
->modifiers
7030 = (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO
7031 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
7032 event
->xbutton
.state
)
7033 | (event
->type
== ButtonRelease
7036 emacs_event
->frame_or_window
= bar
->window
;
7037 emacs_event
->arg
= Qnil
;
7038 emacs_event
->timestamp
= event
->xbutton
.time
;
7039 if (bar
->horizontal
)
7042 = HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
7043 int x
= event
->xbutton
.x
- HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
7046 if (x
> left_range
) x
= left_range
;
7049 emacs_event
->part
= scroll_bar_before_handle
;
7050 else if (x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
7051 emacs_event
->part
= scroll_bar_horizontal_handle
;
7053 emacs_event
->part
= scroll_bar_after_handle
;
7055 #ifndef USE_TOOLKIT_SCROLL_BARS
7056 /* If the user has released the handle, set it to its final position. */
7057 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
7059 int new_start
= - bar
->dragging
;
7060 int new_end
= new_start
+ bar
->end
- bar
->start
;
7062 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
7067 XSETINT (emacs_event
->x
, left_range
);
7068 XSETINT (emacs_event
->y
, x
);
7073 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
7074 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
7077 if (y
> top_range
) y
= top_range
;
7080 emacs_event
->part
= scroll_bar_above_handle
;
7081 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
7082 emacs_event
->part
= scroll_bar_handle
;
7084 emacs_event
->part
= scroll_bar_below_handle
;
7086 #ifndef USE_TOOLKIT_SCROLL_BARS
7087 /* If the user has released the handle, set it to its final position. */
7088 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
7090 int new_start
= y
- bar
->dragging
;
7091 int new_end
= new_start
+ bar
->end
- bar
->start
;
7093 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
7098 XSETINT (emacs_event
->x
, y
);
7099 XSETINT (emacs_event
->y
, top_range
);
7103 #ifndef USE_TOOLKIT_SCROLL_BARS
7105 /* Handle some mouse motion while someone is dragging the scroll bar.
7107 This may be called from a signal handler, so we have to ignore GC
7111 x_scroll_bar_note_movement (struct scroll_bar
*bar
,
7112 const XMotionEvent
*event
)
7114 struct frame
*f
= XFRAME (XWINDOW (bar
->window
)->frame
);
7115 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
7117 dpyinfo
->last_mouse_movement_time
= event
->time
;
7118 dpyinfo
->last_mouse_scroll_bar
= bar
;
7119 f
->mouse_moved
= true;
7121 /* If we're dragging the bar, display it. */
7122 if (bar
->dragging
!= -1)
7124 /* Where should the handle be now? */
7125 int new_start
= event
->y
- bar
->dragging
;
7127 if (new_start
!= bar
->start
)
7129 int new_end
= new_start
+ bar
->end
- bar
->start
;
7131 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
7136 #endif /* !USE_TOOLKIT_SCROLL_BARS */
7138 /* Return information to the user about the current position of the mouse
7139 on the scroll bar. */
7142 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
7143 enum scroll_bar_part
*part
, Lisp_Object
*x
,
7144 Lisp_Object
*y
, Time
*timestamp
)
7146 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
7147 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
7148 Window w
= bar
->x_window
;
7149 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7151 Window dummy_window
;
7153 unsigned int dummy_mask
;
7157 /* Get the mouse's position relative to the scroll bar window, and
7159 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
7161 /* Root, child, root x and root y. */
7162 &dummy_window
, &dummy_window
,
7163 &dummy_coord
, &dummy_coord
,
7165 /* Position relative to scroll bar. */
7168 /* Mouse buttons and modifier keys. */
7171 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
7173 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
7175 if (bar
->dragging
!= -1)
7176 win_y
-= bar
->dragging
;
7180 if (win_y
> top_range
)
7184 *bar_window
= bar
->window
;
7186 if (bar
->dragging
!= -1)
7187 *part
= scroll_bar_handle
;
7188 else if (win_y
< bar
->start
)
7189 *part
= scroll_bar_above_handle
;
7190 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
7191 *part
= scroll_bar_handle
;
7193 *part
= scroll_bar_below_handle
;
7195 XSETINT (*x
, win_y
);
7196 XSETINT (*y
, top_range
);
7198 f
->mouse_moved
= false;
7199 dpyinfo
->last_mouse_scroll_bar
= NULL
;
7200 *timestamp
= dpyinfo
->last_mouse_movement_time
;
7207 /* Return information to the user about the current position of the mouse
7208 on the scroll bar. */
7211 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
7212 enum scroll_bar_part
*part
, Lisp_Object
*x
,
7213 Lisp_Object
*y
, Time
*timestamp
)
7215 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
7216 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
7217 Window w
= bar
->x_window
;
7218 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7220 Window dummy_window
;
7222 unsigned int dummy_mask
;
7226 /* Get the mouse's position relative to the scroll bar window, and
7228 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
7230 /* Root, child, root x and root y. */
7231 &dummy_window
, &dummy_window
,
7232 &dummy_coord
, &dummy_coord
,
7234 /* Position relative to scroll bar. */
7237 /* Mouse buttons and modifier keys. */
7240 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
7242 win_x
-= HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
7244 if (bar
->dragging
!= -1)
7245 win_x
-= bar
->dragging
;
7249 if (win_x
> left_range
)
7253 *bar_window
= bar
->window
;
7255 if (bar
->dragging
!= -1)
7256 *part
= scroll_bar_horizontal_handle
;
7257 else if (win_x
< bar
->start
)
7258 *part
= scroll_bar_before_handle
;
7259 else if (win_x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
7260 *part
= scroll_bar_handle
;
7262 *part
= scroll_bar_after_handle
;
7264 XSETINT (*y
, win_x
);
7265 XSETINT (*x
, left_range
);
7267 f
->mouse_moved
= false;
7268 dpyinfo
->last_mouse_scroll_bar
= NULL
;
7269 *timestamp
= dpyinfo
->last_mouse_movement_time
;
7276 /* The screen has been cleared so we may have changed foreground or
7277 background colors, and the scroll bars may need to be redrawn.
7278 Clear out the scroll bars, and ask for expose events, so we can
7282 x_scroll_bar_clear (struct frame
*f
)
7284 #ifndef USE_TOOLKIT_SCROLL_BARS
7287 /* We can have scroll bars even if this is 0,
7288 if we just turned off scroll bar mode.
7289 But in that case we should not clear them. */
7290 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
7291 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
7292 bar
= XSCROLL_BAR (bar
)->next
)
7293 XClearArea (FRAME_X_DISPLAY (f
),
7294 XSCROLL_BAR (bar
)->x_window
,
7296 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7299 #ifdef ENABLE_CHECKING
7301 /* Record the last 100 characters stored
7302 to help debug the loss-of-chars-during-GC problem. */
7304 static int temp_index
;
7305 static short temp_buffer
[100];
7307 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
7308 if (temp_index == ARRAYELTS (temp_buffer)) \
7310 temp_buffer[temp_index++] = (keysym)
7312 #else /* not ENABLE_CHECKING */
7314 #define STORE_KEYSYM_FOR_DEBUG(keysym) ((void)0)
7316 #endif /* ENABLE_CHECKING */
7318 /* Set this to nonzero to fake an "X I/O error"
7319 on a particular display. */
7321 static struct x_display_info
*XTread_socket_fake_io_error
;
7323 /* When we find no input here, we occasionally do a no-op command
7324 to verify that the X server is still running and we can still talk with it.
7325 We try all the open displays, one by one.
7326 This variable is used for cycling thru the displays. */
7328 static struct x_display_info
*next_noop_dpyinfo
;
7337 /* Filter events for the current X input method.
7338 DPYINFO is the display this event is for.
7339 EVENT is the X event to filter.
7341 Returns non-zero if the event was filtered, caller shall not process
7343 Returns zero if event is wasn't filtered. */
7347 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
7349 /* XFilterEvent returns non-zero if the input method has
7350 consumed the event. We pass the frame's X window to
7351 XFilterEvent because that's the one for which the IC
7354 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
7355 event
->xclient
.window
);
7357 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
7362 static int current_count
;
7363 static int current_finish
;
7364 static struct input_event
*current_hold_quit
;
7366 /* This is the filter function invoked by the GTK event loop.
7367 It is invoked before the XEvent is translated to a GdkEvent,
7368 so we have a chance to act on the event before GTK. */
7369 static GdkFilterReturn
7370 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
7372 XEvent
*xev
= (XEvent
*) gxev
;
7375 if (current_count
>= 0)
7377 struct x_display_info
*dpyinfo
;
7379 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
7382 /* Filter events for the current X input method.
7383 GTK calls XFilterEvent but not for key press and release,
7384 so we do it here. */
7385 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
7387 && x_filter_event (dpyinfo
, xev
))
7390 return GDK_FILTER_REMOVE
;
7395 current_finish
= X_EVENT_NORMAL
;
7398 += handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
7402 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
7406 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
7407 return GDK_FILTER_REMOVE
;
7409 return GDK_FILTER_CONTINUE
;
7411 #endif /* USE_GTK */
7414 static void xembed_send_message (struct frame
*f
, Time
,
7415 enum xembed_message
,
7416 long detail
, long data1
, long data2
);
7419 x_net_wm_state (struct frame
*f
, Window window
)
7421 int value
= FULLSCREEN_NONE
;
7422 Lisp_Object lval
= Qnil
;
7423 bool sticky
= false;
7425 get_current_wm_state (f
, window
, &value
, &sticky
);
7429 case FULLSCREEN_WIDTH
:
7432 case FULLSCREEN_HEIGHT
:
7435 case FULLSCREEN_BOTH
:
7438 case FULLSCREEN_MAXIMIZED
:
7443 frame_size_history_add
7444 (f
, Qx_net_wm_state
, 0, 0,
7445 list2 (get_frame_param (f
, Qfullscreen
), lval
));
7447 store_frame_param (f
, Qfullscreen
, lval
);
7448 /** store_frame_param (f, Qsticky, sticky ? Qt : Qnil); **/
7451 /* Handles the XEvent EVENT on display DPYINFO.
7453 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
7454 *FINISH is zero if caller should continue reading events.
7455 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
7456 *EVENT is unchanged unless we're processing KeyPress event.
7458 We return the number of characters stored into the buffer. */
7461 handle_one_xevent (struct x_display_info
*dpyinfo
,
7462 const XEvent
*event
,
7463 int *finish
, struct input_event
*hold_quit
)
7465 union buffered_input_event inev
;
7468 ptrdiff_t nbytes
= 0;
7469 struct frame
*any
, *f
= NULL
;
7470 struct coding_system coding
;
7471 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
7472 /* This holds the state XLookupString needs to implement dead keys
7473 and other tricks known as "compose processing". _X Window System_
7474 says that a portable program can't use this, but Stephen Gildea assures
7475 me that letting the compiler initialize it to zeros will work okay. */
7476 static XComposeStatus compose_status
;
7477 XEvent configureEvent
;
7482 *finish
= X_EVENT_NORMAL
;
7484 EVENT_INIT (inev
.ie
);
7485 inev
.ie
.kind
= NO_EVENT
;
7488 any
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
7490 if (any
&& any
->wait_event_type
== event
->type
)
7491 any
->wait_event_type
= 0; /* Indicates we got it. */
7493 switch (event
->type
)
7497 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_protocols
7498 && event
->xclient
.format
== 32)
7500 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_take_focus
)
7502 /* Use the value returned by x_any_window_to_frame
7503 because this could be the shell widget window
7504 if the frame has no title bar. */
7507 /* Not quite sure this is needed -pd */
7508 if (f
&& FRAME_XIC (f
))
7509 XSetICFocus (FRAME_XIC (f
));
7512 /* Emacs sets WM hints whose `input' field is `true'. This
7513 instructs the WM to set the input focus automatically for
7514 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
7515 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
7516 it has set the focus. So, XSetInputFocus below is not
7519 The call to XSetInputFocus below has also caused trouble. In
7520 cases where the XSetInputFocus done by the WM and the one
7521 below are temporally close (on a fast machine), the call
7522 below can generate additional FocusIn events which confuse
7525 /* Since we set WM_TAKE_FOCUS, we must call
7526 XSetInputFocus explicitly. But not if f is null,
7527 since that might be an event for a deleted frame. */
7530 Display
*d
= event
->xclient
.display
;
7531 /* Catch and ignore errors, in case window has been
7532 iconified by a window manager such as GWM. */
7534 XSetInputFocus (d
, event
->xclient
.window
,
7535 /* The ICCCM says this is
7536 the only valid choice. */
7538 event
->xclient
.data
.l
[1]);
7539 x_uncatch_errors ();
7541 /* Not certain about handling scroll bars here */
7546 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_save_yourself
)
7548 /* Save state modify the WM_COMMAND property to
7549 something which can reinstate us. This notifies
7550 the session manager, who's looking for such a
7551 PropertyNotify. Can restart processing when
7552 a keyboard or mouse event arrives. */
7553 /* If we have a session manager, don't set this.
7554 KDE will then start two Emacsen, one for the
7555 session manager and one for this. */
7557 if (! x_session_have_connection ())
7560 f
= x_top_window_to_frame (dpyinfo
,
7561 event
->xclient
.window
);
7562 /* This is just so we only give real data once
7563 for a single Emacs process. */
7564 if (f
== SELECTED_FRAME ())
7565 XSetCommand (FRAME_X_DISPLAY (f
),
7566 event
->xclient
.window
,
7567 initial_argv
, initial_argc
);
7569 XSetCommand (FRAME_X_DISPLAY (f
),
7570 event
->xclient
.window
,
7576 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_delete_window
)
7580 goto OTHER
; /* May be a dialog that is to be removed */
7582 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
7583 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7590 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_configure_denied
)
7593 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_window_moved
)
7596 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
7598 new_x
= event
->xclient
.data
.s
[0];
7599 new_y
= event
->xclient
.data
.s
[1];
7603 f
->left_pos
= new_x
;
7610 if (event
->xclient
.message_type
== dpyinfo
->Xatom_editres
)
7614 _XEditResCheckMessages (f
->output_data
.x
->widget
,
7615 NULL
, (XEvent
*) event
, NULL
);
7618 #endif /* HACK_EDITRES */
7620 if (event
->xclient
.message_type
== dpyinfo
->Xatom_DONE
7621 || event
->xclient
.message_type
== dpyinfo
->Xatom_PAGE
)
7623 /* Ghostview job completed. Kill it. We could
7624 reply with "Next" if we received "Page", but we
7625 currently never do because we are interested in
7626 images, only, which should have 1 page. */
7627 Pixmap pixmap
= (Pixmap
) event
->xclient
.data
.l
[1];
7628 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
7631 x_kill_gs_process (pixmap
, f
);
7632 expose_frame (f
, 0, 0, 0, 0);
7636 #ifdef USE_TOOLKIT_SCROLL_BARS
7637 /* Scroll bar callbacks send a ClientMessage from which
7638 we construct an input_event. */
7639 if (event
->xclient
.message_type
== dpyinfo
->Xatom_Scrollbar
)
7641 x_scroll_bar_to_input_event (event
, &inev
.ie
);
7642 *finish
= X_EVENT_GOTO_OUT
;
7645 else if (event
->xclient
.message_type
== dpyinfo
->Xatom_Horizontal_Scrollbar
)
7647 x_horizontal_scroll_bar_to_input_event (event
, &inev
.ie
);
7648 *finish
= X_EVENT_GOTO_OUT
;
7651 #endif /* USE_TOOLKIT_SCROLL_BARS */
7653 /* XEmbed messages from the embedder (if any). */
7654 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
7656 enum xembed_message msg
= event
->xclient
.data
.l
[1];
7657 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
7658 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7660 *finish
= X_EVENT_GOTO_OUT
;
7664 xft_settings_event (dpyinfo
, event
);
7669 if (x_handle_dnd_message (f
, &event
->xclient
, dpyinfo
, &inev
.ie
))
7670 *finish
= X_EVENT_DROP
;
7674 case SelectionNotify
:
7675 x_display_set_last_user_time (dpyinfo
, event
->xselection
.time
);
7676 #ifdef USE_X_TOOLKIT
7677 if (! x_window_to_frame (dpyinfo
, event
->xselection
.requestor
))
7679 #endif /* not USE_X_TOOLKIT */
7680 x_handle_selection_notify (&event
->xselection
);
7683 case SelectionClear
: /* Someone has grabbed ownership. */
7684 x_display_set_last_user_time (dpyinfo
, event
->xselectionclear
.time
);
7685 #ifdef USE_X_TOOLKIT
7686 if (! x_window_to_frame (dpyinfo
, event
->xselectionclear
.window
))
7688 #endif /* USE_X_TOOLKIT */
7690 const XSelectionClearEvent
*eventp
= &event
->xselectionclear
;
7692 inev
.sie
.kind
= SELECTION_CLEAR_EVENT
;
7693 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
7694 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
7695 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
7699 case SelectionRequest
: /* Someone wants our selection. */
7700 x_display_set_last_user_time (dpyinfo
, event
->xselectionrequest
.time
);
7701 #ifdef USE_X_TOOLKIT
7702 if (!x_window_to_frame (dpyinfo
, event
->xselectionrequest
.owner
))
7704 #endif /* USE_X_TOOLKIT */
7706 const XSelectionRequestEvent
*eventp
= &event
->xselectionrequest
;
7708 inev
.sie
.kind
= SELECTION_REQUEST_EVENT
;
7709 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
7710 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
7711 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
7712 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
7713 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
7714 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
7718 case PropertyNotify
:
7719 x_display_set_last_user_time (dpyinfo
, event
->xproperty
.time
);
7720 f
= x_top_window_to_frame (dpyinfo
, event
->xproperty
.window
);
7721 if (f
&& event
->xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
7723 bool not_hidden
= x_handle_net_wm_state (f
, &event
->xproperty
);
7724 if (not_hidden
&& FRAME_ICONIFIED_P (f
))
7726 /* Gnome shell does not iconify us when C-z is pressed.
7727 It hides the frame. So if our state says we aren't
7728 hidden anymore, treat it as deiconified. */
7729 SET_FRAME_VISIBLE (f
, 1);
7730 SET_FRAME_ICONIFIED (f
, false);
7731 f
->output_data
.x
->has_been_visible
= true;
7732 inev
.ie
.kind
= DEICONIFY_EVENT
;
7733 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7735 else if (! not_hidden
&& ! FRAME_ICONIFIED_P (f
))
7737 SET_FRAME_VISIBLE (f
, 0);
7738 SET_FRAME_ICONIFIED (f
, true);
7739 inev
.ie
.kind
= ICONIFY_EVENT
;
7740 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7744 x_handle_property_notify (&event
->xproperty
);
7745 xft_settings_event (dpyinfo
, event
);
7748 case ReparentNotify
:
7749 f
= x_top_window_to_frame (dpyinfo
, event
->xreparent
.window
);
7752 f
->output_data
.x
->parent_desc
= event
->xreparent
.parent
;
7753 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
7755 /* Perhaps reparented due to a WM restart. Reset this. */
7756 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
7757 FRAME_DISPLAY_INFO (f
)->net_supported_window
= 0;
7759 x_set_frame_alpha (f
);
7764 f
= x_window_to_frame (dpyinfo
, event
->xexpose
.window
);
7767 if (!FRAME_VISIBLE_P (f
))
7769 SET_FRAME_VISIBLE (f
, 1);
7770 SET_FRAME_ICONIFIED (f
, false);
7771 f
->output_data
.x
->has_been_visible
= true;
7772 SET_FRAME_GARBAGED (f
);
7777 /* This seems to be needed for GTK 2.6 and later, see
7778 http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15398. */
7780 event
->xexpose
.x
, event
->xexpose
.y
,
7781 event
->xexpose
.width
, event
->xexpose
.height
);
7783 expose_frame (f
, event
->xexpose
.x
, event
->xexpose
.y
,
7784 event
->xexpose
.width
, event
->xexpose
.height
);
7789 #ifndef USE_TOOLKIT_SCROLL_BARS
7790 struct scroll_bar
*bar
;
7792 #if defined USE_LUCID
7793 /* Submenus of the Lucid menu bar aren't widgets
7794 themselves, so there's no way to dispatch events
7795 to them. Recognize this case separately. */
7797 Widget widget
= x_window_to_menu_bar (event
->xexpose
.window
);
7799 xlwmenu_redisplay (widget
);
7801 #endif /* USE_LUCID */
7803 #ifdef USE_TOOLKIT_SCROLL_BARS
7804 /* Dispatch event to the widget. */
7806 #else /* not USE_TOOLKIT_SCROLL_BARS */
7807 bar
= x_window_to_scroll_bar (event
->xexpose
.display
,
7808 event
->xexpose
.window
, 2);
7811 x_scroll_bar_expose (bar
, event
);
7812 #ifdef USE_X_TOOLKIT
7815 #endif /* USE_X_TOOLKIT */
7816 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7820 case GraphicsExpose
: /* This occurs when an XCopyArea's
7821 source area was obscured or not
7823 f
= x_window_to_frame (dpyinfo
, event
->xgraphicsexpose
.drawable
);
7825 expose_frame (f
, event
->xgraphicsexpose
.x
,
7826 event
->xgraphicsexpose
.y
,
7827 event
->xgraphicsexpose
.width
,
7828 event
->xgraphicsexpose
.height
);
7829 #ifdef USE_X_TOOLKIT
7832 #endif /* USE_X_TOOLKIT */
7835 case NoExpose
: /* This occurs when an XCopyArea's
7836 source area was completely
7841 /* Redo the mouse-highlight after the tooltip has gone. */
7842 if (event
->xunmap
.window
== tip_window
)
7845 x_redo_mouse_highlight (dpyinfo
);
7848 f
= x_top_window_to_frame (dpyinfo
, event
->xunmap
.window
);
7849 if (f
) /* F may no longer exist if
7850 the frame was deleted. */
7852 bool visible
= FRAME_VISIBLE_P (f
);
7853 /* While a frame is unmapped, display generation is
7854 disabled; you don't want to spend time updating a
7855 display that won't ever be seen. */
7856 SET_FRAME_VISIBLE (f
, 0);
7857 /* We can't distinguish, from the event, whether the window
7858 has become iconified or invisible. So assume, if it
7859 was previously visible, than now it is iconified.
7860 But x_make_frame_invisible clears both
7861 the visible flag and the iconified flag;
7862 and that way, we know the window is not iconified now. */
7863 if (visible
|| FRAME_ICONIFIED_P (f
))
7865 SET_FRAME_ICONIFIED (f
, true);
7866 inev
.ie
.kind
= ICONIFY_EVENT
;
7867 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7873 /* We use x_top_window_to_frame because map events can
7874 come for sub-windows and they don't mean that the
7875 frame is visible. */
7876 f
= x_top_window_to_frame (dpyinfo
, event
->xmap
.window
);
7879 bool iconified
= FRAME_ICONIFIED_P (f
);
7881 /* Check if fullscreen was specified before we where mapped the
7882 first time, i.e. from the command line. */
7883 if (!f
->output_data
.x
->has_been_visible
)
7884 x_check_fullscreen (f
);
7886 SET_FRAME_VISIBLE (f
, 1);
7887 SET_FRAME_ICONIFIED (f
, false);
7888 f
->output_data
.x
->has_been_visible
= true;
7892 inev
.ie
.kind
= DEICONIFY_EVENT
;
7893 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7895 else if (! NILP (Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
7896 /* Force a redisplay sooner or later to update the
7897 frame titles in case this is the second frame. */
7898 record_asynch_buffer_change ();
7901 xg_frame_resized (f
, -1, -1);
7908 x_display_set_last_user_time (dpyinfo
, event
->xkey
.time
);
7909 ignore_next_mouse_click_timeout
= 0;
7911 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
7912 /* Dispatch KeyPress events when in menu. */
7913 if (popup_activated ())
7919 /* If mouse-highlight is an integer, input clears out
7920 mouse highlighting. */
7921 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
7922 #if ! defined (USE_GTK)
7924 || !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
7928 clear_mouse_face (hlinfo
);
7929 hlinfo
->mouse_face_hidden
= true;
7932 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
7935 /* Scroll bars consume key events, but we want
7936 the keys to go to the scroll bar's frame. */
7937 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
7938 event
->xkey
.window
);
7939 if (widget
&& XmIsScrollBar (widget
))
7941 widget
= XtParent (widget
);
7942 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
7945 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
7949 KeySym keysym
, orig_keysym
;
7950 /* al%imercury@uunet.uu.net says that making this 81
7951 instead of 80 fixed a bug whereby meta chars made
7954 It seems that some version of XmbLookupString has
7955 a bug of not returning XBufferOverflow in
7956 status_return even if the input is too long to
7957 fit in 81 bytes. So, we must prepare sufficient
7958 bytes for copy_buffer. 513 bytes (256 chars for
7959 two-byte character set) seems to be a fairly good
7960 approximation. -- 2000.8.10 handa@etl.go.jp */
7961 unsigned char copy_buffer
[513];
7962 unsigned char *copy_bufptr
= copy_buffer
;
7963 int copy_bufsiz
= sizeof (copy_buffer
);
7965 Lisp_Object coding_system
= Qlatin_1
;
7967 /* Event will be modified. */
7968 XKeyEvent xkey
= event
->xkey
;
7971 /* Don't pass keys to GTK. A Tab will shift focus to the
7972 tool bar in GTK 2.4. Keys will still go to menus and
7973 dialogs because in that case popup_activated is nonzero
7975 *finish
= X_EVENT_DROP
;
7978 xkey
.state
|= x_emacs_to_x_modifiers (FRAME_DISPLAY_INFO (f
),
7979 extra_keyboard_modifiers
);
7980 modifiers
= xkey
.state
;
7982 /* This will have to go some day... */
7984 /* make_lispy_event turns chars into control chars.
7985 Don't do it here because XLookupString is too eager. */
7986 xkey
.state
&= ~ControlMask
;
7987 xkey
.state
&= ~(dpyinfo
->meta_mod_mask
7988 | dpyinfo
->super_mod_mask
7989 | dpyinfo
->hyper_mod_mask
7990 | dpyinfo
->alt_mod_mask
);
7992 /* In case Meta is ComposeCharacter,
7993 clear its status. According to Markus Ehrnsperger
7994 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
7995 this enables ComposeCharacter to work whether or
7996 not it is combined with Meta. */
7997 if (modifiers
& dpyinfo
->meta_mod_mask
)
7998 memset (&compose_status
, 0, sizeof (compose_status
));
8003 Status status_return
;
8005 coding_system
= Vlocale_coding_system
;
8006 nbytes
= XmbLookupString (FRAME_XIC (f
),
8007 &xkey
, (char *) copy_bufptr
,
8008 copy_bufsiz
, &keysym
,
8010 if (status_return
== XBufferOverflow
)
8012 copy_bufsiz
= nbytes
+ 1;
8013 copy_bufptr
= alloca (copy_bufsiz
);
8014 nbytes
= XmbLookupString (FRAME_XIC (f
),
8015 &xkey
, (char *) copy_bufptr
,
8016 copy_bufsiz
, &keysym
,
8019 /* Xutf8LookupString is a new but already deprecated interface. -stef */
8020 if (status_return
== XLookupNone
)
8022 else if (status_return
== XLookupChars
)
8027 else if (status_return
!= XLookupKeySym
8028 && status_return
!= XLookupBoth
)
8032 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
8033 copy_bufsiz
, &keysym
,
8036 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
8037 copy_bufsiz
, &keysym
,
8041 /* If not using XIM/XIC, and a compose sequence is in progress,
8042 we break here. Otherwise, chars_matched is always 0. */
8043 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
8046 memset (&compose_status
, 0, sizeof (compose_status
));
8047 orig_keysym
= keysym
;
8049 /* Common for all keysym input events. */
8050 XSETFRAME (inev
.ie
.frame_or_window
, f
);
8052 = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), modifiers
);
8053 inev
.ie
.timestamp
= xkey
.time
;
8055 /* First deal with keysyms which have defined
8056 translations to characters. */
8057 if (keysym
>= 32 && keysym
< 128)
8058 /* Avoid explicitly decoding each ASCII character. */
8060 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
8061 inev
.ie
.code
= keysym
;
8065 /* Keysyms directly mapped to Unicode characters. */
8066 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
8068 if (keysym
< 0x01000080)
8069 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
8071 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
8072 inev
.ie
.code
= keysym
& 0xFFFFFF;
8076 /* Now non-ASCII. */
8077 if (HASH_TABLE_P (Vx_keysym_table
)
8078 && (c
= Fgethash (make_number (keysym
),
8083 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
8084 ? ASCII_KEYSTROKE_EVENT
8085 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
8086 inev
.ie
.code
= XFASTINT (c
);
8090 /* Random non-modifier sorts of keysyms. */
8091 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
8092 || keysym
== XK_Delete
8093 #ifdef XK_ISO_Left_Tab
8094 || (keysym
>= XK_ISO_Left_Tab
8095 && keysym
<= XK_ISO_Enter
)
8097 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
8098 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
8100 /* This recognizes the "extended function
8101 keys". It seems there's no cleaner way.
8102 Test IsModifierKey to avoid handling
8103 mode_switch incorrectly. */
8104 || (XK_Select
<= keysym
&& keysym
< XK_KP_Space
)
8106 #ifdef XK_dead_circumflex
8107 || orig_keysym
== XK_dead_circumflex
8109 #ifdef XK_dead_grave
8110 || orig_keysym
== XK_dead_grave
8112 #ifdef XK_dead_tilde
8113 || orig_keysym
== XK_dead_tilde
8115 #ifdef XK_dead_diaeresis
8116 || orig_keysym
== XK_dead_diaeresis
8118 #ifdef XK_dead_macron
8119 || orig_keysym
== XK_dead_macron
8121 #ifdef XK_dead_degree
8122 || orig_keysym
== XK_dead_degree
8124 #ifdef XK_dead_acute
8125 || orig_keysym
== XK_dead_acute
8127 #ifdef XK_dead_cedilla
8128 || orig_keysym
== XK_dead_cedilla
8130 #ifdef XK_dead_breve
8131 || orig_keysym
== XK_dead_breve
8133 #ifdef XK_dead_ogonek
8134 || orig_keysym
== XK_dead_ogonek
8136 #ifdef XK_dead_caron
8137 || orig_keysym
== XK_dead_caron
8139 #ifdef XK_dead_doubleacute
8140 || orig_keysym
== XK_dead_doubleacute
8142 #ifdef XK_dead_abovedot
8143 || orig_keysym
== XK_dead_abovedot
8145 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
8146 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
8147 /* Any "vendor-specific" key is ok. */
8148 || (orig_keysym
& (1 << 28))
8149 || (keysym
!= NoSymbol
&& nbytes
== 0))
8150 && ! (IsModifierKey (orig_keysym
)
8151 /* The symbols from XK_ISO_Lock
8152 to XK_ISO_Last_Group_Lock
8153 don't have real modifiers but
8154 should be treated similarly to
8155 Mode_switch by Emacs. */
8156 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
8157 || (XK_ISO_Lock
<= orig_keysym
8158 && orig_keysym
<= XK_ISO_Last_Group_Lock
)
8162 STORE_KEYSYM_FOR_DEBUG (keysym
);
8163 /* make_lispy_event will convert this to a symbolic
8165 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
8166 inev
.ie
.code
= keysym
;
8170 { /* Raw bytes, not keysym. */
8174 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
8176 if (ASCII_CHAR_P (copy_bufptr
[i
]))
8178 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
8181 if (nchars
< nbytes
)
8183 /* Decode the input data. */
8185 /* The input should be decoded with `coding_system'
8186 which depends on which X*LookupString function
8187 we used just above and the locale. */
8188 setup_coding_system (coding_system
, &coding
);
8189 coding
.src_multibyte
= false;
8190 coding
.dst_multibyte
= true;
8191 /* The input is converted to events, thus we can't
8192 handle composition. Anyway, there's no XIM that
8193 gives us composition information. */
8194 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
8196 SAFE_NALLOCA (coding
.destination
, MAX_MULTIBYTE_LENGTH
,
8198 coding
.dst_bytes
= MAX_MULTIBYTE_LENGTH
* nbytes
;
8199 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8200 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
8201 nbytes
= coding
.produced
;
8202 nchars
= coding
.produced_char
;
8203 copy_bufptr
= coding
.destination
;
8206 /* Convert the input data to a sequence of
8207 character events. */
8208 for (i
= 0; i
< nbytes
; i
+= len
)
8211 if (nchars
== nbytes
)
8212 ch
= copy_bufptr
[i
], len
= 1;
8214 ch
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
8215 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (ch
)
8216 ? ASCII_KEYSTROKE_EVENT
8217 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
8219 kbd_buffer_store_buffered_event (&inev
, hold_quit
);
8224 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
8226 if (keysym
== NoSymbol
)
8229 /* FIXME: check side effects and remove this. */
8230 ((XEvent
*) event
)->xkey
= xkey
;
8234 /* Don't dispatch this event since XtDispatchEvent calls
8235 XFilterEvent, and two calls in a row may freeze the
8243 x_display_set_last_user_time (dpyinfo
, event
->xkey
.time
);
8245 /* Don't dispatch this event since XtDispatchEvent calls
8246 XFilterEvent, and two calls in a row may freeze the
8254 x_display_set_last_user_time (dpyinfo
, event
->xcrossing
.time
);
8255 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8259 if (f
&& x_mouse_click_focus_ignore_position
)
8260 ignore_next_mouse_click_timeout
= event
->xmotion
.time
+ 200;
8262 /* EnterNotify counts as mouse movement,
8263 so update things that depend on mouse position. */
8264 if (f
&& !f
->output_data
.x
->hourglass_p
)
8265 note_mouse_movement (f
, &event
->xmotion
);
8267 /* We may get an EnterNotify on the buttons in the toolbar. In that
8268 case we moved out of any highlighted area and need to note this. */
8269 if (!f
&& dpyinfo
->last_mouse_glyph_frame
)
8270 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
8275 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8279 x_display_set_last_user_time (dpyinfo
, event
->xcrossing
.time
);
8280 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8282 f
= x_top_window_to_frame (dpyinfo
, event
->xcrossing
.window
);
8285 if (f
== hlinfo
->mouse_face_mouse_frame
)
8287 /* If we move outside the frame, then we're
8288 certainly no longer on any text in the frame. */
8289 clear_mouse_face (hlinfo
);
8290 hlinfo
->mouse_face_mouse_frame
= 0;
8293 /* Generate a nil HELP_EVENT to cancel a help-echo.
8294 Do it only if there's something to cancel.
8295 Otherwise, the startup message is cleared when
8296 the mouse leaves the frame. */
8297 if (any_help_event_p
)
8301 /* See comment in EnterNotify above */
8302 else if (dpyinfo
->last_mouse_glyph_frame
)
8303 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
8308 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8313 x_display_set_last_user_time (dpyinfo
, event
->xmotion
.time
);
8314 previous_help_echo_string
= help_echo_string
;
8315 help_echo_string
= Qnil
;
8317 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
8318 : x_window_to_frame (dpyinfo
, event
->xmotion
.window
));
8320 if (hlinfo
->mouse_face_hidden
)
8322 hlinfo
->mouse_face_hidden
= false;
8323 clear_mouse_face (hlinfo
);
8327 if (f
&& xg_event_is_for_scrollbar (f
, event
))
8333 /* Generate SELECT_WINDOW_EVENTs when needed.
8334 Don't let popup menus influence things (bug#1261). */
8335 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
8337 static Lisp_Object last_mouse_window
;
8338 Lisp_Object window
= window_from_coordinates
8339 (f
, event
->xmotion
.x
, event
->xmotion
.y
, 0, false);
8341 /* Window will be selected only when it is not selected now and
8342 last mouse movement event was not in it. Minibuffer window
8343 will be selected only when it is active. */
8344 if (WINDOWP (window
)
8345 && !EQ (window
, last_mouse_window
)
8346 && !EQ (window
, selected_window
)
8347 /* For click-to-focus window managers
8348 create event iff we don't leave the
8350 && (focus_follows_mouse
8351 || (EQ (XWINDOW (window
)->frame
,
8352 XWINDOW (selected_window
)->frame
))))
8354 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
8355 inev
.ie
.frame_or_window
= window
;
8357 /* Remember the last window where we saw the mouse. */
8358 last_mouse_window
= window
;
8360 if (!note_mouse_movement (f
, &event
->xmotion
))
8361 help_echo_string
= previous_help_echo_string
;
8365 #ifndef USE_TOOLKIT_SCROLL_BARS
8366 struct scroll_bar
*bar
8367 = x_window_to_scroll_bar (event
->xmotion
.display
,
8368 event
->xmotion
.window
, 2);
8371 x_scroll_bar_note_movement (bar
, &event
->xmotion
);
8372 #endif /* USE_TOOLKIT_SCROLL_BARS */
8374 /* If we move outside the frame, then we're
8375 certainly no longer on any text in the frame. */
8376 clear_mouse_face (hlinfo
);
8379 /* If the contents of the global variable help_echo_string
8380 has changed, generate a HELP_EVENT. */
8381 if (!NILP (help_echo_string
)
8382 || !NILP (previous_help_echo_string
))
8387 case ConfigureNotify
:
8388 /* An opaque move can generate a stream of events as the window
8389 is dragged around. If the connection round trip time isn't
8390 really short, they may come faster than we can respond to
8391 them, given the multiple queries we can do to check window
8392 manager state, translate coordinates, etc.
8394 So if this ConfigureNotify is immediately followed by another
8395 for the same window, use the info from the latest update, and
8396 consider the events all handled. */
8397 /* Opaque resize may be trickier; ConfigureNotify events are
8398 mixed with Expose events for multiple windows. */
8399 configureEvent
= *event
;
8400 while (XPending (dpyinfo
->display
))
8402 XNextEvent (dpyinfo
->display
, &next_event
);
8403 if (next_event
.type
!= ConfigureNotify
8404 || next_event
.xconfigure
.window
!= event
->xconfigure
.window
8405 /* Skipping events with different sizes can lead to a
8406 mispositioned mode line at initial window creation.
8407 Only drop window motion events for now. */
8408 || next_event
.xconfigure
.width
!= event
->xconfigure
.width
8409 || next_event
.xconfigure
.height
!= event
->xconfigure
.height
)
8411 XPutBackEvent (dpyinfo
->display
, &next_event
);
8415 configureEvent
= next_event
;
8417 f
= x_top_window_to_frame (dpyinfo
, configureEvent
.xconfigure
.window
);
8419 if (f
) x_cr_destroy_surface (f
);
8424 && configureEvent
.xconfigure
.window
== FRAME_X_WINDOW (f
))
8426 xg_frame_resized (f
, configureEvent
.xconfigure
.width
,
8427 configureEvent
.xconfigure
.height
);
8429 x_cr_destroy_surface (f
);
8436 x_net_wm_state (f
, configureEvent
.xconfigure
.window
);
8438 #ifdef USE_X_TOOLKIT
8439 /* Tip frames are pure X window, set size for them. */
8440 if (! NILP (tip_frame
) && XFRAME (tip_frame
) == f
)
8442 if (FRAME_PIXEL_HEIGHT (f
) != configureEvent
.xconfigure
.height
8443 || FRAME_PIXEL_WIDTH (f
) != configureEvent
.xconfigure
.width
)
8444 SET_FRAME_GARBAGED (f
);
8445 FRAME_PIXEL_HEIGHT (f
) = configureEvent
.xconfigure
.height
;
8446 FRAME_PIXEL_WIDTH (f
) = configureEvent
.xconfigure
.width
;
8450 #ifndef USE_X_TOOLKIT
8453 FRAME_PIXEL_TO_TEXT_WIDTH (f
, configureEvent
.xconfigure
.width
);
8455 FRAME_PIXEL_TO_TEXT_HEIGHT (f
, configureEvent
.xconfigure
.height
);
8457 /* In the toolkit version, change_frame_size
8458 is called by the code that handles resizing
8459 of the EmacsFrame widget. */
8461 /* Even if the number of character rows and columns has
8462 not changed, the font size may have changed, so we need
8463 to check the pixel dimensions as well. */
8464 if (width
!= FRAME_TEXT_WIDTH (f
)
8465 || height
!= FRAME_TEXT_HEIGHT (f
)
8466 || configureEvent
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
8467 || configureEvent
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
8469 change_frame_size (f
, width
, height
, false, true, false, true);
8470 x_clear_under_internal_border (f
);
8471 SET_FRAME_GARBAGED (f
);
8472 cancel_mouse_face (f
);
8474 #endif /* not USE_GTK */
8478 /* GTK creates windows but doesn't map them.
8479 Only get real positions when mapped. */
8480 if (FRAME_GTK_OUTER_WIDGET (f
)
8481 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
8483 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
8486 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
8487 xic_set_statusarea (f
);
8496 /* If we decide we want to generate an event to be seen
8497 by the rest of Emacs, we put it here. */
8498 bool tool_bar_p
= false;
8500 memset (&compose_status
, 0, sizeof (compose_status
));
8501 dpyinfo
->last_mouse_glyph_frame
= NULL
;
8502 x_display_set_last_user_time (dpyinfo
, event
->xbutton
.time
);
8504 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
8505 : x_window_to_frame (dpyinfo
, event
->xbutton
.window
));
8508 if (f
&& xg_event_is_for_scrollbar (f
, event
))
8513 #if ! defined (USE_GTK)
8514 /* Is this in the tool-bar? */
8515 if (WINDOWP (f
->tool_bar_window
)
8516 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
8519 int x
= event
->xbutton
.x
;
8520 int y
= event
->xbutton
.y
;
8522 window
= window_from_coordinates (f
, x
, y
, 0, true);
8523 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
8525 if (tool_bar_p
&& event
->xbutton
.button
< 4)
8526 handle_tool_bar_click
8527 (f
, x
, y
, event
->xbutton
.type
== ButtonPress
,
8528 x_x_to_emacs_modifiers (dpyinfo
, event
->xbutton
.state
));
8530 #endif /* !USE_GTK */
8533 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
8534 if (! popup_activated ())
8537 if (ignore_next_mouse_click_timeout
)
8539 if (event
->type
== ButtonPress
8540 && event
->xbutton
.time
> ignore_next_mouse_click_timeout
)
8542 ignore_next_mouse_click_timeout
= 0;
8543 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
8545 if (event
->type
== ButtonRelease
)
8546 ignore_next_mouse_click_timeout
= 0;
8549 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
8551 if (FRAME_X_EMBEDDED_P (f
))
8552 xembed_send_message (f
, event
->xbutton
.time
,
8553 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
8557 struct scroll_bar
*bar
8558 = x_window_to_scroll_bar (event
->xbutton
.display
,
8559 event
->xbutton
.window
, 2);
8561 #ifdef USE_TOOLKIT_SCROLL_BARS
8562 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
8564 if (bar
&& event
->xbutton
.state
& ControlMask
)
8566 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
8567 *finish
= X_EVENT_DROP
;
8569 #else /* not USE_TOOLKIT_SCROLL_BARS */
8571 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
8572 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8575 if (event
->type
== ButtonPress
)
8577 dpyinfo
->grabbed
|= (1 << event
->xbutton
.button
);
8578 dpyinfo
->last_mouse_frame
= f
;
8579 #if ! defined (USE_GTK)
8580 if (f
&& !tool_bar_p
)
8581 f
->last_tool_bar_item
= -1;
8582 #endif /* not USE_GTK */
8585 dpyinfo
->grabbed
&= ~(1 << event
->xbutton
.button
);
8587 /* Ignore any mouse motion that happened before this event;
8588 any subsequent mouse-movement Emacs events should reflect
8589 only motion after the ButtonPress/Release. */
8591 f
->mouse_moved
= false;
8593 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
8594 f
= x_menubar_window_to_frame (dpyinfo
, event
);
8595 /* For a down-event in the menu bar,
8596 don't pass it to Xt right now.
8597 Instead, save it away
8598 and we will pass it to Xt from kbd_buffer_get_event.
8599 That way, we can run some Lisp code first. */
8600 if (! popup_activated ()
8602 /* Gtk+ menus only react to the first three buttons. */
8603 && event
->xbutton
.button
< 3
8605 && f
&& event
->type
== ButtonPress
8606 /* Verify the event is really within the menu bar
8607 and not just sent to it due to grabbing. */
8608 && event
->xbutton
.x
>= 0
8609 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
8610 && event
->xbutton
.y
>= 0
8611 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
8612 && event
->xbutton
.same_screen
)
8614 if (!f
->output_data
.x
->saved_menu_event
)
8615 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof *event
);
8616 *f
->output_data
.x
->saved_menu_event
= *event
;
8617 inev
.ie
.kind
= MENU_BAR_ACTIVATE_EVENT
;
8618 XSETFRAME (inev
.ie
.frame_or_window
, f
);
8619 *finish
= X_EVENT_DROP
;
8623 #endif /* USE_X_TOOLKIT || USE_GTK */
8627 case CirculateNotify
:
8630 case CirculateRequest
:
8633 case VisibilityNotify
:
8637 /* Someone has changed the keyboard mapping - update the
8639 switch (event
->xmapping
.request
)
8641 case MappingModifier
:
8642 x_find_modifier_meanings (dpyinfo
);
8643 /* This is meant to fall through. */
8644 case MappingKeyboard
:
8645 XRefreshKeyboardMapping ((XMappingEvent
*) &event
->xmapping
);
8650 xft_settings_event (dpyinfo
, event
);
8655 #ifdef USE_X_TOOLKIT
8657 if (*finish
!= X_EVENT_DROP
)
8658 XtDispatchEvent ((XEvent
*) event
);
8660 #endif /* USE_X_TOOLKIT */
8665 if (inev
.ie
.kind
!= NO_EVENT
)
8667 kbd_buffer_store_buffered_event (&inev
, hold_quit
);
8672 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
8677 XSETFRAME (frame
, f
);
8683 any_help_event_p
= true;
8684 gen_help_event (help_echo_string
, frame
, help_echo_window
,
8685 help_echo_object
, help_echo_pos
);
8689 help_echo_string
= Qnil
;
8690 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
8699 /* Handles the XEvent EVENT on display DISPLAY.
8700 This is used for event loops outside the normal event handling,
8701 i.e. looping while a popup menu or a dialog is posted.
8703 Returns the value handle_one_xevent sets in the finish argument. */
8705 x_dispatch_event (XEvent
*event
, Display
*display
)
8707 struct x_display_info
*dpyinfo
;
8708 int finish
= X_EVENT_NORMAL
;
8710 dpyinfo
= x_display_info_for_display (display
);
8713 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
8718 /* Read events coming from the X server.
8719 Return as soon as there are no more events to be read.
8721 Return the number of characters stored into the buffer,
8722 thus pretending to be `read' (except the characters we store
8723 in the keyboard buffer can be multibyte, so are not necessarily
8727 XTread_socket (struct terminal
*terminal
, struct input_event
*hold_quit
)
8730 bool event_found
= false;
8731 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
8735 /* For debugging, this gives a way to fake an I/O error. */
8736 if (dpyinfo
== XTread_socket_fake_io_error
)
8738 XTread_socket_fake_io_error
= 0;
8739 x_io_error_quitter (dpyinfo
->display
);
8743 while (XPending (dpyinfo
->display
))
8748 XNextEvent (dpyinfo
->display
, &event
);
8751 /* Filter events for the current X input method. */
8752 if (x_filter_event (dpyinfo
, &event
))
8757 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
8759 if (finish
== X_EVENT_GOTO_OUT
)
8765 /* For GTK we must use the GTK event loop. But XEvents gets passed
8766 to our filter function above, and then to the big event switch.
8767 We use a bunch of globals to communicate with our filter function,
8768 that is kind of ugly, but it works.
8770 There is no way to do one display at the time, GTK just does events
8771 from all displays. */
8773 while (gtk_events_pending ())
8775 current_count
= count
;
8776 current_hold_quit
= hold_quit
;
8778 gtk_main_iteration ();
8780 count
= current_count
;
8782 current_hold_quit
= 0;
8784 if (current_finish
== X_EVENT_GOTO_OUT
)
8787 #endif /* USE_GTK */
8789 /* On some systems, an X bug causes Emacs to get no more events
8790 when the window is destroyed. Detect that. (1994.) */
8793 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
8794 One XNOOP in 100 loops will make Emacs terminate.
8795 B. Bretthauer, 1994 */
8797 if (x_noop_count
>= 100)
8801 if (next_noop_dpyinfo
== 0)
8802 next_noop_dpyinfo
= x_display_list
;
8804 XNoOp (next_noop_dpyinfo
->display
);
8806 /* Each time we get here, cycle through the displays now open. */
8807 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
8811 /* If the focus was just given to an auto-raising frame,
8812 raise it now. FIXME: handle more than one such frame. */
8813 if (dpyinfo
->x_pending_autoraise_frame
)
8815 x_raise_frame (dpyinfo
->x_pending_autoraise_frame
);
8816 dpyinfo
->x_pending_autoraise_frame
= NULL
;
8827 /***********************************************************************
8829 ***********************************************************************/
8831 /* Set clipping for output in glyph row ROW. W is the window in which
8832 we operate. GC is the graphics context to set clipping in.
8834 ROW may be a text row or, e.g., a mode line. Text rows must be
8835 clipped to the interior of the window dedicated to text display,
8836 mode lines must be clipped to the whole window. */
8839 x_clip_to_row (struct window
*w
, struct glyph_row
*row
,
8840 enum glyph_row_area area
, GC gc
)
8842 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8843 XRectangle clip_rect
;
8844 int window_x
, window_y
, window_width
;
8846 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
8848 clip_rect
.x
= window_x
;
8849 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
8850 clip_rect
.y
= max (clip_rect
.y
, window_y
);
8851 clip_rect
.width
= window_width
;
8852 clip_rect
.height
= row
->visible_height
;
8854 x_set_clip_rectangles (f
, gc
, &clip_rect
, 1);
8858 /* Draw a hollow box cursor on window W in glyph row ROW. */
8861 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
8863 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8864 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8865 Display
*dpy
= FRAME_X_DISPLAY (f
);
8868 struct glyph
*cursor_glyph
;
8871 /* Get the glyph the cursor is on. If we can't tell because
8872 the current matrix is invalid or such, give up. */
8873 cursor_glyph
= get_phys_cursor_glyph (w
);
8874 if (cursor_glyph
== NULL
)
8877 /* Compute frame-relative coordinates for phys cursor. */
8878 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
8879 wd
= w
->phys_cursor_width
- 1;
8881 /* The foreground of cursor_gc is typically the same as the normal
8882 background color, which can cause the cursor box to be invisible. */
8883 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
8884 if (dpyinfo
->scratch_cursor_gc
)
8885 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
8887 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
8888 GCForeground
, &xgcv
);
8889 gc
= dpyinfo
->scratch_cursor_gc
;
8891 /* When on R2L character, show cursor at the right edge of the
8892 glyph, unless the cursor box is as wide as the glyph or wider
8893 (the latter happens when x-stretch-cursor is non-nil). */
8894 if ((cursor_glyph
->resolved_level
& 1) != 0
8895 && cursor_glyph
->pixel_width
> wd
)
8897 x
+= cursor_glyph
->pixel_width
- wd
;
8901 /* Set clipping, draw the rectangle, and reset clipping again. */
8902 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
8903 x_draw_rectangle (f
, gc
, x
, y
, wd
, h
- 1);
8904 x_reset_clip_rectangles (f
, gc
);
8908 /* Draw a bar cursor on window W in glyph row ROW.
8910 Implementation note: One would like to draw a bar cursor with an
8911 angle equal to the one given by the font property XA_ITALIC_ANGLE.
8912 Unfortunately, I didn't find a font yet that has this property set.
8916 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
8918 struct frame
*f
= XFRAME (w
->frame
);
8919 struct glyph
*cursor_glyph
;
8921 /* If cursor is out of bounds, don't draw garbage. This can happen
8922 in mini-buffer windows when switching between echo area glyphs
8924 cursor_glyph
= get_phys_cursor_glyph (w
);
8925 if (cursor_glyph
== NULL
)
8928 /* Experimental avoidance of cursor on xwidget. */
8929 if (cursor_glyph
->type
== XWIDGET_GLYPH
)
8932 /* If on an image, draw like a normal cursor. That's usually better
8933 visible than drawing a bar, esp. if the image is large so that
8934 the bar might not be in the window. */
8935 if (cursor_glyph
->type
== IMAGE_GLYPH
)
8937 struct glyph_row
*r
;
8938 r
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
8939 draw_phys_cursor_glyph (w
, r
, DRAW_CURSOR
);
8943 Display
*dpy
= FRAME_X_DISPLAY (f
);
8944 Window window
= FRAME_X_WINDOW (f
);
8945 GC gc
= FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
;
8946 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
8947 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
8950 /* If the glyph's background equals the color we normally draw
8951 the bars cursor in, the bar cursor in its normal color is
8952 invisible. Use the glyph's foreground color instead in this
8953 case, on the assumption that the glyph's colors are chosen so
8954 that the glyph is legible. */
8955 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
8956 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
8958 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
8959 xgcv
.graphics_exposures
= False
;
8962 XChangeGC (dpy
, gc
, mask
, &xgcv
);
8965 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
8966 FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
8969 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
8971 if (kind
== BAR_CURSOR
)
8973 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8976 width
= FRAME_CURSOR_WIDTH (f
);
8977 width
= min (cursor_glyph
->pixel_width
, width
);
8979 w
->phys_cursor_width
= width
;
8981 /* If the character under cursor is R2L, draw the bar cursor
8982 on the right of its glyph, rather than on the left. */
8983 if ((cursor_glyph
->resolved_level
& 1) != 0)
8984 x
+= cursor_glyph
->pixel_width
- width
;
8986 x_fill_rectangle (f
, gc
, x
,
8987 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
8988 width
, row
->height
);
8990 else /* HBAR_CURSOR */
8992 int dummy_x
, dummy_y
, dummy_h
;
8993 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8996 width
= row
->height
;
8998 width
= min (row
->height
, width
);
9000 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
9001 &dummy_y
, &dummy_h
);
9003 if ((cursor_glyph
->resolved_level
& 1) != 0
9004 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
- 1)
9005 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
+ 1;
9006 x_fill_rectangle (f
, gc
, x
,
9007 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
9008 row
->height
- width
),
9009 w
->phys_cursor_width
- 1, width
);
9012 x_reset_clip_rectangles (f
, gc
);
9017 /* RIF: Define cursor CURSOR on frame F. */
9020 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
9022 if (!f
->pointer_invisible
9023 && f
->output_data
.x
->current_cursor
!= cursor
)
9024 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
9025 f
->output_data
.x
->current_cursor
= cursor
;
9029 /* RIF: Clear area on frame F. */
9032 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
9034 x_clear_area (f
, x
, y
, width
, height
);
9036 /* Must queue a redraw, because scroll bars might have been cleared. */
9037 if (FRAME_GTK_WIDGET (f
))
9038 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
9043 /* RIF: Draw cursor on window W. */
9046 x_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
, int x
,
9047 int y
, enum text_cursor_kinds cursor_type
,
9048 int cursor_width
, bool on_p
, bool active_p
)
9050 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
9054 w
->phys_cursor_type
= cursor_type
;
9055 w
->phys_cursor_on_p
= true;
9057 if (glyph_row
->exact_window_width_line_p
9058 && (glyph_row
->reversed_p
9059 ? (w
->phys_cursor
.hpos
< 0)
9060 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
9062 glyph_row
->cursor_in_fringe_p
= true;
9063 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
9067 switch (cursor_type
)
9069 case HOLLOW_BOX_CURSOR
:
9070 x_draw_hollow_cursor (w
, glyph_row
);
9073 case FILLED_BOX_CURSOR
:
9074 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
9078 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
9082 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
9086 w
->phys_cursor_width
= 0;
9095 if (w
== XWINDOW (f
->selected_window
))
9096 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
9097 xic_set_preeditarea (w
, x
, y
);
9101 XFlush (FRAME_X_DISPLAY (f
));
9107 /* Make the x-window of frame F use the gnu icon bitmap. */
9110 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
9112 ptrdiff_t bitmap_id
;
9114 if (FRAME_X_WINDOW (f
) == 0)
9117 /* Free up our existing icon bitmap and mask if any. */
9118 if (f
->output_data
.x
->icon_bitmap
> 0)
9119 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
9120 f
->output_data
.x
->icon_bitmap
= 0;
9125 /* Use gtk_window_set_icon_from_file () if available,
9126 It's not restricted to bitmaps */
9127 if (xg_set_icon (f
, file
))
9129 #endif /* USE_GTK */
9130 bitmap_id
= x_create_bitmap_from_file (f
, file
);
9131 x_create_bitmap_mask (f
, bitmap_id
);
9135 /* Create the GNU bitmap and mask if necessary. */
9136 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
9142 if (xg_set_icon (f
, xg_default_icon_file
)
9143 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
9145 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= -2;
9149 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
9151 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
9153 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
9157 /* If all else fails, use the (black and white) xbm image. */
9160 rc
= x_create_bitmap_from_data (f
, (char *) gnu_xbm_bits
,
9161 gnu_xbm_width
, gnu_xbm_height
);
9165 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
9166 x_create_bitmap_mask (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
9170 /* The first time we create the GNU bitmap and mask,
9171 this increments the ref-count one extra time.
9172 As a result, the GNU bitmap and mask are never freed.
9173 That way, we don't have to worry about allocating it again. */
9174 x_reference_bitmap (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
9176 bitmap_id
= FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
;
9179 x_wm_set_icon_pixmap (f
, bitmap_id
);
9180 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
9186 /* Make the x-window of frame F use a rectangle with text.
9187 Use ICON_NAME as the text. */
9190 x_text_icon (struct frame
*f
, const char *icon_name
)
9192 if (FRAME_X_WINDOW (f
) == 0)
9197 text
.value
= (unsigned char *) icon_name
;
9198 text
.encoding
= XA_STRING
;
9200 text
.nitems
= strlen (icon_name
);
9201 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
9204 if (f
->output_data
.x
->icon_bitmap
> 0)
9205 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
9206 f
->output_data
.x
->icon_bitmap
= 0;
9207 x_wm_set_icon_pixmap (f
, 0);
9212 #define X_ERROR_MESSAGE_SIZE 200
9214 /* If non-nil, this should be a string.
9215 It means catch X errors and store the error message in this string.
9217 The reason we use a stack is that x_catch_error/x_uncatch_error can
9218 be called from a signal handler.
9221 struct x_error_message_stack
{
9222 char string
[X_ERROR_MESSAGE_SIZE
];
9224 x_special_error_handler handler
;
9226 struct x_error_message_stack
*prev
;
9228 static struct x_error_message_stack
*x_error_message
;
9230 /* An X error handler which stores the error message in
9231 *x_error_message. This is called from x_error_handler if
9232 x_catch_errors is in effect. */
9235 x_error_catcher (Display
*display
, XErrorEvent
*event
)
9237 XGetErrorText (display
, event
->error_code
,
9238 x_error_message
->string
,
9239 X_ERROR_MESSAGE_SIZE
);
9240 if (x_error_message
->handler
)
9241 x_error_message
->handler (display
, event
, x_error_message
->string
,
9242 x_error_message
->handler_data
);
9245 /* Begin trapping X errors for display DPY. Actually we trap X errors
9246 for all displays, but DPY should be the display you are actually
9249 After calling this function, X protocol errors no longer cause
9250 Emacs to exit; instead, they are recorded in the string
9251 stored in *x_error_message.
9253 Calling x_check_errors signals an Emacs error if an X error has
9254 occurred since the last call to x_catch_errors or x_check_errors.
9256 Calling x_uncatch_errors resumes the normal error handling.
9257 Calling x_uncatch_errors_after_check is similar, but skips an XSync
9258 to the server, and should be used only immediately after
9259 x_had_errors_p or x_check_errors. */
9262 x_catch_errors_with_handler (Display
*dpy
, x_special_error_handler handler
,
9265 struct x_error_message_stack
*data
= xmalloc (sizeof *data
);
9267 /* Make sure any errors from previous requests have been dealt with. */
9271 data
->string
[0] = 0;
9272 data
->handler
= handler
;
9273 data
->handler_data
= handler_data
;
9274 data
->prev
= x_error_message
;
9275 x_error_message
= data
;
9279 x_catch_errors (Display
*dpy
)
9281 x_catch_errors_with_handler (dpy
, NULL
, NULL
);
9284 /* Undo the last x_catch_errors call.
9285 DPY should be the display that was passed to x_catch_errors.
9287 This version should be used only if the immediately preceding
9288 X-protocol-related thing was x_check_errors or x_had_error_p, both
9289 of which issue XSync calls, so we don't need to re-sync here. */
9292 x_uncatch_errors_after_check (void)
9294 struct x_error_message_stack
*tmp
;
9297 tmp
= x_error_message
;
9298 x_error_message
= x_error_message
->prev
;
9303 /* Undo the last x_catch_errors call.
9304 DPY should be the display that was passed to x_catch_errors. */
9307 x_uncatch_errors (void)
9309 struct x_error_message_stack
*tmp
;
9313 /* The display may have been closed before this function is called.
9314 Check if it is still open before calling XSync. */
9315 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
9316 XSync (x_error_message
->dpy
, False
);
9318 tmp
= x_error_message
;
9319 x_error_message
= x_error_message
->prev
;
9324 /* If any X protocol errors have arrived since the last call to
9325 x_catch_errors or x_check_errors, signal an Emacs error using
9326 sprintf (a buffer, FORMAT, the x error message text) as the text. */
9329 x_check_errors (Display
*dpy
, const char *format
)
9331 /* Make sure to catch any errors incurred so far. */
9334 if (x_error_message
->string
[0])
9336 char string
[X_ERROR_MESSAGE_SIZE
];
9337 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
9338 x_uncatch_errors ();
9339 error (format
, string
);
9343 /* Nonzero if we had any X protocol errors
9344 since we did x_catch_errors on DPY. */
9347 x_had_errors_p (Display
*dpy
)
9349 /* Make sure to catch any errors incurred so far. */
9352 return x_error_message
->string
[0] != 0;
9355 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
9358 x_clear_errors (Display
*dpy
)
9360 x_error_message
->string
[0] = 0;
9364 /* See comment in unwind_to_catch why calling this is a bad
9365 * idea. --lorentey */
9366 /* Close off all unclosed x_catch_errors calls. */
9369 x_fully_uncatch_errors (void)
9371 while (x_error_message
)
9372 x_uncatch_errors ();
9377 static unsigned int x_wire_count
;
9380 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
9385 /************************************************************************
9387 ************************************************************************/
9389 /* Error message passed to x_connection_closed. */
9391 static char *error_msg
;
9393 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
9394 the text of an error message that lead to the connection loss. */
9397 x_connection_closed (Display
*dpy
, const char *error_message
, bool ioerror
)
9399 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
9400 Lisp_Object frame
, tail
;
9401 ptrdiff_t idx
= SPECPDL_INDEX ();
9403 error_msg
= alloca (strlen (error_message
) + 1);
9404 strcpy (error_msg
, error_message
);
9406 /* Inhibit redisplay while frames are being deleted. */
9407 specbind (Qinhibit_redisplay
, Qt
);
9411 /* Protect display from being closed when we delete the last
9413 dpyinfo
->reference_count
++;
9414 dpyinfo
->terminal
->reference_count
++;
9416 if (ioerror
) dpyinfo
->display
= 0;
9418 /* First delete frames whose mini-buffers are on frames
9419 that are on the dead display. */
9420 FOR_EACH_FRAME (tail
, frame
)
9422 Lisp_Object minibuf_frame
;
9424 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
9425 if (FRAME_X_P (XFRAME (frame
))
9426 && FRAME_X_P (XFRAME (minibuf_frame
))
9427 && ! EQ (frame
, minibuf_frame
)
9428 && FRAME_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
9429 delete_frame (frame
, Qnoelisp
);
9432 /* Now delete all remaining frames on the dead display.
9433 We are now sure none of these is used as the mini-buffer
9434 for another frame that we need to delete. */
9435 FOR_EACH_FRAME (tail
, frame
)
9436 if (FRAME_X_P (XFRAME (frame
))
9437 && FRAME_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
9439 /* Set this to t so that delete_frame won't get confused
9440 trying to find a replacement. */
9441 kset_default_minibuffer_frame (FRAME_KBOARD (XFRAME (frame
)), Qt
);
9442 delete_frame (frame
, Qnoelisp
);
9445 /* If DPYINFO is null, this means we didn't open the display in the
9446 first place, so don't try to close it. */
9449 /* We can not call XtCloseDisplay here because it calls XSync.
9450 XSync inside the error handler apparently hangs Emacs. On
9451 current Xt versions, this isn't needed either. */
9453 /* A long-standing GTK bug prevents proper disconnect handling
9454 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Once,
9455 the resulting Glib error message loop filled a user's disk.
9456 To avoid this, kill Emacs unconditionally on disconnect. */
9457 shut_down_emacs (0, Qnil
);
9458 fprintf (stderr
, "%s\n\
9459 When compiled with GTK, Emacs cannot recover from X disconnects.\n\
9460 This is a GTK bug: https://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
9461 For details, see etc/PROBLEMS.\n",
9464 #endif /* USE_GTK */
9466 /* Indicate that this display is dead. */
9467 dpyinfo
->display
= 0;
9469 dpyinfo
->reference_count
--;
9470 dpyinfo
->terminal
->reference_count
--;
9471 if (dpyinfo
->reference_count
!= 0)
9472 /* We have just closed all frames on this display. */
9477 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
9478 Fdelete_terminal (tmp
, Qnoelisp
);
9482 if (terminal_list
== 0)
9484 fprintf (stderr
, "%s\n", error_msg
);
9485 Fkill_emacs (make_number (70));
9489 totally_unblock_input ();
9491 unbind_to (idx
, Qnil
);
9492 clear_waiting_for_input ();
9494 /* Tell GCC not to suggest attribute 'noreturn' for this function. */
9495 IF_LINT (if (! terminal_list
) return; )
9497 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
9498 longjmp), because returning from this function would get us back into
9499 Xlib's code which will directly call `exit'. */
9500 error ("%s", error_msg
);
9503 /* We specifically use it before defining it, so that gcc doesn't inline it,
9504 otherwise gdb doesn't know how to properly put a breakpoint on it. */
9505 static void x_error_quitter (Display
*, XErrorEvent
*);
9507 /* This is the first-level handler for X protocol errors.
9508 It calls x_error_quitter or x_error_catcher. */
9511 x_error_handler (Display
*display
, XErrorEvent
*event
)
9513 #if defined USE_GTK && defined HAVE_GTK3
9514 if ((event
->error_code
== BadMatch
|| event
->error_code
== BadWindow
)
9515 && event
->request_code
== X_SetInputFocus
)
9521 if (x_error_message
)
9522 x_error_catcher (display
, event
);
9524 x_error_quitter (display
, event
);
9528 /* This is the usual handler for X protocol errors.
9529 It kills all frames on the display that we got the error for.
9530 If that was the only one, it prints an error message and kills Emacs. */
9532 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
9534 /* On older GCC versions, just putting x_error_quitter
9535 after x_error_handler prevents inlining into the former. */
9537 static void NO_INLINE
9538 x_error_quitter (Display
*display
, XErrorEvent
*event
)
9540 char buf
[256], buf1
[356];
9542 /* Ignore BadName errors. They can happen because of fonts
9543 or colors that are not defined. */
9545 if (event
->error_code
== BadName
)
9548 /* Note that there is no real way portable across R3/R4 to get the
9549 original error handler. */
9551 XGetErrorText (display
, event
->error_code
, buf
, sizeof (buf
));
9552 sprintf (buf1
, "X protocol error: %s on protocol request %d",
9553 buf
, event
->request_code
);
9554 x_connection_closed (display
, buf1
, false);
9558 /* This is the handler for X IO errors, always.
9559 It kills all frames on the display that we lost touch with.
9560 If that was the only one, it prints an error message and kills Emacs. */
9563 x_io_error_quitter (Display
*display
)
9567 snprintf (buf
, sizeof buf
, "Connection lost to X server '%s'",
9568 DisplayString (display
));
9569 x_connection_closed (display
, buf
, true);
9573 /* Changing the font of the frame. */
9575 /* Give frame F the font FONT-OBJECT as its default font. The return
9576 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
9577 frame. If it is negative, generate a new fontset from
9581 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
9583 struct font
*font
= XFONT_OBJECT (font_object
);
9584 int unit
, font_ascent
, font_descent
;
9585 #ifndef USE_X_TOOLKIT
9586 int old_menu_bar_height
= FRAME_MENU_BAR_HEIGHT (f
);
9587 Lisp_Object fullscreen
;
9591 fontset
= fontset_from_font (font_object
);
9592 FRAME_FONTSET (f
) = fontset
;
9593 if (FRAME_FONT (f
) == font
)
9594 /* This font is already set in frame F. There's nothing more to
9598 FRAME_FONT (f
) = font
;
9599 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
9600 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
9601 get_font_ascent_descent (font
, &font_ascent
, &font_descent
);
9602 FRAME_LINE_HEIGHT (f
) = font_ascent
+ font_descent
;
9604 #ifndef USE_X_TOOLKIT
9605 FRAME_MENU_BAR_HEIGHT (f
) = FRAME_MENU_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
);
9608 /* Compute character columns occupied by scrollbar.
9610 Don't do things differently for non-toolkit scrollbars
9612 unit
= FRAME_COLUMN_WIDTH (f
);
9613 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
9614 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
9615 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
9617 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
9619 if (FRAME_X_WINDOW (f
) != 0)
9621 /* Don't change the size of a tip frame; there's no point in
9622 doing it because it's done in Fx_show_tip, and it leads to
9623 problems because the tip frame has no widget. */
9624 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
9626 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
9627 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
9629 #ifndef USE_X_TOOLKIT
9630 if (FRAME_MENU_BAR_HEIGHT (f
) != old_menu_bar_height
9631 && !f
->after_make_frame
9632 && (EQ (frame_inhibit_implied_resize
, Qt
)
9633 || (CONSP (frame_inhibit_implied_resize
)
9634 && NILP (Fmemq (Qfont
, frame_inhibit_implied_resize
))))
9635 && (NILP (fullscreen
= get_frame_param (f
, Qfullscreen
))
9636 || EQ (fullscreen
, Qfullwidth
)))
9637 /* If the menu bar height changes, try to keep text height
9640 (f
, -1, FRAME_TEXT_HEIGHT (f
) + FRAME_MENU_BAR_HEIGHT (f
)
9641 - old_menu_bar_height
, 1, false, Qfont
);
9642 #endif /* USE_X_TOOLKIT */
9648 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
9651 xic_set_xfontset (f
, SSDATA (fontset_ascii (fontset
)));
9660 /***********************************************************************
9662 ***********************************************************************/
9668 /* XIM destroy callback function, which is called whenever the
9669 connection to input method XIM dies. CLIENT_DATA contains a
9670 pointer to the x_display_info structure corresponding to XIM. */
9673 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
9675 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
9676 Lisp_Object frame
, tail
;
9680 /* No need to call XDestroyIC.. */
9681 FOR_EACH_FRAME (tail
, frame
)
9683 struct frame
*f
= XFRAME (frame
);
9684 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
9686 FRAME_XIC (f
) = NULL
;
9687 xic_free_xfontset (f
);
9691 /* No need to call XCloseIM. */
9692 dpyinfo
->xim
= NULL
;
9693 XFree (dpyinfo
->xim_styles
);
9697 #endif /* HAVE_X11R6 */
9699 /* Open the connection to the XIM server on display DPYINFO.
9700 RESOURCE_NAME is the resource name Emacs uses. */
9703 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
9711 XCloseIM (dpyinfo
->xim
);
9712 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
9719 XIMCallback destroy
;
9722 /* Get supported styles and XIM values. */
9723 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
9726 destroy
.callback
= xim_destroy_callback
;
9727 destroy
.client_data
= (XPointer
)dpyinfo
;
9728 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
9734 #endif /* HAVE_XIM */
9735 dpyinfo
->xim
= NULL
;
9739 #ifdef HAVE_X11R6_XIM
9741 /* XIM instantiate callback function, which is called whenever an XIM
9742 server is available. DISPLAY is the display of the XIM.
9743 CLIENT_DATA contains a pointer to an xim_inst_t structure created
9744 when the callback was registered. */
9747 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
9749 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
9750 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
9752 /* We don't support multiple XIM connections. */
9756 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
9758 /* Create XIC for the existing frames on the same display, as long
9759 as they have no XIC. */
9760 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
9762 Lisp_Object tail
, frame
;
9765 FOR_EACH_FRAME (tail
, frame
)
9767 struct frame
*f
= XFRAME (frame
);
9770 && FRAME_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
9771 if (FRAME_XIC (f
) == NULL
)
9773 create_frame_xic (f
);
9774 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
9775 xic_set_statusarea (f
);
9776 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
9778 struct window
*w
= XWINDOW (f
->selected_window
);
9779 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
9788 #endif /* HAVE_X11R6_XIM */
9791 /* Open a connection to the XIM server on display DPYINFO.
9792 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
9793 connection only at the first time. On X11R6, open the connection
9794 in the XIM instantiate callback function. */
9797 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
9799 dpyinfo
->xim
= NULL
;
9803 #ifdef HAVE_X11R6_XIM
9804 struct xim_inst_t
*xim_inst
= xmalloc (sizeof *xim_inst
);
9807 dpyinfo
->xim_callback_data
= xim_inst
;
9808 xim_inst
->dpyinfo
= dpyinfo
;
9809 xim_inst
->resource_name
= xstrdup (resource_name
);
9810 ret
= XRegisterIMInstantiateCallback
9811 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
9812 emacs_class
, xim_instantiate_callback
,
9813 /* This is XPointer in XFree86 but (XPointer *)
9814 on Tru64, at least, hence the configure test. */
9815 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
9816 eassert (ret
== True
);
9817 #else /* not HAVE_X11R6_XIM */
9818 xim_open_dpy (dpyinfo
, resource_name
);
9819 #endif /* not HAVE_X11R6_XIM */
9821 #endif /* HAVE_XIM */
9825 /* Close the connection to the XIM server on display DPYINFO. */
9828 xim_close_dpy (struct x_display_info
*dpyinfo
)
9833 #ifdef HAVE_X11R6_XIM
9834 struct xim_inst_t
*xim_inst
= dpyinfo
->xim_callback_data
;
9836 if (dpyinfo
->display
)
9838 Bool ret
= XUnregisterIMInstantiateCallback
9839 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
9840 emacs_class
, xim_instantiate_callback
,
9841 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
9842 eassert (ret
== True
);
9844 xfree (xim_inst
->resource_name
);
9846 #endif /* HAVE_X11R6_XIM */
9847 if (dpyinfo
->display
)
9848 XCloseIM (dpyinfo
->xim
);
9849 dpyinfo
->xim
= NULL
;
9850 XFree (dpyinfo
->xim_styles
);
9852 #endif /* HAVE_XIM */
9855 #endif /* not HAVE_X11R6_XIM */
9859 /* Calculate the absolute position in frame F
9860 from its current recorded position values and gravity. */
9863 x_calc_absolute_position (struct frame
*f
)
9865 int flags
= f
->size_hint_flags
;
9867 /* We have nothing to do if the current position
9868 is already for the top-left corner. */
9869 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
9872 /* Treat negative positions as relative to the leftmost bottommost
9873 position that fits on the screen. */
9874 if (flags
& XNegative
)
9875 f
->left_pos
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
9876 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
9879 int height
= FRAME_PIXEL_HEIGHT (f
);
9881 #if defined USE_X_TOOLKIT && defined USE_MOTIF
9882 /* Something is fishy here. When using Motif, starting Emacs with
9883 `-g -0-0', the frame appears too low by a few pixels.
9885 This seems to be so because initially, while Emacs is starting,
9886 the column widget's height and the frame's pixel height are
9887 different. The column widget's height is the right one. In
9888 later invocations, when Emacs is up, the frame's pixel height
9891 It's not obvious where the initial small difference comes from.
9892 2000-12-01, gerd. */
9894 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
9897 if (flags
& YNegative
)
9898 f
->top_pos
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
9899 - height
+ f
->top_pos
;
9902 /* The left_pos and top_pos
9903 are now relative to the top and left screen edges,
9904 so the flags should correspond. */
9905 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9908 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
9909 to really change the position, and 0 when calling from
9910 x_make_frame_visible (in that case, XOFF and YOFF are the current
9911 position values). It is -1 when calling from x_set_frame_parameters,
9912 which means, do adjust for borders but don't change the gravity. */
9915 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
9917 int modified_top
, modified_left
;
9919 if (change_gravity
> 0)
9923 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9925 f
->size_hint_flags
|= XNegative
;
9927 f
->size_hint_flags
|= YNegative
;
9928 f
->win_gravity
= NorthWestGravity
;
9930 x_calc_absolute_position (f
);
9933 x_wm_set_size_hint (f
, 0, false);
9935 modified_left
= f
->left_pos
;
9936 modified_top
= f
->top_pos
;
9938 if (change_gravity
!= 0 && FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
9940 /* Some WMs (twm, wmaker at least) has an offset that is smaller
9941 than the WM decorations. So we use the calculated offset instead
9942 of the WM decoration sizes here (x/y_pixels_outer_diff). */
9943 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
9944 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
9947 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9948 modified_left
, modified_top
);
9950 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
9951 FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
);
9953 /* change_gravity is non-zero when this function is called from Lisp to
9954 programmatically move a frame. In that case, we call
9955 x_check_expected_move to discover if we have a "Type A" or "Type B"
9956 window manager, and, for a "Type A" window manager, adjust the position
9959 We call x_check_expected_move if a programmatic move occurred, and
9960 either the window manager type (A/B) is unknown or it is Type A but we
9961 need to compute the top/left offset adjustment for this frame. */
9963 if (change_gravity
!= 0
9964 && (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
9965 || (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
9966 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
9967 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
9968 x_check_expected_move (f
, modified_left
, modified_top
);
9973 /* Return true if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
9974 on the root window for frame F contains ATOMNAME.
9975 This is how a WM check shall be done according to the Window Manager
9976 Specification/Extended Window Manager Hints at
9977 http://freedesktop.org/wiki/Specifications/wm-spec. */
9980 x_wm_supports (struct frame
*f
, Atom want_atom
)
9983 unsigned long actual_size
, bytes_remaining
;
9984 int i
, rc
, actual_format
;
9986 Window wmcheck_window
;
9987 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9988 Window target_window
= dpyinfo
->root_window
;
9989 int max_len
= 65536;
9990 Display
*dpy
= FRAME_X_DISPLAY (f
);
9991 unsigned char *tmp_data
= NULL
;
9992 Atom target_type
= XA_WINDOW
;
9996 x_catch_errors (dpy
);
9997 rc
= XGetWindowProperty (dpy
, target_window
,
9998 dpyinfo
->Xatom_net_supporting_wm_check
,
9999 0, max_len
, False
, target_type
,
10000 &actual_type
, &actual_format
, &actual_size
,
10001 &bytes_remaining
, &tmp_data
);
10003 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
10005 if (tmp_data
) XFree (tmp_data
);
10006 x_uncatch_errors ();
10011 wmcheck_window
= *(Window
*) tmp_data
;
10014 /* Check if window exists. */
10015 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
10016 if (x_had_errors_p (dpy
))
10018 x_uncatch_errors_after_check ();
10023 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
10025 /* Window changed, reload atoms */
10026 if (dpyinfo
->net_supported_atoms
!= NULL
)
10027 XFree (dpyinfo
->net_supported_atoms
);
10028 dpyinfo
->net_supported_atoms
= NULL
;
10029 dpyinfo
->nr_net_supported_atoms
= 0;
10030 dpyinfo
->net_supported_window
= 0;
10032 target_type
= XA_ATOM
;
10034 rc
= XGetWindowProperty (dpy
, target_window
,
10035 dpyinfo
->Xatom_net_supported
,
10036 0, max_len
, False
, target_type
,
10037 &actual_type
, &actual_format
, &actual_size
,
10038 &bytes_remaining
, &tmp_data
);
10040 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
10042 if (tmp_data
) XFree (tmp_data
);
10043 x_uncatch_errors ();
10048 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
10049 dpyinfo
->nr_net_supported_atoms
= actual_size
;
10050 dpyinfo
->net_supported_window
= wmcheck_window
;
10055 for (i
= 0; !ret
&& i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
10056 ret
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
10058 x_uncatch_errors ();
10065 set_wm_state (Lisp_Object frame
, bool add
, Atom atom
, Atom value
)
10067 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (XFRAME (frame
));
10069 x_send_client_event (frame
, make_number (0), frame
,
10070 dpyinfo
->Xatom_net_wm_state
,
10072 /* 1 = add, 0 = remove */
10074 (make_number (add
),
10076 (make_fixnum_or_float (atom
),
10078 ? list1 (make_fixnum_or_float (value
))
10083 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
10086 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10088 XSETFRAME (frame
, f
);
10090 set_wm_state (frame
, !NILP (new_value
),
10091 dpyinfo
->Xatom_net_wm_state_sticky
, None
);
10094 /* Return the current _NET_WM_STATE.
10095 SIZE_STATE is set to one of the FULLSCREEN_* values.
10096 Set *STICKY to the sticky state.
10098 Return true iff we are not hidden. */
10101 get_current_wm_state (struct frame
*f
,
10106 unsigned long actual_size
;
10108 bool is_hidden
= false;
10109 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10110 long max_len
= 65536;
10111 Atom target_type
= XA_ATOM
;
10112 /* If XCB is available, we can avoid three XSync calls. */
10114 xcb_get_property_cookie_t prop_cookie
;
10115 xcb_get_property_reply_t
*prop
;
10116 xcb_atom_t
*reply_data
;
10118 Display
*dpy
= FRAME_X_DISPLAY (f
);
10119 unsigned long bytes_remaining
;
10120 int rc
, actual_format
;
10122 unsigned char *tmp_data
= NULL
;
10127 *size_state
= FULLSCREEN_NONE
;
10132 prop_cookie
= xcb_get_property (dpyinfo
->xcb_connection
, 0, window
,
10133 dpyinfo
->Xatom_net_wm_state
,
10134 target_type
, 0, max_len
);
10135 prop
= xcb_get_property_reply (dpyinfo
->xcb_connection
, prop_cookie
, NULL
);
10136 if (prop
&& prop
->type
== target_type
)
10138 int actual_bytes
= xcb_get_property_value_length (prop
);
10139 eassume (0 <= actual_bytes
);
10140 actual_size
= actual_bytes
/ sizeof *reply_data
;
10141 reply_data
= xcb_get_property_value (prop
);
10146 is_hidden
= FRAME_ICONIFIED_P (f
);
10149 x_catch_errors (dpy
);
10150 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
10151 0, max_len
, False
, target_type
,
10152 &actual_type
, &actual_format
, &actual_size
,
10153 &bytes_remaining
, &tmp_data
);
10155 if (rc
== Success
&& actual_type
== target_type
&& ! x_had_errors_p (dpy
))
10156 reply_data
= (Atom
*) tmp_data
;
10160 is_hidden
= FRAME_ICONIFIED_P (f
);
10163 x_uncatch_errors ();
10166 for (i
= 0; i
< actual_size
; ++i
)
10168 Atom a
= reply_data
[i
];
10169 if (a
== dpyinfo
->Xatom_net_wm_state_hidden
)
10171 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
10173 if (*size_state
== FULLSCREEN_HEIGHT
)
10174 *size_state
= FULLSCREEN_MAXIMIZED
;
10176 *size_state
= FULLSCREEN_WIDTH
;
10178 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
10180 if (*size_state
== FULLSCREEN_WIDTH
)
10181 *size_state
= FULLSCREEN_MAXIMIZED
;
10183 *size_state
= FULLSCREEN_HEIGHT
;
10185 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen
)
10186 *size_state
= FULLSCREEN_BOTH
;
10187 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
10194 if (tmp_data
) XFree (tmp_data
);
10198 return ! is_hidden
;
10201 /* Do fullscreen as specified in extended window manager hints */
10204 do_ewmh_fullscreen (struct frame
*f
)
10206 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10207 bool have_net_atom
= x_wm_supports (f
, dpyinfo
->Xatom_net_wm_state
);
10211 get_current_wm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
10213 /* Some window managers don't say they support _NET_WM_STATE, but they do say
10214 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
10215 if (!have_net_atom
)
10216 have_net_atom
= x_wm_supports (f
, dpyinfo
->Xatom_net_wm_state_fullscreen
);
10218 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
10222 XSETFRAME (frame
, f
);
10224 /* Keep number of calls to set_wm_state as low as possible.
10225 Some window managers, or possible Gtk+, hangs when too many
10226 are sent at once. */
10227 switch (f
->want_fullscreen
)
10229 case FULLSCREEN_BOTH
:
10230 if (cur
!= FULLSCREEN_BOTH
)
10231 set_wm_state (frame
, true, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10234 case FULLSCREEN_WIDTH
:
10235 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_MAXIMIZED
)
10237 set_wm_state (frame
, false,
10238 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10239 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10240 set_wm_state (frame
, true,
10241 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10245 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
10246 || cur
== FULLSCREEN_MAXIMIZED
)
10247 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10248 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10249 if (cur
!= FULLSCREEN_MAXIMIZED
|| x_frame_normalize_before_maximize
)
10250 set_wm_state (frame
, true,
10251 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10254 case FULLSCREEN_HEIGHT
:
10255 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_MAXIMIZED
)
10257 set_wm_state (frame
, false,
10258 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10259 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10260 set_wm_state (frame
, true,
10261 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
10265 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
10266 || cur
== FULLSCREEN_MAXIMIZED
)
10267 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10268 dpyinfo
->Xatom_net_wm_state_maximized_horz
);
10269 if (cur
!= FULLSCREEN_MAXIMIZED
|| x_frame_normalize_before_maximize
)
10270 set_wm_state (frame
, true,
10271 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
10274 case FULLSCREEN_MAXIMIZED
:
10275 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_BOTH
)
10277 set_wm_state (frame
, false,
10278 dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
10279 set_wm_state (frame
, true,
10280 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10281 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10283 else if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_WIDTH
)
10285 set_wm_state (frame
, false,
10286 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10287 set_wm_state (frame
, true,
10288 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10289 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10291 else if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_HEIGHT
)
10293 set_wm_state (frame
, false,
10294 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
10295 set_wm_state (frame
, true,
10296 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10297 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10301 if (cur
== FULLSCREEN_BOTH
)
10302 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10304 else if (cur
== FULLSCREEN_HEIGHT
)
10305 set_wm_state (frame
, true,
10306 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10307 else if (cur
== FULLSCREEN_WIDTH
)
10308 set_wm_state (frame
, true, None
,
10309 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10311 set_wm_state (frame
, true,
10312 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10313 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10316 case FULLSCREEN_NONE
:
10317 if (cur
== FULLSCREEN_BOTH
)
10318 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10321 set_wm_state (frame
, false,
10322 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10323 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10326 f
->want_fullscreen
= FULLSCREEN_NONE
;
10330 return have_net_atom
;
10334 XTfullscreen_hook (struct frame
*f
)
10336 if (FRAME_VISIBLE_P (f
))
10339 x_check_fullscreen (f
);
10347 x_handle_net_wm_state (struct frame
*f
, const XPropertyEvent
*event
)
10349 int value
= FULLSCREEN_NONE
;
10351 bool sticky
= false;
10352 bool not_hidden
= get_current_wm_state (f
, event
->window
, &value
, &sticky
);
10357 case FULLSCREEN_WIDTH
:
10360 case FULLSCREEN_HEIGHT
:
10361 lval
= Qfullheight
;
10363 case FULLSCREEN_BOTH
:
10366 case FULLSCREEN_MAXIMIZED
:
10371 frame_size_history_add
10372 (f
, Qx_handle_net_wm_state
, 0, 0,
10373 list2 (get_frame_param (f
, Qfullscreen
), lval
));
10375 store_frame_param (f
, Qfullscreen
, lval
);
10376 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
10381 /* Check if we need to resize the frame due to a fullscreen request.
10382 If so needed, resize the frame. */
10384 x_check_fullscreen (struct frame
*f
)
10386 Lisp_Object lval
= Qnil
;
10388 if (do_ewmh_fullscreen (f
))
10391 if (f
->output_data
.x
->parent_desc
!= FRAME_DISPLAY_INFO (f
)->root_window
)
10392 return; /* Only fullscreen without WM or with EWM hints (above). */
10394 /* Setting fullscreen to nil doesn't do anything. We could save the
10395 last non-fullscreen size and restore it, but it seems like a
10396 lot of work for this unusual case (no window manager running). */
10398 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
10400 int width
= FRAME_PIXEL_WIDTH (f
), height
= FRAME_PIXEL_HEIGHT (f
);
10401 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10403 switch (f
->want_fullscreen
)
10405 /* No difference between these two when there is no WM */
10406 case FULLSCREEN_MAXIMIZED
:
10408 width
= x_display_pixel_width (dpyinfo
);
10409 height
= x_display_pixel_height (dpyinfo
);
10411 case FULLSCREEN_BOTH
:
10413 width
= x_display_pixel_width (dpyinfo
);
10414 height
= x_display_pixel_height (dpyinfo
);
10416 case FULLSCREEN_WIDTH
:
10418 width
= x_display_pixel_width (dpyinfo
);
10419 height
= height
+ FRAME_MENUBAR_HEIGHT (f
);
10421 case FULLSCREEN_HEIGHT
:
10422 lval
= Qfullheight
;
10423 height
= x_display_pixel_height (dpyinfo
);
10429 frame_size_history_add
10430 (f
, Qx_check_fullscreen
, width
, height
, Qnil
);
10432 x_wm_set_size_hint (f
, 0, false);
10434 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10437 if (FRAME_VISIBLE_P (f
))
10438 x_wait_for_event (f
, ConfigureNotify
);
10441 change_frame_size (f
, width
, height
- FRAME_MENUBAR_HEIGHT (f
),
10442 false, true, false, true);
10447 /* `x_net_wm_state' might have reset the fullscreen frame parameter,
10449 store_frame_param (f
, Qfullscreen
, lval
);
10452 /* This function is called by x_set_offset to determine whether the window
10453 manager interfered with the positioning of the frame. Type A window
10454 managers position the surrounding window manager decorations a small
10455 amount above and left of the user-supplied position. Type B window
10456 managers position the surrounding window manager decorations at the
10457 user-specified position. If we detect a Type A window manager, we
10458 compensate by moving the window right and down by the proper amount. */
10461 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
10463 int current_left
= 0, current_top
= 0;
10465 /* x_real_positions returns the left and top offsets of the outermost
10466 window manager window around the frame. */
10468 x_real_positions (f
, ¤t_left
, ¤t_top
);
10470 if (current_left
!= expected_left
|| current_top
!= expected_top
)
10472 /* It's a "Type A" window manager. */
10477 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
10478 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
10479 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
10481 /* Now fix the mispositioned frame's location. */
10483 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
10484 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
10486 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10487 adjusted_left
, adjusted_top
);
10489 x_sync_with_move (f
, expected_left
, expected_top
, false);
10492 /* It's a "Type B" window manager. We don't have to adjust the
10493 frame's position. */
10495 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
10499 /* Wait for XGetGeometry to return up-to-date position information for a
10500 recently-moved frame. Call this immediately after calling XMoveWindow.
10501 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
10502 frame has been moved to, so we use a fuzzy position comparison instead
10503 of an exact comparison. */
10506 x_sync_with_move (struct frame
*f
, int left
, int top
, bool fuzzy
)
10510 while (count
++ < 50)
10512 int current_left
= 0, current_top
= 0;
10514 /* In theory, this call to XSync only needs to happen once, but in
10515 practice, it doesn't seem to work, hence the need for the surrounding
10518 XSync (FRAME_X_DISPLAY (f
), False
);
10519 x_real_positions (f
, ¤t_left
, ¤t_top
);
10523 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
10526 if (eabs (current_left
- left
) <= 10
10527 && eabs (current_top
- top
) <= 40)
10530 else if (current_left
== left
&& current_top
== top
)
10534 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
10535 will then return up-to-date position info. */
10537 wait_reading_process_output (0, 500000000, 0, false, Qnil
, NULL
, 0);
10541 /* Wait for an event on frame F matching EVENTTYPE. */
10543 x_wait_for_event (struct frame
*f
, int eventtype
)
10545 int level
= interrupt_input_blocked
;
10548 struct timespec tmo
, tmo_at
, time_now
;
10549 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
10551 f
->wait_event_type
= eventtype
;
10553 /* Set timeout to 0.1 second. Hopefully not noticeable.
10554 Maybe it should be configurable. */
10555 tmo
= make_timespec (0, 100 * 1000 * 1000);
10556 tmo_at
= timespec_add (current_timespec (), tmo
);
10558 while (f
->wait_event_type
)
10560 pending_signals
= true;
10561 totally_unblock_input ();
10562 /* XTread_socket is called after unblock. */
10564 interrupt_input_blocked
= level
;
10569 time_now
= current_timespec ();
10570 if (timespec_cmp (tmo_at
, time_now
) < 0)
10573 tmo
= timespec_sub (tmo_at
, time_now
);
10574 if (pselect (fd
+ 1, &fds
, NULL
, NULL
, &tmo
, NULL
) == 0)
10575 break; /* Timeout */
10578 f
->wait_event_type
= 0;
10582 /* Change the size of frame F's X window to WIDTH/HEIGHT in the case F
10583 doesn't have a widget. If CHANGE_GRAVITY, change to
10584 top-left-corner window gravity for this size change and subsequent
10585 size changes. Otherwise leave the window gravity unchanged. */
10588 x_set_window_size_1 (struct frame
*f
, bool change_gravity
,
10589 int width
, int height
)
10591 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
10592 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
10593 int old_width
= FRAME_PIXEL_WIDTH (f
);
10594 int old_height
= FRAME_PIXEL_HEIGHT (f
);
10595 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
10597 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
10598 x_wm_set_size_hint (f
, 0, false);
10600 /* When the frame is fullheight and we only want to change the width
10601 or it is fullwidth and we only want to change the height we should
10602 be able to preserve the fullscreen property. However, due to the
10603 fact that we have to send a resize request anyway, the window
10604 manager will abolish it. At least the respective size should
10605 remain unchanged but giving the frame back its normal size will
10607 if (EQ (fullscreen
, Qfullwidth
) && width
== FRAME_TEXT_WIDTH (f
))
10609 frame_size_history_add
10610 (f
, Qx_set_window_size_1
, width
, height
,
10611 list2 (make_number (old_height
),
10612 make_number (pixelheight
+ FRAME_MENUBAR_HEIGHT (f
))));
10614 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10615 old_width
, pixelheight
+ FRAME_MENUBAR_HEIGHT (f
));
10617 else if (EQ (fullscreen
, Qfullheight
) && height
== FRAME_TEXT_HEIGHT (f
))
10619 frame_size_history_add
10620 (f
, Qx_set_window_size_2
, width
, height
,
10621 list2 (make_number (old_width
), make_number (pixelwidth
)));
10623 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10624 pixelwidth
, old_height
);
10629 frame_size_history_add
10630 (f
, Qx_set_window_size_3
, width
, height
,
10631 list3 (make_number (pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
)),
10632 make_number (pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
10633 + FRAME_MENUBAR_HEIGHT (f
)),
10634 make_number (FRAME_MENUBAR_HEIGHT (f
))));
10636 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10637 pixelwidth
, pixelheight
+ FRAME_MENUBAR_HEIGHT (f
));
10643 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
10644 receive in the ConfigureNotify event; if we get what we asked
10645 for, then the event won't cause the screen to become garbaged, so
10646 we have to make sure to do it here. */
10647 SET_FRAME_GARBAGED (f
);
10649 /* Now, strictly speaking, we can't be sure that this is accurate,
10650 but the window manager will get around to dealing with the size
10651 change request eventually, and we'll hear how it went when the
10652 ConfigureNotify event gets here.
10654 We could just not bother storing any of this information here,
10655 and let the ConfigureNotify event set everything up, but that
10656 might be kind of confusing to the Lisp code, since size changes
10657 wouldn't be reported in the frame parameters until some random
10658 point in the future when the ConfigureNotify event arrives.
10660 Pass true for DELAY since we can't run Lisp code inside of
10663 /* But the ConfigureNotify may in fact never arrive, and then this is
10664 not right if the frame is visible. Instead wait (with timeout)
10665 for the ConfigureNotify. */
10666 if (FRAME_VISIBLE_P (f
))
10668 x_wait_for_event (f
, ConfigureNotify
);
10670 if (!NILP (fullscreen
))
10671 /* Try to restore fullscreen state. */
10673 store_frame_param (f
, Qfullscreen
, fullscreen
);
10674 x_set_fullscreen (f
, fullscreen
, fullscreen
);
10679 change_frame_size (f
, width
, height
, false, true, false, true);
10685 /* Call this to change the size of frame F's x-window.
10686 If CHANGE_GRAVITY, change to top-left-corner window gravity
10687 for this size change and subsequent size changes.
10688 Otherwise we leave the window gravity unchanged. */
10691 x_set_window_size (struct frame
*f
, bool change_gravity
,
10692 int width
, int height
, bool pixelwise
)
10696 /* The following breaks our calculations. If it's really needed,
10697 think of something else. */
10699 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
10701 int text_width
, text_height
;
10703 /* When the frame is maximized/fullscreen or running under for
10704 example Xmonad, x_set_window_size_1 will be a no-op.
10705 In that case, the right thing to do is extend rows/width to
10706 the current frame size. We do that first if x_set_window_size_1
10707 turns out to not be a no-op (there is no way to know).
10708 The size will be adjusted again if the frame gets a
10709 ConfigureNotify event as a result of x_set_window_size. */
10710 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
10711 #ifdef USE_X_TOOLKIT
10712 /* The menu bar is not part of text lines. The tool bar
10714 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
10716 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, FRAME_PIXEL_WIDTH (f
));
10717 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelh
);
10719 change_frame_size (f
, text_width
, text_height
, false, true, false, true);
10723 /* Pixelize width and height, if necessary. */
10726 width
= width
* FRAME_COLUMN_WIDTH (f
);
10727 height
= height
* FRAME_LINE_HEIGHT (f
);
10731 if (FRAME_GTK_WIDGET (f
))
10732 xg_frame_set_char_size (f
, width
, height
);
10734 x_set_window_size_1 (f
, change_gravity
, width
, height
);
10735 #else /* not USE_GTK */
10736 x_set_window_size_1 (f
, change_gravity
, width
, height
);
10737 x_clear_under_internal_border (f
);
10738 #endif /* not USE_GTK */
10740 /* If cursor was outside the new size, mark it as off. */
10741 mark_window_cursors_off (XWINDOW (f
->root_window
));
10743 /* Clear out any recollection of where the mouse highlighting was,
10744 since it might be in a place that's outside the new frame size.
10745 Actually checking whether it is outside is a pain in the neck,
10746 so don't try--just let the highlighting be done afresh with new size. */
10747 cancel_mouse_face (f
);
10752 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
10755 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
10759 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
10760 0, 0, 0, 0, pix_x
, pix_y
);
10764 /* Raise frame F. */
10767 x_raise_frame (struct frame
*f
)
10770 if (FRAME_VISIBLE_P (f
))
10771 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
10772 XFlush (FRAME_X_DISPLAY (f
));
10776 /* Lower frame F. */
10779 x_lower_frame (struct frame
*f
)
10781 if (FRAME_VISIBLE_P (f
))
10784 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
10785 XFlush (FRAME_X_DISPLAY (f
));
10790 /* Request focus with XEmbed */
10793 xembed_request_focus (struct frame
*f
)
10795 /* See XEmbed Protocol Specification at
10796 http://freedesktop.org/wiki/Specifications/xembed-spec */
10797 if (FRAME_VISIBLE_P (f
))
10798 xembed_send_message (f
, CurrentTime
,
10799 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
10802 /* Activate frame with Extended Window Manager Hints */
10805 x_ewmh_activate_frame (struct frame
*f
)
10807 /* See Window Manager Specification/Extended Window Manager Hints at
10808 http://freedesktop.org/wiki/Specifications/wm-spec */
10810 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10812 if (FRAME_VISIBLE_P (f
) && x_wm_supports (f
, dpyinfo
->Xatom_net_active_window
))
10815 XSETFRAME (frame
, f
);
10816 x_send_client_event (frame
, make_number (0), frame
,
10817 dpyinfo
->Xatom_net_active_window
,
10819 list2i (1, dpyinfo
->last_user_time
));
10824 XTframe_raise_lower (struct frame
*f
, bool raise_flag
)
10832 /* XEmbed implementation. */
10834 #if defined USE_X_TOOLKIT || ! defined USE_GTK
10836 /* XEmbed implementation. */
10838 #define XEMBED_VERSION 0
10841 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
10843 unsigned long data
[2];
10844 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10846 data
[0] = XEMBED_VERSION
;
10849 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10850 dpyinfo
->Xatom_XEMBED_INFO
, dpyinfo
->Xatom_XEMBED_INFO
,
10851 32, PropModeReplace
, (unsigned char *) data
, 2);
10853 #endif /* defined USE_X_TOOLKIT || ! defined USE_GTK */
10856 xembed_send_message (struct frame
*f
, Time t
, enum xembed_message msg
,
10857 long int detail
, long int data1
, long int data2
)
10861 event
.xclient
.type
= ClientMessage
;
10862 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
10863 event
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_XEMBED
;
10864 event
.xclient
.format
= 32;
10865 event
.xclient
.data
.l
[0] = t
;
10866 event
.xclient
.data
.l
[1] = msg
;
10867 event
.xclient
.data
.l
[2] = detail
;
10868 event
.xclient
.data
.l
[3] = data1
;
10869 event
.xclient
.data
.l
[4] = data2
;
10871 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
10872 False
, NoEventMask
, &event
);
10873 XSync (FRAME_X_DISPLAY (f
), False
);
10876 /* Change of visibility. */
10878 /* This tries to wait until the frame is really visible.
10879 However, if the window manager asks the user where to position
10880 the frame, this will return before the user finishes doing that.
10881 The frame will not actually be visible at that time,
10882 but it will become visible later when the window manager
10883 finishes with it. */
10886 x_make_frame_visible (struct frame
*f
)
10888 int original_top
, original_left
;
10893 x_set_bitmap_icon (f
);
10895 if (! FRAME_VISIBLE_P (f
))
10897 /* We test FRAME_GARBAGED_P here to make sure we don't
10898 call x_set_offset a second time
10899 if we get to x_make_frame_visible a second time
10900 before the window gets really visible. */
10901 if (! FRAME_ICONIFIED_P (f
)
10902 && ! FRAME_X_EMBEDDED_P (f
)
10903 && ! f
->output_data
.x
->asked_for_visible
)
10904 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
10906 f
->output_data
.x
->asked_for_visible
= true;
10908 if (! EQ (Vx_no_window_manager
, Qt
))
10909 x_wm_set_window_state (f
, NormalState
);
10910 #ifdef USE_X_TOOLKIT
10911 if (FRAME_X_EMBEDDED_P (f
))
10912 xembed_set_info (f
, XEMBED_MAPPED
);
10915 /* This was XtPopup, but that did nothing for an iconified frame. */
10916 XtMapWidget (f
->output_data
.x
->widget
);
10918 #else /* not USE_X_TOOLKIT */
10920 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
10921 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
10923 if (FRAME_X_EMBEDDED_P (f
))
10924 xembed_set_info (f
, XEMBED_MAPPED
);
10926 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10927 #endif /* not USE_GTK */
10928 #endif /* not USE_X_TOOLKIT */
10931 XFlush (FRAME_X_DISPLAY (f
));
10933 /* Synchronize to ensure Emacs knows the frame is visible
10934 before we do anything else. We do this loop with input not blocked
10935 so that incoming events are handled. */
10938 /* This must be before UNBLOCK_INPUT
10939 since events that arrive in response to the actions above
10940 will set it when they are handled. */
10941 bool previously_visible
= f
->output_data
.x
->has_been_visible
;
10943 original_left
= f
->left_pos
;
10944 original_top
= f
->top_pos
;
10946 /* This must come after we set COUNT. */
10949 /* We unblock here so that arriving X events are processed. */
10951 /* Now move the window back to where it was "supposed to be".
10952 But don't do it if the gravity is negative.
10953 When the gravity is negative, this uses a position
10954 that is 3 pixels too low. Perhaps that's really the border width.
10956 Don't do this if the window has never been visible before,
10957 because the window manager may choose the position
10958 and we don't want to override it. */
10960 if (! FRAME_VISIBLE_P (f
)
10961 && ! FRAME_ICONIFIED_P (f
)
10962 && ! FRAME_X_EMBEDDED_P (f
)
10963 && f
->win_gravity
== NorthWestGravity
10964 && previously_visible
)
10968 unsigned int width
, height
, border
, depth
;
10972 /* On some window managers (such as FVWM) moving an existing
10973 window, even to the same place, causes the window manager
10974 to introduce an offset. This can cause the window to move
10975 to an unexpected location. Check the geometry (a little
10976 slow here) and then verify that the window is in the right
10977 place. If the window is not in the right place, move it
10978 there, and take the potential window manager hit. */
10979 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10980 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
10982 if (original_left
!= x
|| original_top
!= y
)
10983 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10984 original_left
, original_top
);
10989 XSETFRAME (frame
, f
);
10991 /* Process X events until a MapNotify event has been seen. */
10992 while (!FRAME_VISIBLE_P (f
))
10994 /* Force processing of queued events. */
10997 /* If on another desktop, the deiconify/map may be ignored and the
10998 frame never becomes visible. XMonad does this.
10999 Prevent an endless loop. */
11000 if (FRAME_ICONIFIED_P (f
) && ++tries
> 100)
11003 /* This hack is still in use at least for Cygwin. See
11004 http://lists.gnu.org/archive/html/emacs-devel/2013-12/msg00351.html.
11006 Machines that do polling rather than SIGIO have been
11007 observed to go into a busy-wait here. So we'll fake an
11008 alarm signal to let the handler know that there's something
11009 to be read. We used to raise a real alarm, but it seems
11010 that the handler isn't always enabled here. This is
11012 if (input_polling_used ())
11014 /* It could be confusing if a real alarm arrives while
11015 processing the fake one. Turn it off and let the
11016 handler reset it. */
11017 int old_poll_suppress_count
= poll_suppress_count
;
11018 poll_suppress_count
= 1;
11019 poll_for_input_1 ();
11020 poll_suppress_count
= old_poll_suppress_count
;
11023 if (XPending (FRAME_X_DISPLAY (f
)))
11026 XNextEvent (FRAME_X_DISPLAY (f
), &xev
);
11027 x_dispatch_event (&xev
, FRAME_X_DISPLAY (f
));
11033 /* Change from mapped state to withdrawn state. */
11035 /* Make the frame visible (mapped and not iconified). */
11038 x_make_frame_invisible (struct frame
*f
)
11042 /* Use the frame's outermost window, not the one we normally draw on. */
11043 window
= FRAME_OUTER_WINDOW (f
);
11045 /* Don't keep the highlight on an invisible frame. */
11046 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
11047 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
11051 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
11052 that the current position of the window is user-specified, rather than
11053 program-specified, so that when the window is mapped again, it will be
11054 placed at the same location, without forcing the user to position it
11055 by hand again (they have already done that once for this window.) */
11056 x_wm_set_size_hint (f
, 0, true);
11059 if (FRAME_GTK_OUTER_WIDGET (f
))
11060 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
11063 if (FRAME_X_EMBEDDED_P (f
))
11064 xembed_set_info (f
, 0);
11069 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
11070 DefaultScreen (FRAME_X_DISPLAY (f
))))
11073 error ("Can't notify window manager of window withdrawal");
11077 /* We can't distinguish this from iconification
11078 just by the event that we get from the server.
11079 So we can't win using the usual strategy of letting
11080 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
11081 and synchronize with the server to make sure we agree. */
11082 SET_FRAME_VISIBLE (f
, 0);
11083 SET_FRAME_ICONIFIED (f
, false);
11090 /* Change window state from mapped to iconified. */
11093 x_iconify_frame (struct frame
*f
)
11095 #ifdef USE_X_TOOLKIT
11099 /* Don't keep the highlight on an invisible frame. */
11100 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
11101 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
11103 if (FRAME_ICONIFIED_P (f
))
11108 x_set_bitmap_icon (f
);
11110 #if defined (USE_GTK)
11111 if (FRAME_GTK_OUTER_WIDGET (f
))
11113 if (! FRAME_VISIBLE_P (f
))
11114 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
11116 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
11117 SET_FRAME_VISIBLE (f
, 0);
11118 SET_FRAME_ICONIFIED (f
, true);
11124 #ifdef USE_X_TOOLKIT
11126 if (! FRAME_VISIBLE_P (f
))
11128 if (! EQ (Vx_no_window_manager
, Qt
))
11129 x_wm_set_window_state (f
, IconicState
);
11130 /* This was XtPopup, but that did nothing for an iconified frame. */
11131 XtMapWidget (f
->output_data
.x
->widget
);
11132 /* The server won't give us any event to indicate
11133 that an invisible frame was changed to an icon,
11134 so we have to record it here. */
11135 SET_FRAME_VISIBLE (f
, 0);
11136 SET_FRAME_ICONIFIED (f
, true);
11141 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
11142 XtWindow (f
->output_data
.x
->widget
),
11143 DefaultScreen (FRAME_X_DISPLAY (f
)));
11147 error ("Can't notify window manager of iconification");
11149 SET_FRAME_ICONIFIED (f
, true);
11150 SET_FRAME_VISIBLE (f
, 0);
11153 XFlush (FRAME_X_DISPLAY (f
));
11155 #else /* not USE_X_TOOLKIT */
11157 /* Make sure the X server knows where the window should be positioned,
11158 in case the user deiconifies with the window manager. */
11159 if (! FRAME_VISIBLE_P (f
)
11160 && ! FRAME_ICONIFIED_P (f
)
11161 && ! FRAME_X_EMBEDDED_P (f
))
11162 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
11164 /* Since we don't know which revision of X we're running, we'll use both
11165 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
11167 /* X11R4: send a ClientMessage to the window manager using the
11168 WM_CHANGE_STATE type. */
11172 msg
.xclient
.window
= FRAME_X_WINDOW (f
);
11173 msg
.xclient
.type
= ClientMessage
;
11174 msg
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
11175 msg
.xclient
.format
= 32;
11176 msg
.xclient
.data
.l
[0] = IconicState
;
11178 if (! XSendEvent (FRAME_X_DISPLAY (f
),
11179 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
11181 SubstructureRedirectMask
| SubstructureNotifyMask
,
11185 error ("Can't notify window manager of iconification");
11189 /* X11R3: set the initial_state field of the window manager hints to
11191 x_wm_set_window_state (f
, IconicState
);
11193 if (!FRAME_VISIBLE_P (f
))
11195 /* If the frame was withdrawn, before, we must map it. */
11196 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11199 SET_FRAME_ICONIFIED (f
, true);
11200 SET_FRAME_VISIBLE (f
, 0);
11202 XFlush (FRAME_X_DISPLAY (f
));
11204 #endif /* not USE_X_TOOLKIT */
11208 /* Free X resources of frame F. */
11211 x_free_frame_resources (struct frame
*f
)
11213 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
11214 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
11215 #ifdef USE_X_TOOLKIT
11217 struct scroll_bar
*b
;
11222 /* If a display connection is dead, don't try sending more
11223 commands to the X server. */
11224 if (dpyinfo
->display
)
11226 /* Always exit with visible pointer to avoid weird issue
11227 with Xfixes (Bug#17609). */
11228 if (f
->pointer_invisible
)
11229 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, 0);
11231 /* We must free faces before destroying windows because some
11232 font-driver (e.g. xft) access a window while finishing a
11234 free_frame_faces (f
);
11236 if (f
->output_data
.x
->icon_desc
)
11237 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
11239 #ifdef USE_X_TOOLKIT
11240 /* Explicitly destroy the scroll bars of the frame. Without
11241 this, we get "BadDrawable" errors from the toolkit later on,
11242 presumably from expose events generated for the disappearing
11243 toolkit scroll bars. */
11244 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
11246 b
= XSCROLL_BAR (bar
);
11247 x_scroll_bar_remove (b
);
11253 free_frame_xic (f
);
11256 x_free_cr_resources (f
);
11257 #ifdef USE_X_TOOLKIT
11258 if (f
->output_data
.x
->widget
)
11260 XtDestroyWidget (f
->output_data
.x
->widget
);
11261 f
->output_data
.x
->widget
= NULL
;
11263 /* Tooltips don't have widgets, only a simple X window, even if
11264 we are using a toolkit. */
11265 else if (FRAME_X_WINDOW (f
))
11266 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11268 free_frame_menubar (f
);
11270 if (f
->shell_position
)
11271 xfree (f
->shell_position
);
11272 #else /* !USE_X_TOOLKIT */
11275 xg_free_frame_widgets (f
);
11276 #endif /* USE_GTK */
11278 if (FRAME_X_WINDOW (f
))
11279 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11280 #endif /* !USE_X_TOOLKIT */
11282 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
11283 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
11284 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
11285 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
11286 unload_color (f
, f
->output_data
.x
->border_pixel
);
11287 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
11289 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
11290 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
11291 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
11292 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
11293 #if defined (USE_LUCID) && defined (USE_TOOLKIT_SCROLL_BARS)
11294 /* Scrollbar shadow colors. */
11295 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
11296 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
11297 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
11298 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
11299 #endif /* USE_LUCID && USE_TOOLKIT_SCROLL_BARS */
11300 if (f
->output_data
.x
->white_relief
.pixel
!= -1)
11301 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
11302 if (f
->output_data
.x
->black_relief
.pixel
!= -1)
11303 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
11307 /* Free extra GCs allocated by x_setup_relief_colors. */
11308 if (f
->output_data
.x
->white_relief
.gc
)
11310 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->white_relief
.gc
);
11311 f
->output_data
.x
->white_relief
.gc
= 0;
11313 if (f
->output_data
.x
->black_relief
.gc
)
11315 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->black_relief
.gc
);
11316 f
->output_data
.x
->black_relief
.gc
= 0;
11319 /* Free cursors. */
11320 if (f
->output_data
.x
->text_cursor
!= 0)
11321 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->text_cursor
);
11322 if (f
->output_data
.x
->nontext_cursor
!= 0)
11323 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->nontext_cursor
);
11324 if (f
->output_data
.x
->modeline_cursor
!= 0)
11325 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->modeline_cursor
);
11326 if (f
->output_data
.x
->hand_cursor
!= 0)
11327 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hand_cursor
);
11328 if (f
->output_data
.x
->hourglass_cursor
!= 0)
11329 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hourglass_cursor
);
11330 if (f
->output_data
.x
->horizontal_drag_cursor
!= 0)
11331 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->horizontal_drag_cursor
);
11332 if (f
->output_data
.x
->vertical_drag_cursor
!= 0)
11333 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->vertical_drag_cursor
);
11335 XFlush (FRAME_X_DISPLAY (f
));
11338 xfree (f
->output_data
.x
->saved_menu_event
);
11339 xfree (f
->output_data
.x
);
11340 f
->output_data
.x
= NULL
;
11342 if (f
== dpyinfo
->x_focus_frame
)
11343 dpyinfo
->x_focus_frame
= 0;
11344 if (f
== dpyinfo
->x_focus_event_frame
)
11345 dpyinfo
->x_focus_event_frame
= 0;
11346 if (f
== dpyinfo
->x_highlight_frame
)
11347 dpyinfo
->x_highlight_frame
= 0;
11348 if (f
== hlinfo
->mouse_face_mouse_frame
)
11349 reset_mouse_highlight (hlinfo
);
11355 /* Destroy the X window of frame F. */
11358 x_destroy_window (struct frame
*f
)
11360 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
11362 /* If a display connection is dead, don't try sending more
11363 commands to the X server. */
11364 if (dpyinfo
->display
!= 0)
11365 x_free_frame_resources (f
);
11367 dpyinfo
->reference_count
--;
11371 /* Setting window manager hints. */
11373 /* Set the normal size hints for the window manager, for frame F.
11374 FLAGS is the flags word to use--or 0 meaning preserve the flags
11375 that the window now has.
11376 If USER_POSITION, set the USPosition
11377 flag (this is useful when FLAGS is 0).
11378 The GTK version is in gtkutils.c. */
11382 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
11384 XSizeHints size_hints
;
11385 Window window
= FRAME_OUTER_WINDOW (f
);
11390 #ifdef USE_X_TOOLKIT
11391 if (f
->output_data
.x
->widget
)
11393 widget_update_wm_size_hints (f
->output_data
.x
->widget
);
11398 /* Setting PMaxSize caused various problems. */
11399 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
11401 size_hints
.x
= f
->left_pos
;
11402 size_hints
.y
= f
->top_pos
;
11404 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
11405 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
11407 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
11408 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
11410 size_hints
.max_width
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
11411 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
11412 size_hints
.max_height
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
11413 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
11415 /* Calculate the base and minimum sizes. */
11417 int base_width
, base_height
;
11419 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
11420 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
11422 /* The window manager uses the base width hints to calculate the
11423 current number of rows and columns in the frame while
11424 resizing; min_width and min_height aren't useful for this
11425 purpose, since they might not give the dimensions for a
11426 zero-row, zero-column frame. */
11428 size_hints
.flags
|= PBaseSize
;
11429 size_hints
.base_width
= base_width
;
11430 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
11431 size_hints
.min_width
= base_width
;
11432 size_hints
.min_height
= base_height
;
11435 /* If we don't need the old flags, we don't need the old hint at all. */
11438 size_hints
.flags
|= flags
;
11443 XSizeHints hints
; /* Sometimes I hate X Windows... */
11444 long supplied_return
;
11447 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
11451 size_hints
.flags
|= flags
;
11456 if (hints
.flags
& PSize
)
11457 size_hints
.flags
|= PSize
;
11458 if (hints
.flags
& PPosition
)
11459 size_hints
.flags
|= PPosition
;
11460 if (hints
.flags
& USPosition
)
11461 size_hints
.flags
|= USPosition
;
11462 if (hints
.flags
& USSize
)
11463 size_hints
.flags
|= USSize
;
11470 size_hints
.win_gravity
= f
->win_gravity
;
11471 size_hints
.flags
|= PWinGravity
;
11475 size_hints
.flags
&= ~ PPosition
;
11476 size_hints
.flags
|= USPosition
;
11478 #endif /* PWinGravity */
11480 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
11482 #endif /* not USE_GTK */
11484 /* Used for IconicState or NormalState */
11487 x_wm_set_window_state (struct frame
*f
, int state
)
11489 #ifdef USE_X_TOOLKIT
11492 XtSetArg (al
[0], XtNinitialState
, state
);
11493 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11494 #else /* not USE_X_TOOLKIT */
11495 Window window
= FRAME_X_WINDOW (f
);
11497 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
11498 f
->output_data
.x
->wm_hints
.initial_state
= state
;
11500 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11501 #endif /* not USE_X_TOOLKIT */
11505 x_wm_set_icon_pixmap (struct frame
*f
, ptrdiff_t pixmap_id
)
11507 Pixmap icon_pixmap
, icon_mask
;
11509 #if !defined USE_X_TOOLKIT && !defined USE_GTK
11510 Window window
= FRAME_OUTER_WINDOW (f
);
11515 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
11516 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
11517 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
11518 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
11522 /* It seems there is no way to turn off use of an icon
11530 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
11534 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
11538 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
11539 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11540 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
11541 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11544 #else /* not USE_X_TOOLKIT && not USE_GTK */
11546 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
11547 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11549 #endif /* not USE_X_TOOLKIT && not USE_GTK */
11553 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
11555 Window window
= FRAME_OUTER_WINDOW (f
);
11557 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
11558 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
11559 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
11561 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11565 /***********************************************************************
11567 ***********************************************************************/
11571 /* Check that FONT is valid on frame F. It is if it can be found in F's
11575 x_check_font (struct frame
*f
, struct font
*font
)
11577 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
11578 if (font
->driver
->check
)
11579 eassert (font
->driver
->check (f
, font
) == 0);
11582 #endif /* GLYPH_DEBUG */
11585 /***********************************************************************
11587 ***********************************************************************/
11589 #ifdef USE_X_TOOLKIT
11590 static XrmOptionDescRec emacs_options
[] = {
11591 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
11592 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
11594 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
11595 XrmoptionSepArg
, NULL
},
11596 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
11598 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11599 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11600 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11601 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
11602 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
11603 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
11604 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
11607 /* Whether atimer for Xt timeouts is activated or not. */
11609 static bool x_timeout_atimer_activated_flag
;
11611 #endif /* USE_X_TOOLKIT */
11613 static int x_initialized
;
11615 /* Test whether two display-name strings agree up to the dot that separates
11616 the screen number from the server number. */
11618 same_x_server (const char *name1
, const char *name2
)
11620 bool seen_colon
= false;
11621 Lisp_Object sysname
= Fsystem_name ();
11622 const char *system_name
= SSDATA (sysname
);
11623 ptrdiff_t system_name_length
= SBYTES (sysname
);
11624 ptrdiff_t length_until_period
= 0;
11626 while (system_name
[length_until_period
] != 0
11627 && system_name
[length_until_period
] != '.')
11628 length_until_period
++;
11630 /* Treat `unix' like an empty host name. */
11631 if (! strncmp (name1
, "unix:", 5))
11633 if (! strncmp (name2
, "unix:", 5))
11635 /* Treat this host's name like an empty host name. */
11636 if (! strncmp (name1
, system_name
, system_name_length
)
11637 && name1
[system_name_length
] == ':')
11638 name1
+= system_name_length
;
11639 if (! strncmp (name2
, system_name
, system_name_length
)
11640 && name2
[system_name_length
] == ':')
11641 name2
+= system_name_length
;
11642 /* Treat this host's domainless name like an empty host name. */
11643 if (! strncmp (name1
, system_name
, length_until_period
)
11644 && name1
[length_until_period
] == ':')
11645 name1
+= length_until_period
;
11646 if (! strncmp (name2
, system_name
, length_until_period
)
11647 && name2
[length_until_period
] == ':')
11648 name2
+= length_until_period
;
11650 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
11654 if (seen_colon
&& *name1
== '.')
11658 && (*name1
== '.' || *name1
== '\0')
11659 && (*name2
== '.' || *name2
== '\0'));
11662 /* Count number of set bits in mask and number of bits to shift to
11663 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
11666 get_bits_and_offset (unsigned long mask
, int *bits
, int *offset
)
11671 while (!(mask
& 1))
11687 /* Return true iff display DISPLAY is available for use.
11688 But don't permanently open it, just test its availability. */
11691 x_display_ok (const char *display
)
11693 /* XOpenDisplay fails if it gets a signal. Block SIGIO which may arrive. */
11694 unrequest_sigio ();
11695 Display
*dpy
= XOpenDisplay (display
);
11699 XCloseDisplay (dpy
);
11705 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
11706 const gchar
*msg
, gpointer user_data
)
11708 if (!strstr (msg
, "g_set_prgname"))
11709 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, msg
);
11713 /* Create invisible cursor on X display referred by DPYINFO. */
11716 make_invisible_cursor (struct x_display_info
*dpyinfo
)
11718 Display
*dpy
= dpyinfo
->display
;
11719 static char const no_data
[] = { 0 };
11724 x_catch_errors (dpy
);
11725 pix
= XCreateBitmapFromData (dpy
, dpyinfo
->root_window
, no_data
, 1, 1);
11726 if (! x_had_errors_p (dpy
) && pix
!= None
)
11730 col
.red
= col
.green
= col
.blue
= 0;
11731 col
.flags
= DoRed
| DoGreen
| DoBlue
;
11732 pixc
= XCreatePixmapCursor (dpy
, pix
, pix
, &col
, &col
, 0, 0);
11733 if (! x_had_errors_p (dpy
) && pixc
!= None
)
11735 XFreePixmap (dpy
, pix
);
11738 x_uncatch_errors ();
11743 /* True if DPY supports Xfixes extension >= 4. */
11746 x_probe_xfixes_extension (Display
*dpy
)
11750 return XFixesQueryVersion (dpy
, &major
, &minor
) && major
>= 4;
11753 #endif /* HAVE_XFIXES */
11756 /* Toggle mouse pointer visibility on frame F by using Xfixes functions. */
11759 xfixes_toggle_visible_pointer (struct frame
*f
, bool invisible
)
11763 XFixesHideCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11765 XFixesShowCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11766 f
->pointer_invisible
= invisible
;
11769 #endif /* HAVE_XFIXES */
11772 /* Toggle mouse pointer visibility on frame F by using invisible cursor. */
11775 x_toggle_visible_pointer (struct frame
*f
, bool invisible
)
11777 eassert (FRAME_DISPLAY_INFO (f
)->invisible_cursor
!= 0);
11779 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11780 FRAME_DISPLAY_INFO (f
)->invisible_cursor
);
11782 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11783 f
->output_data
.x
->current_cursor
);
11784 f
->pointer_invisible
= invisible
;
11787 /* Setup pointer blanking, prefer Xfixes if available. */
11790 x_setup_pointer_blanking (struct x_display_info
*dpyinfo
)
11792 /* FIXME: the brave tester should set EMACS_XFIXES because we're suspecting
11793 X server bug, see http://debbugs.gnu.org/cgi/bugreport.cgi?bug=17609. */
11794 if (egetenv ("EMACS_XFIXES") && x_probe_xfixes_extension (dpyinfo
->display
))
11795 dpyinfo
->toggle_visible_pointer
= xfixes_toggle_visible_pointer
;
11798 dpyinfo
->toggle_visible_pointer
= x_toggle_visible_pointer
;
11799 dpyinfo
->invisible_cursor
= make_invisible_cursor (dpyinfo
);
11803 /* Current X display connection identifier. Incremented for each next
11804 connection established. */
11805 static unsigned x_display_id
;
11807 /* Open a connection to X display DISPLAY_NAME, and return
11808 the structure that describes the open display.
11809 If we cannot contact the display, return null. */
11811 struct x_display_info
*
11812 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
11815 struct terminal
*terminal
;
11816 struct x_display_info
*dpyinfo
;
11819 xcb_connection_t
*xcb_conn
;
11824 if (!x_initialized
)
11830 if (! x_display_ok (SSDATA (display_name
)))
11831 error ("Display %s can't be opened", SSDATA (display_name
));
11835 #define NUM_ARGV 10
11837 char *argv
[NUM_ARGV
];
11838 char **argv2
= argv
;
11841 if (x_initialized
++ > 1)
11843 xg_display_open (SSDATA (display_name
), &dpy
);
11847 static char display_opt
[] = "--display";
11848 static char name_opt
[] = "--name";
11850 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
11854 argv
[argc
++] = initial_argv
[0];
11856 if (! NILP (display_name
))
11858 argv
[argc
++] = display_opt
;
11859 argv
[argc
++] = SSDATA (display_name
);
11862 argv
[argc
++] = name_opt
;
11863 argv
[argc
++] = resource_name
;
11865 XSetLocaleModifiers ("");
11867 /* Work around GLib bug that outputs a faulty warning. See
11868 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
11869 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
11870 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
11872 /* NULL window -> events for all windows go to our function.
11873 Call before gtk_init so Gtk+ event filters comes after our. */
11874 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
11876 /* gtk_init does set_locale. Fix locale before and after. */
11878 unrequest_sigio (); /* See comment in x_display_ok. */
11879 gtk_init (&argc
, &argv2
);
11883 g_log_remove_handler ("GLib", id
);
11887 dpy
= DEFAULT_GDK_DISPLAY ();
11889 #if ! GTK_CHECK_VERSION (2, 90, 0)
11890 /* Load our own gtkrc if it exists. */
11892 const char *file
= "~/.emacs.d/gtkrc";
11893 Lisp_Object s
, abs_file
;
11895 s
= build_string (file
);
11896 abs_file
= Fexpand_file_name (s
, Qnil
);
11898 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
11899 gtk_rc_parse (SSDATA (abs_file
));
11903 XSetErrorHandler (x_error_handler
);
11904 XSetIOErrorHandler (x_io_error_quitter
);
11907 #else /* not USE_GTK */
11908 #ifdef USE_X_TOOLKIT
11909 /* weiner@footloose.sps.mot.com reports that this causes
11911 X protocol error: BadAtom (invalid Atom parameter)
11912 on protocol request 18skiloaf.
11913 So let's not use it until R6. */
11914 #ifdef HAVE_X11XTR6
11915 XtSetLanguageProc (NULL
, NULL
, NULL
);
11926 argv
[argc
++] = "-xrm";
11927 argv
[argc
++] = xrm_option
;
11929 turn_on_atimers (false);
11930 unrequest_sigio (); /* See comment in x_display_ok. */
11931 dpy
= XtOpenDisplay (Xt_app_con
, SSDATA (display_name
),
11932 resource_name
, EMACS_CLASS
,
11933 emacs_options
, XtNumber (emacs_options
),
11936 turn_on_atimers (true);
11938 #ifdef HAVE_X11XTR6
11939 /* I think this is to compensate for XtSetLanguageProc. */
11944 #else /* not USE_X_TOOLKIT */
11945 XSetLocaleModifiers ("");
11946 unrequest_sigio (); // See comment in x_display_ok.
11947 dpy
= XOpenDisplay (SSDATA (display_name
));
11949 #endif /* not USE_X_TOOLKIT */
11950 #endif /* not USE_GTK*/
11952 /* Detect failure. */
11960 xcb_conn
= XGetXCBConnection (dpy
);
11964 xg_display_close (dpy
);
11966 #ifdef USE_X_TOOLKIT
11967 XtCloseDisplay (dpy
);
11969 XCloseDisplay (dpy
);
11971 #endif /* ! USE_GTK */
11978 /* We have definitely succeeded. Record the new connection. */
11980 dpyinfo
= xzalloc (sizeof *dpyinfo
);
11981 terminal
= x_create_terminal (dpyinfo
);
11984 struct x_display_info
*share
;
11986 for (share
= x_display_list
; share
; share
= share
->next
)
11987 if (same_x_server (SSDATA (XCAR (share
->name_list_element
)),
11988 SSDATA (display_name
)))
11991 terminal
->kboard
= share
->terminal
->kboard
;
11994 terminal
->kboard
= allocate_kboard (Qx
);
11996 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
11998 char *vendor
= ServerVendor (dpy
);
12000 /* Temporarily hide the partially initialized terminal. */
12001 terminal_list
= terminal
->next_terminal
;
12003 kset_system_key_alist
12005 call1 (Qvendor_specific_keysyms
,
12006 vendor
? build_string (vendor
) : empty_unibyte_string
));
12008 terminal
->next_terminal
= terminal_list
;
12009 terminal_list
= terminal
;
12012 /* Don't let the initial kboard remain current longer than necessary.
12013 That would cause problems if a file loaded on startup tries to
12014 prompt in the mini-buffer. */
12015 if (current_kboard
== initial_kboard
)
12016 current_kboard
= terminal
->kboard
;
12018 terminal
->kboard
->reference_count
++;
12021 /* Put this display on the chain. */
12022 dpyinfo
->next
= x_display_list
;
12023 x_display_list
= dpyinfo
;
12025 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
12026 dpyinfo
->display
= dpy
;
12027 dpyinfo
->connection
= ConnectionNumber (dpyinfo
->display
);
12029 dpyinfo
->xcb_connection
= xcb_conn
;
12032 /* http://lists.gnu.org/archive/html/emacs-devel/2015-11/msg00194.html */
12033 dpyinfo
->smallest_font_height
= 1;
12034 dpyinfo
->smallest_char_width
= 1;
12036 /* Set the name of the terminal. */
12037 terminal
->name
= xlispstrdup (display_name
);
12040 XSetAfterFunction (x_current_display
, x_trace_wire
);
12043 Lisp_Object system_name
= Fsystem_name ();
12045 if (INT_ADD_WRAPV (SBYTES (Vinvocation_name
), SBYTES (system_name
) + 2,
12047 memory_full (SIZE_MAX
);
12048 dpyinfo
->x_id
= ++x_display_id
;
12049 dpyinfo
->x_id_name
= xmalloc (nbytes
);
12050 char *nametail
= lispstpcpy (dpyinfo
->x_id_name
, Vinvocation_name
);
12052 lispstpcpy (nametail
, system_name
);
12054 /* Figure out which modifier bits mean what. */
12055 x_find_modifier_meanings (dpyinfo
);
12057 /* Get the scroll bar cursor. */
12059 /* We must create a GTK cursor, it is required for GTK widgets. */
12060 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
12061 #endif /* USE_GTK */
12063 dpyinfo
->vertical_scroll_bar_cursor
12064 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
12066 dpyinfo
->horizontal_scroll_bar_cursor
12067 = XCreateFontCursor (dpyinfo
->display
, XC_sb_h_double_arrow
);
12069 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
12070 resource_name
, EMACS_CLASS
);
12071 #ifdef HAVE_XRMSETDATABASE
12072 XrmSetDatabase (dpyinfo
->display
, xrdb
);
12074 dpyinfo
->display
->db
= xrdb
;
12076 /* Put the rdb where we can find it in a way that works on
12078 dpyinfo
->xrdb
= xrdb
;
12080 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
12081 DefaultScreen (dpyinfo
->display
));
12082 select_visual (dpyinfo
);
12083 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
12084 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
12085 dpyinfo
->icon_bitmap_id
= -1;
12086 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
12088 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
12090 /* See if we can construct pixel values from RGB values. */
12091 if (dpyinfo
->visual
->class == TrueColor
)
12093 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
12094 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
12095 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
12096 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
12097 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
12098 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
12101 /* See if a private colormap is requested. */
12102 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
12104 if (dpyinfo
->visual
->class == PseudoColor
)
12106 AUTO_STRING (privateColormap
, "privateColormap");
12107 AUTO_STRING (PrivateColormap
, "PrivateColormap");
12109 = display_x_get_resource (dpyinfo
, privateColormap
,
12110 PrivateColormap
, Qnil
, Qnil
);
12111 if (STRINGP (value
)
12112 && (!strcmp (SSDATA (value
), "true")
12113 || !strcmp (SSDATA (value
), "on")))
12114 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
12118 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
12119 dpyinfo
->visual
, AllocNone
);
12123 /* If we are using Xft, the following precautions should be made:
12125 1. Make sure that the Xrender extension is added before the Xft one.
12126 Otherwise, the close-display hook set by Xft is called after the one
12127 for Xrender, and the former tries to re-add the latter. This results
12128 in inconsistency of internal states and leads to X protocol error when
12129 one reconnects to the same X server (Bug#1696).
12131 2. Check dpi value in X resources. It is better we use it as well,
12132 since Xft will use it, as will all Gnome applications. If our real DPI
12133 is smaller or larger than the one Xft uses, our font will look smaller
12134 or larger than other for other applications, even if it is the same
12135 font name (monospace-10 for example). */
12137 int event_base
, error_base
;
12141 XRenderQueryExtension (dpyinfo
->display
, &event_base
, &error_base
);
12143 v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
12144 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
12145 dpyinfo
->resy
= dpyinfo
->resx
= d
;
12149 if (dpyinfo
->resy
< 1)
12151 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
12152 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
12153 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
12154 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
12155 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
12156 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
12157 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
12158 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
12159 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
12163 static const struct
12168 #define ATOM_REFS_INIT(string, member) \
12169 { string, offsetof (struct x_display_info, member) },
12170 ATOM_REFS_INIT ("WM_PROTOCOLS", Xatom_wm_protocols
)
12171 ATOM_REFS_INIT ("WM_TAKE_FOCUS", Xatom_wm_take_focus
)
12172 ATOM_REFS_INIT ("WM_SAVE_YOURSELF", Xatom_wm_save_yourself
)
12173 ATOM_REFS_INIT ("WM_DELETE_WINDOW", Xatom_wm_delete_window
)
12174 ATOM_REFS_INIT ("WM_CHANGE_STATE", Xatom_wm_change_state
)
12175 ATOM_REFS_INIT ("WM_CONFIGURE_DENIED", Xatom_wm_configure_denied
)
12176 ATOM_REFS_INIT ("WM_MOVED", Xatom_wm_window_moved
)
12177 ATOM_REFS_INIT ("WM_CLIENT_LEADER", Xatom_wm_client_leader
)
12178 ATOM_REFS_INIT ("Editres", Xatom_editres
)
12179 ATOM_REFS_INIT ("CLIPBOARD", Xatom_CLIPBOARD
)
12180 ATOM_REFS_INIT ("TIMESTAMP", Xatom_TIMESTAMP
)
12181 ATOM_REFS_INIT ("TEXT", Xatom_TEXT
)
12182 ATOM_REFS_INIT ("COMPOUND_TEXT", Xatom_COMPOUND_TEXT
)
12183 ATOM_REFS_INIT ("UTF8_STRING", Xatom_UTF8_STRING
)
12184 ATOM_REFS_INIT ("DELETE", Xatom_DELETE
)
12185 ATOM_REFS_INIT ("MULTIPLE", Xatom_MULTIPLE
)
12186 ATOM_REFS_INIT ("INCR", Xatom_INCR
)
12187 ATOM_REFS_INIT ("_EMACS_TMP_", Xatom_EMACS_TMP
)
12188 ATOM_REFS_INIT ("TARGETS", Xatom_TARGETS
)
12189 ATOM_REFS_INIT ("NULL", Xatom_NULL
)
12190 ATOM_REFS_INIT ("ATOM", Xatom_ATOM
)
12191 ATOM_REFS_INIT ("ATOM_PAIR", Xatom_ATOM_PAIR
)
12192 ATOM_REFS_INIT ("CLIPBOARD_MANAGER", Xatom_CLIPBOARD_MANAGER
)
12193 ATOM_REFS_INIT ("_XEMBED_INFO", Xatom_XEMBED_INFO
)
12194 /* For properties of font. */
12195 ATOM_REFS_INIT ("PIXEL_SIZE", Xatom_PIXEL_SIZE
)
12196 ATOM_REFS_INIT ("AVERAGE_WIDTH", Xatom_AVERAGE_WIDTH
)
12197 ATOM_REFS_INIT ("_MULE_BASELINE_OFFSET", Xatom_MULE_BASELINE_OFFSET
)
12198 ATOM_REFS_INIT ("_MULE_RELATIVE_COMPOSE", Xatom_MULE_RELATIVE_COMPOSE
)
12199 ATOM_REFS_INIT ("_MULE_DEFAULT_ASCENT", Xatom_MULE_DEFAULT_ASCENT
)
12200 /* Ghostscript support. */
12201 ATOM_REFS_INIT ("DONE", Xatom_DONE
)
12202 ATOM_REFS_INIT ("PAGE", Xatom_PAGE
)
12203 ATOM_REFS_INIT ("SCROLLBAR", Xatom_Scrollbar
)
12204 ATOM_REFS_INIT ("HORIZONTAL_SCROLLBAR", Xatom_Horizontal_Scrollbar
)
12205 ATOM_REFS_INIT ("_XEMBED", Xatom_XEMBED
)
12207 ATOM_REFS_INIT ("_NET_WM_STATE", Xatom_net_wm_state
)
12208 ATOM_REFS_INIT ("_NET_WM_STATE_FULLSCREEN", Xatom_net_wm_state_fullscreen
)
12209 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_HORZ",
12210 Xatom_net_wm_state_maximized_horz
)
12211 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_VERT",
12212 Xatom_net_wm_state_maximized_vert
)
12213 ATOM_REFS_INIT ("_NET_WM_STATE_STICKY", Xatom_net_wm_state_sticky
)
12214 ATOM_REFS_INIT ("_NET_WM_STATE_HIDDEN", Xatom_net_wm_state_hidden
)
12215 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE", Xatom_net_window_type
)
12216 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE_TOOLTIP",
12217 Xatom_net_window_type_tooltip
)
12218 ATOM_REFS_INIT ("_NET_WM_ICON_NAME", Xatom_net_wm_icon_name
)
12219 ATOM_REFS_INIT ("_NET_WM_NAME", Xatom_net_wm_name
)
12220 ATOM_REFS_INIT ("_NET_SUPPORTED", Xatom_net_supported
)
12221 ATOM_REFS_INIT ("_NET_SUPPORTING_WM_CHECK", Xatom_net_supporting_wm_check
)
12222 ATOM_REFS_INIT ("_NET_WM_WINDOW_OPACITY", Xatom_net_wm_window_opacity
)
12223 ATOM_REFS_INIT ("_NET_ACTIVE_WINDOW", Xatom_net_active_window
)
12224 ATOM_REFS_INIT ("_NET_FRAME_EXTENTS", Xatom_net_frame_extents
)
12225 ATOM_REFS_INIT ("_NET_CURRENT_DESKTOP", Xatom_net_current_desktop
)
12226 ATOM_REFS_INIT ("_NET_WORKAREA", Xatom_net_workarea
)
12227 /* Session management */
12228 ATOM_REFS_INIT ("SM_CLIENT_ID", Xatom_SM_CLIENT_ID
)
12229 ATOM_REFS_INIT ("_XSETTINGS_SETTINGS", Xatom_xsettings_prop
)
12230 ATOM_REFS_INIT ("MANAGER", Xatom_xsettings_mgr
)
12234 enum { atom_count
= ARRAYELTS (atom_refs
) };
12235 /* 1 for _XSETTINGS_SN. */
12236 enum { total_atom_count
= 1 + atom_count
};
12237 Atom atoms_return
[total_atom_count
];
12238 char *atom_names
[total_atom_count
];
12239 static char const xsettings_fmt
[] = "_XSETTINGS_S%d";
12240 char xsettings_atom_name
[sizeof xsettings_fmt
- 2
12241 + INT_STRLEN_BOUND (int)];
12243 for (i
= 0; i
< atom_count
; i
++)
12244 atom_names
[i
] = (char *) atom_refs
[i
].name
;
12246 /* Build _XSETTINGS_SN atom name. */
12247 sprintf (xsettings_atom_name
, xsettings_fmt
,
12248 XScreenNumberOfScreen (dpyinfo
->screen
));
12249 atom_names
[i
] = xsettings_atom_name
;
12251 XInternAtoms (dpyinfo
->display
, atom_names
, total_atom_count
,
12252 False
, atoms_return
);
12254 for (i
= 0; i
< atom_count
; i
++)
12255 *(Atom
*) ((char *) dpyinfo
+ atom_refs
[i
].offset
) = atoms_return
[i
];
12257 /* Manually copy last atom. */
12258 dpyinfo
->Xatom_xsettings_sel
= atoms_return
[i
];
12261 dpyinfo
->x_dnd_atoms_size
= 8;
12262 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof *dpyinfo
->x_dnd_atoms
12263 * dpyinfo
->x_dnd_atoms_size
);
12265 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
12266 gray_bits
, gray_width
, gray_height
,
12269 x_setup_pointer_blanking (dpyinfo
);
12272 xim_initialize (dpyinfo
, resource_name
);
12275 xsettings_initialize (dpyinfo
);
12277 /* This is only needed for distinguishing keyboard and process input. */
12278 if (dpyinfo
->connection
!= 0)
12279 add_keyboard_wait_descriptor (dpyinfo
->connection
);
12282 fcntl (dpyinfo
->connection
, F_SETOWN
, getpid ());
12283 #endif /* ! defined (F_SETOWN) */
12285 if (interrupt_input
)
12286 init_sigio (dpyinfo
->connection
);
12290 XrmValue d
, fr
, to
;
12293 dpy
= dpyinfo
->display
;
12294 d
.addr
= (XPointer
)&dpy
;
12295 d
.size
= sizeof (Display
*);
12296 fr
.addr
= XtDefaultFont
;
12297 fr
.size
= sizeof (XtDefaultFont
);
12298 to
.size
= sizeof (Font
*);
12299 to
.addr
= (XPointer
)&font
;
12300 x_catch_errors (dpy
);
12301 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
12303 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
12304 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
12305 /* Do not free XFontStruct returned by the above call to XQueryFont.
12306 This leads to X protocol errors at XtCloseDisplay (Bug#18403). */
12307 x_uncatch_errors ();
12311 /* See if we should run in synchronous mode. This is useful
12312 for debugging X code. */
12314 AUTO_STRING (synchronous
, "synchronous");
12315 AUTO_STRING (Synchronous
, "Synchronous");
12316 Lisp_Object value
= display_x_get_resource (dpyinfo
, synchronous
,
12317 Synchronous
, Qnil
, Qnil
);
12318 if (STRINGP (value
)
12319 && (!strcmp (SSDATA (value
), "true")
12320 || !strcmp (SSDATA (value
), "on")))
12321 XSynchronize (dpyinfo
->display
, True
);
12325 AUTO_STRING (useXIM
, "useXIM");
12326 AUTO_STRING (UseXIM
, "UseXIM");
12327 Lisp_Object value
= display_x_get_resource (dpyinfo
, useXIM
, UseXIM
,
12330 if (STRINGP (value
)
12331 && (!strcmp (SSDATA (value
), "false")
12332 || !strcmp (SSDATA (value
), "off")))
12335 if (STRINGP (value
)
12336 && (!strcmp (SSDATA (value
), "true")
12337 || !strcmp (SSDATA (value
), "on")))
12343 /* Only do this for the very first display in the Emacs session.
12344 Ignore X session management when Emacs was first started on a
12345 tty or started as a daemon. */
12346 if (terminal
->id
== 1 && ! IS_DAEMON
)
12347 x_session_initialize (dpyinfo
);
12351 x_extension_initialize (dpyinfo
);
12359 /* Get rid of display DPYINFO, deleting all frames on it,
12360 and without sending any more commands to the X server. */
12363 x_delete_display (struct x_display_info
*dpyinfo
)
12365 struct terminal
*t
;
12366 struct color_name_cache_entry
*color_entry
, *next_color_entry
;
12368 /* Close all frames and delete the generic struct terminal for this
12370 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
12371 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
12374 /* Close X session management when we close its display. */
12375 if (t
->id
== 1 && x_session_have_connection ())
12376 x_session_close ();
12378 delete_terminal (t
);
12382 if (next_noop_dpyinfo
== dpyinfo
)
12383 next_noop_dpyinfo
= dpyinfo
->next
;
12385 if (x_display_list
== dpyinfo
)
12386 x_display_list
= dpyinfo
->next
;
12389 struct x_display_info
*tail
;
12391 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
12392 if (tail
->next
== dpyinfo
)
12393 tail
->next
= tail
->next
->next
;
12396 for (color_entry
= dpyinfo
->color_names
;
12398 color_entry
= next_color_entry
)
12400 next_color_entry
= color_entry
->next
;
12401 xfree (color_entry
->name
);
12402 xfree (color_entry
);
12405 xfree (dpyinfo
->x_id_name
);
12406 xfree (dpyinfo
->x_dnd_atoms
);
12407 xfree (dpyinfo
->color_cells
);
12411 #ifdef USE_X_TOOLKIT
12413 /* Atimer callback function for TIMER. Called every 0.1s to process
12414 Xt timeouts, if needed. We must avoid calling XtAppPending as
12415 much as possible because that function does an implicit XFlush
12416 that slows us down. */
12419 x_process_timeouts (struct atimer
*timer
)
12422 x_timeout_atimer_activated_flag
= false;
12423 if (toolkit_scroll_bar_interaction
|| popup_activated ())
12425 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
12426 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
12427 /* Reactivate the atimer for next time. */
12428 x_activate_timeout_atimer ();
12433 /* Install an asynchronous timer that processes Xt timeout events
12434 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
12435 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
12436 function whenever these variables are set. This is necessary
12437 because some widget sets use timeouts internally, for example the
12438 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
12439 processed, these widgets don't behave normally. */
12442 x_activate_timeout_atimer (void)
12445 if (!x_timeout_atimer_activated_flag
)
12447 struct timespec interval
= make_timespec (0, 100 * 1000 * 1000);
12448 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
12449 x_timeout_atimer_activated_flag
= true;
12454 #endif /* USE_X_TOOLKIT */
12457 /* Set up use of X before we make the first connection. */
12459 static struct redisplay_interface x_redisplay_interface
=
12461 x_frame_parm_handlers
,
12465 x_clear_end_of_line
,
12467 x_after_update_window_line
,
12468 x_update_window_begin
,
12469 x_update_window_end
,
12471 x_clear_window_mouse_face
,
12472 x_get_glyph_overhangs
,
12473 x_fix_overlapping_area
,
12474 x_draw_fringe_bitmap
,
12476 x_cr_define_fringe_bitmap
,
12477 x_cr_destroy_fringe_bitmap
,
12479 0, /* define_fringe_bitmap */
12480 0, /* destroy_fringe_bitmap */
12482 x_compute_glyph_string_overhangs
,
12483 x_draw_glyph_string
,
12484 x_define_frame_cursor
,
12485 x_clear_frame_area
,
12486 x_draw_window_cursor
,
12487 x_draw_vertical_window_border
,
12488 x_draw_window_divider
,
12489 x_shift_glyphs_for_insert
, /* Never called; see comment in function. */
12495 /* This function is called when the last frame on a display is deleted. */
12497 x_delete_terminal (struct terminal
*terminal
)
12499 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
12501 /* Protect against recursive calls. delete_frame in
12502 delete_terminal calls us back when it deletes our last frame. */
12503 if (!terminal
->name
)
12508 /* We must close our connection to the XIM server before closing the
12511 xim_close_dpy (dpyinfo
);
12514 /* Normally, the display is available... */
12515 if (dpyinfo
->display
)
12517 x_destroy_all_bitmaps (dpyinfo
);
12518 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
12520 /* Whether or not XCloseDisplay destroys the associated resource
12521 database depends on the version of libX11. To avoid both
12522 crash and memory leak, we dissociate the database from the
12523 display and then destroy dpyinfo->xrdb ourselves.
12525 Unfortunately, the above strategy does not work in some
12526 situations due to a bug in newer versions of libX11: because
12527 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
12528 dpy->db is NULL, XCloseDisplay destroys the associated
12529 database whereas it has not been created by XGetDefault
12530 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
12531 don't destroy the database here in order to avoid the crash
12532 in the above situations for now, though that may cause memory
12533 leaks in other situations. */
12535 #ifdef HAVE_XRMSETDATABASE
12536 XrmSetDatabase (dpyinfo
->display
, NULL
);
12538 dpyinfo
->display
->db
= NULL
;
12540 /* We used to call XrmDestroyDatabase from x_delete_display, but
12541 some older versions of libX11 crash if we call it after
12542 closing all the displays. */
12543 XrmDestroyDatabase (dpyinfo
->xrdb
);
12547 xg_display_close (dpyinfo
->display
);
12549 #ifdef USE_X_TOOLKIT
12550 XtCloseDisplay (dpyinfo
->display
);
12552 XCloseDisplay (dpyinfo
->display
);
12554 #endif /* ! USE_GTK */
12555 /* Do not close the connection here because it's already closed
12556 by X(t)CloseDisplay (Bug#18403). */
12557 dpyinfo
->display
= NULL
;
12560 /* ...but if called from x_connection_closed, the display may already
12561 be closed and dpyinfo->display was set to 0 to indicate that. Since
12562 X server is most likely gone, explicit close is the only reliable
12563 way to continue and avoid Bug#19147. */
12564 else if (dpyinfo
->connection
>= 0)
12565 emacs_close (dpyinfo
->connection
);
12567 /* No more input on this descriptor. */
12568 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
12569 /* Mark as dead. */
12570 dpyinfo
->connection
= -1;
12572 x_delete_display (dpyinfo
);
12576 /* Create a struct terminal, initialize it with the X11 specific
12577 functions and make DISPLAY->TERMINAL point to it. */
12579 static struct terminal
*
12580 x_create_terminal (struct x_display_info
*dpyinfo
)
12582 struct terminal
*terminal
;
12584 terminal
= create_terminal (output_x_window
, &x_redisplay_interface
);
12586 terminal
->display_info
.x
= dpyinfo
;
12587 dpyinfo
->terminal
= terminal
;
12589 /* kboard is initialized in x_term_init. */
12591 terminal
->clear_frame_hook
= x_clear_frame
;
12592 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
12593 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
12594 terminal
->ring_bell_hook
= XTring_bell
;
12595 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
12596 terminal
->update_begin_hook
= x_update_begin
;
12597 terminal
->update_end_hook
= x_update_end
;
12598 terminal
->read_socket_hook
= XTread_socket
;
12599 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
12600 terminal
->mouse_position_hook
= XTmouse_position
;
12601 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
12602 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
12603 terminal
->fullscreen_hook
= XTfullscreen_hook
;
12604 terminal
->menu_show_hook
= x_menu_show
;
12605 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
12606 terminal
->popup_dialog_hook
= xw_popup_dialog
;
12608 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
12609 terminal
->set_horizontal_scroll_bar_hook
= XTset_horizontal_scroll_bar
;
12610 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
12611 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
12612 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
12613 terminal
->delete_frame_hook
= x_destroy_window
;
12614 terminal
->delete_terminal_hook
= x_delete_terminal
;
12615 /* Other hooks are NULL by default. */
12621 x_initialize (void)
12626 any_help_event_p
= false;
12627 ignore_next_mouse_click_timeout
= 0;
12630 current_count
= -1;
12633 /* Try to use interrupt input; if we can't, then start polling. */
12634 Fset_input_interrupt_mode (Qt
);
12636 #ifdef USE_X_TOOLKIT
12637 XtToolkitInitialize ();
12639 Xt_app_con
= XtCreateApplicationContext ();
12641 /* Register a converter from strings to pixels, which uses
12642 Emacs' color allocation infrastructure. */
12643 XtAppSetTypeConverter (Xt_app_con
,
12644 XtRString
, XtRPixel
, cvt_string_to_pixel
,
12645 cvt_string_to_pixel_args
,
12646 XtNumber (cvt_string_to_pixel_args
),
12647 XtCacheByDisplay
, cvt_pixel_dtor
);
12649 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
12652 #ifdef USE_TOOLKIT_SCROLL_BARS
12654 xaw3d_arrow_scroll
= False
;
12655 xaw3d_pick_top
= True
;
12660 x_cr_init_fringe (&x_redisplay_interface
);
12663 /* Note that there is no real way portable across R3/R4 to get the
12664 original error handler. */
12665 XSetErrorHandler (x_error_handler
);
12666 XSetIOErrorHandler (x_io_error_quitter
);
12673 /* Emacs can handle only core input events, so make sure
12674 Gtk doesn't use Xinput or Xinput2 extensions. */
12675 xputenv ("GDK_CORE_DEVICE_EVENTS=1");
12680 syms_of_xterm (void)
12682 x_error_message
= NULL
;
12684 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
12685 DEFSYM (Qlatin_1
, "latin-1");
12688 xg_default_icon_file
= build_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
12689 staticpro (&xg_default_icon_file
);
12691 DEFSYM (Qx_gtk_map_stock
, "x-gtk-map-stock");
12694 DEFVAR_BOOL ("x-use-underline-position-properties",
12695 x_use_underline_position_properties
,
12696 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
12697 A value of nil means ignore them. If you encounter fonts with bogus
12698 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
12699 to 4.1, set this to nil. You can also use `underline-minimum-offset'
12700 to override the font's UNDERLINE_POSITION for small font display
12702 x_use_underline_position_properties
= true;
12704 DEFVAR_BOOL ("x-underline-at-descent-line",
12705 x_underline_at_descent_line
,
12706 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
12707 A value of nil means to draw the underline according to the value of the
12708 variable `x-use-underline-position-properties', which is usually at the
12709 baseline level. The default value is nil. */);
12710 x_underline_at_descent_line
= false;
12712 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
12713 x_mouse_click_focus_ignore_position
,
12714 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
12715 This variable is only used when the window manager requires that you
12716 click on a frame to select it (give it focus). In that case, a value
12717 of nil, means that the selected window and cursor position changes to
12718 reflect the mouse click position, while a non-nil value means that the
12719 selected window or cursor position is preserved. */);
12720 x_mouse_click_focus_ignore_position
= false;
12722 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
12723 doc
: /* Which toolkit scroll bars Emacs uses, if any.
12724 A value of nil means Emacs doesn't use toolkit scroll bars.
12725 With the X Window system, the value is a symbol describing the
12726 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
12727 With MS Windows or Nextstep, the value is t. */);
12728 #ifdef USE_TOOLKIT_SCROLL_BARS
12730 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
12731 #elif defined HAVE_XAW3D
12732 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
12734 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
12736 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
12739 Vx_toolkit_scroll_bars
= Qnil
;
12742 DEFSYM (Qmodifier_value
, "modifier-value");
12743 DEFSYM (Qalt
, "alt");
12744 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
12745 DEFSYM (Qhyper
, "hyper");
12746 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
12747 DEFSYM (Qmeta
, "meta");
12748 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
12749 DEFSYM (Qsuper
, "super");
12750 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
12752 DEFVAR_LISP ("x-alt-keysym", Vx_alt_keysym
,
12753 doc
: /* Which keys Emacs uses for the alt modifier.
12754 This should be one of the symbols `alt', `hyper', `meta', `super'.
12755 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
12756 is nil, which is the same as `alt'. */);
12757 Vx_alt_keysym
= Qnil
;
12759 DEFVAR_LISP ("x-hyper-keysym", Vx_hyper_keysym
,
12760 doc
: /* Which keys Emacs uses for the hyper modifier.
12761 This should be one of the symbols `alt', `hyper', `meta', `super'.
12762 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
12763 default is nil, which is the same as `hyper'. */);
12764 Vx_hyper_keysym
= Qnil
;
12766 DEFVAR_LISP ("x-meta-keysym", Vx_meta_keysym
,
12767 doc
: /* Which keys Emacs uses for the meta modifier.
12768 This should be one of the symbols `alt', `hyper', `meta', `super'.
12769 For example, `meta' means use the Meta_L and Meta_R keysyms. The
12770 default is nil, which is the same as `meta'. */);
12771 Vx_meta_keysym
= Qnil
;
12773 DEFVAR_LISP ("x-super-keysym", Vx_super_keysym
,
12774 doc
: /* Which keys Emacs uses for the super modifier.
12775 This should be one of the symbols `alt', `hyper', `meta', `super'.
12776 For example, `super' means use the Super_L and Super_R keysyms. The
12777 default is nil, which is the same as `super'. */);
12778 Vx_super_keysym
= Qnil
;
12780 DEFVAR_LISP ("x-keysym-table", Vx_keysym_table
,
12781 doc
: /* Hash table of character codes indexed by X keysym codes. */);
12782 Vx_keysym_table
= make_hash_table (hashtest_eql
, make_number (900),
12783 make_float (DEFAULT_REHASH_SIZE
),
12784 make_float (DEFAULT_REHASH_THRESHOLD
),
12787 DEFVAR_BOOL ("x-frame-normalize-before-maximize",
12788 x_frame_normalize_before_maximize
,
12789 doc
: /* Non-nil means normalize frame before maximizing.
12790 If this variable is t, Emacs first asks the window manager to give the
12791 frame its normal size, and only then the final state, whenever changing
12792 from a full-height, full-width or full-both state to the maximized one
12793 or when changing from the maximized to the full-height or full-width
12796 Set this variable only if your window manager cannot handle the
12797 transition between the various maximization states. */);
12798 x_frame_normalize_before_maximize
= false;