1 /* X Communication module for terminals which understand the X protocol.
3 Copyright (C) 1989, 1993-2015 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"
31 #include "syssignal.h"
33 /* This may include sys/types.h, and that somehow loses
34 if this is not done before the other system files. */
36 #include <X11/cursorfont.h>
38 /* If we have Xfixes extension, use it for pointer blanking. */
40 #include <X11/extensions/Xfixes.h>
43 /* Using Xft implies that XRender is available. */
45 #include <X11/extensions/Xrender.h>
48 /* Load sys/types.h if not already loaded.
49 In some systems loading it twice is suicidal. */
51 #include <sys/types.h>
54 #include <sys/ioctl.h>
61 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
62 /* #include <sys/param.h> */
65 #include "character.h"
68 #include "dispextern.h"
70 #include "termhooks.h"
73 #include "emacs-icon.h"
78 #include "intervals.h"
83 #include "xsettings.h"
85 #include "sysselect.h"
89 #include <X11/Shell.h>
97 #include <X11/Xproto.h>
101 #if defined (USE_LUCID) || defined (USE_MOTIF)
102 #include "../lwlib/xlwmenu.h"
106 #if !defined (NO_EDITRES)
108 extern void _XEditResCheckMessages (Widget
, XtPointer
, XEvent
*, Boolean
*);
109 #endif /* not NO_EDITRES */
111 /* Include toolkit specific headers for the scroll bar widget. */
113 #ifdef USE_TOOLKIT_SCROLL_BARS
114 #if defined USE_MOTIF
115 #include <Xm/Xm.h> /* For LESSTIF_VERSION */
116 #include <Xm/ScrollBar.h>
117 #else /* !USE_MOTIF i.e. use Xaw */
120 #include <X11/Xaw3d/Simple.h>
121 #include <X11/Xaw3d/Scrollbar.h>
122 #include <X11/Xaw3d/ThreeD.h>
123 #else /* !HAVE_XAW3D */
124 #include <X11/Xaw/Simple.h>
125 #include <X11/Xaw/Scrollbar.h>
126 #endif /* !HAVE_XAW3D */
128 #define XtNpickTop "pickTop"
129 #endif /* !XtNpickTop */
130 #endif /* !USE_MOTIF */
131 #endif /* USE_TOOLKIT_SCROLL_BARS */
133 #endif /* USE_X_TOOLKIT */
137 #ifndef XtNinitialState
138 #define XtNinitialState "initialState"
142 #include "bitmaps/gray.xbm"
145 #include <X11/XKBlib.h>
148 /* Default to using XIM if available. */
152 bool use_xim
= false; /* configure --without-xim */
155 /* Non-zero means that a HELP_EVENT has been generated since Emacs
158 static bool any_help_event_p
;
160 /* This is a chain of structures for all the X displays currently in
163 struct x_display_info
*x_display_list
;
167 /* The application context for Xt use. */
168 XtAppContext Xt_app_con
;
169 static String Xt_default_resources
[] = {0};
171 /* Non-zero means user is interacting with a toolkit scroll bar. */
172 static bool toolkit_scroll_bar_interaction
;
174 #endif /* USE_X_TOOLKIT */
176 /* Non-zero timeout value means ignore next mouse click if it arrives
177 before that timeout elapses (i.e. as part of the same sequence of
178 events resulting from clicking on a frame to select it). */
180 static Time ignore_next_mouse_click_timeout
;
182 /* Used locally within XTread_socket. */
184 static int x_noop_count
;
187 /* The name of the Emacs icon file. */
188 static Lisp_Object xg_default_icon_file
;
191 /* Some functions take this as char *, not const char *. */
192 static char emacs_class
[] = EMACS_CLASS
;
196 XEMBED_MAPPED
= 1 << 0
201 XEMBED_EMBEDDED_NOTIFY
= 0,
202 XEMBED_WINDOW_ACTIVATE
= 1,
203 XEMBED_WINDOW_DEACTIVATE
= 2,
204 XEMBED_REQUEST_FOCUS
= 3,
206 XEMBED_FOCUS_OUT
= 5,
207 XEMBED_FOCUS_NEXT
= 6,
208 XEMBED_FOCUS_PREV
= 7,
210 XEMBED_MODALITY_ON
= 10,
211 XEMBED_MODALITY_OFF
= 11,
212 XEMBED_REGISTER_ACCELERATOR
= 12,
213 XEMBED_UNREGISTER_ACCELERATOR
= 13,
214 XEMBED_ACTIVATE_ACCELERATOR
= 14
217 static void x_free_cr_resources (struct frame
*);
218 static bool x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
219 static void x_raise_frame (struct frame
*);
220 static void x_lower_frame (struct frame
*);
221 static int x_io_error_quitter (Display
*);
222 static struct terminal
*x_create_terminal (struct x_display_info
*);
223 static void x_frame_rehighlight (struct x_display_info
*);
225 static void x_clip_to_row (struct window
*, struct glyph_row
*,
226 enum glyph_row_area
, GC
);
227 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
, int);
228 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
229 enum scroll_bar_part
*,
230 Lisp_Object
*, Lisp_Object
*,
232 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
233 enum scroll_bar_part
*,
234 Lisp_Object
*, Lisp_Object
*,
236 static bool x_handle_net_wm_state (struct frame
*, const XPropertyEvent
*);
237 static void x_check_fullscreen (struct frame
*);
238 static void x_check_expected_move (struct frame
*, int, int);
239 static void x_sync_with_move (struct frame
*, int, int, bool);
240 static int handle_one_xevent (struct x_display_info
*,
241 const XEvent
*, int *,
242 struct input_event
*);
243 #if ! (defined USE_X_TOOLKIT || defined USE_MOTIF)
244 static int x_dispatch_event (XEvent
*, Display
*);
246 static void x_wm_set_window_state (struct frame
*, int);
247 static void x_wm_set_icon_pixmap (struct frame
*, ptrdiff_t);
248 static void x_initialize (void);
250 static bool get_current_wm_state (struct frame
*, Window
, int *, bool *);
252 /* Flush display of frame F. */
255 x_flush (struct frame
*f
)
257 eassert (f
&& FRAME_X_P (f
));
258 /* Don't call XFlush when it is not safe to redisplay; the X
259 connection may be broken. */
260 if (!NILP (Vinhibit_redisplay
))
264 XFlush (FRAME_X_DISPLAY (f
));
269 /* Remove calls to XFlush by defining XFlush to an empty replacement.
270 Calls to XFlush should be unnecessary because the X output buffer
271 is flushed automatically as needed by calls to XPending,
272 XNextEvent, or XWindowEvent according to the XFlush man page.
273 XTread_socket calls XPending. Removing XFlush improves
276 #define XFlush(DISPLAY) (void) 0
279 /***********************************************************************
281 ***********************************************************************/
285 /* This is a function useful for recording debugging information about
286 the sequence of occurrences in this file. */
294 struct record event_record
[100];
296 int event_record_index
;
299 record_event (char *locus
, int type
)
301 if (event_record_index
== ARRAYELTS (event_record
))
302 event_record_index
= 0;
304 event_record
[event_record_index
].locus
= locus
;
305 event_record
[event_record_index
].type
= type
;
306 event_record_index
++;
313 #define FRAME_CR_CONTEXT(f) ((f)->output_data.x->cr_context)
314 #define FRAME_CR_SURFACE(f) ((f)->output_data.x->cr_surface)
316 static struct x_gc_ext_data
*
317 x_gc_get_ext_data (struct frame
*f
, GC gc
, int create_if_not_found_p
)
319 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
321 XExtData
**head
, *ext_data
;
324 head
= XEHeadOfExtensionList (object
);
325 ext_data
= XFindOnExtensionList (head
, dpyinfo
->ext_codes
->extension
);
326 if (ext_data
== NULL
)
328 if (!create_if_not_found_p
)
332 ext_data
= xzalloc (sizeof (*ext_data
));
333 ext_data
->number
= dpyinfo
->ext_codes
->extension
;
334 ext_data
->private_data
= xzalloc (sizeof (struct x_gc_ext_data
));
335 XAddToExtensionList (head
, ext_data
);
338 return (struct x_gc_ext_data
*) ext_data
->private_data
;
342 x_extension_initialize (struct x_display_info
*dpyinfo
)
344 XExtCodes
*ext_codes
= XAddExtension (dpyinfo
->display
);
346 dpyinfo
->ext_codes
= ext_codes
;
350 x_cr_destroy_surface (struct frame
*f
)
352 if (FRAME_CR_SURFACE (f
))
354 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
355 cairo_surface_destroy (FRAME_CR_SURFACE (f
));
356 FRAME_CR_SURFACE (f
) = 0;
357 if (cr
) cairo_destroy (cr
);
358 FRAME_CR_CONTEXT (f
) = NULL
;
363 x_begin_cr_clip (struct frame
*f
, GC gc
)
365 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
370 if (! FRAME_CR_SURFACE (f
))
372 cairo_surface_t
*surface
;
373 surface
= cairo_xlib_surface_create (FRAME_X_DISPLAY (f
),
375 FRAME_DISPLAY_INFO (f
)->visual
,
376 FRAME_PIXEL_WIDTH (f
),
377 FRAME_PIXEL_HEIGHT (f
));
378 cr
= cairo_create (surface
);
379 cairo_surface_destroy (surface
);
382 cr
= cairo_create (FRAME_CR_SURFACE (f
));
383 FRAME_CR_CONTEXT (f
) = cr
;
389 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 0);
391 if (gc_ext
&& gc_ext
->n_clip_rects
)
395 for (i
= 0; i
< gc_ext
->n_clip_rects
; i
++)
396 cairo_rectangle (cr
, gc_ext
->clip_rects
[i
].x
,
397 gc_ext
->clip_rects
[i
].y
,
398 gc_ext
->clip_rects
[i
].width
,
399 gc_ext
->clip_rects
[i
].height
);
408 x_end_cr_clip (struct frame
*f
)
410 cairo_restore (FRAME_CR_CONTEXT (f
));
414 x_set_cr_source_with_gc_foreground (struct frame
*f
, GC gc
)
419 XGetGCValues (FRAME_X_DISPLAY (f
), gc
, GCForeground
, &xgcv
);
420 color
.pixel
= xgcv
.foreground
;
421 x_query_color (f
, &color
);
422 cairo_set_source_rgb (FRAME_CR_CONTEXT (f
), color
.red
/ 65535.0,
423 color
.green
/ 65535.0, color
.blue
/ 65535.0);
427 x_set_cr_source_with_gc_background (struct frame
*f
, GC gc
)
432 XGetGCValues (FRAME_X_DISPLAY (f
), gc
, GCBackground
, &xgcv
);
433 color
.pixel
= xgcv
.background
;
434 x_query_color (f
, &color
);
435 cairo_set_source_rgb (FRAME_CR_CONTEXT (f
), color
.red
/ 65535.0,
436 color
.green
/ 65535.0, color
.blue
/ 65535.0);
439 /* Fringe bitmaps. */
441 static int max_fringe_bmp
= 0;
442 static cairo_pattern_t
**fringe_bmp
= 0;
445 x_cr_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
448 cairo_surface_t
*surface
;
450 cairo_pattern_t
*pattern
;
452 if (which
>= max_fringe_bmp
)
455 max_fringe_bmp
= which
+ 20;
456 fringe_bmp
= (cairo_pattern_t
**) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (cairo_pattern_t
*));
457 while (i
< max_fringe_bmp
)
463 surface
= cairo_image_surface_create (CAIRO_FORMAT_A1
, wd
, h
);
464 stride
= cairo_image_surface_get_stride (surface
);
465 data
= cairo_image_surface_get_data (surface
);
467 for (i
= 0; i
< h
; i
++)
469 *((unsigned short *) data
) = bits
[i
];
473 cairo_surface_mark_dirty (surface
);
474 pattern
= cairo_pattern_create_for_surface (surface
);
475 cairo_surface_destroy (surface
);
479 fringe_bmp
[which
] = pattern
;
483 x_cr_destroy_fringe_bitmap (int which
)
485 if (which
>= max_fringe_bmp
)
488 if (fringe_bmp
[which
])
491 cairo_pattern_destroy (fringe_bmp
[which
]);
494 fringe_bmp
[which
] = 0;
498 x_cr_draw_image (struct frame
*f
, GC gc
, cairo_pattern_t
*image
,
499 int src_x
, int src_y
, int width
, int height
,
500 int dest_x
, int dest_y
, bool overlay_p
)
503 cairo_matrix_t matrix
;
504 cairo_surface_t
*surface
;
505 cairo_format_t format
;
507 cr
= x_begin_cr_clip (f
, gc
);
509 cairo_rectangle (cr
, dest_x
, dest_y
, width
, height
);
512 x_set_cr_source_with_gc_background (f
, gc
);
513 cairo_rectangle (cr
, dest_x
, dest_y
, width
, height
);
514 cairo_fill_preserve (cr
);
517 cairo_matrix_init_translate (&matrix
, src_x
- dest_x
, src_y
- dest_y
);
518 cairo_pattern_set_matrix (image
, &matrix
);
519 cairo_pattern_get_surface (image
, &surface
);
520 format
= cairo_image_surface_get_format (surface
);
521 if (format
!= CAIRO_FORMAT_A8
&& format
!= CAIRO_FORMAT_A1
)
523 cairo_set_source (cr
, image
);
528 x_set_cr_source_with_gc_foreground (f
, gc
);
529 cairo_mask (cr
, image
);
535 x_cr_draw_frame (cairo_t
*cr
, struct frame
*f
)
539 width
= FRAME_PIXEL_WIDTH (f
);
540 height
= FRAME_PIXEL_HEIGHT (f
);
542 x_free_cr_resources (f
);
543 FRAME_CR_CONTEXT (f
) = cr
;
544 x_clear_area (f
, 0, 0, width
, height
);
545 expose_frame (f
, 0, 0, width
, height
);
546 FRAME_CR_CONTEXT (f
) = NULL
;
549 static cairo_status_t
550 x_cr_accumulate_data (void *closure
, const unsigned char *data
,
553 Lisp_Object
*acc
= (Lisp_Object
*) closure
;
555 *acc
= Fcons (make_unibyte_string ((char const *) data
, length
), *acc
);
557 return CAIRO_STATUS_SUCCESS
;
561 x_cr_destroy (Lisp_Object arg
)
563 cairo_t
*cr
= (cairo_t
*) XSAVE_POINTER (arg
, 0);
571 x_cr_export_frames (Lisp_Object frames
, cairo_surface_type_t surface_type
)
574 cairo_surface_t
*surface
;
577 void (*surface_set_size_func
) (cairo_surface_t
*, double, double) = NULL
;
578 Lisp_Object acc
= Qnil
;
579 int count
= SPECPDL_INDEX ();
583 f
= XFRAME (XCAR (frames
));
584 frames
= XCDR (frames
);
585 width
= FRAME_PIXEL_WIDTH (f
);
586 height
= FRAME_PIXEL_HEIGHT (f
);
589 #ifdef CAIRO_HAS_PDF_SURFACE
590 if (surface_type
== CAIRO_SURFACE_TYPE_PDF
)
592 surface
= cairo_pdf_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
594 surface_set_size_func
= cairo_pdf_surface_set_size
;
598 #ifdef CAIRO_HAS_PNG_FUNCTIONS
599 if (surface_type
== CAIRO_SURFACE_TYPE_IMAGE
)
600 surface
= cairo_image_surface_create (CAIRO_FORMAT_RGB24
, width
, height
);
603 #ifdef CAIRO_HAS_PS_SURFACE
604 if (surface_type
== CAIRO_SURFACE_TYPE_PS
)
606 surface
= cairo_ps_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
608 surface_set_size_func
= cairo_ps_surface_set_size
;
612 #ifdef CAIRO_HAS_SVG_SURFACE
613 if (surface_type
== CAIRO_SURFACE_TYPE_SVG
)
614 surface
= cairo_svg_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
620 cr
= cairo_create (surface
);
621 cairo_surface_destroy (surface
);
622 record_unwind_protect (x_cr_destroy
, make_save_ptr (cr
));
630 x_free_cr_resources (f
);
631 FRAME_CR_CONTEXT (f
) = cr
;
632 x_clear_area (f
, 0, 0, width
, height
);
633 expose_frame (f
, 0, 0, width
, height
);
634 FRAME_CR_CONTEXT (f
) = NULL
;
641 cairo_surface_show_page (surface
);
642 f
= XFRAME (XCAR (frames
));
643 frames
= XCDR (frames
);
644 width
= FRAME_PIXEL_WIDTH (f
);
645 height
= FRAME_PIXEL_HEIGHT (f
);
646 if (surface_set_size_func
)
647 (*surface_set_size_func
) (surface
, width
, height
);
651 #ifdef CAIRO_HAS_PNG_FUNCTIONS
652 if (surface_type
== CAIRO_SURFACE_TYPE_IMAGE
)
655 cairo_surface_flush (surface
);
656 cairo_surface_write_to_png_stream (surface
, x_cr_accumulate_data
, &acc
);
660 unbind_to (count
, Qnil
);
662 return CALLN (Fapply
, intern ("concat"), Fnreverse (acc
));
665 #endif /* USE_CAIRO */
668 x_free_cr_resources (struct frame
*f
)
673 Lisp_Object rest
, frame
;
674 FOR_EACH_FRAME (rest
, frame
)
675 if (FRAME_X_P (XFRAME (frame
)))
676 x_free_cr_resources (XFRAME (frame
));
680 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
684 cairo_surface_t
*surface
= cairo_get_target (cr
);
686 if (cairo_surface_get_type (surface
) == CAIRO_SURFACE_TYPE_XLIB
)
689 FRAME_CR_CONTEXT (f
) = NULL
;
697 x_set_clip_rectangles (struct frame
*f
, GC gc
, XRectangle
*rectangles
, int n
)
699 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, rectangles
, n
, Unsorted
);
701 eassert (n
>= 0 && n
<= MAX_CLIP_RECTS
);
704 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 1);
706 gc_ext
->n_clip_rects
= n
;
707 memcpy (gc_ext
->clip_rects
, rectangles
, sizeof (XRectangle
) * n
);
713 x_reset_clip_rectangles (struct frame
*f
, GC gc
)
715 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
718 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 0);
721 gc_ext
->n_clip_rects
= 0;
727 x_fill_rectangle (struct frame
*f
, GC gc
, int x
, int y
, int width
, int height
)
732 cr
= x_begin_cr_clip (f
, gc
);
733 x_set_cr_source_with_gc_foreground (f
, gc
);
734 cairo_rectangle (cr
, x
, y
, width
, height
);
738 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
739 gc
, x
, y
, width
, height
);
744 x_draw_rectangle (struct frame
*f
, GC gc
, int x
, int y
, int width
, int height
)
749 cr
= x_begin_cr_clip (f
, gc
);
750 x_set_cr_source_with_gc_foreground (f
, gc
);
751 cairo_rectangle (cr
, x
+ 0.5, y
+ 0.5, width
, height
);
752 cairo_set_line_width (cr
, 1);
756 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
757 gc
, x
, y
, width
, height
);
762 x_clear_window (struct frame
*f
)
767 cr
= x_begin_cr_clip (f
, NULL
);
768 x_set_cr_source_with_gc_background (f
, f
->output_data
.x
->normal_gc
);
772 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
778 x_fill_trapezoid_for_relief (struct frame
*f
, GC gc
, int x
, int y
,
779 int width
, int height
, int top_p
)
783 cr
= x_begin_cr_clip (f
, gc
);
784 x_set_cr_source_with_gc_foreground (f
, gc
);
785 cairo_move_to (cr
, top_p
? x
: x
+ height
, y
);
786 cairo_line_to (cr
, x
, y
+ height
);
787 cairo_line_to (cr
, top_p
? x
+ width
- height
: x
+ width
, y
+ height
);
788 cairo_line_to (cr
, x
+ width
, y
);
795 CORNER_BOTTOM_RIGHT
, /* 0 -> pi/2 */
796 CORNER_BOTTOM_LEFT
, /* pi/2 -> pi */
797 CORNER_TOP_LEFT
, /* pi -> 3pi/2 */
798 CORNER_TOP_RIGHT
, /* 3pi/2 -> 2pi */
803 x_erase_corners_for_relief (struct frame
*f
, GC gc
, int x
, int y
,
804 int width
, int height
,
805 double radius
, double margin
, int corners
)
810 cr
= x_begin_cr_clip (f
, gc
);
811 x_set_cr_source_with_gc_background (f
, gc
);
812 for (i
= 0; i
< CORNER_LAST
; i
++)
813 if (corners
& (1 << i
))
815 double xm
, ym
, xc
, yc
;
817 if (i
== CORNER_TOP_LEFT
|| i
== CORNER_BOTTOM_LEFT
)
818 xm
= x
- margin
, xc
= xm
+ radius
;
820 xm
= x
+ width
+ margin
, xc
= xm
- radius
;
821 if (i
== CORNER_TOP_LEFT
|| i
== CORNER_TOP_RIGHT
)
822 ym
= y
- margin
, yc
= ym
+ radius
;
824 ym
= y
+ height
+ margin
, yc
= ym
- radius
;
826 cairo_move_to (cr
, xm
, ym
);
827 cairo_arc (cr
, xc
, yc
, radius
, i
* M_PI_2
, (i
+ 1) * M_PI_2
);
830 cairo_rectangle (cr
, x
, y
, width
, height
);
836 x_draw_horizontal_wave (struct frame
*f
, GC gc
, int x
, int y
,
837 int width
, int height
, int wave_length
)
840 double dx
= wave_length
, dy
= height
- 1;
843 cr
= x_begin_cr_clip (f
, gc
);
844 x_set_cr_source_with_gc_foreground (f
, gc
);
845 cairo_rectangle (cr
, x
, y
, width
, height
);
850 xoffset
= x
% (wave_length
* 2);
852 xoffset
= wave_length
* 2;
855 xoffset
= x
% (wave_length
* 2) + wave_length
* 2;
856 n
= (width
+ xoffset
) / wave_length
+ 1;
857 if (xoffset
> wave_length
)
859 xoffset
-= wave_length
;
865 cairo_move_to (cr
, x
- xoffset
+ 0.5, y
+ 0.5);
868 cairo_rel_line_to (cr
, dx
, dy
);
871 cairo_set_line_width (cr
, 1);
878 /* Return the struct x_display_info corresponding to DPY. */
880 struct x_display_info
*
881 x_display_info_for_display (Display
*dpy
)
883 struct x_display_info
*dpyinfo
;
885 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
886 if (dpyinfo
->display
== dpy
)
893 x_find_topmost_parent (struct frame
*f
)
895 struct x_output
*x
= f
->output_data
.x
;
896 Window win
= None
, wi
= x
->parent_desc
;
897 Display
*dpy
= FRAME_X_DISPLAY (f
);
899 while (wi
!= FRAME_DISPLAY_INFO (f
)->root_window
)
903 unsigned int nchildren
;
906 if (XQueryTree (dpy
, win
, &root
, &wi
, &children
, &nchildren
))
915 #define OPAQUE 0xffffffff
918 x_set_frame_alpha (struct frame
*f
)
920 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
921 Display
*dpy
= FRAME_X_DISPLAY (f
);
922 Window win
= FRAME_OUTER_WINDOW (f
);
924 double alpha_min
= 1.0;
928 if (dpyinfo
->x_highlight_frame
== f
)
933 if (FLOATP (Vframe_alpha_lower_limit
))
934 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
935 else if (INTEGERP (Vframe_alpha_lower_limit
))
936 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
940 else if (alpha
> 1.0)
942 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
945 opac
= alpha
* OPAQUE
;
947 x_catch_errors (dpy
);
949 /* If there is a parent from the window manager, put the property there
950 also, to work around broken window managers that fail to do that.
951 Do this unconditionally as this function is called on reparent when
952 alpha has not changed on the frame. */
954 parent
= x_find_topmost_parent (f
);
956 XChangeProperty (dpy
, parent
, dpyinfo
->Xatom_net_wm_window_opacity
,
957 XA_CARDINAL
, 32, PropModeReplace
,
958 (unsigned char *) &opac
, 1);
960 /* return unless necessary */
965 unsigned long n
, left
;
967 rc
= XGetWindowProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
968 0, 1, False
, XA_CARDINAL
,
969 &actual
, &format
, &n
, &left
,
972 if (rc
== Success
&& actual
!= None
)
974 unsigned long value
= *(unsigned long *)data
;
984 XChangeProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
985 XA_CARDINAL
, 32, PropModeReplace
,
986 (unsigned char *) &opac
, 1);
990 /***********************************************************************
991 Starting and ending an update
992 ***********************************************************************/
994 /* Start an update of frame F. This function is installed as a hook
995 for update_begin, i.e. it is called when update_begin is called.
996 This function is called prior to calls to x_update_window_begin for
997 each window being updated. Currently, there is nothing to do here
998 because all interesting stuff is done on a window basis. */
1001 x_update_begin (struct frame
*f
)
1004 if (! NILP (tip_frame
) && XFRAME (tip_frame
) == f
1005 && ! FRAME_VISIBLE_P (f
))
1008 if (! FRAME_CR_SURFACE (f
))
1012 if (FRAME_GTK_WIDGET (f
))
1014 GdkWindow
*w
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
1015 width
= gdk_window_get_width (w
);
1016 height
= gdk_window_get_height (w
);
1021 width
= FRAME_PIXEL_WIDTH (f
);
1022 height
= FRAME_PIXEL_HEIGHT (f
);
1023 if (! FRAME_EXTERNAL_TOOL_BAR (f
))
1024 height
+= FRAME_TOOL_BAR_HEIGHT (f
);
1025 if (! FRAME_EXTERNAL_MENU_BAR (f
))
1026 height
+= FRAME_MENU_BAR_HEIGHT (f
);
1029 if (width
> 0 && height
> 0)
1032 FRAME_CR_SURFACE (f
) = cairo_image_surface_create
1033 (CAIRO_FORMAT_ARGB32
, width
, height
);
1037 #endif /* USE_CAIRO */
1040 /* Start update of window W. */
1043 x_update_window_begin (struct window
*w
)
1045 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1046 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
1048 w
->output_cursor
= w
->cursor
;
1052 if (f
== hlinfo
->mouse_face_mouse_frame
)
1054 /* Don't do highlighting for mouse motion during the update. */
1055 hlinfo
->mouse_face_defer
= true;
1057 /* If F needs to be redrawn, simply forget about any prior mouse
1059 if (FRAME_GARBAGED_P (f
))
1060 hlinfo
->mouse_face_window
= Qnil
;
1067 /* Draw a vertical window border from (x,y0) to (x,y1) */
1070 x_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
1072 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1075 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
1077 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
1081 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
, x
, y0
, 1, y1
- y0
);
1083 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1084 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
1088 /* Draw a window divider from (x0,y0) to (x1,y1) */
1091 x_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
1093 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1094 struct face
*face
= FACE_FROM_ID (f
, WINDOW_DIVIDER_FACE_ID
);
1095 struct face
*face_first
= FACE_FROM_ID (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
1096 struct face
*face_last
= FACE_FROM_ID (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
1097 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
1098 unsigned long color_first
= (face_first
1099 ? face_first
->foreground
1100 : FRAME_FOREGROUND_PIXEL (f
));
1101 unsigned long color_last
= (face_last
1102 ? face_last
->foreground
1103 : FRAME_FOREGROUND_PIXEL (f
));
1104 Display
*display
= FRAME_X_DISPLAY (f
);
1106 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
1109 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_first
);
1110 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1111 x0
, y0
, 1, y1
- y0
);
1112 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
1113 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1114 x0
+ 1, y0
, x1
- x0
- 2, y1
- y0
);
1115 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_last
);
1116 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1117 x1
- 1, y0
, 1, y1
- y0
);
1119 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
1122 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_first
);
1123 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1124 x0
, y0
, x1
- x0
, 1);
1125 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
1126 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1127 x0
, y0
+ 1, x1
- x0
, y1
- y0
- 2);
1128 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_last
);
1129 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1130 x0
, y1
- 1, x1
- x0
, 1);
1134 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
1135 x_fill_rectangle (f
, f
->output_data
.x
->normal_gc
,
1136 x0
, y0
, x1
- x0
, y1
- y0
);
1140 /* End update of window W.
1142 Draw vertical borders between horizontally adjacent windows, and
1143 display W's cursor if CURSOR_ON_P is non-zero.
1145 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
1146 glyphs in mouse-face were overwritten. In that case we have to
1147 make sure that the mouse-highlight is properly redrawn.
1149 W may be a menu bar pseudo-window in case we don't have X toolkit
1150 support. Such windows don't have a cursor, so don't display it
1154 x_update_window_end (struct window
*w
, bool cursor_on_p
,
1155 bool mouse_face_overwritten_p
)
1157 if (!w
->pseudo_window_p
)
1162 display_and_set_cursor (w
, true,
1163 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
1164 w
->output_cursor
.x
, w
->output_cursor
.y
);
1166 if (draw_window_fringes (w
, true))
1168 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
1169 x_draw_right_divider (w
);
1171 x_draw_vertical_border (w
);
1177 /* If a row with mouse-face was overwritten, arrange for
1178 XTframe_up_to_date to redisplay the mouse highlight. */
1179 if (mouse_face_overwritten_p
)
1181 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
1183 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
1184 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
1185 hlinfo
->mouse_face_window
= Qnil
;
1190 /* End update of frame F. This function is installed as a hook in
1194 x_update_end (struct frame
*f
)
1196 /* Mouse highlight may be displayed again. */
1197 MOUSE_HL_INFO (f
)->mouse_face_defer
= false;
1200 if (FRAME_CR_SURFACE (f
))
1204 #if defined (USE_GTK) && defined (HAVE_GTK3)
1205 if (FRAME_GTK_WIDGET (f
))
1207 GdkWindow
*w
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
1208 cr
= gdk_cairo_create (w
);
1213 cairo_surface_t
*surface
;
1214 int width
= FRAME_PIXEL_WIDTH (f
);
1215 int height
= FRAME_PIXEL_HEIGHT (f
);
1216 if (! FRAME_EXTERNAL_TOOL_BAR (f
))
1217 height
+= FRAME_TOOL_BAR_HEIGHT (f
);
1218 if (! FRAME_EXTERNAL_MENU_BAR (f
))
1219 height
+= FRAME_MENU_BAR_HEIGHT (f
);
1220 surface
= cairo_xlib_surface_create (FRAME_X_DISPLAY (f
),
1222 FRAME_DISPLAY_INFO (f
)->visual
,
1225 cr
= cairo_create (surface
);
1226 cairo_surface_destroy (surface
);
1229 cairo_set_source_surface (cr
, FRAME_CR_SURFACE (f
), 0, 0);
1234 #endif /* USE_CAIRO */
1238 XFlush (FRAME_X_DISPLAY (f
));
1244 /* This function is called from various places in xdisp.c
1245 whenever a complete update has been performed. */
1248 XTframe_up_to_date (struct frame
*f
)
1251 FRAME_MOUSE_UPDATE (f
);
1255 /* Clear under internal border if any (GTK has its own version). */
1258 x_clear_under_internal_border (struct frame
*f
)
1260 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
1262 int border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1263 int width
= FRAME_PIXEL_WIDTH (f
);
1264 int height
= FRAME_PIXEL_HEIGHT (f
);
1265 int margin
= FRAME_TOP_MARGIN_HEIGHT (f
);
1268 x_clear_area (f
, 0, 0, border
, height
);
1269 x_clear_area (f
, 0, margin
, width
, border
);
1270 x_clear_area (f
, width
- border
, 0, border
, height
);
1271 x_clear_area (f
, 0, height
- border
, width
, border
);
1277 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
1278 arrow bitmaps, or clear the fringes if no bitmaps are required
1279 before DESIRED_ROW is made current. This function is called from
1280 update_window_line only if it is known that there are differences
1281 between bitmaps to be drawn between current row and DESIRED_ROW. */
1284 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
1288 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
1289 desired_row
->redraw_fringe_bitmaps_p
= true;
1291 #ifdef USE_X_TOOLKIT
1292 /* When a window has disappeared, make sure that no rest of
1293 full-width rows stays visible in the internal border. Could
1294 check here if updated window is the leftmost/rightmost window,
1295 but I guess it's not worth doing since vertically split windows
1296 are almost never used, internal border is rarely set, and the
1297 overhead is very small. */
1302 if (windows_or_buffers_changed
1303 && desired_row
->full_width_p
1304 && (f
= XFRAME (w
->frame
),
1305 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
1307 && (height
= desired_row
->visible_height
,
1310 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
1313 x_clear_area (f
, 0, y
, width
, height
);
1314 x_clear_area (f
, FRAME_PIXEL_WIDTH (f
) - width
, y
, width
, height
);
1322 x_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, struct draw_fringe_bitmap_params
*p
)
1324 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1325 Display
*display
= FRAME_X_DISPLAY (f
);
1326 Window window
= FRAME_X_WINDOW (f
);
1327 GC gc
= f
->output_data
.x
->normal_gc
;
1328 struct face
*face
= p
->face
;
1330 /* Must clip because of partially visible lines. */
1331 x_clip_to_row (w
, row
, ANY_AREA
, gc
);
1333 if (p
->bx
>= 0 && !p
->overlay_p
)
1335 /* In case the same realized face is used for fringes and
1336 for something displayed in the text (e.g. face `region' on
1337 mono-displays, the fill style may have been changed to
1338 FillSolid in x_draw_glyph_string_background. */
1340 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
1342 XSetForeground (display
, face
->gc
, face
->background
);
1344 x_fill_rectangle (f
, face
->gc
, p
->bx
, p
->by
, p
->nx
, p
->ny
);
1347 XSetForeground (display
, face
->gc
, face
->foreground
);
1351 if (p
->which
&& p
->which
< max_fringe_bmp
)
1355 XGetGCValues (display
, gc
, GCForeground
| GCBackground
, &gcv
);
1356 XSetForeground (display
, gc
, (p
->cursor_p
1357 ? (p
->overlay_p
? face
->background
1358 : f
->output_data
.x
->cursor_pixel
)
1359 : face
->foreground
));
1360 XSetBackground (display
, gc
, face
->background
);
1361 x_cr_draw_image (f
, gc
, fringe_bmp
[p
->which
], 0, p
->dh
,
1362 p
->wd
, p
->h
, p
->x
, p
->y
, p
->overlay_p
);
1363 XSetForeground (display
, gc
, gcv
.foreground
);
1364 XSetBackground (display
, gc
, gcv
.background
);
1366 #else /* not USE_CAIRO */
1370 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
1371 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
1375 bits
= (char *) (p
->bits
+ p
->dh
);
1377 bits
= (char *) p
->bits
+ p
->dh
;
1379 /* Draw the bitmap. I believe these small pixmaps can be cached
1381 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
1383 ? (p
->overlay_p
? face
->background
1384 : f
->output_data
.x
->cursor_pixel
)
1385 : face
->foreground
),
1386 face
->background
, depth
);
1390 clipmask
= XCreatePixmapFromBitmapData (display
,
1391 FRAME_DISPLAY_INFO (f
)->root_window
,
1394 gcv
.clip_mask
= clipmask
;
1395 gcv
.clip_x_origin
= p
->x
;
1396 gcv
.clip_y_origin
= p
->y
;
1397 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
1400 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
1401 p
->wd
, p
->h
, p
->x
, p
->y
);
1402 XFreePixmap (display
, pixmap
);
1406 gcv
.clip_mask
= (Pixmap
) 0;
1407 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
1408 XFreePixmap (display
, clipmask
);
1411 #endif /* not USE_CAIRO */
1413 x_reset_clip_rectangles (f
, gc
);
1416 /***********************************************************************
1418 ***********************************************************************/
1422 static void x_set_glyph_string_clipping (struct glyph_string
*);
1423 static void x_set_glyph_string_gc (struct glyph_string
*);
1424 static void x_draw_glyph_string_foreground (struct glyph_string
*);
1425 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
1426 static void x_draw_glyph_string_box (struct glyph_string
*);
1427 static void x_draw_glyph_string (struct glyph_string
*);
1428 static _Noreturn
void x_delete_glyphs (struct frame
*, int);
1429 static void x_compute_glyph_string_overhangs (struct glyph_string
*);
1430 static void x_set_cursor_gc (struct glyph_string
*);
1431 static void x_set_mode_line_face_gc (struct glyph_string
*);
1432 static void x_set_mouse_face_gc (struct glyph_string
*);
1433 static bool x_alloc_lighter_color (struct frame
*, Display
*, Colormap
,
1434 unsigned long *, double, int);
1435 static void x_setup_relief_color (struct frame
*, struct relief
*,
1436 double, int, unsigned long);
1437 static void x_setup_relief_colors (struct glyph_string
*);
1438 static void x_draw_image_glyph_string (struct glyph_string
*);
1439 static void x_draw_image_relief (struct glyph_string
*);
1440 static void x_draw_image_foreground (struct glyph_string
*);
1441 static void x_draw_image_foreground_1 (struct glyph_string
*, Pixmap
);
1442 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
1444 static void x_draw_relief_rect (struct frame
*, int, int, int, int,
1445 int, bool, bool, bool, bool, bool,
1447 static void x_draw_box_rect (struct glyph_string
*, int, int, int, int,
1448 int, bool, bool, XRectangle
*);
1449 static void x_scroll_bar_clear (struct frame
*);
1452 static void x_check_font (struct frame
*, struct font
*);
1456 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1460 x_set_cursor_gc (struct glyph_string
*s
)
1462 if (s
->font
== FRAME_FONT (s
->f
)
1463 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1464 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1466 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
1469 /* Cursor on non-default face: must merge. */
1473 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
1474 xgcv
.foreground
= s
->face
->background
;
1476 /* If the glyph would be invisible, try a different foreground. */
1477 if (xgcv
.foreground
== xgcv
.background
)
1478 xgcv
.foreground
= s
->face
->foreground
;
1479 if (xgcv
.foreground
== xgcv
.background
)
1480 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
1481 if (xgcv
.foreground
== xgcv
.background
)
1482 xgcv
.foreground
= s
->face
->foreground
;
1484 /* Make sure the cursor is distinct from text in this face. */
1485 if (xgcv
.background
== s
->face
->background
1486 && xgcv
.foreground
== s
->face
->foreground
)
1488 xgcv
.background
= s
->face
->foreground
;
1489 xgcv
.foreground
= s
->face
->background
;
1492 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1493 xgcv
.graphics_exposures
= False
;
1494 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
1496 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1497 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1500 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1501 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1503 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1508 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1511 x_set_mouse_face_gc (struct glyph_string
*s
)
1516 /* What face has to be used last for the mouse face? */
1517 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
1518 face
= FACE_FROM_ID (s
->f
, face_id
);
1520 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1522 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1523 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1525 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1526 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1527 prepare_face_for_display (s
->f
, s
->face
);
1529 if (s
->font
== s
->face
->font
)
1530 s
->gc
= s
->face
->gc
;
1533 /* Otherwise construct scratch_cursor_gc with values from FACE
1538 xgcv
.background
= s
->face
->background
;
1539 xgcv
.foreground
= s
->face
->foreground
;
1540 xgcv
.graphics_exposures
= False
;
1541 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
1543 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1544 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1547 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1548 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1550 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1553 eassert (s
->gc
!= 0);
1557 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1558 Faces to use in the mode line have already been computed when the
1559 matrix was built, so there isn't much to do, here. */
1562 x_set_mode_line_face_gc (struct glyph_string
*s
)
1564 s
->gc
= s
->face
->gc
;
1568 /* Set S->gc of glyph string S for drawing that glyph string. Set
1569 S->stippled_p to a non-zero value if the face of S has a stipple
1573 x_set_glyph_string_gc (struct glyph_string
*s
)
1575 prepare_face_for_display (s
->f
, s
->face
);
1577 if (s
->hl
== DRAW_NORMAL_TEXT
)
1579 s
->gc
= s
->face
->gc
;
1580 s
->stippled_p
= s
->face
->stipple
!= 0;
1582 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1584 x_set_mode_line_face_gc (s
);
1585 s
->stippled_p
= s
->face
->stipple
!= 0;
1587 else if (s
->hl
== DRAW_CURSOR
)
1589 x_set_cursor_gc (s
);
1590 s
->stippled_p
= false;
1592 else if (s
->hl
== DRAW_MOUSE_FACE
)
1594 x_set_mouse_face_gc (s
);
1595 s
->stippled_p
= s
->face
->stipple
!= 0;
1597 else if (s
->hl
== DRAW_IMAGE_RAISED
1598 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1600 s
->gc
= s
->face
->gc
;
1601 s
->stippled_p
= s
->face
->stipple
!= 0;
1606 /* GC must have been set. */
1607 eassert (s
->gc
!= 0);
1611 /* Set clipping for output of glyph string S. S may be part of a mode
1612 line or menu if we don't have X toolkit support. */
1615 x_set_glyph_string_clipping (struct glyph_string
*s
)
1617 XRectangle
*r
= s
->clip
;
1618 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1621 x_set_clip_rectangles (s
->f
, s
->gc
, r
, n
);
1626 /* Set SRC's clipping for output of glyph string DST. This is called
1627 when we are drawing DST's left_overhang or right_overhang only in
1631 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
, struct glyph_string
*dst
)
1636 r
.width
= src
->width
;
1638 r
.height
= src
->height
;
1641 x_set_clip_rectangles (dst
->f
, dst
->gc
, &r
, 1);
1646 Compute left and right overhang of glyph string S. */
1649 x_compute_glyph_string_overhangs (struct glyph_string
*s
)
1652 && (s
->first_glyph
->type
== CHAR_GLYPH
1653 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
1655 struct font_metrics metrics
;
1657 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1659 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1660 struct font
*font
= s
->font
;
1663 for (i
= 0; i
< s
->nchars
; i
++)
1664 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
1665 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1669 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1671 composition_gstring_width (gstring
, s
->cmp_from
, s
->cmp_to
, &metrics
);
1673 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1674 ? metrics
.rbearing
- metrics
.width
: 0);
1675 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1679 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1680 s
->left_overhang
= - s
->cmp
->lbearing
;
1685 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1688 x_clear_glyph_string_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
1691 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1692 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1693 x_fill_rectangle (s
->f
, s
->gc
, x
, y
, w
, h
);
1694 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1698 /* Draw the background of glyph_string S. If S->background_filled_p
1699 is non-zero don't draw it. FORCE_P non-zero means draw the
1700 background even if it wouldn't be drawn normally. This is used
1701 when a string preceding S draws into the background of S, or S
1702 contains the first component of a composition. */
1705 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1707 /* Nothing to do if background has already been drawn or if it
1708 shouldn't be drawn in the first place. */
1709 if (!s
->background_filled_p
)
1711 int box_line_width
= max (s
->face
->box_line_width
, 0);
1715 /* Fill background with a stipple pattern. */
1716 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1717 x_fill_rectangle (s
->f
, s
->gc
, s
->x
,
1718 s
->y
+ box_line_width
,
1719 s
->background_width
,
1720 s
->height
- 2 * box_line_width
);
1721 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1722 s
->background_filled_p
= true;
1724 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1725 /* When xdisp.c ignores FONT_HEIGHT, we cannot trust
1726 font dimensions, since the actual glyphs might be
1727 much smaller. So in that case we always clear the
1728 rectangle with background color. */
1729 || FONT_TOO_HIGH (s
->font
)
1730 || s
->font_not_found_p
1731 || s
->extends_to_end_of_line_p
1734 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1735 s
->background_width
,
1736 s
->height
- 2 * box_line_width
);
1737 s
->background_filled_p
= true;
1743 /* Draw the foreground of glyph string S. */
1746 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1750 /* If first glyph of S has a left box line, start drawing the text
1751 of S to the right of that box line. */
1752 if (s
->face
->box
!= FACE_NO_BOX
1753 && s
->first_glyph
->left_box_line_p
)
1754 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1758 /* Draw characters of S as rectangles if S's font could not be
1760 if (s
->font_not_found_p
)
1762 for (i
= 0; i
< s
->nchars
; ++i
)
1764 struct glyph
*g
= s
->first_glyph
+ i
;
1765 x_draw_rectangle (s
->f
,
1766 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1768 x
+= g
->pixel_width
;
1773 struct font
*font
= s
->font
;
1774 int boff
= font
->baseline_offset
;
1777 if (font
->vertical_centering
)
1778 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1780 y
= s
->ybase
- boff
;
1782 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1783 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, false);
1785 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, true);
1786 if (s
->face
->overstrike
)
1787 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, false);
1791 /* Draw the foreground of composite glyph string S. */
1794 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1797 struct font
*font
= s
->font
;
1799 /* If first glyph of S has a left box line, start drawing the text
1800 of S to the right of that box line. */
1801 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1802 && s
->first_glyph
->left_box_line_p
)
1803 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1807 /* S is a glyph string for a composition. S->cmp_from is the index
1808 of the first character drawn for glyphs of this composition.
1809 S->cmp_from == 0 means we are drawing the very first character of
1810 this composition. */
1812 /* Draw a rectangle for the composition if the font for the very
1813 first character of the composition could not be loaded. */
1814 if (s
->font_not_found_p
)
1816 if (s
->cmp_from
== 0)
1817 x_draw_rectangle (s
->f
, s
->gc
, x
, s
->y
,
1818 s
->width
- 1, s
->height
- 1);
1820 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1824 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1825 /* TAB in a composition means display glyphs with padding
1826 space on the left or right. */
1827 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1829 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1830 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1832 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, false);
1833 if (s
->face
->overstrike
)
1834 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, false);
1839 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1844 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1846 glyph
= LGSTRING_GLYPH (gstring
, i
);
1847 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1848 width
+= LGLYPH_WIDTH (glyph
);
1851 int xoff
, yoff
, wadjust
;
1855 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1856 if (s
->face
->overstrike
)
1857 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, false);
1860 xoff
= LGLYPH_XOFF (glyph
);
1861 yoff
= LGLYPH_YOFF (glyph
);
1862 wadjust
= LGLYPH_WADJUST (glyph
);
1863 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, false);
1864 if (s
->face
->overstrike
)
1865 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
,
1874 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1875 if (s
->face
->overstrike
)
1876 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, false);
1882 /* Draw the foreground of glyph string S for glyphless characters. */
1885 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1887 struct glyph
*glyph
= s
->first_glyph
;
1891 /* If first glyph of S has a left box line, start drawing the text
1892 of S to the right of that box line. */
1893 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1894 && s
->first_glyph
->left_box_line_p
)
1895 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1901 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1903 char buf
[7], *str
= NULL
;
1904 int len
= glyph
->u
.glyphless
.len
;
1906 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1909 && CHAR_TABLE_P (Vglyphless_char_display
)
1910 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1914 = (! glyph
->u
.glyphless
.for_no_font
1915 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1916 glyph
->u
.glyphless
.ch
)
1917 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1918 if (STRINGP (acronym
))
1919 str
= SSDATA (acronym
);
1922 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1924 sprintf (buf
, "%0*X",
1925 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1926 glyph
->u
.glyphless
.ch
+ 0u);
1932 int upper_len
= (len
+ 1) / 2;
1935 /* It is assured that all LEN characters in STR is ASCII. */
1936 for (j
= 0; j
< len
; j
++)
1938 code
= s
->font
->driver
->encode_char (s
->font
, str
[j
]);
1939 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1941 s
->font
->driver
->draw (s
, 0, upper_len
,
1942 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1943 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1945 s
->font
->driver
->draw (s
, upper_len
, len
,
1946 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1947 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1950 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1951 x_draw_rectangle (s
->f
, s
->gc
,
1952 x
, s
->ybase
- glyph
->ascent
,
1953 glyph
->pixel_width
- 1,
1954 glyph
->ascent
+ glyph
->descent
- 1);
1955 x
+= glyph
->pixel_width
;
1959 #ifdef USE_X_TOOLKIT
1963 /* Return the frame on which widget WIDGET is used.. Abort if frame
1964 cannot be determined. */
1966 static struct frame
*
1967 x_frame_of_widget (Widget widget
)
1969 struct x_display_info
*dpyinfo
;
1970 Lisp_Object tail
, frame
;
1973 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1975 /* Find the top-level shell of the widget. Note that this function
1976 can be called when the widget is not yet realized, so XtWindow
1977 (widget) == 0. That's the reason we can't simply use
1978 x_any_window_to_frame. */
1979 while (!XtIsTopLevelShell (widget
))
1980 widget
= XtParent (widget
);
1982 /* Look for a frame with that top-level widget. Allocate the color
1983 on that frame to get the right gamma correction value. */
1984 FOR_EACH_FRAME (tail
, frame
)
1988 && f
->output_data
.nothing
!= 1
1989 && FRAME_DISPLAY_INFO (f
) == dpyinfo
1990 && f
->output_data
.x
->widget
== widget
)
1996 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1997 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1998 If this produces the same color as PIXEL, try a color where all RGB
1999 values have DELTA added. Return the allocated color in *PIXEL.
2000 DISPLAY is the X display, CMAP is the colormap to operate on.
2001 Value is true if successful. */
2004 x_alloc_lighter_color_for_widget (Widget widget
, Display
*display
, Colormap cmap
,
2005 unsigned long *pixel
, double factor
, int delta
)
2007 struct frame
*f
= x_frame_of_widget (widget
);
2008 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
2011 #endif /* USE_LUCID */
2014 /* Structure specifying which arguments should be passed by Xt to
2015 cvt_string_to_pixel. We want the widget's screen and colormap. */
2017 static XtConvertArgRec cvt_string_to_pixel_args
[] =
2019 {XtWidgetBaseOffset
, (XtPointer
) offsetof (WidgetRec
, core
.screen
),
2021 {XtWidgetBaseOffset
, (XtPointer
) offsetof (WidgetRec
, core
.colormap
),
2026 /* The address of this variable is returned by
2027 cvt_string_to_pixel. */
2029 static Pixel cvt_string_to_pixel_value
;
2032 /* Convert a color name to a pixel color.
2034 DPY is the display we are working on.
2036 ARGS is an array of *NARGS XrmValue structures holding additional
2037 information about the widget for which the conversion takes place.
2038 The contents of this array are determined by the specification
2039 in cvt_string_to_pixel_args.
2041 FROM is a pointer to an XrmValue which points to the color name to
2042 convert. TO is an XrmValue in which to return the pixel color.
2044 CLOSURE_RET is a pointer to user-data, in which we record if
2045 we allocated the color or not.
2047 Value is True if successful, False otherwise. */
2050 cvt_string_to_pixel (Display
*dpy
, XrmValue
*args
, Cardinal
*nargs
,
2051 XrmValue
*from
, XrmValue
*to
,
2052 XtPointer
*closure_ret
)
2062 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
2063 "wrongParameters", "cvt_string_to_pixel",
2065 "Screen and colormap args required", NULL
, NULL
);
2069 screen
= *(Screen
**) args
[0].addr
;
2070 cmap
= *(Colormap
*) args
[1].addr
;
2071 color_name
= (String
) from
->addr
;
2073 if (strcmp (color_name
, XtDefaultBackground
) == 0)
2075 *closure_ret
= (XtPointer
) False
;
2076 pixel
= WhitePixelOfScreen (screen
);
2078 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
2080 *closure_ret
= (XtPointer
) False
;
2081 pixel
= BlackPixelOfScreen (screen
);
2083 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
2084 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
2086 pixel
= color
.pixel
;
2087 *closure_ret
= (XtPointer
) True
;
2092 Cardinal nparams
= 1;
2094 params
[0] = color_name
;
2095 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
2096 "badValue", "cvt_string_to_pixel",
2097 "XtToolkitError", "Invalid color '%s'",
2102 if (to
->addr
!= NULL
)
2104 if (to
->size
< sizeof (Pixel
))
2106 to
->size
= sizeof (Pixel
);
2110 *(Pixel
*) to
->addr
= pixel
;
2114 cvt_string_to_pixel_value
= pixel
;
2115 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
2118 to
->size
= sizeof (Pixel
);
2123 /* Free a pixel color which was previously allocated via
2124 cvt_string_to_pixel. This is registered as the destructor
2125 for this type of resource via XtSetTypeConverter.
2127 APP is the application context in which we work.
2129 TO is a pointer to an XrmValue holding the color to free.
2130 CLOSURE is the value we stored in CLOSURE_RET for this color
2131 in cvt_string_to_pixel.
2133 ARGS and NARGS are like for cvt_string_to_pixel. */
2136 cvt_pixel_dtor (XtAppContext app
, XrmValuePtr to
, XtPointer closure
, XrmValuePtr args
,
2141 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
2143 "Screen and colormap arguments required",
2146 else if (closure
!= NULL
)
2148 /* We did allocate the pixel, so free it. */
2149 Screen
*screen
= *(Screen
**) args
[0].addr
;
2150 Colormap cmap
= *(Colormap
*) args
[1].addr
;
2151 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
2152 (Pixel
*) to
->addr
, 1);
2157 #endif /* USE_X_TOOLKIT */
2160 /* Value is an array of XColor structures for the contents of the
2161 color map of display DPY. Set *NCELLS to the size of the array.
2162 Note that this probably shouldn't be called for large color maps,
2163 say a 24-bit TrueColor map. */
2165 static const XColor
*
2166 x_color_cells (Display
*dpy
, int *ncells
)
2168 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
2170 if (dpyinfo
->color_cells
== NULL
)
2172 Screen
*screen
= dpyinfo
->screen
;
2173 int ncolor_cells
= XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
2176 dpyinfo
->color_cells
= xnmalloc (ncolor_cells
,
2177 sizeof *dpyinfo
->color_cells
);
2178 dpyinfo
->ncolor_cells
= ncolor_cells
;
2180 for (i
= 0; i
< ncolor_cells
; ++i
)
2181 dpyinfo
->color_cells
[i
].pixel
= i
;
2183 XQueryColors (dpy
, dpyinfo
->cmap
,
2184 dpyinfo
->color_cells
, ncolor_cells
);
2187 *ncells
= dpyinfo
->ncolor_cells
;
2188 return dpyinfo
->color_cells
;
2192 /* On frame F, translate pixel colors to RGB values for the NCOLORS
2193 colors in COLORS. Use cached information, if available. */
2196 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
2198 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
2200 if (dpyinfo
->color_cells
)
2203 for (i
= 0; i
< ncolors
; ++i
)
2205 unsigned long pixel
= colors
[i
].pixel
;
2206 eassert (pixel
< dpyinfo
->ncolor_cells
);
2207 eassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
2208 colors
[i
] = dpyinfo
->color_cells
[pixel
];
2212 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
2216 /* On frame F, translate pixel color to RGB values for the color in
2217 COLOR. Use cached information, if available. */
2220 x_query_color (struct frame
*f
, XColor
*color
)
2222 x_query_colors (f
, color
, 1);
2226 /* On frame F, translate the color name to RGB values. Use cached
2227 information, if possible.
2229 Note that there is currently no way to clean old entries out of the
2230 cache. However, it is limited to names in the server's database,
2231 and names we've actually looked up; list-colors-display is probably
2232 the most color-intensive case we're likely to hit. */
2234 Status
x_parse_color (struct frame
*f
, const char *color_name
,
2237 Display
*dpy
= FRAME_X_DISPLAY (f
);
2238 Colormap cmap
= FRAME_X_COLORMAP (f
);
2240 struct color_name_cache_entry
*cache_entry
;
2242 if (color_name
[0] == '#')
2244 /* The hex form is parsed directly by XParseColor without
2245 talking to the X server. No need for caching. */
2246 return XParseColor (dpy
, cmap
, color_name
, color
);
2249 for (cache_entry
= FRAME_DISPLAY_INFO (f
)->color_names
; cache_entry
;
2250 cache_entry
= cache_entry
->next
)
2252 if (!xstrcasecmp(cache_entry
->name
, color_name
))
2254 *color
= cache_entry
->rgb
;
2259 if (XParseColor (dpy
, cmap
, color_name
, color
) == 0)
2260 /* No caching of negative results, currently. */
2263 cache_entry
= xzalloc (sizeof *cache_entry
);
2264 cache_entry
->rgb
= *color
;
2265 cache_entry
->name
= xstrdup (color_name
);
2266 cache_entry
->next
= FRAME_DISPLAY_INFO (f
)->color_names
;
2267 FRAME_DISPLAY_INFO (f
)->color_names
= cache_entry
;
2272 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
2273 exact match can't be allocated, try the nearest color available.
2274 Value is true if successful. Set *COLOR to the color
2278 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
2282 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
2285 /* If we got to this point, the colormap is full, so we're going
2286 to try to get the next closest color. The algorithm used is
2287 a least-squares matching, which is what X uses for closest
2288 color matching with StaticColor visuals. */
2290 int max_color_delta
= 255;
2291 int max_delta
= 3 * max_color_delta
;
2292 int nearest_delta
= max_delta
+ 1;
2294 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
2296 for (nearest
= i
= 0; i
< ncells
; ++i
)
2298 int dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
2299 int dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
2300 int dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
2301 int delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
2303 if (delta
< nearest_delta
)
2306 nearest_delta
= delta
;
2310 color
->red
= cells
[nearest
].red
;
2311 color
->green
= cells
[nearest
].green
;
2312 color
->blue
= cells
[nearest
].blue
;
2313 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
2317 /* If allocation succeeded, and the allocated pixel color is not
2318 equal to a cached pixel color recorded earlier, there was a
2319 change in the colormap, so clear the color cache. */
2320 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
2321 XColor
*cached_color
;
2323 if (dpyinfo
->color_cells
2324 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
2325 (cached_color
->red
!= color
->red
2326 || cached_color
->blue
!= color
->blue
2327 || cached_color
->green
!= color
->green
)))
2329 xfree (dpyinfo
->color_cells
);
2330 dpyinfo
->color_cells
= NULL
;
2331 dpyinfo
->ncolor_cells
= 0;
2335 #ifdef DEBUG_X_COLORS
2337 register_color (color
->pixel
);
2338 #endif /* DEBUG_X_COLORS */
2344 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
2345 exact match can't be allocated, try the nearest color available.
2346 Value is true if successful. Set *COLOR to the color
2350 x_alloc_nearest_color (struct frame
*f
, Colormap cmap
, XColor
*color
)
2352 gamma_correct (f
, color
);
2353 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
2357 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
2358 It's necessary to do this instead of just using PIXEL directly to
2359 get color reference counts right. */
2362 x_copy_color (struct frame
*f
, unsigned long pixel
)
2366 color
.pixel
= pixel
;
2368 x_query_color (f
, &color
);
2369 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
2371 #ifdef DEBUG_X_COLORS
2372 register_color (pixel
);
2378 /* Brightness beyond which a color won't have its highlight brightness
2381 Nominally, highlight colors for `3d' faces are calculated by
2382 brightening an object's color by a constant scale factor, but this
2383 doesn't yield good results for dark colors, so for colors who's
2384 brightness is less than this value (on a scale of 0-65535) have an
2385 use an additional additive factor.
2387 The value here is set so that the default menu-bar/mode-line color
2388 (grey75) will not have its highlights changed at all. */
2389 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
2392 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
2393 or DELTA. Try a color with RGB values multiplied by FACTOR first.
2394 If this produces the same color as PIXEL, try a color where all RGB
2395 values have DELTA added. Return the allocated color in *PIXEL.
2396 DISPLAY is the X display, CMAP is the colormap to operate on.
2397 Value is non-zero if successful. */
2400 x_alloc_lighter_color (struct frame
*f
, Display
*display
, Colormap cmap
,
2401 unsigned long *pixel
, double factor
, int delta
)
2407 /* Get RGB color values. */
2408 color
.pixel
= *pixel
;
2409 x_query_color (f
, &color
);
2411 /* Change RGB values by specified FACTOR. Avoid overflow! */
2412 eassert (factor
>= 0);
2413 new.red
= min (0xffff, factor
* color
.red
);
2414 new.green
= min (0xffff, factor
* color
.green
);
2415 new.blue
= min (0xffff, factor
* color
.blue
);
2417 /* Calculate brightness of COLOR. */
2418 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
2420 /* We only boost colors that are darker than
2421 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
2422 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
2423 /* Make an additive adjustment to NEW, because it's dark enough so
2424 that scaling by FACTOR alone isn't enough. */
2426 /* How far below the limit this color is (0 - 1, 1 being darker). */
2427 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
2428 /* The additive adjustment. */
2429 int min_delta
= delta
* dimness
* factor
/ 2;
2433 new.red
= max (0, new.red
- min_delta
);
2434 new.green
= max (0, new.green
- min_delta
);
2435 new.blue
= max (0, new.blue
- min_delta
);
2439 new.red
= min (0xffff, min_delta
+ new.red
);
2440 new.green
= min (0xffff, min_delta
+ new.green
);
2441 new.blue
= min (0xffff, min_delta
+ new.blue
);
2445 /* Try to allocate the color. */
2446 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
2449 if (new.pixel
== *pixel
)
2451 /* If we end up with the same color as before, try adding
2452 delta to the RGB values. */
2453 x_free_colors (f
, &new.pixel
, 1);
2455 new.red
= min (0xffff, delta
+ color
.red
);
2456 new.green
= min (0xffff, delta
+ color
.green
);
2457 new.blue
= min (0xffff, delta
+ color
.blue
);
2458 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
2469 /* Set up the foreground color for drawing relief lines of glyph
2470 string S. RELIEF is a pointer to a struct relief containing the GC
2471 with which lines will be drawn. Use a color that is FACTOR or
2472 DELTA lighter or darker than the relief's background which is found
2473 in S->f->output_data.x->relief_background. If such a color cannot
2474 be allocated, use DEFAULT_PIXEL, instead. */
2477 x_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
2478 int delta
, unsigned long default_pixel
)
2481 struct x_output
*di
= f
->output_data
.x
;
2482 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
2483 unsigned long pixel
;
2484 unsigned long background
= di
->relief_background
;
2485 Colormap cmap
= FRAME_X_COLORMAP (f
);
2486 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
2487 Display
*dpy
= FRAME_X_DISPLAY (f
);
2489 xgcv
.graphics_exposures
= False
;
2490 xgcv
.line_width
= 1;
2492 /* Free previously allocated color. The color cell will be reused
2493 when it has been freed as many times as it was allocated, so this
2494 doesn't affect faces using the same colors. */
2495 if (relief
->gc
&& relief
->pixel
!= -1)
2497 x_free_colors (f
, &relief
->pixel
, 1);
2501 /* Allocate new color. */
2502 xgcv
.foreground
= default_pixel
;
2504 if (dpyinfo
->n_planes
!= 1
2505 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
2506 xgcv
.foreground
= relief
->pixel
= pixel
;
2508 if (relief
->gc
== 0)
2510 xgcv
.stipple
= dpyinfo
->gray
;
2512 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
2515 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
2519 /* Set up colors for the relief lines around glyph string S. */
2522 x_setup_relief_colors (struct glyph_string
*s
)
2524 struct x_output
*di
= s
->f
->output_data
.x
;
2525 unsigned long color
;
2527 if (s
->face
->use_box_color_for_shadows_p
)
2528 color
= s
->face
->box_color
;
2529 else if (s
->first_glyph
->type
== IMAGE_GLYPH
2531 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
2532 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
2537 /* Get the background color of the face. */
2538 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
2539 color
= xgcv
.background
;
2542 if (di
->white_relief
.gc
== 0
2543 || color
!= di
->relief_background
)
2545 di
->relief_background
= color
;
2546 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
2547 WHITE_PIX_DEFAULT (s
->f
));
2548 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
2549 BLACK_PIX_DEFAULT (s
->f
));
2554 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2555 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2556 to draw, it must be >= 0. RAISED_P means draw a raised
2557 relief. LEFT_P means draw a relief on the left side of
2558 the rectangle. RIGHT_P means draw a relief on the right
2559 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2563 x_draw_relief_rect (struct frame
*f
,
2564 int left_x
, int top_y
, int right_x
, int bottom_y
,
2565 int width
, bool raised_p
, bool top_p
, bool bot_p
,
2566 bool left_p
, bool right_p
,
2567 XRectangle
*clip_rect
)
2570 GC top_left_gc
, bottom_right_gc
;
2575 top_left_gc
= f
->output_data
.x
->white_relief
.gc
;
2576 bottom_right_gc
= f
->output_data
.x
->black_relief
.gc
;
2580 top_left_gc
= f
->output_data
.x
->black_relief
.gc
;
2581 bottom_right_gc
= f
->output_data
.x
->white_relief
.gc
;
2584 x_set_clip_rectangles (f
, top_left_gc
, clip_rect
, 1);
2585 x_set_clip_rectangles (f
, bottom_right_gc
, clip_rect
, 1);
2589 x_fill_rectangle (f
, top_left_gc
, left_x
, top_y
,
2590 width
, bottom_y
+ 1 - top_y
);
2592 corners
|= 1 << CORNER_TOP_LEFT
;
2594 corners
|= 1 << CORNER_BOTTOM_LEFT
;
2598 x_fill_rectangle (f
, bottom_right_gc
, right_x
+ 1 - width
, top_y
,
2599 width
, bottom_y
+ 1 - top_y
);
2601 corners
|= 1 << CORNER_TOP_RIGHT
;
2603 corners
|= 1 << CORNER_BOTTOM_RIGHT
;
2608 x_fill_rectangle (f
, top_left_gc
, left_x
, top_y
,
2609 right_x
+ 1 - left_x
, width
);
2611 x_fill_trapezoid_for_relief (f
, top_left_gc
, left_x
, top_y
,
2612 right_x
+ 1 - left_x
, width
, 1);
2617 x_fill_rectangle (f
, bottom_right_gc
, left_x
, bottom_y
+ 1 - width
,
2618 right_x
+ 1 - left_x
, width
);
2620 x_fill_trapezoid_for_relief (f
, bottom_right_gc
,
2621 left_x
, bottom_y
+ 1 - width
,
2622 right_x
+ 1 - left_x
, width
, 0);
2624 if (left_p
&& width
!= 1)
2625 x_fill_rectangle (f
, bottom_right_gc
, left_x
, top_y
,
2626 1, bottom_y
+ 1 - top_y
);
2627 if (top_p
&& width
!= 1)
2628 x_fill_rectangle (f
, bottom_right_gc
, left_x
, top_y
,
2629 right_x
+ 1 - left_x
, 1);
2632 XSetBackground (FRAME_X_DISPLAY (f
), top_left_gc
,
2633 FRAME_BACKGROUND_PIXEL (f
));
2634 x_erase_corners_for_relief (f
, top_left_gc
, left_x
, top_y
,
2635 right_x
- left_x
+ 1, bottom_y
- top_y
+ 1,
2639 x_reset_clip_rectangles (f
, top_left_gc
);
2640 x_reset_clip_rectangles (f
, bottom_right_gc
);
2642 Display
*dpy
= FRAME_X_DISPLAY (f
);
2643 Window window
= FRAME_X_WINDOW (f
);
2648 gc
= f
->output_data
.x
->white_relief
.gc
;
2650 gc
= f
->output_data
.x
->black_relief
.gc
;
2651 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2653 /* This code is more complicated than it has to be, because of two
2654 minor hacks to make the boxes look nicer: (i) if width > 1, draw
2655 the outermost line using the black relief. (ii) Omit the four
2662 XDrawLine (dpy
, window
, gc
,
2663 left_x
+ left_p
, top_y
,
2664 right_x
+ !right_p
, top_y
);
2666 for (i
= 1; i
< width
; ++i
)
2667 XDrawLine (dpy
, window
, gc
,
2668 left_x
+ i
* left_p
, top_y
+ i
,
2669 right_x
+ 1 - i
* right_p
, top_y
+ i
);
2676 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
2678 XClearArea (dpy
, window
, left_x
, top_y
, 1, 1, False
);
2679 XClearArea (dpy
, window
, left_x
, bottom_y
, 1, 1, False
);
2681 for (i
= (width
> 1 ? 1 : 0); i
< width
; ++i
)
2682 XDrawLine (dpy
, window
, gc
,
2683 left_x
+ i
, top_y
+ (i
+ 1) * top_p
,
2684 left_x
+ i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
2687 XSetClipMask (dpy
, gc
, None
);
2689 gc
= f
->output_data
.x
->black_relief
.gc
;
2691 gc
= f
->output_data
.x
->white_relief
.gc
;
2692 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2696 /* Outermost top line. */
2698 XDrawLine (dpy
, window
, gc
,
2699 left_x
+ left_p
, top_y
,
2700 right_x
+ !right_p
, top_y
);
2702 /* Outermost left line. */
2704 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
2710 XDrawLine (dpy
, window
, gc
,
2711 left_x
+ left_p
, bottom_y
,
2712 right_x
+ !right_p
, bottom_y
);
2713 for (i
= 1; i
< width
; ++i
)
2714 XDrawLine (dpy
, window
, gc
,
2715 left_x
+ i
* left_p
, bottom_y
- i
,
2716 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2722 XClearArea (dpy
, window
, right_x
, top_y
, 1, 1, False
);
2723 XClearArea (dpy
, window
, right_x
, bottom_y
, 1, 1, False
);
2724 for (i
= 0; i
< width
; ++i
)
2725 XDrawLine (dpy
, window
, gc
,
2726 right_x
- i
, top_y
+ (i
+ 1) * top_p
,
2727 right_x
- i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
2730 x_reset_clip_rectangles (f
, gc
);
2736 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2737 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2738 draw, it must be >= 0. LEFT_P means draw a line on the
2739 left side of the rectangle. RIGHT_P means draw a line
2740 on the right side of the rectangle. CLIP_RECT is the clipping
2741 rectangle to use when drawing. */
2744 x_draw_box_rect (struct glyph_string
*s
,
2745 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
2746 bool left_p
, bool right_p
, XRectangle
*clip_rect
)
2750 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2751 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2752 x_set_clip_rectangles (s
->f
, s
->gc
, clip_rect
, 1);
2755 x_fill_rectangle (s
->f
, s
->gc
,
2756 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2760 x_fill_rectangle (s
->f
, s
->gc
,
2761 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2764 x_fill_rectangle (s
->f
, s
->gc
,
2765 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2769 x_fill_rectangle (s
->f
, s
->gc
,
2770 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2772 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2773 x_reset_clip_rectangles (s
->f
, s
->gc
);
2777 /* Draw a box around glyph string S. */
2780 x_draw_glyph_string_box (struct glyph_string
*s
)
2782 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
;
2783 bool raised_p
, left_p
, right_p
;
2784 struct glyph
*last_glyph
;
2785 XRectangle clip_rect
;
2787 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2788 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2789 : window_box_right (s
->w
, s
->area
));
2791 /* The glyph that may have a right box line. */
2792 last_glyph
= (s
->cmp
|| s
->img
2794 : s
->first_glyph
+ s
->nchars
- 1);
2796 width
= eabs (s
->face
->box_line_width
);
2797 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2799 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2801 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2803 bottom_y
= top_y
+ s
->height
- 1;
2805 left_p
= (s
->first_glyph
->left_box_line_p
2806 || (s
->hl
== DRAW_MOUSE_FACE
2808 || s
->prev
->hl
!= s
->hl
)));
2809 right_p
= (last_glyph
->right_box_line_p
2810 || (s
->hl
== DRAW_MOUSE_FACE
2812 || s
->next
->hl
!= s
->hl
)));
2814 get_glyph_string_clip_rect (s
, &clip_rect
);
2816 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2817 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2818 left_p
, right_p
, &clip_rect
);
2821 x_setup_relief_colors (s
);
2822 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2823 width
, raised_p
, true, true, left_p
, right_p
,
2829 /* Draw foreground of image glyph string S. */
2832 x_draw_image_foreground (struct glyph_string
*s
)
2835 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2837 /* If first glyph of S has a left box line, start drawing it to the
2838 right of that line. */
2839 if (s
->face
->box
!= FACE_NO_BOX
2840 && s
->first_glyph
->left_box_line_p
2842 x
+= eabs (s
->face
->box_line_width
);
2844 /* If there is a margin around the image, adjust x- and y-position
2846 if (s
->slice
.x
== 0)
2847 x
+= s
->img
->hmargin
;
2848 if (s
->slice
.y
== 0)
2849 y
+= s
->img
->vmargin
;
2855 /* We can't set both a clip mask and use XSetClipRectangles
2856 because the latter also sets a clip mask. We also can't
2857 trust on the shape extension to be available
2858 (XShapeCombineRegion). So, compute the rectangle to draw
2860 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2863 XRectangle clip_rect
, image_rect
, r
;
2865 xgcv
.clip_mask
= s
->img
->mask
;
2866 xgcv
.clip_x_origin
= x
;
2867 xgcv
.clip_y_origin
= y
;
2868 xgcv
.function
= GXcopy
;
2869 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2871 get_glyph_string_clip_rect (s
, &clip_rect
);
2874 image_rect
.width
= s
->slice
.width
;
2875 image_rect
.height
= s
->slice
.height
;
2876 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2877 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2878 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2879 r
.width
, r
.height
, r
.x
, r
.y
);
2883 XRectangle clip_rect
, image_rect
, r
;
2885 get_glyph_string_clip_rect (s
, &clip_rect
);
2888 image_rect
.width
= s
->slice
.width
;
2889 image_rect
.height
= s
->slice
.height
;
2890 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2891 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2892 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2893 r
.width
, r
.height
, r
.x
, r
.y
);
2895 /* When the image has a mask, we can expect that at
2896 least part of a mouse highlight or a block cursor will
2897 be visible. If the image doesn't have a mask, make
2898 a block cursor visible by drawing a rectangle around
2899 the image. I believe it's looking better if we do
2900 nothing here for mouse-face. */
2901 if (s
->hl
== DRAW_CURSOR
)
2903 int relief
= eabs (s
->img
->relief
);
2904 x_draw_rectangle (s
->f
, s
->gc
,
2905 x
- relief
, y
- relief
,
2906 s
->slice
.width
+ relief
*2 - 1,
2907 s
->slice
.height
+ relief
*2 - 1);
2912 /* Draw a rectangle if image could not be loaded. */
2913 x_draw_rectangle (s
->f
, s
->gc
, x
, y
,
2914 s
->slice
.width
- 1, s
->slice
.height
- 1);
2918 /* Draw a relief around the image glyph string S. */
2921 x_draw_image_relief (struct glyph_string
*s
)
2924 bool raised_p
, top_p
, bot_p
, left_p
, right_p
;
2925 int extra_x
, extra_y
;
2928 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2930 /* If first glyph of S has a left box line, start drawing it to the
2931 right of that line. */
2932 if (s
->face
->box
!= FACE_NO_BOX
2933 && s
->first_glyph
->left_box_line_p
2935 x
+= eabs (s
->face
->box_line_width
);
2937 /* If there is a margin around the image, adjust x- and y-position
2939 if (s
->slice
.x
== 0)
2940 x
+= s
->img
->hmargin
;
2941 if (s
->slice
.y
== 0)
2942 y
+= s
->img
->vmargin
;
2944 if (s
->hl
== DRAW_IMAGE_SUNKEN
2945 || s
->hl
== DRAW_IMAGE_RAISED
)
2947 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2948 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2952 thick
= eabs (s
->img
->relief
);
2953 raised_p
= s
->img
->relief
> 0;
2956 x1
= x
+ s
->slice
.width
- 1;
2957 y1
= y
+ s
->slice
.height
- 1;
2959 extra_x
= extra_y
= 0;
2960 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
2962 if (CONSP (Vtool_bar_button_margin
)
2963 && INTEGERP (XCAR (Vtool_bar_button_margin
))
2964 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
2966 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
2967 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
2969 else if (INTEGERP (Vtool_bar_button_margin
))
2970 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
2973 top_p
= bot_p
= left_p
= right_p
= false;
2975 if (s
->slice
.x
== 0)
2976 x
-= thick
+ extra_x
, left_p
= true;
2977 if (s
->slice
.y
== 0)
2978 y
-= thick
+ extra_y
, top_p
= true;
2979 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
2980 x1
+= thick
+ extra_x
, right_p
= true;
2981 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
2982 y1
+= thick
+ extra_y
, bot_p
= true;
2984 x_setup_relief_colors (s
);
2985 get_glyph_string_clip_rect (s
, &r
);
2986 x_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
2987 top_p
, bot_p
, left_p
, right_p
, &r
);
2991 /* Draw the foreground of image glyph string S to PIXMAP. */
2994 x_draw_image_foreground_1 (struct glyph_string
*s
, Pixmap pixmap
)
2997 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2999 /* If first glyph of S has a left box line, start drawing it to the
3000 right of that line. */
3001 if (s
->face
->box
!= FACE_NO_BOX
3002 && s
->first_glyph
->left_box_line_p
3004 x
+= eabs (s
->face
->box_line_width
);
3006 /* If there is a margin around the image, adjust x- and y-position
3008 if (s
->slice
.x
== 0)
3009 x
+= s
->img
->hmargin
;
3010 if (s
->slice
.y
== 0)
3011 y
+= s
->img
->vmargin
;
3017 /* We can't set both a clip mask and use XSetClipRectangles
3018 because the latter also sets a clip mask. We also can't
3019 trust on the shape extension to be available
3020 (XShapeCombineRegion). So, compute the rectangle to draw
3022 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
3026 xgcv
.clip_mask
= s
->img
->mask
;
3027 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
3028 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
3029 xgcv
.function
= GXcopy
;
3030 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
3032 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3033 s
->slice
.x
, s
->slice
.y
,
3034 s
->slice
.width
, s
->slice
.height
, x
, y
);
3035 XSetClipMask (s
->display
, s
->gc
, None
);
3039 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
3040 s
->slice
.x
, s
->slice
.y
,
3041 s
->slice
.width
, s
->slice
.height
, x
, y
);
3043 /* When the image has a mask, we can expect that at
3044 least part of a mouse highlight or a block cursor will
3045 be visible. If the image doesn't have a mask, make
3046 a block cursor visible by drawing a rectangle around
3047 the image. I believe it's looking better if we do
3048 nothing here for mouse-face. */
3049 if (s
->hl
== DRAW_CURSOR
)
3051 int r
= eabs (s
->img
->relief
);
3052 x_draw_rectangle (s
->f
, s
->gc
, x
- r
, y
- r
,
3053 s
->slice
.width
+ r
*2 - 1,
3054 s
->slice
.height
+ r
*2 - 1);
3059 /* Draw a rectangle if image could not be loaded. */
3060 x_draw_rectangle (s
->f
, s
->gc
, x
, y
,
3061 s
->slice
.width
- 1, s
->slice
.height
- 1);
3065 /* Draw part of the background of glyph string S. X, Y, W, and H
3066 give the rectangle to draw. */
3069 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
3073 /* Fill background with a stipple pattern. */
3074 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3075 x_fill_rectangle (s
->f
, s
->gc
, x
, y
, w
, h
);
3076 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3079 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
3083 /* Draw image glyph string S.
3086 s->x +-------------------------
3089 | +-------------------------
3092 | | +-------------------
3098 x_draw_image_glyph_string (struct glyph_string
*s
)
3100 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
3101 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
3103 Pixmap pixmap
= None
;
3106 if (s
->slice
.y
== 0)
3107 height
-= box_line_vwidth
;
3108 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
3109 height
-= box_line_vwidth
;
3111 /* Fill background with face under the image. Do it only if row is
3112 taller than image or if image has a clip mask to reduce
3114 s
->stippled_p
= s
->face
->stipple
!= 0;
3115 if (height
> s
->slice
.height
3119 || s
->img
->pixmap
== 0
3120 || s
->width
!= s
->background_width
)
3124 /* Create a pixmap as large as the glyph string. Fill it
3125 with the background color. Copy the image to it, using
3126 its mask. Copy the temporary pixmap to the display. */
3127 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
3128 int depth
= DefaultDepthOfScreen (screen
);
3130 /* Create a pixmap as large as the glyph string. */
3131 pixmap
= XCreatePixmap (s
->display
, s
->window
,
3132 s
->background_width
,
3135 /* Don't clip in the following because we're working on the
3137 XSetClipMask (s
->display
, s
->gc
, None
);
3139 /* Fill the pixmap with the background color/stipple. */
3142 /* Fill background with a stipple pattern. */
3143 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3144 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
3145 XFillRectangle (s
->display
, pixmap
, s
->gc
,
3146 0, 0, s
->background_width
, s
->height
);
3147 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3148 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
3153 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
3155 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3156 XFillRectangle (s
->display
, pixmap
, s
->gc
,
3157 0, 0, s
->background_width
, s
->height
);
3158 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3165 int width
= s
->background_width
;
3167 if (s
->first_glyph
->left_box_line_p
3170 x
+= box_line_hwidth
;
3171 width
-= box_line_hwidth
;
3174 if (s
->slice
.y
== 0)
3175 y
+= box_line_vwidth
;
3177 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
3180 s
->background_filled_p
= true;
3183 /* Draw the foreground. */
3185 if (s
->img
->cr_data
)
3187 cairo_t
*cr
= x_begin_cr_clip (s
->f
, s
->gc
);
3189 int x
= s
->x
+ s
->img
->hmargin
;
3190 int y
= s
->y
+ s
->img
->vmargin
;
3191 int width
= s
->background_width
;
3193 cairo_set_source_surface (cr
, s
->img
->cr_data
,
3196 cairo_rectangle (cr
, x
, y
, width
, height
);
3198 x_end_cr_clip (s
->f
);
3204 x_draw_image_foreground_1 (s
, pixmap
);
3205 x_set_glyph_string_clipping (s
);
3206 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
3207 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
3208 XFreePixmap (s
->display
, pixmap
);
3211 x_draw_image_foreground (s
);
3213 /* If we must draw a relief around the image, do it. */
3215 || s
->hl
== DRAW_IMAGE_RAISED
3216 || s
->hl
== DRAW_IMAGE_SUNKEN
)
3217 x_draw_image_relief (s
);
3221 /* Draw stretch glyph string S. */
3224 x_draw_stretch_glyph_string (struct glyph_string
*s
)
3226 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
3228 if (s
->hl
== DRAW_CURSOR
3229 && !x_stretch_cursor_p
)
3231 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
3232 wide as the stretch glyph. */
3233 int width
, background_width
= s
->background_width
;
3236 if (!s
->row
->reversed_p
)
3238 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
3242 background_width
-= left_x
- x
;
3248 /* In R2L rows, draw the cursor on the right edge of the
3250 int right_x
= window_box_right (s
->w
, TEXT_AREA
);
3252 if (x
+ background_width
> right_x
)
3253 background_width
-= x
- right_x
;
3254 x
+= background_width
;
3256 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
3257 if (s
->row
->reversed_p
)
3261 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
3263 /* Clear rest using the GC of the original non-cursor face. */
3264 if (width
< background_width
)
3267 int w
= background_width
- width
, h
= s
->height
;
3271 if (!s
->row
->reversed_p
)
3275 if (s
->row
->mouse_face_p
3276 && cursor_in_mouse_face_p (s
->w
))
3278 x_set_mouse_face_gc (s
);
3284 get_glyph_string_clip_rect (s
, &r
);
3285 x_set_clip_rectangles (s
->f
, gc
, &r
, 1);
3287 if (s
->face
->stipple
)
3289 /* Fill background with a stipple pattern. */
3290 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
3291 x_fill_rectangle (s
->f
, gc
, x
, y
, w
, h
);
3292 XSetFillStyle (s
->display
, gc
, FillSolid
);
3297 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
3298 XSetForeground (s
->display
, gc
, xgcv
.background
);
3299 x_fill_rectangle (s
->f
, gc
, x
, y
, w
, h
);
3300 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
3303 x_reset_clip_rectangles (s
->f
, gc
);
3306 else if (!s
->background_filled_p
)
3308 int background_width
= s
->background_width
;
3309 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
3311 /* Don't draw into left margin, fringe or scrollbar area
3312 except for header line and mode line. */
3313 if (x
< left_x
&& !s
->row
->mode_line_p
)
3315 background_width
-= left_x
- x
;
3318 if (background_width
> 0)
3319 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
3322 s
->background_filled_p
= true;
3326 Draw a wavy line under S. The wave fills wave_height pixels from y0.
3332 wave_height = 3 | * * * *
3337 x_draw_underwave (struct glyph_string
*s
)
3339 int wave_height
= 3, wave_length
= 2;
3341 x_draw_horizontal_wave (s
->f
, s
->gc
, s
->x
, s
->ybase
- wave_height
+ 3,
3342 s
->width
, wave_height
, wave_length
);
3343 #else /* not USE_CAIRO */
3344 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, xmax
;
3346 XRectangle wave_clip
, string_clip
, final_clip
;
3349 dy
= wave_height
- 1;
3351 y0
= s
->ybase
- wave_height
+ 3;
3355 /* Find and set clipping rectangle */
3359 wave_clip
.width
= width
;
3360 wave_clip
.height
= wave_height
;
3361 get_glyph_string_clip_rect (s
, &string_clip
);
3363 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
3366 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &final_clip
, 1, Unsorted
);
3368 /* Draw the waves */
3370 x1
= x0
- (x0
% dx
);
3372 odd
= (x1
/ dx
) & 1;
3380 if (INT_MAX
- dx
< xmax
)
3385 XDrawLine (s
->display
, s
->window
, s
->gc
, x1
, y1
, x2
, y2
);
3387 x2
+= dx
, y2
= y0
+ odd
*dy
;
3391 /* Restore previous clipping rectangle(s) */
3392 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, s
->clip
, s
->num_clips
, Unsorted
);
3393 #endif /* not USE_CAIRO */
3397 /* Draw glyph string S. */
3400 x_draw_glyph_string (struct glyph_string
*s
)
3402 bool relief_drawn_p
= false;
3404 /* If S draws into the background of its successors, draw the
3405 background of the successors first so that S can draw into it.
3406 This makes S->next use XDrawString instead of XDrawImageString. */
3407 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
3410 struct glyph_string
*next
;
3412 for (width
= 0, next
= s
->next
;
3413 next
&& width
< s
->right_overhang
;
3414 width
+= next
->width
, next
= next
->next
)
3415 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
3417 x_set_glyph_string_gc (next
);
3418 x_set_glyph_string_clipping (next
);
3419 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
3420 x_draw_stretch_glyph_string (next
);
3422 x_draw_glyph_string_background (next
, true);
3423 next
->num_clips
= 0;
3427 /* Set up S->gc, set clipping and draw S. */
3428 x_set_glyph_string_gc (s
);
3430 /* Draw relief (if any) in advance for char/composition so that the
3431 glyph string can be drawn over it. */
3432 if (!s
->for_overlaps
3433 && s
->face
->box
!= FACE_NO_BOX
3434 && (s
->first_glyph
->type
== CHAR_GLYPH
3435 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
3438 x_set_glyph_string_clipping (s
);
3439 x_draw_glyph_string_background (s
, true);
3440 x_draw_glyph_string_box (s
);
3441 x_set_glyph_string_clipping (s
);
3442 relief_drawn_p
= true;
3444 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
3446 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
3447 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
3448 /* We must clip just this glyph. left_overhang part has already
3449 drawn when s->prev was drawn, and right_overhang part will be
3450 drawn later when s->next is drawn. */
3451 x_set_glyph_string_clipping_exactly (s
, s
);
3453 x_set_glyph_string_clipping (s
);
3455 switch (s
->first_glyph
->type
)
3458 x_draw_image_glyph_string (s
);
3462 x_draw_stretch_glyph_string (s
);
3466 if (s
->for_overlaps
)
3467 s
->background_filled_p
= true;
3469 x_draw_glyph_string_background (s
, false);
3470 x_draw_glyph_string_foreground (s
);
3473 case COMPOSITE_GLYPH
:
3474 if (s
->for_overlaps
|| (s
->cmp_from
> 0
3475 && ! s
->first_glyph
->u
.cmp
.automatic
))
3476 s
->background_filled_p
= true;
3478 x_draw_glyph_string_background (s
, true);
3479 x_draw_composite_glyph_string_foreground (s
);
3482 case GLYPHLESS_GLYPH
:
3483 if (s
->for_overlaps
)
3484 s
->background_filled_p
= true;
3486 x_draw_glyph_string_background (s
, true);
3487 x_draw_glyphless_glyph_string_foreground (s
);
3494 if (!s
->for_overlaps
)
3496 /* Draw underline. */
3497 if (s
->face
->underline_p
)
3499 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
3501 if (s
->face
->underline_defaulted_p
)
3502 x_draw_underwave (s
);
3506 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3507 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
3508 x_draw_underwave (s
);
3509 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3512 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
3514 unsigned long thickness
, position
;
3517 if (s
->prev
&& s
->prev
->face
->underline_p
3518 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
3520 /* We use the same underline style as the previous one. */
3521 thickness
= s
->prev
->underline_thickness
;
3522 position
= s
->prev
->underline_position
;
3526 /* Get the underline thickness. Default is 1 pixel. */
3527 if (s
->font
&& s
->font
->underline_thickness
> 0)
3528 thickness
= s
->font
->underline_thickness
;
3531 if (x_underline_at_descent_line
)
3532 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
3535 /* Get the underline position. This is the recommended
3536 vertical offset in pixels from the baseline to the top of
3537 the underline. This is a signed value according to the
3538 specs, and its default is
3540 ROUND ((maximum descent) / 2), with
3541 ROUND(x) = floor (x + 0.5) */
3543 if (x_use_underline_position_properties
3544 && s
->font
&& s
->font
->underline_position
>= 0)
3545 position
= s
->font
->underline_position
;
3547 position
= (s
->font
->descent
+ 1) / 2;
3549 position
= underline_minimum_offset
;
3551 position
= max (position
, underline_minimum_offset
);
3553 /* Check the sanity of thickness and position. We should
3554 avoid drawing underline out of the current line area. */
3555 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
3556 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
3557 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
3558 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
3559 s
->underline_thickness
= thickness
;
3560 s
->underline_position
= position
;
3561 y
= s
->ybase
+ position
;
3562 if (s
->face
->underline_defaulted_p
)
3563 x_fill_rectangle (s
->f
, s
->gc
,
3564 s
->x
, y
, s
->width
, thickness
);
3568 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3569 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
3570 x_fill_rectangle (s
->f
, s
->gc
,
3571 s
->x
, y
, s
->width
, thickness
);
3572 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3576 /* Draw overline. */
3577 if (s
->face
->overline_p
)
3579 unsigned long dy
= 0, h
= 1;
3581 if (s
->face
->overline_color_defaulted_p
)
3582 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3587 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3588 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
3589 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3591 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3595 /* Draw strike-through. */
3596 if (s
->face
->strike_through_p
)
3598 unsigned long h
= 1;
3599 unsigned long dy
= (s
->height
- h
) / 2;
3601 if (s
->face
->strike_through_color_defaulted_p
)
3602 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3607 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3608 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
3609 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3611 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3615 /* Draw relief if not yet drawn. */
3616 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
3617 x_draw_glyph_string_box (s
);
3621 struct glyph_string
*prev
;
3623 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
3624 if (prev
->hl
!= s
->hl
3625 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
3627 /* As prev was drawn while clipped to its own area, we
3628 must draw the right_overhang part using s->hl now. */
3629 enum draw_glyphs_face save
= prev
->hl
;
3632 x_set_glyph_string_gc (prev
);
3633 x_set_glyph_string_clipping_exactly (s
, prev
);
3634 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
3635 x_draw_glyph_string_foreground (prev
);
3637 x_draw_composite_glyph_string_foreground (prev
);
3638 x_reset_clip_rectangles (prev
->f
, prev
->gc
);
3640 prev
->num_clips
= 0;
3646 struct glyph_string
*next
;
3648 for (next
= s
->next
; next
; next
= next
->next
)
3649 if (next
->hl
!= s
->hl
3650 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
3652 /* As next will be drawn while clipped to its own area,
3653 we must draw the left_overhang part using s->hl now. */
3654 enum draw_glyphs_face save
= next
->hl
;
3657 x_set_glyph_string_gc (next
);
3658 x_set_glyph_string_clipping_exactly (s
, next
);
3659 if (next
->first_glyph
->type
== CHAR_GLYPH
)
3660 x_draw_glyph_string_foreground (next
);
3662 x_draw_composite_glyph_string_foreground (next
);
3663 x_reset_clip_rectangles (next
->f
, next
->gc
);
3665 next
->num_clips
= 0;
3666 next
->clip_head
= s
->next
;
3671 /* Reset clipping. */
3672 x_reset_clip_rectangles (s
->f
, s
->gc
);
3676 /* Shift display to make room for inserted glyphs. */
3679 x_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
, int width
, int height
, int shift_by
)
3681 /* Never called on a GUI frame, see
3682 http://lists.gnu.org/archive/html/emacs-devel/2015-05/msg00456.html
3684 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3685 f
->output_data
.x
->normal_gc
,
3686 x
, y
, width
, height
,
3690 /* Delete N glyphs at the nominal cursor position. Not implemented
3694 x_delete_glyphs (struct frame
*f
, register int n
)
3700 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
3701 If they are <= 0, this is probably an error. */
3704 x_clear_area1 (Display
*dpy
, Window window
,
3705 int x
, int y
, int width
, int height
, int exposures
)
3707 eassert (width
> 0 && height
> 0);
3708 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
3713 x_clear_area (struct frame
*f
, int x
, int y
, int width
, int height
)
3718 eassert (width
> 0 && height
> 0);
3720 cr
= x_begin_cr_clip (f
, NULL
);
3721 x_set_cr_source_with_gc_background (f
, f
->output_data
.x
->normal_gc
);
3722 cairo_rectangle (cr
, x
, y
, width
, height
);
3726 x_clear_area1 (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3727 x
, y
, width
, height
, False
);
3732 /* Clear an entire frame. */
3735 x_clear_frame (struct frame
*f
)
3737 /* Clearing the frame will erase any cursor, so mark them all as no
3739 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3745 /* We have to clear the scroll bars. If we have changed colors or
3746 something like that, then they should be notified. */
3747 x_scroll_bar_clear (f
);
3749 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3750 /* Make sure scroll bars are redrawn. As they aren't redrawn by
3751 redisplay, do it here. */
3752 if (FRAME_GTK_WIDGET (f
))
3753 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
3756 XFlush (FRAME_X_DISPLAY (f
));
3761 /* RIF: Show hourglass cursor on frame F. */
3764 x_show_hourglass (struct frame
*f
)
3766 Display
*dpy
= FRAME_X_DISPLAY (f
);
3770 struct x_output
*x
= FRAME_X_OUTPUT (f
);
3771 #ifdef USE_X_TOOLKIT
3774 if (FRAME_OUTER_WINDOW (f
))
3777 x
->hourglass_p
= true;
3779 if (!x
->hourglass_window
)
3781 unsigned long mask
= CWCursor
;
3782 XSetWindowAttributes attrs
;
3784 Window parent
= FRAME_X_WINDOW (f
);
3786 Window parent
= FRAME_OUTER_WINDOW (f
);
3788 attrs
.cursor
= x
->hourglass_cursor
;
3790 x
->hourglass_window
= XCreateWindow
3791 (dpy
, parent
, 0, 0, 32000, 32000, 0, 0,
3792 InputOnly
, CopyFromParent
, mask
, &attrs
);
3795 XMapRaised (dpy
, x
->hourglass_window
);
3801 /* RIF: Cancel hourglass cursor on frame F. */
3804 x_hide_hourglass (struct frame
*f
)
3806 struct x_output
*x
= FRAME_X_OUTPUT (f
);
3808 /* Watch out for newly created frames. */
3809 if (x
->hourglass_window
)
3811 XUnmapWindow (FRAME_X_DISPLAY (f
), x
->hourglass_window
);
3812 /* Sync here because XTread_socket looks at the
3813 hourglass_p flag that is reset to zero below. */
3814 XSync (FRAME_X_DISPLAY (f
), False
);
3815 x
->hourglass_p
= false;
3819 /* Invert the middle quarter of the frame for .15 sec. */
3822 XTflash (struct frame
*f
)
3828 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
3829 when the scroll bars and the edit widget share the same X window. */
3830 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
3832 cairo_t
*cr
= gdk_cairo_create (window
);
3833 cairo_set_source_rgb (cr
, 1, 1, 1);
3834 cairo_set_operator (cr
, CAIRO_OPERATOR_DIFFERENCE
);
3835 #define XFillRectangle(d, win, gc, x, y, w, h) \
3837 cairo_rectangle (cr, x, y, w, h); \
3841 #else /* ! HAVE_GTK3 */
3844 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
3845 ^ FRAME_BACKGROUND_PIXEL (f
));
3846 vals
.function
= GDK_XOR
;
3847 gc
= gdk_gc_new_with_values (window
,
3848 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
3849 #define XFillRectangle(d, win, gc, x, y, w, h) \
3850 gdk_draw_rectangle (window, gc, true, x, y, w, h)
3851 #endif /* ! HAVE_GTK3 */
3852 #else /* ! USE_GTK */
3855 /* Create a GC that will use the GXxor function to flip foreground
3856 pixels into background pixels. */
3860 values
.function
= GXxor
;
3861 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
3862 ^ FRAME_BACKGROUND_PIXEL (f
));
3864 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3865 GCFunction
| GCForeground
, &values
);
3869 /* Get the height not including a menu bar widget. */
3870 int height
= FRAME_PIXEL_HEIGHT (f
);
3871 /* Height of each line to flash. */
3872 int flash_height
= FRAME_LINE_HEIGHT (f
);
3873 /* These will be the left and right margins of the rectangles. */
3874 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3875 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
3876 int width
= flash_right
- flash_left
;
3878 /* If window is tall, flash top and bottom line. */
3879 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3881 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3883 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3884 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3885 width
, flash_height
);
3886 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3888 (height
- flash_height
3889 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3890 width
, flash_height
);
3894 /* If it is short, flash it all. */
3895 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3896 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3897 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3902 struct timespec delay
= make_timespec (0, 150 * 1000 * 1000);
3903 struct timespec wakeup
= timespec_add (current_timespec (), delay
);
3905 /* Keep waiting until past the time wakeup or any input gets
3907 while (! detect_input_pending ())
3909 struct timespec current
= current_timespec ();
3910 struct timespec timeout
;
3912 /* Break if result would not be positive. */
3913 if (timespec_cmp (wakeup
, current
) <= 0)
3916 /* How long `select' should wait. */
3917 timeout
= make_timespec (0, 10 * 1000 * 1000);
3919 /* Try to wait that long--but we might wake up sooner. */
3920 pselect (0, NULL
, NULL
, NULL
, &timeout
, NULL
);
3924 /* If window is tall, flash top and bottom line. */
3925 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3927 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3929 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3930 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3931 width
, flash_height
);
3932 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3934 (height
- flash_height
3935 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3936 width
, flash_height
);
3939 /* If it is short, flash it all. */
3940 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3941 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3942 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3948 g_object_unref (G_OBJECT (gc
));
3950 #undef XFillRectangle
3952 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3963 XTtoggle_invisible_pointer (struct frame
*f
, bool invisible
)
3966 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, invisible
);
3971 /* Make audible bell. */
3974 XTring_bell (struct frame
*f
)
3976 if (FRAME_X_DISPLAY (f
))
3984 XkbBell (FRAME_X_DISPLAY (f
), None
, 0, None
);
3986 XBell (FRAME_X_DISPLAY (f
), 0);
3988 XFlush (FRAME_X_DISPLAY (f
));
3994 /***********************************************************************
3996 ***********************************************************************/
3998 /* Perform an insert-lines or delete-lines operation, inserting N
3999 lines or deleting -N lines at vertical position VPOS. */
4002 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
4008 /* Scroll part of the display as described by RUN. */
4011 x_scroll_run (struct window
*w
, struct run
*run
)
4013 struct frame
*f
= XFRAME (w
->frame
);
4014 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
4016 /* Get frame-relative bounding box of the text display area of W,
4017 without mode lines. Include in this box the left and right
4019 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
4021 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
4022 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
4023 bottom_y
= y
+ height
;
4027 /* Scrolling up. Make sure we don't copy part of the mode
4028 line at the bottom. */
4029 if (from_y
+ run
->height
> bottom_y
)
4030 height
= bottom_y
- from_y
;
4032 height
= run
->height
;
4036 /* Scrolling down. Make sure we don't copy over the mode line.
4038 if (to_y
+ run
->height
> bottom_y
)
4039 height
= bottom_y
- to_y
;
4041 height
= run
->height
;
4046 /* Cursor off. Will be switched on again in x_update_window_end. */
4050 SET_FRAME_GARBAGED (f
);
4052 XCopyArea (FRAME_X_DISPLAY (f
),
4053 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
4054 f
->output_data
.x
->normal_gc
,
4065 /***********************************************************************
4067 ***********************************************************************/
4071 frame_highlight (struct frame
*f
)
4073 /* We used to only do this if Vx_no_window_manager was non-nil, but
4074 the ICCCM (section 4.1.6) says that the window's border pixmap
4075 and border pixel are window attributes which are "private to the
4076 client", so we can always change it to whatever we want. */
4078 /* I recently started to get errors in this XSetWindowBorder, depending on
4079 the window-manager in use, tho something more is at play since I've been
4080 using that same window-manager binary for ever. Let's not crash just
4081 because of this (bug#9310). */
4082 x_catch_errors (FRAME_X_DISPLAY (f
));
4083 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4084 f
->output_data
.x
->border_pixel
);
4085 x_uncatch_errors ();
4087 x_update_cursor (f
, true);
4088 x_set_frame_alpha (f
);
4092 frame_unhighlight (struct frame
*f
)
4094 /* We used to only do this if Vx_no_window_manager was non-nil, but
4095 the ICCCM (section 4.1.6) says that the window's border pixmap
4096 and border pixel are window attributes which are "private to the
4097 client", so we can always change it to whatever we want. */
4099 /* Same as above for XSetWindowBorder (bug#9310). */
4100 x_catch_errors (FRAME_X_DISPLAY (f
));
4101 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4102 f
->output_data
.x
->border_tile
);
4103 x_uncatch_errors ();
4105 x_update_cursor (f
, true);
4106 x_set_frame_alpha (f
);
4109 /* The focus has changed. Update the frames as necessary to reflect
4110 the new situation. Note that we can't change the selected frame
4111 here, because the Lisp code we are interrupting might become confused.
4112 Each event gets marked with the frame in which it occurred, so the
4113 Lisp code can tell when the switch took place by examining the events. */
4116 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
4118 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
4120 if (frame
!= dpyinfo
->x_focus_frame
)
4122 /* Set this before calling other routines, so that they see
4123 the correct value of x_focus_frame. */
4124 dpyinfo
->x_focus_frame
= frame
;
4126 if (old_focus
&& old_focus
->auto_lower
)
4127 x_lower_frame (old_focus
);
4129 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
4130 dpyinfo
->x_pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
4132 dpyinfo
->x_pending_autoraise_frame
= NULL
;
4135 x_frame_rehighlight (dpyinfo
);
4138 /* Handle FocusIn and FocusOut state changes for FRAME.
4139 If FRAME has focus and there exists more than one frame, puts
4140 a FOCUS_IN_EVENT into *BUFP. */
4143 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
4145 if (type
== FocusIn
)
4147 if (dpyinfo
->x_focus_event_frame
!= frame
)
4149 x_new_focus_frame (dpyinfo
, frame
);
4150 dpyinfo
->x_focus_event_frame
= frame
;
4152 /* Don't stop displaying the initial startup message
4153 for a switch-frame event we don't need. */
4154 /* When run as a daemon, Vterminal_frame is always NIL. */
4155 bufp
->arg
= (((NILP (Vterminal_frame
)
4156 || ! FRAME_X_P (XFRAME (Vterminal_frame
))
4157 || EQ (Fdaemonp (), Qt
))
4158 && CONSP (Vframe_list
)
4159 && !NILP (XCDR (Vframe_list
)))
4161 bufp
->kind
= FOCUS_IN_EVENT
;
4162 XSETFRAME (bufp
->frame_or_window
, frame
);
4165 frame
->output_data
.x
->focus_state
|= state
;
4168 if (FRAME_XIC (frame
))
4169 XSetICFocus (FRAME_XIC (frame
));
4172 else if (type
== FocusOut
)
4174 frame
->output_data
.x
->focus_state
&= ~state
;
4176 if (dpyinfo
->x_focus_event_frame
== frame
)
4178 dpyinfo
->x_focus_event_frame
= 0;
4179 x_new_focus_frame (dpyinfo
, 0);
4181 bufp
->kind
= FOCUS_OUT_EVENT
;
4182 XSETFRAME (bufp
->frame_or_window
, frame
);
4186 if (FRAME_XIC (frame
))
4187 XUnsetICFocus (FRAME_XIC (frame
));
4189 if (frame
->pointer_invisible
)
4190 XTtoggle_invisible_pointer (frame
, false);
4194 /* Return the Emacs frame-object corresponding to an X window.
4195 It could be the frame's main window or an icon window. */
4197 static struct frame
*
4198 x_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4200 Lisp_Object tail
, frame
;
4206 FOR_EACH_FRAME (tail
, frame
)
4209 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4211 if (f
->output_data
.x
->hourglass_window
== wdesc
)
4213 #ifdef USE_X_TOOLKIT
4214 if ((f
->output_data
.x
->edit_widget
4215 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
4216 /* A tooltip frame? */
4217 || (!f
->output_data
.x
->edit_widget
4218 && FRAME_X_WINDOW (f
) == wdesc
)
4219 || f
->output_data
.x
->icon_desc
== wdesc
)
4221 #else /* not USE_X_TOOLKIT */
4223 if (f
->output_data
.x
->edit_widget
)
4225 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4226 struct x_output
*x
= f
->output_data
.x
;
4227 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
4230 #endif /* USE_GTK */
4231 if (FRAME_X_WINDOW (f
) == wdesc
4232 || f
->output_data
.x
->icon_desc
== wdesc
)
4234 #endif /* not USE_X_TOOLKIT */
4239 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
4241 /* Like x_window_to_frame but also compares the window with the widget's
4244 static struct frame
*
4245 x_any_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4247 Lisp_Object tail
, frame
;
4248 struct frame
*f
, *found
= NULL
;
4254 FOR_EACH_FRAME (tail
, frame
)
4259 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
4261 /* This frame matches if the window is any of its widgets. */
4262 x
= f
->output_data
.x
;
4263 if (x
->hourglass_window
== wdesc
)
4268 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4270 && gtk_widget_get_toplevel (gwdesc
) == x
->widget
)
4273 if (wdesc
== XtWindow (x
->widget
)
4274 || wdesc
== XtWindow (x
->column_widget
)
4275 || wdesc
== XtWindow (x
->edit_widget
))
4277 /* Match if the window is this frame's menubar. */
4278 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
4282 else if (FRAME_X_WINDOW (f
) == wdesc
)
4283 /* A tooltip frame. */
4291 /* Likewise, but consider only the menu bar widget. */
4293 static struct frame
*
4294 x_menubar_window_to_frame (struct x_display_info
*dpyinfo
,
4295 const XEvent
*event
)
4297 Window wdesc
= event
->xany
.window
;
4298 Lisp_Object tail
, frame
;
4305 FOR_EACH_FRAME (tail
, frame
)
4308 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4310 x
= f
->output_data
.x
;
4312 if (x
->menubar_widget
&& xg_event_is_for_menubar (f
, event
))
4315 /* Match if the window is this frame's menubar. */
4316 if (x
->menubar_widget
4317 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
4324 /* Return the frame whose principal (outermost) window is WDESC.
4325 If WDESC is some other (smaller) window, we return 0. */
4328 x_top_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4330 Lisp_Object tail
, frame
;
4337 FOR_EACH_FRAME (tail
, frame
)
4340 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4342 x
= f
->output_data
.x
;
4346 /* This frame matches if the window is its topmost widget. */
4348 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4349 if (gwdesc
== x
->widget
)
4352 if (wdesc
== XtWindow (x
->widget
))
4356 else if (FRAME_X_WINDOW (f
) == wdesc
)
4357 /* Tooltip frame. */
4363 #else /* !USE_X_TOOLKIT && !USE_GTK */
4365 #define x_any_window_to_frame(d, i) x_window_to_frame (d, i)
4366 #define x_top_window_to_frame(d, i) x_window_to_frame (d, i)
4368 #endif /* USE_X_TOOLKIT || USE_GTK */
4370 /* The focus may have changed. Figure out if it is a real focus change,
4371 by checking both FocusIn/Out and Enter/LeaveNotify events.
4373 Returns FOCUS_IN_EVENT event in *BUFP. */
4376 x_detect_focus_change (struct x_display_info
*dpyinfo
, struct frame
*frame
,
4377 const XEvent
*event
, struct input_event
*bufp
)
4382 switch (event
->type
)
4387 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
4389 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
4391 if (event
->xcrossing
.detail
!= NotifyInferior
4392 && event
->xcrossing
.focus
4393 && ! (focus_state
& FOCUS_EXPLICIT
))
4394 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
4396 dpyinfo
, frame
, bufp
);
4402 x_focus_changed (event
->type
,
4403 (event
->xfocus
.detail
== NotifyPointer
?
4404 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
4405 dpyinfo
, frame
, bufp
);
4409 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
4411 enum xembed_message msg
= event
->xclient
.data
.l
[1];
4412 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
4413 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
4420 #if !defined USE_X_TOOLKIT && !defined USE_GTK
4421 /* Handle an event saying the mouse has moved out of an Emacs frame. */
4424 x_mouse_leave (struct x_display_info
*dpyinfo
)
4426 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
4430 /* The focus has changed, or we have redirected a frame's focus to
4431 another frame (this happens when a frame uses a surrogate
4432 mini-buffer frame). Shift the highlight as appropriate.
4434 The FRAME argument doesn't necessarily have anything to do with which
4435 frame is being highlighted or un-highlighted; we only use it to find
4436 the appropriate X display info. */
4439 XTframe_rehighlight (struct frame
*frame
)
4441 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
4445 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
4447 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
4449 if (dpyinfo
->x_focus_frame
)
4451 dpyinfo
->x_highlight_frame
4452 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
4453 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
4454 : dpyinfo
->x_focus_frame
);
4455 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
4457 fset_focus_frame (dpyinfo
->x_focus_frame
, Qnil
);
4458 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
4462 dpyinfo
->x_highlight_frame
= 0;
4464 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
4467 frame_unhighlight (old_highlight
);
4468 if (dpyinfo
->x_highlight_frame
)
4469 frame_highlight (dpyinfo
->x_highlight_frame
);
4475 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
4477 /* Initialize mode_switch_bit and modifier_meaning. */
4479 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
4481 int min_code
, max_code
;
4484 XModifierKeymap
*mods
;
4486 dpyinfo
->meta_mod_mask
= 0;
4487 dpyinfo
->shift_lock_mask
= 0;
4488 dpyinfo
->alt_mod_mask
= 0;
4489 dpyinfo
->super_mod_mask
= 0;
4490 dpyinfo
->hyper_mod_mask
= 0;
4492 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
4494 syms
= XGetKeyboardMapping (dpyinfo
->display
,
4495 min_code
, max_code
- min_code
+ 1,
4497 mods
= XGetModifierMapping (dpyinfo
->display
);
4499 /* Scan the modifier table to see which modifier bits the Meta and
4500 Alt keysyms are on. */
4502 int row
, col
; /* The row and column in the modifier table. */
4503 bool found_alt_or_meta
;
4505 for (row
= 3; row
< 8; row
++)
4507 found_alt_or_meta
= false;
4508 for (col
= 0; col
< mods
->max_keypermod
; col
++)
4510 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
4512 /* Zeroes are used for filler. Skip them. */
4516 /* Are any of this keycode's keysyms a meta key? */
4520 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
4522 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
4528 found_alt_or_meta
= true;
4529 dpyinfo
->meta_mod_mask
|= (1 << row
);
4534 found_alt_or_meta
= true;
4535 dpyinfo
->alt_mod_mask
|= (1 << row
);
4540 if (!found_alt_or_meta
)
4541 dpyinfo
->hyper_mod_mask
|= (1 << row
);
4542 code_col
= syms_per_code
;
4543 col
= mods
->max_keypermod
;
4548 if (!found_alt_or_meta
)
4549 dpyinfo
->super_mod_mask
|= (1 << row
);
4550 code_col
= syms_per_code
;
4551 col
= mods
->max_keypermod
;
4555 /* Ignore this if it's not on the lock modifier. */
4556 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
4557 dpyinfo
->shift_lock_mask
= LockMask
;
4558 code_col
= syms_per_code
;
4559 col
= mods
->max_keypermod
;
4568 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
4569 if (! dpyinfo
->meta_mod_mask
)
4571 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
4572 dpyinfo
->alt_mod_mask
= 0;
4575 /* If some keys are both alt and meta,
4576 make them just meta, not alt. */
4577 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
4579 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
4583 XFreeModifiermap (mods
);
4586 /* Convert between the modifier bits X uses and the modifier bits
4590 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, int state
)
4592 int mod_meta
= meta_modifier
;
4593 int mod_alt
= alt_modifier
;
4594 int mod_hyper
= hyper_modifier
;
4595 int mod_super
= super_modifier
;
4598 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
4599 if (INTEGERP (tem
)) mod_alt
= XINT (tem
) & INT_MAX
;
4600 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
4601 if (INTEGERP (tem
)) mod_meta
= XINT (tem
) & INT_MAX
;
4602 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
4603 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
) & INT_MAX
;
4604 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
4605 if (INTEGERP (tem
)) mod_super
= XINT (tem
) & INT_MAX
;
4607 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
4608 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
4609 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
4610 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
4611 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
4612 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
4616 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, EMACS_INT state
)
4618 EMACS_INT mod_meta
= meta_modifier
;
4619 EMACS_INT mod_alt
= alt_modifier
;
4620 EMACS_INT mod_hyper
= hyper_modifier
;
4621 EMACS_INT mod_super
= super_modifier
;
4625 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
4626 if (INTEGERP (tem
)) mod_alt
= XINT (tem
);
4627 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
4628 if (INTEGERP (tem
)) mod_meta
= XINT (tem
);
4629 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
4630 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
);
4631 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
4632 if (INTEGERP (tem
)) mod_super
= XINT (tem
);
4635 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
4636 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
4637 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
4638 | ((state
& shift_modifier
) ? ShiftMask
: 0)
4639 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
4640 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
4643 /* Convert a keysym to its name. */
4646 x_get_keysym_name (int keysym
)
4651 value
= XKeysymToString (keysym
);
4657 /* Mouse clicks and mouse movement. Rah.
4659 Formerly, we used PointerMotionHintMask (in standard_event_mask)
4660 so that we would have to call XQueryPointer after each MotionNotify
4661 event to ask for another such event. However, this made mouse tracking
4662 slow, and there was a bug that made it eventually stop.
4664 Simply asking for MotionNotify all the time seems to work better.
4666 In order to avoid asking for motion events and then throwing most
4667 of them away or busy-polling the server for mouse positions, we ask
4668 the server for pointer motion hints. This means that we get only
4669 one event per group of mouse movements. "Groups" are delimited by
4670 other kinds of events (focus changes and button clicks, for
4671 example), or by XQueryPointer calls; when one of these happens, we
4672 get another MotionNotify event the next time the mouse moves. This
4673 is at least as efficient as getting motion events when mouse
4674 tracking is on, and I suspect only negligibly worse when tracking
4677 /* Prepare a mouse-event in *RESULT for placement in the input queue.
4679 If the event is a button press, then note that we have grabbed
4683 construct_mouse_click (struct input_event
*result
,
4684 const XButtonEvent
*event
,
4687 /* Make the event type NO_EVENT; we'll change that when we decide
4689 result
->kind
= MOUSE_CLICK_EVENT
;
4690 result
->code
= event
->button
- Button1
;
4691 result
->timestamp
= event
->time
;
4692 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
),
4694 | (event
->type
== ButtonRelease
4698 XSETINT (result
->x
, event
->x
);
4699 XSETINT (result
->y
, event
->y
);
4700 XSETFRAME (result
->frame_or_window
, f
);
4705 /* Function to report a mouse movement to the mainstream Emacs code.
4706 The input handler calls this.
4708 We have received a mouse movement event, which is given in *event.
4709 If the mouse is over a different glyph than it was last time, tell
4710 the mainstream emacs code by setting mouse_moved. If not, ask for
4711 another motion event, so we can check again the next time it moves. */
4714 note_mouse_movement (struct frame
*frame
, const XMotionEvent
*event
)
4717 struct x_display_info
*dpyinfo
;
4719 if (!FRAME_X_OUTPUT (frame
))
4722 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
4723 dpyinfo
->last_mouse_movement_time
= event
->time
;
4724 dpyinfo
->last_mouse_motion_frame
= frame
;
4725 dpyinfo
->last_mouse_motion_x
= event
->x
;
4726 dpyinfo
->last_mouse_motion_y
= event
->y
;
4728 if (event
->window
!= FRAME_X_WINDOW (frame
))
4730 frame
->mouse_moved
= true;
4731 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4732 note_mouse_highlight (frame
, -1, -1);
4733 dpyinfo
->last_mouse_glyph_frame
= NULL
;
4738 /* Has the mouse moved off the glyph it was on at the last sighting? */
4739 r
= &dpyinfo
->last_mouse_glyph
;
4740 if (frame
!= dpyinfo
->last_mouse_glyph_frame
4741 || event
->x
< r
->x
|| event
->x
>= r
->x
+ r
->width
4742 || event
->y
< r
->y
|| event
->y
>= r
->y
+ r
->height
)
4744 frame
->mouse_moved
= true;
4745 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4746 note_mouse_highlight (frame
, event
->x
, event
->y
);
4747 /* Remember which glyph we're now on. */
4748 remember_mouse_glyph (frame
, event
->x
, event
->y
, r
);
4749 dpyinfo
->last_mouse_glyph_frame
= frame
;
4756 /* Return the current position of the mouse.
4757 *FP should be a frame which indicates which display to ask about.
4759 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
4760 and *PART to the frame, window, and scroll bar part that the mouse
4761 is over. Set *X and *Y to the portion and whole of the mouse's
4762 position on the scroll bar.
4764 If the mouse movement started elsewhere, set *FP to the frame the
4765 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
4768 Set *TIMESTAMP to the server time-stamp for the time at which the mouse
4769 was at this position.
4771 Don't store anything if we don't have a valid set of values to report.
4773 This clears the mouse_moved flag, so we can wait for the next mouse
4777 XTmouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
4778 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
4782 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4786 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
4788 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4790 if (bar
->horizontal
)
4791 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
4793 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
4800 Window dummy_window
;
4803 Lisp_Object frame
, tail
;
4805 /* Clear the mouse-moved flag for every frame on this display. */
4806 FOR_EACH_FRAME (tail
, frame
)
4807 if (FRAME_X_P (XFRAME (frame
))
4808 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
4809 XFRAME (frame
)->mouse_moved
= false;
4811 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4813 /* Figure out which root window we're on. */
4814 XQueryPointer (FRAME_X_DISPLAY (*fp
),
4815 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
4817 /* The root window which contains the pointer. */
4820 /* Trash which we can't trust if the pointer is on
4821 a different screen. */
4824 /* The position on that root window. */
4827 /* More trash we can't trust. */
4830 /* Modifier keys and pointer buttons, about which
4832 (unsigned int *) &dummy
);
4834 /* Now we have a position on the root; find the innermost window
4835 containing the pointer. */
4839 int parent_x
= 0, parent_y
= 0;
4843 /* XTranslateCoordinates can get errors if the window
4844 structure is changing at the same time this function
4845 is running. So at least we must not crash from them. */
4847 x_catch_errors (FRAME_X_DISPLAY (*fp
));
4849 if (x_mouse_grabbed (dpyinfo
))
4851 /* If mouse was grabbed on a frame, give coords for that frame
4852 even if the mouse is now outside it. */
4853 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4859 FRAME_X_WINDOW (dpyinfo
->last_mouse_frame
),
4861 /* From-position, to-position. */
4862 root_x
, root_y
, &win_x
, &win_y
,
4866 f1
= dpyinfo
->last_mouse_frame
;
4872 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4874 /* From-window, to-window. */
4877 /* From-position, to-position. */
4878 root_x
, root_y
, &win_x
, &win_y
,
4883 if (child
== None
|| child
== win
)
4886 /* We don't wan't to know the innermost window. We
4887 want the edit window. For non-Gtk+ the innermost
4888 window is the edit window. For Gtk+ it might not
4889 be. It might be the tool bar for example. */
4890 if (x_window_to_frame (dpyinfo
, win
))
4898 /* Now we know that:
4899 win is the innermost window containing the pointer
4900 (XTC says it has no child containing the pointer),
4901 win_x and win_y are the pointer's position in it
4902 (XTC did this the last time through), and
4903 parent_x and parent_y are the pointer's position in win's parent.
4904 (They are what win_x and win_y were when win was child.
4905 If win is the root window, it has no parent, and
4906 parent_{x,y} are invalid, but that's okay, because we'll
4907 never use them in that case.) */
4910 /* We don't wan't to know the innermost window. We
4911 want the edit window. */
4912 f1
= x_window_to_frame (dpyinfo
, win
);
4914 /* Is win one of our frames? */
4915 f1
= x_any_window_to_frame (dpyinfo
, win
);
4918 #ifdef USE_X_TOOLKIT
4919 /* If we end up with the menu bar window, say it's not
4922 && f1
->output_data
.x
->menubar_widget
4923 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
4925 #endif /* USE_X_TOOLKIT */
4928 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
4931 x_uncatch_errors ();
4933 /* If not, is it one of our scroll bars? */
4936 struct scroll_bar
*bar
;
4938 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
, 2);
4942 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4948 if (f1
== 0 && insist
> 0)
4949 f1
= SELECTED_FRAME ();
4953 /* Ok, we found a frame. Store all the values.
4954 last_mouse_glyph is a rectangle used to reduce the
4955 generation of mouse events. To not miss any motion
4956 events, we must divide the frame into rectangles of the
4957 size of the smallest character that could be displayed
4958 on it, i.e. into the same rectangles that matrices on
4959 the frame are divided into. */
4961 /* FIXME: what if F1 is not an X frame? */
4962 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
4963 remember_mouse_glyph (f1
, win_x
, win_y
, &dpyinfo
->last_mouse_glyph
);
4964 dpyinfo
->last_mouse_glyph_frame
= f1
;
4969 XSETINT (*x
, win_x
);
4970 XSETINT (*y
, win_y
);
4971 *timestamp
= dpyinfo
->last_mouse_movement_time
;
4981 /***********************************************************************
4983 ***********************************************************************/
4985 /* Scroll bar support. */
4987 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
4989 This can be called in GC, so we have to make sure to strip off mark
4992 static struct scroll_bar
*
4993 x_window_to_scroll_bar (Display
*display
, Window window_id
, int type
)
4995 Lisp_Object tail
, frame
;
4997 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
4998 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
4999 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
5001 FOR_EACH_FRAME (tail
, frame
)
5003 Lisp_Object bar
, condemned
;
5005 if (! FRAME_X_P (XFRAME (frame
)))
5008 /* Scan this frame's scroll bar list for a scroll bar with the
5010 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
5011 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
5012 /* This trick allows us to search both the ordinary and
5013 condemned scroll bar lists with one loop. */
5014 ! NILP (bar
) || (bar
= condemned
,
5017 bar
= XSCROLL_BAR (bar
)->next
)
5018 if (XSCROLL_BAR (bar
)->x_window
== window_id
5019 && FRAME_X_DISPLAY (XFRAME (frame
)) == display
5021 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
5022 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
5023 return XSCROLL_BAR (bar
);
5030 #if defined USE_LUCID
5032 /* Return the Lucid menu bar WINDOW is part of. Return null
5033 if WINDOW is not part of a menu bar. */
5036 x_window_to_menu_bar (Window window
)
5038 Lisp_Object tail
, frame
;
5040 FOR_EACH_FRAME (tail
, frame
)
5041 if (FRAME_X_P (XFRAME (frame
)))
5043 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
5045 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
5051 #endif /* USE_LUCID */
5054 /************************************************************************
5056 ************************************************************************/
5058 #ifdef USE_TOOLKIT_SCROLL_BARS
5060 static void x_send_scroll_bar_event (Lisp_Object
, enum scroll_bar_part
,
5063 /* Lisp window being scrolled. Set when starting to interact with
5064 a toolkit scroll bar, reset to nil when ending the interaction. */
5066 static Lisp_Object window_being_scrolled
;
5068 /* Whether this is an Xaw with arrow-scrollbars. This should imply
5069 that movements of 1/20 of the screen size are mapped to up/down. */
5072 /* Id of action hook installed for scroll bars. */
5074 static XtActionHookId action_hook_id
;
5075 static XtActionHookId horizontal_action_hook_id
;
5077 static Boolean xaw3d_arrow_scroll
;
5079 /* Whether the drag scrolling maintains the mouse at the top of the
5080 thumb. If not, resizing the thumb needs to be done more carefully
5081 to avoid jerkiness. */
5083 static Boolean xaw3d_pick_top
;
5085 /* Action hook installed via XtAppAddActionHook when toolkit scroll
5086 bars are used.. The hook is responsible for detecting when
5087 the user ends an interaction with the scroll bar, and generates
5088 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
5091 xt_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
5092 XEvent
*event
, String
*params
, Cardinal
*num_params
)
5095 const char *end_action
;
5098 scroll_bar_p
= XmIsScrollBar (widget
);
5099 end_action
= "Release";
5100 #else /* !USE_MOTIF i.e. use Xaw */
5101 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
5102 end_action
= "EndScroll";
5103 #endif /* USE_MOTIF */
5106 && strcmp (action_name
, end_action
) == 0
5107 && WINDOWP (window_being_scrolled
))
5110 struct scroll_bar
*bar
;
5112 x_send_scroll_bar_event (window_being_scrolled
,
5113 scroll_bar_end_scroll
, 0, 0, false);
5114 w
= XWINDOW (window_being_scrolled
);
5115 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5117 if (bar
->dragging
!= -1)
5120 /* The thumb size is incorrect while dragging: fix it. */
5121 set_vertical_scroll_bar (w
);
5123 window_being_scrolled
= Qnil
;
5124 #if defined (USE_LUCID)
5125 bar
->last_seen_part
= scroll_bar_nowhere
;
5127 /* Xt timeouts no longer needed. */
5128 toolkit_scroll_bar_interaction
= false;
5134 xt_horizontal_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
5135 XEvent
*event
, String
*params
, Cardinal
*num_params
)
5138 const char *end_action
;
5141 scroll_bar_p
= XmIsScrollBar (widget
);
5142 end_action
= "Release";
5143 #else /* !USE_MOTIF i.e. use Xaw */
5144 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
5145 end_action
= "EndScroll";
5146 #endif /* USE_MOTIF */
5149 && strcmp (action_name
, end_action
) == 0
5150 && WINDOWP (window_being_scrolled
))
5153 struct scroll_bar
*bar
;
5155 x_send_scroll_bar_event (window_being_scrolled
,
5156 scroll_bar_end_scroll
, 0, 0, true);
5157 w
= XWINDOW (window_being_scrolled
);
5158 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
5160 if (bar
->dragging
!= -1)
5163 /* The thumb size is incorrect while dragging: fix it. */
5164 set_horizontal_scroll_bar (w
);
5166 window_being_scrolled
= Qnil
;
5167 #if defined (USE_LUCID)
5168 bar
->last_seen_part
= scroll_bar_nowhere
;
5170 /* Xt timeouts no longer needed. */
5171 toolkit_scroll_bar_interaction
= false;
5174 #endif /* not USE_GTK */
5176 /* Send a client message with message type Xatom_Scrollbar for a
5177 scroll action to the frame of WINDOW. PART is a value identifying
5178 the part of the scroll bar that was clicked on. PORTION is the
5179 amount to scroll of a whole of WHOLE. */
5182 x_send_scroll_bar_event (Lisp_Object window
, enum scroll_bar_part part
,
5183 int portion
, int whole
, bool horizontal
)
5186 XClientMessageEvent
*ev
= &event
.xclient
;
5187 struct window
*w
= XWINDOW (window
);
5188 struct frame
*f
= XFRAME (w
->frame
);
5189 intptr_t iw
= (intptr_t) w
;
5190 enum { BITS_PER_INTPTR
= CHAR_BIT
* sizeof iw
};
5191 verify (BITS_PER_INTPTR
<= 64);
5192 int sign_shift
= BITS_PER_INTPTR
- 32;
5196 /* Construct a ClientMessage event to send to the frame. */
5197 ev
->type
= ClientMessage
;
5198 ev
->message_type
= (horizontal
5199 ? FRAME_DISPLAY_INFO (f
)->Xatom_Horizontal_Scrollbar
5200 : FRAME_DISPLAY_INFO (f
)->Xatom_Scrollbar
);
5201 ev
->display
= FRAME_X_DISPLAY (f
);
5202 ev
->window
= FRAME_X_WINDOW (f
);
5205 /* A 32-bit X client on a 64-bit X server can pass a window pointer
5206 as-is. A 64-bit client on a 32-bit X server is in trouble
5207 because a pointer does not fit and would be truncated while
5208 passing through the server. So use two slots and hope that X12
5209 will resolve such issues someday. */
5210 ev
->data
.l
[0] = iw
>> 31 >> 1;
5211 ev
->data
.l
[1] = sign_shift
<= 0 ? iw
: iw
<< sign_shift
>> sign_shift
;
5212 ev
->data
.l
[2] = part
;
5213 ev
->data
.l
[3] = portion
;
5214 ev
->data
.l
[4] = whole
;
5216 /* Make Xt timeouts work while the scroll bar is active. */
5217 #ifdef USE_X_TOOLKIT
5218 toolkit_scroll_bar_interaction
= true;
5219 x_activate_timeout_atimer ();
5222 /* Setting the event mask to zero means that the message will
5223 be sent to the client that created the window, and if that
5224 window no longer exists, no event will be sent. */
5225 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
5230 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
5234 x_scroll_bar_to_input_event (const XEvent
*event
,
5235 struct input_event
*ievent
)
5237 const XClientMessageEvent
*ev
= &event
->xclient
;
5241 /* See the comment in the function above. */
5242 intptr_t iw0
= ev
->data
.l
[0];
5243 intptr_t iw1
= ev
->data
.l
[1];
5244 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
5245 w
= (struct window
*) iw
;
5247 XSETWINDOW (window
, w
);
5249 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
5250 ievent
->frame_or_window
= window
;
5253 ievent
->timestamp
= CurrentTime
;
5256 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
5259 ievent
->part
= ev
->data
.l
[2];
5260 ievent
->x
= make_number (ev
->data
.l
[3]);
5261 ievent
->y
= make_number (ev
->data
.l
[4]);
5262 ievent
->modifiers
= 0;
5265 /* Transform a horizontal scroll bar ClientMessage EVENT to an Emacs
5266 input event in *IEVENT. */
5269 x_horizontal_scroll_bar_to_input_event (const XEvent
*event
,
5270 struct input_event
*ievent
)
5272 const XClientMessageEvent
*ev
= &event
->xclient
;
5276 /* See the comment in the function above. */
5277 intptr_t iw0
= ev
->data
.l
[0];
5278 intptr_t iw1
= ev
->data
.l
[1];
5279 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
5280 w
= (struct window
*) iw
;
5282 XSETWINDOW (window
, w
);
5284 ievent
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
5285 ievent
->frame_or_window
= window
;
5288 ievent
->timestamp
= CurrentTime
;
5291 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
5294 ievent
->part
= ev
->data
.l
[2];
5295 ievent
->x
= make_number (ev
->data
.l
[3]);
5296 ievent
->y
= make_number (ev
->data
.l
[4]);
5297 ievent
->modifiers
= 0;
5303 /* Minimum and maximum values used for Motif scroll bars. */
5305 #define XM_SB_MAX 10000000
5307 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
5308 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
5309 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
5312 xm_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5314 struct scroll_bar
*bar
= client_data
;
5315 XmScrollBarCallbackStruct
*cs
= call_data
;
5316 enum scroll_bar_part part
= scroll_bar_nowhere
;
5317 bool horizontal
= bar
->horizontal
;
5318 int whole
= 0, portion
= 0;
5322 case XmCR_DECREMENT
:
5324 part
= horizontal
? scroll_bar_left_arrow
: scroll_bar_up_arrow
;
5327 case XmCR_INCREMENT
:
5329 part
= horizontal
? scroll_bar_right_arrow
: scroll_bar_down_arrow
;
5332 case XmCR_PAGE_DECREMENT
:
5334 part
= horizontal
? scroll_bar_before_handle
: scroll_bar_above_handle
;
5337 case XmCR_PAGE_INCREMENT
:
5339 part
= horizontal
? scroll_bar_after_handle
: scroll_bar_below_handle
;
5344 part
= horizontal
? scroll_bar_to_leftmost
: scroll_bar_to_top
;
5347 case XmCR_TO_BOTTOM
:
5349 part
= horizontal
? scroll_bar_to_rightmost
: scroll_bar_to_bottom
;
5357 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
5362 portion
= bar
->whole
* ((float)cs
->value
/ XM_SB_MAX
);
5363 whole
= bar
->whole
* ((float)(XM_SB_MAX
- slider_size
) / XM_SB_MAX
);
5364 portion
= min (portion
, whole
);
5365 part
= scroll_bar_horizontal_handle
;
5369 whole
= XM_SB_MAX
- slider_size
;
5370 portion
= min (cs
->value
, whole
);
5371 part
= scroll_bar_handle
;
5374 bar
->dragging
= cs
->value
;
5378 case XmCR_VALUE_CHANGED
:
5382 if (part
!= scroll_bar_nowhere
)
5384 window_being_scrolled
= bar
->window
;
5385 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
,
5390 #elif defined USE_GTK
5392 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
5393 bar widget. DATA is a pointer to the scroll_bar structure. */
5396 xg_scroll_callback (GtkRange
*range
,
5397 GtkScrollType scroll
,
5401 int whole
= 0, portion
= 0;
5402 struct scroll_bar
*bar
= user_data
;
5403 enum scroll_bar_part part
= scroll_bar_nowhere
;
5404 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
5405 struct frame
*f
= g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
5407 if (xg_ignore_gtk_scrollbar
) return false;
5411 case GTK_SCROLL_JUMP
:
5412 /* Buttons 1 2 or 3 must be grabbed. */
5413 if (FRAME_DISPLAY_INFO (f
)->grabbed
!= 0
5414 && FRAME_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
5416 if (bar
->horizontal
)
5418 part
= scroll_bar_horizontal_handle
;
5419 whole
= (int)(gtk_adjustment_get_upper (adj
) -
5420 gtk_adjustment_get_page_size (adj
));
5421 portion
= min ((int)value
, whole
);
5422 bar
->dragging
= portion
;
5426 part
= scroll_bar_handle
;
5427 whole
= gtk_adjustment_get_upper (adj
) -
5428 gtk_adjustment_get_page_size (adj
);
5429 portion
= min ((int)value
, whole
);
5430 bar
->dragging
= portion
;
5434 case GTK_SCROLL_STEP_BACKWARD
:
5435 part
= (bar
->horizontal
5436 ? scroll_bar_left_arrow
: scroll_bar_up_arrow
);
5439 case GTK_SCROLL_STEP_FORWARD
:
5440 part
= (bar
->horizontal
5441 ? scroll_bar_right_arrow
: scroll_bar_down_arrow
);
5444 case GTK_SCROLL_PAGE_BACKWARD
:
5445 part
= (bar
->horizontal
5446 ? scroll_bar_before_handle
: scroll_bar_above_handle
);
5449 case GTK_SCROLL_PAGE_FORWARD
:
5450 part
= (bar
->horizontal
5451 ? scroll_bar_after_handle
: scroll_bar_below_handle
);
5458 if (part
!= scroll_bar_nowhere
)
5460 window_being_scrolled
= bar
->window
;
5461 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
,
5468 /* Callback for button release. Sets dragging to -1 when dragging is done. */
5471 xg_end_scroll_callback (GtkWidget
*widget
,
5472 GdkEventButton
*event
,
5475 struct scroll_bar
*bar
= user_data
;
5477 if (WINDOWP (window_being_scrolled
))
5479 x_send_scroll_bar_event (window_being_scrolled
,
5480 scroll_bar_end_scroll
, 0, 0, bar
->horizontal
);
5481 window_being_scrolled
= Qnil
;
5488 #else /* not USE_GTK and not USE_MOTIF */
5490 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
5491 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
5492 scroll bar struct. CALL_DATA is a pointer to a float saying where
5496 xaw_jump_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5498 struct scroll_bar
*bar
= client_data
;
5499 float *top_addr
= call_data
;
5500 float top
= *top_addr
;
5502 int whole
, portion
, height
, width
;
5503 enum scroll_bar_part part
;
5504 bool horizontal
= bar
->horizontal
;
5509 /* Get the size of the thumb, a value between 0 and 1. */
5511 XtVaGetValues (widget
, XtNshown
, &shown
, XtNwidth
, &width
, NULL
);
5516 whole
= bar
->whole
- (shown
* bar
->whole
);
5517 portion
= min (top
* bar
->whole
, whole
);
5525 part
= scroll_bar_horizontal_handle
;
5529 /* Get the size of the thumb, a value between 0 and 1. */
5531 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
5535 portion
= shown
< 1 ? top
* whole
: 0;
5537 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0f
/ height
))
5538 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
5539 the bottom, so we force the scrolling whenever we see that we're
5540 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
5541 we try to ensure that we always stay two pixels away from the
5543 part
= scroll_bar_down_arrow
;
5545 part
= scroll_bar_handle
;
5548 window_being_scrolled
= bar
->window
;
5549 bar
->dragging
= portion
;
5550 bar
->last_seen_part
= part
;
5551 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
, bar
->horizontal
);
5555 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
5556 i.e. line or page up or down. WIDGET is the Xaw scroll bar
5557 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
5558 the scroll bar. CALL_DATA is an integer specifying the action that
5559 has taken place. Its magnitude is in the range 0..height of the
5560 scroll bar. Negative values mean scroll towards buffer start.
5561 Values < height of scroll bar mean line-wise movement. */
5564 xaw_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5566 struct scroll_bar
*bar
= client_data
;
5567 /* The position really is stored cast to a pointer. */
5568 int position
= (intptr_t) call_data
;
5569 Dimension height
, width
;
5570 enum scroll_bar_part part
;
5572 if (bar
->horizontal
)
5574 /* Get the width of the scroll bar. */
5576 XtVaGetValues (widget
, XtNwidth
, &width
, NULL
);
5579 if (eabs (position
) >= width
)
5580 part
= (position
< 0) ? scroll_bar_before_handle
: scroll_bar_after_handle
;
5582 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
5583 it maps line-movement to call_data = max(5, height/20). */
5584 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, width
/ 20))
5585 part
= (position
< 0) ? scroll_bar_left_arrow
: scroll_bar_right_arrow
;
5587 part
= scroll_bar_move_ratio
;
5589 window_being_scrolled
= bar
->window
;
5591 bar
->last_seen_part
= part
;
5592 x_send_scroll_bar_event (bar
->window
, part
, position
, width
,
5598 /* Get the height of the scroll bar. */
5600 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
5603 if (eabs (position
) >= height
)
5604 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
5606 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
5607 it maps line-movement to call_data = max(5, height/20). */
5608 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
5609 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
5611 part
= scroll_bar_move_ratio
;
5613 window_being_scrolled
= bar
->window
;
5615 bar
->last_seen_part
= part
;
5616 x_send_scroll_bar_event (bar
->window
, part
, position
, height
,
5621 #endif /* not USE_GTK and not USE_MOTIF */
5623 #define SCROLL_BAR_NAME "verticalScrollBar"
5624 #define SCROLL_BAR_HORIZONTAL_NAME "horizontalScrollBar"
5626 /* Create the widget for scroll bar BAR on frame F. Record the widget
5627 and X window of the scroll bar in BAR. */
5631 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5633 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
5636 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
5637 G_CALLBACK (xg_end_scroll_callback
),
5643 x_create_horizontal_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5645 const char *scroll_bar_name
= SCROLL_BAR_HORIZONTAL_NAME
;
5648 xg_create_horizontal_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
5649 G_CALLBACK (xg_end_scroll_callback
),
5654 #else /* not USE_GTK */
5657 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5663 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
5664 unsigned long pixel
;
5669 /* Set resources. Create the widget. */
5670 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5671 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
5672 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
5673 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
5674 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
5675 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
5676 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
5678 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5681 XtSetArg (av
[ac
], XmNforeground
, pixel
);
5685 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5688 XtSetArg (av
[ac
], XmNbackground
, pixel
);
5692 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
5693 (char *) scroll_bar_name
, av
, ac
);
5695 /* Add one callback for everything that can happen. */
5696 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
5698 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
5700 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
5702 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
5704 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
5706 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
5708 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
5711 /* Realize the widget. Only after that is the X window created. */
5712 XtRealizeWidget (widget
);
5714 /* Set the cursor to an arrow. I didn't find a resource to do that.
5715 And I'm wondering why it hasn't an arrow cursor by default. */
5716 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
5717 f
->output_data
.x
->nontext_cursor
);
5719 #else /* !USE_MOTIF i.e. use Xaw */
5721 /* Set resources. Create the widget. The background of the
5722 Xaw3d scroll bar widget is a little bit light for my taste.
5723 We don't alter it here to let users change it according
5724 to their taste with `emacs*verticalScrollBar.background: xxx'. */
5725 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5726 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
5727 /* For smoother scrolling with Xaw3d -sm */
5728 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
5730 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5733 XtSetArg (av
[ac
], XtNforeground
, pixel
);
5737 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5740 XtSetArg (av
[ac
], XtNbackground
, pixel
);
5744 /* Top/bottom shadow colors. */
5746 /* Allocate them, if necessary. */
5747 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
5749 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5752 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5753 FRAME_X_COLORMAP (f
),
5754 &pixel
, 1.2, 0x8000))
5756 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
5759 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5761 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5764 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5765 FRAME_X_COLORMAP (f
),
5766 &pixel
, 0.6, 0x4000))
5768 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
5772 #ifdef XtNbeNiceToColormap
5773 /* Tell the toolkit about them. */
5774 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
5775 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5776 /* We tried to allocate a color for the top/bottom shadow, and
5777 failed, so tell Xaw3d to use dithering instead. */
5778 /* But only if we have a small colormap. Xaw3d can allocate nice
5781 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
5782 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
5786 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
5787 be more consistent with other emacs 3d colors, and since Xaw3d is
5788 not good at dealing with allocation failure. */
5790 /* This tells Xaw3d to use real colors instead of dithering for
5792 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
5795 /* Specify the colors. */
5796 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
5799 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
5802 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
5805 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
5811 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
5812 f
->output_data
.x
->edit_widget
, av
, ac
);
5815 char const *initial
= "";
5816 char const *val
= initial
;
5817 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
5818 #ifdef XtNarrowScrollbars
5819 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
5821 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
5822 if (xaw3d_arrow_scroll
|| val
== initial
)
5823 { /* ARROW_SCROLL */
5824 xaw3d_arrow_scroll
= True
;
5825 /* Isn't that just a personal preference ? --Stef */
5826 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
5830 /* Define callbacks. */
5831 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
5832 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
5835 /* Realize the widget. Only after that is the X window created. */
5836 XtRealizeWidget (widget
);
5838 #endif /* !USE_MOTIF */
5840 /* Install an action hook that lets us detect when the user
5841 finishes interacting with a scroll bar. */
5842 if (action_hook_id
== 0)
5843 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
5845 /* Remember X window and widget in the scroll bar vector. */
5846 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
5847 xwindow
= XtWindow (widget
);
5848 bar
->x_window
= xwindow
;
5850 bar
->horizontal
= false;
5856 x_create_horizontal_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5862 const char *scroll_bar_name
= SCROLL_BAR_HORIZONTAL_NAME
;
5863 unsigned long pixel
;
5868 /* Set resources. Create the widget. */
5869 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5870 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
5871 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
5872 XtSetArg (av
[ac
], XmNorientation
, XmHORIZONTAL
); ++ac
;
5873 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_RIGHT
), ++ac
;
5874 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
5875 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
5877 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5880 XtSetArg (av
[ac
], XmNforeground
, pixel
);
5884 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5887 XtSetArg (av
[ac
], XmNbackground
, pixel
);
5891 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
5892 (char *) scroll_bar_name
, av
, ac
);
5894 /* Add one callback for everything that can happen. */
5895 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
5897 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
5899 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
5901 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
5903 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
5905 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
5907 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
5910 /* Realize the widget. Only after that is the X window created. */
5911 XtRealizeWidget (widget
);
5913 /* Set the cursor to an arrow. I didn't find a resource to do that.
5914 And I'm wondering why it hasn't an arrow cursor by default. */
5915 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
5916 f
->output_data
.x
->nontext_cursor
);
5918 #else /* !USE_MOTIF i.e. use Xaw */
5920 /* Set resources. Create the widget. The background of the
5921 Xaw3d scroll bar widget is a little bit light for my taste.
5922 We don't alter it here to let users change it according
5923 to their taste with `emacs*verticalScrollBar.background: xxx'. */
5924 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5925 XtSetArg (av
[ac
], XtNorientation
, XtorientHorizontal
); ++ac
;
5926 /* For smoother scrolling with Xaw3d -sm */
5927 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
5929 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5932 XtSetArg (av
[ac
], XtNforeground
, pixel
);
5936 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5939 XtSetArg (av
[ac
], XtNbackground
, pixel
);
5943 /* Top/bottom shadow colors. */
5945 /* Allocate them, if necessary. */
5946 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
5948 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5951 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5952 FRAME_X_COLORMAP (f
),
5953 &pixel
, 1.2, 0x8000))
5955 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
5958 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5960 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5963 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5964 FRAME_X_COLORMAP (f
),
5965 &pixel
, 0.6, 0x4000))
5967 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
5971 #ifdef XtNbeNiceToColormap
5972 /* Tell the toolkit about them. */
5973 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
5974 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5975 /* We tried to allocate a color for the top/bottom shadow, and
5976 failed, so tell Xaw3d to use dithering instead. */
5977 /* But only if we have a small colormap. Xaw3d can allocate nice
5980 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
5981 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
5985 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
5986 be more consistent with other emacs 3d colors, and since Xaw3d is
5987 not good at dealing with allocation failure. */
5989 /* This tells Xaw3d to use real colors instead of dithering for
5991 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
5994 /* Specify the colors. */
5995 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
5998 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
6001 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
6004 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
6010 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
6011 f
->output_data
.x
->edit_widget
, av
, ac
);
6014 char const *initial
= "";
6015 char const *val
= initial
;
6016 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
6017 #ifdef XtNarrowScrollbars
6018 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
6020 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
6021 if (xaw3d_arrow_scroll
|| val
== initial
)
6022 { /* ARROW_SCROLL */
6023 xaw3d_arrow_scroll
= True
;
6024 /* Isn't that just a personal preference ? --Stef */
6025 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
6029 /* Define callbacks. */
6030 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
6031 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
6034 /* Realize the widget. Only after that is the X window created. */
6035 XtRealizeWidget (widget
);
6037 #endif /* !USE_MOTIF */
6039 /* Install an action hook that lets us detect when the user
6040 finishes interacting with a scroll bar. */
6041 if (horizontal_action_hook_id
== 0)
6042 horizontal_action_hook_id
6043 = XtAppAddActionHook (Xt_app_con
, xt_horizontal_action_hook
, 0);
6045 /* Remember X window and widget in the scroll bar vector. */
6046 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
6047 xwindow
= XtWindow (widget
);
6048 bar
->x_window
= xwindow
;
6050 bar
->horizontal
= true;
6054 #endif /* not USE_GTK */
6057 /* Set the thumb size and position of scroll bar BAR. We are currently
6058 displaying PORTION out of a whole WHOLE, and our position POSITION. */
6062 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
6064 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
6068 x_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
6070 xg_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
6073 #else /* not USE_GTK */
6075 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
6078 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6079 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6086 if (scroll_bar_adjust_thumb_portion_p
)
6088 /* We use an estimate of 30 chars per line rather than the real
6089 `portion' value. This has the disadvantage that the thumb size
6090 is not very representative, but it makes our life a lot easier.
6091 Otherwise, we have to constantly adjust the thumb size, which
6092 we can't always do quickly enough: while dragging, the size of
6093 the thumb might prevent the user from dragging the thumb all the
6094 way to the end. but Motif and some versions of Xaw3d don't allow
6095 updating the thumb size while dragging. Also, even if we can update
6096 its size, the update will often happen too late.
6097 If you don't believe it, check out revision 1.650 of xterm.c to see
6098 what hoops we were going through and the still poor behavior we got. */
6099 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
6100 /* When the thumb is at the bottom, position == whole.
6101 So we need to increase `whole' to make space for the thumb. */
6109 top
= (float) position
/ whole
;
6110 shown
= (float) portion
/ whole
;
6113 if (bar
->dragging
== -1)
6117 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
6118 is the scroll bar's maximum and MIN is the scroll bar's minimum
6120 size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
6122 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
6123 value
= top
* XM_SB_MAX
;
6124 value
= min (value
, XM_SB_MAX
- size
);
6126 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
6128 #else /* !USE_MOTIF i.e. use Xaw */
6134 top
= (float) position
/ whole
;
6135 shown
= (float) portion
/ whole
;
6139 float old_top
, old_shown
;
6141 XtVaGetValues (widget
,
6142 XtNtopOfThumb
, &old_top
,
6143 XtNshown
, &old_shown
,
6147 /* Massage the top+shown values. */
6148 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
6149 top
= max (0, min (1, top
));
6152 #if ! defined (HAVE_XAW3D)
6153 /* With Xaw, 'top' values too closer to 1.0 may
6154 cause the thumb to disappear. Fix that. */
6155 top
= min (top
, 0.99f
);
6157 /* Keep two pixels available for moving the thumb down. */
6158 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
6159 #if ! defined (HAVE_XAW3D)
6160 /* Likewise with too small 'shown'. */
6161 shown
= max (shown
, 0.01f
);
6164 /* If the call to XawScrollbarSetThumb below doesn't seem to
6165 work, check that 'NARROWPROTO' is defined in src/config.h.
6166 If this is not so, most likely you need to fix configure. */
6167 if (top
!= old_top
|| shown
!= old_shown
)
6169 if (bar
->dragging
== -1)
6170 XawScrollbarSetThumb (widget
, top
, shown
);
6173 /* Try to make the scrolling a tad smoother. */
6174 if (!xaw3d_pick_top
)
6175 shown
= min (shown
, old_shown
);
6177 XawScrollbarSetThumb (widget
, top
, shown
);
6181 #endif /* !USE_MOTIF */
6187 x_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
6190 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6191 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6198 shown
= (float) portion
/ whole
;
6199 top
= (float) position
/ (whole
- portion
);
6201 int size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
6202 int value
= clip_to_bounds (0, top
* (XM_SB_MAX
- size
), XM_SB_MAX
- size
);
6204 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
6206 #else /* !USE_MOTIF i.e. use Xaw */
6212 top
= (float) position
/ whole
;
6213 shown
= (float) portion
/ whole
;
6217 float old_top
, old_shown
;
6219 XtVaGetValues (widget
,
6220 XtNtopOfThumb
, &old_top
,
6221 XtNshown
, &old_shown
,
6226 /* Massage the top+shown values. */
6227 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
6228 top
= max (0, min (1, top
));
6231 #if ! defined (HAVE_XAW3D)
6232 /* With Xaw, 'top' values too closer to 1.0 may
6233 cause the thumb to disappear. Fix that. */
6234 top
= min (top
, 0.99f
);
6236 /* Keep two pixels available for moving the thumb down. */
6237 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
6238 #if ! defined (HAVE_XAW3D)
6239 /* Likewise with too small 'shown'. */
6240 shown
= max (shown
, 0.01f
);
6244 /* If the call to XawScrollbarSetThumb below doesn't seem to
6245 work, check that 'NARROWPROTO' is defined in src/config.h.
6246 If this is not so, most likely you need to fix configure. */
6247 XawScrollbarSetThumb (widget
, top
, shown
);
6249 if (top
!= old_top
|| shown
!= old_shown
)
6251 if (bar
->dragging
== -1)
6252 XawScrollbarSetThumb (widget
, top
, shown
);
6255 /* Try to make the scrolling a tad smoother. */
6256 if (!xaw3d_pick_top
)
6257 shown
= min (shown
, old_shown
);
6259 XawScrollbarSetThumb (widget
, top
, shown
);
6264 #endif /* !USE_MOTIF */
6268 #endif /* not USE_GTK */
6270 #endif /* USE_TOOLKIT_SCROLL_BARS */
6274 /************************************************************************
6275 Scroll bars, general
6276 ************************************************************************/
6278 /* Create a scroll bar and return the scroll bar vector for it. W is
6279 the Emacs window on which to create the scroll bar. TOP, LEFT,
6280 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
6283 static struct scroll_bar
*
6284 x_scroll_bar_create (struct window
*w
, int top
, int left
,
6285 int width
, int height
, bool horizontal
)
6287 struct frame
*f
= XFRAME (w
->frame
);
6288 struct scroll_bar
*bar
6289 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
6294 #ifdef USE_TOOLKIT_SCROLL_BARS
6296 x_create_horizontal_toolkit_scroll_bar (f
, bar
);
6298 x_create_toolkit_scroll_bar (f
, bar
);
6299 #else /* not USE_TOOLKIT_SCROLL_BARS */
6301 XSetWindowAttributes a
;
6305 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
6306 if (a
.background_pixel
== -1)
6307 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
6309 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
6310 | ButtonMotionMask
| PointerMotionHintMask
6312 a
.cursor
= FRAME_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
6314 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
6316 /* Clear the area of W that will serve as a scroll bar. This is
6317 for the case that a window has been split horizontally. In
6318 this case, no clear_frame is generated to reduce flickering. */
6319 if (width
> 0 && window_box_height (w
) > 0)
6320 x_clear_area (f
, left
, top
, width
, window_box_height (w
));
6322 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6323 /* Position and size of scroll bar. */
6324 left
, top
, width
, height
,
6325 /* Border width, depth, class, and visual. */
6332 bar
->x_window
= window
;
6334 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6336 XSETWINDOW (bar
->window
, w
);
6340 bar
->height
= height
;
6344 bar
->horizontal
= horizontal
;
6345 #if defined (USE_TOOLKIT_SCROLL_BARS) && defined (USE_LUCID)
6346 bar
->last_seen_part
= scroll_bar_nowhere
;
6349 /* Add bar to its frame's list of scroll bars. */
6350 bar
->next
= FRAME_SCROLL_BARS (f
);
6352 XSETVECTOR (barobj
, bar
);
6353 fset_scroll_bars (f
, barobj
);
6354 if (!NILP (bar
->next
))
6355 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6357 /* Map the window/widget. */
6358 #ifdef USE_TOOLKIT_SCROLL_BARS
6362 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
,
6363 left
, width
, max (height
, 1));
6365 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
6366 left
, width
, max (height
, 1));
6367 #else /* not USE_GTK */
6368 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6369 XtConfigureWidget (scroll_bar
, left
, top
, width
, max (height
, 1), 0);
6370 XtMapWidget (scroll_bar
);
6371 #endif /* not USE_GTK */
6373 #else /* not USE_TOOLKIT_SCROLL_BARS */
6374 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
6375 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6382 #ifndef USE_TOOLKIT_SCROLL_BARS
6384 /* Draw BAR's handle in the proper position.
6386 If the handle is already drawn from START to END, don't bother
6387 redrawing it, unless REBUILD; in that case, always
6388 redraw it. (REBUILD is handy for drawing the handle after expose
6391 Normally, we want to constrain the start and end of the handle to
6392 fit inside its rectangle, but if the user is dragging the scroll
6393 bar handle, we want to let them drag it down all the way, so that
6394 the bar's top is as far down as it goes; otherwise, there's no way
6395 to move to the very end of the buffer. */
6398 x_scroll_bar_set_handle (struct scroll_bar
*bar
, int start
, int end
,
6401 bool dragging
= bar
->dragging
!= -1;
6402 Window w
= bar
->x_window
;
6403 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6404 GC gc
= f
->output_data
.x
->normal_gc
;
6406 /* If the display is already accurate, do nothing. */
6408 && start
== bar
->start
6415 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
6416 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
6417 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
6419 /* Make sure the values are reasonable, and try to preserve
6420 the distance between start and end. */
6422 int length
= end
- start
;
6426 else if (start
> top_range
)
6428 end
= start
+ length
;
6432 else if (end
> top_range
&& ! dragging
)
6436 /* Store the adjusted setting in the scroll bar. */
6440 /* Clip the end position, just for display. */
6441 if (end
> top_range
)
6444 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
6445 below top positions, to make sure the handle is always at least
6446 that many pixels tall. */
6447 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
6449 /* Draw the empty space above the handle. Note that we can't clear
6450 zero-height areas; that means "clear to end of window." */
6451 if ((inside_width
> 0) && (start
> 0))
6452 x_clear_area1 (FRAME_X_DISPLAY (f
), w
,
6453 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6454 VERTICAL_SCROLL_BAR_TOP_BORDER
,
6455 inside_width
, start
, False
);
6457 /* Change to proper foreground color if one is specified. */
6458 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6459 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6460 f
->output_data
.x
->scroll_bar_foreground_pixel
);
6462 /* Draw the handle itself. */
6463 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
6464 /* x, y, width, height */
6465 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6466 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
6467 inside_width
, end
- start
);
6469 /* Restore the foreground color of the GC if we changed it above. */
6470 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6471 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6472 FRAME_FOREGROUND_PIXEL (f
));
6474 /* Draw the empty space below the handle. Note that we can't
6475 clear zero-height areas; that means "clear to end of window." */
6476 if ((inside_width
> 0) && (end
< inside_height
))
6477 x_clear_area1 (FRAME_X_DISPLAY (f
), w
,
6478 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6479 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
6480 inside_width
, inside_height
- end
, False
);
6486 #endif /* !USE_TOOLKIT_SCROLL_BARS */
6488 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
6492 x_scroll_bar_remove (struct scroll_bar
*bar
)
6494 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6497 #ifdef USE_TOOLKIT_SCROLL_BARS
6499 xg_remove_scroll_bar (f
, bar
->x_window
);
6500 #else /* not USE_GTK */
6501 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
6502 #endif /* not USE_GTK */
6504 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
6507 /* Dissociate this scroll bar from its window. */
6508 if (bar
->horizontal
)
6509 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
6511 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
6517 /* Set the handle of the vertical scroll bar for WINDOW to indicate
6518 that we are displaying PORTION characters out of a total of WHOLE
6519 characters, starting at POSITION. If WINDOW has no scroll bar,
6523 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
6525 struct frame
*f
= XFRAME (w
->frame
);
6527 struct scroll_bar
*bar
;
6528 int top
, height
, left
, width
;
6529 int window_y
, window_height
;
6531 /* Get window dimensions. */
6532 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
6534 height
= window_height
;
6535 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
6536 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
6538 /* Does the scroll bar exist yet? */
6539 if (NILP (w
->vertical_scroll_bar
))
6541 if (width
> 0 && height
> 0)
6544 x_clear_area (f
, left
, top
, width
, height
);
6548 bar
= x_scroll_bar_create (w
, top
, left
, width
, max (height
, 1), false);
6552 /* It may just need to be moved and resized. */
6553 unsigned int mask
= 0;
6555 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
6559 if (left
!= bar
->left
)
6561 if (top
!= bar
->top
)
6563 if (width
!= bar
->width
)
6565 if (height
!= bar
->height
)
6568 #ifdef USE_TOOLKIT_SCROLL_BARS
6570 /* Move/size the scroll bar widget. */
6573 /* Since toolkit scroll bars are smaller than the space reserved
6574 for them on the frame, we have to clear "under" them. */
6575 if (width
> 0 && height
> 0)
6576 x_clear_area (f
, left
, top
, width
, height
);
6578 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
6579 left
, width
, max (height
, 1));
6580 #else /* not USE_GTK */
6581 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
6582 left
, top
, width
, max (height
, 1), 0);
6583 #endif /* not USE_GTK */
6585 #else /* not USE_TOOLKIT_SCROLL_BARS */
6587 /* Move/size the scroll bar window. */
6596 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
6600 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6602 /* Remember new settings. */
6606 bar
->height
= height
;
6611 #ifdef USE_TOOLKIT_SCROLL_BARS
6612 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
6613 #else /* not USE_TOOLKIT_SCROLL_BARS */
6614 /* Set the scroll bar's current state, unless we're currently being
6616 if (bar
->dragging
== -1)
6618 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
6621 x_scroll_bar_set_handle (bar
, 0, top_range
, false);
6624 int start
= ((double) position
* top_range
) / whole
;
6625 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
6626 x_scroll_bar_set_handle (bar
, start
, end
, false);
6629 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6631 XSETVECTOR (barobj
, bar
);
6632 wset_vertical_scroll_bar (w
, barobj
);
6637 XTset_horizontal_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
6639 struct frame
*f
= XFRAME (w
->frame
);
6641 struct scroll_bar
*bar
;
6642 int top
, height
, left
, width
;
6643 int window_x
, window_width
;
6644 int pixel_width
= WINDOW_PIXEL_WIDTH (w
);
6646 /* Get window dimensions. */
6647 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
6649 width
= window_width
;
6650 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
6651 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
6653 /* Does the scroll bar exist yet? */
6654 if (NILP (w
->horizontal_scroll_bar
))
6656 if (width
> 0 && height
> 0)
6660 /* Clear also part between window_width and
6661 WINDOW_PIXEL_WIDTH. */
6662 x_clear_area (f
, left
, top
, pixel_width
, height
);
6666 bar
= x_scroll_bar_create (w
, top
, left
, width
, height
, true);
6670 /* It may just need to be moved and resized. */
6671 unsigned int mask
= 0;
6673 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
6677 if (left
!= bar
->left
)
6679 if (top
!= bar
->top
)
6681 if (width
!= bar
->width
)
6683 if (height
!= bar
->height
)
6686 #ifdef USE_TOOLKIT_SCROLL_BARS
6687 /* Move/size the scroll bar widget. */
6690 /* Since toolkit scroll bars are smaller than the space reserved
6691 for them on the frame, we have to clear "under" them. */
6692 if (width
> 0 && height
> 0)
6694 WINDOW_LEFT_EDGE_X (w
), top
,
6695 pixel_width
- WINDOW_RIGHT_DIVIDER_WIDTH (w
), height
);
6697 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
, left
,
6699 #else /* not USE_GTK */
6700 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
6701 left
, top
, width
, height
, 0);
6702 #endif /* not USE_GTK */
6704 #else /* not USE_TOOLKIT_SCROLL_BARS */
6706 /* Clear areas not covered by the scroll bar because it's not as
6707 wide as the area reserved for it. This makes sure a
6708 previous mode line display is cleared after C-x 2 C-x 1, for
6711 int area_height
= WINDOW_CONFIG_SCROLL_BAR_HEIGHT (w
);
6712 int rest
= area_height
- height
;
6713 if (rest
> 0 && width
> 0)
6714 x_clear_area (f
, left
, top
, width
, rest
);
6717 /* Move/size the scroll bar window. */
6726 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
6730 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6732 /* Remember new settings. */
6736 bar
->height
= height
;
6741 #ifdef USE_TOOLKIT_SCROLL_BARS
6742 x_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
6743 #else /* not USE_TOOLKIT_SCROLL_BARS */
6744 /* Set the scroll bar's current state, unless we're currently being
6746 if (bar
->dragging
== -1)
6748 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
);
6751 x_scroll_bar_set_handle (bar
, 0, left_range
, false);
6754 int start
= ((double) position
* left_range
) / whole
;
6755 int end
= ((double) (position
+ portion
) * left_range
) / whole
;
6756 x_scroll_bar_set_handle (bar
, start
, end
, false);
6759 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6761 XSETVECTOR (barobj
, bar
);
6762 wset_horizontal_scroll_bar (w
, barobj
);
6766 /* The following three hooks are used when we're doing a thorough
6767 redisplay of the frame. We don't explicitly know which scroll bars
6768 are going to be deleted, because keeping track of when windows go
6769 away is a real pain - "Can you say set-window-configuration, boys
6770 and girls?" Instead, we just assert at the beginning of redisplay
6771 that *all* scroll bars are to be removed, and then save a scroll bar
6772 from the fiery pit when we actually redisplay its window. */
6774 /* Arrange for all scroll bars on FRAME to be removed at the next call
6775 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
6776 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
6779 XTcondemn_scroll_bars (struct frame
*frame
)
6781 if (!NILP (FRAME_SCROLL_BARS (frame
)))
6783 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
6785 /* Prepend scrollbars to already condemned ones. */
6786 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
6788 while (!NILP (XSCROLL_BAR (last
)->next
))
6789 last
= XSCROLL_BAR (last
)->next
;
6791 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
6792 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
6795 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
6796 fset_scroll_bars (frame
, Qnil
);
6801 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
6802 Note that WINDOW isn't necessarily condemned at all. */
6805 XTredeem_scroll_bar (struct window
*w
)
6807 struct scroll_bar
*bar
;
6811 /* We can't redeem this window's scroll bar if it doesn't have one. */
6812 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
6815 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
6817 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
6818 /* Unlink it from the condemned list. */
6819 f
= XFRAME (WINDOW_FRAME (w
));
6820 if (NILP (bar
->prev
))
6822 /* If the prev pointer is nil, it must be the first in one of
6824 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
6825 /* It's not condemned. Everything's fine. */
6827 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
6828 w
->vertical_scroll_bar
))
6829 fset_condemned_scroll_bars (f
, bar
->next
);
6831 /* If its prev pointer is nil, it must be at the front of
6832 one or the other! */
6836 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
6838 if (! NILP (bar
->next
))
6839 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
6841 bar
->next
= FRAME_SCROLL_BARS (f
);
6843 XSETVECTOR (barobj
, bar
);
6844 fset_scroll_bars (f
, barobj
);
6845 if (! NILP (bar
->next
))
6846 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6850 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
6852 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
6853 /* Unlink it from the condemned list. */
6854 f
= XFRAME (WINDOW_FRAME (w
));
6855 if (NILP (bar
->prev
))
6857 /* If the prev pointer is nil, it must be the first in one of
6859 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
6860 /* It's not condemned. Everything's fine. */
6862 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
6863 w
->horizontal_scroll_bar
))
6864 fset_condemned_scroll_bars (f
, bar
->next
);
6866 /* If its prev pointer is nil, it must be at the front of
6867 one or the other! */
6871 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
6873 if (! NILP (bar
->next
))
6874 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
6876 bar
->next
= FRAME_SCROLL_BARS (f
);
6878 XSETVECTOR (barobj
, bar
);
6879 fset_scroll_bars (f
, barobj
);
6880 if (! NILP (bar
->next
))
6881 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6885 /* Remove all scroll bars on FRAME that haven't been saved since the
6886 last call to `*condemn_scroll_bars_hook'. */
6889 XTjudge_scroll_bars (struct frame
*f
)
6891 Lisp_Object bar
, next
;
6893 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
6895 /* Clear out the condemned list now so we won't try to process any
6896 more events on the hapless scroll bars. */
6897 fset_condemned_scroll_bars (f
, Qnil
);
6899 for (; ! NILP (bar
); bar
= next
)
6901 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
6903 x_scroll_bar_remove (b
);
6906 b
->next
= b
->prev
= Qnil
;
6909 /* Now there should be no references to the condemned scroll bars,
6910 and they should get garbage-collected. */
6914 #ifndef USE_TOOLKIT_SCROLL_BARS
6915 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
6916 is a no-op when using toolkit scroll bars.
6918 This may be called from a signal handler, so we have to ignore GC
6922 x_scroll_bar_expose (struct scroll_bar
*bar
, const XEvent
*event
)
6924 Window w
= bar
->x_window
;
6925 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6926 GC gc
= f
->output_data
.x
->normal_gc
;
6930 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, true);
6932 /* Switch to scroll bar foreground color. */
6933 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6934 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6935 f
->output_data
.x
->scroll_bar_foreground_pixel
);
6937 /* Draw a one-pixel border just inside the edges of the scroll bar. */
6938 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
6939 /* x, y, width, height */
6940 0, 0, bar
->width
- 1, bar
->height
- 1);
6942 /* Restore the foreground color of the GC if we changed it above. */
6943 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6944 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6945 FRAME_FOREGROUND_PIXEL (f
));
6950 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6952 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
6953 is set to something other than NO_EVENT, it is enqueued.
6955 This may be called from a signal handler, so we have to ignore GC
6960 x_scroll_bar_handle_click (struct scroll_bar
*bar
,
6961 const XEvent
*event
,
6962 struct input_event
*emacs_event
)
6964 if (! WINDOWP (bar
->window
))
6967 emacs_event
->kind
= (bar
->horizontal
6968 ? HORIZONTAL_SCROLL_BAR_CLICK_EVENT
6969 : SCROLL_BAR_CLICK_EVENT
);
6970 emacs_event
->code
= event
->xbutton
.button
- Button1
;
6971 emacs_event
->modifiers
6972 = (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO
6973 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
6974 event
->xbutton
.state
)
6975 | (event
->type
== ButtonRelease
6978 emacs_event
->frame_or_window
= bar
->window
;
6979 emacs_event
->arg
= Qnil
;
6980 emacs_event
->timestamp
= event
->xbutton
.time
;
6981 if (bar
->horizontal
)
6984 = HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
6985 int x
= event
->xbutton
.x
- HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
6988 if (x
> left_range
) x
= left_range
;
6991 emacs_event
->part
= scroll_bar_before_handle
;
6992 else if (x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
6993 emacs_event
->part
= scroll_bar_horizontal_handle
;
6995 emacs_event
->part
= scroll_bar_after_handle
;
6997 #ifndef USE_TOOLKIT_SCROLL_BARS
6998 /* If the user has released the handle, set it to its final position. */
6999 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
7001 int new_start
= - bar
->dragging
;
7002 int new_end
= new_start
+ bar
->end
- bar
->start
;
7004 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
7009 XSETINT (emacs_event
->x
, left_range
);
7010 XSETINT (emacs_event
->y
, x
);
7015 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
7016 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
7019 if (y
> top_range
) y
= top_range
;
7022 emacs_event
->part
= scroll_bar_above_handle
;
7023 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
7024 emacs_event
->part
= scroll_bar_handle
;
7026 emacs_event
->part
= scroll_bar_below_handle
;
7028 #ifndef USE_TOOLKIT_SCROLL_BARS
7029 /* If the user has released the handle, set it to its final position. */
7030 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
7032 int new_start
= y
- bar
->dragging
;
7033 int new_end
= new_start
+ bar
->end
- bar
->start
;
7035 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
7040 XSETINT (emacs_event
->x
, y
);
7041 XSETINT (emacs_event
->y
, top_range
);
7045 #ifndef USE_TOOLKIT_SCROLL_BARS
7047 /* Handle some mouse motion while someone is dragging the scroll bar.
7049 This may be called from a signal handler, so we have to ignore GC
7053 x_scroll_bar_note_movement (struct scroll_bar
*bar
,
7054 const XMotionEvent
*event
)
7056 struct frame
*f
= XFRAME (XWINDOW (bar
->window
)->frame
);
7057 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
7059 dpyinfo
->last_mouse_movement_time
= event
->time
;
7060 dpyinfo
->last_mouse_scroll_bar
= bar
;
7061 f
->mouse_moved
= true;
7063 /* If we're dragging the bar, display it. */
7064 if (bar
->dragging
!= -1)
7066 /* Where should the handle be now? */
7067 int new_start
= event
->y
- bar
->dragging
;
7069 if (new_start
!= bar
->start
)
7071 int new_end
= new_start
+ bar
->end
- bar
->start
;
7073 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
7078 #endif /* !USE_TOOLKIT_SCROLL_BARS */
7080 /* Return information to the user about the current position of the mouse
7081 on the scroll bar. */
7084 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
7085 enum scroll_bar_part
*part
, Lisp_Object
*x
,
7086 Lisp_Object
*y
, Time
*timestamp
)
7088 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
7089 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
7090 Window w
= bar
->x_window
;
7091 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7093 Window dummy_window
;
7095 unsigned int dummy_mask
;
7099 /* Get the mouse's position relative to the scroll bar window, and
7101 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
7103 /* Root, child, root x and root y. */
7104 &dummy_window
, &dummy_window
,
7105 &dummy_coord
, &dummy_coord
,
7107 /* Position relative to scroll bar. */
7110 /* Mouse buttons and modifier keys. */
7113 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
7115 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
7117 if (bar
->dragging
!= -1)
7118 win_y
-= bar
->dragging
;
7122 if (win_y
> top_range
)
7126 *bar_window
= bar
->window
;
7128 if (bar
->dragging
!= -1)
7129 *part
= scroll_bar_handle
;
7130 else if (win_y
< bar
->start
)
7131 *part
= scroll_bar_above_handle
;
7132 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
7133 *part
= scroll_bar_handle
;
7135 *part
= scroll_bar_below_handle
;
7137 XSETINT (*x
, win_y
);
7138 XSETINT (*y
, top_range
);
7140 f
->mouse_moved
= false;
7141 dpyinfo
->last_mouse_scroll_bar
= NULL
;
7142 *timestamp
= dpyinfo
->last_mouse_movement_time
;
7149 /* Return information to the user about the current position of the mouse
7150 on the scroll bar. */
7153 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
7154 enum scroll_bar_part
*part
, Lisp_Object
*x
,
7155 Lisp_Object
*y
, Time
*timestamp
)
7157 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
7158 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
7159 Window w
= bar
->x_window
;
7160 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7162 Window dummy_window
;
7164 unsigned int dummy_mask
;
7168 /* Get the mouse's position relative to the scroll bar window, and
7170 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
7172 /* Root, child, root x and root y. */
7173 &dummy_window
, &dummy_window
,
7174 &dummy_coord
, &dummy_coord
,
7176 /* Position relative to scroll bar. */
7179 /* Mouse buttons and modifier keys. */
7182 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
7184 win_x
-= HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
7186 if (bar
->dragging
!= -1)
7187 win_x
-= bar
->dragging
;
7191 if (win_x
> left_range
)
7195 *bar_window
= bar
->window
;
7197 if (bar
->dragging
!= -1)
7198 *part
= scroll_bar_horizontal_handle
;
7199 else if (win_x
< bar
->start
)
7200 *part
= scroll_bar_before_handle
;
7201 else if (win_x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
7202 *part
= scroll_bar_handle
;
7204 *part
= scroll_bar_after_handle
;
7206 XSETINT (*y
, win_x
);
7207 XSETINT (*x
, left_range
);
7209 f
->mouse_moved
= false;
7210 dpyinfo
->last_mouse_scroll_bar
= NULL
;
7211 *timestamp
= dpyinfo
->last_mouse_movement_time
;
7218 /* The screen has been cleared so we may have changed foreground or
7219 background colors, and the scroll bars may need to be redrawn.
7220 Clear out the scroll bars, and ask for expose events, so we can
7224 x_scroll_bar_clear (struct frame
*f
)
7226 #ifndef USE_TOOLKIT_SCROLL_BARS
7229 /* We can have scroll bars even if this is 0,
7230 if we just turned off scroll bar mode.
7231 But in that case we should not clear them. */
7232 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
7233 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
7234 bar
= XSCROLL_BAR (bar
)->next
)
7235 XClearArea (FRAME_X_DISPLAY (f
),
7236 XSCROLL_BAR (bar
)->x_window
,
7238 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7241 #ifdef ENABLE_CHECKING
7243 /* Record the last 100 characters stored
7244 to help debug the loss-of-chars-during-GC problem. */
7246 static int temp_index
;
7247 static short temp_buffer
[100];
7249 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
7250 if (temp_index == ARRAYELTS (temp_buffer)) \
7252 temp_buffer[temp_index++] = (keysym)
7254 #else /* not ENABLE_CHECKING */
7256 #define STORE_KEYSYM_FOR_DEBUG(keysym) ((void)0)
7258 #endif /* ENABLE_CHECKING */
7260 /* Set this to nonzero to fake an "X I/O error"
7261 on a particular display. */
7263 static struct x_display_info
*XTread_socket_fake_io_error
;
7265 /* When we find no input here, we occasionally do a no-op command
7266 to verify that the X server is still running and we can still talk with it.
7267 We try all the open displays, one by one.
7268 This variable is used for cycling thru the displays. */
7270 static struct x_display_info
*next_noop_dpyinfo
;
7279 /* Filter events for the current X input method.
7280 DPYINFO is the display this event is for.
7281 EVENT is the X event to filter.
7283 Returns non-zero if the event was filtered, caller shall not process
7285 Returns zero if event is wasn't filtered. */
7289 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
7291 /* XFilterEvent returns non-zero if the input method has
7292 consumed the event. We pass the frame's X window to
7293 XFilterEvent because that's the one for which the IC
7296 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
7297 event
->xclient
.window
);
7299 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
7304 static int current_count
;
7305 static int current_finish
;
7306 static struct input_event
*current_hold_quit
;
7308 /* This is the filter function invoked by the GTK event loop.
7309 It is invoked before the XEvent is translated to a GdkEvent,
7310 so we have a chance to act on the event before GTK. */
7311 static GdkFilterReturn
7312 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
7314 XEvent
*xev
= (XEvent
*) gxev
;
7317 if (current_count
>= 0)
7319 struct x_display_info
*dpyinfo
;
7321 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
7324 /* Filter events for the current X input method.
7325 GTK calls XFilterEvent but not for key press and release,
7326 so we do it here. */
7327 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
7329 && x_filter_event (dpyinfo
, xev
))
7332 return GDK_FILTER_REMOVE
;
7337 current_finish
= X_EVENT_NORMAL
;
7340 += handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
7344 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
7348 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
7349 return GDK_FILTER_REMOVE
;
7351 return GDK_FILTER_CONTINUE
;
7353 #endif /* USE_GTK */
7356 static void xembed_send_message (struct frame
*f
, Time
,
7357 enum xembed_message
,
7358 long detail
, long data1
, long data2
);
7361 x_net_wm_state (struct frame
*f
, Window window
)
7363 int value
= FULLSCREEN_NONE
;
7364 Lisp_Object lval
= Qnil
;
7365 bool sticky
= false;
7367 get_current_wm_state (f
, window
, &value
, &sticky
);
7371 case FULLSCREEN_WIDTH
:
7374 case FULLSCREEN_HEIGHT
:
7377 case FULLSCREEN_BOTH
:
7380 case FULLSCREEN_MAXIMIZED
:
7385 frame_size_history_add
7386 (f
, Qx_net_wm_state
, 0, 0,
7387 list2 (get_frame_param (f
, Qfullscreen
), lval
));
7389 store_frame_param (f
, Qfullscreen
, lval
);
7390 /** store_frame_param (f, Qsticky, sticky ? Qt : Qnil); **/
7393 /* Handles the XEvent EVENT on display DPYINFO.
7395 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
7396 *FINISH is zero if caller should continue reading events.
7397 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
7398 *EVENT is unchanged unless we're processing KeyPress event.
7400 We return the number of characters stored into the buffer. */
7403 handle_one_xevent (struct x_display_info
*dpyinfo
,
7404 const XEvent
*event
,
7405 int *finish
, struct input_event
*hold_quit
)
7407 union buffered_input_event inev
;
7410 ptrdiff_t nbytes
= 0;
7411 struct frame
*any
, *f
= NULL
;
7412 struct coding_system coding
;
7413 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
7414 /* This holds the state XLookupString needs to implement dead keys
7415 and other tricks known as "compose processing". _X Window System_
7416 says that a portable program can't use this, but Stephen Gildea assures
7417 me that letting the compiler initialize it to zeros will work okay. */
7418 static XComposeStatus compose_status
;
7422 *finish
= X_EVENT_NORMAL
;
7424 EVENT_INIT (inev
.ie
);
7425 inev
.ie
.kind
= NO_EVENT
;
7428 any
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
7430 if (any
&& any
->wait_event_type
== event
->type
)
7431 any
->wait_event_type
= 0; /* Indicates we got it. */
7433 switch (event
->type
)
7437 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_protocols
7438 && event
->xclient
.format
== 32)
7440 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_take_focus
)
7442 /* Use the value returned by x_any_window_to_frame
7443 because this could be the shell widget window
7444 if the frame has no title bar. */
7447 /* Not quite sure this is needed -pd */
7448 if (f
&& FRAME_XIC (f
))
7449 XSetICFocus (FRAME_XIC (f
));
7452 /* Emacs sets WM hints whose `input' field is `true'. This
7453 instructs the WM to set the input focus automatically for
7454 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
7455 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
7456 it has set the focus. So, XSetInputFocus below is not
7459 The call to XSetInputFocus below has also caused trouble. In
7460 cases where the XSetInputFocus done by the WM and the one
7461 below are temporally close (on a fast machine), the call
7462 below can generate additional FocusIn events which confuse
7465 /* Since we set WM_TAKE_FOCUS, we must call
7466 XSetInputFocus explicitly. But not if f is null,
7467 since that might be an event for a deleted frame. */
7470 Display
*d
= event
->xclient
.display
;
7471 /* Catch and ignore errors, in case window has been
7472 iconified by a window manager such as GWM. */
7474 XSetInputFocus (d
, event
->xclient
.window
,
7475 /* The ICCCM says this is
7476 the only valid choice. */
7478 event
->xclient
.data
.l
[1]);
7479 /* This is needed to detect the error
7480 if there is an error. */
7482 x_uncatch_errors ();
7484 /* Not certain about handling scroll bars here */
7489 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_save_yourself
)
7491 /* Save state modify the WM_COMMAND property to
7492 something which can reinstate us. This notifies
7493 the session manager, who's looking for such a
7494 PropertyNotify. Can restart processing when
7495 a keyboard or mouse event arrives. */
7496 /* If we have a session manager, don't set this.
7497 KDE will then start two Emacsen, one for the
7498 session manager and one for this. */
7500 if (! x_session_have_connection ())
7503 f
= x_top_window_to_frame (dpyinfo
,
7504 event
->xclient
.window
);
7505 /* This is just so we only give real data once
7506 for a single Emacs process. */
7507 if (f
== SELECTED_FRAME ())
7508 XSetCommand (FRAME_X_DISPLAY (f
),
7509 event
->xclient
.window
,
7510 initial_argv
, initial_argc
);
7512 XSetCommand (FRAME_X_DISPLAY (f
),
7513 event
->xclient
.window
,
7519 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_delete_window
)
7523 goto OTHER
; /* May be a dialog that is to be removed */
7525 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
7526 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7533 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_configure_denied
)
7536 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_window_moved
)
7539 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
7541 new_x
= event
->xclient
.data
.s
[0];
7542 new_y
= event
->xclient
.data
.s
[1];
7546 f
->left_pos
= new_x
;
7553 if (event
->xclient
.message_type
== dpyinfo
->Xatom_editres
)
7557 _XEditResCheckMessages (f
->output_data
.x
->widget
,
7558 NULL
, (XEvent
*) event
, NULL
);
7561 #endif /* HACK_EDITRES */
7563 if (event
->xclient
.message_type
== dpyinfo
->Xatom_DONE
7564 || event
->xclient
.message_type
== dpyinfo
->Xatom_PAGE
)
7566 /* Ghostview job completed. Kill it. We could
7567 reply with "Next" if we received "Page", but we
7568 currently never do because we are interested in
7569 images, only, which should have 1 page. */
7570 Pixmap pixmap
= (Pixmap
) event
->xclient
.data
.l
[1];
7571 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
7574 x_kill_gs_process (pixmap
, f
);
7575 expose_frame (f
, 0, 0, 0, 0);
7579 #ifdef USE_TOOLKIT_SCROLL_BARS
7580 /* Scroll bar callbacks send a ClientMessage from which
7581 we construct an input_event. */
7582 if (event
->xclient
.message_type
== dpyinfo
->Xatom_Scrollbar
)
7584 x_scroll_bar_to_input_event (event
, &inev
.ie
);
7585 *finish
= X_EVENT_GOTO_OUT
;
7588 else if (event
->xclient
.message_type
== dpyinfo
->Xatom_Horizontal_Scrollbar
)
7590 x_horizontal_scroll_bar_to_input_event (event
, &inev
.ie
);
7591 *finish
= X_EVENT_GOTO_OUT
;
7594 #endif /* USE_TOOLKIT_SCROLL_BARS */
7596 /* XEmbed messages from the embedder (if any). */
7597 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
7599 enum xembed_message msg
= event
->xclient
.data
.l
[1];
7600 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
7601 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7603 *finish
= X_EVENT_GOTO_OUT
;
7607 xft_settings_event (dpyinfo
, event
);
7612 if (x_handle_dnd_message (f
, &event
->xclient
, dpyinfo
, &inev
.ie
))
7613 *finish
= X_EVENT_DROP
;
7617 case SelectionNotify
:
7618 x_display_set_last_user_time (dpyinfo
, event
->xselection
.time
);
7619 #ifdef USE_X_TOOLKIT
7620 if (! x_window_to_frame (dpyinfo
, event
->xselection
.requestor
))
7622 #endif /* not USE_X_TOOLKIT */
7623 x_handle_selection_notify (&event
->xselection
);
7626 case SelectionClear
: /* Someone has grabbed ownership. */
7627 x_display_set_last_user_time (dpyinfo
, event
->xselectionclear
.time
);
7628 #ifdef USE_X_TOOLKIT
7629 if (! x_window_to_frame (dpyinfo
, event
->xselectionclear
.window
))
7631 #endif /* USE_X_TOOLKIT */
7633 const XSelectionClearEvent
*eventp
= &event
->xselectionclear
;
7635 inev
.sie
.kind
= SELECTION_CLEAR_EVENT
;
7636 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
7637 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
7638 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
7642 case SelectionRequest
: /* Someone wants our selection. */
7643 x_display_set_last_user_time (dpyinfo
, event
->xselectionrequest
.time
);
7644 #ifdef USE_X_TOOLKIT
7645 if (!x_window_to_frame (dpyinfo
, event
->xselectionrequest
.owner
))
7647 #endif /* USE_X_TOOLKIT */
7649 const XSelectionRequestEvent
*eventp
= &event
->xselectionrequest
;
7651 inev
.sie
.kind
= SELECTION_REQUEST_EVENT
;
7652 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
7653 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
7654 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
7655 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
7656 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
7657 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
7661 case PropertyNotify
:
7662 x_display_set_last_user_time (dpyinfo
, event
->xproperty
.time
);
7663 f
= x_top_window_to_frame (dpyinfo
, event
->xproperty
.window
);
7664 if (f
&& event
->xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
7666 bool not_hidden
= x_handle_net_wm_state (f
, &event
->xproperty
);
7667 if (not_hidden
&& FRAME_ICONIFIED_P (f
))
7669 /* Gnome shell does not iconify us when C-z is pressed.
7670 It hides the frame. So if our state says we aren't
7671 hidden anymore, treat it as deiconified. */
7672 SET_FRAME_VISIBLE (f
, 1);
7673 SET_FRAME_ICONIFIED (f
, false);
7674 f
->output_data
.x
->has_been_visible
= true;
7675 inev
.ie
.kind
= DEICONIFY_EVENT
;
7676 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7678 else if (! not_hidden
&& ! FRAME_ICONIFIED_P (f
))
7680 SET_FRAME_VISIBLE (f
, 0);
7681 SET_FRAME_ICONIFIED (f
, true);
7682 inev
.ie
.kind
= ICONIFY_EVENT
;
7683 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7687 x_handle_property_notify (&event
->xproperty
);
7688 xft_settings_event (dpyinfo
, event
);
7691 case ReparentNotify
:
7692 f
= x_top_window_to_frame (dpyinfo
, event
->xreparent
.window
);
7695 f
->output_data
.x
->parent_desc
= event
->xreparent
.parent
;
7696 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
7698 /* Perhaps reparented due to a WM restart. Reset this. */
7699 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
7700 FRAME_DISPLAY_INFO (f
)->net_supported_window
= 0;
7702 x_set_frame_alpha (f
);
7707 f
= x_window_to_frame (dpyinfo
, event
->xexpose
.window
);
7710 if (!FRAME_VISIBLE_P (f
))
7712 SET_FRAME_VISIBLE (f
, 1);
7713 SET_FRAME_ICONIFIED (f
, false);
7714 f
->output_data
.x
->has_been_visible
= true;
7715 SET_FRAME_GARBAGED (f
);
7720 /* This seems to be needed for GTK 2.6 and later, see
7721 http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15398. */
7723 event
->xexpose
.x
, event
->xexpose
.y
,
7724 event
->xexpose
.width
, event
->xexpose
.height
);
7726 expose_frame (f
, event
->xexpose
.x
, event
->xexpose
.y
,
7727 event
->xexpose
.width
, event
->xexpose
.height
);
7732 #ifndef USE_TOOLKIT_SCROLL_BARS
7733 struct scroll_bar
*bar
;
7735 #if defined USE_LUCID
7736 /* Submenus of the Lucid menu bar aren't widgets
7737 themselves, so there's no way to dispatch events
7738 to them. Recognize this case separately. */
7740 Widget widget
= x_window_to_menu_bar (event
->xexpose
.window
);
7742 xlwmenu_redisplay (widget
);
7744 #endif /* USE_LUCID */
7746 #ifdef USE_TOOLKIT_SCROLL_BARS
7747 /* Dispatch event to the widget. */
7749 #else /* not USE_TOOLKIT_SCROLL_BARS */
7750 bar
= x_window_to_scroll_bar (event
->xexpose
.display
,
7751 event
->xexpose
.window
, 2);
7754 x_scroll_bar_expose (bar
, event
);
7755 #ifdef USE_X_TOOLKIT
7758 #endif /* USE_X_TOOLKIT */
7759 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7763 case GraphicsExpose
: /* This occurs when an XCopyArea's
7764 source area was obscured or not
7766 f
= x_window_to_frame (dpyinfo
, event
->xgraphicsexpose
.drawable
);
7768 expose_frame (f
, event
->xgraphicsexpose
.x
,
7769 event
->xgraphicsexpose
.y
,
7770 event
->xgraphicsexpose
.width
,
7771 event
->xgraphicsexpose
.height
);
7772 #ifdef USE_X_TOOLKIT
7775 #endif /* USE_X_TOOLKIT */
7778 case NoExpose
: /* This occurs when an XCopyArea's
7779 source area was completely
7784 /* Redo the mouse-highlight after the tooltip has gone. */
7785 if (event
->xunmap
.window
== tip_window
)
7788 x_redo_mouse_highlight (dpyinfo
);
7791 f
= x_top_window_to_frame (dpyinfo
, event
->xunmap
.window
);
7792 if (f
) /* F may no longer exist if
7793 the frame was deleted. */
7795 bool visible
= FRAME_VISIBLE_P (f
);
7796 /* While a frame is unmapped, display generation is
7797 disabled; you don't want to spend time updating a
7798 display that won't ever be seen. */
7799 SET_FRAME_VISIBLE (f
, 0);
7800 /* We can't distinguish, from the event, whether the window
7801 has become iconified or invisible. So assume, if it
7802 was previously visible, than now it is iconified.
7803 But x_make_frame_invisible clears both
7804 the visible flag and the iconified flag;
7805 and that way, we know the window is not iconified now. */
7806 if (visible
|| FRAME_ICONIFIED_P (f
))
7808 SET_FRAME_ICONIFIED (f
, true);
7809 inev
.ie
.kind
= ICONIFY_EVENT
;
7810 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7816 /* We use x_top_window_to_frame because map events can
7817 come for sub-windows and they don't mean that the
7818 frame is visible. */
7819 f
= x_top_window_to_frame (dpyinfo
, event
->xmap
.window
);
7822 bool iconified
= FRAME_ICONIFIED_P (f
);
7824 /* Check if fullscreen was specified before we where mapped the
7825 first time, i.e. from the command line. */
7826 if (!f
->output_data
.x
->has_been_visible
)
7827 x_check_fullscreen (f
);
7829 SET_FRAME_VISIBLE (f
, 1);
7830 SET_FRAME_ICONIFIED (f
, false);
7831 f
->output_data
.x
->has_been_visible
= true;
7835 inev
.ie
.kind
= DEICONIFY_EVENT
;
7836 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7838 else if (! NILP (Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
7839 /* Force a redisplay sooner or later to update the
7840 frame titles in case this is the second frame. */
7841 record_asynch_buffer_change ();
7844 xg_frame_resized (f
, -1, -1);
7851 x_display_set_last_user_time (dpyinfo
, event
->xkey
.time
);
7852 ignore_next_mouse_click_timeout
= 0;
7854 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
7855 /* Dispatch KeyPress events when in menu. */
7856 if (popup_activated ())
7862 /* If mouse-highlight is an integer, input clears out
7863 mouse highlighting. */
7864 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
7865 #if ! defined (USE_GTK)
7867 || !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
))
7871 clear_mouse_face (hlinfo
);
7872 hlinfo
->mouse_face_hidden
= true;
7875 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
7878 /* Scroll bars consume key events, but we want
7879 the keys to go to the scroll bar's frame. */
7880 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
7881 event
->xkey
.window
);
7882 if (widget
&& XmIsScrollBar (widget
))
7884 widget
= XtParent (widget
);
7885 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
7888 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
7892 KeySym keysym
, orig_keysym
;
7893 /* al%imercury@uunet.uu.net says that making this 81
7894 instead of 80 fixed a bug whereby meta chars made
7897 It seems that some version of XmbLookupString has
7898 a bug of not returning XBufferOverflow in
7899 status_return even if the input is too long to
7900 fit in 81 bytes. So, we must prepare sufficient
7901 bytes for copy_buffer. 513 bytes (256 chars for
7902 two-byte character set) seems to be a fairly good
7903 approximation. -- 2000.8.10 handa@etl.go.jp */
7904 unsigned char copy_buffer
[513];
7905 unsigned char *copy_bufptr
= copy_buffer
;
7906 int copy_bufsiz
= sizeof (copy_buffer
);
7908 Lisp_Object coding_system
= Qlatin_1
;
7910 /* Event will be modified. */
7911 XKeyEvent xkey
= event
->xkey
;
7914 /* Don't pass keys to GTK. A Tab will shift focus to the
7915 tool bar in GTK 2.4. Keys will still go to menus and
7916 dialogs because in that case popup_activated is nonzero
7918 *finish
= X_EVENT_DROP
;
7921 xkey
.state
|= x_emacs_to_x_modifiers (FRAME_DISPLAY_INFO (f
),
7922 extra_keyboard_modifiers
);
7923 modifiers
= xkey
.state
;
7925 /* This will have to go some day... */
7927 /* make_lispy_event turns chars into control chars.
7928 Don't do it here because XLookupString is too eager. */
7929 xkey
.state
&= ~ControlMask
;
7930 xkey
.state
&= ~(dpyinfo
->meta_mod_mask
7931 | dpyinfo
->super_mod_mask
7932 | dpyinfo
->hyper_mod_mask
7933 | dpyinfo
->alt_mod_mask
);
7935 /* In case Meta is ComposeCharacter,
7936 clear its status. According to Markus Ehrnsperger
7937 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
7938 this enables ComposeCharacter to work whether or
7939 not it is combined with Meta. */
7940 if (modifiers
& dpyinfo
->meta_mod_mask
)
7941 memset (&compose_status
, 0, sizeof (compose_status
));
7946 Status status_return
;
7948 coding_system
= Vlocale_coding_system
;
7949 nbytes
= XmbLookupString (FRAME_XIC (f
),
7950 &xkey
, (char *) copy_bufptr
,
7951 copy_bufsiz
, &keysym
,
7953 if (status_return
== XBufferOverflow
)
7955 copy_bufsiz
= nbytes
+ 1;
7956 copy_bufptr
= alloca (copy_bufsiz
);
7957 nbytes
= XmbLookupString (FRAME_XIC (f
),
7958 &xkey
, (char *) copy_bufptr
,
7959 copy_bufsiz
, &keysym
,
7962 /* Xutf8LookupString is a new but already deprecated interface. -stef */
7963 if (status_return
== XLookupNone
)
7965 else if (status_return
== XLookupChars
)
7970 else if (status_return
!= XLookupKeySym
7971 && status_return
!= XLookupBoth
)
7975 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
7976 copy_bufsiz
, &keysym
,
7979 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
7980 copy_bufsiz
, &keysym
,
7984 /* If not using XIM/XIC, and a compose sequence is in progress,
7985 we break here. Otherwise, chars_matched is always 0. */
7986 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
7989 memset (&compose_status
, 0, sizeof (compose_status
));
7990 orig_keysym
= keysym
;
7992 /* Common for all keysym input events. */
7993 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7995 = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), modifiers
);
7996 inev
.ie
.timestamp
= xkey
.time
;
7998 /* First deal with keysyms which have defined
7999 translations to characters. */
8000 if (keysym
>= 32 && keysym
< 128)
8001 /* Avoid explicitly decoding each ASCII character. */
8003 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
8004 inev
.ie
.code
= keysym
;
8008 /* Keysyms directly mapped to Unicode characters. */
8009 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
8011 if (keysym
< 0x01000080)
8012 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
8014 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
8015 inev
.ie
.code
= keysym
& 0xFFFFFF;
8019 /* Now non-ASCII. */
8020 if (HASH_TABLE_P (Vx_keysym_table
)
8021 && (c
= Fgethash (make_number (keysym
),
8026 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
8027 ? ASCII_KEYSTROKE_EVENT
8028 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
8029 inev
.ie
.code
= XFASTINT (c
);
8033 /* Random non-modifier sorts of keysyms. */
8034 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
8035 || keysym
== XK_Delete
8036 #ifdef XK_ISO_Left_Tab
8037 || (keysym
>= XK_ISO_Left_Tab
8038 && keysym
<= XK_ISO_Enter
)
8040 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
8041 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
8043 /* This recognizes the "extended function
8044 keys". It seems there's no cleaner way.
8045 Test IsModifierKey to avoid handling
8046 mode_switch incorrectly. */
8047 || (XK_Select
<= keysym
&& keysym
< XK_KP_Space
)
8049 #ifdef XK_dead_circumflex
8050 || orig_keysym
== XK_dead_circumflex
8052 #ifdef XK_dead_grave
8053 || orig_keysym
== XK_dead_grave
8055 #ifdef XK_dead_tilde
8056 || orig_keysym
== XK_dead_tilde
8058 #ifdef XK_dead_diaeresis
8059 || orig_keysym
== XK_dead_diaeresis
8061 #ifdef XK_dead_macron
8062 || orig_keysym
== XK_dead_macron
8064 #ifdef XK_dead_degree
8065 || orig_keysym
== XK_dead_degree
8067 #ifdef XK_dead_acute
8068 || orig_keysym
== XK_dead_acute
8070 #ifdef XK_dead_cedilla
8071 || orig_keysym
== XK_dead_cedilla
8073 #ifdef XK_dead_breve
8074 || orig_keysym
== XK_dead_breve
8076 #ifdef XK_dead_ogonek
8077 || orig_keysym
== XK_dead_ogonek
8079 #ifdef XK_dead_caron
8080 || orig_keysym
== XK_dead_caron
8082 #ifdef XK_dead_doubleacute
8083 || orig_keysym
== XK_dead_doubleacute
8085 #ifdef XK_dead_abovedot
8086 || orig_keysym
== XK_dead_abovedot
8088 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
8089 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
8090 /* Any "vendor-specific" key is ok. */
8091 || (orig_keysym
& (1 << 28))
8092 || (keysym
!= NoSymbol
&& nbytes
== 0))
8093 && ! (IsModifierKey (orig_keysym
)
8094 /* The symbols from XK_ISO_Lock
8095 to XK_ISO_Last_Group_Lock
8096 don't have real modifiers but
8097 should be treated similarly to
8098 Mode_switch by Emacs. */
8099 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
8100 || (XK_ISO_Lock
<= orig_keysym
8101 && orig_keysym
<= XK_ISO_Last_Group_Lock
)
8105 STORE_KEYSYM_FOR_DEBUG (keysym
);
8106 /* make_lispy_event will convert this to a symbolic
8108 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
8109 inev
.ie
.code
= keysym
;
8113 { /* Raw bytes, not keysym. */
8117 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
8119 if (ASCII_CHAR_P (copy_bufptr
[i
]))
8121 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
8124 if (nchars
< nbytes
)
8126 /* Decode the input data. */
8128 /* The input should be decoded with `coding_system'
8129 which depends on which X*LookupString function
8130 we used just above and the locale. */
8131 setup_coding_system (coding_system
, &coding
);
8132 coding
.src_multibyte
= false;
8133 coding
.dst_multibyte
= true;
8134 /* The input is converted to events, thus we can't
8135 handle composition. Anyway, there's no XIM that
8136 gives us composition information. */
8137 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
8139 SAFE_NALLOCA (coding
.destination
, MAX_MULTIBYTE_LENGTH
,
8141 coding
.dst_bytes
= MAX_MULTIBYTE_LENGTH
* nbytes
;
8142 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8143 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
8144 nbytes
= coding
.produced
;
8145 nchars
= coding
.produced_char
;
8146 copy_bufptr
= coding
.destination
;
8149 /* Convert the input data to a sequence of
8150 character events. */
8151 for (i
= 0; i
< nbytes
; i
+= len
)
8154 if (nchars
== nbytes
)
8155 ch
= copy_bufptr
[i
], len
= 1;
8157 ch
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
8158 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (ch
)
8159 ? ASCII_KEYSTROKE_EVENT
8160 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
8162 kbd_buffer_store_buffered_event (&inev
, hold_quit
);
8167 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
8169 if (keysym
== NoSymbol
)
8172 /* FIXME: check side effects and remove this. */
8173 ((XEvent
*) event
)->xkey
= xkey
;
8177 /* Don't dispatch this event since XtDispatchEvent calls
8178 XFilterEvent, and two calls in a row may freeze the
8186 x_display_set_last_user_time (dpyinfo
, event
->xkey
.time
);
8188 /* Don't dispatch this event since XtDispatchEvent calls
8189 XFilterEvent, and two calls in a row may freeze the
8197 x_display_set_last_user_time (dpyinfo
, event
->xcrossing
.time
);
8198 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8202 if (f
&& x_mouse_click_focus_ignore_position
)
8203 ignore_next_mouse_click_timeout
= event
->xmotion
.time
+ 200;
8205 /* EnterNotify counts as mouse movement,
8206 so update things that depend on mouse position. */
8207 if (f
&& !f
->output_data
.x
->hourglass_p
)
8208 note_mouse_movement (f
, &event
->xmotion
);
8210 /* We may get an EnterNotify on the buttons in the toolbar. In that
8211 case we moved out of any highlighted area and need to note this. */
8212 if (!f
&& dpyinfo
->last_mouse_glyph_frame
)
8213 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
8218 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8222 x_display_set_last_user_time (dpyinfo
, event
->xcrossing
.time
);
8223 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8225 f
= x_top_window_to_frame (dpyinfo
, event
->xcrossing
.window
);
8228 if (f
== hlinfo
->mouse_face_mouse_frame
)
8230 /* If we move outside the frame, then we're
8231 certainly no longer on any text in the frame. */
8232 clear_mouse_face (hlinfo
);
8233 hlinfo
->mouse_face_mouse_frame
= 0;
8236 /* Generate a nil HELP_EVENT to cancel a help-echo.
8237 Do it only if there's something to cancel.
8238 Otherwise, the startup message is cleared when
8239 the mouse leaves the frame. */
8240 if (any_help_event_p
)
8244 /* See comment in EnterNotify above */
8245 else if (dpyinfo
->last_mouse_glyph_frame
)
8246 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
8251 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8256 x_display_set_last_user_time (dpyinfo
, event
->xmotion
.time
);
8257 previous_help_echo_string
= help_echo_string
;
8258 help_echo_string
= Qnil
;
8260 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
8261 : x_window_to_frame (dpyinfo
, event
->xmotion
.window
));
8263 if (hlinfo
->mouse_face_hidden
)
8265 hlinfo
->mouse_face_hidden
= false;
8266 clear_mouse_face (hlinfo
);
8270 if (f
&& xg_event_is_for_scrollbar (f
, event
))
8276 /* Generate SELECT_WINDOW_EVENTs when needed.
8277 Don't let popup menus influence things (bug#1261). */
8278 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
8280 static Lisp_Object last_mouse_window
;
8281 Lisp_Object window
= window_from_coordinates
8282 (f
, event
->xmotion
.x
, event
->xmotion
.y
, 0, false);
8284 /* Window will be selected only when it is not selected now and
8285 last mouse movement event was not in it. Minibuffer window
8286 will be selected only when it is active. */
8287 if (WINDOWP (window
)
8288 && !EQ (window
, last_mouse_window
)
8289 && !EQ (window
, selected_window
)
8290 /* For click-to-focus window managers
8291 create event iff we don't leave the
8293 && (focus_follows_mouse
8294 || (EQ (XWINDOW (window
)->frame
,
8295 XWINDOW (selected_window
)->frame
))))
8297 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
8298 inev
.ie
.frame_or_window
= window
;
8300 /* Remember the last window where we saw the mouse. */
8301 last_mouse_window
= window
;
8303 if (!note_mouse_movement (f
, &event
->xmotion
))
8304 help_echo_string
= previous_help_echo_string
;
8308 #ifndef USE_TOOLKIT_SCROLL_BARS
8309 struct scroll_bar
*bar
8310 = x_window_to_scroll_bar (event
->xmotion
.display
,
8311 event
->xmotion
.window
, 2);
8314 x_scroll_bar_note_movement (bar
, &event
->xmotion
);
8315 #endif /* USE_TOOLKIT_SCROLL_BARS */
8317 /* If we move outside the frame, then we're
8318 certainly no longer on any text in the frame. */
8319 clear_mouse_face (hlinfo
);
8322 /* If the contents of the global variable help_echo_string
8323 has changed, generate a HELP_EVENT. */
8324 if (!NILP (help_echo_string
)
8325 || !NILP (previous_help_echo_string
))
8330 case ConfigureNotify
:
8331 f
= x_top_window_to_frame (dpyinfo
, event
->xconfigure
.window
);
8333 if (f
) x_cr_destroy_surface (f
);
8338 && event
->xconfigure
.window
== FRAME_X_WINDOW (f
))
8340 xg_frame_resized (f
, event
->xconfigure
.width
,
8341 event
->xconfigure
.height
);
8343 x_cr_destroy_surface (f
);
8350 x_net_wm_state (f
, event
->xconfigure
.window
);
8352 #ifdef USE_X_TOOLKIT
8353 /* Tip frames are pure X window, set size for them. */
8354 if (! NILP (tip_frame
) && XFRAME (tip_frame
) == f
)
8356 if (FRAME_PIXEL_HEIGHT (f
) != event
->xconfigure
.height
8357 || FRAME_PIXEL_WIDTH (f
) != event
->xconfigure
.width
)
8358 SET_FRAME_GARBAGED (f
);
8359 FRAME_PIXEL_HEIGHT (f
) = event
->xconfigure
.height
;
8360 FRAME_PIXEL_WIDTH (f
) = event
->xconfigure
.width
;
8364 #ifndef USE_X_TOOLKIT
8366 int width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, event
->xconfigure
.width
);
8367 int height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, event
->xconfigure
.height
);
8369 /* In the toolkit version, change_frame_size
8370 is called by the code that handles resizing
8371 of the EmacsFrame widget. */
8373 /* Even if the number of character rows and columns has
8374 not changed, the font size may have changed, so we need
8375 to check the pixel dimensions as well. */
8376 if (width
!= FRAME_TEXT_WIDTH (f
)
8377 || height
!= FRAME_TEXT_HEIGHT (f
)
8378 || event
->xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
8379 || event
->xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
8381 change_frame_size (f
, width
, height
, false, true, false, true);
8382 x_clear_under_internal_border (f
);
8383 SET_FRAME_GARBAGED (f
);
8384 cancel_mouse_face (f
);
8386 #endif /* not USE_GTK */
8390 /* GTK creates windows but doesn't map them.
8391 Only get real positions when mapped. */
8392 if (FRAME_GTK_OUTER_WIDGET (f
)
8393 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
8395 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
8398 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
8399 xic_set_statusarea (f
);
8408 /* If we decide we want to generate an event to be seen
8409 by the rest of Emacs, we put it here. */
8410 bool tool_bar_p
= false;
8412 memset (&compose_status
, 0, sizeof (compose_status
));
8413 dpyinfo
->last_mouse_glyph_frame
= NULL
;
8414 x_display_set_last_user_time (dpyinfo
, event
->xbutton
.time
);
8416 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
8417 : x_window_to_frame (dpyinfo
, event
->xbutton
.window
));
8420 if (f
&& xg_event_is_for_scrollbar (f
, event
))
8425 #if ! defined (USE_GTK)
8426 /* Is this in the tool-bar? */
8427 if (WINDOWP (f
->tool_bar_window
)
8428 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
8431 int x
= event
->xbutton
.x
;
8432 int y
= event
->xbutton
.y
;
8434 window
= window_from_coordinates (f
, x
, y
, 0, true);
8435 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
8437 if (tool_bar_p
&& event
->xbutton
.button
< 4)
8438 handle_tool_bar_click
8439 (f
, x
, y
, event
->xbutton
.type
== ButtonPress
,
8440 x_x_to_emacs_modifiers (dpyinfo
, event
->xbutton
.state
));
8442 #endif /* !USE_GTK */
8445 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
8446 if (! popup_activated ())
8449 if (ignore_next_mouse_click_timeout
)
8451 if (event
->type
== ButtonPress
8452 && event
->xbutton
.time
> ignore_next_mouse_click_timeout
)
8454 ignore_next_mouse_click_timeout
= 0;
8455 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
8457 if (event
->type
== ButtonRelease
)
8458 ignore_next_mouse_click_timeout
= 0;
8461 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
8463 if (FRAME_X_EMBEDDED_P (f
))
8464 xembed_send_message (f
, event
->xbutton
.time
,
8465 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
8469 struct scroll_bar
*bar
8470 = x_window_to_scroll_bar (event
->xbutton
.display
,
8471 event
->xbutton
.window
, 2);
8473 #ifdef USE_TOOLKIT_SCROLL_BARS
8474 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
8476 if (bar
&& event
->xbutton
.state
& ControlMask
)
8478 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
8479 *finish
= X_EVENT_DROP
;
8481 #else /* not USE_TOOLKIT_SCROLL_BARS */
8483 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
8484 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8487 if (event
->type
== ButtonPress
)
8489 dpyinfo
->grabbed
|= (1 << event
->xbutton
.button
);
8490 dpyinfo
->last_mouse_frame
= f
;
8491 #if ! defined (USE_GTK)
8492 if (f
&& !tool_bar_p
)
8493 f
->last_tool_bar_item
= -1;
8494 #endif /* not USE_GTK */
8497 dpyinfo
->grabbed
&= ~(1 << event
->xbutton
.button
);
8499 /* Ignore any mouse motion that happened before this event;
8500 any subsequent mouse-movement Emacs events should reflect
8501 only motion after the ButtonPress/Release. */
8503 f
->mouse_moved
= false;
8505 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
8506 f
= x_menubar_window_to_frame (dpyinfo
, event
);
8507 /* For a down-event in the menu bar,
8508 don't pass it to Xt right now.
8509 Instead, save it away
8510 and we will pass it to Xt from kbd_buffer_get_event.
8511 That way, we can run some Lisp code first. */
8512 if (! popup_activated ()
8514 /* Gtk+ menus only react to the first three buttons. */
8515 && event
->xbutton
.button
< 3
8517 && f
&& event
->type
== ButtonPress
8518 /* Verify the event is really within the menu bar
8519 and not just sent to it due to grabbing. */
8520 && event
->xbutton
.x
>= 0
8521 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
8522 && event
->xbutton
.y
>= 0
8523 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
8524 && event
->xbutton
.same_screen
)
8526 if (!f
->output_data
.x
->saved_menu_event
)
8527 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof *event
);
8528 *f
->output_data
.x
->saved_menu_event
= *event
;
8529 inev
.ie
.kind
= MENU_BAR_ACTIVATE_EVENT
;
8530 XSETFRAME (inev
.ie
.frame_or_window
, f
);
8531 *finish
= X_EVENT_DROP
;
8535 #endif /* USE_X_TOOLKIT || USE_GTK */
8539 case CirculateNotify
:
8542 case CirculateRequest
:
8545 case VisibilityNotify
:
8549 /* Someone has changed the keyboard mapping - update the
8551 switch (event
->xmapping
.request
)
8553 case MappingModifier
:
8554 x_find_modifier_meanings (dpyinfo
);
8555 /* This is meant to fall through. */
8556 case MappingKeyboard
:
8557 XRefreshKeyboardMapping ((XMappingEvent
*) &event
->xmapping
);
8562 xft_settings_event (dpyinfo
, event
);
8567 #ifdef USE_X_TOOLKIT
8569 if (*finish
!= X_EVENT_DROP
)
8570 XtDispatchEvent ((XEvent
*) event
);
8572 #endif /* USE_X_TOOLKIT */
8577 if (inev
.ie
.kind
!= NO_EVENT
)
8579 kbd_buffer_store_buffered_event (&inev
, hold_quit
);
8584 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
8589 XSETFRAME (frame
, f
);
8595 any_help_event_p
= true;
8596 gen_help_event (help_echo_string
, frame
, help_echo_window
,
8597 help_echo_object
, help_echo_pos
);
8601 help_echo_string
= Qnil
;
8602 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
8611 /* Handles the XEvent EVENT on display DISPLAY.
8612 This is used for event loops outside the normal event handling,
8613 i.e. looping while a popup menu or a dialog is posted.
8615 Returns the value handle_one_xevent sets in the finish argument. */
8617 x_dispatch_event (XEvent
*event
, Display
*display
)
8619 struct x_display_info
*dpyinfo
;
8620 int finish
= X_EVENT_NORMAL
;
8622 dpyinfo
= x_display_info_for_display (display
);
8625 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
8630 /* Read events coming from the X server.
8631 Return as soon as there are no more events to be read.
8633 Return the number of characters stored into the buffer,
8634 thus pretending to be `read' (except the characters we store
8635 in the keyboard buffer can be multibyte, so are not necessarily
8639 XTread_socket (struct terminal
*terminal
, struct input_event
*hold_quit
)
8642 bool event_found
= false;
8643 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
8647 /* For debugging, this gives a way to fake an I/O error. */
8648 if (dpyinfo
== XTread_socket_fake_io_error
)
8650 XTread_socket_fake_io_error
= 0;
8651 x_io_error_quitter (dpyinfo
->display
);
8655 while (XPending (dpyinfo
->display
))
8660 XNextEvent (dpyinfo
->display
, &event
);
8663 /* Filter events for the current X input method. */
8664 if (x_filter_event (dpyinfo
, &event
))
8669 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
8671 if (finish
== X_EVENT_GOTO_OUT
)
8677 /* For GTK we must use the GTK event loop. But XEvents gets passed
8678 to our filter function above, and then to the big event switch.
8679 We use a bunch of globals to communicate with our filter function,
8680 that is kind of ugly, but it works.
8682 There is no way to do one display at the time, GTK just does events
8683 from all displays. */
8685 while (gtk_events_pending ())
8687 current_count
= count
;
8688 current_hold_quit
= hold_quit
;
8690 gtk_main_iteration ();
8692 count
= current_count
;
8694 current_hold_quit
= 0;
8696 if (current_finish
== X_EVENT_GOTO_OUT
)
8699 #endif /* USE_GTK */
8701 /* On some systems, an X bug causes Emacs to get no more events
8702 when the window is destroyed. Detect that. (1994.) */
8705 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
8706 One XNOOP in 100 loops will make Emacs terminate.
8707 B. Bretthauer, 1994 */
8709 if (x_noop_count
>= 100)
8713 if (next_noop_dpyinfo
== 0)
8714 next_noop_dpyinfo
= x_display_list
;
8716 XNoOp (next_noop_dpyinfo
->display
);
8718 /* Each time we get here, cycle through the displays now open. */
8719 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
8723 /* If the focus was just given to an auto-raising frame,
8724 raise it now. FIXME: handle more than one such frame. */
8725 if (dpyinfo
->x_pending_autoraise_frame
)
8727 x_raise_frame (dpyinfo
->x_pending_autoraise_frame
);
8728 dpyinfo
->x_pending_autoraise_frame
= NULL
;
8739 /***********************************************************************
8741 ***********************************************************************/
8743 /* Set clipping for output in glyph row ROW. W is the window in which
8744 we operate. GC is the graphics context to set clipping in.
8746 ROW may be a text row or, e.g., a mode line. Text rows must be
8747 clipped to the interior of the window dedicated to text display,
8748 mode lines must be clipped to the whole window. */
8751 x_clip_to_row (struct window
*w
, struct glyph_row
*row
,
8752 enum glyph_row_area area
, GC gc
)
8754 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8755 XRectangle clip_rect
;
8756 int window_x
, window_y
, window_width
;
8758 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
8760 clip_rect
.x
= window_x
;
8761 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
8762 clip_rect
.y
= max (clip_rect
.y
, window_y
);
8763 clip_rect
.width
= window_width
;
8764 clip_rect
.height
= row
->visible_height
;
8766 x_set_clip_rectangles (f
, gc
, &clip_rect
, 1);
8770 /* Draw a hollow box cursor on window W in glyph row ROW. */
8773 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
8775 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8776 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8777 Display
*dpy
= FRAME_X_DISPLAY (f
);
8780 struct glyph
*cursor_glyph
;
8783 /* Get the glyph the cursor is on. If we can't tell because
8784 the current matrix is invalid or such, give up. */
8785 cursor_glyph
= get_phys_cursor_glyph (w
);
8786 if (cursor_glyph
== NULL
)
8789 /* Compute frame-relative coordinates for phys cursor. */
8790 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
8791 wd
= w
->phys_cursor_width
- 1;
8793 /* The foreground of cursor_gc is typically the same as the normal
8794 background color, which can cause the cursor box to be invisible. */
8795 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
8796 if (dpyinfo
->scratch_cursor_gc
)
8797 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
8799 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
8800 GCForeground
, &xgcv
);
8801 gc
= dpyinfo
->scratch_cursor_gc
;
8803 /* When on R2L character, show cursor at the right edge of the
8804 glyph, unless the cursor box is as wide as the glyph or wider
8805 (the latter happens when x-stretch-cursor is non-nil). */
8806 if ((cursor_glyph
->resolved_level
& 1) != 0
8807 && cursor_glyph
->pixel_width
> wd
)
8809 x
+= cursor_glyph
->pixel_width
- wd
;
8813 /* Set clipping, draw the rectangle, and reset clipping again. */
8814 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
8815 x_draw_rectangle (f
, gc
, x
, y
, wd
, h
- 1);
8816 x_reset_clip_rectangles (f
, gc
);
8820 /* Draw a bar cursor on window W in glyph row ROW.
8822 Implementation note: One would like to draw a bar cursor with an
8823 angle equal to the one given by the font property XA_ITALIC_ANGLE.
8824 Unfortunately, I didn't find a font yet that has this property set.
8828 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
8830 struct frame
*f
= XFRAME (w
->frame
);
8831 struct glyph
*cursor_glyph
;
8833 /* If cursor is out of bounds, don't draw garbage. This can happen
8834 in mini-buffer windows when switching between echo area glyphs
8836 cursor_glyph
= get_phys_cursor_glyph (w
);
8837 if (cursor_glyph
== NULL
)
8840 /* If on an image, draw like a normal cursor. That's usually better
8841 visible than drawing a bar, esp. if the image is large so that
8842 the bar might not be in the window. */
8843 if (cursor_glyph
->type
== IMAGE_GLYPH
)
8845 struct glyph_row
*r
;
8846 r
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
8847 draw_phys_cursor_glyph (w
, r
, DRAW_CURSOR
);
8851 Display
*dpy
= FRAME_X_DISPLAY (f
);
8852 Window window
= FRAME_X_WINDOW (f
);
8853 GC gc
= FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
;
8854 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
8855 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
8858 /* If the glyph's background equals the color we normally draw
8859 the bars cursor in, the bar cursor in its normal color is
8860 invisible. Use the glyph's foreground color instead in this
8861 case, on the assumption that the glyph's colors are chosen so
8862 that the glyph is legible. */
8863 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
8864 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
8866 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
8867 xgcv
.graphics_exposures
= False
;
8870 XChangeGC (dpy
, gc
, mask
, &xgcv
);
8873 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
8874 FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
8877 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
8879 if (kind
== BAR_CURSOR
)
8881 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8884 width
= FRAME_CURSOR_WIDTH (f
);
8885 width
= min (cursor_glyph
->pixel_width
, width
);
8887 w
->phys_cursor_width
= width
;
8889 /* If the character under cursor is R2L, draw the bar cursor
8890 on the right of its glyph, rather than on the left. */
8891 if ((cursor_glyph
->resolved_level
& 1) != 0)
8892 x
+= cursor_glyph
->pixel_width
- width
;
8894 x_fill_rectangle (f
, gc
, x
,
8895 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
8896 width
, row
->height
);
8898 else /* HBAR_CURSOR */
8900 int dummy_x
, dummy_y
, dummy_h
;
8901 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8904 width
= row
->height
;
8906 width
= min (row
->height
, width
);
8908 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
8909 &dummy_y
, &dummy_h
);
8911 if ((cursor_glyph
->resolved_level
& 1) != 0
8912 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
- 1)
8913 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
+ 1;
8914 x_fill_rectangle (f
, gc
, x
,
8915 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
8916 row
->height
- width
),
8917 w
->phys_cursor_width
- 1, width
);
8920 x_reset_clip_rectangles (f
, gc
);
8925 /* RIF: Define cursor CURSOR on frame F. */
8928 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
8930 if (!f
->pointer_invisible
8931 && f
->output_data
.x
->current_cursor
!= cursor
)
8932 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
8933 f
->output_data
.x
->current_cursor
= cursor
;
8937 /* RIF: Clear area on frame F. */
8940 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
8942 x_clear_area (f
, x
, y
, width
, height
);
8944 /* Must queue a redraw, because scroll bars might have been cleared. */
8945 if (FRAME_GTK_WIDGET (f
))
8946 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
8951 /* RIF: Draw cursor on window W. */
8954 x_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
, int x
,
8955 int y
, enum text_cursor_kinds cursor_type
,
8956 int cursor_width
, bool on_p
, bool active_p
)
8958 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8962 w
->phys_cursor_type
= cursor_type
;
8963 w
->phys_cursor_on_p
= true;
8965 if (glyph_row
->exact_window_width_line_p
8966 && (glyph_row
->reversed_p
8967 ? (w
->phys_cursor
.hpos
< 0)
8968 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
8970 glyph_row
->cursor_in_fringe_p
= true;
8971 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
8975 switch (cursor_type
)
8977 case HOLLOW_BOX_CURSOR
:
8978 x_draw_hollow_cursor (w
, glyph_row
);
8981 case FILLED_BOX_CURSOR
:
8982 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
8986 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
8990 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
8994 w
->phys_cursor_width
= 0;
9003 if (w
== XWINDOW (f
->selected_window
))
9004 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
9005 xic_set_preeditarea (w
, x
, y
);
9009 XFlush (FRAME_X_DISPLAY (f
));
9015 /* Make the x-window of frame F use the gnu icon bitmap. */
9018 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
9020 ptrdiff_t bitmap_id
;
9022 if (FRAME_X_WINDOW (f
) == 0)
9025 /* Free up our existing icon bitmap and mask if any. */
9026 if (f
->output_data
.x
->icon_bitmap
> 0)
9027 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
9028 f
->output_data
.x
->icon_bitmap
= 0;
9033 /* Use gtk_window_set_icon_from_file () if available,
9034 It's not restricted to bitmaps */
9035 if (xg_set_icon (f
, file
))
9037 #endif /* USE_GTK */
9038 bitmap_id
= x_create_bitmap_from_file (f
, file
);
9039 x_create_bitmap_mask (f
, bitmap_id
);
9043 /* Create the GNU bitmap and mask if necessary. */
9044 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
9050 if (xg_set_icon (f
, xg_default_icon_file
)
9051 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
9053 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= -2;
9057 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
9059 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
9061 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
9065 /* If all else fails, use the (black and white) xbm image. */
9068 rc
= x_create_bitmap_from_data (f
, (char *) gnu_xbm_bits
,
9069 gnu_xbm_width
, gnu_xbm_height
);
9073 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
9074 x_create_bitmap_mask (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
9078 /* The first time we create the GNU bitmap and mask,
9079 this increments the ref-count one extra time.
9080 As a result, the GNU bitmap and mask are never freed.
9081 That way, we don't have to worry about allocating it again. */
9082 x_reference_bitmap (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
9084 bitmap_id
= FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
;
9087 x_wm_set_icon_pixmap (f
, bitmap_id
);
9088 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
9094 /* Make the x-window of frame F use a rectangle with text.
9095 Use ICON_NAME as the text. */
9098 x_text_icon (struct frame
*f
, const char *icon_name
)
9100 if (FRAME_X_WINDOW (f
) == 0)
9105 text
.value
= (unsigned char *) icon_name
;
9106 text
.encoding
= XA_STRING
;
9108 text
.nitems
= strlen (icon_name
);
9109 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
9112 if (f
->output_data
.x
->icon_bitmap
> 0)
9113 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
9114 f
->output_data
.x
->icon_bitmap
= 0;
9115 x_wm_set_icon_pixmap (f
, 0);
9120 #define X_ERROR_MESSAGE_SIZE 200
9122 /* If non-nil, this should be a string.
9123 It means catch X errors and store the error message in this string.
9125 The reason we use a stack is that x_catch_error/x_uncatch_error can
9126 be called from a signal handler.
9129 struct x_error_message_stack
{
9130 char string
[X_ERROR_MESSAGE_SIZE
];
9132 struct x_error_message_stack
*prev
;
9134 static struct x_error_message_stack
*x_error_message
;
9136 /* An X error handler which stores the error message in
9137 *x_error_message. This is called from x_error_handler if
9138 x_catch_errors is in effect. */
9141 x_error_catcher (Display
*display
, XErrorEvent
*event
)
9143 XGetErrorText (display
, event
->error_code
,
9144 x_error_message
->string
,
9145 X_ERROR_MESSAGE_SIZE
);
9148 /* Begin trapping X errors for display DPY. Actually we trap X errors
9149 for all displays, but DPY should be the display you are actually
9152 After calling this function, X protocol errors no longer cause
9153 Emacs to exit; instead, they are recorded in the string
9154 stored in *x_error_message.
9156 Calling x_check_errors signals an Emacs error if an X error has
9157 occurred since the last call to x_catch_errors or x_check_errors.
9159 Calling x_uncatch_errors resumes the normal error handling. */
9162 x_catch_errors (Display
*dpy
)
9164 struct x_error_message_stack
*data
= xmalloc (sizeof *data
);
9166 /* Make sure any errors from previous requests have been dealt with. */
9170 data
->string
[0] = 0;
9171 data
->prev
= x_error_message
;
9172 x_error_message
= data
;
9175 /* Undo the last x_catch_errors call.
9176 DPY should be the display that was passed to x_catch_errors. */
9179 x_uncatch_errors (void)
9181 struct x_error_message_stack
*tmp
;
9185 /* The display may have been closed before this function is called.
9186 Check if it is still open before calling XSync. */
9187 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
9188 XSync (x_error_message
->dpy
, False
);
9190 tmp
= x_error_message
;
9191 x_error_message
= x_error_message
->prev
;
9196 /* If any X protocol errors have arrived since the last call to
9197 x_catch_errors or x_check_errors, signal an Emacs error using
9198 sprintf (a buffer, FORMAT, the x error message text) as the text. */
9201 x_check_errors (Display
*dpy
, const char *format
)
9203 /* Make sure to catch any errors incurred so far. */
9206 if (x_error_message
->string
[0])
9208 char string
[X_ERROR_MESSAGE_SIZE
];
9209 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
9210 x_uncatch_errors ();
9211 error (format
, string
);
9215 /* Nonzero if we had any X protocol errors
9216 since we did x_catch_errors on DPY. */
9219 x_had_errors_p (Display
*dpy
)
9221 /* Make sure to catch any errors incurred so far. */
9224 return x_error_message
->string
[0] != 0;
9227 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
9230 x_clear_errors (Display
*dpy
)
9232 x_error_message
->string
[0] = 0;
9236 /* See comment in unwind_to_catch why calling this is a bad
9237 * idea. --lorentey */
9238 /* Close off all unclosed x_catch_errors calls. */
9241 x_fully_uncatch_errors (void)
9243 while (x_error_message
)
9244 x_uncatch_errors ();
9249 static unsigned int x_wire_count
;
9252 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
9257 /************************************************************************
9259 ************************************************************************/
9261 /* Error message passed to x_connection_closed. */
9263 static char *error_msg
;
9265 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
9266 the text of an error message that lead to the connection loss. */
9269 x_connection_closed (Display
*dpy
, const char *error_message
, bool ioerror
)
9271 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
9272 Lisp_Object frame
, tail
;
9273 ptrdiff_t idx
= SPECPDL_INDEX ();
9275 error_msg
= alloca (strlen (error_message
) + 1);
9276 strcpy (error_msg
, error_message
);
9278 /* Inhibit redisplay while frames are being deleted. */
9279 specbind (Qinhibit_redisplay
, Qt
);
9283 /* Protect display from being closed when we delete the last
9285 dpyinfo
->reference_count
++;
9286 dpyinfo
->terminal
->reference_count
++;
9288 if (ioerror
) dpyinfo
->display
= 0;
9290 /* First delete frames whose mini-buffers are on frames
9291 that are on the dead display. */
9292 FOR_EACH_FRAME (tail
, frame
)
9294 Lisp_Object minibuf_frame
;
9296 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
9297 if (FRAME_X_P (XFRAME (frame
))
9298 && FRAME_X_P (XFRAME (minibuf_frame
))
9299 && ! EQ (frame
, minibuf_frame
)
9300 && FRAME_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
9301 delete_frame (frame
, Qnoelisp
);
9304 /* Now delete all remaining frames on the dead display.
9305 We are now sure none of these is used as the mini-buffer
9306 for another frame that we need to delete. */
9307 FOR_EACH_FRAME (tail
, frame
)
9308 if (FRAME_X_P (XFRAME (frame
))
9309 && FRAME_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
9311 /* Set this to t so that delete_frame won't get confused
9312 trying to find a replacement. */
9313 kset_default_minibuffer_frame (FRAME_KBOARD (XFRAME (frame
)), Qt
);
9314 delete_frame (frame
, Qnoelisp
);
9317 /* If DPYINFO is null, this means we didn't open the display in the
9318 first place, so don't try to close it. */
9321 /* We can not call XtCloseDisplay here because it calls XSync.
9322 XSync inside the error handler apparently hangs Emacs. On
9323 current Xt versions, this isn't needed either. */
9325 /* A long-standing GTK bug prevents proper disconnect handling
9326 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Once,
9327 the resulting Glib error message loop filled a user's disk.
9328 To avoid this, kill Emacs unconditionally on disconnect. */
9329 shut_down_emacs (0, Qnil
);
9330 fprintf (stderr
, "%s\n\
9331 When compiled with GTK, Emacs cannot recover from X disconnects.\n\
9332 This is a GTK bug: https://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
9333 For details, see etc/PROBLEMS.\n",
9336 #endif /* USE_GTK */
9338 /* Indicate that this display is dead. */
9339 dpyinfo
->display
= 0;
9341 dpyinfo
->reference_count
--;
9342 dpyinfo
->terminal
->reference_count
--;
9343 if (dpyinfo
->reference_count
!= 0)
9344 /* We have just closed all frames on this display. */
9349 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
9350 Fdelete_terminal (tmp
, Qnoelisp
);
9354 if (terminal_list
== 0)
9356 fprintf (stderr
, "%s\n", error_msg
);
9357 Fkill_emacs (make_number (70));
9361 totally_unblock_input ();
9363 unbind_to (idx
, Qnil
);
9364 clear_waiting_for_input ();
9366 /* Tell GCC not to suggest attribute 'noreturn' for this function. */
9367 IF_LINT (if (! terminal_list
) return; )
9369 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
9370 longjmp), because returning from this function would get us back into
9371 Xlib's code which will directly call `exit'. */
9372 error ("%s", error_msg
);
9375 /* We specifically use it before defining it, so that gcc doesn't inline it,
9376 otherwise gdb doesn't know how to properly put a breakpoint on it. */
9377 static void x_error_quitter (Display
*, XErrorEvent
*);
9379 /* This is the first-level handler for X protocol errors.
9380 It calls x_error_quitter or x_error_catcher. */
9383 x_error_handler (Display
*display
, XErrorEvent
*event
)
9385 #if defined USE_GTK && defined HAVE_GTK3
9386 if ((event
->error_code
== BadMatch
|| event
->error_code
== BadWindow
)
9387 && event
->request_code
== X_SetInputFocus
)
9393 if (x_error_message
)
9394 x_error_catcher (display
, event
);
9396 x_error_quitter (display
, event
);
9400 /* This is the usual handler for X protocol errors.
9401 It kills all frames on the display that we got the error for.
9402 If that was the only one, it prints an error message and kills Emacs. */
9404 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
9406 /* On older GCC versions, just putting x_error_quitter
9407 after x_error_handler prevents inlining into the former. */
9409 static void NO_INLINE
9410 x_error_quitter (Display
*display
, XErrorEvent
*event
)
9412 char buf
[256], buf1
[356];
9414 /* Ignore BadName errors. They can happen because of fonts
9415 or colors that are not defined. */
9417 if (event
->error_code
== BadName
)
9420 /* Note that there is no real way portable across R3/R4 to get the
9421 original error handler. */
9423 XGetErrorText (display
, event
->error_code
, buf
, sizeof (buf
));
9424 sprintf (buf1
, "X protocol error: %s on protocol request %d",
9425 buf
, event
->request_code
);
9426 x_connection_closed (display
, buf1
, false);
9430 /* This is the handler for X IO errors, always.
9431 It kills all frames on the display that we lost touch with.
9432 If that was the only one, it prints an error message and kills Emacs. */
9435 x_io_error_quitter (Display
*display
)
9439 snprintf (buf
, sizeof buf
, "Connection lost to X server '%s'",
9440 DisplayString (display
));
9441 x_connection_closed (display
, buf
, true);
9445 /* Changing the font of the frame. */
9447 /* Give frame F the font FONT-OBJECT as its default font. The return
9448 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
9449 frame. If it is negative, generate a new fontset from
9453 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
9455 struct font
*font
= XFONT_OBJECT (font_object
);
9456 int unit
, font_ascent
, font_descent
;
9459 fontset
= fontset_from_font (font_object
);
9460 FRAME_FONTSET (f
) = fontset
;
9461 if (FRAME_FONT (f
) == font
)
9462 /* This font is already set in frame F. There's nothing more to
9466 FRAME_FONT (f
) = font
;
9467 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
9468 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
9469 get_font_ascent_descent (font
, &font_ascent
, &font_descent
);
9470 FRAME_LINE_HEIGHT (f
) = font_ascent
+ font_descent
;
9472 #ifndef USE_X_TOOLKIT
9473 FRAME_MENU_BAR_HEIGHT (f
) = FRAME_MENU_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
);
9476 /* Compute character columns occupied by scrollbar.
9478 Don't do things differently for non-toolkit scrollbars
9480 unit
= FRAME_COLUMN_WIDTH (f
);
9481 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
9482 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
9483 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
9485 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
9487 if (FRAME_X_WINDOW (f
) != 0)
9489 /* Don't change the size of a tip frame; there's no point in
9490 doing it because it's done in Fx_show_tip, and it leads to
9491 problems because the tip frame has no widget. */
9492 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
9493 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
9494 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
9500 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
9503 xic_set_xfontset (f
, SSDATA (fontset_ascii (fontset
)));
9512 /***********************************************************************
9514 ***********************************************************************/
9520 /* XIM destroy callback function, which is called whenever the
9521 connection to input method XIM dies. CLIENT_DATA contains a
9522 pointer to the x_display_info structure corresponding to XIM. */
9525 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
9527 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
9528 Lisp_Object frame
, tail
;
9532 /* No need to call XDestroyIC.. */
9533 FOR_EACH_FRAME (tail
, frame
)
9535 struct frame
*f
= XFRAME (frame
);
9536 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
9538 FRAME_XIC (f
) = NULL
;
9539 xic_free_xfontset (f
);
9543 /* No need to call XCloseIM. */
9544 dpyinfo
->xim
= NULL
;
9545 XFree (dpyinfo
->xim_styles
);
9549 #endif /* HAVE_X11R6 */
9551 /* Open the connection to the XIM server on display DPYINFO.
9552 RESOURCE_NAME is the resource name Emacs uses. */
9555 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
9563 XCloseIM (dpyinfo
->xim
);
9564 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
9571 XIMCallback destroy
;
9574 /* Get supported styles and XIM values. */
9575 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
9578 destroy
.callback
= xim_destroy_callback
;
9579 destroy
.client_data
= (XPointer
)dpyinfo
;
9580 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
9586 #endif /* HAVE_XIM */
9587 dpyinfo
->xim
= NULL
;
9591 #ifdef HAVE_X11R6_XIM
9593 /* XIM instantiate callback function, which is called whenever an XIM
9594 server is available. DISPLAY is the display of the XIM.
9595 CLIENT_DATA contains a pointer to an xim_inst_t structure created
9596 when the callback was registered. */
9599 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
9601 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
9602 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
9604 /* We don't support multiple XIM connections. */
9608 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
9610 /* Create XIC for the existing frames on the same display, as long
9611 as they have no XIC. */
9612 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
9614 Lisp_Object tail
, frame
;
9617 FOR_EACH_FRAME (tail
, frame
)
9619 struct frame
*f
= XFRAME (frame
);
9622 && FRAME_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
9623 if (FRAME_XIC (f
) == NULL
)
9625 create_frame_xic (f
);
9626 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
9627 xic_set_statusarea (f
);
9628 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
9630 struct window
*w
= XWINDOW (f
->selected_window
);
9631 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
9640 #endif /* HAVE_X11R6_XIM */
9643 /* Open a connection to the XIM server on display DPYINFO.
9644 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
9645 connection only at the first time. On X11R6, open the connection
9646 in the XIM instantiate callback function. */
9649 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
9651 dpyinfo
->xim
= NULL
;
9655 #ifdef HAVE_X11R6_XIM
9656 struct xim_inst_t
*xim_inst
= xmalloc (sizeof *xim_inst
);
9659 dpyinfo
->xim_callback_data
= xim_inst
;
9660 xim_inst
->dpyinfo
= dpyinfo
;
9661 xim_inst
->resource_name
= xstrdup (resource_name
);
9662 ret
= XRegisterIMInstantiateCallback
9663 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
9664 emacs_class
, xim_instantiate_callback
,
9665 /* This is XPointer in XFree86 but (XPointer *)
9666 on Tru64, at least, hence the configure test. */
9667 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
9668 eassert (ret
== True
);
9669 #else /* not HAVE_X11R6_XIM */
9670 xim_open_dpy (dpyinfo
, resource_name
);
9671 #endif /* not HAVE_X11R6_XIM */
9673 #endif /* HAVE_XIM */
9677 /* Close the connection to the XIM server on display DPYINFO. */
9680 xim_close_dpy (struct x_display_info
*dpyinfo
)
9685 #ifdef HAVE_X11R6_XIM
9686 struct xim_inst_t
*xim_inst
= dpyinfo
->xim_callback_data
;
9688 if (dpyinfo
->display
)
9690 Bool ret
= XUnregisterIMInstantiateCallback
9691 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
9692 emacs_class
, xim_instantiate_callback
,
9693 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
9694 eassert (ret
== True
);
9696 xfree (xim_inst
->resource_name
);
9698 #endif /* HAVE_X11R6_XIM */
9699 if (dpyinfo
->display
)
9700 XCloseIM (dpyinfo
->xim
);
9701 dpyinfo
->xim
= NULL
;
9702 XFree (dpyinfo
->xim_styles
);
9704 #endif /* HAVE_XIM */
9707 #endif /* not HAVE_X11R6_XIM */
9711 /* Calculate the absolute position in frame F
9712 from its current recorded position values and gravity. */
9715 x_calc_absolute_position (struct frame
*f
)
9717 int flags
= f
->size_hint_flags
;
9719 /* We have nothing to do if the current position
9720 is already for the top-left corner. */
9721 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
9724 /* Treat negative positions as relative to the leftmost bottommost
9725 position that fits on the screen. */
9726 if (flags
& XNegative
)
9727 f
->left_pos
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
9728 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
9731 int height
= FRAME_PIXEL_HEIGHT (f
);
9733 #if defined USE_X_TOOLKIT && defined USE_MOTIF
9734 /* Something is fishy here. When using Motif, starting Emacs with
9735 `-g -0-0', the frame appears too low by a few pixels.
9737 This seems to be so because initially, while Emacs is starting,
9738 the column widget's height and the frame's pixel height are
9739 different. The column widget's height is the right one. In
9740 later invocations, when Emacs is up, the frame's pixel height
9743 It's not obvious where the initial small difference comes from.
9744 2000-12-01, gerd. */
9746 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
9749 if (flags
& YNegative
)
9750 f
->top_pos
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
9751 - height
+ f
->top_pos
;
9754 /* The left_pos and top_pos
9755 are now relative to the top and left screen edges,
9756 so the flags should correspond. */
9757 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9760 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
9761 to really change the position, and 0 when calling from
9762 x_make_frame_visible (in that case, XOFF and YOFF are the current
9763 position values). It is -1 when calling from x_set_frame_parameters,
9764 which means, do adjust for borders but don't change the gravity. */
9767 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
9769 int modified_top
, modified_left
;
9771 if (change_gravity
> 0)
9775 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9777 f
->size_hint_flags
|= XNegative
;
9779 f
->size_hint_flags
|= YNegative
;
9780 f
->win_gravity
= NorthWestGravity
;
9782 x_calc_absolute_position (f
);
9785 x_wm_set_size_hint (f
, 0, false);
9787 modified_left
= f
->left_pos
;
9788 modified_top
= f
->top_pos
;
9790 if (change_gravity
!= 0 && FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
9792 /* Some WMs (twm, wmaker at least) has an offset that is smaller
9793 than the WM decorations. So we use the calculated offset instead
9794 of the WM decoration sizes here (x/y_pixels_outer_diff). */
9795 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
9796 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
9799 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9800 modified_left
, modified_top
);
9802 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
9803 FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
);
9805 /* change_gravity is non-zero when this function is called from Lisp to
9806 programmatically move a frame. In that case, we call
9807 x_check_expected_move to discover if we have a "Type A" or "Type B"
9808 window manager, and, for a "Type A" window manager, adjust the position
9811 We call x_check_expected_move if a programmatic move occurred, and
9812 either the window manager type (A/B) is unknown or it is Type A but we
9813 need to compute the top/left offset adjustment for this frame. */
9815 if (change_gravity
!= 0
9816 && (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
9817 || (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
9818 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
9819 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
9820 x_check_expected_move (f
, modified_left
, modified_top
);
9825 /* Return true if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
9826 on the root window for frame F contains ATOMNAME.
9827 This is how a WM check shall be done according to the Window Manager
9828 Specification/Extended Window Manager Hints at
9829 http://freedesktop.org/wiki/Specifications/wm-spec. */
9832 x_wm_supports (struct frame
*f
, Atom want_atom
)
9835 unsigned long actual_size
, bytes_remaining
;
9836 int i
, rc
, actual_format
;
9838 Window wmcheck_window
;
9839 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9840 Window target_window
= dpyinfo
->root_window
;
9841 int max_len
= 65536;
9842 Display
*dpy
= FRAME_X_DISPLAY (f
);
9843 unsigned char *tmp_data
= NULL
;
9844 Atom target_type
= XA_WINDOW
;
9848 x_catch_errors (dpy
);
9849 rc
= XGetWindowProperty (dpy
, target_window
,
9850 dpyinfo
->Xatom_net_supporting_wm_check
,
9851 0, max_len
, False
, target_type
,
9852 &actual_type
, &actual_format
, &actual_size
,
9853 &bytes_remaining
, &tmp_data
);
9855 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
9857 if (tmp_data
) XFree (tmp_data
);
9858 x_uncatch_errors ();
9863 wmcheck_window
= *(Window
*) tmp_data
;
9866 /* Check if window exists. */
9867 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
9869 if (x_had_errors_p (dpy
))
9871 x_uncatch_errors ();
9876 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
9878 /* Window changed, reload atoms */
9879 if (dpyinfo
->net_supported_atoms
!= NULL
)
9880 XFree (dpyinfo
->net_supported_atoms
);
9881 dpyinfo
->net_supported_atoms
= NULL
;
9882 dpyinfo
->nr_net_supported_atoms
= 0;
9883 dpyinfo
->net_supported_window
= 0;
9885 target_type
= XA_ATOM
;
9887 rc
= XGetWindowProperty (dpy
, target_window
,
9888 dpyinfo
->Xatom_net_supported
,
9889 0, max_len
, False
, target_type
,
9890 &actual_type
, &actual_format
, &actual_size
,
9891 &bytes_remaining
, &tmp_data
);
9893 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
9895 if (tmp_data
) XFree (tmp_data
);
9896 x_uncatch_errors ();
9901 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
9902 dpyinfo
->nr_net_supported_atoms
= actual_size
;
9903 dpyinfo
->net_supported_window
= wmcheck_window
;
9908 for (i
= 0; !ret
&& i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
9909 ret
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
9911 x_uncatch_errors ();
9918 set_wm_state (Lisp_Object frame
, bool add
, Atom atom
, Atom value
)
9920 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (XFRAME (frame
));
9922 x_send_client_event (frame
, make_number (0), frame
,
9923 dpyinfo
->Xatom_net_wm_state
,
9925 /* 1 = add, 0 = remove */
9929 (make_fixnum_or_float (atom
),
9931 ? list1 (make_fixnum_or_float (value
))
9936 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
9939 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9941 XSETFRAME (frame
, f
);
9943 set_wm_state (frame
, !NILP (new_value
),
9944 dpyinfo
->Xatom_net_wm_state_sticky
, None
);
9947 /* Return the current _NET_WM_STATE.
9948 SIZE_STATE is set to one of the FULLSCREEN_* values.
9949 Set *STICKY to the sticky state.
9951 Return true iff we are not hidden. */
9954 get_current_wm_state (struct frame
*f
,
9960 unsigned long actual_size
, bytes_remaining
;
9961 int i
, rc
, actual_format
;
9962 bool is_hidden
= false;
9963 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9964 long max_len
= 65536;
9965 Display
*dpy
= FRAME_X_DISPLAY (f
);
9966 unsigned char *tmp_data
= NULL
;
9967 Atom target_type
= XA_ATOM
;
9970 *size_state
= FULLSCREEN_NONE
;
9973 x_catch_errors (dpy
);
9974 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
9975 0, max_len
, False
, target_type
,
9976 &actual_type
, &actual_format
, &actual_size
,
9977 &bytes_remaining
, &tmp_data
);
9979 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
9981 if (tmp_data
) XFree (tmp_data
);
9982 x_uncatch_errors ();
9984 return !FRAME_ICONIFIED_P (f
);
9987 x_uncatch_errors ();
9989 for (i
= 0; i
< actual_size
; ++i
)
9991 Atom a
= ((Atom
*)tmp_data
)[i
];
9992 if (a
== dpyinfo
->Xatom_net_wm_state_hidden
)
9994 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
9996 if (*size_state
== FULLSCREEN_HEIGHT
)
9997 *size_state
= FULLSCREEN_MAXIMIZED
;
9999 *size_state
= FULLSCREEN_WIDTH
;
10001 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
10003 if (*size_state
== FULLSCREEN_WIDTH
)
10004 *size_state
= FULLSCREEN_MAXIMIZED
;
10006 *size_state
= FULLSCREEN_HEIGHT
;
10008 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen
)
10009 *size_state
= FULLSCREEN_BOTH
;
10010 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
10014 if (tmp_data
) XFree (tmp_data
);
10016 return ! is_hidden
;
10019 /* Do fullscreen as specified in extended window manager hints */
10022 do_ewmh_fullscreen (struct frame
*f
)
10024 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10025 bool have_net_atom
= x_wm_supports (f
, dpyinfo
->Xatom_net_wm_state
);
10029 get_current_wm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
10031 /* Some window managers don't say they support _NET_WM_STATE, but they do say
10032 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
10033 if (!have_net_atom
)
10034 have_net_atom
= x_wm_supports (f
, dpyinfo
->Xatom_net_wm_state_fullscreen
);
10036 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
10040 XSETFRAME (frame
, f
);
10042 /* Keep number of calls to set_wm_state as low as possible.
10043 Some window managers, or possible Gtk+, hangs when too many
10044 are sent at once. */
10045 switch (f
->want_fullscreen
)
10047 case FULLSCREEN_BOTH
:
10048 if (cur
!= FULLSCREEN_BOTH
)
10049 set_wm_state (frame
, true, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10052 case FULLSCREEN_WIDTH
:
10053 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_MAXIMIZED
)
10055 set_wm_state (frame
, false,
10056 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10057 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10058 set_wm_state (frame
, true,
10059 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10063 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
10064 || cur
== FULLSCREEN_MAXIMIZED
)
10065 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10066 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10067 if (cur
!= FULLSCREEN_MAXIMIZED
|| x_frame_normalize_before_maximize
)
10068 set_wm_state (frame
, true,
10069 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10072 case FULLSCREEN_HEIGHT
:
10073 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_MAXIMIZED
)
10075 set_wm_state (frame
, false,
10076 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10077 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10078 set_wm_state (frame
, true,
10079 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
10083 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
10084 || cur
== FULLSCREEN_MAXIMIZED
)
10085 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10086 dpyinfo
->Xatom_net_wm_state_maximized_horz
);
10087 if (cur
!= FULLSCREEN_MAXIMIZED
|| x_frame_normalize_before_maximize
)
10088 set_wm_state (frame
, true,
10089 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
10092 case FULLSCREEN_MAXIMIZED
:
10093 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_BOTH
)
10095 set_wm_state (frame
, false,
10096 dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
10097 set_wm_state (frame
, true,
10098 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10099 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10101 else if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_WIDTH
)
10103 set_wm_state (frame
, false,
10104 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10105 set_wm_state (frame
, true,
10106 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10107 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10109 else if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_HEIGHT
)
10111 set_wm_state (frame
, false,
10112 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
10113 set_wm_state (frame
, true,
10114 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10115 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10119 if (cur
== FULLSCREEN_BOTH
)
10120 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10122 else if (cur
== FULLSCREEN_HEIGHT
)
10123 set_wm_state (frame
, true,
10124 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10125 else if (cur
== FULLSCREEN_WIDTH
)
10126 set_wm_state (frame
, true, None
,
10127 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10129 set_wm_state (frame
, true,
10130 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10131 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10134 case FULLSCREEN_NONE
:
10135 if (cur
== FULLSCREEN_BOTH
)
10136 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10139 set_wm_state (frame
, false,
10140 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10141 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10144 f
->want_fullscreen
= FULLSCREEN_NONE
;
10148 return have_net_atom
;
10152 XTfullscreen_hook (struct frame
*f
)
10154 if (FRAME_VISIBLE_P (f
))
10157 x_check_fullscreen (f
);
10165 x_handle_net_wm_state (struct frame
*f
, const XPropertyEvent
*event
)
10167 int value
= FULLSCREEN_NONE
;
10169 bool sticky
= false;
10170 bool not_hidden
= get_current_wm_state (f
, event
->window
, &value
, &sticky
);
10175 case FULLSCREEN_WIDTH
:
10178 case FULLSCREEN_HEIGHT
:
10179 lval
= Qfullheight
;
10181 case FULLSCREEN_BOTH
:
10184 case FULLSCREEN_MAXIMIZED
:
10189 frame_size_history_add
10190 (f
, Qx_handle_net_wm_state
, 0, 0,
10191 list2 (get_frame_param (f
, Qfullscreen
), lval
));
10193 store_frame_param (f
, Qfullscreen
, lval
);
10194 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
10199 /* Check if we need to resize the frame due to a fullscreen request.
10200 If so needed, resize the frame. */
10202 x_check_fullscreen (struct frame
*f
)
10204 Lisp_Object lval
= Qnil
;
10206 if (do_ewmh_fullscreen (f
))
10209 if (f
->output_data
.x
->parent_desc
!= FRAME_DISPLAY_INFO (f
)->root_window
)
10210 return; /* Only fullscreen without WM or with EWM hints (above). */
10212 /* Setting fullscreen to nil doesn't do anything. We could save the
10213 last non-fullscreen size and restore it, but it seems like a
10214 lot of work for this unusual case (no window manager running). */
10216 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
10218 int width
= FRAME_PIXEL_WIDTH (f
), height
= FRAME_PIXEL_HEIGHT (f
);
10219 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10221 switch (f
->want_fullscreen
)
10223 /* No difference between these two when there is no WM */
10224 case FULLSCREEN_MAXIMIZED
:
10226 width
= x_display_pixel_width (dpyinfo
);
10227 height
= x_display_pixel_height (dpyinfo
);
10229 case FULLSCREEN_BOTH
:
10231 width
= x_display_pixel_width (dpyinfo
);
10232 height
= x_display_pixel_height (dpyinfo
);
10234 case FULLSCREEN_WIDTH
:
10236 width
= x_display_pixel_width (dpyinfo
);
10237 height
= height
+ FRAME_MENUBAR_HEIGHT (f
);
10239 case FULLSCREEN_HEIGHT
:
10240 lval
= Qfullheight
;
10241 height
= x_display_pixel_height (dpyinfo
);
10247 frame_size_history_add
10248 (f
, Qx_check_fullscreen
, width
, height
, Qnil
);
10250 x_wm_set_size_hint (f
, 0, false);
10252 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10255 if (FRAME_VISIBLE_P (f
))
10256 x_wait_for_event (f
, ConfigureNotify
);
10259 change_frame_size (f
, width
, height
- FRAME_MENUBAR_HEIGHT (f
),
10260 false, true, false, true);
10265 /* `x_net_wm_state' might have reset the fullscreen frame parameter,
10267 store_frame_param (f
, Qfullscreen
, lval
);
10270 /* This function is called by x_set_offset to determine whether the window
10271 manager interfered with the positioning of the frame. Type A window
10272 managers position the surrounding window manager decorations a small
10273 amount above and left of the user-supplied position. Type B window
10274 managers position the surrounding window manager decorations at the
10275 user-specified position. If we detect a Type A window manager, we
10276 compensate by moving the window right and down by the proper amount. */
10279 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
10281 int current_left
= 0, current_top
= 0;
10283 /* x_real_positions returns the left and top offsets of the outermost
10284 window manager window around the frame. */
10286 x_real_positions (f
, ¤t_left
, ¤t_top
);
10288 if (current_left
!= expected_left
|| current_top
!= expected_top
)
10290 /* It's a "Type A" window manager. */
10295 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
10296 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
10297 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
10299 /* Now fix the mispositioned frame's location. */
10301 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
10302 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
10304 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10305 adjusted_left
, adjusted_top
);
10307 x_sync_with_move (f
, expected_left
, expected_top
, false);
10310 /* It's a "Type B" window manager. We don't have to adjust the
10311 frame's position. */
10313 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
10317 /* Wait for XGetGeometry to return up-to-date position information for a
10318 recently-moved frame. Call this immediately after calling XMoveWindow.
10319 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
10320 frame has been moved to, so we use a fuzzy position comparison instead
10321 of an exact comparison. */
10324 x_sync_with_move (struct frame
*f
, int left
, int top
, bool fuzzy
)
10328 while (count
++ < 50)
10330 int current_left
= 0, current_top
= 0;
10332 /* In theory, this call to XSync only needs to happen once, but in
10333 practice, it doesn't seem to work, hence the need for the surrounding
10336 XSync (FRAME_X_DISPLAY (f
), False
);
10337 x_real_positions (f
, ¤t_left
, ¤t_top
);
10341 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
10344 if (eabs (current_left
- left
) <= 10
10345 && eabs (current_top
- top
) <= 40)
10348 else if (current_left
== left
&& current_top
== top
)
10352 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
10353 will then return up-to-date position info. */
10355 wait_reading_process_output (0, 500000000, 0, false, Qnil
, NULL
, 0);
10359 /* Wait for an event on frame F matching EVENTTYPE. */
10361 x_wait_for_event (struct frame
*f
, int eventtype
)
10363 int level
= interrupt_input_blocked
;
10366 struct timespec tmo
, tmo_at
, time_now
;
10367 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
10369 f
->wait_event_type
= eventtype
;
10371 /* Set timeout to 0.1 second. Hopefully not noticeable.
10372 Maybe it should be configurable. */
10373 tmo
= make_timespec (0, 100 * 1000 * 1000);
10374 tmo_at
= timespec_add (current_timespec (), tmo
);
10376 while (f
->wait_event_type
)
10378 pending_signals
= true;
10379 totally_unblock_input ();
10380 /* XTread_socket is called after unblock. */
10382 interrupt_input_blocked
= level
;
10387 time_now
= current_timespec ();
10388 if (timespec_cmp (tmo_at
, time_now
) < 0)
10391 tmo
= timespec_sub (tmo_at
, time_now
);
10392 if (pselect (fd
+ 1, &fds
, NULL
, NULL
, &tmo
, NULL
) == 0)
10393 break; /* Timeout */
10396 f
->wait_event_type
= 0;
10400 /* Change the size of frame F's X window to WIDTH/HEIGHT in the case F
10401 doesn't have a widget. If CHANGE_GRAVITY, change to
10402 top-left-corner window gravity for this size change and subsequent
10403 size changes. Otherwise leave the window gravity unchanged. */
10406 x_set_window_size_1 (struct frame
*f
, bool change_gravity
,
10407 int width
, int height
)
10409 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
10410 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
10411 int old_width
= FRAME_PIXEL_WIDTH (f
);
10412 int old_height
= FRAME_PIXEL_HEIGHT (f
);
10413 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
10415 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
10416 x_wm_set_size_hint (f
, 0, false);
10418 /* When the frame is fullheight and we only want to change the width
10419 or it is fullwidth and we only want to change the height we should
10420 be able to preserve the fullscreen property. However, due to the
10421 fact that we have to send a resize request anyway, the window
10422 manager will abolish it. At least the respective size should
10423 remain unchanged but giving the frame back its normal size will
10425 if (EQ (fullscreen
, Qfullwidth
) && width
== FRAME_TEXT_WIDTH (f
))
10427 frame_size_history_add
10428 (f
, Qxg_frame_set_char_size_1
, width
, height
,
10429 list2 (make_number (old_height
),
10430 make_number (pixelheight
+ FRAME_MENUBAR_HEIGHT (f
))));
10432 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10433 old_width
, pixelheight
+ FRAME_MENUBAR_HEIGHT (f
));
10435 else if (EQ (fullscreen
, Qfullheight
) && height
== FRAME_TEXT_HEIGHT (f
))
10437 frame_size_history_add
10438 (f
, Qxg_frame_set_char_size_2
, width
, height
,
10439 list2 (make_number (old_width
), make_number (pixelwidth
)));
10441 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10442 pixelwidth
, old_height
);
10447 frame_size_history_add
10448 (f
, Qxg_frame_set_char_size_3
, width
, height
,
10449 list2 (make_number (pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
)),
10450 make_number (pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
10451 + FRAME_MENUBAR_HEIGHT (f
))));
10453 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10454 pixelwidth
, pixelheight
+ FRAME_MENUBAR_HEIGHT (f
));
10460 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
10461 receive in the ConfigureNotify event; if we get what we asked
10462 for, then the event won't cause the screen to become garbaged, so
10463 we have to make sure to do it here. */
10464 SET_FRAME_GARBAGED (f
);
10466 /* Now, strictly speaking, we can't be sure that this is accurate,
10467 but the window manager will get around to dealing with the size
10468 change request eventually, and we'll hear how it went when the
10469 ConfigureNotify event gets here.
10471 We could just not bother storing any of this information here,
10472 and let the ConfigureNotify event set everything up, but that
10473 might be kind of confusing to the Lisp code, since size changes
10474 wouldn't be reported in the frame parameters until some random
10475 point in the future when the ConfigureNotify event arrives.
10477 Pass true for DELAY since we can't run Lisp code inside of
10480 /* But the ConfigureNotify may in fact never arrive, and then this is
10481 not right if the frame is visible. Instead wait (with timeout)
10482 for the ConfigureNotify. */
10483 if (FRAME_VISIBLE_P (f
))
10485 x_wait_for_event (f
, ConfigureNotify
);
10487 if (!NILP (fullscreen
))
10488 /* Try to restore fullscreen state. */
10490 store_frame_param (f
, Qfullscreen
, fullscreen
);
10491 x_set_fullscreen (f
, fullscreen
, fullscreen
);
10496 change_frame_size (f
, width
, height
, false, true, false, true);
10502 /* Call this to change the size of frame F's x-window.
10503 If CHANGE_GRAVITY, change to top-left-corner window gravity
10504 for this size change and subsequent size changes.
10505 Otherwise we leave the window gravity unchanged. */
10508 x_set_window_size (struct frame
*f
, bool change_gravity
,
10509 int width
, int height
, bool pixelwise
)
10513 /* The following breaks our calculations. If it's really needed,
10514 think of something else. */
10516 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
10518 int text_width
, text_height
;
10520 /* When the frame is maximized/fullscreen or running under for
10521 example Xmonad, x_set_window_size_1 will be a no-op.
10522 In that case, the right thing to do is extend rows/width to
10523 the current frame size. We do that first if x_set_window_size_1
10524 turns out to not be a no-op (there is no way to know).
10525 The size will be adjusted again if the frame gets a
10526 ConfigureNotify event as a result of x_set_window_size. */
10527 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
10528 #ifdef USE_X_TOOLKIT
10529 /* The menu bar is not part of text lines. The tool bar
10531 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
10533 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, FRAME_PIXEL_WIDTH (f
));
10534 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelh
);
10536 change_frame_size (f
, text_width
, text_height
, false, true, false, true);
10540 /* Pixelize width and height, if necessary. */
10543 width
= width
* FRAME_COLUMN_WIDTH (f
);
10544 height
= height
* FRAME_LINE_HEIGHT (f
);
10548 if (FRAME_GTK_WIDGET (f
))
10549 xg_frame_set_char_size (f
, width
, height
);
10551 x_set_window_size_1 (f
, change_gravity
, width
, height
);
10552 #else /* not USE_GTK */
10553 x_set_window_size_1 (f
, change_gravity
, width
, height
);
10554 x_clear_under_internal_border (f
);
10555 #endif /* not USE_GTK */
10557 /* If cursor was outside the new size, mark it as off. */
10558 mark_window_cursors_off (XWINDOW (f
->root_window
));
10560 /* Clear out any recollection of where the mouse highlighting was,
10561 since it might be in a place that's outside the new frame size.
10562 Actually checking whether it is outside is a pain in the neck,
10563 so don't try--just let the highlighting be done afresh with new size. */
10564 cancel_mouse_face (f
);
10569 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
10572 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
10576 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
10577 0, 0, 0, 0, pix_x
, pix_y
);
10581 /* Raise frame F. */
10584 x_raise_frame (struct frame
*f
)
10587 if (FRAME_VISIBLE_P (f
))
10588 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
10589 XFlush (FRAME_X_DISPLAY (f
));
10593 /* Lower frame F. */
10596 x_lower_frame (struct frame
*f
)
10598 if (FRAME_VISIBLE_P (f
))
10601 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
10602 XFlush (FRAME_X_DISPLAY (f
));
10607 /* Request focus with XEmbed */
10610 xembed_request_focus (struct frame
*f
)
10612 /* See XEmbed Protocol Specification at
10613 http://freedesktop.org/wiki/Specifications/xembed-spec */
10614 if (FRAME_VISIBLE_P (f
))
10615 xembed_send_message (f
, CurrentTime
,
10616 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
10619 /* Activate frame with Extended Window Manager Hints */
10622 x_ewmh_activate_frame (struct frame
*f
)
10624 /* See Window Manager Specification/Extended Window Manager Hints at
10625 http://freedesktop.org/wiki/Specifications/wm-spec */
10627 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10629 if (FRAME_VISIBLE_P (f
) && x_wm_supports (f
, dpyinfo
->Xatom_net_active_window
))
10632 XSETFRAME (frame
, f
);
10633 x_send_client_event (frame
, make_number (0), frame
,
10634 dpyinfo
->Xatom_net_active_window
,
10636 list2i (1, dpyinfo
->last_user_time
));
10641 XTframe_raise_lower (struct frame
*f
, bool raise_flag
)
10649 /* XEmbed implementation. */
10651 #if defined USE_X_TOOLKIT || ! defined USE_GTK
10653 /* XEmbed implementation. */
10655 #define XEMBED_VERSION 0
10658 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
10660 unsigned long data
[2];
10661 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10663 data
[0] = XEMBED_VERSION
;
10666 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10667 dpyinfo
->Xatom_XEMBED_INFO
, dpyinfo
->Xatom_XEMBED_INFO
,
10668 32, PropModeReplace
, (unsigned char *) data
, 2);
10670 #endif /* defined USE_X_TOOLKIT || ! defined USE_GTK */
10673 xembed_send_message (struct frame
*f
, Time t
, enum xembed_message msg
,
10674 long int detail
, long int data1
, long int data2
)
10678 event
.xclient
.type
= ClientMessage
;
10679 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
10680 event
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_XEMBED
;
10681 event
.xclient
.format
= 32;
10682 event
.xclient
.data
.l
[0] = t
;
10683 event
.xclient
.data
.l
[1] = msg
;
10684 event
.xclient
.data
.l
[2] = detail
;
10685 event
.xclient
.data
.l
[3] = data1
;
10686 event
.xclient
.data
.l
[4] = data2
;
10688 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
10689 False
, NoEventMask
, &event
);
10690 XSync (FRAME_X_DISPLAY (f
), False
);
10693 /* Change of visibility. */
10695 /* This tries to wait until the frame is really visible.
10696 However, if the window manager asks the user where to position
10697 the frame, this will return before the user finishes doing that.
10698 The frame will not actually be visible at that time,
10699 but it will become visible later when the window manager
10700 finishes with it. */
10703 x_make_frame_visible (struct frame
*f
)
10705 int original_top
, original_left
;
10710 x_set_bitmap_icon (f
);
10712 if (! FRAME_VISIBLE_P (f
))
10714 /* We test FRAME_GARBAGED_P here to make sure we don't
10715 call x_set_offset a second time
10716 if we get to x_make_frame_visible a second time
10717 before the window gets really visible. */
10718 if (! FRAME_ICONIFIED_P (f
)
10719 && ! FRAME_X_EMBEDDED_P (f
)
10720 && ! f
->output_data
.x
->asked_for_visible
)
10721 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
10723 f
->output_data
.x
->asked_for_visible
= true;
10725 if (! EQ (Vx_no_window_manager
, Qt
))
10726 x_wm_set_window_state (f
, NormalState
);
10727 #ifdef USE_X_TOOLKIT
10728 if (FRAME_X_EMBEDDED_P (f
))
10729 xembed_set_info (f
, XEMBED_MAPPED
);
10732 /* This was XtPopup, but that did nothing for an iconified frame. */
10733 XtMapWidget (f
->output_data
.x
->widget
);
10735 #else /* not USE_X_TOOLKIT */
10737 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
10738 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
10740 if (FRAME_X_EMBEDDED_P (f
))
10741 xembed_set_info (f
, XEMBED_MAPPED
);
10743 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10744 #endif /* not USE_GTK */
10745 #endif /* not USE_X_TOOLKIT */
10748 XFlush (FRAME_X_DISPLAY (f
));
10750 /* Synchronize to ensure Emacs knows the frame is visible
10751 before we do anything else. We do this loop with input not blocked
10752 so that incoming events are handled. */
10755 /* This must be before UNBLOCK_INPUT
10756 since events that arrive in response to the actions above
10757 will set it when they are handled. */
10758 bool previously_visible
= f
->output_data
.x
->has_been_visible
;
10760 original_left
= f
->left_pos
;
10761 original_top
= f
->top_pos
;
10763 /* This must come after we set COUNT. */
10766 /* We unblock here so that arriving X events are processed. */
10768 /* Now move the window back to where it was "supposed to be".
10769 But don't do it if the gravity is negative.
10770 When the gravity is negative, this uses a position
10771 that is 3 pixels too low. Perhaps that's really the border width.
10773 Don't do this if the window has never been visible before,
10774 because the window manager may choose the position
10775 and we don't want to override it. */
10777 if (! FRAME_VISIBLE_P (f
)
10778 && ! FRAME_ICONIFIED_P (f
)
10779 && ! FRAME_X_EMBEDDED_P (f
)
10780 && f
->win_gravity
== NorthWestGravity
10781 && previously_visible
)
10785 unsigned int width
, height
, border
, depth
;
10789 /* On some window managers (such as FVWM) moving an existing
10790 window, even to the same place, causes the window manager
10791 to introduce an offset. This can cause the window to move
10792 to an unexpected location. Check the geometry (a little
10793 slow here) and then verify that the window is in the right
10794 place. If the window is not in the right place, move it
10795 there, and take the potential window manager hit. */
10796 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10797 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
10799 if (original_left
!= x
|| original_top
!= y
)
10800 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10801 original_left
, original_top
);
10806 XSETFRAME (frame
, f
);
10808 /* Process X events until a MapNotify event has been seen. */
10809 while (!FRAME_VISIBLE_P (f
))
10811 /* Force processing of queued events. */
10814 /* If on another desktop, the deiconify/map may be ignored and the
10815 frame never becomes visible. XMonad does this.
10816 Prevent an endless loop. */
10817 if (FRAME_ICONIFIED_P (f
) && ++tries
> 100)
10820 /* This hack is still in use at least for Cygwin. See
10821 http://lists.gnu.org/archive/html/emacs-devel/2013-12/msg00351.html.
10823 Machines that do polling rather than SIGIO have been
10824 observed to go into a busy-wait here. So we'll fake an
10825 alarm signal to let the handler know that there's something
10826 to be read. We used to raise a real alarm, but it seems
10827 that the handler isn't always enabled here. This is
10829 if (input_polling_used ())
10831 /* It could be confusing if a real alarm arrives while
10832 processing the fake one. Turn it off and let the
10833 handler reset it. */
10834 int old_poll_suppress_count
= poll_suppress_count
;
10835 poll_suppress_count
= 1;
10836 poll_for_input_1 ();
10837 poll_suppress_count
= old_poll_suppress_count
;
10840 if (XPending (FRAME_X_DISPLAY (f
)))
10843 XNextEvent (FRAME_X_DISPLAY (f
), &xev
);
10844 x_dispatch_event (&xev
, FRAME_X_DISPLAY (f
));
10850 /* Change from mapped state to withdrawn state. */
10852 /* Make the frame visible (mapped and not iconified). */
10855 x_make_frame_invisible (struct frame
*f
)
10859 /* Use the frame's outermost window, not the one we normally draw on. */
10860 window
= FRAME_OUTER_WINDOW (f
);
10862 /* Don't keep the highlight on an invisible frame. */
10863 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
10864 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
10868 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
10869 that the current position of the window is user-specified, rather than
10870 program-specified, so that when the window is mapped again, it will be
10871 placed at the same location, without forcing the user to position it
10872 by hand again (they have already done that once for this window.) */
10873 x_wm_set_size_hint (f
, 0, true);
10876 if (FRAME_GTK_OUTER_WIDGET (f
))
10877 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
10880 if (FRAME_X_EMBEDDED_P (f
))
10881 xembed_set_info (f
, 0);
10886 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
10887 DefaultScreen (FRAME_X_DISPLAY (f
))))
10890 error ("Can't notify window manager of window withdrawal");
10894 /* We can't distinguish this from iconification
10895 just by the event that we get from the server.
10896 So we can't win using the usual strategy of letting
10897 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
10898 and synchronize with the server to make sure we agree. */
10899 SET_FRAME_VISIBLE (f
, 0);
10900 SET_FRAME_ICONIFIED (f
, false);
10907 /* Change window state from mapped to iconified. */
10910 x_iconify_frame (struct frame
*f
)
10912 #ifdef USE_X_TOOLKIT
10916 /* Don't keep the highlight on an invisible frame. */
10917 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
10918 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
10920 if (FRAME_ICONIFIED_P (f
))
10925 x_set_bitmap_icon (f
);
10927 #if defined (USE_GTK)
10928 if (FRAME_GTK_OUTER_WIDGET (f
))
10930 if (! FRAME_VISIBLE_P (f
))
10931 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
10933 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
10934 SET_FRAME_VISIBLE (f
, 0);
10935 SET_FRAME_ICONIFIED (f
, true);
10941 #ifdef USE_X_TOOLKIT
10943 if (! FRAME_VISIBLE_P (f
))
10945 if (! EQ (Vx_no_window_manager
, Qt
))
10946 x_wm_set_window_state (f
, IconicState
);
10947 /* This was XtPopup, but that did nothing for an iconified frame. */
10948 XtMapWidget (f
->output_data
.x
->widget
);
10949 /* The server won't give us any event to indicate
10950 that an invisible frame was changed to an icon,
10951 so we have to record it here. */
10952 SET_FRAME_VISIBLE (f
, 0);
10953 SET_FRAME_ICONIFIED (f
, true);
10958 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
10959 XtWindow (f
->output_data
.x
->widget
),
10960 DefaultScreen (FRAME_X_DISPLAY (f
)));
10964 error ("Can't notify window manager of iconification");
10966 SET_FRAME_ICONIFIED (f
, true);
10967 SET_FRAME_VISIBLE (f
, 0);
10970 XFlush (FRAME_X_DISPLAY (f
));
10972 #else /* not USE_X_TOOLKIT */
10974 /* Make sure the X server knows where the window should be positioned,
10975 in case the user deiconifies with the window manager. */
10976 if (! FRAME_VISIBLE_P (f
)
10977 && ! FRAME_ICONIFIED_P (f
)
10978 && ! FRAME_X_EMBEDDED_P (f
))
10979 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
10981 /* Since we don't know which revision of X we're running, we'll use both
10982 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
10984 /* X11R4: send a ClientMessage to the window manager using the
10985 WM_CHANGE_STATE type. */
10989 msg
.xclient
.window
= FRAME_X_WINDOW (f
);
10990 msg
.xclient
.type
= ClientMessage
;
10991 msg
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
10992 msg
.xclient
.format
= 32;
10993 msg
.xclient
.data
.l
[0] = IconicState
;
10995 if (! XSendEvent (FRAME_X_DISPLAY (f
),
10996 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
10998 SubstructureRedirectMask
| SubstructureNotifyMask
,
11002 error ("Can't notify window manager of iconification");
11006 /* X11R3: set the initial_state field of the window manager hints to
11008 x_wm_set_window_state (f
, IconicState
);
11010 if (!FRAME_VISIBLE_P (f
))
11012 /* If the frame was withdrawn, before, we must map it. */
11013 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11016 SET_FRAME_ICONIFIED (f
, true);
11017 SET_FRAME_VISIBLE (f
, 0);
11019 XFlush (FRAME_X_DISPLAY (f
));
11021 #endif /* not USE_X_TOOLKIT */
11025 /* Free X resources of frame F. */
11028 x_free_frame_resources (struct frame
*f
)
11030 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
11031 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
11032 #ifdef USE_X_TOOLKIT
11034 struct scroll_bar
*b
;
11039 /* If a display connection is dead, don't try sending more
11040 commands to the X server. */
11041 if (dpyinfo
->display
)
11043 /* Always exit with visible pointer to avoid weird issue
11044 with Xfixes (Bug#17609). */
11045 if (f
->pointer_invisible
)
11046 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, 0);
11048 /* We must free faces before destroying windows because some
11049 font-driver (e.g. xft) access a window while finishing a
11051 free_frame_faces (f
);
11053 if (f
->output_data
.x
->icon_desc
)
11054 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
11056 #ifdef USE_X_TOOLKIT
11057 /* Explicitly destroy the scroll bars of the frame. Without
11058 this, we get "BadDrawable" errors from the toolkit later on,
11059 presumably from expose events generated for the disappearing
11060 toolkit scroll bars. */
11061 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
11063 b
= XSCROLL_BAR (bar
);
11064 x_scroll_bar_remove (b
);
11070 free_frame_xic (f
);
11073 x_free_cr_resources (f
);
11074 #ifdef USE_X_TOOLKIT
11075 if (f
->output_data
.x
->widget
)
11077 XtDestroyWidget (f
->output_data
.x
->widget
);
11078 f
->output_data
.x
->widget
= NULL
;
11080 /* Tooltips don't have widgets, only a simple X window, even if
11081 we are using a toolkit. */
11082 else if (FRAME_X_WINDOW (f
))
11083 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11085 free_frame_menubar (f
);
11087 if (f
->shell_position
)
11088 xfree (f
->shell_position
);
11089 #else /* !USE_X_TOOLKIT */
11092 xg_free_frame_widgets (f
);
11093 #endif /* USE_GTK */
11095 if (FRAME_X_WINDOW (f
))
11096 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11097 #endif /* !USE_X_TOOLKIT */
11099 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
11100 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
11101 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
11102 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
11103 unload_color (f
, f
->output_data
.x
->border_pixel
);
11104 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
11106 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
11107 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
11108 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
11109 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
11110 #if defined (USE_LUCID) && defined (USE_TOOLKIT_SCROLL_BARS)
11111 /* Scrollbar shadow colors. */
11112 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
11113 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
11114 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
11115 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
11116 #endif /* USE_LUCID && USE_TOOLKIT_SCROLL_BARS */
11117 if (f
->output_data
.x
->white_relief
.pixel
!= -1)
11118 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
11119 if (f
->output_data
.x
->black_relief
.pixel
!= -1)
11120 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
11124 /* Free extra GCs allocated by x_setup_relief_colors. */
11125 if (f
->output_data
.x
->white_relief
.gc
)
11127 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->white_relief
.gc
);
11128 f
->output_data
.x
->white_relief
.gc
= 0;
11130 if (f
->output_data
.x
->black_relief
.gc
)
11132 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->black_relief
.gc
);
11133 f
->output_data
.x
->black_relief
.gc
= 0;
11136 /* Free cursors. */
11137 if (f
->output_data
.x
->text_cursor
!= 0)
11138 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->text_cursor
);
11139 if (f
->output_data
.x
->nontext_cursor
!= 0)
11140 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->nontext_cursor
);
11141 if (f
->output_data
.x
->modeline_cursor
!= 0)
11142 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->modeline_cursor
);
11143 if (f
->output_data
.x
->hand_cursor
!= 0)
11144 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hand_cursor
);
11145 if (f
->output_data
.x
->hourglass_cursor
!= 0)
11146 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hourglass_cursor
);
11147 if (f
->output_data
.x
->horizontal_drag_cursor
!= 0)
11148 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->horizontal_drag_cursor
);
11149 if (f
->output_data
.x
->vertical_drag_cursor
!= 0)
11150 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->vertical_drag_cursor
);
11152 XFlush (FRAME_X_DISPLAY (f
));
11155 xfree (f
->output_data
.x
->saved_menu_event
);
11156 xfree (f
->output_data
.x
);
11157 f
->output_data
.x
= NULL
;
11159 if (f
== dpyinfo
->x_focus_frame
)
11160 dpyinfo
->x_focus_frame
= 0;
11161 if (f
== dpyinfo
->x_focus_event_frame
)
11162 dpyinfo
->x_focus_event_frame
= 0;
11163 if (f
== dpyinfo
->x_highlight_frame
)
11164 dpyinfo
->x_highlight_frame
= 0;
11165 if (f
== hlinfo
->mouse_face_mouse_frame
)
11166 reset_mouse_highlight (hlinfo
);
11172 /* Destroy the X window of frame F. */
11175 x_destroy_window (struct frame
*f
)
11177 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
11179 /* If a display connection is dead, don't try sending more
11180 commands to the X server. */
11181 if (dpyinfo
->display
!= 0)
11182 x_free_frame_resources (f
);
11184 dpyinfo
->reference_count
--;
11188 /* Setting window manager hints. */
11190 /* Set the normal size hints for the window manager, for frame F.
11191 FLAGS is the flags word to use--or 0 meaning preserve the flags
11192 that the window now has.
11193 If USER_POSITION, set the USPosition
11194 flag (this is useful when FLAGS is 0).
11195 The GTK version is in gtkutils.c. */
11199 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
11201 XSizeHints size_hints
;
11202 Window window
= FRAME_OUTER_WINDOW (f
);
11207 #ifdef USE_X_TOOLKIT
11208 if (f
->output_data
.x
->widget
)
11210 widget_update_wm_size_hints (f
->output_data
.x
->widget
);
11215 /* Setting PMaxSize caused various problems. */
11216 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
11218 size_hints
.x
= f
->left_pos
;
11219 size_hints
.y
= f
->top_pos
;
11221 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
11222 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
11224 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
11225 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
11227 size_hints
.max_width
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
11228 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
11229 size_hints
.max_height
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
11230 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
11232 /* Calculate the base and minimum sizes. */
11234 int base_width
, base_height
;
11235 int min_rows
= 0, min_cols
= 0;
11237 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
11238 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
11240 if (frame_resize_pixelwise
)
11241 /* Needed to prevent a bad protocol error crash when making the
11242 frame size very small. */
11244 min_cols
= 2 * min_cols
;
11245 min_rows
= 2 * min_rows
;
11248 /* The window manager uses the base width hints to calculate the
11249 current number of rows and columns in the frame while
11250 resizing; min_width and min_height aren't useful for this
11251 purpose, since they might not give the dimensions for a
11252 zero-row, zero-column frame.
11254 We use the base_width and base_height members if we have
11255 them; otherwise, we set the min_width and min_height members
11256 to the size for a zero x zero frame. */
11258 size_hints
.flags
|= PBaseSize
;
11259 size_hints
.base_width
= base_width
;
11260 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
11261 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
11262 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
11265 /* If we don't need the old flags, we don't need the old hint at all. */
11268 size_hints
.flags
|= flags
;
11273 XSizeHints hints
; /* Sometimes I hate X Windows... */
11274 long supplied_return
;
11277 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
11281 size_hints
.flags
|= flags
;
11286 if (hints
.flags
& PSize
)
11287 size_hints
.flags
|= PSize
;
11288 if (hints
.flags
& PPosition
)
11289 size_hints
.flags
|= PPosition
;
11290 if (hints
.flags
& USPosition
)
11291 size_hints
.flags
|= USPosition
;
11292 if (hints
.flags
& USSize
)
11293 size_hints
.flags
|= USSize
;
11300 size_hints
.win_gravity
= f
->win_gravity
;
11301 size_hints
.flags
|= PWinGravity
;
11305 size_hints
.flags
&= ~ PPosition
;
11306 size_hints
.flags
|= USPosition
;
11308 #endif /* PWinGravity */
11310 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
11312 #endif /* not USE_GTK */
11314 /* Used for IconicState or NormalState */
11317 x_wm_set_window_state (struct frame
*f
, int state
)
11319 #ifdef USE_X_TOOLKIT
11322 XtSetArg (al
[0], XtNinitialState
, state
);
11323 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11324 #else /* not USE_X_TOOLKIT */
11325 Window window
= FRAME_X_WINDOW (f
);
11327 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
11328 f
->output_data
.x
->wm_hints
.initial_state
= state
;
11330 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11331 #endif /* not USE_X_TOOLKIT */
11335 x_wm_set_icon_pixmap (struct frame
*f
, ptrdiff_t pixmap_id
)
11337 Pixmap icon_pixmap
, icon_mask
;
11339 #if !defined USE_X_TOOLKIT && !defined USE_GTK
11340 Window window
= FRAME_OUTER_WINDOW (f
);
11345 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
11346 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
11347 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
11348 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
11352 /* It seems there is no way to turn off use of an icon
11360 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
11364 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
11368 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
11369 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11370 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
11371 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11374 #else /* not USE_X_TOOLKIT && not USE_GTK */
11376 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
11377 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11379 #endif /* not USE_X_TOOLKIT && not USE_GTK */
11383 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
11385 Window window
= FRAME_OUTER_WINDOW (f
);
11387 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
11388 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
11389 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
11391 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11395 /***********************************************************************
11397 ***********************************************************************/
11401 /* Check that FONT is valid on frame F. It is if it can be found in F's
11405 x_check_font (struct frame
*f
, struct font
*font
)
11407 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
11408 if (font
->driver
->check
)
11409 eassert (font
->driver
->check (f
, font
) == 0);
11412 #endif /* GLYPH_DEBUG */
11415 /***********************************************************************
11417 ***********************************************************************/
11419 #ifdef USE_X_TOOLKIT
11420 static XrmOptionDescRec emacs_options
[] = {
11421 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
11422 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
11424 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
11425 XrmoptionSepArg
, NULL
},
11426 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
11428 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11429 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11430 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11431 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
11432 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
11433 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
11434 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
11437 /* Whether atimer for Xt timeouts is activated or not. */
11439 static bool x_timeout_atimer_activated_flag
;
11441 #endif /* USE_X_TOOLKIT */
11443 static int x_initialized
;
11445 /* Test whether two display-name strings agree up to the dot that separates
11446 the screen number from the server number. */
11448 same_x_server (const char *name1
, const char *name2
)
11450 bool seen_colon
= false;
11451 Lisp_Object sysname
= Fsystem_name ();
11452 const char *system_name
= SSDATA (sysname
);
11453 ptrdiff_t system_name_length
= SBYTES (sysname
);
11454 ptrdiff_t length_until_period
= 0;
11456 while (system_name
[length_until_period
] != 0
11457 && system_name
[length_until_period
] != '.')
11458 length_until_period
++;
11460 /* Treat `unix' like an empty host name. */
11461 if (! strncmp (name1
, "unix:", 5))
11463 if (! strncmp (name2
, "unix:", 5))
11465 /* Treat this host's name like an empty host name. */
11466 if (! strncmp (name1
, system_name
, system_name_length
)
11467 && name1
[system_name_length
] == ':')
11468 name1
+= system_name_length
;
11469 if (! strncmp (name2
, system_name
, system_name_length
)
11470 && name2
[system_name_length
] == ':')
11471 name2
+= system_name_length
;
11472 /* Treat this host's domainless name like an empty host name. */
11473 if (! strncmp (name1
, system_name
, length_until_period
)
11474 && name1
[length_until_period
] == ':')
11475 name1
+= length_until_period
;
11476 if (! strncmp (name2
, system_name
, length_until_period
)
11477 && name2
[length_until_period
] == ':')
11478 name2
+= length_until_period
;
11480 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
11484 if (seen_colon
&& *name1
== '.')
11488 && (*name1
== '.' || *name1
== '\0')
11489 && (*name2
== '.' || *name2
== '\0'));
11492 /* Count number of set bits in mask and number of bits to shift to
11493 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
11496 get_bits_and_offset (unsigned long mask
, int *bits
, int *offset
)
11501 while (!(mask
& 1))
11517 /* Return true iff display DISPLAY is available for use.
11518 But don't permanently open it, just test its availability. */
11521 x_display_ok (const char *display
)
11523 /* XOpenDisplay fails if it gets a signal. Block SIGIO which may arrive. */
11524 unrequest_sigio ();
11525 Display
*dpy
= XOpenDisplay (display
);
11529 XCloseDisplay (dpy
);
11535 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
11536 const gchar
*msg
, gpointer user_data
)
11538 if (!strstr (msg
, "g_set_prgname"))
11539 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, msg
);
11543 /* Create invisible cursor on X display referred by DPYINFO. */
11546 make_invisible_cursor (struct x_display_info
*dpyinfo
)
11548 Display
*dpy
= dpyinfo
->display
;
11549 static char const no_data
[] = { 0 };
11554 x_catch_errors (dpy
);
11555 pix
= XCreateBitmapFromData (dpy
, dpyinfo
->root_window
, no_data
, 1, 1);
11556 if (! x_had_errors_p (dpy
) && pix
!= None
)
11560 col
.red
= col
.green
= col
.blue
= 0;
11561 col
.flags
= DoRed
| DoGreen
| DoBlue
;
11562 pixc
= XCreatePixmapCursor (dpy
, pix
, pix
, &col
, &col
, 0, 0);
11563 if (! x_had_errors_p (dpy
) && pixc
!= None
)
11565 XFreePixmap (dpy
, pix
);
11568 x_uncatch_errors ();
11573 /* True if DPY supports Xfixes extension >= 4. */
11576 x_probe_xfixes_extension (Display
*dpy
)
11580 return XFixesQueryVersion (dpy
, &major
, &minor
) && major
>= 4;
11583 #endif /* HAVE_XFIXES */
11586 /* Toggle mouse pointer visibility on frame F by using Xfixes functions. */
11589 xfixes_toggle_visible_pointer (struct frame
*f
, bool invisible
)
11593 XFixesHideCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11595 XFixesShowCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11596 f
->pointer_invisible
= invisible
;
11599 #endif /* HAVE_XFIXES */
11602 /* Toggle mouse pointer visibility on frame F by using invisible cursor. */
11605 x_toggle_visible_pointer (struct frame
*f
, bool invisible
)
11607 eassert (FRAME_DISPLAY_INFO (f
)->invisible_cursor
!= 0);
11609 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11610 FRAME_DISPLAY_INFO (f
)->invisible_cursor
);
11612 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11613 f
->output_data
.x
->current_cursor
);
11614 f
->pointer_invisible
= invisible
;
11617 /* Setup pointer blanking, prefer Xfixes if available. */
11620 x_setup_pointer_blanking (struct x_display_info
*dpyinfo
)
11622 /* FIXME: the brave tester should set EMACS_XFIXES because we're suspecting
11623 X server bug, see http://debbugs.gnu.org/cgi/bugreport.cgi?bug=17609. */
11624 if (egetenv ("EMACS_XFIXES") && x_probe_xfixes_extension (dpyinfo
->display
))
11625 dpyinfo
->toggle_visible_pointer
= xfixes_toggle_visible_pointer
;
11628 dpyinfo
->toggle_visible_pointer
= x_toggle_visible_pointer
;
11629 dpyinfo
->invisible_cursor
= make_invisible_cursor (dpyinfo
);
11633 /* Current X display connection identifier. Incremented for each next
11634 connection established. */
11635 static unsigned x_display_id
;
11637 /* Open a connection to X display DISPLAY_NAME, and return
11638 the structure that describes the open display.
11639 If we cannot contact the display, return null. */
11641 struct x_display_info
*
11642 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
11645 struct terminal
*terminal
;
11646 struct x_display_info
*dpyinfo
;
11652 if (!x_initialized
)
11658 if (! x_display_ok (SSDATA (display_name
)))
11659 error ("Display %s can't be opened", SSDATA (display_name
));
11663 #define NUM_ARGV 10
11665 char *argv
[NUM_ARGV
];
11666 char **argv2
= argv
;
11669 if (x_initialized
++ > 1)
11671 xg_display_open (SSDATA (display_name
), &dpy
);
11675 static char display_opt
[] = "--display";
11676 static char name_opt
[] = "--name";
11678 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
11682 argv
[argc
++] = initial_argv
[0];
11684 if (! NILP (display_name
))
11686 argv
[argc
++] = display_opt
;
11687 argv
[argc
++] = SSDATA (display_name
);
11690 argv
[argc
++] = name_opt
;
11691 argv
[argc
++] = resource_name
;
11693 XSetLocaleModifiers ("");
11695 /* Work around GLib bug that outputs a faulty warning. See
11696 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
11697 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
11698 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
11700 /* NULL window -> events for all windows go to our function.
11701 Call before gtk_init so Gtk+ event filters comes after our. */
11702 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
11704 /* gtk_init does set_locale. Fix locale before and after. */
11706 unrequest_sigio (); /* See comment in x_display_ok. */
11707 gtk_init (&argc
, &argv2
);
11711 g_log_remove_handler ("GLib", id
);
11715 dpy
= DEFAULT_GDK_DISPLAY ();
11717 #if ! GTK_CHECK_VERSION (2, 90, 0)
11718 /* Load our own gtkrc if it exists. */
11720 const char *file
= "~/.emacs.d/gtkrc";
11721 Lisp_Object s
, abs_file
;
11723 s
= build_string (file
);
11724 abs_file
= Fexpand_file_name (s
, Qnil
);
11726 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
11727 gtk_rc_parse (SSDATA (abs_file
));
11731 XSetErrorHandler (x_error_handler
);
11732 XSetIOErrorHandler (x_io_error_quitter
);
11735 #else /* not USE_GTK */
11736 #ifdef USE_X_TOOLKIT
11737 /* weiner@footloose.sps.mot.com reports that this causes
11739 X protocol error: BadAtom (invalid Atom parameter)
11740 on protocol request 18skiloaf.
11741 So let's not use it until R6. */
11742 #ifdef HAVE_X11XTR6
11743 XtSetLanguageProc (NULL
, NULL
, NULL
);
11754 argv
[argc
++] = "-xrm";
11755 argv
[argc
++] = xrm_option
;
11757 turn_on_atimers (false);
11758 unrequest_sigio (); /* See comment in x_display_ok. */
11759 dpy
= XtOpenDisplay (Xt_app_con
, SSDATA (display_name
),
11760 resource_name
, EMACS_CLASS
,
11761 emacs_options
, XtNumber (emacs_options
),
11764 turn_on_atimers (true);
11766 #ifdef HAVE_X11XTR6
11767 /* I think this is to compensate for XtSetLanguageProc. */
11772 #else /* not USE_X_TOOLKIT */
11773 XSetLocaleModifiers ("");
11774 unrequest_sigio (); // See comment in x_display_ok.
11775 dpy
= XOpenDisplay (SSDATA (display_name
));
11777 #endif /* not USE_X_TOOLKIT */
11778 #endif /* not USE_GTK*/
11780 /* Detect failure. */
11787 /* We have definitely succeeded. Record the new connection. */
11789 dpyinfo
= xzalloc (sizeof *dpyinfo
);
11790 terminal
= x_create_terminal (dpyinfo
);
11793 struct x_display_info
*share
;
11795 for (share
= x_display_list
; share
; share
= share
->next
)
11796 if (same_x_server (SSDATA (XCAR (share
->name_list_element
)),
11797 SSDATA (display_name
)))
11800 terminal
->kboard
= share
->terminal
->kboard
;
11803 terminal
->kboard
= allocate_kboard (Qx
);
11805 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
11807 char *vendor
= ServerVendor (dpy
);
11809 /* Temporarily hide the partially initialized terminal. */
11810 terminal_list
= terminal
->next_terminal
;
11812 kset_system_key_alist
11814 call1 (Qvendor_specific_keysyms
,
11815 vendor
? build_string (vendor
) : empty_unibyte_string
));
11817 terminal
->next_terminal
= terminal_list
;
11818 terminal_list
= terminal
;
11821 /* Don't let the initial kboard remain current longer than necessary.
11822 That would cause problems if a file loaded on startup tries to
11823 prompt in the mini-buffer. */
11824 if (current_kboard
== initial_kboard
)
11825 current_kboard
= terminal
->kboard
;
11827 terminal
->kboard
->reference_count
++;
11830 /* Put this display on the chain. */
11831 dpyinfo
->next
= x_display_list
;
11832 x_display_list
= dpyinfo
;
11834 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
11835 dpyinfo
->display
= dpy
;
11836 dpyinfo
->connection
= ConnectionNumber (dpyinfo
->display
);
11838 /* Set the name of the terminal. */
11839 terminal
->name
= xlispstrdup (display_name
);
11842 XSetAfterFunction (x_current_display
, x_trace_wire
);
11845 lim
= min (PTRDIFF_MAX
, SIZE_MAX
) - sizeof "@";
11846 Lisp_Object system_name
= Fsystem_name ();
11847 if (lim
- SBYTES (Vinvocation_name
) < SBYTES (system_name
))
11848 memory_full (SIZE_MAX
);
11849 dpyinfo
->x_id
= ++x_display_id
;
11850 dpyinfo
->x_id_name
= xmalloc (SBYTES (Vinvocation_name
)
11851 + SBYTES (system_name
) + 2);
11852 char *nametail
= lispstpcpy (dpyinfo
->x_id_name
, Vinvocation_name
);
11854 lispstpcpy (nametail
, system_name
);
11856 /* Figure out which modifier bits mean what. */
11857 x_find_modifier_meanings (dpyinfo
);
11859 /* Get the scroll bar cursor. */
11861 /* We must create a GTK cursor, it is required for GTK widgets. */
11862 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
11863 #endif /* USE_GTK */
11865 dpyinfo
->vertical_scroll_bar_cursor
11866 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
11868 dpyinfo
->horizontal_scroll_bar_cursor
11869 = XCreateFontCursor (dpyinfo
->display
, XC_sb_h_double_arrow
);
11871 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
11872 resource_name
, EMACS_CLASS
);
11873 #ifdef HAVE_XRMSETDATABASE
11874 XrmSetDatabase (dpyinfo
->display
, xrdb
);
11876 dpyinfo
->display
->db
= xrdb
;
11878 /* Put the rdb where we can find it in a way that works on
11880 dpyinfo
->xrdb
= xrdb
;
11882 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
11883 DefaultScreen (dpyinfo
->display
));
11884 select_visual (dpyinfo
);
11885 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
11886 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
11887 dpyinfo
->icon_bitmap_id
= -1;
11888 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
11890 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
11892 /* See if we can construct pixel values from RGB values. */
11893 if (dpyinfo
->visual
->class == TrueColor
)
11895 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
11896 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
11897 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
11898 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
11899 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
11900 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
11903 /* See if a private colormap is requested. */
11904 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
11906 if (dpyinfo
->visual
->class == PseudoColor
)
11908 AUTO_STRING (privateColormap
, "privateColormap");
11909 AUTO_STRING (PrivateColormap
, "PrivateColormap");
11911 = display_x_get_resource (dpyinfo
, privateColormap
,
11912 PrivateColormap
, Qnil
, Qnil
);
11913 if (STRINGP (value
)
11914 && (!strcmp (SSDATA (value
), "true")
11915 || !strcmp (SSDATA (value
), "on")))
11916 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
11920 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
11921 dpyinfo
->visual
, AllocNone
);
11925 /* If we are using Xft, the following precautions should be made:
11927 1. Make sure that the Xrender extension is added before the Xft one.
11928 Otherwise, the close-display hook set by Xft is called after the one
11929 for Xrender, and the former tries to re-add the latter. This results
11930 in inconsistency of internal states and leads to X protocol error when
11931 one reconnects to the same X server (Bug#1696).
11933 2. Check dpi value in X resources. It is better we use it as well,
11934 since Xft will use it, as will all Gnome applications. If our real DPI
11935 is smaller or larger than the one Xft uses, our font will look smaller
11936 or larger than other for other applications, even if it is the same
11937 font name (monospace-10 for example). */
11939 int event_base
, error_base
;
11943 XRenderQueryExtension (dpyinfo
->display
, &event_base
, &error_base
);
11945 v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
11946 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
11947 dpyinfo
->resy
= dpyinfo
->resx
= d
;
11951 if (dpyinfo
->resy
< 1)
11953 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
11954 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
11955 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
11956 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
11957 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
11958 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
11959 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
11960 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
11961 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
11965 static const struct
11970 #define ATOM_REFS_INIT(string, member) \
11971 { string, offsetof (struct x_display_info, member) },
11972 ATOM_REFS_INIT ("WM_PROTOCOLS", Xatom_wm_protocols
)
11973 ATOM_REFS_INIT ("WM_TAKE_FOCUS", Xatom_wm_take_focus
)
11974 ATOM_REFS_INIT ("WM_SAVE_YOURSELF", Xatom_wm_save_yourself
)
11975 ATOM_REFS_INIT ("WM_DELETE_WINDOW", Xatom_wm_delete_window
)
11976 ATOM_REFS_INIT ("WM_CHANGE_STATE", Xatom_wm_change_state
)
11977 ATOM_REFS_INIT ("WM_CONFIGURE_DENIED", Xatom_wm_configure_denied
)
11978 ATOM_REFS_INIT ("WM_MOVED", Xatom_wm_window_moved
)
11979 ATOM_REFS_INIT ("WM_CLIENT_LEADER", Xatom_wm_client_leader
)
11980 ATOM_REFS_INIT ("Editres", Xatom_editres
)
11981 ATOM_REFS_INIT ("CLIPBOARD", Xatom_CLIPBOARD
)
11982 ATOM_REFS_INIT ("TIMESTAMP", Xatom_TIMESTAMP
)
11983 ATOM_REFS_INIT ("TEXT", Xatom_TEXT
)
11984 ATOM_REFS_INIT ("COMPOUND_TEXT", Xatom_COMPOUND_TEXT
)
11985 ATOM_REFS_INIT ("UTF8_STRING", Xatom_UTF8_STRING
)
11986 ATOM_REFS_INIT ("DELETE", Xatom_DELETE
)
11987 ATOM_REFS_INIT ("MULTIPLE", Xatom_MULTIPLE
)
11988 ATOM_REFS_INIT ("INCR", Xatom_INCR
)
11989 ATOM_REFS_INIT ("_EMACS_TMP_", Xatom_EMACS_TMP
)
11990 ATOM_REFS_INIT ("TARGETS", Xatom_TARGETS
)
11991 ATOM_REFS_INIT ("NULL", Xatom_NULL
)
11992 ATOM_REFS_INIT ("ATOM", Xatom_ATOM
)
11993 ATOM_REFS_INIT ("ATOM_PAIR", Xatom_ATOM_PAIR
)
11994 ATOM_REFS_INIT ("CLIPBOARD_MANAGER", Xatom_CLIPBOARD_MANAGER
)
11995 ATOM_REFS_INIT ("_XEMBED_INFO", Xatom_XEMBED_INFO
)
11996 /* For properties of font. */
11997 ATOM_REFS_INIT ("PIXEL_SIZE", Xatom_PIXEL_SIZE
)
11998 ATOM_REFS_INIT ("AVERAGE_WIDTH", Xatom_AVERAGE_WIDTH
)
11999 ATOM_REFS_INIT ("_MULE_BASELINE_OFFSET", Xatom_MULE_BASELINE_OFFSET
)
12000 ATOM_REFS_INIT ("_MULE_RELATIVE_COMPOSE", Xatom_MULE_RELATIVE_COMPOSE
)
12001 ATOM_REFS_INIT ("_MULE_DEFAULT_ASCENT", Xatom_MULE_DEFAULT_ASCENT
)
12002 /* Ghostscript support. */
12003 ATOM_REFS_INIT ("DONE", Xatom_DONE
)
12004 ATOM_REFS_INIT ("PAGE", Xatom_PAGE
)
12005 ATOM_REFS_INIT ("SCROLLBAR", Xatom_Scrollbar
)
12006 ATOM_REFS_INIT ("HORIZONTAL_SCROLLBAR", Xatom_Horizontal_Scrollbar
)
12007 ATOM_REFS_INIT ("_XEMBED", Xatom_XEMBED
)
12009 ATOM_REFS_INIT ("_NET_WM_STATE", Xatom_net_wm_state
)
12010 ATOM_REFS_INIT ("_NET_WM_STATE_FULLSCREEN", Xatom_net_wm_state_fullscreen
)
12011 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_HORZ",
12012 Xatom_net_wm_state_maximized_horz
)
12013 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_VERT",
12014 Xatom_net_wm_state_maximized_vert
)
12015 ATOM_REFS_INIT ("_NET_WM_STATE_STICKY", Xatom_net_wm_state_sticky
)
12016 ATOM_REFS_INIT ("_NET_WM_STATE_HIDDEN", Xatom_net_wm_state_hidden
)
12017 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE", Xatom_net_window_type
)
12018 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE_TOOLTIP",
12019 Xatom_net_window_type_tooltip
)
12020 ATOM_REFS_INIT ("_NET_WM_ICON_NAME", Xatom_net_wm_icon_name
)
12021 ATOM_REFS_INIT ("_NET_WM_NAME", Xatom_net_wm_name
)
12022 ATOM_REFS_INIT ("_NET_SUPPORTED", Xatom_net_supported
)
12023 ATOM_REFS_INIT ("_NET_SUPPORTING_WM_CHECK", Xatom_net_supporting_wm_check
)
12024 ATOM_REFS_INIT ("_NET_WM_WINDOW_OPACITY", Xatom_net_wm_window_opacity
)
12025 ATOM_REFS_INIT ("_NET_ACTIVE_WINDOW", Xatom_net_active_window
)
12026 ATOM_REFS_INIT ("_NET_FRAME_EXTENTS", Xatom_net_frame_extents
)
12027 ATOM_REFS_INIT ("_NET_CURRENT_DESKTOP", Xatom_net_current_desktop
)
12028 ATOM_REFS_INIT ("_NET_WORKAREA", Xatom_net_workarea
)
12029 /* Session management */
12030 ATOM_REFS_INIT ("SM_CLIENT_ID", Xatom_SM_CLIENT_ID
)
12031 ATOM_REFS_INIT ("_XSETTINGS_SETTINGS", Xatom_xsettings_prop
)
12032 ATOM_REFS_INIT ("MANAGER", Xatom_xsettings_mgr
)
12036 enum { atom_count
= ARRAYELTS (atom_refs
) };
12037 /* 1 for _XSETTINGS_SN. */
12038 enum { total_atom_count
= 1 + atom_count
};
12039 Atom atoms_return
[total_atom_count
];
12040 char *atom_names
[total_atom_count
];
12041 static char const xsettings_fmt
[] = "_XSETTINGS_S%d";
12042 char xsettings_atom_name
[sizeof xsettings_fmt
- 2
12043 + INT_STRLEN_BOUND (int)];
12045 for (i
= 0; i
< atom_count
; i
++)
12046 atom_names
[i
] = (char *) atom_refs
[i
].name
;
12048 /* Build _XSETTINGS_SN atom name. */
12049 sprintf (xsettings_atom_name
, xsettings_fmt
,
12050 XScreenNumberOfScreen (dpyinfo
->screen
));
12051 atom_names
[i
] = xsettings_atom_name
;
12053 XInternAtoms (dpyinfo
->display
, atom_names
, total_atom_count
,
12054 False
, atoms_return
);
12056 for (i
= 0; i
< atom_count
; i
++)
12057 *(Atom
*) ((char *) dpyinfo
+ atom_refs
[i
].offset
) = atoms_return
[i
];
12059 /* Manually copy last atom. */
12060 dpyinfo
->Xatom_xsettings_sel
= atoms_return
[i
];
12063 dpyinfo
->x_dnd_atoms_size
= 8;
12064 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof *dpyinfo
->x_dnd_atoms
12065 * dpyinfo
->x_dnd_atoms_size
);
12067 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
12068 gray_bits
, gray_width
, gray_height
,
12071 x_setup_pointer_blanking (dpyinfo
);
12074 xim_initialize (dpyinfo
, resource_name
);
12077 xsettings_initialize (dpyinfo
);
12079 /* This is only needed for distinguishing keyboard and process input. */
12080 if (dpyinfo
->connection
!= 0)
12081 add_keyboard_wait_descriptor (dpyinfo
->connection
);
12084 fcntl (dpyinfo
->connection
, F_SETOWN
, getpid ());
12085 #endif /* ! defined (F_SETOWN) */
12087 if (interrupt_input
)
12088 init_sigio (dpyinfo
->connection
);
12092 XrmValue d
, fr
, to
;
12095 dpy
= dpyinfo
->display
;
12096 d
.addr
= (XPointer
)&dpy
;
12097 d
.size
= sizeof (Display
*);
12098 fr
.addr
= XtDefaultFont
;
12099 fr
.size
= sizeof (XtDefaultFont
);
12100 to
.size
= sizeof (Font
*);
12101 to
.addr
= (XPointer
)&font
;
12102 x_catch_errors (dpy
);
12103 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
12105 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
12106 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
12107 /* Do not free XFontStruct returned by the above call to XQueryFont.
12108 This leads to X protocol errors at XtCloseDisplay (Bug#18403). */
12109 x_uncatch_errors ();
12113 /* See if we should run in synchronous mode. This is useful
12114 for debugging X code. */
12116 AUTO_STRING (synchronous
, "synchronous");
12117 AUTO_STRING (Synchronous
, "Synchronous");
12118 Lisp_Object value
= display_x_get_resource (dpyinfo
, synchronous
,
12119 Synchronous
, Qnil
, Qnil
);
12120 if (STRINGP (value
)
12121 && (!strcmp (SSDATA (value
), "true")
12122 || !strcmp (SSDATA (value
), "on")))
12123 XSynchronize (dpyinfo
->display
, True
);
12127 AUTO_STRING (useXIM
, "useXIM");
12128 AUTO_STRING (UseXIM
, "UseXIM");
12129 Lisp_Object value
= display_x_get_resource (dpyinfo
, useXIM
, UseXIM
,
12132 if (STRINGP (value
)
12133 && (!strcmp (SSDATA (value
), "false")
12134 || !strcmp (SSDATA (value
), "off")))
12137 if (STRINGP (value
)
12138 && (!strcmp (SSDATA (value
), "true")
12139 || !strcmp (SSDATA (value
), "on")))
12145 /* Only do this for the very first display in the Emacs session.
12146 Ignore X session management when Emacs was first started on a
12147 tty or started as a daemon. */
12148 if (terminal
->id
== 1 && ! IS_DAEMON
)
12149 x_session_initialize (dpyinfo
);
12153 x_extension_initialize (dpyinfo
);
12161 /* Get rid of display DPYINFO, deleting all frames on it,
12162 and without sending any more commands to the X server. */
12165 x_delete_display (struct x_display_info
*dpyinfo
)
12167 struct terminal
*t
;
12168 struct color_name_cache_entry
*color_entry
, *next_color_entry
;
12170 /* Close all frames and delete the generic struct terminal for this
12172 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
12173 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
12176 /* Close X session management when we close its display. */
12177 if (t
->id
== 1 && x_session_have_connection ())
12178 x_session_close ();
12180 delete_terminal (t
);
12184 if (next_noop_dpyinfo
== dpyinfo
)
12185 next_noop_dpyinfo
= dpyinfo
->next
;
12187 if (x_display_list
== dpyinfo
)
12188 x_display_list
= dpyinfo
->next
;
12191 struct x_display_info
*tail
;
12193 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
12194 if (tail
->next
== dpyinfo
)
12195 tail
->next
= tail
->next
->next
;
12198 for (color_entry
= dpyinfo
->color_names
;
12200 color_entry
= next_color_entry
)
12202 next_color_entry
= color_entry
->next
;
12203 xfree (color_entry
->name
);
12204 xfree (color_entry
);
12207 xfree (dpyinfo
->x_id_name
);
12208 xfree (dpyinfo
->x_dnd_atoms
);
12209 xfree (dpyinfo
->color_cells
);
12213 #ifdef USE_X_TOOLKIT
12215 /* Atimer callback function for TIMER. Called every 0.1s to process
12216 Xt timeouts, if needed. We must avoid calling XtAppPending as
12217 much as possible because that function does an implicit XFlush
12218 that slows us down. */
12221 x_process_timeouts (struct atimer
*timer
)
12224 x_timeout_atimer_activated_flag
= false;
12225 if (toolkit_scroll_bar_interaction
|| popup_activated ())
12227 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
12228 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
12229 /* Reactivate the atimer for next time. */
12230 x_activate_timeout_atimer ();
12235 /* Install an asynchronous timer that processes Xt timeout events
12236 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
12237 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
12238 function whenever these variables are set. This is necessary
12239 because some widget sets use timeouts internally, for example the
12240 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
12241 processed, these widgets don't behave normally. */
12244 x_activate_timeout_atimer (void)
12247 if (!x_timeout_atimer_activated_flag
)
12249 struct timespec interval
= make_timespec (0, 100 * 1000 * 1000);
12250 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
12251 x_timeout_atimer_activated_flag
= true;
12256 #endif /* USE_X_TOOLKIT */
12259 /* Set up use of X before we make the first connection. */
12261 static struct redisplay_interface x_redisplay_interface
=
12263 x_frame_parm_handlers
,
12267 x_clear_end_of_line
,
12269 x_after_update_window_line
,
12270 x_update_window_begin
,
12271 x_update_window_end
,
12273 x_clear_window_mouse_face
,
12274 x_get_glyph_overhangs
,
12275 x_fix_overlapping_area
,
12276 x_draw_fringe_bitmap
,
12278 x_cr_define_fringe_bitmap
,
12279 x_cr_destroy_fringe_bitmap
,
12281 0, /* define_fringe_bitmap */
12282 0, /* destroy_fringe_bitmap */
12284 x_compute_glyph_string_overhangs
,
12285 x_draw_glyph_string
,
12286 x_define_frame_cursor
,
12287 x_clear_frame_area
,
12288 x_draw_window_cursor
,
12289 x_draw_vertical_window_border
,
12290 x_draw_window_divider
,
12291 x_shift_glyphs_for_insert
, /* Never called; see comment in function. */
12297 /* This function is called when the last frame on a display is deleted. */
12299 x_delete_terminal (struct terminal
*terminal
)
12301 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
12303 /* Protect against recursive calls. delete_frame in
12304 delete_terminal calls us back when it deletes our last frame. */
12305 if (!terminal
->name
)
12310 /* We must close our connection to the XIM server before closing the
12313 xim_close_dpy (dpyinfo
);
12316 /* Normally, the display is available... */
12317 if (dpyinfo
->display
)
12319 x_destroy_all_bitmaps (dpyinfo
);
12320 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
12322 /* Whether or not XCloseDisplay destroys the associated resource
12323 database depends on the version of libX11. To avoid both
12324 crash and memory leak, we dissociate the database from the
12325 display and then destroy dpyinfo->xrdb ourselves.
12327 Unfortunately, the above strategy does not work in some
12328 situations due to a bug in newer versions of libX11: because
12329 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
12330 dpy->db is NULL, XCloseDisplay destroys the associated
12331 database whereas it has not been created by XGetDefault
12332 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
12333 don't destroy the database here in order to avoid the crash
12334 in the above situations for now, though that may cause memory
12335 leaks in other situations. */
12337 #ifdef HAVE_XRMSETDATABASE
12338 XrmSetDatabase (dpyinfo
->display
, NULL
);
12340 dpyinfo
->display
->db
= NULL
;
12342 /* We used to call XrmDestroyDatabase from x_delete_display, but
12343 some older versions of libX11 crash if we call it after
12344 closing all the displays. */
12345 XrmDestroyDatabase (dpyinfo
->xrdb
);
12349 xg_display_close (dpyinfo
->display
);
12351 #ifdef USE_X_TOOLKIT
12352 XtCloseDisplay (dpyinfo
->display
);
12354 XCloseDisplay (dpyinfo
->display
);
12356 #endif /* ! USE_GTK */
12357 /* Do not close the connection here because it's already closed
12358 by X(t)CloseDisplay (Bug#18403). */
12359 dpyinfo
->display
= NULL
;
12362 /* ...but if called from x_connection_closed, the display may already
12363 be closed and dpyinfo->display was set to 0 to indicate that. Since
12364 X server is most likely gone, explicit close is the only reliable
12365 way to continue and avoid Bug#19147. */
12366 else if (dpyinfo
->connection
>= 0)
12367 emacs_close (dpyinfo
->connection
);
12369 /* No more input on this descriptor. */
12370 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
12371 /* Mark as dead. */
12372 dpyinfo
->connection
= -1;
12374 x_delete_display (dpyinfo
);
12378 /* Create a struct terminal, initialize it with the X11 specific
12379 functions and make DISPLAY->TERMINAL point to it. */
12381 static struct terminal
*
12382 x_create_terminal (struct x_display_info
*dpyinfo
)
12384 struct terminal
*terminal
;
12386 terminal
= create_terminal (output_x_window
, &x_redisplay_interface
);
12388 terminal
->display_info
.x
= dpyinfo
;
12389 dpyinfo
->terminal
= terminal
;
12391 /* kboard is initialized in x_term_init. */
12393 terminal
->clear_frame_hook
= x_clear_frame
;
12394 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
12395 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
12396 terminal
->ring_bell_hook
= XTring_bell
;
12397 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
12398 terminal
->update_begin_hook
= x_update_begin
;
12399 terminal
->update_end_hook
= x_update_end
;
12400 terminal
->read_socket_hook
= XTread_socket
;
12401 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
12402 terminal
->mouse_position_hook
= XTmouse_position
;
12403 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
12404 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
12405 terminal
->fullscreen_hook
= XTfullscreen_hook
;
12406 terminal
->menu_show_hook
= x_menu_show
;
12407 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
12408 terminal
->popup_dialog_hook
= xw_popup_dialog
;
12410 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
12411 terminal
->set_horizontal_scroll_bar_hook
= XTset_horizontal_scroll_bar
;
12412 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
12413 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
12414 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
12415 terminal
->delete_frame_hook
= x_destroy_window
;
12416 terminal
->delete_terminal_hook
= x_delete_terminal
;
12417 /* Other hooks are NULL by default. */
12423 x_initialize (void)
12428 any_help_event_p
= false;
12429 ignore_next_mouse_click_timeout
= 0;
12432 current_count
= -1;
12435 /* Try to use interrupt input; if we can't, then start polling. */
12436 Fset_input_interrupt_mode (Qt
);
12438 #ifdef USE_X_TOOLKIT
12439 XtToolkitInitialize ();
12441 Xt_app_con
= XtCreateApplicationContext ();
12443 /* Register a converter from strings to pixels, which uses
12444 Emacs' color allocation infrastructure. */
12445 XtAppSetTypeConverter (Xt_app_con
,
12446 XtRString
, XtRPixel
, cvt_string_to_pixel
,
12447 cvt_string_to_pixel_args
,
12448 XtNumber (cvt_string_to_pixel_args
),
12449 XtCacheByDisplay
, cvt_pixel_dtor
);
12451 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
12454 #ifdef USE_TOOLKIT_SCROLL_BARS
12456 xaw3d_arrow_scroll
= False
;
12457 xaw3d_pick_top
= True
;
12462 x_cr_init_fringe (&x_redisplay_interface
);
12465 /* Note that there is no real way portable across R3/R4 to get the
12466 original error handler. */
12467 XSetErrorHandler (x_error_handler
);
12468 XSetIOErrorHandler (x_io_error_quitter
);
12475 /* Emacs can handle only core input events, so make sure
12476 Gtk doesn't use Xinput or Xinput2 extensions. */
12477 xputenv ("GDK_CORE_DEVICE_EVENTS=1");
12482 syms_of_xterm (void)
12484 x_error_message
= NULL
;
12486 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
12487 DEFSYM (Qlatin_1
, "latin-1");
12490 xg_default_icon_file
= build_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
12491 staticpro (&xg_default_icon_file
);
12493 DEFSYM (Qx_gtk_map_stock
, "x-gtk-map-stock");
12496 DEFVAR_BOOL ("x-use-underline-position-properties",
12497 x_use_underline_position_properties
,
12498 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
12499 A value of nil means ignore them. If you encounter fonts with bogus
12500 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
12501 to 4.1, set this to nil. You can also use `underline-minimum-offset'
12502 to override the font's UNDERLINE_POSITION for small font display
12504 x_use_underline_position_properties
= true;
12506 DEFVAR_BOOL ("x-underline-at-descent-line",
12507 x_underline_at_descent_line
,
12508 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
12509 A value of nil means to draw the underline according to the value of the
12510 variable `x-use-underline-position-properties', which is usually at the
12511 baseline level. The default value is nil. */);
12512 x_underline_at_descent_line
= false;
12514 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
12515 x_mouse_click_focus_ignore_position
,
12516 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
12517 This variable is only used when the window manager requires that you
12518 click on a frame to select it (give it focus). In that case, a value
12519 of nil, means that the selected window and cursor position changes to
12520 reflect the mouse click position, while a non-nil value means that the
12521 selected window or cursor position is preserved. */);
12522 x_mouse_click_focus_ignore_position
= false;
12524 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
12525 doc
: /* Which toolkit scroll bars Emacs uses, if any.
12526 A value of nil means Emacs doesn't use toolkit scroll bars.
12527 With the X Window system, the value is a symbol describing the
12528 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
12529 With MS Windows or Nextstep, the value is t. */);
12530 #ifdef USE_TOOLKIT_SCROLL_BARS
12532 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
12533 #elif defined HAVE_XAW3D
12534 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
12536 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
12538 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
12541 Vx_toolkit_scroll_bars
= Qnil
;
12544 DEFSYM (Qmodifier_value
, "modifier-value");
12545 DEFSYM (Qalt
, "alt");
12546 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
12547 DEFSYM (Qhyper
, "hyper");
12548 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
12549 DEFSYM (Qmeta
, "meta");
12550 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
12551 DEFSYM (Qsuper
, "super");
12552 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
12554 DEFVAR_LISP ("x-alt-keysym", Vx_alt_keysym
,
12555 doc
: /* Which keys Emacs uses for the alt modifier.
12556 This should be one of the symbols `alt', `hyper', `meta', `super'.
12557 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
12558 is nil, which is the same as `alt'. */);
12559 Vx_alt_keysym
= Qnil
;
12561 DEFVAR_LISP ("x-hyper-keysym", Vx_hyper_keysym
,
12562 doc
: /* Which keys Emacs uses for the hyper modifier.
12563 This should be one of the symbols `alt', `hyper', `meta', `super'.
12564 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
12565 default is nil, which is the same as `hyper'. */);
12566 Vx_hyper_keysym
= Qnil
;
12568 DEFVAR_LISP ("x-meta-keysym", Vx_meta_keysym
,
12569 doc
: /* Which keys Emacs uses for the meta modifier.
12570 This should be one of the symbols `alt', `hyper', `meta', `super'.
12571 For example, `meta' means use the Meta_L and Meta_R keysyms. The
12572 default is nil, which is the same as `meta'. */);
12573 Vx_meta_keysym
= Qnil
;
12575 DEFVAR_LISP ("x-super-keysym", Vx_super_keysym
,
12576 doc
: /* Which keys Emacs uses for the super modifier.
12577 This should be one of the symbols `alt', `hyper', `meta', `super'.
12578 For example, `super' means use the Super_L and Super_R keysyms. The
12579 default is nil, which is the same as `super'. */);
12580 Vx_super_keysym
= Qnil
;
12582 DEFVAR_LISP ("x-keysym-table", Vx_keysym_table
,
12583 doc
: /* Hash table of character codes indexed by X keysym codes. */);
12584 Vx_keysym_table
= make_hash_table (hashtest_eql
, make_number (900),
12585 make_float (DEFAULT_REHASH_SIZE
),
12586 make_float (DEFAULT_REHASH_THRESHOLD
),
12589 DEFVAR_BOOL ("x-frame-normalize-before-maximize",
12590 x_frame_normalize_before_maximize
,
12591 doc
: /* Non-nil means normalize frame before maximizing.
12592 If this variable is t, Emacs first asks the window manager to give the
12593 frame its normal size, and only then the final state, whenever changing
12594 from a full-height, full-width or full-both state to the maximized one
12595 or when changing from the maximized to the full-height or full-width
12598 Set this variable only if your window manager cannot handle the
12599 transition between the various maximization states. */);
12600 x_frame_normalize_before_maximize
= false;