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. */
27 #include "blockinput.h"
28 #include "syssignal.h"
30 /* This may include sys/types.h, and that somehow loses
31 if this is not done before the other system files. */
33 #include <X11/cursorfont.h>
35 /* If we have Xfixes extension, use it for pointer blanking. */
37 #include <X11/extensions/Xfixes.h>
40 /* Using Xft implies that XRender is available. */
42 #include <X11/extensions/Xrender.h>
45 /* Load sys/types.h if not already loaded.
46 In some systems loading it twice is suicidal. */
48 #include <sys/types.h>
51 #include <sys/ioctl.h>
58 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
59 /* #include <sys/param.h> */
62 #include "character.h"
65 #include "dispextern.h"
67 #include "termhooks.h"
70 #include "emacs-icon.h"
75 #include "intervals.h"
80 #include "xsettings.h"
82 #include "sysselect.h"
86 #include <X11/Shell.h>
94 #include <X11/Xproto.h>
98 #if defined (USE_LUCID) || defined (USE_MOTIF)
99 #include "../lwlib/xlwmenu.h"
103 #if !defined (NO_EDITRES)
105 extern void _XEditResCheckMessages (Widget
, XtPointer
, XEvent
*, Boolean
*);
106 #endif /* not NO_EDITRES */
108 /* Include toolkit specific headers for the scroll bar widget. */
110 #ifdef USE_TOOLKIT_SCROLL_BARS
111 #if defined USE_MOTIF
112 #include <Xm/Xm.h> /* For LESSTIF_VERSION */
113 #include <Xm/ScrollBar.h>
114 #else /* !USE_MOTIF i.e. use Xaw */
117 #include <X11/Xaw3d/Simple.h>
118 #include <X11/Xaw3d/Scrollbar.h>
119 #include <X11/Xaw3d/ThreeD.h>
120 #else /* !HAVE_XAW3D */
121 #include <X11/Xaw/Simple.h>
122 #include <X11/Xaw/Scrollbar.h>
123 #endif /* !HAVE_XAW3D */
125 #define XtNpickTop "pickTop"
126 #endif /* !XtNpickTop */
127 #endif /* !USE_MOTIF */
128 #endif /* USE_TOOLKIT_SCROLL_BARS */
130 #endif /* USE_X_TOOLKIT */
134 #ifndef XtNinitialState
135 #define XtNinitialState "initialState"
139 #include "bitmaps/gray.xbm"
142 #include <X11/XKBlib.h>
145 /* Default to using XIM if available. */
149 bool use_xim
= false; /* configure --without-xim */
152 /* Non-zero means that a HELP_EVENT has been generated since Emacs
155 static bool any_help_event_p
;
157 /* This is a chain of structures for all the X displays currently in
160 struct x_display_info
*x_display_list
;
164 /* The application context for Xt use. */
165 XtAppContext Xt_app_con
;
166 static String Xt_default_resources
[] = {0};
168 /* Non-zero means user is interacting with a toolkit scroll bar. */
169 static bool toolkit_scroll_bar_interaction
;
171 #endif /* USE_X_TOOLKIT */
173 /* Non-zero timeout value means ignore next mouse click if it arrives
174 before that timeout elapses (i.e. as part of the same sequence of
175 events resulting from clicking on a frame to select it). */
177 static Time ignore_next_mouse_click_timeout
;
179 /* Used locally within XTread_socket. */
181 static int x_noop_count
;
184 /* The name of the Emacs icon file. */
185 static Lisp_Object xg_default_icon_file
;
188 /* Some functions take this as char *, not const char *. */
189 static char emacs_class
[] = EMACS_CLASS
;
193 XEMBED_MAPPED
= 1 << 0
198 XEMBED_EMBEDDED_NOTIFY
= 0,
199 XEMBED_WINDOW_ACTIVATE
= 1,
200 XEMBED_WINDOW_DEACTIVATE
= 2,
201 XEMBED_REQUEST_FOCUS
= 3,
203 XEMBED_FOCUS_OUT
= 5,
204 XEMBED_FOCUS_NEXT
= 6,
205 XEMBED_FOCUS_PREV
= 7,
207 XEMBED_MODALITY_ON
= 10,
208 XEMBED_MODALITY_OFF
= 11,
209 XEMBED_REGISTER_ACCELERATOR
= 12,
210 XEMBED_UNREGISTER_ACCELERATOR
= 13,
211 XEMBED_ACTIVATE_ACCELERATOR
= 14
214 static bool x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
215 static void x_set_window_size_1 (struct frame
*, bool, int, int);
216 static void x_raise_frame (struct frame
*);
217 static void x_lower_frame (struct frame
*);
218 static const XColor
*x_color_cells (Display
*, int *);
219 static int x_io_error_quitter (Display
*);
220 static struct terminal
*x_create_terminal (struct x_display_info
*);
221 static void x_update_end (struct frame
*);
222 static void XTframe_up_to_date (struct frame
*);
223 static void x_clear_area1 (Display
*, Window
, int, int, int, int, int);
224 static void x_clear_frame (struct frame
*);
225 static _Noreturn
void x_ins_del_lines (struct frame
*, int, int);
226 static void frame_highlight (struct frame
*);
227 static void frame_unhighlight (struct frame
*);
228 static void x_new_focus_frame (struct x_display_info
*, struct frame
*);
229 static void x_focus_changed (int, int, struct x_display_info
*,
230 struct frame
*, struct input_event
*);
231 static void XTframe_rehighlight (struct frame
*);
232 static void x_frame_rehighlight (struct x_display_info
*);
233 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
234 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
235 enum text_cursor_kinds
);
237 static void x_clip_to_row (struct window
*, struct glyph_row
*,
238 enum glyph_row_area
, GC
);
239 static void x_flush (struct frame
*f
);
240 static void x_update_begin (struct frame
*);
241 static void x_update_window_begin (struct window
*);
242 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
, int);
243 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
244 enum scroll_bar_part
*,
245 Lisp_Object
*, Lisp_Object
*,
247 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
248 enum scroll_bar_part
*,
249 Lisp_Object
*, Lisp_Object
*,
251 static bool x_handle_net_wm_state (struct frame
*, const XPropertyEvent
*);
252 static void x_check_fullscreen (struct frame
*);
253 static void x_check_expected_move (struct frame
*, int, int);
254 static void x_sync_with_move (struct frame
*, int, int, bool);
255 static int handle_one_xevent (struct x_display_info
*,
256 const XEvent
*, int *,
257 struct input_event
*);
258 #if ! (defined USE_X_TOOLKIT || defined USE_MOTIF)
259 static int x_dispatch_event (XEvent
*, Display
*);
261 /* Don't declare this _Noreturn because we want no
262 interference with debugging failing X calls. */
263 static void x_connection_closed (Display
*, const char *);
264 static void x_wm_set_window_state (struct frame
*, int);
265 static void x_wm_set_icon_pixmap (struct frame
*, ptrdiff_t);
266 static void x_initialize (void);
268 static bool get_current_wm_state (struct frame
*, Window
, int *, bool *);
270 /* Flush display of frame F. */
273 x_flush (struct frame
*f
)
275 eassert (f
&& FRAME_X_P (f
));
276 /* Don't call XFlush when it is not safe to redisplay; the X
277 connection may be broken. */
278 if (!NILP (Vinhibit_redisplay
))
282 XFlush (FRAME_X_DISPLAY (f
));
287 /* Remove calls to XFlush by defining XFlush to an empty replacement.
288 Calls to XFlush should be unnecessary because the X output buffer
289 is flushed automatically as needed by calls to XPending,
290 XNextEvent, or XWindowEvent according to the XFlush man page.
291 XTread_socket calls XPending. Removing XFlush improves
294 #define XFlush(DISPLAY) (void) 0
297 /***********************************************************************
299 ***********************************************************************/
303 /* This is a function useful for recording debugging information about
304 the sequence of occurrences in this file. */
312 struct record event_record
[100];
314 int event_record_index
;
317 record_event (char *locus
, int type
)
319 if (event_record_index
== ARRAYELTS (event_record
))
320 event_record_index
= 0;
322 event_record
[event_record_index
].locus
= locus
;
323 event_record
[event_record_index
].type
= type
;
324 event_record_index
++;
329 static void x_prepare_for_xlibdraw (struct frame
*);
330 static void x_set_clip_rectangles (struct frame
*, GC
, XRectangle
*, int);
331 static void x_reset_clip_rectangles (struct frame
*, GC
);
332 static void x_fill_rectangle (struct frame
*, GC
, int, int,
333 unsigned int, unsigned int);
334 static void x_draw_rectangle (struct frame
*, GC
, int, int,
335 unsigned int, unsigned int);
336 static void x_fill_trapezoid_for_relief (struct frame
*, GC
, int, int,
337 unsigned int, unsigned int, int);
338 static void x_clear_window (struct frame
*);
341 static struct x_gc_ext_data
*x_gc_get_ext_data (struct frame
*, GC
, int);
342 static void x_extension_initialize (struct x_display_info
*);
343 static cairo_status_t
x_cr_accumulate_data (void *,
344 const unsigned char *,
347 #define FRAME_CR_CONTEXT(f) ((f)->output_data.x->cr_context)
348 #define FRAME_CR_SURFACE(f) ((f)->output_data.x->cr_surface)
350 static struct x_gc_ext_data
*
351 x_gc_get_ext_data (struct frame
*f
, GC gc
, int create_if_not_found_p
)
353 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
355 XExtData
**head
, *ext_data
;
358 head
= XEHeadOfExtensionList (object
);
359 ext_data
= XFindOnExtensionList (head
, dpyinfo
->ext_codes
->extension
);
360 if (ext_data
== NULL
)
362 if (!create_if_not_found_p
)
366 ext_data
= xzalloc (sizeof (*ext_data
));
367 ext_data
->number
= dpyinfo
->ext_codes
->extension
;
368 ext_data
->private_data
= xzalloc (sizeof (struct x_gc_ext_data
));
369 XAddToExtensionList (head
, ext_data
);
372 return (struct x_gc_ext_data
*) ext_data
->private_data
;
376 x_extension_initialize (struct x_display_info
*dpyinfo
)
378 XExtCodes
*ext_codes
= XAddExtension (dpyinfo
->display
);
380 dpyinfo
->ext_codes
= ext_codes
;
384 x_cr_destroy_surface (struct frame
*f
)
386 if (FRAME_CR_SURFACE (f
))
388 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
389 cairo_surface_destroy (FRAME_CR_SURFACE (f
));
390 FRAME_CR_SURFACE (f
) = 0;
391 if (cr
) cairo_destroy (cr
);
392 FRAME_CR_CONTEXT (f
) = NULL
;
397 x_begin_cr_clip (struct frame
*f
, GC gc
)
399 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
404 if (! FRAME_CR_SURFACE (f
))
406 cairo_surface_t
*surface
;
407 surface
= cairo_xlib_surface_create (FRAME_X_DISPLAY (f
),
409 FRAME_DISPLAY_INFO (f
)->visual
,
410 FRAME_PIXEL_WIDTH (f
),
411 FRAME_PIXEL_HEIGHT (f
));
412 cr
= cairo_create (surface
);
413 cairo_surface_destroy (surface
);
416 cr
= cairo_create (FRAME_CR_SURFACE (f
));
417 FRAME_CR_CONTEXT (f
) = cr
;
423 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 0);
425 if (gc_ext
&& gc_ext
->n_clip_rects
)
429 for (i
= 0; i
< gc_ext
->n_clip_rects
; i
++)
430 cairo_rectangle (cr
, gc_ext
->clip_rects
[i
].x
,
431 gc_ext
->clip_rects
[i
].y
,
432 gc_ext
->clip_rects
[i
].width
,
433 gc_ext
->clip_rects
[i
].height
);
442 x_end_cr_clip (struct frame
*f
)
444 cairo_restore (FRAME_CR_CONTEXT (f
));
448 x_set_cr_source_with_gc_foreground (struct frame
*f
, GC gc
)
453 XGetGCValues (FRAME_X_DISPLAY (f
), gc
, GCForeground
, &xgcv
);
454 color
.pixel
= xgcv
.foreground
;
455 x_query_color (f
, &color
);
456 cairo_set_source_rgb (FRAME_CR_CONTEXT (f
), color
.red
/ 65535.0,
457 color
.green
/ 65535.0, color
.blue
/ 65535.0);
461 x_set_cr_source_with_gc_background (struct frame
*f
, GC gc
)
466 XGetGCValues (FRAME_X_DISPLAY (f
), gc
, GCBackground
, &xgcv
);
467 color
.pixel
= xgcv
.background
;
468 x_query_color (f
, &color
);
469 cairo_set_source_rgb (FRAME_CR_CONTEXT (f
), color
.red
/ 65535.0,
470 color
.green
/ 65535.0, color
.blue
/ 65535.0);
473 /* Fringe bitmaps. */
475 static int max_fringe_bmp
= 0;
476 static cairo_pattern_t
**fringe_bmp
= 0;
479 x_cr_define_fringe_bitmap (int which
, unsigned short *bits
, int h
, int wd
)
482 cairo_surface_t
*surface
;
484 cairo_pattern_t
*pattern
;
486 if (which
>= max_fringe_bmp
)
489 max_fringe_bmp
= which
+ 20;
490 fringe_bmp
= (cairo_pattern_t
**) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (cairo_pattern_t
*));
491 while (i
< max_fringe_bmp
)
497 surface
= cairo_image_surface_create (CAIRO_FORMAT_A1
, wd
, h
);
498 stride
= cairo_image_surface_get_stride (surface
);
499 data
= cairo_image_surface_get_data (surface
);
501 for (i
= 0; i
< h
; i
++)
503 *((unsigned short *) data
) = bits
[i
];
507 cairo_surface_mark_dirty (surface
);
508 pattern
= cairo_pattern_create_for_surface (surface
);
509 cairo_surface_destroy (surface
);
513 fringe_bmp
[which
] = pattern
;
517 x_cr_destroy_fringe_bitmap (int which
)
519 if (which
>= max_fringe_bmp
)
522 if (fringe_bmp
[which
])
525 cairo_pattern_destroy (fringe_bmp
[which
]);
528 fringe_bmp
[which
] = 0;
532 x_cr_draw_image (struct frame
*f
,
534 cairo_pattern_t
*image
,
544 cairo_matrix_t matrix
;
545 cairo_surface_t
*surface
;
546 cairo_format_t format
;
548 cr
= x_begin_cr_clip (f
, gc
);
550 cairo_rectangle (cr
, dest_x
, dest_y
, width
, height
);
553 x_set_cr_source_with_gc_background (f
, gc
);
554 cairo_rectangle (cr
, dest_x
, dest_y
, width
, height
);
555 cairo_fill_preserve (cr
);
558 cairo_matrix_init_translate (&matrix
, src_x
- dest_x
, src_y
- dest_y
);
559 cairo_pattern_set_matrix (image
, &matrix
);
560 cairo_pattern_get_surface (image
, &surface
);
561 format
= cairo_image_surface_get_format (surface
);
562 if (format
!= CAIRO_FORMAT_A8
&& format
!= CAIRO_FORMAT_A1
)
564 cairo_set_source (cr
, image
);
569 x_set_cr_source_with_gc_foreground (f
, gc
);
570 cairo_mask (cr
, image
);
576 x_cr_draw_frame (cairo_t
*cr
, struct frame
*f
)
580 width
= FRAME_PIXEL_WIDTH (f
);
581 height
= FRAME_PIXEL_HEIGHT (f
);
583 x_prepare_for_xlibdraw (f
);
584 FRAME_CR_CONTEXT (f
) = cr
;
585 x_clear_area (f
, 0, 0, width
, height
);
586 expose_frame (f
, 0, 0, width
, height
);
587 FRAME_CR_CONTEXT (f
) = NULL
;
590 static cairo_status_t
591 x_cr_accumulate_data (void *closure
, const unsigned char *data
,
594 Lisp_Object
*acc
= (Lisp_Object
*) closure
;
596 *acc
= Fcons (make_unibyte_string (data
, length
), *acc
);
598 return CAIRO_STATUS_SUCCESS
;
602 x_cr_destroy (Lisp_Object arg
)
604 cairo_t
*cr
= (cairo_t
*) XSAVE_POINTER (arg
, 0);
612 x_cr_export_frames (Lisp_Object frames
, cairo_surface_type_t surface_type
)
615 cairo_surface_t
*surface
;
618 void (*surface_set_size_func
) (cairo_surface_t
*, double, double) = NULL
;
619 Lisp_Object acc
= Qnil
, args
[2];
620 int count
= SPECPDL_INDEX ();
624 f
= XFRAME (XCAR (frames
));
625 frames
= XCDR (frames
);
626 width
= FRAME_PIXEL_WIDTH (f
);
627 height
= FRAME_PIXEL_HEIGHT (f
);
630 #ifdef CAIRO_HAS_PDF_SURFACE
631 if (surface_type
== CAIRO_SURFACE_TYPE_PDF
)
633 surface
= cairo_pdf_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
635 surface_set_size_func
= cairo_pdf_surface_set_size
;
639 #ifdef CAIRO_HAS_PNG_FUNCTIONS
640 if (surface_type
== CAIRO_SURFACE_TYPE_IMAGE
)
641 surface
= cairo_image_surface_create (CAIRO_FORMAT_RGB24
, width
, height
);
644 #ifdef CAIRO_HAS_PS_SURFACE
645 if (surface_type
== CAIRO_SURFACE_TYPE_PS
)
647 surface
= cairo_ps_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
649 surface_set_size_func
= cairo_ps_surface_set_size
;
653 #ifdef CAIRO_HAS_SVG_SURFACE
654 if (surface_type
== CAIRO_SURFACE_TYPE_SVG
)
655 surface
= cairo_svg_surface_create_for_stream (x_cr_accumulate_data
, &acc
,
661 cr
= cairo_create (surface
);
662 cairo_surface_destroy (surface
);
663 record_unwind_protect (x_cr_destroy
, make_save_ptr (cr
));
671 x_prepare_for_xlibdraw (f
);
672 FRAME_CR_CONTEXT (f
) = cr
;
673 x_clear_area (f
, 0, 0, width
, height
);
674 expose_frame (f
, 0, 0, width
, height
);
675 FRAME_CR_CONTEXT (f
) = NULL
;
682 cairo_surface_show_page (surface
);
683 f
= XFRAME (XCAR (frames
));
684 frames
= XCDR (frames
);
685 width
= FRAME_PIXEL_WIDTH (f
);
686 height
= FRAME_PIXEL_HEIGHT (f
);
687 if (surface_set_size_func
)
688 (*surface_set_size_func
) (surface
, width
, height
);
692 #ifdef CAIRO_HAS_PNG_FUNCTIONS
693 if (surface_type
== CAIRO_SURFACE_TYPE_IMAGE
)
696 cairo_surface_flush (surface
);
697 cairo_surface_write_to_png_stream (surface
, x_cr_accumulate_data
, &acc
);
701 unbind_to (count
, Qnil
);
703 args
[0] = intern ("concat");
704 args
[1] = Fnreverse (acc
);
705 return Fapply (2, args
);
708 #endif /* USE_CAIRO */
711 x_prepare_for_xlibdraw (struct frame
*f
)
716 Lisp_Object rest
, frame
;
717 FOR_EACH_FRAME (rest
, frame
)
718 if (FRAME_X_P (XFRAME (frame
)))
719 x_prepare_for_xlibdraw (XFRAME (frame
));
723 cairo_t
*cr
= FRAME_CR_CONTEXT (f
);
727 cairo_surface_t
*surface
= cairo_get_target (cr
);
729 if (cairo_surface_get_type (surface
) == CAIRO_SURFACE_TYPE_XLIB
)
732 FRAME_CR_CONTEXT (f
) = NULL
;
740 x_set_clip_rectangles (struct frame
*f
, GC gc
, XRectangle
*rectangles
, int n
)
742 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, rectangles
, n
, Unsorted
);
744 eassert (n
>= 0 && n
<= MAX_CLIP_RECTS
);
747 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 1);
749 gc_ext
->n_clip_rects
= n
;
750 memcpy (gc_ext
->clip_rects
, rectangles
, sizeof (XRectangle
) * n
);
756 x_reset_clip_rectangles (struct frame
*f
, GC gc
)
758 XSetClipMask (FRAME_X_DISPLAY (f
), gc
, None
);
761 struct x_gc_ext_data
*gc_ext
= x_gc_get_ext_data (f
, gc
, 0);
764 gc_ext
->n_clip_rects
= 0;
770 x_fill_rectangle (struct frame
*f
, GC gc
, int x
, int y
,
771 unsigned int width
, unsigned int height
)
776 cr
= x_begin_cr_clip (f
, gc
);
777 x_set_cr_source_with_gc_foreground (f
, gc
);
778 cairo_rectangle (cr
, x
, y
, width
, height
);
782 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
783 gc
, x
, y
, width
, height
);
788 x_draw_rectangle (struct frame
*f
, GC gc
, int x
, int y
,
789 unsigned int width
, unsigned int height
)
794 cr
= x_begin_cr_clip (f
, gc
);
795 x_set_cr_source_with_gc_foreground (f
, gc
);
796 cairo_rectangle (cr
, x
+ 0.5, y
+ 0.5, width
, height
);
797 cairo_set_line_width (cr
, 1);
801 XDrawRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
802 gc
, x
, y
, width
, height
);
807 x_clear_window (struct frame
*f
)
812 cr
= x_begin_cr_clip (f
, NULL
);
813 x_set_cr_source_with_gc_background (f
, f
->output_data
.x
->normal_gc
);
817 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
823 x_fill_trapezoid_for_relief (struct frame
*f
, GC gc
, int x
, int y
,
824 unsigned int width
, unsigned int height
, int top_p
)
828 cr
= x_begin_cr_clip (f
, gc
);
829 x_set_cr_source_with_gc_foreground (f
, gc
);
830 cairo_move_to (cr
, top_p
? x
: x
+ height
, y
);
831 cairo_line_to (cr
, x
, y
+ height
);
832 cairo_line_to (cr
, top_p
? x
+ width
- height
: x
+ width
, y
+ height
);
833 cairo_line_to (cr
, x
+ width
, y
);
834 cairo_close_path (cr
);
840 x_draw_horizontal_wave (struct frame
*f
, GC gc
, int x
, int y
,
841 int width
, int height
, int wave_length
)
844 double dx
= wave_length
, dy
= height
- 1;
847 cr
= x_begin_cr_clip (f
, gc
);
848 x_set_cr_source_with_gc_foreground (f
, gc
);
849 cairo_rectangle (cr
, x
, y
, width
, height
);
854 xoffset
= x
% (wave_length
* 2);
856 xoffset
= wave_length
* 2;
859 xoffset
= x
% (wave_length
* 2) + wave_length
* 2;
860 n
= (width
+ xoffset
) / wave_length
+ 1;
861 if (xoffset
> wave_length
)
863 xoffset
-= wave_length
;
869 cairo_move_to (cr
, x
- xoffset
+ 0.5, y
+ 0.5);
872 cairo_rel_line_to (cr
, dx
, dy
);
875 cairo_set_line_width (cr
, 1);
882 /* Return the struct x_display_info corresponding to DPY. */
884 struct x_display_info
*
885 x_display_info_for_display (Display
*dpy
)
887 struct x_display_info
*dpyinfo
;
889 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
890 if (dpyinfo
->display
== dpy
)
897 x_find_topmost_parent (struct frame
*f
)
899 struct x_output
*x
= f
->output_data
.x
;
900 Window win
= None
, wi
= x
->parent_desc
;
901 Display
*dpy
= FRAME_X_DISPLAY (f
);
903 while (wi
!= FRAME_DISPLAY_INFO (f
)->root_window
)
907 unsigned int nchildren
;
910 if (XQueryTree (dpy
, win
, &root
, &wi
, &children
, &nchildren
))
919 #define OPAQUE 0xffffffff
922 x_set_frame_alpha (struct frame
*f
)
924 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
925 Display
*dpy
= FRAME_X_DISPLAY (f
);
926 Window win
= FRAME_OUTER_WINDOW (f
);
928 double alpha_min
= 1.0;
932 if (dpyinfo
->x_highlight_frame
== f
)
937 if (FLOATP (Vframe_alpha_lower_limit
))
938 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
939 else if (INTEGERP (Vframe_alpha_lower_limit
))
940 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
944 else if (alpha
> 1.0)
946 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
949 opac
= alpha
* OPAQUE
;
951 x_catch_errors (dpy
);
953 /* If there is a parent from the window manager, put the property there
954 also, to work around broken window managers that fail to do that.
955 Do this unconditionally as this function is called on reparent when
956 alpha has not changed on the frame. */
958 parent
= x_find_topmost_parent (f
);
960 XChangeProperty (dpy
, parent
, dpyinfo
->Xatom_net_wm_window_opacity
,
961 XA_CARDINAL
, 32, PropModeReplace
,
962 (unsigned char *) &opac
, 1);
964 /* return unless necessary */
969 unsigned long n
, left
;
971 rc
= XGetWindowProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
972 0, 1, False
, XA_CARDINAL
,
973 &actual
, &format
, &n
, &left
,
976 if (rc
== Success
&& actual
!= None
)
978 unsigned long value
= *(unsigned long *)data
;
988 XChangeProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
989 XA_CARDINAL
, 32, PropModeReplace
,
990 (unsigned char *) &opac
, 1);
994 /***********************************************************************
995 Starting and ending an update
996 ***********************************************************************/
998 /* Start an update of frame F. This function is installed as a hook
999 for update_begin, i.e. it is called when update_begin is called.
1000 This function is called prior to calls to x_update_window_begin for
1001 each window being updated. Currently, there is nothing to do here
1002 because all interesting stuff is done on a window basis. */
1005 x_update_begin (struct frame
*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 || s
->font_not_found_p
1726 || s
->extends_to_end_of_line_p
1729 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1730 s
->background_width
,
1731 s
->height
- 2 * box_line_width
);
1732 s
->background_filled_p
= true;
1738 /* Draw the foreground of glyph string S. */
1741 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1745 /* If first glyph of S has a left box line, start drawing the text
1746 of S to the right of that box line. */
1747 if (s
->face
->box
!= FACE_NO_BOX
1748 && s
->first_glyph
->left_box_line_p
)
1749 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1753 /* Draw characters of S as rectangles if S's font could not be
1755 if (s
->font_not_found_p
)
1757 for (i
= 0; i
< s
->nchars
; ++i
)
1759 struct glyph
*g
= s
->first_glyph
+ i
;
1760 x_draw_rectangle (s
->f
,
1761 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1763 x
+= g
->pixel_width
;
1768 struct font
*font
= s
->font
;
1769 int boff
= font
->baseline_offset
;
1772 if (font
->vertical_centering
)
1773 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1775 y
= s
->ybase
- boff
;
1777 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1778 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, false);
1780 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, true);
1781 if (s
->face
->overstrike
)
1782 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, false);
1786 /* Draw the foreground of composite glyph string S. */
1789 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1792 struct font
*font
= s
->font
;
1794 /* If first glyph of S has a left box line, start drawing the text
1795 of S to the right of that box line. */
1796 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1797 && s
->first_glyph
->left_box_line_p
)
1798 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1802 /* S is a glyph string for a composition. S->cmp_from is the index
1803 of the first character drawn for glyphs of this composition.
1804 S->cmp_from == 0 means we are drawing the very first character of
1805 this composition. */
1807 /* Draw a rectangle for the composition if the font for the very
1808 first character of the composition could not be loaded. */
1809 if (s
->font_not_found_p
)
1811 if (s
->cmp_from
== 0)
1812 x_draw_rectangle (s
->f
, s
->gc
, x
, s
->y
,
1813 s
->width
- 1, s
->height
- 1);
1815 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1819 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1820 /* TAB in a composition means display glyphs with padding
1821 space on the left or right. */
1822 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1824 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1825 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1827 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, false);
1828 if (s
->face
->overstrike
)
1829 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, false);
1834 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1839 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1841 glyph
= LGSTRING_GLYPH (gstring
, i
);
1842 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1843 width
+= LGLYPH_WIDTH (glyph
);
1846 int xoff
, yoff
, wadjust
;
1850 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1851 if (s
->face
->overstrike
)
1852 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, false);
1855 xoff
= LGLYPH_XOFF (glyph
);
1856 yoff
= LGLYPH_YOFF (glyph
);
1857 wadjust
= LGLYPH_WADJUST (glyph
);
1858 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, false);
1859 if (s
->face
->overstrike
)
1860 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
,
1869 font
->driver
->draw (s
, j
, i
, x
, y
, false);
1870 if (s
->face
->overstrike
)
1871 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, false);
1877 /* Draw the foreground of glyph string S for glyphless characters. */
1880 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1882 struct glyph
*glyph
= s
->first_glyph
;
1886 /* If first glyph of S has a left box line, start drawing the text
1887 of S to the right of that box line. */
1888 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1889 && s
->first_glyph
->left_box_line_p
)
1890 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1896 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1898 char buf
[7], *str
= NULL
;
1899 int len
= glyph
->u
.glyphless
.len
;
1901 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1904 && CHAR_TABLE_P (Vglyphless_char_display
)
1905 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1909 = (! glyph
->u
.glyphless
.for_no_font
1910 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1911 glyph
->u
.glyphless
.ch
)
1912 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1913 if (STRINGP (acronym
))
1914 str
= SSDATA (acronym
);
1917 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1919 sprintf (buf
, "%0*X",
1920 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1921 glyph
->u
.glyphless
.ch
);
1927 int upper_len
= (len
+ 1) / 2;
1930 /* It is assured that all LEN characters in STR is ASCII. */
1931 for (j
= 0; j
< len
; j
++)
1933 code
= s
->font
->driver
->encode_char (s
->font
, str
[j
]);
1934 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1936 s
->font
->driver
->draw (s
, 0, upper_len
,
1937 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1938 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1940 s
->font
->driver
->draw (s
, upper_len
, len
,
1941 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1942 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1945 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1946 x_draw_rectangle (s
->f
, s
->gc
,
1947 x
, s
->ybase
- glyph
->ascent
,
1948 glyph
->pixel_width
- 1,
1949 glyph
->ascent
+ glyph
->descent
- 1);
1950 x
+= glyph
->pixel_width
;
1954 #ifdef USE_X_TOOLKIT
1958 /* Return the frame on which widget WIDGET is used.. Abort if frame
1959 cannot be determined. */
1961 static struct frame
*
1962 x_frame_of_widget (Widget widget
)
1964 struct x_display_info
*dpyinfo
;
1965 Lisp_Object tail
, frame
;
1968 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1970 /* Find the top-level shell of the widget. Note that this function
1971 can be called when the widget is not yet realized, so XtWindow
1972 (widget) == 0. That's the reason we can't simply use
1973 x_any_window_to_frame. */
1974 while (!XtIsTopLevelShell (widget
))
1975 widget
= XtParent (widget
);
1977 /* Look for a frame with that top-level widget. Allocate the color
1978 on that frame to get the right gamma correction value. */
1979 FOR_EACH_FRAME (tail
, frame
)
1983 && f
->output_data
.nothing
!= 1
1984 && FRAME_DISPLAY_INFO (f
) == dpyinfo
1985 && f
->output_data
.x
->widget
== widget
)
1991 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1992 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1993 If this produces the same color as PIXEL, try a color where all RGB
1994 values have DELTA added. Return the allocated color in *PIXEL.
1995 DISPLAY is the X display, CMAP is the colormap to operate on.
1996 Value is true if successful. */
1999 x_alloc_lighter_color_for_widget (Widget widget
, Display
*display
, Colormap cmap
,
2000 unsigned long *pixel
, double factor
, int delta
)
2002 struct frame
*f
= x_frame_of_widget (widget
);
2003 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
2006 #endif /* USE_LUCID */
2009 /* Structure specifying which arguments should be passed by Xt to
2010 cvt_string_to_pixel. We want the widget's screen and colormap. */
2012 static XtConvertArgRec cvt_string_to_pixel_args
[] =
2014 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
2016 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
2021 /* The address of this variable is returned by
2022 cvt_string_to_pixel. */
2024 static Pixel cvt_string_to_pixel_value
;
2027 /* Convert a color name to a pixel color.
2029 DPY is the display we are working on.
2031 ARGS is an array of *NARGS XrmValue structures holding additional
2032 information about the widget for which the conversion takes place.
2033 The contents of this array are determined by the specification
2034 in cvt_string_to_pixel_args.
2036 FROM is a pointer to an XrmValue which points to the color name to
2037 convert. TO is an XrmValue in which to return the pixel color.
2039 CLOSURE_RET is a pointer to user-data, in which we record if
2040 we allocated the color or not.
2042 Value is True if successful, False otherwise. */
2045 cvt_string_to_pixel (Display
*dpy
, XrmValue
*args
, Cardinal
*nargs
,
2046 XrmValue
*from
, XrmValue
*to
,
2047 XtPointer
*closure_ret
)
2057 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
2058 "wrongParameters", "cvt_string_to_pixel",
2060 "Screen and colormap args required", NULL
, NULL
);
2064 screen
= *(Screen
**) args
[0].addr
;
2065 cmap
= *(Colormap
*) args
[1].addr
;
2066 color_name
= (String
) from
->addr
;
2068 if (strcmp (color_name
, XtDefaultBackground
) == 0)
2070 *closure_ret
= (XtPointer
) False
;
2071 pixel
= WhitePixelOfScreen (screen
);
2073 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
2075 *closure_ret
= (XtPointer
) False
;
2076 pixel
= BlackPixelOfScreen (screen
);
2078 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
2079 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
2081 pixel
= color
.pixel
;
2082 *closure_ret
= (XtPointer
) True
;
2087 Cardinal nparams
= 1;
2089 params
[0] = color_name
;
2090 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
2091 "badValue", "cvt_string_to_pixel",
2092 "XtToolkitError", "Invalid color `%s'",
2097 if (to
->addr
!= NULL
)
2099 if (to
->size
< sizeof (Pixel
))
2101 to
->size
= sizeof (Pixel
);
2105 *(Pixel
*) to
->addr
= pixel
;
2109 cvt_string_to_pixel_value
= pixel
;
2110 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
2113 to
->size
= sizeof (Pixel
);
2118 /* Free a pixel color which was previously allocated via
2119 cvt_string_to_pixel. This is registered as the destructor
2120 for this type of resource via XtSetTypeConverter.
2122 APP is the application context in which we work.
2124 TO is a pointer to an XrmValue holding the color to free.
2125 CLOSURE is the value we stored in CLOSURE_RET for this color
2126 in cvt_string_to_pixel.
2128 ARGS and NARGS are like for cvt_string_to_pixel. */
2131 cvt_pixel_dtor (XtAppContext app
, XrmValuePtr to
, XtPointer closure
, XrmValuePtr args
,
2136 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
2138 "Screen and colormap arguments required",
2141 else if (closure
!= NULL
)
2143 /* We did allocate the pixel, so free it. */
2144 Screen
*screen
= *(Screen
**) args
[0].addr
;
2145 Colormap cmap
= *(Colormap
*) args
[1].addr
;
2146 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
2147 (Pixel
*) to
->addr
, 1);
2152 #endif /* USE_X_TOOLKIT */
2155 /* Value is an array of XColor structures for the contents of the
2156 color map of display DPY. Set *NCELLS to the size of the array.
2157 Note that this probably shouldn't be called for large color maps,
2158 say a 24-bit TrueColor map. */
2160 static const XColor
*
2161 x_color_cells (Display
*dpy
, int *ncells
)
2163 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
2165 if (dpyinfo
->color_cells
== NULL
)
2167 Screen
*screen
= dpyinfo
->screen
;
2168 int ncolor_cells
= XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
2171 dpyinfo
->color_cells
= xnmalloc (ncolor_cells
,
2172 sizeof *dpyinfo
->color_cells
);
2173 dpyinfo
->ncolor_cells
= ncolor_cells
;
2175 for (i
= 0; i
< ncolor_cells
; ++i
)
2176 dpyinfo
->color_cells
[i
].pixel
= i
;
2178 XQueryColors (dpy
, dpyinfo
->cmap
,
2179 dpyinfo
->color_cells
, ncolor_cells
);
2182 *ncells
= dpyinfo
->ncolor_cells
;
2183 return dpyinfo
->color_cells
;
2187 /* On frame F, translate pixel colors to RGB values for the NCOLORS
2188 colors in COLORS. Use cached information, if available. */
2191 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
2193 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
2195 if (dpyinfo
->color_cells
)
2198 for (i
= 0; i
< ncolors
; ++i
)
2200 unsigned long pixel
= colors
[i
].pixel
;
2201 eassert (pixel
< dpyinfo
->ncolor_cells
);
2202 eassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
2203 colors
[i
] = dpyinfo
->color_cells
[pixel
];
2207 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
2211 /* On frame F, translate pixel color to RGB values for the color in
2212 COLOR. Use cached information, if available. */
2215 x_query_color (struct frame
*f
, XColor
*color
)
2217 x_query_colors (f
, color
, 1);
2221 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
2222 exact match can't be allocated, try the nearest color available.
2223 Value is true if successful. Set *COLOR to the color
2227 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
2231 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
2234 /* If we got to this point, the colormap is full, so we're going
2235 to try to get the next closest color. The algorithm used is
2236 a least-squares matching, which is what X uses for closest
2237 color matching with StaticColor visuals. */
2239 int max_color_delta
= 255;
2240 int max_delta
= 3 * max_color_delta
;
2241 int nearest_delta
= max_delta
+ 1;
2243 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
2245 for (nearest
= i
= 0; i
< ncells
; ++i
)
2247 int dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
2248 int dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
2249 int dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
2250 int delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
2252 if (delta
< nearest_delta
)
2255 nearest_delta
= delta
;
2259 color
->red
= cells
[nearest
].red
;
2260 color
->green
= cells
[nearest
].green
;
2261 color
->blue
= cells
[nearest
].blue
;
2262 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
2266 /* If allocation succeeded, and the allocated pixel color is not
2267 equal to a cached pixel color recorded earlier, there was a
2268 change in the colormap, so clear the color cache. */
2269 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
2270 XColor
*cached_color
;
2272 if (dpyinfo
->color_cells
2273 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
2274 (cached_color
->red
!= color
->red
2275 || cached_color
->blue
!= color
->blue
2276 || cached_color
->green
!= color
->green
)))
2278 xfree (dpyinfo
->color_cells
);
2279 dpyinfo
->color_cells
= NULL
;
2280 dpyinfo
->ncolor_cells
= 0;
2284 #ifdef DEBUG_X_COLORS
2286 register_color (color
->pixel
);
2287 #endif /* DEBUG_X_COLORS */
2293 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
2294 exact match can't be allocated, try the nearest color available.
2295 Value is true if successful. Set *COLOR to the color
2299 x_alloc_nearest_color (struct frame
*f
, Colormap cmap
, XColor
*color
)
2301 gamma_correct (f
, color
);
2302 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
2306 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
2307 It's necessary to do this instead of just using PIXEL directly to
2308 get color reference counts right. */
2311 x_copy_color (struct frame
*f
, unsigned long pixel
)
2315 color
.pixel
= pixel
;
2317 x_query_color (f
, &color
);
2318 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
2320 #ifdef DEBUG_X_COLORS
2321 register_color (pixel
);
2327 /* Brightness beyond which a color won't have its highlight brightness
2330 Nominally, highlight colors for `3d' faces are calculated by
2331 brightening an object's color by a constant scale factor, but this
2332 doesn't yield good results for dark colors, so for colors who's
2333 brightness is less than this value (on a scale of 0-65535) have an
2334 use an additional additive factor.
2336 The value here is set so that the default menu-bar/mode-line color
2337 (grey75) will not have its highlights changed at all. */
2338 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
2341 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
2342 or DELTA. Try a color with RGB values multiplied by FACTOR first.
2343 If this produces the same color as PIXEL, try a color where all RGB
2344 values have DELTA added. Return the allocated color in *PIXEL.
2345 DISPLAY is the X display, CMAP is the colormap to operate on.
2346 Value is non-zero if successful. */
2349 x_alloc_lighter_color (struct frame
*f
, Display
*display
, Colormap cmap
,
2350 unsigned long *pixel
, double factor
, int delta
)
2356 /* Get RGB color values. */
2357 color
.pixel
= *pixel
;
2358 x_query_color (f
, &color
);
2360 /* Change RGB values by specified FACTOR. Avoid overflow! */
2361 eassert (factor
>= 0);
2362 new.red
= min (0xffff, factor
* color
.red
);
2363 new.green
= min (0xffff, factor
* color
.green
);
2364 new.blue
= min (0xffff, factor
* color
.blue
);
2366 /* Calculate brightness of COLOR. */
2367 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
2369 /* We only boost colors that are darker than
2370 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
2371 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
2372 /* Make an additive adjustment to NEW, because it's dark enough so
2373 that scaling by FACTOR alone isn't enough. */
2375 /* How far below the limit this color is (0 - 1, 1 being darker). */
2376 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
2377 /* The additive adjustment. */
2378 int min_delta
= delta
* dimness
* factor
/ 2;
2382 new.red
= max (0, new.red
- min_delta
);
2383 new.green
= max (0, new.green
- min_delta
);
2384 new.blue
= max (0, new.blue
- min_delta
);
2388 new.red
= min (0xffff, min_delta
+ new.red
);
2389 new.green
= min (0xffff, min_delta
+ new.green
);
2390 new.blue
= min (0xffff, min_delta
+ new.blue
);
2394 /* Try to allocate the color. */
2395 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
2398 if (new.pixel
== *pixel
)
2400 /* If we end up with the same color as before, try adding
2401 delta to the RGB values. */
2402 x_free_colors (f
, &new.pixel
, 1);
2404 new.red
= min (0xffff, delta
+ color
.red
);
2405 new.green
= min (0xffff, delta
+ color
.green
);
2406 new.blue
= min (0xffff, delta
+ color
.blue
);
2407 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
2418 /* Set up the foreground color for drawing relief lines of glyph
2419 string S. RELIEF is a pointer to a struct relief containing the GC
2420 with which lines will be drawn. Use a color that is FACTOR or
2421 DELTA lighter or darker than the relief's background which is found
2422 in S->f->output_data.x->relief_background. If such a color cannot
2423 be allocated, use DEFAULT_PIXEL, instead. */
2426 x_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
2427 int delta
, unsigned long default_pixel
)
2430 struct x_output
*di
= f
->output_data
.x
;
2431 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
2432 unsigned long pixel
;
2433 unsigned long background
= di
->relief_background
;
2434 Colormap cmap
= FRAME_X_COLORMAP (f
);
2435 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
2436 Display
*dpy
= FRAME_X_DISPLAY (f
);
2438 xgcv
.graphics_exposures
= False
;
2439 xgcv
.line_width
= 1;
2441 /* Free previously allocated color. The color cell will be reused
2442 when it has been freed as many times as it was allocated, so this
2443 doesn't affect faces using the same colors. */
2444 if (relief
->gc
&& relief
->pixel
!= -1)
2446 x_free_colors (f
, &relief
->pixel
, 1);
2450 /* Allocate new color. */
2451 xgcv
.foreground
= default_pixel
;
2453 if (dpyinfo
->n_planes
!= 1
2454 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
2455 xgcv
.foreground
= relief
->pixel
= pixel
;
2457 if (relief
->gc
== 0)
2459 xgcv
.stipple
= dpyinfo
->gray
;
2461 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
2464 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
2468 /* Set up colors for the relief lines around glyph string S. */
2471 x_setup_relief_colors (struct glyph_string
*s
)
2473 struct x_output
*di
= s
->f
->output_data
.x
;
2474 unsigned long color
;
2476 if (s
->face
->use_box_color_for_shadows_p
)
2477 color
= s
->face
->box_color
;
2478 else if (s
->first_glyph
->type
== IMAGE_GLYPH
2480 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
2481 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
2486 /* Get the background color of the face. */
2487 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
2488 color
= xgcv
.background
;
2491 if (di
->white_relief
.gc
== 0
2492 || color
!= di
->relief_background
)
2494 di
->relief_background
= color
;
2495 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
2496 WHITE_PIX_DEFAULT (s
->f
));
2497 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
2498 BLACK_PIX_DEFAULT (s
->f
));
2503 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2504 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2505 to draw, it must be >= 0. RAISED_P means draw a raised
2506 relief. LEFT_P means draw a relief on the left side of
2507 the rectangle. RIGHT_P means draw a relief on the right
2508 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2512 x_draw_relief_rect (struct frame
*f
,
2513 int left_x
, int top_y
, int right_x
, int bottom_y
,
2514 int width
, bool raised_p
, bool top_p
, bool bot_p
,
2515 bool left_p
, bool right_p
,
2516 XRectangle
*clip_rect
)
2519 GC top_left_gc
, bottom_right_gc
;
2523 top_left_gc
= f
->output_data
.x
->white_relief
.gc
;
2524 bottom_right_gc
= f
->output_data
.x
->black_relief
.gc
;
2528 top_left_gc
= f
->output_data
.x
->black_relief
.gc
;
2529 bottom_right_gc
= f
->output_data
.x
->white_relief
.gc
;
2532 x_set_clip_rectangles (f
, top_left_gc
, clip_rect
, 1);
2533 x_set_clip_rectangles (f
, bottom_right_gc
, clip_rect
, 1);
2536 x_fill_rectangle (f
, top_left_gc
, left_x
, top_y
,
2537 width
, bottom_y
+ 1 - top_y
);
2539 x_fill_rectangle (f
, bottom_right_gc
, right_x
+ 1 - width
, top_y
,
2540 width
, bottom_y
+ 1 - top_y
);
2544 x_fill_rectangle (f
, top_left_gc
, left_x
, top_y
,
2545 right_x
+ 1 - left_x
, width
);
2547 x_fill_trapezoid_for_relief (f
, top_left_gc
, left_x
, top_y
,
2548 right_x
+ 1 - left_x
, width
, 1);
2553 x_fill_rectangle (f
, bottom_right_gc
, left_x
, bottom_y
+ 1 - width
,
2554 right_x
+ 1 - left_x
, width
);
2556 x_fill_trapezoid_for_relief (f
, bottom_right_gc
,
2557 left_x
, bottom_y
+ 1 - width
,
2558 right_x
+ 1 - left_x
, width
, 0);
2561 x_set_clip_rectangles (f
, top_left_gc
, clip_rect
, 1);
2562 x_set_clip_rectangles (f
, bottom_right_gc
, clip_rect
, 1);
2564 Display
*dpy
= FRAME_X_DISPLAY (f
);
2565 Window window
= FRAME_X_WINDOW (f
);
2570 gc
= f
->output_data
.x
->white_relief
.gc
;
2572 gc
= f
->output_data
.x
->black_relief
.gc
;
2573 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2575 /* This code is more complicated than it has to be, because of two
2576 minor hacks to make the boxes look nicer: (i) if width > 1, draw
2577 the outermost line using the black relief. (ii) Omit the four
2584 XDrawLine (dpy
, window
, gc
,
2585 left_x
+ left_p
, top_y
,
2586 right_x
+ !right_p
, top_y
);
2588 for (i
= 1; i
< width
; ++i
)
2589 XDrawLine (dpy
, window
, gc
,
2590 left_x
+ i
* left_p
, top_y
+ i
,
2591 right_x
+ 1 - i
* right_p
, top_y
+ i
);
2598 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
2600 XClearArea (dpy
, window
, left_x
, top_y
, 1, 1, False
);
2601 XClearArea (dpy
, window
, left_x
, bottom_y
, 1, 1, False
);
2603 for (i
= (width
> 1 ? 1 : 0); i
< width
; ++i
)
2604 XDrawLine (dpy
, window
, gc
,
2605 left_x
+ i
, top_y
+ (i
+ 1) * top_p
,
2606 left_x
+ i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
2609 XSetClipMask (dpy
, gc
, None
);
2611 gc
= f
->output_data
.x
->black_relief
.gc
;
2613 gc
= f
->output_data
.x
->white_relief
.gc
;
2614 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2618 /* Outermost top line. */
2620 XDrawLine (dpy
, window
, gc
,
2621 left_x
+ left_p
, top_y
,
2622 right_x
+ !right_p
, top_y
);
2624 /* Outermost left line. */
2626 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
2632 XDrawLine (dpy
, window
, gc
,
2633 left_x
+ left_p
, bottom_y
,
2634 right_x
+ !right_p
, bottom_y
);
2635 for (i
= 1; i
< width
; ++i
)
2636 XDrawLine (dpy
, window
, gc
,
2637 left_x
+ i
* left_p
, bottom_y
- i
,
2638 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2644 XClearArea (dpy
, window
, right_x
, top_y
, 1, 1, False
);
2645 XClearArea (dpy
, window
, right_x
, bottom_y
, 1, 1, False
);
2646 for (i
= 0; i
< width
; ++i
)
2647 XDrawLine (dpy
, window
, gc
,
2648 right_x
- i
, top_y
+ (i
+ 1) * top_p
,
2649 right_x
- i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
2652 x_reset_clip_rectangles (f
, gc
);
2658 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2659 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2660 draw, it must be >= 0. LEFT_P means draw a line on the
2661 left side of the rectangle. RIGHT_P means draw a line
2662 on the right side of the rectangle. CLIP_RECT is the clipping
2663 rectangle to use when drawing. */
2666 x_draw_box_rect (struct glyph_string
*s
,
2667 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
2668 bool left_p
, bool right_p
, XRectangle
*clip_rect
)
2672 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2673 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2674 x_set_clip_rectangles (s
->f
, s
->gc
, clip_rect
, 1);
2677 x_fill_rectangle (s
->f
, s
->gc
,
2678 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2682 x_fill_rectangle (s
->f
, s
->gc
,
2683 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2686 x_fill_rectangle (s
->f
, s
->gc
,
2687 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2691 x_fill_rectangle (s
->f
, s
->gc
,
2692 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2694 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2695 x_reset_clip_rectangles (s
->f
, s
->gc
);
2699 /* Draw a box around glyph string S. */
2702 x_draw_glyph_string_box (struct glyph_string
*s
)
2704 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
;
2705 bool raised_p
, left_p
, right_p
;
2706 struct glyph
*last_glyph
;
2707 XRectangle clip_rect
;
2709 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2710 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2711 : window_box_right (s
->w
, s
->area
));
2713 /* The glyph that may have a right box line. */
2714 last_glyph
= (s
->cmp
|| s
->img
2716 : s
->first_glyph
+ s
->nchars
- 1);
2718 width
= eabs (s
->face
->box_line_width
);
2719 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2721 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2723 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2725 bottom_y
= top_y
+ s
->height
- 1;
2727 left_p
= (s
->first_glyph
->left_box_line_p
2728 || (s
->hl
== DRAW_MOUSE_FACE
2730 || s
->prev
->hl
!= s
->hl
)));
2731 right_p
= (last_glyph
->right_box_line_p
2732 || (s
->hl
== DRAW_MOUSE_FACE
2734 || s
->next
->hl
!= s
->hl
)));
2736 get_glyph_string_clip_rect (s
, &clip_rect
);
2738 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2739 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2740 left_p
, right_p
, &clip_rect
);
2743 x_setup_relief_colors (s
);
2744 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2745 width
, raised_p
, true, true, left_p
, right_p
,
2751 /* Draw foreground of image glyph string S. */
2754 x_draw_image_foreground (struct glyph_string
*s
)
2757 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2759 /* If first glyph of S has a left box line, start drawing it to the
2760 right of that line. */
2761 if (s
->face
->box
!= FACE_NO_BOX
2762 && s
->first_glyph
->left_box_line_p
2764 x
+= eabs (s
->face
->box_line_width
);
2766 /* If there is a margin around the image, adjust x- and y-position
2768 if (s
->slice
.x
== 0)
2769 x
+= s
->img
->hmargin
;
2770 if (s
->slice
.y
== 0)
2771 y
+= s
->img
->vmargin
;
2777 /* We can't set both a clip mask and use XSetClipRectangles
2778 because the latter also sets a clip mask. We also can't
2779 trust on the shape extension to be available
2780 (XShapeCombineRegion). So, compute the rectangle to draw
2782 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2785 XRectangle clip_rect
, image_rect
, r
;
2787 xgcv
.clip_mask
= s
->img
->mask
;
2788 xgcv
.clip_x_origin
= x
;
2789 xgcv
.clip_y_origin
= y
;
2790 xgcv
.function
= GXcopy
;
2791 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2793 get_glyph_string_clip_rect (s
, &clip_rect
);
2796 image_rect
.width
= s
->slice
.width
;
2797 image_rect
.height
= s
->slice
.height
;
2798 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2799 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2800 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2801 r
.width
, r
.height
, r
.x
, r
.y
);
2805 XRectangle clip_rect
, image_rect
, r
;
2807 get_glyph_string_clip_rect (s
, &clip_rect
);
2810 image_rect
.width
= s
->slice
.width
;
2811 image_rect
.height
= s
->slice
.height
;
2812 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2813 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2814 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2815 r
.width
, r
.height
, r
.x
, r
.y
);
2817 /* When the image has a mask, we can expect that at
2818 least part of a mouse highlight or a block cursor will
2819 be visible. If the image doesn't have a mask, make
2820 a block cursor visible by drawing a rectangle around
2821 the image. I believe it's looking better if we do
2822 nothing here for mouse-face. */
2823 if (s
->hl
== DRAW_CURSOR
)
2825 int relief
= eabs (s
->img
->relief
);
2826 x_draw_rectangle (s
->f
, s
->gc
,
2827 x
- relief
, y
- relief
,
2828 s
->slice
.width
+ relief
*2 - 1,
2829 s
->slice
.height
+ relief
*2 - 1);
2834 /* Draw a rectangle if image could not be loaded. */
2835 x_draw_rectangle (s
->f
, s
->gc
, x
, y
,
2836 s
->slice
.width
- 1, s
->slice
.height
- 1);
2840 /* Draw a relief around the image glyph string S. */
2843 x_draw_image_relief (struct glyph_string
*s
)
2846 bool raised_p
, top_p
, bot_p
, left_p
, right_p
;
2847 int extra_x
, extra_y
;
2850 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2852 /* If first glyph of S has a left box line, start drawing it to the
2853 right of that line. */
2854 if (s
->face
->box
!= FACE_NO_BOX
2855 && s
->first_glyph
->left_box_line_p
2857 x
+= eabs (s
->face
->box_line_width
);
2859 /* If there is a margin around the image, adjust x- and y-position
2861 if (s
->slice
.x
== 0)
2862 x
+= s
->img
->hmargin
;
2863 if (s
->slice
.y
== 0)
2864 y
+= s
->img
->vmargin
;
2866 if (s
->hl
== DRAW_IMAGE_SUNKEN
2867 || s
->hl
== DRAW_IMAGE_RAISED
)
2869 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2870 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2874 thick
= eabs (s
->img
->relief
);
2875 raised_p
= s
->img
->relief
> 0;
2878 x1
= x
+ s
->slice
.width
- 1;
2879 y1
= y
+ s
->slice
.height
- 1;
2881 extra_x
= extra_y
= 0;
2882 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
2884 if (CONSP (Vtool_bar_button_margin
)
2885 && INTEGERP (XCAR (Vtool_bar_button_margin
))
2886 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
2888 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
2889 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
2891 else if (INTEGERP (Vtool_bar_button_margin
))
2892 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
2895 top_p
= bot_p
= left_p
= right_p
= false;
2897 if (s
->slice
.x
== 0)
2898 x
-= thick
+ extra_x
, left_p
= true;
2899 if (s
->slice
.y
== 0)
2900 y
-= thick
+ extra_y
, top_p
= true;
2901 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
2902 x1
+= thick
+ extra_x
, right_p
= true;
2903 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
2904 y1
+= thick
+ extra_y
, bot_p
= true;
2906 x_setup_relief_colors (s
);
2907 get_glyph_string_clip_rect (s
, &r
);
2908 x_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
2909 top_p
, bot_p
, left_p
, right_p
, &r
);
2913 /* Draw the foreground of image glyph string S to PIXMAP. */
2916 x_draw_image_foreground_1 (struct glyph_string
*s
, Pixmap pixmap
)
2919 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2921 /* If first glyph of S has a left box line, start drawing it to the
2922 right of that line. */
2923 if (s
->face
->box
!= FACE_NO_BOX
2924 && s
->first_glyph
->left_box_line_p
2926 x
+= eabs (s
->face
->box_line_width
);
2928 /* If there is a margin around the image, adjust x- and y-position
2930 if (s
->slice
.x
== 0)
2931 x
+= s
->img
->hmargin
;
2932 if (s
->slice
.y
== 0)
2933 y
+= s
->img
->vmargin
;
2939 /* We can't set both a clip mask and use XSetClipRectangles
2940 because the latter also sets a clip mask. We also can't
2941 trust on the shape extension to be available
2942 (XShapeCombineRegion). So, compute the rectangle to draw
2944 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2948 xgcv
.clip_mask
= s
->img
->mask
;
2949 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2950 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2951 xgcv
.function
= GXcopy
;
2952 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2954 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2955 s
->slice
.x
, s
->slice
.y
,
2956 s
->slice
.width
, s
->slice
.height
, x
, y
);
2957 XSetClipMask (s
->display
, s
->gc
, None
);
2961 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2962 s
->slice
.x
, s
->slice
.y
,
2963 s
->slice
.width
, s
->slice
.height
, x
, y
);
2965 /* When the image has a mask, we can expect that at
2966 least part of a mouse highlight or a block cursor will
2967 be visible. If the image doesn't have a mask, make
2968 a block cursor visible by drawing a rectangle around
2969 the image. I believe it's looking better if we do
2970 nothing here for mouse-face. */
2971 if (s
->hl
== DRAW_CURSOR
)
2973 int r
= eabs (s
->img
->relief
);
2974 x_draw_rectangle (s
->f
, s
->gc
, x
- r
, y
- r
,
2975 s
->slice
.width
+ r
*2 - 1,
2976 s
->slice
.height
+ r
*2 - 1);
2981 /* Draw a rectangle if image could not be loaded. */
2982 x_draw_rectangle (s
->f
, s
->gc
, x
, y
,
2983 s
->slice
.width
- 1, s
->slice
.height
- 1);
2987 /* Draw part of the background of glyph string S. X, Y, W, and H
2988 give the rectangle to draw. */
2991 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2995 /* Fill background with a stipple pattern. */
2996 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2997 x_fill_rectangle (s
->f
, s
->gc
, x
, y
, w
, h
);
2998 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3001 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
3005 /* Draw image glyph string S.
3008 s->x +-------------------------
3011 | +-------------------------
3014 | | +-------------------
3020 x_draw_image_glyph_string (struct glyph_string
*s
)
3022 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
3023 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
3025 Pixmap pixmap
= None
;
3028 if (s
->slice
.y
== 0)
3029 height
-= box_line_vwidth
;
3030 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
3031 height
-= box_line_vwidth
;
3033 /* Fill background with face under the image. Do it only if row is
3034 taller than image or if image has a clip mask to reduce
3036 s
->stippled_p
= s
->face
->stipple
!= 0;
3037 if (height
> s
->slice
.height
3041 || s
->img
->pixmap
== 0
3042 || s
->width
!= s
->background_width
)
3046 /* Create a pixmap as large as the glyph string. Fill it
3047 with the background color. Copy the image to it, using
3048 its mask. Copy the temporary pixmap to the display. */
3049 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
3050 int depth
= DefaultDepthOfScreen (screen
);
3052 /* Create a pixmap as large as the glyph string. */
3053 pixmap
= XCreatePixmap (s
->display
, s
->window
,
3054 s
->background_width
,
3057 /* Don't clip in the following because we're working on the
3059 XSetClipMask (s
->display
, s
->gc
, None
);
3061 /* Fill the pixmap with the background color/stipple. */
3064 /* Fill background with a stipple pattern. */
3065 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3066 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
3067 XFillRectangle (s
->display
, pixmap
, s
->gc
,
3068 0, 0, s
->background_width
, s
->height
);
3069 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3070 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
3075 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
3077 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
3078 XFillRectangle (s
->display
, pixmap
, s
->gc
,
3079 0, 0, s
->background_width
, s
->height
);
3080 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3087 int width
= s
->background_width
;
3089 if (s
->first_glyph
->left_box_line_p
3092 x
+= box_line_hwidth
;
3093 width
-= box_line_hwidth
;
3096 if (s
->slice
.y
== 0)
3097 y
+= box_line_vwidth
;
3099 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
3102 s
->background_filled_p
= true;
3105 /* Draw the foreground. */
3106 if (s
->img
->cr_data
)
3108 cairo_t
*cr
= x_begin_cr_clip (s
->f
, s
->gc
);
3110 int x
= s
->x
+ s
->img
->hmargin
;
3111 int y
= s
->y
+ s
->img
->vmargin
;
3112 int width
= s
->background_width
;
3114 cairo_set_source_surface (cr
, s
->img
->cr_data
,
3117 cairo_rectangle (cr
, x
, y
, width
, height
);
3119 x_end_cr_clip (s
->f
);
3121 else if (pixmap
!= None
)
3123 x_draw_image_foreground_1 (s
, pixmap
);
3124 x_set_glyph_string_clipping (s
);
3125 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
3126 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
3127 XFreePixmap (s
->display
, pixmap
);
3130 x_draw_image_foreground (s
);
3132 /* If we must draw a relief around the image, do it. */
3134 || s
->hl
== DRAW_IMAGE_RAISED
3135 || s
->hl
== DRAW_IMAGE_SUNKEN
)
3136 x_draw_image_relief (s
);
3140 /* Draw stretch glyph string S. */
3143 x_draw_stretch_glyph_string (struct glyph_string
*s
)
3145 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
3147 if (s
->hl
== DRAW_CURSOR
3148 && !x_stretch_cursor_p
)
3150 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
3151 wide as the stretch glyph. */
3152 int width
, background_width
= s
->background_width
;
3155 if (!s
->row
->reversed_p
)
3157 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
3161 background_width
-= left_x
- x
;
3167 /* In R2L rows, draw the cursor on the right edge of the
3169 int right_x
= window_box_right (s
->w
, TEXT_AREA
);
3171 if (x
+ background_width
> right_x
)
3172 background_width
-= x
- right_x
;
3173 x
+= background_width
;
3175 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
3176 if (s
->row
->reversed_p
)
3180 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
3182 /* Clear rest using the GC of the original non-cursor face. */
3183 if (width
< background_width
)
3186 int w
= background_width
- width
, h
= s
->height
;
3190 if (!s
->row
->reversed_p
)
3194 if (s
->row
->mouse_face_p
3195 && cursor_in_mouse_face_p (s
->w
))
3197 x_set_mouse_face_gc (s
);
3203 get_glyph_string_clip_rect (s
, &r
);
3204 x_set_clip_rectangles (s
->f
, gc
, &r
, 1);
3206 if (s
->face
->stipple
)
3208 /* Fill background with a stipple pattern. */
3209 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
3210 x_fill_rectangle (s
->f
, gc
, x
, y
, w
, h
);
3211 XSetFillStyle (s
->display
, gc
, FillSolid
);
3216 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
3217 XSetForeground (s
->display
, gc
, xgcv
.background
);
3218 x_fill_rectangle (s
->f
, gc
, x
, y
, w
, h
);
3219 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
3222 XSetClipMask (s
->display
, gc
, None
);
3225 else if (!s
->background_filled_p
)
3227 int background_width
= s
->background_width
;
3228 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
3230 /* Don't draw into left margin, fringe or scrollbar area
3231 except for header line and mode line. */
3232 if (x
< left_x
&& !s
->row
->mode_line_p
)
3234 background_width
-= left_x
- x
;
3237 if (background_width
> 0)
3238 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
3241 s
->background_filled_p
= true;
3245 Draw a wavy line under S. The wave fills wave_height pixels from y0.
3251 wave_height = 3 | * * * *
3256 x_draw_underwave (struct glyph_string
*s
)
3258 int wave_height
= 3, wave_length
= 2;
3260 x_draw_horizontal_wave (s
->f
, s
->gc
, s
->x
, s
->ybase
- wave_height
+ 3,
3261 s
->width
, wave_height
, wave_length
);
3262 #else /* not USE_CAIRO */
3263 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, xmax
;
3265 XRectangle wave_clip
, string_clip
, final_clip
;
3268 dy
= wave_height
- 1;
3270 y0
= s
->ybase
- wave_height
+ 3;
3274 /* Find and set clipping rectangle */
3278 wave_clip
.width
= width
;
3279 wave_clip
.height
= wave_height
;
3280 get_glyph_string_clip_rect (s
, &string_clip
);
3282 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
3285 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &final_clip
, 1, Unsorted
);
3287 /* Draw the waves */
3289 x1
= x0
- (x0
% dx
);
3291 odd
= (x1
/ dx
) & 1;
3299 if (INT_MAX
- dx
< xmax
)
3304 XDrawLine (s
->display
, s
->window
, s
->gc
, x1
, y1
, x2
, y2
);
3306 x2
+= dx
, y2
= y0
+ odd
*dy
;
3310 /* Restore previous clipping rectangle(s) */
3311 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, s
->clip
, s
->num_clips
, Unsorted
);
3312 #endif /* not USE_CAIRO */
3316 /* Draw glyph string S. */
3319 x_draw_glyph_string (struct glyph_string
*s
)
3321 bool relief_drawn_p
= false;
3323 /* If S draws into the background of its successors, draw the
3324 background of the successors first so that S can draw into it.
3325 This makes S->next use XDrawString instead of XDrawImageString. */
3326 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
3329 struct glyph_string
*next
;
3331 for (width
= 0, next
= s
->next
;
3332 next
&& width
< s
->right_overhang
;
3333 width
+= next
->width
, next
= next
->next
)
3334 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
3336 x_set_glyph_string_gc (next
);
3337 x_set_glyph_string_clipping (next
);
3338 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
3339 x_draw_stretch_glyph_string (next
);
3341 x_draw_glyph_string_background (next
, true);
3342 next
->num_clips
= 0;
3346 /* Set up S->gc, set clipping and draw S. */
3347 x_set_glyph_string_gc (s
);
3349 /* Draw relief (if any) in advance for char/composition so that the
3350 glyph string can be drawn over it. */
3351 if (!s
->for_overlaps
3352 && s
->face
->box
!= FACE_NO_BOX
3353 && (s
->first_glyph
->type
== CHAR_GLYPH
3354 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
3357 x_set_glyph_string_clipping (s
);
3358 x_draw_glyph_string_background (s
, true);
3359 x_draw_glyph_string_box (s
);
3360 x_set_glyph_string_clipping (s
);
3361 relief_drawn_p
= true;
3363 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
3365 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
3366 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
3367 /* We must clip just this glyph. left_overhang part has already
3368 drawn when s->prev was drawn, and right_overhang part will be
3369 drawn later when s->next is drawn. */
3370 x_set_glyph_string_clipping_exactly (s
, s
);
3372 x_set_glyph_string_clipping (s
);
3374 switch (s
->first_glyph
->type
)
3377 x_draw_image_glyph_string (s
);
3381 x_draw_stretch_glyph_string (s
);
3385 if (s
->for_overlaps
)
3386 s
->background_filled_p
= true;
3388 x_draw_glyph_string_background (s
, false);
3389 x_draw_glyph_string_foreground (s
);
3392 case COMPOSITE_GLYPH
:
3393 if (s
->for_overlaps
|| (s
->cmp_from
> 0
3394 && ! s
->first_glyph
->u
.cmp
.automatic
))
3395 s
->background_filled_p
= true;
3397 x_draw_glyph_string_background (s
, true);
3398 x_draw_composite_glyph_string_foreground (s
);
3401 case GLYPHLESS_GLYPH
:
3402 if (s
->for_overlaps
)
3403 s
->background_filled_p
= true;
3405 x_draw_glyph_string_background (s
, true);
3406 x_draw_glyphless_glyph_string_foreground (s
);
3413 if (!s
->for_overlaps
)
3415 /* Draw underline. */
3416 if (s
->face
->underline_p
)
3418 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
3420 if (s
->face
->underline_defaulted_p
)
3421 x_draw_underwave (s
);
3425 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3426 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
3427 x_draw_underwave (s
);
3428 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3431 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
3433 unsigned long thickness
, position
;
3436 if (s
->prev
&& s
->prev
->face
->underline_p
3437 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
3439 /* We use the same underline style as the previous one. */
3440 thickness
= s
->prev
->underline_thickness
;
3441 position
= s
->prev
->underline_position
;
3445 /* Get the underline thickness. Default is 1 pixel. */
3446 if (s
->font
&& s
->font
->underline_thickness
> 0)
3447 thickness
= s
->font
->underline_thickness
;
3450 if (x_underline_at_descent_line
)
3451 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
3454 /* Get the underline position. This is the recommended
3455 vertical offset in pixels from the baseline to the top of
3456 the underline. This is a signed value according to the
3457 specs, and its default is
3459 ROUND ((maximum descent) / 2), with
3460 ROUND(x) = floor (x + 0.5) */
3462 if (x_use_underline_position_properties
3463 && s
->font
&& s
->font
->underline_position
>= 0)
3464 position
= s
->font
->underline_position
;
3466 position
= (s
->font
->descent
+ 1) / 2;
3468 position
= underline_minimum_offset
;
3470 position
= max (position
, underline_minimum_offset
);
3472 /* Check the sanity of thickness and position. We should
3473 avoid drawing underline out of the current line area. */
3474 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
3475 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
3476 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
3477 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
3478 s
->underline_thickness
= thickness
;
3479 s
->underline_position
= position
;
3480 y
= s
->ybase
+ position
;
3481 if (s
->face
->underline_defaulted_p
)
3482 x_fill_rectangle (s
->f
, s
->gc
,
3483 s
->x
, y
, s
->width
, thickness
);
3487 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3488 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
3489 x_fill_rectangle (s
->f
, s
->gc
,
3490 s
->x
, y
, s
->width
, thickness
);
3491 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3495 /* Draw overline. */
3496 if (s
->face
->overline_p
)
3498 unsigned long dy
= 0, h
= 1;
3500 if (s
->face
->overline_color_defaulted_p
)
3501 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3506 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3507 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
3508 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3510 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3514 /* Draw strike-through. */
3515 if (s
->face
->strike_through_p
)
3517 unsigned long h
= 1;
3518 unsigned long dy
= (s
->height
- h
) / 2;
3520 if (s
->face
->strike_through_color_defaulted_p
)
3521 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3526 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3527 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
3528 x_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3530 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3534 /* Draw relief if not yet drawn. */
3535 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
3536 x_draw_glyph_string_box (s
);
3540 struct glyph_string
*prev
;
3542 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
3543 if (prev
->hl
!= s
->hl
3544 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
3546 /* As prev was drawn while clipped to its own area, we
3547 must draw the right_overhang part using s->hl now. */
3548 enum draw_glyphs_face save
= prev
->hl
;
3551 x_set_glyph_string_gc (prev
);
3552 x_set_glyph_string_clipping_exactly (s
, prev
);
3553 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
3554 x_draw_glyph_string_foreground (prev
);
3556 x_draw_composite_glyph_string_foreground (prev
);
3557 x_reset_clip_rectangles (prev
->f
, prev
->gc
);
3559 prev
->num_clips
= 0;
3565 struct glyph_string
*next
;
3567 for (next
= s
->next
; next
; next
= next
->next
)
3568 if (next
->hl
!= s
->hl
3569 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
3571 /* As next will be drawn while clipped to its own area,
3572 we must draw the left_overhang part using s->hl now. */
3573 enum draw_glyphs_face save
= next
->hl
;
3576 x_set_glyph_string_gc (next
);
3577 x_set_glyph_string_clipping_exactly (s
, next
);
3578 if (next
->first_glyph
->type
== CHAR_GLYPH
)
3579 x_draw_glyph_string_foreground (next
);
3581 x_draw_composite_glyph_string_foreground (next
);
3582 x_reset_clip_rectangles (next
->f
, next
->gc
);
3584 next
->num_clips
= 0;
3585 next
->clip_head
= s
->next
;
3590 /* Reset clipping. */
3591 x_reset_clip_rectangles (s
->f
, s
->gc
);
3595 /* Shift display to make room for inserted glyphs. */
3598 x_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
, int width
, int height
, int shift_by
)
3600 x_prepare_for_xlibdraw (f
);
3601 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3602 f
->output_data
.x
->normal_gc
,
3603 x
, y
, width
, height
,
3607 /* Delete N glyphs at the nominal cursor position. Not implemented
3611 x_delete_glyphs (struct frame
*f
, register int n
)
3617 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
3618 If they are <= 0, this is probably an error. */
3621 x_clear_area1 (Display
*dpy
, Window window
,
3622 int x
, int y
, int width
, int height
, int exposures
)
3624 eassert (width
> 0 && height
> 0);
3625 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
3630 x_clear_area (struct frame
*f
, int x
, int y
, int width
, int height
)
3635 eassert (width
> 0 && height
> 0);
3637 cr
= x_begin_cr_clip (f
, NULL
);
3638 x_set_cr_source_with_gc_background (f
, f
->output_data
.x
->normal_gc
);
3639 cairo_rectangle (cr
, x
, y
, width
, height
);
3643 x_clear_area1 (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3644 x
, y
, width
, height
, False
);
3649 /* Clear an entire frame. */
3652 x_clear_frame (struct frame
*f
)
3654 /* Clearing the frame will erase any cursor, so mark them all as no
3656 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
3662 /* We have to clear the scroll bars. If we have changed colors or
3663 something like that, then they should be notified. */
3664 x_scroll_bar_clear (f
);
3666 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3667 /* Make sure scroll bars are redrawn. As they aren't redrawn by
3668 redisplay, do it here. */
3669 if (FRAME_GTK_WIDGET (f
))
3670 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
3673 XFlush (FRAME_X_DISPLAY (f
));
3678 /* RIF: Show hourglass cursor on frame F. */
3681 x_show_hourglass (struct frame
*f
)
3683 Display
*dpy
= FRAME_X_DISPLAY (f
);
3687 struct x_output
*x
= FRAME_X_OUTPUT (f
);
3688 #ifdef USE_X_TOOLKIT
3691 if (FRAME_OUTER_WINDOW (f
))
3694 x
->hourglass_p
= true;
3696 if (!x
->hourglass_window
)
3698 unsigned long mask
= CWCursor
;
3699 XSetWindowAttributes attrs
;
3701 Window parent
= FRAME_X_WINDOW (f
);
3703 Window parent
= FRAME_OUTER_WINDOW (f
);
3705 attrs
.cursor
= x
->hourglass_cursor
;
3707 x
->hourglass_window
= XCreateWindow
3708 (dpy
, parent
, 0, 0, 32000, 32000, 0, 0,
3709 InputOnly
, CopyFromParent
, mask
, &attrs
);
3712 XMapRaised (dpy
, x
->hourglass_window
);
3718 /* RIF: Cancel hourglass cursor on frame F. */
3721 x_hide_hourglass (struct frame
*f
)
3723 struct x_output
*x
= FRAME_X_OUTPUT (f
);
3725 /* Watch out for newly created frames. */
3726 if (x
->hourglass_window
)
3728 XUnmapWindow (FRAME_X_DISPLAY (f
), x
->hourglass_window
);
3729 /* Sync here because XTread_socket looks at the
3730 hourglass_p flag that is reset to zero below. */
3731 XSync (FRAME_X_DISPLAY (f
), False
);
3732 x
->hourglass_p
= false;
3736 /* Invert the middle quarter of the frame for .15 sec. */
3739 XTflash (struct frame
*f
)
3745 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
3746 when the scroll bars and the edit widget share the same X window. */
3747 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
3749 cairo_t
*cr
= gdk_cairo_create (window
);
3750 cairo_set_source_rgb (cr
, 1, 1, 1);
3751 cairo_set_operator (cr
, CAIRO_OPERATOR_DIFFERENCE
);
3752 #define XFillRectangle(d, win, gc, x, y, w, h) \
3754 cairo_rectangle (cr, x, y, w, h); \
3758 #else /* ! HAVE_GTK3 */
3761 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
3762 ^ FRAME_BACKGROUND_PIXEL (f
));
3763 vals
.function
= GDK_XOR
;
3764 gc
= gdk_gc_new_with_values (window
,
3765 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
3766 #define XFillRectangle(d, win, gc, x, y, w, h) \
3767 gdk_draw_rectangle (window, gc, true, x, y, w, h)
3768 #endif /* ! HAVE_GTK3 */
3769 #else /* ! USE_GTK */
3772 /* Create a GC that will use the GXxor function to flip foreground
3773 pixels into background pixels. */
3777 values
.function
= GXxor
;
3778 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
3779 ^ FRAME_BACKGROUND_PIXEL (f
));
3781 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3782 GCFunction
| GCForeground
, &values
);
3786 /* Get the height not including a menu bar widget. */
3787 int height
= FRAME_PIXEL_HEIGHT (f
);
3788 /* Height of each line to flash. */
3789 int flash_height
= FRAME_LINE_HEIGHT (f
);
3790 /* These will be the left and right margins of the rectangles. */
3791 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3792 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
3793 int width
= flash_right
- flash_left
;
3795 /* If window is tall, flash top and bottom line. */
3796 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3798 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3800 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3801 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3802 width
, flash_height
);
3803 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3805 (height
- flash_height
3806 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3807 width
, flash_height
);
3811 /* If it is short, flash it all. */
3812 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3813 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3814 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3819 struct timespec delay
= make_timespec (0, 150 * 1000 * 1000);
3820 struct timespec wakeup
= timespec_add (current_timespec (), delay
);
3822 /* Keep waiting until past the time wakeup or any input gets
3824 while (! detect_input_pending ())
3826 struct timespec current
= current_timespec ();
3827 struct timespec timeout
;
3829 /* Break if result would not be positive. */
3830 if (timespec_cmp (wakeup
, current
) <= 0)
3833 /* How long `select' should wait. */
3834 timeout
= make_timespec (0, 10 * 1000 * 1000);
3836 /* Try to wait that long--but we might wake up sooner. */
3837 pselect (0, NULL
, NULL
, NULL
, &timeout
, NULL
);
3841 /* If window is tall, flash top and bottom line. */
3842 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3844 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3846 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3847 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3848 width
, flash_height
);
3849 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3851 (height
- flash_height
3852 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3853 width
, flash_height
);
3856 /* If it is short, flash it all. */
3857 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3858 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3859 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3865 g_object_unref (G_OBJECT (gc
));
3867 #undef XFillRectangle
3869 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3880 XTtoggle_invisible_pointer (struct frame
*f
, bool invisible
)
3883 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, invisible
);
3888 /* Make audible bell. */
3891 XTring_bell (struct frame
*f
)
3893 if (FRAME_X_DISPLAY (f
))
3901 XkbBell (FRAME_X_DISPLAY (f
), None
, 0, None
);
3903 XBell (FRAME_X_DISPLAY (f
), 0);
3905 XFlush (FRAME_X_DISPLAY (f
));
3911 /***********************************************************************
3913 ***********************************************************************/
3915 /* Perform an insert-lines or delete-lines operation, inserting N
3916 lines or deleting -N lines at vertical position VPOS. */
3919 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
3925 /* Scroll part of the display as described by RUN. */
3928 x_scroll_run (struct window
*w
, struct run
*run
)
3930 struct frame
*f
= XFRAME (w
->frame
);
3931 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3933 /* Get frame-relative bounding box of the text display area of W,
3934 without mode lines. Include in this box the left and right
3936 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
3938 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3939 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3940 bottom_y
= y
+ height
;
3944 /* Scrolling up. Make sure we don't copy part of the mode
3945 line at the bottom. */
3946 if (from_y
+ run
->height
> bottom_y
)
3947 height
= bottom_y
- from_y
;
3949 height
= run
->height
;
3953 /* Scrolling down. Make sure we don't copy over the mode line.
3955 if (to_y
+ run
->height
> bottom_y
)
3956 height
= bottom_y
- to_y
;
3958 height
= run
->height
;
3963 /* Cursor off. Will be switched on again in x_update_window_end. */
3967 SET_FRAME_GARBAGED (f
);
3969 XCopyArea (FRAME_X_DISPLAY (f
),
3970 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3971 f
->output_data
.x
->normal_gc
,
3982 /***********************************************************************
3984 ***********************************************************************/
3988 frame_highlight (struct frame
*f
)
3990 /* We used to only do this if Vx_no_window_manager was non-nil, but
3991 the ICCCM (section 4.1.6) says that the window's border pixmap
3992 and border pixel are window attributes which are "private to the
3993 client", so we can always change it to whatever we want. */
3995 /* I recently started to get errors in this XSetWindowBorder, depending on
3996 the window-manager in use, tho something more is at play since I've been
3997 using that same window-manager binary for ever. Let's not crash just
3998 because of this (bug#9310). */
3999 x_catch_errors (FRAME_X_DISPLAY (f
));
4000 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4001 f
->output_data
.x
->border_pixel
);
4002 x_uncatch_errors ();
4004 x_update_cursor (f
, true);
4005 x_set_frame_alpha (f
);
4009 frame_unhighlight (struct frame
*f
)
4011 /* We used to only do this if Vx_no_window_manager was non-nil, but
4012 the ICCCM (section 4.1.6) says that the window's border pixmap
4013 and border pixel are window attributes which are "private to the
4014 client", so we can always change it to whatever we want. */
4016 /* Same as above for XSetWindowBorder (bug#9310). */
4017 x_catch_errors (FRAME_X_DISPLAY (f
));
4018 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4019 f
->output_data
.x
->border_tile
);
4020 x_uncatch_errors ();
4022 x_update_cursor (f
, true);
4023 x_set_frame_alpha (f
);
4026 /* The focus has changed. Update the frames as necessary to reflect
4027 the new situation. Note that we can't change the selected frame
4028 here, because the Lisp code we are interrupting might become confused.
4029 Each event gets marked with the frame in which it occurred, so the
4030 Lisp code can tell when the switch took place by examining the events. */
4033 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
4035 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
4037 if (frame
!= dpyinfo
->x_focus_frame
)
4039 /* Set this before calling other routines, so that they see
4040 the correct value of x_focus_frame. */
4041 dpyinfo
->x_focus_frame
= frame
;
4043 if (old_focus
&& old_focus
->auto_lower
)
4044 x_lower_frame (old_focus
);
4046 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
4047 dpyinfo
->x_pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
4049 dpyinfo
->x_pending_autoraise_frame
= NULL
;
4052 x_frame_rehighlight (dpyinfo
);
4055 /* Handle FocusIn and FocusOut state changes for FRAME.
4056 If FRAME has focus and there exists more than one frame, puts
4057 a FOCUS_IN_EVENT into *BUFP. */
4060 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
4062 if (type
== FocusIn
)
4064 if (dpyinfo
->x_focus_event_frame
!= frame
)
4066 x_new_focus_frame (dpyinfo
, frame
);
4067 dpyinfo
->x_focus_event_frame
= frame
;
4069 /* Don't stop displaying the initial startup message
4070 for a switch-frame event we don't need. */
4071 /* When run as a daemon, Vterminal_frame is always NIL. */
4072 bufp
->arg
= (((NILP (Vterminal_frame
)
4073 || ! FRAME_X_P (XFRAME (Vterminal_frame
))
4074 || EQ (Fdaemonp (), Qt
))
4075 && CONSP (Vframe_list
)
4076 && !NILP (XCDR (Vframe_list
)))
4078 bufp
->kind
= FOCUS_IN_EVENT
;
4079 XSETFRAME (bufp
->frame_or_window
, frame
);
4082 frame
->output_data
.x
->focus_state
|= state
;
4085 if (FRAME_XIC (frame
))
4086 XSetICFocus (FRAME_XIC (frame
));
4089 else if (type
== FocusOut
)
4091 frame
->output_data
.x
->focus_state
&= ~state
;
4093 if (dpyinfo
->x_focus_event_frame
== frame
)
4095 dpyinfo
->x_focus_event_frame
= 0;
4096 x_new_focus_frame (dpyinfo
, 0);
4098 bufp
->kind
= FOCUS_OUT_EVENT
;
4099 XSETFRAME (bufp
->frame_or_window
, frame
);
4103 if (FRAME_XIC (frame
))
4104 XUnsetICFocus (FRAME_XIC (frame
));
4106 if (frame
->pointer_invisible
)
4107 XTtoggle_invisible_pointer (frame
, false);
4111 /* Return the Emacs frame-object corresponding to an X window.
4112 It could be the frame's main window or an icon window. */
4114 static struct frame
*
4115 x_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4117 Lisp_Object tail
, frame
;
4123 FOR_EACH_FRAME (tail
, frame
)
4126 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4128 if (f
->output_data
.x
->hourglass_window
== wdesc
)
4130 #ifdef USE_X_TOOLKIT
4131 if ((f
->output_data
.x
->edit_widget
4132 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
4133 /* A tooltip frame? */
4134 || (!f
->output_data
.x
->edit_widget
4135 && FRAME_X_WINDOW (f
) == wdesc
)
4136 || f
->output_data
.x
->icon_desc
== wdesc
)
4138 #else /* not USE_X_TOOLKIT */
4140 if (f
->output_data
.x
->edit_widget
)
4142 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4143 struct x_output
*x
= f
->output_data
.x
;
4144 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
4147 #endif /* USE_GTK */
4148 if (FRAME_X_WINDOW (f
) == wdesc
4149 || f
->output_data
.x
->icon_desc
== wdesc
)
4151 #endif /* not USE_X_TOOLKIT */
4156 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
4158 /* Like x_window_to_frame but also compares the window with the widget's
4161 static struct frame
*
4162 x_any_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4164 Lisp_Object tail
, frame
;
4165 struct frame
*f
, *found
= NULL
;
4171 FOR_EACH_FRAME (tail
, frame
)
4176 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
4178 /* This frame matches if the window is any of its widgets. */
4179 x
= f
->output_data
.x
;
4180 if (x
->hourglass_window
== wdesc
)
4185 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4187 && gtk_widget_get_toplevel (gwdesc
) == x
->widget
)
4190 if (wdesc
== XtWindow (x
->widget
)
4191 || wdesc
== XtWindow (x
->column_widget
)
4192 || wdesc
== XtWindow (x
->edit_widget
))
4194 /* Match if the window is this frame's menubar. */
4195 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
4199 else if (FRAME_X_WINDOW (f
) == wdesc
)
4200 /* A tooltip frame. */
4208 /* Likewise, but consider only the menu bar widget. */
4210 static struct frame
*
4211 x_menubar_window_to_frame (struct x_display_info
*dpyinfo
,
4212 const XEvent
*event
)
4214 Window wdesc
= event
->xany
.window
;
4215 Lisp_Object tail
, frame
;
4222 FOR_EACH_FRAME (tail
, frame
)
4225 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4227 x
= f
->output_data
.x
;
4229 if (x
->menubar_widget
&& xg_event_is_for_menubar (f
, event
))
4232 /* Match if the window is this frame's menubar. */
4233 if (x
->menubar_widget
4234 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
4241 /* Return the frame whose principal (outermost) window is WDESC.
4242 If WDESC is some other (smaller) window, we return 0. */
4245 x_top_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
4247 Lisp_Object tail
, frame
;
4254 FOR_EACH_FRAME (tail
, frame
)
4257 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
4259 x
= f
->output_data
.x
;
4263 /* This frame matches if the window is its topmost widget. */
4265 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
4266 if (gwdesc
== x
->widget
)
4269 if (wdesc
== XtWindow (x
->widget
))
4273 else if (FRAME_X_WINDOW (f
) == wdesc
)
4274 /* Tooltip frame. */
4280 #else /* !USE_X_TOOLKIT && !USE_GTK */
4282 #define x_any_window_to_frame(d, i) x_window_to_frame (d, i)
4283 #define x_top_window_to_frame(d, i) x_window_to_frame (d, i)
4285 #endif /* USE_X_TOOLKIT || USE_GTK */
4287 /* The focus may have changed. Figure out if it is a real focus change,
4288 by checking both FocusIn/Out and Enter/LeaveNotify events.
4290 Returns FOCUS_IN_EVENT event in *BUFP. */
4293 x_detect_focus_change (struct x_display_info
*dpyinfo
, struct frame
*frame
,
4294 const XEvent
*event
, struct input_event
*bufp
)
4299 switch (event
->type
)
4304 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
4306 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
4308 if (event
->xcrossing
.detail
!= NotifyInferior
4309 && event
->xcrossing
.focus
4310 && ! (focus_state
& FOCUS_EXPLICIT
))
4311 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
4313 dpyinfo
, frame
, bufp
);
4319 x_focus_changed (event
->type
,
4320 (event
->xfocus
.detail
== NotifyPointer
?
4321 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
4322 dpyinfo
, frame
, bufp
);
4326 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
4328 enum xembed_message msg
= event
->xclient
.data
.l
[1];
4329 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
4330 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
4337 #if !defined USE_X_TOOLKIT && !defined USE_GTK
4338 /* Handle an event saying the mouse has moved out of an Emacs frame. */
4341 x_mouse_leave (struct x_display_info
*dpyinfo
)
4343 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
4347 /* The focus has changed, or we have redirected a frame's focus to
4348 another frame (this happens when a frame uses a surrogate
4349 mini-buffer frame). Shift the highlight as appropriate.
4351 The FRAME argument doesn't necessarily have anything to do with which
4352 frame is being highlighted or un-highlighted; we only use it to find
4353 the appropriate X display info. */
4356 XTframe_rehighlight (struct frame
*frame
)
4358 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
4362 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
4364 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
4366 if (dpyinfo
->x_focus_frame
)
4368 dpyinfo
->x_highlight_frame
4369 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
4370 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
4371 : dpyinfo
->x_focus_frame
);
4372 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
4374 fset_focus_frame (dpyinfo
->x_focus_frame
, Qnil
);
4375 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
4379 dpyinfo
->x_highlight_frame
= 0;
4381 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
4384 frame_unhighlight (old_highlight
);
4385 if (dpyinfo
->x_highlight_frame
)
4386 frame_highlight (dpyinfo
->x_highlight_frame
);
4392 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
4394 /* Initialize mode_switch_bit and modifier_meaning. */
4396 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
4398 int min_code
, max_code
;
4401 XModifierKeymap
*mods
;
4403 dpyinfo
->meta_mod_mask
= 0;
4404 dpyinfo
->shift_lock_mask
= 0;
4405 dpyinfo
->alt_mod_mask
= 0;
4406 dpyinfo
->super_mod_mask
= 0;
4407 dpyinfo
->hyper_mod_mask
= 0;
4409 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
4411 syms
= XGetKeyboardMapping (dpyinfo
->display
,
4412 min_code
, max_code
- min_code
+ 1,
4414 mods
= XGetModifierMapping (dpyinfo
->display
);
4416 /* Scan the modifier table to see which modifier bits the Meta and
4417 Alt keysyms are on. */
4419 int row
, col
; /* The row and column in the modifier table. */
4420 bool found_alt_or_meta
;
4422 for (row
= 3; row
< 8; row
++)
4424 found_alt_or_meta
= false;
4425 for (col
= 0; col
< mods
->max_keypermod
; col
++)
4427 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
4429 /* Zeroes are used for filler. Skip them. */
4433 /* Are any of this keycode's keysyms a meta key? */
4437 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
4439 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
4445 found_alt_or_meta
= true;
4446 dpyinfo
->meta_mod_mask
|= (1 << row
);
4451 found_alt_or_meta
= true;
4452 dpyinfo
->alt_mod_mask
|= (1 << row
);
4457 if (!found_alt_or_meta
)
4458 dpyinfo
->hyper_mod_mask
|= (1 << row
);
4459 code_col
= syms_per_code
;
4460 col
= mods
->max_keypermod
;
4465 if (!found_alt_or_meta
)
4466 dpyinfo
->super_mod_mask
|= (1 << row
);
4467 code_col
= syms_per_code
;
4468 col
= mods
->max_keypermod
;
4472 /* Ignore this if it's not on the lock modifier. */
4473 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
4474 dpyinfo
->shift_lock_mask
= LockMask
;
4475 code_col
= syms_per_code
;
4476 col
= mods
->max_keypermod
;
4485 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
4486 if (! dpyinfo
->meta_mod_mask
)
4488 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
4489 dpyinfo
->alt_mod_mask
= 0;
4492 /* If some keys are both alt and meta,
4493 make them just meta, not alt. */
4494 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
4496 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
4500 XFreeModifiermap (mods
);
4503 /* Convert between the modifier bits X uses and the modifier bits
4507 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, int state
)
4509 int mod_meta
= meta_modifier
;
4510 int mod_alt
= alt_modifier
;
4511 int mod_hyper
= hyper_modifier
;
4512 int mod_super
= super_modifier
;
4515 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
4516 if (INTEGERP (tem
)) mod_alt
= XINT (tem
) & INT_MAX
;
4517 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
4518 if (INTEGERP (tem
)) mod_meta
= XINT (tem
) & INT_MAX
;
4519 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
4520 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
) & INT_MAX
;
4521 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
4522 if (INTEGERP (tem
)) mod_super
= XINT (tem
) & INT_MAX
;
4524 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
4525 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
4526 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
4527 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
4528 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
4529 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
4533 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, EMACS_INT state
)
4535 EMACS_INT mod_meta
= meta_modifier
;
4536 EMACS_INT mod_alt
= alt_modifier
;
4537 EMACS_INT mod_hyper
= hyper_modifier
;
4538 EMACS_INT mod_super
= super_modifier
;
4542 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
4543 if (INTEGERP (tem
)) mod_alt
= XINT (tem
);
4544 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
4545 if (INTEGERP (tem
)) mod_meta
= XINT (tem
);
4546 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
4547 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
);
4548 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
4549 if (INTEGERP (tem
)) mod_super
= XINT (tem
);
4552 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
4553 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
4554 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
4555 | ((state
& shift_modifier
) ? ShiftMask
: 0)
4556 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
4557 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
4560 /* Convert a keysym to its name. */
4563 x_get_keysym_name (int keysym
)
4568 value
= XKeysymToString (keysym
);
4574 /* Mouse clicks and mouse movement. Rah.
4576 Formerly, we used PointerMotionHintMask (in standard_event_mask)
4577 so that we would have to call XQueryPointer after each MotionNotify
4578 event to ask for another such event. However, this made mouse tracking
4579 slow, and there was a bug that made it eventually stop.
4581 Simply asking for MotionNotify all the time seems to work better.
4583 In order to avoid asking for motion events and then throwing most
4584 of them away or busy-polling the server for mouse positions, we ask
4585 the server for pointer motion hints. This means that we get only
4586 one event per group of mouse movements. "Groups" are delimited by
4587 other kinds of events (focus changes and button clicks, for
4588 example), or by XQueryPointer calls; when one of these happens, we
4589 get another MotionNotify event the next time the mouse moves. This
4590 is at least as efficient as getting motion events when mouse
4591 tracking is on, and I suspect only negligibly worse when tracking
4594 /* Prepare a mouse-event in *RESULT for placement in the input queue.
4596 If the event is a button press, then note that we have grabbed
4600 construct_mouse_click (struct input_event
*result
,
4601 const XButtonEvent
*event
,
4604 /* Make the event type NO_EVENT; we'll change that when we decide
4606 result
->kind
= MOUSE_CLICK_EVENT
;
4607 result
->code
= event
->button
- Button1
;
4608 result
->timestamp
= event
->time
;
4609 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
),
4611 | (event
->type
== ButtonRelease
4615 XSETINT (result
->x
, event
->x
);
4616 XSETINT (result
->y
, event
->y
);
4617 XSETFRAME (result
->frame_or_window
, f
);
4622 /* Function to report a mouse movement to the mainstream Emacs code.
4623 The input handler calls this.
4625 We have received a mouse movement event, which is given in *event.
4626 If the mouse is over a different glyph than it was last time, tell
4627 the mainstream emacs code by setting mouse_moved. If not, ask for
4628 another motion event, so we can check again the next time it moves. */
4631 note_mouse_movement (struct frame
*frame
, const XMotionEvent
*event
)
4634 struct x_display_info
*dpyinfo
;
4636 if (!FRAME_X_OUTPUT (frame
))
4639 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
4640 dpyinfo
->last_mouse_movement_time
= event
->time
;
4641 dpyinfo
->last_mouse_motion_frame
= frame
;
4642 dpyinfo
->last_mouse_motion_x
= event
->x
;
4643 dpyinfo
->last_mouse_motion_y
= event
->y
;
4645 if (event
->window
!= FRAME_X_WINDOW (frame
))
4647 frame
->mouse_moved
= true;
4648 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4649 note_mouse_highlight (frame
, -1, -1);
4650 dpyinfo
->last_mouse_glyph_frame
= NULL
;
4655 /* Has the mouse moved off the glyph it was on at the last sighting? */
4656 r
= &dpyinfo
->last_mouse_glyph
;
4657 if (frame
!= dpyinfo
->last_mouse_glyph_frame
4658 || event
->x
< r
->x
|| event
->x
>= r
->x
+ r
->width
4659 || event
->y
< r
->y
|| event
->y
>= r
->y
+ r
->height
)
4661 frame
->mouse_moved
= true;
4662 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4663 note_mouse_highlight (frame
, event
->x
, event
->y
);
4664 /* Remember which glyph we're now on. */
4665 remember_mouse_glyph (frame
, event
->x
, event
->y
, r
);
4666 dpyinfo
->last_mouse_glyph_frame
= frame
;
4673 /* Return the current position of the mouse.
4674 *FP should be a frame which indicates which display to ask about.
4676 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
4677 and *PART to the frame, window, and scroll bar part that the mouse
4678 is over. Set *X and *Y to the portion and whole of the mouse's
4679 position on the scroll bar.
4681 If the mouse movement started elsewhere, set *FP to the frame the
4682 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
4685 Set *TIMESTAMP to the server time-stamp for the time at which the mouse
4686 was at this position.
4688 Don't store anything if we don't have a valid set of values to report.
4690 This clears the mouse_moved flag, so we can wait for the next mouse
4694 XTmouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
4695 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
4699 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
4703 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
4705 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
4707 if (bar
->horizontal
)
4708 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
4710 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
4717 Window dummy_window
;
4720 Lisp_Object frame
, tail
;
4722 /* Clear the mouse-moved flag for every frame on this display. */
4723 FOR_EACH_FRAME (tail
, frame
)
4724 if (FRAME_X_P (XFRAME (frame
))
4725 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
4726 XFRAME (frame
)->mouse_moved
= false;
4728 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4730 /* Figure out which root window we're on. */
4731 XQueryPointer (FRAME_X_DISPLAY (*fp
),
4732 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
4734 /* The root window which contains the pointer. */
4737 /* Trash which we can't trust if the pointer is on
4738 a different screen. */
4741 /* The position on that root window. */
4744 /* More trash we can't trust. */
4747 /* Modifier keys and pointer buttons, about which
4749 (unsigned int *) &dummy
);
4751 /* Now we have a position on the root; find the innermost window
4752 containing the pointer. */
4756 int parent_x
= 0, parent_y
= 0;
4760 /* XTranslateCoordinates can get errors if the window
4761 structure is changing at the same time this function
4762 is running. So at least we must not crash from them. */
4764 x_catch_errors (FRAME_X_DISPLAY (*fp
));
4766 if (x_mouse_grabbed (dpyinfo
))
4768 /* If mouse was grabbed on a frame, give coords for that frame
4769 even if the mouse is now outside it. */
4770 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4776 FRAME_X_WINDOW (dpyinfo
->last_mouse_frame
),
4778 /* From-position, to-position. */
4779 root_x
, root_y
, &win_x
, &win_y
,
4783 f1
= dpyinfo
->last_mouse_frame
;
4789 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4791 /* From-window, to-window. */
4794 /* From-position, to-position. */
4795 root_x
, root_y
, &win_x
, &win_y
,
4800 if (child
== None
|| child
== win
)
4803 /* We don't wan't to know the innermost window. We
4804 want the edit window. For non-Gtk+ the innermost
4805 window is the edit window. For Gtk+ it might not
4806 be. It might be the tool bar for example. */
4807 if (x_window_to_frame (dpyinfo
, win
))
4815 /* Now we know that:
4816 win is the innermost window containing the pointer
4817 (XTC says it has no child containing the pointer),
4818 win_x and win_y are the pointer's position in it
4819 (XTC did this the last time through), and
4820 parent_x and parent_y are the pointer's position in win's parent.
4821 (They are what win_x and win_y were when win was child.
4822 If win is the root window, it has no parent, and
4823 parent_{x,y} are invalid, but that's okay, because we'll
4824 never use them in that case.) */
4827 /* We don't wan't to know the innermost window. We
4828 want the edit window. */
4829 f1
= x_window_to_frame (dpyinfo
, win
);
4831 /* Is win one of our frames? */
4832 f1
= x_any_window_to_frame (dpyinfo
, win
);
4835 #ifdef USE_X_TOOLKIT
4836 /* If we end up with the menu bar window, say it's not
4839 && f1
->output_data
.x
->menubar_widget
4840 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
4842 #endif /* USE_X_TOOLKIT */
4845 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
4848 x_uncatch_errors ();
4850 /* If not, is it one of our scroll bars? */
4853 struct scroll_bar
*bar
;
4855 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
, 2);
4859 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4865 if (f1
== 0 && insist
> 0)
4866 f1
= SELECTED_FRAME ();
4870 /* Ok, we found a frame. Store all the values.
4871 last_mouse_glyph is a rectangle used to reduce the
4872 generation of mouse events. To not miss any motion
4873 events, we must divide the frame into rectangles of the
4874 size of the smallest character that could be displayed
4875 on it, i.e. into the same rectangles that matrices on
4876 the frame are divided into. */
4878 /* FIXME: what if F1 is not an X frame? */
4879 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
4880 remember_mouse_glyph (f1
, win_x
, win_y
, &dpyinfo
->last_mouse_glyph
);
4881 dpyinfo
->last_mouse_glyph_frame
= f1
;
4886 XSETINT (*x
, win_x
);
4887 XSETINT (*y
, win_y
);
4888 *timestamp
= dpyinfo
->last_mouse_movement_time
;
4898 /***********************************************************************
4900 ***********************************************************************/
4902 /* Scroll bar support. */
4904 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
4906 This can be called in GC, so we have to make sure to strip off mark
4909 static struct scroll_bar
*
4910 x_window_to_scroll_bar (Display
*display
, Window window_id
, int type
)
4912 Lisp_Object tail
, frame
;
4914 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
4915 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
4916 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
4918 FOR_EACH_FRAME (tail
, frame
)
4920 Lisp_Object bar
, condemned
;
4922 if (! FRAME_X_P (XFRAME (frame
)))
4925 /* Scan this frame's scroll bar list for a scroll bar with the
4927 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
4928 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
4929 /* This trick allows us to search both the ordinary and
4930 condemned scroll bar lists with one loop. */
4931 ! NILP (bar
) || (bar
= condemned
,
4934 bar
= XSCROLL_BAR (bar
)->next
)
4935 if (XSCROLL_BAR (bar
)->x_window
== window_id
4936 && FRAME_X_DISPLAY (XFRAME (frame
)) == display
4938 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
4939 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
4940 return XSCROLL_BAR (bar
);
4947 #if defined USE_LUCID
4949 /* Return the Lucid menu bar WINDOW is part of. Return null
4950 if WINDOW is not part of a menu bar. */
4953 x_window_to_menu_bar (Window window
)
4955 Lisp_Object tail
, frame
;
4957 FOR_EACH_FRAME (tail
, frame
)
4958 if (FRAME_X_P (XFRAME (frame
)))
4960 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
4962 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
4968 #endif /* USE_LUCID */
4971 /************************************************************************
4973 ************************************************************************/
4975 #ifdef USE_TOOLKIT_SCROLL_BARS
4977 static void x_send_scroll_bar_event (Lisp_Object
, enum scroll_bar_part
,
4980 /* Lisp window being scrolled. Set when starting to interact with
4981 a toolkit scroll bar, reset to nil when ending the interaction. */
4983 static Lisp_Object window_being_scrolled
;
4985 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4986 that movements of 1/20 of the screen size are mapped to up/down. */
4989 /* Id of action hook installed for scroll bars. */
4991 static XtActionHookId action_hook_id
;
4992 static XtActionHookId horizontal_action_hook_id
;
4994 static Boolean xaw3d_arrow_scroll
;
4996 /* Whether the drag scrolling maintains the mouse at the top of the
4997 thumb. If not, resizing the thumb needs to be done more carefully
4998 to avoid jerkiness. */
5000 static Boolean xaw3d_pick_top
;
5002 /* Action hook installed via XtAppAddActionHook when toolkit scroll
5003 bars are used.. The hook is responsible for detecting when
5004 the user ends an interaction with the scroll bar, and generates
5005 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
5008 xt_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
5009 XEvent
*event
, String
*params
, Cardinal
*num_params
)
5012 const char *end_action
;
5015 scroll_bar_p
= XmIsScrollBar (widget
);
5016 end_action
= "Release";
5017 #else /* !USE_MOTIF i.e. use Xaw */
5018 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
5019 end_action
= "EndScroll";
5020 #endif /* USE_MOTIF */
5023 && strcmp (action_name
, end_action
) == 0
5024 && WINDOWP (window_being_scrolled
))
5027 struct scroll_bar
*bar
;
5029 x_send_scroll_bar_event (window_being_scrolled
,
5030 scroll_bar_end_scroll
, 0, 0, false);
5031 w
= XWINDOW (window_being_scrolled
);
5032 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5034 if (bar
->dragging
!= -1)
5037 /* The thumb size is incorrect while dragging: fix it. */
5038 set_vertical_scroll_bar (w
);
5040 window_being_scrolled
= Qnil
;
5041 #if defined (USE_LUCID)
5042 bar
->last_seen_part
= scroll_bar_nowhere
;
5044 /* Xt timeouts no longer needed. */
5045 toolkit_scroll_bar_interaction
= false;
5051 xt_horizontal_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
5052 XEvent
*event
, String
*params
, Cardinal
*num_params
)
5055 const char *end_action
;
5058 scroll_bar_p
= XmIsScrollBar (widget
);
5059 end_action
= "Release";
5060 #else /* !USE_MOTIF i.e. use Xaw */
5061 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
5062 end_action
= "EndScroll";
5063 #endif /* USE_MOTIF */
5066 && strcmp (action_name
, end_action
) == 0
5067 && WINDOWP (window_being_scrolled
))
5070 struct scroll_bar
*bar
;
5072 x_send_scroll_bar_event (window_being_scrolled
,
5073 scroll_bar_end_scroll
, 0, 0, true);
5074 w
= XWINDOW (window_being_scrolled
);
5075 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
5077 if (bar
->dragging
!= -1)
5080 /* The thumb size is incorrect while dragging: fix it. */
5081 set_horizontal_scroll_bar (w
);
5083 window_being_scrolled
= Qnil
;
5084 #if defined (USE_LUCID)
5085 bar
->last_seen_part
= scroll_bar_nowhere
;
5087 /* Xt timeouts no longer needed. */
5088 toolkit_scroll_bar_interaction
= false;
5091 #endif /* not USE_GTK */
5093 /* Send a client message with message type Xatom_Scrollbar for a
5094 scroll action to the frame of WINDOW. PART is a value identifying
5095 the part of the scroll bar that was clicked on. PORTION is the
5096 amount to scroll of a whole of WHOLE. */
5099 x_send_scroll_bar_event (Lisp_Object window
, enum scroll_bar_part part
,
5100 int portion
, int whole
, bool horizontal
)
5103 XClientMessageEvent
*ev
= &event
.xclient
;
5104 struct window
*w
= XWINDOW (window
);
5105 struct frame
*f
= XFRAME (w
->frame
);
5106 intptr_t iw
= (intptr_t) w
;
5107 enum { BITS_PER_INTPTR
= CHAR_BIT
* sizeof iw
};
5108 verify (BITS_PER_INTPTR
<= 64);
5109 int sign_shift
= BITS_PER_INTPTR
- 32;
5113 /* Construct a ClientMessage event to send to the frame. */
5114 ev
->type
= ClientMessage
;
5115 ev
->message_type
= (horizontal
5116 ? FRAME_DISPLAY_INFO (f
)->Xatom_Horizontal_Scrollbar
5117 : FRAME_DISPLAY_INFO (f
)->Xatom_Scrollbar
);
5118 ev
->display
= FRAME_X_DISPLAY (f
);
5119 ev
->window
= FRAME_X_WINDOW (f
);
5122 /* A 32-bit X client on a 64-bit X server can pass a window pointer
5123 as-is. A 64-bit client on a 32-bit X server is in trouble
5124 because a pointer does not fit and would be truncated while
5125 passing through the server. So use two slots and hope that X12
5126 will resolve such issues someday. */
5127 ev
->data
.l
[0] = iw
>> 31 >> 1;
5128 ev
->data
.l
[1] = sign_shift
<= 0 ? iw
: iw
<< sign_shift
>> sign_shift
;
5129 ev
->data
.l
[2] = part
;
5130 ev
->data
.l
[3] = portion
;
5131 ev
->data
.l
[4] = whole
;
5133 /* Make Xt timeouts work while the scroll bar is active. */
5134 #ifdef USE_X_TOOLKIT
5135 toolkit_scroll_bar_interaction
= true;
5136 x_activate_timeout_atimer ();
5139 /* Setting the event mask to zero means that the message will
5140 be sent to the client that created the window, and if that
5141 window no longer exists, no event will be sent. */
5142 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
5147 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
5151 x_scroll_bar_to_input_event (const XEvent
*event
,
5152 struct input_event
*ievent
)
5154 const XClientMessageEvent
*ev
= &event
->xclient
;
5158 /* See the comment in the function above. */
5159 intptr_t iw0
= ev
->data
.l
[0];
5160 intptr_t iw1
= ev
->data
.l
[1];
5161 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
5162 w
= (struct window
*) iw
;
5164 XSETWINDOW (window
, w
);
5166 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
5167 ievent
->frame_or_window
= window
;
5170 ievent
->timestamp
= CurrentTime
;
5173 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
5176 ievent
->part
= ev
->data
.l
[2];
5177 ievent
->x
= make_number (ev
->data
.l
[3]);
5178 ievent
->y
= make_number (ev
->data
.l
[4]);
5179 ievent
->modifiers
= 0;
5182 /* Transform a horizontal scroll bar ClientMessage EVENT to an Emacs
5183 input event in *IEVENT. */
5186 x_horizontal_scroll_bar_to_input_event (const XEvent
*event
,
5187 struct input_event
*ievent
)
5189 const XClientMessageEvent
*ev
= &event
->xclient
;
5193 /* See the comment in the function above. */
5194 intptr_t iw0
= ev
->data
.l
[0];
5195 intptr_t iw1
= ev
->data
.l
[1];
5196 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
5197 w
= (struct window
*) iw
;
5199 XSETWINDOW (window
, w
);
5201 ievent
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
5202 ievent
->frame_or_window
= window
;
5205 ievent
->timestamp
= CurrentTime
;
5208 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
5211 ievent
->part
= ev
->data
.l
[2];
5212 ievent
->x
= make_number (ev
->data
.l
[3]);
5213 ievent
->y
= make_number (ev
->data
.l
[4]);
5214 ievent
->modifiers
= 0;
5220 /* Minimum and maximum values used for Motif scroll bars. */
5222 #define XM_SB_MAX 10000000
5224 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
5225 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
5226 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
5229 xm_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5231 struct scroll_bar
*bar
= client_data
;
5232 XmScrollBarCallbackStruct
*cs
= call_data
;
5233 enum scroll_bar_part part
= scroll_bar_nowhere
;
5234 bool horizontal
= bar
->horizontal
;
5235 int whole
= 0, portion
= 0;
5239 case XmCR_DECREMENT
:
5241 part
= horizontal
? scroll_bar_left_arrow
: scroll_bar_up_arrow
;
5244 case XmCR_INCREMENT
:
5246 part
= horizontal
? scroll_bar_right_arrow
: scroll_bar_down_arrow
;
5249 case XmCR_PAGE_DECREMENT
:
5251 part
= horizontal
? scroll_bar_before_handle
: scroll_bar_above_handle
;
5254 case XmCR_PAGE_INCREMENT
:
5256 part
= horizontal
? scroll_bar_after_handle
: scroll_bar_below_handle
;
5261 part
= horizontal
? scroll_bar_to_leftmost
: scroll_bar_to_top
;
5264 case XmCR_TO_BOTTOM
:
5266 part
= horizontal
? scroll_bar_to_rightmost
: scroll_bar_to_bottom
;
5274 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
5279 portion
= bar
->whole
* ((float)cs
->value
/ XM_SB_MAX
);
5280 whole
= bar
->whole
* ((float)(XM_SB_MAX
- slider_size
) / XM_SB_MAX
);
5281 portion
= min (portion
, whole
);
5282 part
= scroll_bar_horizontal_handle
;
5286 whole
= XM_SB_MAX
- slider_size
;
5287 portion
= min (cs
->value
, whole
);
5288 part
= scroll_bar_handle
;
5291 bar
->dragging
= cs
->value
;
5295 case XmCR_VALUE_CHANGED
:
5299 if (part
!= scroll_bar_nowhere
)
5301 window_being_scrolled
= bar
->window
;
5302 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
,
5307 #elif defined USE_GTK
5309 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
5310 bar widget. DATA is a pointer to the scroll_bar structure. */
5313 xg_scroll_callback (GtkRange
*range
,
5314 GtkScrollType scroll
,
5318 int whole
= 0, portion
= 0;
5319 struct scroll_bar
*bar
= user_data
;
5320 enum scroll_bar_part part
= scroll_bar_nowhere
;
5321 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
5322 struct frame
*f
= g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
5324 if (xg_ignore_gtk_scrollbar
) return false;
5328 case GTK_SCROLL_JUMP
:
5329 /* Buttons 1 2 or 3 must be grabbed. */
5330 if (FRAME_DISPLAY_INFO (f
)->grabbed
!= 0
5331 && FRAME_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
5333 if (bar
->horizontal
)
5335 part
= scroll_bar_horizontal_handle
;
5336 whole
= (int)(gtk_adjustment_get_upper (adj
) -
5337 gtk_adjustment_get_page_size (adj
));
5338 portion
= min ((int)value
, whole
);
5339 bar
->dragging
= portion
;
5343 part
= scroll_bar_handle
;
5344 whole
= gtk_adjustment_get_upper (adj
) -
5345 gtk_adjustment_get_page_size (adj
);
5346 portion
= min ((int)value
, whole
);
5347 bar
->dragging
= portion
;
5351 case GTK_SCROLL_STEP_BACKWARD
:
5352 part
= (bar
->horizontal
5353 ? scroll_bar_left_arrow
: scroll_bar_up_arrow
);
5356 case GTK_SCROLL_STEP_FORWARD
:
5357 part
= (bar
->horizontal
5358 ? scroll_bar_right_arrow
: scroll_bar_down_arrow
);
5361 case GTK_SCROLL_PAGE_BACKWARD
:
5362 part
= (bar
->horizontal
5363 ? scroll_bar_before_handle
: scroll_bar_above_handle
);
5366 case GTK_SCROLL_PAGE_FORWARD
:
5367 part
= (bar
->horizontal
5368 ? scroll_bar_after_handle
: scroll_bar_below_handle
);
5373 if (part
!= scroll_bar_nowhere
)
5375 window_being_scrolled
= bar
->window
;
5376 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
,
5383 /* Callback for button release. Sets dragging to -1 when dragging is done. */
5386 xg_end_scroll_callback (GtkWidget
*widget
,
5387 GdkEventButton
*event
,
5390 struct scroll_bar
*bar
= user_data
;
5392 if (WINDOWP (window_being_scrolled
))
5394 x_send_scroll_bar_event (window_being_scrolled
,
5395 scroll_bar_end_scroll
, 0, 0, bar
->horizontal
);
5396 window_being_scrolled
= Qnil
;
5403 #else /* not USE_GTK and not USE_MOTIF */
5405 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
5406 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
5407 scroll bar struct. CALL_DATA is a pointer to a float saying where
5411 xaw_jump_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5413 struct scroll_bar
*bar
= client_data
;
5414 float *top_addr
= call_data
;
5415 float top
= *top_addr
;
5417 int whole
, portion
, height
, width
;
5418 enum scroll_bar_part part
;
5419 bool horizontal
= bar
->horizontal
;
5424 /* Get the size of the thumb, a value between 0 and 1. */
5426 XtVaGetValues (widget
, XtNshown
, &shown
, XtNwidth
, &width
, NULL
);
5431 whole
= bar
->whole
- (shown
* bar
->whole
);
5432 portion
= min (top
* bar
->whole
, whole
);
5440 part
= scroll_bar_horizontal_handle
;
5444 /* Get the size of the thumb, a value between 0 and 1. */
5446 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
5450 portion
= shown
< 1 ? top
* whole
: 0;
5452 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0f
/ height
))
5453 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
5454 the bottom, so we force the scrolling whenever we see that we're
5455 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
5456 we try to ensure that we always stay two pixels away from the
5458 part
= scroll_bar_down_arrow
;
5460 part
= scroll_bar_handle
;
5463 window_being_scrolled
= bar
->window
;
5464 bar
->dragging
= portion
;
5465 bar
->last_seen_part
= part
;
5466 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
, bar
->horizontal
);
5470 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
5471 i.e. line or page up or down. WIDGET is the Xaw scroll bar
5472 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
5473 the scroll bar. CALL_DATA is an integer specifying the action that
5474 has taken place. Its magnitude is in the range 0..height of the
5475 scroll bar. Negative values mean scroll towards buffer start.
5476 Values < height of scroll bar mean line-wise movement. */
5479 xaw_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
5481 struct scroll_bar
*bar
= client_data
;
5482 /* The position really is stored cast to a pointer. */
5483 int position
= (intptr_t) call_data
;
5484 Dimension height
, width
;
5485 enum scroll_bar_part part
;
5487 if (bar
->horizontal
)
5489 /* Get the width of the scroll bar. */
5491 XtVaGetValues (widget
, XtNwidth
, &width
, NULL
);
5494 if (eabs (position
) >= width
)
5495 part
= (position
< 0) ? scroll_bar_before_handle
: scroll_bar_after_handle
;
5497 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
5498 it maps line-movement to call_data = max(5, height/20). */
5499 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, width
/ 20))
5500 part
= (position
< 0) ? scroll_bar_left_arrow
: scroll_bar_right_arrow
;
5502 part
= scroll_bar_move_ratio
;
5504 window_being_scrolled
= bar
->window
;
5506 bar
->last_seen_part
= part
;
5507 x_send_scroll_bar_event (bar
->window
, part
, position
, width
,
5513 /* Get the height of the scroll bar. */
5515 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
5518 if (eabs (position
) >= height
)
5519 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
5521 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
5522 it maps line-movement to call_data = max(5, height/20). */
5523 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
5524 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
5526 part
= scroll_bar_move_ratio
;
5528 window_being_scrolled
= bar
->window
;
5530 bar
->last_seen_part
= part
;
5531 x_send_scroll_bar_event (bar
->window
, part
, position
, height
,
5536 #endif /* not USE_GTK and not USE_MOTIF */
5538 #define SCROLL_BAR_NAME "verticalScrollBar"
5539 #define SCROLL_BAR_HORIZONTAL_NAME "horizontalScrollBar"
5541 /* Create the widget for scroll bar BAR on frame F. Record the widget
5542 and X window of the scroll bar in BAR. */
5546 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5548 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
5551 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
5552 G_CALLBACK (xg_end_scroll_callback
),
5558 x_create_horizontal_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5560 const char *scroll_bar_name
= SCROLL_BAR_HORIZONTAL_NAME
;
5563 xg_create_horizontal_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
5564 G_CALLBACK (xg_end_scroll_callback
),
5569 #else /* not USE_GTK */
5572 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5578 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
5579 unsigned long pixel
;
5584 /* Set resources. Create the widget. */
5585 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5586 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
5587 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
5588 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
5589 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
5590 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
5591 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
5593 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5596 XtSetArg (av
[ac
], XmNforeground
, pixel
);
5600 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5603 XtSetArg (av
[ac
], XmNbackground
, pixel
);
5607 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
5608 (char *) scroll_bar_name
, av
, ac
);
5610 /* Add one callback for everything that can happen. */
5611 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
5613 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
5615 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
5617 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
5619 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
5621 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
5623 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
5626 /* Realize the widget. Only after that is the X window created. */
5627 XtRealizeWidget (widget
);
5629 /* Set the cursor to an arrow. I didn't find a resource to do that.
5630 And I'm wondering why it hasn't an arrow cursor by default. */
5631 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
5632 f
->output_data
.x
->nontext_cursor
);
5634 #else /* !USE_MOTIF i.e. use Xaw */
5636 /* Set resources. Create the widget. The background of the
5637 Xaw3d scroll bar widget is a little bit light for my taste.
5638 We don't alter it here to let users change it according
5639 to their taste with `emacs*verticalScrollBar.background: xxx'. */
5640 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5641 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
5642 /* For smoother scrolling with Xaw3d -sm */
5643 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
5645 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5648 XtSetArg (av
[ac
], XtNforeground
, pixel
);
5652 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5655 XtSetArg (av
[ac
], XtNbackground
, pixel
);
5659 /* Top/bottom shadow colors. */
5661 /* Allocate them, if necessary. */
5662 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
5664 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5667 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5668 FRAME_X_COLORMAP (f
),
5669 &pixel
, 1.2, 0x8000))
5671 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
5674 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5676 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5679 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5680 FRAME_X_COLORMAP (f
),
5681 &pixel
, 0.6, 0x4000))
5683 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
5687 #ifdef XtNbeNiceToColormap
5688 /* Tell the toolkit about them. */
5689 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
5690 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5691 /* We tried to allocate a color for the top/bottom shadow, and
5692 failed, so tell Xaw3d to use dithering instead. */
5693 /* But only if we have a small colormap. Xaw3d can allocate nice
5696 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
5697 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
5701 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
5702 be more consistent with other emacs 3d colors, and since Xaw3d is
5703 not good at dealing with allocation failure. */
5705 /* This tells Xaw3d to use real colors instead of dithering for
5707 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
5710 /* Specify the colors. */
5711 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
5714 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
5717 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
5720 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
5726 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
5727 f
->output_data
.x
->edit_widget
, av
, ac
);
5730 char const *initial
= "";
5731 char const *val
= initial
;
5732 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
5733 #ifdef XtNarrowScrollbars
5734 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
5736 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
5737 if (xaw3d_arrow_scroll
|| val
== initial
)
5738 { /* ARROW_SCROLL */
5739 xaw3d_arrow_scroll
= True
;
5740 /* Isn't that just a personal preference ? --Stef */
5741 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
5745 /* Define callbacks. */
5746 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
5747 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
5750 /* Realize the widget. Only after that is the X window created. */
5751 XtRealizeWidget (widget
);
5753 #endif /* !USE_MOTIF */
5755 /* Install an action hook that lets us detect when the user
5756 finishes interacting with a scroll bar. */
5757 if (action_hook_id
== 0)
5758 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
5760 /* Remember X window and widget in the scroll bar vector. */
5761 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
5762 xwindow
= XtWindow (widget
);
5763 bar
->x_window
= xwindow
;
5765 bar
->horizontal
= false;
5771 x_create_horizontal_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
5777 const char *scroll_bar_name
= SCROLL_BAR_HORIZONTAL_NAME
;
5778 unsigned long pixel
;
5783 /* Set resources. Create the widget. */
5784 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5785 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
5786 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
5787 XtSetArg (av
[ac
], XmNorientation
, XmHORIZONTAL
); ++ac
;
5788 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_RIGHT
), ++ac
;
5789 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
5790 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
5792 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5795 XtSetArg (av
[ac
], XmNforeground
, pixel
);
5799 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5802 XtSetArg (av
[ac
], XmNbackground
, pixel
);
5806 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
5807 (char *) scroll_bar_name
, av
, ac
);
5809 /* Add one callback for everything that can happen. */
5810 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
5812 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
5814 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
5816 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
5818 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
5820 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
5822 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
5825 /* Realize the widget. Only after that is the X window created. */
5826 XtRealizeWidget (widget
);
5828 /* Set the cursor to an arrow. I didn't find a resource to do that.
5829 And I'm wondering why it hasn't an arrow cursor by default. */
5830 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
5831 f
->output_data
.x
->nontext_cursor
);
5833 #else /* !USE_MOTIF i.e. use Xaw */
5835 /* Set resources. Create the widget. The background of the
5836 Xaw3d scroll bar widget is a little bit light for my taste.
5837 We don't alter it here to let users change it according
5838 to their taste with `emacs*verticalScrollBar.background: xxx'. */
5839 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5840 XtSetArg (av
[ac
], XtNorientation
, XtorientHorizontal
); ++ac
;
5841 /* For smoother scrolling with Xaw3d -sm */
5842 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
5844 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5847 XtSetArg (av
[ac
], XtNforeground
, pixel
);
5851 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5854 XtSetArg (av
[ac
], XtNbackground
, pixel
);
5858 /* Top/bottom shadow colors. */
5860 /* Allocate them, if necessary. */
5861 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
5863 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5866 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5867 FRAME_X_COLORMAP (f
),
5868 &pixel
, 1.2, 0x8000))
5870 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
5873 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5875 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5878 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5879 FRAME_X_COLORMAP (f
),
5880 &pixel
, 0.6, 0x4000))
5882 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
5886 #ifdef XtNbeNiceToColormap
5887 /* Tell the toolkit about them. */
5888 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
5889 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5890 /* We tried to allocate a color for the top/bottom shadow, and
5891 failed, so tell Xaw3d to use dithering instead. */
5892 /* But only if we have a small colormap. Xaw3d can allocate nice
5895 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
5896 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
5900 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
5901 be more consistent with other emacs 3d colors, and since Xaw3d is
5902 not good at dealing with allocation failure. */
5904 /* This tells Xaw3d to use real colors instead of dithering for
5906 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
5909 /* Specify the colors. */
5910 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
5913 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
5916 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
5919 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
5925 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
5926 f
->output_data
.x
->edit_widget
, av
, ac
);
5929 char const *initial
= "";
5930 char const *val
= initial
;
5931 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
5932 #ifdef XtNarrowScrollbars
5933 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
5935 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
5936 if (xaw3d_arrow_scroll
|| val
== initial
)
5937 { /* ARROW_SCROLL */
5938 xaw3d_arrow_scroll
= True
;
5939 /* Isn't that just a personal preference ? --Stef */
5940 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
5944 /* Define callbacks. */
5945 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
5946 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
5949 /* Realize the widget. Only after that is the X window created. */
5950 XtRealizeWidget (widget
);
5952 #endif /* !USE_MOTIF */
5954 /* Install an action hook that lets us detect when the user
5955 finishes interacting with a scroll bar. */
5956 if (horizontal_action_hook_id
== 0)
5957 horizontal_action_hook_id
5958 = XtAppAddActionHook (Xt_app_con
, xt_horizontal_action_hook
, 0);
5960 /* Remember X window and widget in the scroll bar vector. */
5961 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
5962 xwindow
= XtWindow (widget
);
5963 bar
->x_window
= xwindow
;
5965 bar
->horizontal
= true;
5969 #endif /* not USE_GTK */
5972 /* Set the thumb size and position of scroll bar BAR. We are currently
5973 displaying PORTION out of a whole WHOLE, and our position POSITION. */
5977 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
5979 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5983 x_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
5985 xg_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
5988 #else /* not USE_GTK */
5990 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
5993 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5994 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6001 if (scroll_bar_adjust_thumb_portion_p
)
6003 /* We use an estimate of 30 chars per line rather than the real
6004 `portion' value. This has the disadvantage that the thumb size
6005 is not very representative, but it makes our life a lot easier.
6006 Otherwise, we have to constantly adjust the thumb size, which
6007 we can't always do quickly enough: while dragging, the size of
6008 the thumb might prevent the user from dragging the thumb all the
6009 way to the end. but Motif and some versions of Xaw3d don't allow
6010 updating the thumb size while dragging. Also, even if we can update
6011 its size, the update will often happen too late.
6012 If you don't believe it, check out revision 1.650 of xterm.c to see
6013 what hoops we were going through and the still poor behavior we got. */
6014 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
6015 /* When the thumb is at the bottom, position == whole.
6016 So we need to increase `whole' to make space for the thumb. */
6024 top
= (float) position
/ whole
;
6025 shown
= (float) portion
/ whole
;
6028 if (bar
->dragging
== -1)
6032 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
6033 is the scroll bar's maximum and MIN is the scroll bar's minimum
6035 size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
6037 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
6038 value
= top
* XM_SB_MAX
;
6039 value
= min (value
, XM_SB_MAX
- size
);
6041 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
6043 #else /* !USE_MOTIF i.e. use Xaw */
6049 top
= (float) position
/ whole
;
6050 shown
= (float) portion
/ whole
;
6054 float old_top
, old_shown
;
6056 XtVaGetValues (widget
,
6057 XtNtopOfThumb
, &old_top
,
6058 XtNshown
, &old_shown
,
6062 /* Massage the top+shown values. */
6063 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
6064 top
= max (0, min (1, top
));
6067 #if ! defined (HAVE_XAW3D)
6068 /* With Xaw, 'top' values too closer to 1.0 may
6069 cause the thumb to disappear. Fix that. */
6070 top
= min (top
, 0.99f
);
6072 /* Keep two pixels available for moving the thumb down. */
6073 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
6074 #if ! defined (HAVE_XAW3D)
6075 /* Likewise with too small 'shown'. */
6076 shown
= max (shown
, 0.01f
);
6079 /* If the call to XawScrollbarSetThumb below doesn't seem to
6080 work, check that 'NARROWPROTO' is defined in src/config.h.
6081 If this is not so, most likely you need to fix configure. */
6082 if (top
!= old_top
|| shown
!= old_shown
)
6084 if (bar
->dragging
== -1)
6085 XawScrollbarSetThumb (widget
, top
, shown
);
6088 /* Try to make the scrolling a tad smoother. */
6089 if (!xaw3d_pick_top
)
6090 shown
= min (shown
, old_shown
);
6092 XawScrollbarSetThumb (widget
, top
, shown
);
6096 #endif /* !USE_MOTIF */
6102 x_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
6105 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6106 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6113 shown
= (float) portion
/ whole
;
6114 top
= (float) position
/ (whole
- portion
);
6116 int size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
6117 int value
= clip_to_bounds (0, top
* (XM_SB_MAX
- size
), XM_SB_MAX
- size
);
6119 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
6121 #else /* !USE_MOTIF i.e. use Xaw */
6127 top
= (float) position
/ whole
;
6128 shown
= (float) portion
/ whole
;
6132 float old_top
, old_shown
;
6134 XtVaGetValues (widget
,
6135 XtNtopOfThumb
, &old_top
,
6136 XtNshown
, &old_shown
,
6141 /* Massage the top+shown values. */
6142 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
6143 top
= max (0, min (1, top
));
6146 #if ! defined (HAVE_XAW3D)
6147 /* With Xaw, 'top' values too closer to 1.0 may
6148 cause the thumb to disappear. Fix that. */
6149 top
= min (top
, 0.99f
);
6151 /* Keep two pixels available for moving the thumb down. */
6152 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
6153 #if ! defined (HAVE_XAW3D)
6154 /* Likewise with too small 'shown'. */
6155 shown
= max (shown
, 0.01f
);
6159 /* If the call to XawScrollbarSetThumb below doesn't seem to
6160 work, check that 'NARROWPROTO' is defined in src/config.h.
6161 If this is not so, most likely you need to fix configure. */
6162 XawScrollbarSetThumb (widget
, top
, shown
);
6164 if (top
!= old_top
|| shown
!= old_shown
)
6166 if (bar
->dragging
== -1)
6167 XawScrollbarSetThumb (widget
, top
, shown
);
6170 /* Try to make the scrolling a tad smoother. */
6171 if (!xaw3d_pick_top
)
6172 shown
= min (shown
, old_shown
);
6174 XawScrollbarSetThumb (widget
, top
, shown
);
6179 #endif /* !USE_MOTIF */
6183 #endif /* not USE_GTK */
6185 #endif /* USE_TOOLKIT_SCROLL_BARS */
6189 /************************************************************************
6190 Scroll bars, general
6191 ************************************************************************/
6193 /* Create a scroll bar and return the scroll bar vector for it. W is
6194 the Emacs window on which to create the scroll bar. TOP, LEFT,
6195 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
6198 static struct scroll_bar
*
6199 x_scroll_bar_create (struct window
*w
, int top
, int left
,
6200 int width
, int height
, bool horizontal
)
6202 struct frame
*f
= XFRAME (w
->frame
);
6203 struct scroll_bar
*bar
6204 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
6209 #ifdef USE_TOOLKIT_SCROLL_BARS
6211 x_create_horizontal_toolkit_scroll_bar (f
, bar
);
6213 x_create_toolkit_scroll_bar (f
, bar
);
6214 #else /* not USE_TOOLKIT_SCROLL_BARS */
6216 XSetWindowAttributes a
;
6220 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
6221 if (a
.background_pixel
== -1)
6222 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
6224 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
6225 | ButtonMotionMask
| PointerMotionHintMask
6227 a
.cursor
= FRAME_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
6229 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
6231 /* Clear the area of W that will serve as a scroll bar. This is
6232 for the case that a window has been split horizontally. In
6233 this case, no clear_frame is generated to reduce flickering. */
6234 if (width
> 0 && window_box_height (w
) > 0)
6235 x_clear_area (f
, left
, top
, width
, window_box_height (w
));
6237 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6238 /* Position and size of scroll bar. */
6239 left
, top
, width
, height
,
6240 /* Border width, depth, class, and visual. */
6247 bar
->x_window
= window
;
6249 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6251 XSETWINDOW (bar
->window
, w
);
6255 bar
->height
= height
;
6259 bar
->horizontal
= horizontal
;
6260 #if defined (USE_TOOLKIT_SCROLL_BARS) && defined (USE_LUCID)
6261 bar
->last_seen_part
= scroll_bar_nowhere
;
6264 /* Add bar to its frame's list of scroll bars. */
6265 bar
->next
= FRAME_SCROLL_BARS (f
);
6267 XSETVECTOR (barobj
, bar
);
6268 fset_scroll_bars (f
, barobj
);
6269 if (!NILP (bar
->next
))
6270 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6272 /* Map the window/widget. */
6273 #ifdef USE_TOOLKIT_SCROLL_BARS
6277 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
,
6278 left
, width
, max (height
, 1));
6280 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
6281 left
, width
, max (height
, 1));
6282 #else /* not USE_GTK */
6283 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
6284 XtConfigureWidget (scroll_bar
, left
, top
, width
, max (height
, 1), 0);
6285 XtMapWidget (scroll_bar
);
6286 #endif /* not USE_GTK */
6288 #else /* not USE_TOOLKIT_SCROLL_BARS */
6289 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
6290 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6297 #ifndef USE_TOOLKIT_SCROLL_BARS
6299 /* Draw BAR's handle in the proper position.
6301 If the handle is already drawn from START to END, don't bother
6302 redrawing it, unless REBUILD; in that case, always
6303 redraw it. (REBUILD is handy for drawing the handle after expose
6306 Normally, we want to constrain the start and end of the handle to
6307 fit inside its rectangle, but if the user is dragging the scroll
6308 bar handle, we want to let them drag it down all the way, so that
6309 the bar's top is as far down as it goes; otherwise, there's no way
6310 to move to the very end of the buffer. */
6313 x_scroll_bar_set_handle (struct scroll_bar
*bar
, int start
, int end
,
6316 bool dragging
= bar
->dragging
!= -1;
6317 Window w
= bar
->x_window
;
6318 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6319 GC gc
= f
->output_data
.x
->normal_gc
;
6321 /* If the display is already accurate, do nothing. */
6323 && start
== bar
->start
6330 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
6331 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
6332 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
6334 /* Make sure the values are reasonable, and try to preserve
6335 the distance between start and end. */
6337 int length
= end
- start
;
6341 else if (start
> top_range
)
6343 end
= start
+ length
;
6347 else if (end
> top_range
&& ! dragging
)
6351 /* Store the adjusted setting in the scroll bar. */
6355 /* Clip the end position, just for display. */
6356 if (end
> top_range
)
6359 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
6360 below top positions, to make sure the handle is always at least
6361 that many pixels tall. */
6362 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
6364 /* Draw the empty space above the handle. Note that we can't clear
6365 zero-height areas; that means "clear to end of window." */
6366 if ((inside_width
> 0) && (start
> 0))
6367 x_clear_area1 (FRAME_X_DISPLAY (f
), w
,
6368 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6369 VERTICAL_SCROLL_BAR_TOP_BORDER
,
6370 inside_width
, start
);
6372 /* Change to proper foreground color if one is specified. */
6373 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6374 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6375 f
->output_data
.x
->scroll_bar_foreground_pixel
);
6377 /* Draw the handle itself. */
6378 x_fill_rectangle (f
, gc
,
6379 /* x, y, width, height */
6380 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6381 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
6382 inside_width
, end
- start
);
6384 /* Restore the foreground color of the GC if we changed it above. */
6385 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6386 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6387 FRAME_FOREGROUND_PIXEL (f
));
6389 /* Draw the empty space below the handle. Note that we can't
6390 clear zero-height areas; that means "clear to end of window." */
6391 if ((inside_width
> 0) && (end
< inside_height
))
6392 x_clear_area1 (FRAME_X_DISPLAY (f
), w
,
6393 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
6394 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
6395 inside_width
, inside_height
- end
);
6401 #endif /* !USE_TOOLKIT_SCROLL_BARS */
6403 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
6407 x_scroll_bar_remove (struct scroll_bar
*bar
)
6409 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6412 #ifdef USE_TOOLKIT_SCROLL_BARS
6414 xg_remove_scroll_bar (f
, bar
->x_window
);
6415 #else /* not USE_GTK */
6416 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
6417 #endif /* not USE_GTK */
6419 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
6422 /* Dissociate this scroll bar from its window. */
6423 if (bar
->horizontal
)
6424 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
6426 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
6432 /* Set the handle of the vertical scroll bar for WINDOW to indicate
6433 that we are displaying PORTION characters out of a total of WHOLE
6434 characters, starting at POSITION. If WINDOW has no scroll bar,
6438 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
6440 struct frame
*f
= XFRAME (w
->frame
);
6442 struct scroll_bar
*bar
;
6443 int top
, height
, left
, width
;
6444 int window_y
, window_height
;
6446 /* Get window dimensions. */
6447 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
6449 height
= window_height
;
6450 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
6451 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
6453 /* Does the scroll bar exist yet? */
6454 if (NILP (w
->vertical_scroll_bar
))
6456 if (width
> 0 && height
> 0)
6459 x_clear_area (f
, left
, top
, width
, height
);
6463 bar
= x_scroll_bar_create (w
, top
, left
, width
, max (height
, 1), false);
6467 /* It may just need to be moved and resized. */
6468 unsigned int mask
= 0;
6470 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
6474 if (left
!= bar
->left
)
6476 if (top
!= bar
->top
)
6478 if (width
!= bar
->width
)
6480 if (height
!= bar
->height
)
6483 #ifdef USE_TOOLKIT_SCROLL_BARS
6485 /* Move/size the scroll bar widget. */
6488 /* Since toolkit scroll bars are smaller than the space reserved
6489 for them on the frame, we have to clear "under" them. */
6490 if (width
> 0 && height
> 0)
6491 x_clear_area (f
, left
, top
, width
, height
);
6493 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
6494 left
, width
, max (height
, 1));
6495 #else /* not USE_GTK */
6496 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
6497 left
, top
, width
, max (height
, 1), 0);
6498 #endif /* not USE_GTK */
6500 #else /* not USE_TOOLKIT_SCROLL_BARS */
6502 /* Move/size the scroll bar window. */
6511 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
6515 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6517 /* Remember new settings. */
6521 bar
->height
= height
;
6526 #ifdef USE_TOOLKIT_SCROLL_BARS
6527 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
6528 #else /* not USE_TOOLKIT_SCROLL_BARS */
6529 /* Set the scroll bar's current state, unless we're currently being
6531 if (bar
->dragging
== -1)
6533 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
6536 x_scroll_bar_set_handle (bar
, 0, top_range
, false);
6539 int start
= ((double) position
* top_range
) / whole
;
6540 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
6541 x_scroll_bar_set_handle (bar
, start
, end
, false);
6544 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6546 XSETVECTOR (barobj
, bar
);
6547 wset_vertical_scroll_bar (w
, barobj
);
6552 XTset_horizontal_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
6554 struct frame
*f
= XFRAME (w
->frame
);
6556 struct scroll_bar
*bar
;
6557 int top
, height
, left
, width
;
6558 int window_x
, window_width
;
6559 int pixel_width
= WINDOW_PIXEL_WIDTH (w
);
6561 /* Get window dimensions. */
6562 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
6564 width
= window_width
;
6565 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
6566 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
6568 /* Does the scroll bar exist yet? */
6569 if (NILP (w
->horizontal_scroll_bar
))
6571 if (width
> 0 && height
> 0)
6575 /* Clear also part between window_width and
6576 WINDOW_PIXEL_WIDTH. */
6577 x_clear_area (f
, left
, top
, pixel_width
, height
);
6581 bar
= x_scroll_bar_create (w
, top
, left
, width
, height
, true);
6585 /* It may just need to be moved and resized. */
6586 unsigned int mask
= 0;
6588 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
6592 if (left
!= bar
->left
)
6594 if (top
!= bar
->top
)
6596 if (width
!= bar
->width
)
6598 if (height
!= bar
->height
)
6601 #ifdef USE_TOOLKIT_SCROLL_BARS
6602 /* Move/size the scroll bar widget. */
6605 /* Since toolkit scroll bars are smaller than the space reserved
6606 for them on the frame, we have to clear "under" them. */
6607 if (width
> 0 && height
> 0)
6609 WINDOW_LEFT_EDGE_X (w
), top
,
6610 pixel_width
- WINDOW_RIGHT_DIVIDER_WIDTH (w
), height
);
6612 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
, left
,
6614 #else /* not USE_GTK */
6615 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
6616 left
, top
, width
, height
, 0);
6617 #endif /* not USE_GTK */
6619 #else /* not USE_TOOLKIT_SCROLL_BARS */
6621 /* Clear areas not covered by the scroll bar because it's not as
6622 wide as the area reserved for it. This makes sure a
6623 previous mode line display is cleared after C-x 2 C-x 1, for
6626 int area_height
= WINDOW_CONFIG_SCROLL_BAR_HEIGHT (w
);
6627 int rest
= area_height
- height
;
6628 if (rest
> 0 && width
> 0)
6629 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6630 left
, top
, width
, rest
);
6633 /* Move/size the scroll bar window. */
6642 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
6646 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6648 /* Remember new settings. */
6652 bar
->height
= height
;
6657 #ifdef USE_TOOLKIT_SCROLL_BARS
6658 x_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
6659 #else /* not USE_TOOLKIT_SCROLL_BARS */
6660 /* Set the scroll bar's current state, unless we're currently being
6662 if (bar
->dragging
== -1)
6664 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
);
6667 x_scroll_bar_set_handle (bar
, 0, left_range
, false);
6670 int start
= ((double) position
* left_range
) / whole
;
6671 int end
= ((double) (position
+ portion
) * left_range
) / whole
;
6672 x_scroll_bar_set_handle (bar
, start
, end
, false);
6675 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6677 XSETVECTOR (barobj
, bar
);
6678 wset_horizontal_scroll_bar (w
, barobj
);
6682 /* The following three hooks are used when we're doing a thorough
6683 redisplay of the frame. We don't explicitly know which scroll bars
6684 are going to be deleted, because keeping track of when windows go
6685 away is a real pain - "Can you say set-window-configuration, boys
6686 and girls?" Instead, we just assert at the beginning of redisplay
6687 that *all* scroll bars are to be removed, and then save a scroll bar
6688 from the fiery pit when we actually redisplay its window. */
6690 /* Arrange for all scroll bars on FRAME to be removed at the next call
6691 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
6692 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
6695 XTcondemn_scroll_bars (struct frame
*frame
)
6697 if (!NILP (FRAME_SCROLL_BARS (frame
)))
6699 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
6701 /* Prepend scrollbars to already condemned ones. */
6702 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
6704 while (!NILP (XSCROLL_BAR (last
)->next
))
6705 last
= XSCROLL_BAR (last
)->next
;
6707 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
6708 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
6711 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
6712 fset_scroll_bars (frame
, Qnil
);
6717 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
6718 Note that WINDOW isn't necessarily condemned at all. */
6721 XTredeem_scroll_bar (struct window
*w
)
6723 struct scroll_bar
*bar
;
6727 /* We can't redeem this window's scroll bar if it doesn't have one. */
6728 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
6731 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
6733 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
6734 /* Unlink it from the condemned list. */
6735 f
= XFRAME (WINDOW_FRAME (w
));
6736 if (NILP (bar
->prev
))
6738 /* If the prev pointer is nil, it must be the first in one of
6740 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
6741 /* It's not condemned. Everything's fine. */
6743 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
6744 w
->vertical_scroll_bar
))
6745 fset_condemned_scroll_bars (f
, bar
->next
);
6747 /* If its prev pointer is nil, it must be at the front of
6748 one or the other! */
6752 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
6754 if (! NILP (bar
->next
))
6755 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
6757 bar
->next
= FRAME_SCROLL_BARS (f
);
6759 XSETVECTOR (barobj
, bar
);
6760 fset_scroll_bars (f
, barobj
);
6761 if (! NILP (bar
->next
))
6762 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6766 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
6768 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
6769 /* Unlink it from the condemned list. */
6770 f
= XFRAME (WINDOW_FRAME (w
));
6771 if (NILP (bar
->prev
))
6773 /* If the prev pointer is nil, it must be the first in one of
6775 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
6776 /* It's not condemned. Everything's fine. */
6778 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
6779 w
->horizontal_scroll_bar
))
6780 fset_condemned_scroll_bars (f
, bar
->next
);
6782 /* If its prev pointer is nil, it must be at the front of
6783 one or the other! */
6787 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
6789 if (! NILP (bar
->next
))
6790 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
6792 bar
->next
= FRAME_SCROLL_BARS (f
);
6794 XSETVECTOR (barobj
, bar
);
6795 fset_scroll_bars (f
, barobj
);
6796 if (! NILP (bar
->next
))
6797 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6801 /* Remove all scroll bars on FRAME that haven't been saved since the
6802 last call to `*condemn_scroll_bars_hook'. */
6805 XTjudge_scroll_bars (struct frame
*f
)
6807 Lisp_Object bar
, next
;
6809 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
6811 /* Clear out the condemned list now so we won't try to process any
6812 more events on the hapless scroll bars. */
6813 fset_condemned_scroll_bars (f
, Qnil
);
6815 for (; ! NILP (bar
); bar
= next
)
6817 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
6819 x_scroll_bar_remove (b
);
6822 b
->next
= b
->prev
= Qnil
;
6825 /* Now there should be no references to the condemned scroll bars,
6826 and they should get garbage-collected. */
6830 #ifndef USE_TOOLKIT_SCROLL_BARS
6831 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
6832 is a no-op when using toolkit scroll bars.
6834 This may be called from a signal handler, so we have to ignore GC
6838 x_scroll_bar_expose (struct scroll_bar
*bar
, const XEvent
*event
)
6840 Window w
= bar
->x_window
;
6841 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6842 GC gc
= f
->output_data
.x
->normal_gc
;
6846 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, true);
6848 /* Switch to scroll bar foreground color. */
6849 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6850 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6851 f
->output_data
.x
->scroll_bar_foreground_pixel
);
6853 /* Draw a one-pixel border just inside the edges of the scroll bar. */
6854 x_draw_rectangle (f
, gc
,
6855 /* x, y, width, height */
6856 0, 0, bar
->width
- 1, bar
->height
- 1);
6858 /* Restore the foreground color of the GC if we changed it above. */
6859 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6860 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6861 FRAME_FOREGROUND_PIXEL (f
));
6866 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6868 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
6869 is set to something other than NO_EVENT, it is enqueued.
6871 This may be called from a signal handler, so we have to ignore GC
6876 x_scroll_bar_handle_click (struct scroll_bar
*bar
,
6877 const XEvent
*event
,
6878 struct input_event
*emacs_event
)
6880 if (! WINDOWP (bar
->window
))
6883 emacs_event
->kind
= (bar
->horizontal
6884 ? HORIZONTAL_SCROLL_BAR_CLICK_EVENT
6885 : SCROLL_BAR_CLICK_EVENT
);
6886 emacs_event
->code
= event
->xbutton
.button
- Button1
;
6887 emacs_event
->modifiers
6888 = (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO
6889 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
6890 event
->xbutton
.state
)
6891 | (event
->type
== ButtonRelease
6894 emacs_event
->frame_or_window
= bar
->window
;
6895 emacs_event
->arg
= Qnil
;
6896 emacs_event
->timestamp
= event
->xbutton
.time
;
6897 if (bar
->horizontal
)
6900 = HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
6901 int x
= event
->xbutton
.x
- HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
6904 if (x
> left_range
) x
= left_range
;
6907 emacs_event
->part
= scroll_bar_before_handle
;
6908 else if (x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
6909 emacs_event
->part
= scroll_bar_horizontal_handle
;
6911 emacs_event
->part
= scroll_bar_after_handle
;
6913 #ifndef USE_TOOLKIT_SCROLL_BARS
6914 /* If the user has released the handle, set it to its final position. */
6915 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
6917 int new_start
= - bar
->dragging
;
6918 int new_end
= new_start
+ bar
->end
- bar
->start
;
6920 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
6925 XSETINT (emacs_event
->x
, left_range
);
6926 XSETINT (emacs_event
->y
, x
);
6931 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
6932 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
6935 if (y
> top_range
) y
= top_range
;
6938 emacs_event
->part
= scroll_bar_above_handle
;
6939 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
6940 emacs_event
->part
= scroll_bar_handle
;
6942 emacs_event
->part
= scroll_bar_below_handle
;
6944 #ifndef USE_TOOLKIT_SCROLL_BARS
6945 /* If the user has released the handle, set it to its final position. */
6946 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
6948 int new_start
= y
- bar
->dragging
;
6949 int new_end
= new_start
+ bar
->end
- bar
->start
;
6951 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
6956 XSETINT (emacs_event
->x
, y
);
6957 XSETINT (emacs_event
->y
, top_range
);
6961 #ifndef USE_TOOLKIT_SCROLL_BARS
6963 /* Handle some mouse motion while someone is dragging the scroll bar.
6965 This may be called from a signal handler, so we have to ignore GC
6969 x_scroll_bar_note_movement (struct scroll_bar
*bar
,
6970 const XMotionEvent
*event
)
6972 struct frame
*f
= XFRAME (XWINDOW (bar
->window
)->frame
);
6973 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6975 dpyinfo
->last_mouse_movement_time
= event
->time
;
6976 dpyinfo
->last_mouse_scroll_bar
= bar
;
6977 f
->mouse_moved
= true;
6979 /* If we're dragging the bar, display it. */
6980 if (bar
->dragging
!= -1)
6982 /* Where should the handle be now? */
6983 int new_start
= event
->y
- bar
->dragging
;
6985 if (new_start
!= bar
->start
)
6987 int new_end
= new_start
+ bar
->end
- bar
->start
;
6989 x_scroll_bar_set_handle (bar
, new_start
, new_end
, false);
6994 #endif /* !USE_TOOLKIT_SCROLL_BARS */
6996 /* Return information to the user about the current position of the mouse
6997 on the scroll bar. */
7000 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
7001 enum scroll_bar_part
*part
, Lisp_Object
*x
,
7002 Lisp_Object
*y
, Time
*timestamp
)
7004 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
7005 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
7006 Window w
= bar
->x_window
;
7007 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7009 Window dummy_window
;
7011 unsigned int dummy_mask
;
7015 /* Get the mouse's position relative to the scroll bar window, and
7017 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
7019 /* Root, child, root x and root y. */
7020 &dummy_window
, &dummy_window
,
7021 &dummy_coord
, &dummy_coord
,
7023 /* Position relative to scroll bar. */
7026 /* Mouse buttons and modifier keys. */
7029 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
7031 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
7033 if (bar
->dragging
!= -1)
7034 win_y
-= bar
->dragging
;
7038 if (win_y
> top_range
)
7042 *bar_window
= bar
->window
;
7044 if (bar
->dragging
!= -1)
7045 *part
= scroll_bar_handle
;
7046 else if (win_y
< bar
->start
)
7047 *part
= scroll_bar_above_handle
;
7048 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
7049 *part
= scroll_bar_handle
;
7051 *part
= scroll_bar_below_handle
;
7053 XSETINT (*x
, win_y
);
7054 XSETINT (*y
, top_range
);
7056 f
->mouse_moved
= false;
7057 dpyinfo
->last_mouse_scroll_bar
= NULL
;
7058 *timestamp
= dpyinfo
->last_mouse_movement_time
;
7065 /* Return information to the user about the current position of the mouse
7066 on the scroll bar. */
7069 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
7070 enum scroll_bar_part
*part
, Lisp_Object
*x
,
7071 Lisp_Object
*y
, Time
*timestamp
)
7073 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
7074 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
7075 Window w
= bar
->x_window
;
7076 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7078 Window dummy_window
;
7080 unsigned int dummy_mask
;
7084 /* Get the mouse's position relative to the scroll bar window, and
7086 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
7088 /* Root, child, root x and root y. */
7089 &dummy_window
, &dummy_window
,
7090 &dummy_coord
, &dummy_coord
,
7092 /* Position relative to scroll bar. */
7095 /* Mouse buttons and modifier keys. */
7098 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
7100 win_x
-= HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
7102 if (bar
->dragging
!= -1)
7103 win_x
-= bar
->dragging
;
7107 if (win_x
> left_range
)
7111 *bar_window
= bar
->window
;
7113 if (bar
->dragging
!= -1)
7114 *part
= scroll_bar_horizontal_handle
;
7115 else if (win_x
< bar
->start
)
7116 *part
= scroll_bar_before_handle
;
7117 else if (win_x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
7118 *part
= scroll_bar_handle
;
7120 *part
= scroll_bar_after_handle
;
7122 XSETINT (*y
, win_x
);
7123 XSETINT (*x
, left_range
);
7125 f
->mouse_moved
= false;
7126 dpyinfo
->last_mouse_scroll_bar
= NULL
;
7127 *timestamp
= dpyinfo
->last_mouse_movement_time
;
7134 /* The screen has been cleared so we may have changed foreground or
7135 background colors, and the scroll bars may need to be redrawn.
7136 Clear out the scroll bars, and ask for expose events, so we can
7140 x_scroll_bar_clear (struct frame
*f
)
7142 #ifndef USE_TOOLKIT_SCROLL_BARS
7145 /* We can have scroll bars even if this is 0,
7146 if we just turned off scroll bar mode.
7147 But in that case we should not clear them. */
7148 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
7149 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
7150 bar
= XSCROLL_BAR (bar
)->next
)
7151 XClearArea (FRAME_X_DISPLAY (f
),
7152 XSCROLL_BAR (bar
)->x_window
,
7154 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7157 #ifdef ENABLE_CHECKING
7159 /* Record the last 100 characters stored
7160 to help debug the loss-of-chars-during-GC problem. */
7162 static int temp_index
;
7163 static short temp_buffer
[100];
7165 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
7166 if (temp_index == ARRAYELTS (temp_buffer)) \
7168 temp_buffer[temp_index++] = (keysym)
7170 #else /* not ENABLE_CHECKING */
7172 #define STORE_KEYSYM_FOR_DEBUG(keysym) ((void)0)
7174 #endif /* ENABLE_CHECKING */
7176 /* Set this to nonzero to fake an "X I/O error"
7177 on a particular display. */
7179 static struct x_display_info
*XTread_socket_fake_io_error
;
7181 /* When we find no input here, we occasionally do a no-op command
7182 to verify that the X server is still running and we can still talk with it.
7183 We try all the open displays, one by one.
7184 This variable is used for cycling thru the displays. */
7186 static struct x_display_info
*next_noop_dpyinfo
;
7195 /* Filter events for the current X input method.
7196 DPYINFO is the display this event is for.
7197 EVENT is the X event to filter.
7199 Returns non-zero if the event was filtered, caller shall not process
7201 Returns zero if event is wasn't filtered. */
7205 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
7207 /* XFilterEvent returns non-zero if the input method has
7208 consumed the event. We pass the frame's X window to
7209 XFilterEvent because that's the one for which the IC
7212 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
7213 event
->xclient
.window
);
7215 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
7220 static int current_count
;
7221 static int current_finish
;
7222 static struct input_event
*current_hold_quit
;
7224 /* This is the filter function invoked by the GTK event loop.
7225 It is invoked before the XEvent is translated to a GdkEvent,
7226 so we have a chance to act on the event before GTK. */
7227 static GdkFilterReturn
7228 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
7230 XEvent
*xev
= (XEvent
*) gxev
;
7233 if (current_count
>= 0)
7235 struct x_display_info
*dpyinfo
;
7237 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
7240 /* Filter events for the current X input method.
7241 GTK calls XFilterEvent but not for key press and release,
7242 so we do it here. */
7243 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
7245 && x_filter_event (dpyinfo
, xev
))
7248 return GDK_FILTER_REMOVE
;
7253 current_finish
= X_EVENT_NORMAL
;
7256 += handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
7260 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
7264 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
7265 return GDK_FILTER_REMOVE
;
7267 return GDK_FILTER_CONTINUE
;
7269 #endif /* USE_GTK */
7272 static void xembed_send_message (struct frame
*f
, Time
,
7273 enum xembed_message
,
7274 long detail
, long data1
, long data2
);
7277 x_net_wm_state (struct frame
*f
, Window window
)
7279 int value
= FULLSCREEN_NONE
;
7280 Lisp_Object lval
= Qnil
;
7281 bool sticky
= false;
7283 get_current_wm_state (f
, window
, &value
, &sticky
);
7287 case FULLSCREEN_WIDTH
:
7290 case FULLSCREEN_HEIGHT
:
7293 case FULLSCREEN_BOTH
:
7296 case FULLSCREEN_MAXIMIZED
:
7301 frame_size_history_add
7302 (f
, Qx_net_wm_state
, 0, 0,
7303 list2 (get_frame_param (f
, Qfullscreen
), lval
));
7305 store_frame_param (f
, Qfullscreen
, lval
);
7306 /** store_frame_param (f, Qsticky, sticky ? Qt : Qnil); **/
7309 /* Handles the XEvent EVENT on display DPYINFO.
7311 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
7312 *FINISH is zero if caller should continue reading events.
7313 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
7314 *EVENT is unchanged unless we're processing KeyPress event.
7316 We return the number of characters stored into the buffer. */
7319 handle_one_xevent (struct x_display_info
*dpyinfo
,
7320 const XEvent
*event
,
7321 int *finish
, struct input_event
*hold_quit
)
7324 struct input_event ie
;
7325 struct selection_input_event sie
;
7329 ptrdiff_t nbytes
= 0;
7330 struct frame
*any
, *f
= NULL
;
7331 struct coding_system coding
;
7332 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
7333 /* This holds the state XLookupString needs to implement dead keys
7334 and other tricks known as "compose processing". _X Window System_
7335 says that a portable program can't use this, but Stephen Gildea assures
7336 me that letting the compiler initialize it to zeros will work okay. */
7337 static XComposeStatus compose_status
;
7341 *finish
= X_EVENT_NORMAL
;
7343 EVENT_INIT (inev
.ie
);
7344 inev
.ie
.kind
= NO_EVENT
;
7347 any
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
7349 if (any
&& any
->wait_event_type
== event
->type
)
7350 any
->wait_event_type
= 0; /* Indicates we got it. */
7352 switch (event
->type
)
7356 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_protocols
7357 && event
->xclient
.format
== 32)
7359 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_take_focus
)
7361 /* Use the value returned by x_any_window_to_frame
7362 because this could be the shell widget window
7363 if the frame has no title bar. */
7366 /* Not quite sure this is needed -pd */
7367 if (f
&& FRAME_XIC (f
))
7368 XSetICFocus (FRAME_XIC (f
));
7371 /* Emacs sets WM hints whose `input' field is `true'. This
7372 instructs the WM to set the input focus automatically for
7373 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
7374 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
7375 it has set the focus. So, XSetInputFocus below is not
7378 The call to XSetInputFocus below has also caused trouble. In
7379 cases where the XSetInputFocus done by the WM and the one
7380 below are temporally close (on a fast machine), the call
7381 below can generate additional FocusIn events which confuse
7384 /* Since we set WM_TAKE_FOCUS, we must call
7385 XSetInputFocus explicitly. But not if f is null,
7386 since that might be an event for a deleted frame. */
7389 Display
*d
= event
->xclient
.display
;
7390 /* Catch and ignore errors, in case window has been
7391 iconified by a window manager such as GWM. */
7393 XSetInputFocus (d
, event
->xclient
.window
,
7394 /* The ICCCM says this is
7395 the only valid choice. */
7397 event
->xclient
.data
.l
[1]);
7398 /* This is needed to detect the error
7399 if there is an error. */
7401 x_uncatch_errors ();
7403 /* Not certain about handling scroll bars here */
7408 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_save_yourself
)
7410 /* Save state modify the WM_COMMAND property to
7411 something which can reinstate us. This notifies
7412 the session manager, who's looking for such a
7413 PropertyNotify. Can restart processing when
7414 a keyboard or mouse event arrives. */
7415 /* If we have a session manager, don't set this.
7416 KDE will then start two Emacsen, one for the
7417 session manager and one for this. */
7419 if (! x_session_have_connection ())
7422 f
= x_top_window_to_frame (dpyinfo
,
7423 event
->xclient
.window
);
7424 /* This is just so we only give real data once
7425 for a single Emacs process. */
7426 if (f
== SELECTED_FRAME ())
7427 XSetCommand (FRAME_X_DISPLAY (f
),
7428 event
->xclient
.window
,
7429 initial_argv
, initial_argc
);
7431 XSetCommand (FRAME_X_DISPLAY (f
),
7432 event
->xclient
.window
,
7438 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_delete_window
)
7442 goto OTHER
; /* May be a dialog that is to be removed */
7444 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
7445 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7452 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_configure_denied
)
7455 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_window_moved
)
7458 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
7460 new_x
= event
->xclient
.data
.s
[0];
7461 new_y
= event
->xclient
.data
.s
[1];
7465 f
->left_pos
= new_x
;
7472 if (event
->xclient
.message_type
== dpyinfo
->Xatom_editres
)
7476 _XEditResCheckMessages (f
->output_data
.x
->widget
,
7477 NULL
, (XEvent
*) event
, NULL
);
7480 #endif /* HACK_EDITRES */
7482 if (event
->xclient
.message_type
== dpyinfo
->Xatom_DONE
7483 || event
->xclient
.message_type
== dpyinfo
->Xatom_PAGE
)
7485 /* Ghostview job completed. Kill it. We could
7486 reply with "Next" if we received "Page", but we
7487 currently never do because we are interested in
7488 images, only, which should have 1 page. */
7489 Pixmap pixmap
= (Pixmap
) event
->xclient
.data
.l
[1];
7490 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
7493 x_kill_gs_process (pixmap
, f
);
7494 expose_frame (f
, 0, 0, 0, 0);
7498 #ifdef USE_TOOLKIT_SCROLL_BARS
7499 /* Scroll bar callbacks send a ClientMessage from which
7500 we construct an input_event. */
7501 if (event
->xclient
.message_type
== dpyinfo
->Xatom_Scrollbar
)
7503 x_scroll_bar_to_input_event (event
, &inev
.ie
);
7504 *finish
= X_EVENT_GOTO_OUT
;
7507 else if (event
->xclient
.message_type
== dpyinfo
->Xatom_Horizontal_Scrollbar
)
7509 x_horizontal_scroll_bar_to_input_event (event
, &inev
.ie
);
7510 *finish
= X_EVENT_GOTO_OUT
;
7513 #endif /* USE_TOOLKIT_SCROLL_BARS */
7515 /* XEmbed messages from the embedder (if any). */
7516 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
7518 enum xembed_message msg
= event
->xclient
.data
.l
[1];
7519 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
7520 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7522 *finish
= X_EVENT_GOTO_OUT
;
7526 xft_settings_event (dpyinfo
, event
);
7531 if (x_handle_dnd_message (f
, &event
->xclient
, dpyinfo
, &inev
.ie
))
7532 *finish
= X_EVENT_DROP
;
7536 case SelectionNotify
:
7537 x_display_set_last_user_time (dpyinfo
, event
->xselection
.time
);
7538 #ifdef USE_X_TOOLKIT
7539 if (! x_window_to_frame (dpyinfo
, event
->xselection
.requestor
))
7541 #endif /* not USE_X_TOOLKIT */
7542 x_handle_selection_notify (&event
->xselection
);
7545 case SelectionClear
: /* Someone has grabbed ownership. */
7546 x_display_set_last_user_time (dpyinfo
, event
->xselectionclear
.time
);
7547 #ifdef USE_X_TOOLKIT
7548 if (! x_window_to_frame (dpyinfo
, event
->xselectionclear
.window
))
7550 #endif /* USE_X_TOOLKIT */
7552 const XSelectionClearEvent
*eventp
= &event
->xselectionclear
;
7554 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
7555 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
7556 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
7557 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
7561 case SelectionRequest
: /* Someone wants our selection. */
7562 x_display_set_last_user_time (dpyinfo
, event
->xselectionrequest
.time
);
7563 #ifdef USE_X_TOOLKIT
7564 if (!x_window_to_frame (dpyinfo
, event
->xselectionrequest
.owner
))
7566 #endif /* USE_X_TOOLKIT */
7568 const XSelectionRequestEvent
*eventp
= &event
->xselectionrequest
;
7570 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
7571 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
7572 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
7573 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
7574 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
7575 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
7576 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
7580 case PropertyNotify
:
7581 x_display_set_last_user_time (dpyinfo
, event
->xproperty
.time
);
7582 f
= x_top_window_to_frame (dpyinfo
, event
->xproperty
.window
);
7583 if (f
&& event
->xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
7585 bool not_hidden
= x_handle_net_wm_state (f
, &event
->xproperty
);
7586 if (not_hidden
&& FRAME_ICONIFIED_P (f
))
7588 /* Gnome shell does not iconify us when C-z is pressed.
7589 It hides the frame. So if our state says we aren't
7590 hidden anymore, treat it as deiconified. */
7591 SET_FRAME_VISIBLE (f
, 1);
7592 SET_FRAME_ICONIFIED (f
, false);
7593 f
->output_data
.x
->has_been_visible
= true;
7594 inev
.ie
.kind
= DEICONIFY_EVENT
;
7595 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7597 else if (! not_hidden
&& ! FRAME_ICONIFIED_P (f
))
7599 SET_FRAME_VISIBLE (f
, 0);
7600 SET_FRAME_ICONIFIED (f
, true);
7601 inev
.ie
.kind
= ICONIFY_EVENT
;
7602 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7606 x_handle_property_notify (&event
->xproperty
);
7607 xft_settings_event (dpyinfo
, event
);
7610 case ReparentNotify
:
7611 f
= x_top_window_to_frame (dpyinfo
, event
->xreparent
.window
);
7614 f
->output_data
.x
->parent_desc
= event
->xreparent
.parent
;
7615 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
7617 /* Perhaps reparented due to a WM restart. Reset this. */
7618 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
7619 FRAME_DISPLAY_INFO (f
)->net_supported_window
= 0;
7621 x_set_frame_alpha (f
);
7626 f
= x_window_to_frame (dpyinfo
, event
->xexpose
.window
);
7629 if (!FRAME_VISIBLE_P (f
))
7631 SET_FRAME_VISIBLE (f
, 1);
7632 SET_FRAME_ICONIFIED (f
, false);
7633 f
->output_data
.x
->has_been_visible
= true;
7634 SET_FRAME_GARBAGED (f
);
7638 #if defined (USE_GTK) && ! defined (HAVE_GTK3) && ! defined (USE_CAIRO)
7639 /* This seems to be needed for GTK 2.6 and later, see
7640 http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15398. */
7642 event
->xexpose
.x
, event
->xexpose
.y
,
7643 event
->xexpose
.width
, event
->xexpose
.height
);
7645 expose_frame (f
, event
->xexpose
.x
, event
->xexpose
.y
,
7646 event
->xexpose
.width
, event
->xexpose
.height
);
7651 #ifndef USE_TOOLKIT_SCROLL_BARS
7652 struct scroll_bar
*bar
;
7654 #if defined USE_LUCID
7655 /* Submenus of the Lucid menu bar aren't widgets
7656 themselves, so there's no way to dispatch events
7657 to them. Recognize this case separately. */
7659 Widget widget
= x_window_to_menu_bar (event
->xexpose
.window
);
7661 xlwmenu_redisplay (widget
);
7663 #endif /* USE_LUCID */
7665 #ifdef USE_TOOLKIT_SCROLL_BARS
7666 /* Dispatch event to the widget. */
7668 #else /* not USE_TOOLKIT_SCROLL_BARS */
7669 bar
= x_window_to_scroll_bar (event
->xexpose
.display
,
7670 event
->xexpose
.window
, 2);
7673 x_scroll_bar_expose (bar
, event
);
7674 #ifdef USE_X_TOOLKIT
7677 #endif /* USE_X_TOOLKIT */
7678 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7682 case GraphicsExpose
: /* This occurs when an XCopyArea's
7683 source area was obscured or not
7685 f
= x_window_to_frame (dpyinfo
, event
->xgraphicsexpose
.drawable
);
7687 expose_frame (f
, event
->xgraphicsexpose
.x
,
7688 event
->xgraphicsexpose
.y
,
7689 event
->xgraphicsexpose
.width
,
7690 event
->xgraphicsexpose
.height
);
7691 #ifdef USE_X_TOOLKIT
7694 #endif /* USE_X_TOOLKIT */
7697 case NoExpose
: /* This occurs when an XCopyArea's
7698 source area was completely
7703 /* Redo the mouse-highlight after the tooltip has gone. */
7704 if (event
->xunmap
.window
== tip_window
)
7707 x_redo_mouse_highlight (dpyinfo
);
7710 f
= x_top_window_to_frame (dpyinfo
, event
->xunmap
.window
);
7711 if (f
) /* F may no longer exist if
7712 the frame was deleted. */
7714 bool visible
= FRAME_VISIBLE_P (f
);
7715 /* While a frame is unmapped, display generation is
7716 disabled; you don't want to spend time updating a
7717 display that won't ever be seen. */
7718 SET_FRAME_VISIBLE (f
, 0);
7719 /* We can't distinguish, from the event, whether the window
7720 has become iconified or invisible. So assume, if it
7721 was previously visible, than now it is iconified.
7722 But x_make_frame_invisible clears both
7723 the visible flag and the iconified flag;
7724 and that way, we know the window is not iconified now. */
7725 if (visible
|| FRAME_ICONIFIED_P (f
))
7727 SET_FRAME_ICONIFIED (f
, true);
7728 inev
.ie
.kind
= ICONIFY_EVENT
;
7729 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7735 if (event
->xmap
.window
== tip_window
)
7736 /* The tooltip has been drawn already. Avoid
7737 the SET_FRAME_GARBAGED below. */
7740 /* We use x_top_window_to_frame because map events can
7741 come for sub-windows and they don't mean that the
7742 frame is visible. */
7743 f
= x_top_window_to_frame (dpyinfo
, event
->xmap
.window
);
7746 bool iconified
= FRAME_ICONIFIED_P (f
);
7748 /* Check if fullscreen was specified before we where mapped the
7749 first time, i.e. from the command line. */
7750 if (!f
->output_data
.x
->has_been_visible
)
7751 x_check_fullscreen (f
);
7753 SET_FRAME_VISIBLE (f
, 1);
7754 SET_FRAME_ICONIFIED (f
, false);
7755 f
->output_data
.x
->has_been_visible
= true;
7759 inev
.ie
.kind
= DEICONIFY_EVENT
;
7760 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7762 else if (! NILP (Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
7763 /* Force a redisplay sooner or later to update the
7764 frame titles in case this is the second frame. */
7765 record_asynch_buffer_change ();
7768 xg_frame_resized (f
, -1, -1);
7775 x_display_set_last_user_time (dpyinfo
, event
->xkey
.time
);
7776 ignore_next_mouse_click_timeout
= 0;
7778 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
7779 /* Dispatch KeyPress events when in menu. */
7780 if (popup_activated ())
7786 #if ! defined (USE_GTK)
7787 /* If mouse-highlight is an integer, input clears out
7788 mouse highlighting. */
7789 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
7791 || !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)))
7793 clear_mouse_face (hlinfo
);
7794 hlinfo
->mouse_face_hidden
= true;
7798 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
7801 /* Scroll bars consume key events, but we want
7802 the keys to go to the scroll bar's frame. */
7803 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
7804 event
->xkey
.window
);
7805 if (widget
&& XmIsScrollBar (widget
))
7807 widget
= XtParent (widget
);
7808 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
7811 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
7815 KeySym keysym
, orig_keysym
;
7816 /* al%imercury@uunet.uu.net says that making this 81
7817 instead of 80 fixed a bug whereby meta chars made
7820 It seems that some version of XmbLookupString has
7821 a bug of not returning XBufferOverflow in
7822 status_return even if the input is too long to
7823 fit in 81 bytes. So, we must prepare sufficient
7824 bytes for copy_buffer. 513 bytes (256 chars for
7825 two-byte character set) seems to be a fairly good
7826 approximation. -- 2000.8.10 handa@etl.go.jp */
7827 unsigned char copy_buffer
[513];
7828 unsigned char *copy_bufptr
= copy_buffer
;
7829 int copy_bufsiz
= sizeof (copy_buffer
);
7831 Lisp_Object coding_system
= Qlatin_1
;
7833 /* Event will be modified. */
7834 XKeyEvent xkey
= event
->xkey
;
7837 /* Don't pass keys to GTK. A Tab will shift focus to the
7838 tool bar in GTK 2.4. Keys will still go to menus and
7839 dialogs because in that case popup_activated is nonzero
7841 *finish
= X_EVENT_DROP
;
7844 xkey
.state
|= x_emacs_to_x_modifiers (FRAME_DISPLAY_INFO (f
),
7845 extra_keyboard_modifiers
);
7846 modifiers
= xkey
.state
;
7848 /* This will have to go some day... */
7850 /* make_lispy_event turns chars into control chars.
7851 Don't do it here because XLookupString is too eager. */
7852 xkey
.state
&= ~ControlMask
;
7853 xkey
.state
&= ~(dpyinfo
->meta_mod_mask
7854 | dpyinfo
->super_mod_mask
7855 | dpyinfo
->hyper_mod_mask
7856 | dpyinfo
->alt_mod_mask
);
7858 /* In case Meta is ComposeCharacter,
7859 clear its status. According to Markus Ehrnsperger
7860 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
7861 this enables ComposeCharacter to work whether or
7862 not it is combined with Meta. */
7863 if (modifiers
& dpyinfo
->meta_mod_mask
)
7864 memset (&compose_status
, 0, sizeof (compose_status
));
7869 Status status_return
;
7871 coding_system
= Vlocale_coding_system
;
7872 nbytes
= XmbLookupString (FRAME_XIC (f
),
7873 &xkey
, (char *) copy_bufptr
,
7874 copy_bufsiz
, &keysym
,
7876 if (status_return
== XBufferOverflow
)
7878 copy_bufsiz
= nbytes
+ 1;
7879 copy_bufptr
= alloca (copy_bufsiz
);
7880 nbytes
= XmbLookupString (FRAME_XIC (f
),
7881 &xkey
, (char *) copy_bufptr
,
7882 copy_bufsiz
, &keysym
,
7885 /* Xutf8LookupString is a new but already deprecated interface. -stef */
7886 if (status_return
== XLookupNone
)
7888 else if (status_return
== XLookupChars
)
7893 else if (status_return
!= XLookupKeySym
7894 && status_return
!= XLookupBoth
)
7898 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
7899 copy_bufsiz
, &keysym
,
7902 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
7903 copy_bufsiz
, &keysym
,
7907 /* If not using XIM/XIC, and a compose sequence is in progress,
7908 we break here. Otherwise, chars_matched is always 0. */
7909 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
7912 memset (&compose_status
, 0, sizeof (compose_status
));
7913 orig_keysym
= keysym
;
7915 /* Common for all keysym input events. */
7916 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7918 = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), modifiers
);
7919 inev
.ie
.timestamp
= xkey
.time
;
7921 /* First deal with keysyms which have defined
7922 translations to characters. */
7923 if (keysym
>= 32 && keysym
< 128)
7924 /* Avoid explicitly decoding each ASCII character. */
7926 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
7927 inev
.ie
.code
= keysym
;
7931 /* Keysyms directly mapped to Unicode characters. */
7932 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
7934 if (keysym
< 0x01000080)
7935 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
7937 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
7938 inev
.ie
.code
= keysym
& 0xFFFFFF;
7942 /* Now non-ASCII. */
7943 if (HASH_TABLE_P (Vx_keysym_table
)
7944 && (c
= Fgethash (make_number (keysym
),
7949 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
7950 ? ASCII_KEYSTROKE_EVENT
7951 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
7952 inev
.ie
.code
= XFASTINT (c
);
7956 /* Random non-modifier sorts of keysyms. */
7957 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
7958 || keysym
== XK_Delete
7959 #ifdef XK_ISO_Left_Tab
7960 || (keysym
>= XK_ISO_Left_Tab
7961 && keysym
<= XK_ISO_Enter
)
7963 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
7964 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
7966 /* This recognizes the "extended function
7967 keys". It seems there's no cleaner way.
7968 Test IsModifierKey to avoid handling
7969 mode_switch incorrectly. */
7970 || (XK_Select
<= keysym
&& keysym
< XK_KP_Space
)
7972 #ifdef XK_dead_circumflex
7973 || orig_keysym
== XK_dead_circumflex
7975 #ifdef XK_dead_grave
7976 || orig_keysym
== XK_dead_grave
7978 #ifdef XK_dead_tilde
7979 || orig_keysym
== XK_dead_tilde
7981 #ifdef XK_dead_diaeresis
7982 || orig_keysym
== XK_dead_diaeresis
7984 #ifdef XK_dead_macron
7985 || orig_keysym
== XK_dead_macron
7987 #ifdef XK_dead_degree
7988 || orig_keysym
== XK_dead_degree
7990 #ifdef XK_dead_acute
7991 || orig_keysym
== XK_dead_acute
7993 #ifdef XK_dead_cedilla
7994 || orig_keysym
== XK_dead_cedilla
7996 #ifdef XK_dead_breve
7997 || orig_keysym
== XK_dead_breve
7999 #ifdef XK_dead_ogonek
8000 || orig_keysym
== XK_dead_ogonek
8002 #ifdef XK_dead_caron
8003 || orig_keysym
== XK_dead_caron
8005 #ifdef XK_dead_doubleacute
8006 || orig_keysym
== XK_dead_doubleacute
8008 #ifdef XK_dead_abovedot
8009 || orig_keysym
== XK_dead_abovedot
8011 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
8012 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
8013 /* Any "vendor-specific" key is ok. */
8014 || (orig_keysym
& (1 << 28))
8015 || (keysym
!= NoSymbol
&& nbytes
== 0))
8016 && ! (IsModifierKey (orig_keysym
)
8017 /* The symbols from XK_ISO_Lock
8018 to XK_ISO_Last_Group_Lock
8019 don't have real modifiers but
8020 should be treated similarly to
8021 Mode_switch by Emacs. */
8022 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
8023 || (XK_ISO_Lock
<= orig_keysym
8024 && orig_keysym
<= XK_ISO_Last_Group_Lock
)
8028 STORE_KEYSYM_FOR_DEBUG (keysym
);
8029 /* make_lispy_event will convert this to a symbolic
8031 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
8032 inev
.ie
.code
= keysym
;
8036 { /* Raw bytes, not keysym. */
8040 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
8042 if (ASCII_CHAR_P (copy_bufptr
[i
]))
8044 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
8047 if (nchars
< nbytes
)
8049 /* Decode the input data. */
8051 /* The input should be decoded with `coding_system'
8052 which depends on which X*LookupString function
8053 we used just above and the locale. */
8054 setup_coding_system (coding_system
, &coding
);
8055 coding
.src_multibyte
= false;
8056 coding
.dst_multibyte
= true;
8057 /* The input is converted to events, thus we can't
8058 handle composition. Anyway, there's no XIM that
8059 gives us composition information. */
8060 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
8062 SAFE_NALLOCA (coding
.destination
, MAX_MULTIBYTE_LENGTH
,
8064 coding
.dst_bytes
= MAX_MULTIBYTE_LENGTH
* nbytes
;
8065 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
8066 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
8067 nbytes
= coding
.produced
;
8068 nchars
= coding
.produced_char
;
8069 copy_bufptr
= coding
.destination
;
8072 /* Convert the input data to a sequence of
8073 character events. */
8074 for (i
= 0; i
< nbytes
; i
+= len
)
8077 if (nchars
== nbytes
)
8078 ch
= copy_bufptr
[i
], len
= 1;
8080 ch
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
8081 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (ch
)
8082 ? ASCII_KEYSTROKE_EVENT
8083 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
8085 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
8090 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
8092 if (keysym
== NoSymbol
)
8095 /* FIXME: check side effects and remove this. */
8096 ((XEvent
*) event
)->xkey
= xkey
;
8100 /* Don't dispatch this event since XtDispatchEvent calls
8101 XFilterEvent, and two calls in a row may freeze the
8109 x_display_set_last_user_time (dpyinfo
, event
->xkey
.time
);
8111 /* Don't dispatch this event since XtDispatchEvent calls
8112 XFilterEvent, and two calls in a row may freeze the
8120 x_display_set_last_user_time (dpyinfo
, event
->xcrossing
.time
);
8121 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8125 if (f
&& x_mouse_click_focus_ignore_position
)
8126 ignore_next_mouse_click_timeout
= event
->xmotion
.time
+ 200;
8128 /* EnterNotify counts as mouse movement,
8129 so update things that depend on mouse position. */
8130 if (f
&& !f
->output_data
.x
->hourglass_p
)
8131 note_mouse_movement (f
, &event
->xmotion
);
8133 /* We may get an EnterNotify on the buttons in the toolbar. In that
8134 case we moved out of any highlighted area and need to note this. */
8135 if (!f
&& dpyinfo
->last_mouse_glyph_frame
)
8136 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
8141 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8145 x_display_set_last_user_time (dpyinfo
, event
->xcrossing
.time
);
8146 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8148 f
= x_top_window_to_frame (dpyinfo
, event
->xcrossing
.window
);
8151 if (f
== hlinfo
->mouse_face_mouse_frame
)
8153 /* If we move outside the frame, then we're
8154 certainly no longer on any text in the frame. */
8155 clear_mouse_face (hlinfo
);
8156 hlinfo
->mouse_face_mouse_frame
= 0;
8159 /* Generate a nil HELP_EVENT to cancel a help-echo.
8160 Do it only if there's something to cancel.
8161 Otherwise, the startup message is cleared when
8162 the mouse leaves the frame. */
8163 if (any_help_event_p
)
8167 /* See comment in EnterNotify above */
8168 else if (dpyinfo
->last_mouse_glyph_frame
)
8169 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
8174 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
8179 x_display_set_last_user_time (dpyinfo
, event
->xmotion
.time
);
8180 previous_help_echo_string
= help_echo_string
;
8181 help_echo_string
= Qnil
;
8183 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
8184 : x_window_to_frame (dpyinfo
, event
->xmotion
.window
));
8186 if (hlinfo
->mouse_face_hidden
)
8188 hlinfo
->mouse_face_hidden
= false;
8189 clear_mouse_face (hlinfo
);
8193 if (f
&& xg_event_is_for_scrollbar (f
, event
))
8199 /* Generate SELECT_WINDOW_EVENTs when needed.
8200 Don't let popup menus influence things (bug#1261). */
8201 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
8203 static Lisp_Object last_mouse_window
;
8204 Lisp_Object window
= window_from_coordinates
8205 (f
, event
->xmotion
.x
, event
->xmotion
.y
, 0, false);
8207 /* Window will be selected only when it is not selected now and
8208 last mouse movement event was not in it. Minibuffer window
8209 will be selected only when it is active. */
8210 if (WINDOWP (window
)
8211 && !EQ (window
, last_mouse_window
)
8212 && !EQ (window
, selected_window
)
8213 /* For click-to-focus window managers
8214 create event iff we don't leave the
8216 && (focus_follows_mouse
8217 || (EQ (XWINDOW (window
)->frame
,
8218 XWINDOW (selected_window
)->frame
))))
8220 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
8221 inev
.ie
.frame_or_window
= window
;
8223 /* Remember the last window where we saw the mouse. */
8224 last_mouse_window
= window
;
8226 if (!note_mouse_movement (f
, &event
->xmotion
))
8227 help_echo_string
= previous_help_echo_string
;
8231 #ifndef USE_TOOLKIT_SCROLL_BARS
8232 struct scroll_bar
*bar
8233 = x_window_to_scroll_bar (event
->xmotion
.display
,
8234 event
->xmotion
.window
, 2);
8237 x_scroll_bar_note_movement (bar
, &event
->xmotion
);
8238 #endif /* USE_TOOLKIT_SCROLL_BARS */
8240 /* If we move outside the frame, then we're
8241 certainly no longer on any text in the frame. */
8242 clear_mouse_face (hlinfo
);
8245 /* If the contents of the global variable help_echo_string
8246 has changed, generate a HELP_EVENT. */
8247 if (!NILP (help_echo_string
)
8248 || !NILP (previous_help_echo_string
))
8253 case ConfigureNotify
:
8254 f
= x_top_window_to_frame (dpyinfo
, event
->xconfigure
.window
);
8256 if (f
) x_cr_destroy_surface (f
);
8261 && event
->xconfigure
.window
== FRAME_X_WINDOW (f
))
8263 xg_frame_resized (f
, event
->xconfigure
.width
,
8264 event
->xconfigure
.height
);
8265 x_cr_destroy_surface (f
);
8271 x_net_wm_state (f
, event
->xconfigure
.window
);
8273 #ifndef USE_X_TOOLKIT
8275 int width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, event
->xconfigure
.width
);
8276 int height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, event
->xconfigure
.height
);
8278 /* In the toolkit version, change_frame_size
8279 is called by the code that handles resizing
8280 of the EmacsFrame widget. */
8282 /* Even if the number of character rows and columns has
8283 not changed, the font size may have changed, so we need
8284 to check the pixel dimensions as well. */
8285 if (width
!= FRAME_TEXT_WIDTH (f
)
8286 || height
!= FRAME_TEXT_HEIGHT (f
)
8287 || event
->xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
8288 || event
->xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
8290 change_frame_size (f
, width
, height
, false, true, false, true);
8291 x_clear_under_internal_border (f
);
8292 SET_FRAME_GARBAGED (f
);
8293 cancel_mouse_face (f
);
8295 #endif /* not USE_GTK */
8299 /* GTK creates windows but doesn't map them.
8300 Only get real positions when mapped. */
8301 if (FRAME_GTK_OUTER_WIDGET (f
)
8302 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
8304 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
8307 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
8308 xic_set_statusarea (f
);
8317 /* If we decide we want to generate an event to be seen
8318 by the rest of Emacs, we put it here. */
8319 bool tool_bar_p
= false;
8321 memset (&compose_status
, 0, sizeof (compose_status
));
8322 dpyinfo
->last_mouse_glyph_frame
= NULL
;
8323 x_display_set_last_user_time (dpyinfo
, event
->xbutton
.time
);
8325 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
8326 : x_window_to_frame (dpyinfo
, event
->xbutton
.window
));
8329 if (f
&& xg_event_is_for_scrollbar (f
, event
))
8334 #if ! defined (USE_GTK)
8335 /* Is this in the tool-bar? */
8336 if (WINDOWP (f
->tool_bar_window
)
8337 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
8340 int x
= event
->xbutton
.x
;
8341 int y
= event
->xbutton
.y
;
8343 window
= window_from_coordinates (f
, x
, y
, 0, true);
8344 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
8346 if (tool_bar_p
&& event
->xbutton
.button
< 4)
8347 handle_tool_bar_click
8348 (f
, x
, y
, event
->xbutton
.type
== ButtonPress
,
8349 x_x_to_emacs_modifiers (dpyinfo
, event
->xbutton
.state
));
8351 #endif /* !USE_GTK */
8354 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
8355 if (! popup_activated ())
8358 if (ignore_next_mouse_click_timeout
)
8360 if (event
->type
== ButtonPress
8361 && event
->xbutton
.time
> ignore_next_mouse_click_timeout
)
8363 ignore_next_mouse_click_timeout
= 0;
8364 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
8366 if (event
->type
== ButtonRelease
)
8367 ignore_next_mouse_click_timeout
= 0;
8370 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
8372 if (FRAME_X_EMBEDDED_P (f
))
8373 xembed_send_message (f
, event
->xbutton
.time
,
8374 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
8378 struct scroll_bar
*bar
8379 = x_window_to_scroll_bar (event
->xbutton
.display
,
8380 event
->xbutton
.window
, 2);
8382 #ifdef USE_TOOLKIT_SCROLL_BARS
8383 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
8385 if (bar
&& event
->xbutton
.state
& ControlMask
)
8387 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
8388 *finish
= X_EVENT_DROP
;
8390 #else /* not USE_TOOLKIT_SCROLL_BARS */
8392 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
8393 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8396 if (event
->type
== ButtonPress
)
8398 dpyinfo
->grabbed
|= (1 << event
->xbutton
.button
);
8399 dpyinfo
->last_mouse_frame
= f
;
8400 #if ! defined (USE_GTK)
8401 if (f
&& !tool_bar_p
)
8402 f
->last_tool_bar_item
= -1;
8403 #endif /* not USE_GTK */
8406 dpyinfo
->grabbed
&= ~(1 << event
->xbutton
.button
);
8408 /* Ignore any mouse motion that happened before this event;
8409 any subsequent mouse-movement Emacs events should reflect
8410 only motion after the ButtonPress/Release. */
8412 f
->mouse_moved
= false;
8414 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
8415 f
= x_menubar_window_to_frame (dpyinfo
, event
);
8416 /* For a down-event in the menu bar,
8417 don't pass it to Xt right now.
8418 Instead, save it away
8419 and we will pass it to Xt from kbd_buffer_get_event.
8420 That way, we can run some Lisp code first. */
8421 if (! popup_activated ()
8423 /* Gtk+ menus only react to the first three buttons. */
8424 && event
->xbutton
.button
< 3
8426 && f
&& event
->type
== ButtonPress
8427 /* Verify the event is really within the menu bar
8428 and not just sent to it due to grabbing. */
8429 && event
->xbutton
.x
>= 0
8430 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
8431 && event
->xbutton
.y
>= 0
8432 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
8433 && event
->xbutton
.same_screen
)
8435 if (!f
->output_data
.x
->saved_menu_event
)
8436 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof *event
);
8437 *f
->output_data
.x
->saved_menu_event
= *event
;
8438 inev
.ie
.kind
= MENU_BAR_ACTIVATE_EVENT
;
8439 XSETFRAME (inev
.ie
.frame_or_window
, f
);
8440 *finish
= X_EVENT_DROP
;
8444 #endif /* USE_X_TOOLKIT || USE_GTK */
8448 case CirculateNotify
:
8451 case CirculateRequest
:
8454 case VisibilityNotify
:
8458 /* Someone has changed the keyboard mapping - update the
8460 switch (event
->xmapping
.request
)
8462 case MappingModifier
:
8463 x_find_modifier_meanings (dpyinfo
);
8464 /* This is meant to fall through. */
8465 case MappingKeyboard
:
8466 XRefreshKeyboardMapping ((XMappingEvent
*) &event
->xmapping
);
8471 xft_settings_event (dpyinfo
, event
);
8476 #ifdef USE_X_TOOLKIT
8478 if (*finish
!= X_EVENT_DROP
)
8479 XtDispatchEvent ((XEvent
*) event
);
8481 #endif /* USE_X_TOOLKIT */
8486 if (inev
.ie
.kind
!= NO_EVENT
)
8488 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
8493 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
8498 XSETFRAME (frame
, f
);
8504 any_help_event_p
= true;
8505 gen_help_event (help_echo_string
, frame
, help_echo_window
,
8506 help_echo_object
, help_echo_pos
);
8510 help_echo_string
= Qnil
;
8511 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
8520 /* Handles the XEvent EVENT on display DISPLAY.
8521 This is used for event loops outside the normal event handling,
8522 i.e. looping while a popup menu or a dialog is posted.
8524 Returns the value handle_one_xevent sets in the finish argument. */
8526 x_dispatch_event (XEvent
*event
, Display
*display
)
8528 struct x_display_info
*dpyinfo
;
8529 int finish
= X_EVENT_NORMAL
;
8531 dpyinfo
= x_display_info_for_display (display
);
8534 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
8539 /* Read events coming from the X server.
8540 Return as soon as there are no more events to be read.
8542 Return the number of characters stored into the buffer,
8543 thus pretending to be `read' (except the characters we store
8544 in the keyboard buffer can be multibyte, so are not necessarily
8548 XTread_socket (struct terminal
*terminal
, struct input_event
*hold_quit
)
8551 bool event_found
= false;
8552 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
8556 /* For debugging, this gives a way to fake an I/O error. */
8557 if (dpyinfo
== XTread_socket_fake_io_error
)
8559 XTread_socket_fake_io_error
= 0;
8560 x_io_error_quitter (dpyinfo
->display
);
8564 while (XPending (dpyinfo
->display
))
8569 XNextEvent (dpyinfo
->display
, &event
);
8572 /* Filter events for the current X input method. */
8573 if (x_filter_event (dpyinfo
, &event
))
8578 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
8580 if (finish
== X_EVENT_GOTO_OUT
)
8586 /* For GTK we must use the GTK event loop. But XEvents gets passed
8587 to our filter function above, and then to the big event switch.
8588 We use a bunch of globals to communicate with our filter function,
8589 that is kind of ugly, but it works.
8591 There is no way to do one display at the time, GTK just does events
8592 from all displays. */
8594 while (gtk_events_pending ())
8596 current_count
= count
;
8597 current_hold_quit
= hold_quit
;
8599 gtk_main_iteration ();
8601 count
= current_count
;
8603 current_hold_quit
= 0;
8605 if (current_finish
== X_EVENT_GOTO_OUT
)
8608 #endif /* USE_GTK */
8610 /* On some systems, an X bug causes Emacs to get no more events
8611 when the window is destroyed. Detect that. (1994.) */
8614 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
8615 One XNOOP in 100 loops will make Emacs terminate.
8616 B. Bretthauer, 1994 */
8618 if (x_noop_count
>= 100)
8622 if (next_noop_dpyinfo
== 0)
8623 next_noop_dpyinfo
= x_display_list
;
8625 XNoOp (next_noop_dpyinfo
->display
);
8627 /* Each time we get here, cycle through the displays now open. */
8628 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
8632 /* If the focus was just given to an auto-raising frame,
8633 raise it now. FIXME: handle more than one such frame. */
8634 if (dpyinfo
->x_pending_autoraise_frame
)
8636 x_raise_frame (dpyinfo
->x_pending_autoraise_frame
);
8637 dpyinfo
->x_pending_autoraise_frame
= NULL
;
8648 /***********************************************************************
8650 ***********************************************************************/
8652 /* Set clipping for output in glyph row ROW. W is the window in which
8653 we operate. GC is the graphics context to set clipping in.
8655 ROW may be a text row or, e.g., a mode line. Text rows must be
8656 clipped to the interior of the window dedicated to text display,
8657 mode lines must be clipped to the whole window. */
8660 x_clip_to_row (struct window
*w
, struct glyph_row
*row
,
8661 enum glyph_row_area area
, GC gc
)
8663 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8664 XRectangle clip_rect
;
8665 int window_x
, window_y
, window_width
;
8667 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
8669 clip_rect
.x
= window_x
;
8670 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
8671 clip_rect
.y
= max (clip_rect
.y
, window_y
);
8672 clip_rect
.width
= window_width
;
8673 clip_rect
.height
= row
->visible_height
;
8675 x_set_clip_rectangles (f
, gc
, &clip_rect
, 1);
8679 /* Draw a hollow box cursor on window W in glyph row ROW. */
8682 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
8684 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8685 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8686 Display
*dpy
= FRAME_X_DISPLAY (f
);
8689 struct glyph
*cursor_glyph
;
8692 /* Get the glyph the cursor is on. If we can't tell because
8693 the current matrix is invalid or such, give up. */
8694 cursor_glyph
= get_phys_cursor_glyph (w
);
8695 if (cursor_glyph
== NULL
)
8698 /* Compute frame-relative coordinates for phys cursor. */
8699 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
8700 wd
= w
->phys_cursor_width
- 1;
8702 /* The foreground of cursor_gc is typically the same as the normal
8703 background color, which can cause the cursor box to be invisible. */
8704 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
8705 if (dpyinfo
->scratch_cursor_gc
)
8706 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
8708 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
8709 GCForeground
, &xgcv
);
8710 gc
= dpyinfo
->scratch_cursor_gc
;
8712 /* When on R2L character, show cursor at the right edge of the
8713 glyph, unless the cursor box is as wide as the glyph or wider
8714 (the latter happens when x-stretch-cursor is non-nil). */
8715 if ((cursor_glyph
->resolved_level
& 1) != 0
8716 && cursor_glyph
->pixel_width
> wd
)
8718 x
+= cursor_glyph
->pixel_width
- wd
;
8722 /* Set clipping, draw the rectangle, and reset clipping again. */
8723 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
8724 x_draw_rectangle (f
, gc
, x
, y
, wd
, h
- 1);
8725 x_reset_clip_rectangles (f
, gc
);
8729 /* Draw a bar cursor on window W in glyph row ROW.
8731 Implementation note: One would like to draw a bar cursor with an
8732 angle equal to the one given by the font property XA_ITALIC_ANGLE.
8733 Unfortunately, I didn't find a font yet that has this property set.
8737 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
8739 struct frame
*f
= XFRAME (w
->frame
);
8740 struct glyph
*cursor_glyph
;
8742 /* If cursor is out of bounds, don't draw garbage. This can happen
8743 in mini-buffer windows when switching between echo area glyphs
8745 cursor_glyph
= get_phys_cursor_glyph (w
);
8746 if (cursor_glyph
== NULL
)
8749 /* If on an image, draw like a normal cursor. That's usually better
8750 visible than drawing a bar, esp. if the image is large so that
8751 the bar might not be in the window. */
8752 if (cursor_glyph
->type
== IMAGE_GLYPH
)
8754 struct glyph_row
*r
;
8755 r
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
8756 draw_phys_cursor_glyph (w
, r
, DRAW_CURSOR
);
8760 Display
*dpy
= FRAME_X_DISPLAY (f
);
8761 Window window
= FRAME_X_WINDOW (f
);
8762 GC gc
= FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
;
8763 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
8764 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
8767 /* If the glyph's background equals the color we normally draw
8768 the bars cursor in, the bar cursor in its normal color is
8769 invisible. Use the glyph's foreground color instead in this
8770 case, on the assumption that the glyph's colors are chosen so
8771 that the glyph is legible. */
8772 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
8773 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
8775 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
8776 xgcv
.graphics_exposures
= False
;
8779 XChangeGC (dpy
, gc
, mask
, &xgcv
);
8782 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
8783 FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
8786 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
8788 if (kind
== BAR_CURSOR
)
8790 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8793 width
= FRAME_CURSOR_WIDTH (f
);
8794 width
= min (cursor_glyph
->pixel_width
, width
);
8796 w
->phys_cursor_width
= width
;
8798 /* If the character under cursor is R2L, draw the bar cursor
8799 on the right of its glyph, rather than on the left. */
8800 if ((cursor_glyph
->resolved_level
& 1) != 0)
8801 x
+= cursor_glyph
->pixel_width
- width
;
8803 x_fill_rectangle (f
, gc
, x
,
8804 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
8805 width
, row
->height
);
8807 else /* HBAR_CURSOR */
8809 int dummy_x
, dummy_y
, dummy_h
;
8810 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8813 width
= row
->height
;
8815 width
= min (row
->height
, width
);
8817 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
8818 &dummy_y
, &dummy_h
);
8820 if ((cursor_glyph
->resolved_level
& 1) != 0
8821 && cursor_glyph
->pixel_width
> w
->phys_cursor_width
- 1)
8822 x
+= cursor_glyph
->pixel_width
- w
->phys_cursor_width
+ 1;
8823 x_fill_rectangle (f
, gc
, x
,
8824 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
8825 row
->height
- width
),
8826 w
->phys_cursor_width
- 1, width
);
8829 x_reset_clip_rectangles (f
, gc
);
8834 /* RIF: Define cursor CURSOR on frame F. */
8837 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
8839 if (!f
->pointer_invisible
8840 && f
->output_data
.x
->current_cursor
!= cursor
)
8841 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
8842 f
->output_data
.x
->current_cursor
= cursor
;
8846 /* RIF: Clear area on frame F. */
8849 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
8851 x_clear_area (f
, x
, y
, width
, height
);
8853 /* Must queue a redraw, because scroll bars might have been cleared. */
8854 if (FRAME_GTK_WIDGET (f
))
8855 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
8860 /* RIF: Draw cursor on window W. */
8863 x_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
, int x
,
8864 int y
, enum text_cursor_kinds cursor_type
,
8865 int cursor_width
, bool on_p
, bool active_p
)
8867 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8871 w
->phys_cursor_type
= cursor_type
;
8872 w
->phys_cursor_on_p
= true;
8874 if (glyph_row
->exact_window_width_line_p
8875 && (glyph_row
->reversed_p
8876 ? (w
->phys_cursor
.hpos
< 0)
8877 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
8879 glyph_row
->cursor_in_fringe_p
= true;
8880 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
8884 switch (cursor_type
)
8886 case HOLLOW_BOX_CURSOR
:
8887 x_draw_hollow_cursor (w
, glyph_row
);
8890 case FILLED_BOX_CURSOR
:
8891 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
8895 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
8899 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
8903 w
->phys_cursor_width
= 0;
8912 if (w
== XWINDOW (f
->selected_window
))
8913 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
8914 xic_set_preeditarea (w
, x
, y
);
8918 XFlush (FRAME_X_DISPLAY (f
));
8924 /* Make the x-window of frame F use the gnu icon bitmap. */
8927 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
8929 ptrdiff_t bitmap_id
;
8931 if (FRAME_X_WINDOW (f
) == 0)
8934 /* Free up our existing icon bitmap and mask if any. */
8935 if (f
->output_data
.x
->icon_bitmap
> 0)
8936 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
8937 f
->output_data
.x
->icon_bitmap
= 0;
8942 /* Use gtk_window_set_icon_from_file () if available,
8943 It's not restricted to bitmaps */
8944 if (xg_set_icon (f
, file
))
8946 #endif /* USE_GTK */
8947 bitmap_id
= x_create_bitmap_from_file (f
, file
);
8948 x_create_bitmap_mask (f
, bitmap_id
);
8952 /* Create the GNU bitmap and mask if necessary. */
8953 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
8959 if (xg_set_icon (f
, xg_default_icon_file
)
8960 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
8962 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= -2;
8966 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
8968 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
8970 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
8974 /* If all else fails, use the (black and white) xbm image. */
8977 rc
= x_create_bitmap_from_data (f
, (char *) gnu_xbm_bits
,
8978 gnu_xbm_width
, gnu_xbm_height
);
8982 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
8983 x_create_bitmap_mask (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
8987 /* The first time we create the GNU bitmap and mask,
8988 this increments the ref-count one extra time.
8989 As a result, the GNU bitmap and mask are never freed.
8990 That way, we don't have to worry about allocating it again. */
8991 x_reference_bitmap (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
8993 bitmap_id
= FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
;
8996 x_wm_set_icon_pixmap (f
, bitmap_id
);
8997 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
9003 /* Make the x-window of frame F use a rectangle with text.
9004 Use ICON_NAME as the text. */
9007 x_text_icon (struct frame
*f
, const char *icon_name
)
9009 if (FRAME_X_WINDOW (f
) == 0)
9014 text
.value
= (unsigned char *) icon_name
;
9015 text
.encoding
= XA_STRING
;
9017 text
.nitems
= strlen (icon_name
);
9018 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
9021 if (f
->output_data
.x
->icon_bitmap
> 0)
9022 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
9023 f
->output_data
.x
->icon_bitmap
= 0;
9024 x_wm_set_icon_pixmap (f
, 0);
9029 #define X_ERROR_MESSAGE_SIZE 200
9031 /* If non-nil, this should be a string.
9032 It means catch X errors and store the error message in this string.
9034 The reason we use a stack is that x_catch_error/x_uncatch_error can
9035 be called from a signal handler.
9038 struct x_error_message_stack
{
9039 char string
[X_ERROR_MESSAGE_SIZE
];
9041 struct x_error_message_stack
*prev
;
9043 static struct x_error_message_stack
*x_error_message
;
9045 /* An X error handler which stores the error message in
9046 *x_error_message. This is called from x_error_handler if
9047 x_catch_errors is in effect. */
9050 x_error_catcher (Display
*display
, XErrorEvent
*event
)
9052 XGetErrorText (display
, event
->error_code
,
9053 x_error_message
->string
,
9054 X_ERROR_MESSAGE_SIZE
);
9057 /* Begin trapping X errors for display DPY. Actually we trap X errors
9058 for all displays, but DPY should be the display you are actually
9061 After calling this function, X protocol errors no longer cause
9062 Emacs to exit; instead, they are recorded in the string
9063 stored in *x_error_message.
9065 Calling x_check_errors signals an Emacs error if an X error has
9066 occurred since the last call to x_catch_errors or x_check_errors.
9068 Calling x_uncatch_errors resumes the normal error handling. */
9071 x_catch_errors (Display
*dpy
)
9073 struct x_error_message_stack
*data
= xmalloc (sizeof *data
);
9075 /* Make sure any errors from previous requests have been dealt with. */
9079 data
->string
[0] = 0;
9080 data
->prev
= x_error_message
;
9081 x_error_message
= data
;
9084 /* Undo the last x_catch_errors call.
9085 DPY should be the display that was passed to x_catch_errors. */
9088 x_uncatch_errors (void)
9090 struct x_error_message_stack
*tmp
;
9094 /* The display may have been closed before this function is called.
9095 Check if it is still open before calling XSync. */
9096 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
9097 XSync (x_error_message
->dpy
, False
);
9099 tmp
= x_error_message
;
9100 x_error_message
= x_error_message
->prev
;
9105 /* If any X protocol errors have arrived since the last call to
9106 x_catch_errors or x_check_errors, signal an Emacs error using
9107 sprintf (a buffer, FORMAT, the x error message text) as the text. */
9110 x_check_errors (Display
*dpy
, const char *format
)
9112 /* Make sure to catch any errors incurred so far. */
9115 if (x_error_message
->string
[0])
9117 char string
[X_ERROR_MESSAGE_SIZE
];
9118 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
9119 x_uncatch_errors ();
9120 error (format
, string
);
9124 /* Nonzero if we had any X protocol errors
9125 since we did x_catch_errors on DPY. */
9128 x_had_errors_p (Display
*dpy
)
9130 /* Make sure to catch any errors incurred so far. */
9133 return x_error_message
->string
[0] != 0;
9136 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
9139 x_clear_errors (Display
*dpy
)
9141 x_error_message
->string
[0] = 0;
9145 /* See comment in unwind_to_catch why calling this is a bad
9146 * idea. --lorentey */
9147 /* Close off all unclosed x_catch_errors calls. */
9150 x_fully_uncatch_errors (void)
9152 while (x_error_message
)
9153 x_uncatch_errors ();
9158 static unsigned int x_wire_count
;
9161 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
9166 /************************************************************************
9168 ************************************************************************/
9170 /* Error message passed to x_connection_closed. */
9172 static char *error_msg
;
9174 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
9175 the text of an error message that lead to the connection loss. */
9178 x_connection_closed (Display
*dpy
, const char *error_message
)
9180 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
9181 Lisp_Object frame
, tail
;
9182 ptrdiff_t idx
= SPECPDL_INDEX ();
9184 error_msg
= alloca (strlen (error_message
) + 1);
9185 strcpy (error_msg
, error_message
);
9187 /* Inhibit redisplay while frames are being deleted. */
9188 specbind (Qinhibit_redisplay
, Qt
);
9192 /* Protect display from being closed when we delete the last
9194 dpyinfo
->reference_count
++;
9195 dpyinfo
->terminal
->reference_count
++;
9198 /* First delete frames whose mini-buffers are on frames
9199 that are on the dead display. */
9200 FOR_EACH_FRAME (tail
, frame
)
9202 Lisp_Object minibuf_frame
;
9204 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
9205 if (FRAME_X_P (XFRAME (frame
))
9206 && FRAME_X_P (XFRAME (minibuf_frame
))
9207 && ! EQ (frame
, minibuf_frame
)
9208 && FRAME_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
9209 delete_frame (frame
, Qnoelisp
);
9212 /* Now delete all remaining frames on the dead display.
9213 We are now sure none of these is used as the mini-buffer
9214 for another frame that we need to delete. */
9215 FOR_EACH_FRAME (tail
, frame
)
9216 if (FRAME_X_P (XFRAME (frame
))
9217 && FRAME_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
9219 /* Set this to t so that delete_frame won't get confused
9220 trying to find a replacement. */
9221 kset_default_minibuffer_frame (FRAME_KBOARD (XFRAME (frame
)), Qt
);
9222 delete_frame (frame
, Qnoelisp
);
9225 /* If DPYINFO is null, this means we didn't open the display in the
9226 first place, so don't try to close it. */
9229 /* We can not call XtCloseDisplay here because it calls XSync.
9230 XSync inside the error handler apparently hangs Emacs. On
9231 current Xt versions, this isn't needed either. */
9233 /* A long-standing GTK bug prevents proper disconnect handling
9234 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Once,
9235 the resulting Glib error message loop filled a user's disk.
9236 To avoid this, kill Emacs unconditionally on disconnect. */
9237 shut_down_emacs (0, Qnil
);
9238 fprintf (stderr
, "%s\n\
9239 When compiled with GTK, Emacs cannot recover from X disconnects.\n\
9240 This is a GTK bug: https://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
9241 For details, see etc/PROBLEMS.\n",
9244 #endif /* USE_GTK */
9246 /* Indicate that this display is dead. */
9247 dpyinfo
->display
= 0;
9249 dpyinfo
->reference_count
--;
9250 dpyinfo
->terminal
->reference_count
--;
9251 if (dpyinfo
->reference_count
!= 0)
9252 /* We have just closed all frames on this display. */
9257 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
9258 Fdelete_terminal (tmp
, Qnoelisp
);
9262 if (terminal_list
== 0)
9264 fprintf (stderr
, "%s\n", error_msg
);
9265 Fkill_emacs (make_number (70));
9269 totally_unblock_input ();
9271 unbind_to (idx
, Qnil
);
9272 clear_waiting_for_input ();
9274 /* Tell GCC not to suggest attribute 'noreturn' for this function. */
9275 IF_LINT (if (! terminal_list
) return; )
9277 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
9278 longjmp), because returning from this function would get us back into
9279 Xlib's code which will directly call `exit'. */
9280 error ("%s", error_msg
);
9283 /* We specifically use it before defining it, so that gcc doesn't inline it,
9284 otherwise gdb doesn't know how to properly put a breakpoint on it. */
9285 static void x_error_quitter (Display
*, XErrorEvent
*);
9287 /* This is the first-level handler for X protocol errors.
9288 It calls x_error_quitter or x_error_catcher. */
9291 x_error_handler (Display
*display
, XErrorEvent
*event
)
9293 #if defined USE_GTK && defined HAVE_GTK3
9294 if ((event
->error_code
== BadMatch
|| event
->error_code
== BadWindow
)
9295 && event
->request_code
== X_SetInputFocus
)
9301 if (x_error_message
)
9302 x_error_catcher (display
, event
);
9304 x_error_quitter (display
, event
);
9308 /* This is the usual handler for X protocol errors.
9309 It kills all frames on the display that we got the error for.
9310 If that was the only one, it prints an error message and kills Emacs. */
9312 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
9314 /* On older GCC versions, just putting x_error_quitter
9315 after x_error_handler prevents inlining into the former. */
9317 static void NO_INLINE
9318 x_error_quitter (Display
*display
, XErrorEvent
*event
)
9320 char buf
[256], buf1
[356];
9322 /* Ignore BadName errors. They can happen because of fonts
9323 or colors that are not defined. */
9325 if (event
->error_code
== BadName
)
9328 /* Note that there is no real way portable across R3/R4 to get the
9329 original error handler. */
9331 XGetErrorText (display
, event
->error_code
, buf
, sizeof (buf
));
9332 sprintf (buf1
, "X protocol error: %s on protocol request %d",
9333 buf
, event
->request_code
);
9334 x_connection_closed (display
, buf1
);
9338 /* This is the handler for X IO errors, always.
9339 It kills all frames on the display that we lost touch with.
9340 If that was the only one, it prints an error message and kills Emacs. */
9343 x_io_error_quitter (Display
*display
)
9347 snprintf (buf
, sizeof buf
, "Connection lost to X server `%s'",
9348 DisplayString (display
));
9349 x_connection_closed (display
, buf
);
9353 /* Changing the font of the frame. */
9355 /* Give frame F the font FONT-OBJECT as its default font. The return
9356 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
9357 frame. If it is negative, generate a new fontset from
9361 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
9363 struct font
*font
= XFONT_OBJECT (font_object
);
9367 fontset
= fontset_from_font (font_object
);
9368 FRAME_FONTSET (f
) = fontset
;
9369 if (FRAME_FONT (f
) == font
)
9370 /* This font is already set in frame F. There's nothing more to
9374 FRAME_FONT (f
) = font
;
9375 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
9376 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
9377 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
9379 #ifndef USE_X_TOOLKIT
9380 FRAME_MENU_BAR_HEIGHT (f
) = FRAME_MENU_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
);
9383 /* Compute character columns occupied by scrollbar.
9385 Don't do things differently for non-toolkit scrollbars
9387 unit
= FRAME_COLUMN_WIDTH (f
);
9388 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
9389 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
9390 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
9392 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
9394 if (FRAME_X_WINDOW (f
) != 0)
9396 /* Don't change the size of a tip frame; there's no point in
9397 doing it because it's done in Fx_show_tip, and it leads to
9398 problems because the tip frame has no widget. */
9399 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
9400 adjust_frame_size (f
, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
9401 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 3,
9407 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
9410 xic_set_xfontset (f
, SSDATA (fontset_ascii (fontset
)));
9419 /***********************************************************************
9421 ***********************************************************************/
9427 /* XIM destroy callback function, which is called whenever the
9428 connection to input method XIM dies. CLIENT_DATA contains a
9429 pointer to the x_display_info structure corresponding to XIM. */
9432 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
9434 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
9435 Lisp_Object frame
, tail
;
9439 /* No need to call XDestroyIC.. */
9440 FOR_EACH_FRAME (tail
, frame
)
9442 struct frame
*f
= XFRAME (frame
);
9443 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
9445 FRAME_XIC (f
) = NULL
;
9446 xic_free_xfontset (f
);
9450 /* No need to call XCloseIM. */
9451 dpyinfo
->xim
= NULL
;
9452 XFree (dpyinfo
->xim_styles
);
9456 #endif /* HAVE_X11R6 */
9458 /* Open the connection to the XIM server on display DPYINFO.
9459 RESOURCE_NAME is the resource name Emacs uses. */
9462 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
9470 XCloseIM (dpyinfo
->xim
);
9471 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
9478 XIMCallback destroy
;
9481 /* Get supported styles and XIM values. */
9482 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
9485 destroy
.callback
= xim_destroy_callback
;
9486 destroy
.client_data
= (XPointer
)dpyinfo
;
9487 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
9493 #endif /* HAVE_XIM */
9494 dpyinfo
->xim
= NULL
;
9498 #ifdef HAVE_X11R6_XIM
9500 /* XIM instantiate callback function, which is called whenever an XIM
9501 server is available. DISPLAY is the display of the XIM.
9502 CLIENT_DATA contains a pointer to an xim_inst_t structure created
9503 when the callback was registered. */
9506 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
9508 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
9509 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
9511 /* We don't support multiple XIM connections. */
9515 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
9517 /* Create XIC for the existing frames on the same display, as long
9518 as they have no XIC. */
9519 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
9521 Lisp_Object tail
, frame
;
9524 FOR_EACH_FRAME (tail
, frame
)
9526 struct frame
*f
= XFRAME (frame
);
9529 && FRAME_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
9530 if (FRAME_XIC (f
) == NULL
)
9532 create_frame_xic (f
);
9533 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
9534 xic_set_statusarea (f
);
9535 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
9537 struct window
*w
= XWINDOW (f
->selected_window
);
9538 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
9547 #endif /* HAVE_X11R6_XIM */
9550 /* Open a connection to the XIM server on display DPYINFO.
9551 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
9552 connection only at the first time. On X11R6, open the connection
9553 in the XIM instantiate callback function. */
9556 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
9558 dpyinfo
->xim
= NULL
;
9562 #ifdef HAVE_X11R6_XIM
9563 struct xim_inst_t
*xim_inst
= xmalloc (sizeof *xim_inst
);
9566 dpyinfo
->xim_callback_data
= xim_inst
;
9567 xim_inst
->dpyinfo
= dpyinfo
;
9568 xim_inst
->resource_name
= xstrdup (resource_name
);
9569 ret
= XRegisterIMInstantiateCallback
9570 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
9571 emacs_class
, xim_instantiate_callback
,
9572 /* This is XPointer in XFree86 but (XPointer *)
9573 on Tru64, at least, hence the configure test. */
9574 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
9575 eassert (ret
== True
);
9576 #else /* not HAVE_X11R6_XIM */
9577 xim_open_dpy (dpyinfo
, resource_name
);
9578 #endif /* not HAVE_X11R6_XIM */
9580 #endif /* HAVE_XIM */
9584 /* Close the connection to the XIM server on display DPYINFO. */
9587 xim_close_dpy (struct x_display_info
*dpyinfo
)
9592 #ifdef HAVE_X11R6_XIM
9593 struct xim_inst_t
*xim_inst
= dpyinfo
->xim_callback_data
;
9595 if (dpyinfo
->display
)
9597 Bool ret
= XUnregisterIMInstantiateCallback
9598 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
9599 emacs_class
, xim_instantiate_callback
,
9600 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
9601 eassert (ret
== True
);
9603 xfree (xim_inst
->resource_name
);
9605 #endif /* HAVE_X11R6_XIM */
9606 if (dpyinfo
->display
)
9607 XCloseIM (dpyinfo
->xim
);
9608 dpyinfo
->xim
= NULL
;
9609 XFree (dpyinfo
->xim_styles
);
9611 #endif /* HAVE_XIM */
9614 #endif /* not HAVE_X11R6_XIM */
9618 /* Calculate the absolute position in frame F
9619 from its current recorded position values and gravity. */
9622 x_calc_absolute_position (struct frame
*f
)
9624 int flags
= f
->size_hint_flags
;
9626 /* We have nothing to do if the current position
9627 is already for the top-left corner. */
9628 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
9631 /* Treat negative positions as relative to the leftmost bottommost
9632 position that fits on the screen. */
9633 if (flags
& XNegative
)
9634 f
->left_pos
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
9635 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
9638 int height
= FRAME_PIXEL_HEIGHT (f
);
9640 #if defined USE_X_TOOLKIT && defined USE_MOTIF
9641 /* Something is fishy here. When using Motif, starting Emacs with
9642 `-g -0-0', the frame appears too low by a few pixels.
9644 This seems to be so because initially, while Emacs is starting,
9645 the column widget's height and the frame's pixel height are
9646 different. The column widget's height is the right one. In
9647 later invocations, when Emacs is up, the frame's pixel height
9650 It's not obvious where the initial small difference comes from.
9651 2000-12-01, gerd. */
9653 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
9656 if (flags
& YNegative
)
9657 f
->top_pos
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
9658 - height
+ f
->top_pos
;
9661 /* The left_pos and top_pos
9662 are now relative to the top and left screen edges,
9663 so the flags should correspond. */
9664 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9667 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
9668 to really change the position, and 0 when calling from
9669 x_make_frame_visible (in that case, XOFF and YOFF are the current
9670 position values). It is -1 when calling from x_set_frame_parameters,
9671 which means, do adjust for borders but don't change the gravity. */
9674 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
9676 int modified_top
, modified_left
;
9678 if (change_gravity
> 0)
9682 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9684 f
->size_hint_flags
|= XNegative
;
9686 f
->size_hint_flags
|= YNegative
;
9687 f
->win_gravity
= NorthWestGravity
;
9689 x_calc_absolute_position (f
);
9692 x_wm_set_size_hint (f
, 0, false);
9694 modified_left
= f
->left_pos
;
9695 modified_top
= f
->top_pos
;
9697 if (change_gravity
!= 0 && FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
9699 /* Some WMs (twm, wmaker at least) has an offset that is smaller
9700 than the WM decorations. So we use the calculated offset instead
9701 of the WM decoration sizes here (x/y_pixels_outer_diff). */
9702 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
9703 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
9706 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9707 modified_left
, modified_top
);
9709 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
9710 FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
);
9712 /* change_gravity is non-zero when this function is called from Lisp to
9713 programmatically move a frame. In that case, we call
9714 x_check_expected_move to discover if we have a "Type A" or "Type B"
9715 window manager, and, for a "Type A" window manager, adjust the position
9718 We call x_check_expected_move if a programmatic move occurred, and
9719 either the window manager type (A/B) is unknown or it is Type A but we
9720 need to compute the top/left offset adjustment for this frame. */
9722 if (change_gravity
!= 0
9723 && (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
9724 || (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
9725 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
9726 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
9727 x_check_expected_move (f
, modified_left
, modified_top
);
9732 /* Return true if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
9733 on the root window for frame F contains ATOMNAME.
9734 This is how a WM check shall be done according to the Window Manager
9735 Specification/Extended Window Manager Hints at
9736 http://freedesktop.org/wiki/Specifications/wm-spec. */
9739 wm_supports (struct frame
*f
, Atom want_atom
)
9742 unsigned long actual_size
, bytes_remaining
;
9743 int i
, rc
, actual_format
;
9745 Window wmcheck_window
;
9746 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9747 Window target_window
= dpyinfo
->root_window
;
9748 int max_len
= 65536;
9749 Display
*dpy
= FRAME_X_DISPLAY (f
);
9750 unsigned char *tmp_data
= NULL
;
9751 Atom target_type
= XA_WINDOW
;
9755 x_catch_errors (dpy
);
9756 rc
= XGetWindowProperty (dpy
, target_window
,
9757 dpyinfo
->Xatom_net_supporting_wm_check
,
9758 0, max_len
, False
, target_type
,
9759 &actual_type
, &actual_format
, &actual_size
,
9760 &bytes_remaining
, &tmp_data
);
9762 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
9764 if (tmp_data
) XFree (tmp_data
);
9765 x_uncatch_errors ();
9770 wmcheck_window
= *(Window
*) tmp_data
;
9773 /* Check if window exists. */
9774 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
9776 if (x_had_errors_p (dpy
))
9778 x_uncatch_errors ();
9783 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
9785 /* Window changed, reload atoms */
9786 if (dpyinfo
->net_supported_atoms
!= NULL
)
9787 XFree (dpyinfo
->net_supported_atoms
);
9788 dpyinfo
->net_supported_atoms
= NULL
;
9789 dpyinfo
->nr_net_supported_atoms
= 0;
9790 dpyinfo
->net_supported_window
= 0;
9792 target_type
= XA_ATOM
;
9794 rc
= XGetWindowProperty (dpy
, target_window
,
9795 dpyinfo
->Xatom_net_supported
,
9796 0, max_len
, False
, target_type
,
9797 &actual_type
, &actual_format
, &actual_size
,
9798 &bytes_remaining
, &tmp_data
);
9800 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
9802 if (tmp_data
) XFree (tmp_data
);
9803 x_uncatch_errors ();
9808 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
9809 dpyinfo
->nr_net_supported_atoms
= actual_size
;
9810 dpyinfo
->net_supported_window
= wmcheck_window
;
9815 for (i
= 0; !ret
&& i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
9816 ret
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
9818 x_uncatch_errors ();
9825 set_wm_state (Lisp_Object frame
, bool add
, Atom atom
, Atom value
)
9827 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (XFRAME (frame
));
9829 x_send_client_event (frame
, make_number (0), frame
,
9830 dpyinfo
->Xatom_net_wm_state
,
9832 /* 1 = add, 0 = remove */
9836 (make_fixnum_or_float (atom
),
9838 ? list1 (make_fixnum_or_float (value
))
9843 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
9846 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9848 XSETFRAME (frame
, f
);
9850 set_wm_state (frame
, !NILP (new_value
),
9851 dpyinfo
->Xatom_net_wm_state_sticky
, None
);
9854 /* Return the current _NET_WM_STATE.
9855 SIZE_STATE is set to one of the FULLSCREEN_* values.
9856 Set *STICKY to the sticky state.
9858 Return true iff we are not hidden. */
9861 get_current_wm_state (struct frame
*f
,
9867 unsigned long actual_size
, bytes_remaining
;
9868 int i
, rc
, actual_format
;
9869 bool is_hidden
= false;
9870 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9871 long max_len
= 65536;
9872 Display
*dpy
= FRAME_X_DISPLAY (f
);
9873 unsigned char *tmp_data
= NULL
;
9874 Atom target_type
= XA_ATOM
;
9877 *size_state
= FULLSCREEN_NONE
;
9880 x_catch_errors (dpy
);
9881 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
9882 0, max_len
, False
, target_type
,
9883 &actual_type
, &actual_format
, &actual_size
,
9884 &bytes_remaining
, &tmp_data
);
9886 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
9888 if (tmp_data
) XFree (tmp_data
);
9889 x_uncatch_errors ();
9891 return !FRAME_ICONIFIED_P (f
);
9894 x_uncatch_errors ();
9896 for (i
= 0; i
< actual_size
; ++i
)
9898 Atom a
= ((Atom
*)tmp_data
)[i
];
9899 if (a
== dpyinfo
->Xatom_net_wm_state_hidden
)
9901 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
9903 if (*size_state
== FULLSCREEN_HEIGHT
)
9904 *size_state
= FULLSCREEN_MAXIMIZED
;
9906 *size_state
= FULLSCREEN_WIDTH
;
9908 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
9910 if (*size_state
== FULLSCREEN_WIDTH
)
9911 *size_state
= FULLSCREEN_MAXIMIZED
;
9913 *size_state
= FULLSCREEN_HEIGHT
;
9915 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen
)
9916 *size_state
= FULLSCREEN_BOTH
;
9917 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
9921 if (tmp_data
) XFree (tmp_data
);
9926 /* Do fullscreen as specified in extended window manager hints */
9929 do_ewmh_fullscreen (struct frame
*f
)
9931 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9932 bool have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state
);
9936 get_current_wm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
9938 /* Some window managers don't say they support _NET_WM_STATE, but they do say
9939 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
9941 have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state_fullscreen
);
9943 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
9947 XSETFRAME (frame
, f
);
9949 /* Keep number of calls to set_wm_state as low as possible.
9950 Some window managers, or possible Gtk+, hangs when too many
9951 are sent at once. */
9952 switch (f
->want_fullscreen
)
9954 case FULLSCREEN_BOTH
:
9955 if (cur
!= FULLSCREEN_BOTH
)
9956 set_wm_state (frame
, true, dpyinfo
->Xatom_net_wm_state_fullscreen
,
9959 case FULLSCREEN_WIDTH
:
9960 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_MAXIMIZED
)
9962 set_wm_state (frame
, false,
9963 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
9964 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9965 set_wm_state (frame
, true,
9966 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
9970 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
9971 || cur
== FULLSCREEN_MAXIMIZED
)
9972 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
9973 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9974 if (cur
!= FULLSCREEN_MAXIMIZED
|| x_frame_normalize_before_maximize
)
9975 set_wm_state (frame
, true,
9976 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
9979 case FULLSCREEN_HEIGHT
:
9980 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_MAXIMIZED
)
9982 set_wm_state (frame
, false,
9983 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
9984 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9985 set_wm_state (frame
, true,
9986 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
9990 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
9991 || cur
== FULLSCREEN_MAXIMIZED
)
9992 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
9993 dpyinfo
->Xatom_net_wm_state_maximized_horz
);
9994 if (cur
!= FULLSCREEN_MAXIMIZED
|| x_frame_normalize_before_maximize
)
9995 set_wm_state (frame
, true,
9996 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
9999 case FULLSCREEN_MAXIMIZED
:
10000 if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_BOTH
)
10002 set_wm_state (frame
, false,
10003 dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
10004 set_wm_state (frame
, true,
10005 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10006 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10008 else if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_WIDTH
)
10010 set_wm_state (frame
, false,
10011 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10012 set_wm_state (frame
, true,
10013 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10014 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10016 else if (x_frame_normalize_before_maximize
&& cur
== FULLSCREEN_HEIGHT
)
10018 set_wm_state (frame
, false,
10019 dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
10020 set_wm_state (frame
, true,
10021 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10022 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10026 if (cur
== FULLSCREEN_BOTH
)
10027 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10029 else if (cur
== FULLSCREEN_HEIGHT
)
10030 set_wm_state (frame
, true,
10031 dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
10032 else if (cur
== FULLSCREEN_WIDTH
)
10033 set_wm_state (frame
, true, None
,
10034 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10036 set_wm_state (frame
, true,
10037 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10038 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10041 case FULLSCREEN_NONE
:
10042 if (cur
== FULLSCREEN_BOTH
)
10043 set_wm_state (frame
, false, dpyinfo
->Xatom_net_wm_state_fullscreen
,
10046 set_wm_state (frame
, false,
10047 dpyinfo
->Xatom_net_wm_state_maximized_horz
,
10048 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
10051 f
->want_fullscreen
= FULLSCREEN_NONE
;
10055 return have_net_atom
;
10059 XTfullscreen_hook (struct frame
*f
)
10061 if (FRAME_VISIBLE_P (f
))
10064 x_check_fullscreen (f
);
10072 x_handle_net_wm_state (struct frame
*f
, const XPropertyEvent
*event
)
10074 int value
= FULLSCREEN_NONE
;
10076 bool sticky
= false;
10077 bool not_hidden
= get_current_wm_state (f
, event
->window
, &value
, &sticky
);
10082 case FULLSCREEN_WIDTH
:
10085 case FULLSCREEN_HEIGHT
:
10086 lval
= Qfullheight
;
10088 case FULLSCREEN_BOTH
:
10091 case FULLSCREEN_MAXIMIZED
:
10096 frame_size_history_add
10097 (f
, Qx_handle_net_wm_state
, 0, 0,
10098 list2 (get_frame_param (f
, Qfullscreen
), lval
));
10100 store_frame_param (f
, Qfullscreen
, lval
);
10101 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
10106 /* Check if we need to resize the frame due to a fullscreen request.
10107 If so needed, resize the frame. */
10109 x_check_fullscreen (struct frame
*f
)
10111 if (do_ewmh_fullscreen (f
))
10114 if (f
->output_data
.x
->parent_desc
!= FRAME_DISPLAY_INFO (f
)->root_window
)
10115 return; /* Only fullscreen without WM or with EWM hints (above). */
10117 /* Setting fullscreen to nil doesn't do anything. We could save the
10118 last non-fullscreen size and restore it, but it seems like a
10119 lot of work for this unusual case (no window manager running). */
10121 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
10123 int width
= FRAME_PIXEL_WIDTH (f
), height
= FRAME_PIXEL_HEIGHT (f
);
10124 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10126 switch (f
->want_fullscreen
)
10128 /* No difference between these two when there is no WM */
10129 case FULLSCREEN_BOTH
:
10130 case FULLSCREEN_MAXIMIZED
:
10131 width
= x_display_pixel_width (dpyinfo
);
10132 height
= x_display_pixel_height (dpyinfo
);
10134 case FULLSCREEN_WIDTH
:
10135 width
= x_display_pixel_width (dpyinfo
);
10136 height
= height
+ FRAME_MENUBAR_HEIGHT (f
);
10138 case FULLSCREEN_HEIGHT
:
10139 height
= x_display_pixel_height (dpyinfo
);
10142 frame_size_history_add
10143 (f
, Qx_check_fullscreen
, width
, height
, Qnil
);
10145 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10148 if (FRAME_VISIBLE_P (f
))
10149 x_wait_for_event (f
, ConfigureNotify
);
10152 change_frame_size (f
, width
, height
- FRAME_MENUBAR_HEIGHT (f
),
10153 false, true, false, true);
10159 /* This function is called by x_set_offset to determine whether the window
10160 manager interfered with the positioning of the frame. Type A window
10161 managers position the surrounding window manager decorations a small
10162 amount above and left of the user-supplied position. Type B window
10163 managers position the surrounding window manager decorations at the
10164 user-specified position. If we detect a Type A window manager, we
10165 compensate by moving the window right and down by the proper amount. */
10168 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
10170 int current_left
= 0, current_top
= 0;
10172 /* x_real_positions returns the left and top offsets of the outermost
10173 window manager window around the frame. */
10175 x_real_positions (f
, ¤t_left
, ¤t_top
);
10177 if (current_left
!= expected_left
|| current_top
!= expected_top
)
10179 /* It's a "Type A" window manager. */
10184 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
10185 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
10186 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
10188 /* Now fix the mispositioned frame's location. */
10190 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
10191 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
10193 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10194 adjusted_left
, adjusted_top
);
10196 x_sync_with_move (f
, expected_left
, expected_top
, false);
10199 /* It's a "Type B" window manager. We don't have to adjust the
10200 frame's position. */
10202 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
10206 /* Wait for XGetGeometry to return up-to-date position information for a
10207 recently-moved frame. Call this immediately after calling XMoveWindow.
10208 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
10209 frame has been moved to, so we use a fuzzy position comparison instead
10210 of an exact comparison. */
10213 x_sync_with_move (struct frame
*f
, int left
, int top
, bool fuzzy
)
10217 while (count
++ < 50)
10219 int current_left
= 0, current_top
= 0;
10221 /* In theory, this call to XSync only needs to happen once, but in
10222 practice, it doesn't seem to work, hence the need for the surrounding
10225 XSync (FRAME_X_DISPLAY (f
), False
);
10226 x_real_positions (f
, ¤t_left
, ¤t_top
);
10230 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
10233 if (eabs (current_left
- left
) <= 10
10234 && eabs (current_top
- top
) <= 40)
10237 else if (current_left
== left
&& current_top
== top
)
10241 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
10242 will then return up-to-date position info. */
10244 wait_reading_process_output (0, 500000000, 0, false, Qnil
, NULL
, 0);
10248 /* Wait for an event on frame F matching EVENTTYPE. */
10250 x_wait_for_event (struct frame
*f
, int eventtype
)
10252 int level
= interrupt_input_blocked
;
10255 struct timespec tmo
, tmo_at
, time_now
;
10256 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
10258 f
->wait_event_type
= eventtype
;
10260 /* Set timeout to 0.1 second. Hopefully not noticeable.
10261 Maybe it should be configurable. */
10262 tmo
= make_timespec (0, 100 * 1000 * 1000);
10263 tmo_at
= timespec_add (current_timespec (), tmo
);
10265 while (f
->wait_event_type
)
10267 pending_signals
= true;
10268 totally_unblock_input ();
10269 /* XTread_socket is called after unblock. */
10271 interrupt_input_blocked
= level
;
10276 time_now
= current_timespec ();
10277 if (timespec_cmp (tmo_at
, time_now
) < 0)
10280 tmo
= timespec_sub (tmo_at
, time_now
);
10281 if (pselect (fd
+ 1, &fds
, NULL
, NULL
, &tmo
, NULL
) == 0)
10282 break; /* Timeout */
10285 f
->wait_event_type
= 0;
10289 /* Change the size of frame F's X window to WIDTH/HEIGHT in the case F
10290 doesn't have a widget. If CHANGE_GRAVITY, change to
10291 top-left-corner window gravity for this size change and subsequent
10292 size changes. Otherwise leave the window gravity unchanged. */
10295 x_set_window_size_1 (struct frame
*f
, bool change_gravity
,
10296 int width
, int height
)
10298 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
10299 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
10300 int old_width
= FRAME_PIXEL_WIDTH (f
);
10301 int old_height
= FRAME_PIXEL_HEIGHT (f
);
10302 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
10304 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
10305 x_wm_set_size_hint (f
, 0, false);
10307 /* When the frame is fullheight and we only want to change the width
10308 or it is fullwidth and we only want to change the height we should
10309 be able to preserve the fullscreen property. However, due to the
10310 fact that we have to send a resize request anyway, the window
10311 manager will abolish it. At least the respective size should
10312 remain unchanged but giving the frame back its normal size will
10314 if (EQ (fullscreen
, Qfullwidth
) && width
== FRAME_TEXT_WIDTH (f
))
10316 frame_size_history_add
10317 (f
, Qxg_frame_set_char_size_1
, width
, height
,
10318 list2 (make_number (old_height
),
10319 make_number (pixelheight
+ FRAME_MENUBAR_HEIGHT (f
))));
10321 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10322 old_width
, pixelheight
+ FRAME_MENUBAR_HEIGHT (f
));
10324 else if (EQ (fullscreen
, Qfullheight
) && height
== FRAME_TEXT_HEIGHT (f
))
10326 frame_size_history_add
10327 (f
, Qxg_frame_set_char_size_2
, width
, height
,
10328 list2 (make_number (old_width
), make_number (pixelwidth
)));
10330 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10331 pixelwidth
, old_height
);
10336 frame_size_history_add
10337 (f
, Qxg_frame_set_char_size_3
, width
, height
,
10338 list2 (make_number (pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
)),
10339 make_number (pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
10340 + FRAME_MENUBAR_HEIGHT (f
))));
10342 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10343 pixelwidth
, pixelheight
+ FRAME_MENUBAR_HEIGHT (f
));
10349 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
10350 receive in the ConfigureNotify event; if we get what we asked
10351 for, then the event won't cause the screen to become garbaged, so
10352 we have to make sure to do it here. */
10353 SET_FRAME_GARBAGED (f
);
10355 /* Now, strictly speaking, we can't be sure that this is accurate,
10356 but the window manager will get around to dealing with the size
10357 change request eventually, and we'll hear how it went when the
10358 ConfigureNotify event gets here.
10360 We could just not bother storing any of this information here,
10361 and let the ConfigureNotify event set everything up, but that
10362 might be kind of confusing to the Lisp code, since size changes
10363 wouldn't be reported in the frame parameters until some random
10364 point in the future when the ConfigureNotify event arrives.
10366 Pass true for DELAY since we can't run Lisp code inside of
10369 /* But the ConfigureNotify may in fact never arrive, and then this is
10370 not right if the frame is visible. Instead wait (with timeout)
10371 for the ConfigureNotify. */
10372 if (FRAME_VISIBLE_P (f
))
10374 x_wait_for_event (f
, ConfigureNotify
);
10376 if (!NILP (fullscreen
))
10377 /* Try to restore fullscreen state. */
10379 store_frame_param (f
, Qfullscreen
, fullscreen
);
10380 x_set_fullscreen (f
, fullscreen
, fullscreen
);
10385 change_frame_size (f
, width
, height
, false, true, false, true);
10391 /* Call this to change the size of frame F's x-window.
10392 If CHANGE_GRAVITY, change to top-left-corner window gravity
10393 for this size change and subsequent size changes.
10394 Otherwise we leave the window gravity unchanged. */
10397 x_set_window_size (struct frame
*f
, bool change_gravity
,
10398 int width
, int height
, bool pixelwise
)
10402 /* The following breaks our calculations. If it's really needed,
10403 think of something else. */
10405 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
10407 int text_width
, text_height
;
10409 /* When the frame is maximized/fullscreen or running under for
10410 example Xmonad, x_set_window_size_1 will be a no-op.
10411 In that case, the right thing to do is extend rows/width to
10412 the current frame size. We do that first if x_set_window_size_1
10413 turns out to not be a no-op (there is no way to know).
10414 The size will be adjusted again if the frame gets a
10415 ConfigureNotify event as a result of x_set_window_size. */
10416 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
10417 #ifdef USE_X_TOOLKIT
10418 /* The menu bar is not part of text lines. The tool bar
10420 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
10422 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, FRAME_PIXEL_WIDTH (f
));
10423 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelh
);
10425 change_frame_size (f
, text_width
, text_height
, false, true, false, true);
10429 /* Pixelize width and height, if necessary. */
10432 width
= width
* FRAME_COLUMN_WIDTH (f
);
10433 height
= height
* FRAME_LINE_HEIGHT (f
);
10437 if (FRAME_GTK_WIDGET (f
))
10438 xg_frame_set_char_size (f
, width
, height
);
10440 x_set_window_size_1 (f
, change_gravity
, width
, height
);
10441 #else /* not USE_GTK */
10442 x_set_window_size_1 (f
, change_gravity
, width
, height
);
10443 x_clear_under_internal_border (f
);
10444 #endif /* not USE_GTK */
10446 /* If cursor was outside the new size, mark it as off. */
10447 mark_window_cursors_off (XWINDOW (f
->root_window
));
10449 /* Clear out any recollection of where the mouse highlighting was,
10450 since it might be in a place that's outside the new frame size.
10451 Actually checking whether it is outside is a pain in the neck,
10452 so don't try--just let the highlighting be done afresh with new size. */
10453 cancel_mouse_face (f
);
10457 do_pending_window_change (false);
10460 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
10463 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
10467 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
10468 0, 0, 0, 0, pix_x
, pix_y
);
10472 /* Raise frame F. */
10475 x_raise_frame (struct frame
*f
)
10478 if (FRAME_VISIBLE_P (f
))
10479 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
10480 XFlush (FRAME_X_DISPLAY (f
));
10484 /* Lower frame F. */
10487 x_lower_frame (struct frame
*f
)
10489 if (FRAME_VISIBLE_P (f
))
10492 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
10493 XFlush (FRAME_X_DISPLAY (f
));
10498 /* Request focus with XEmbed */
10501 xembed_request_focus (struct frame
*f
)
10503 /* See XEmbed Protocol Specification at
10504 http://freedesktop.org/wiki/Specifications/xembed-spec */
10505 if (FRAME_VISIBLE_P (f
))
10506 xembed_send_message (f
, CurrentTime
,
10507 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
10510 /* Activate frame with Extended Window Manager Hints */
10513 x_ewmh_activate_frame (struct frame
*f
)
10515 /* See Window Manager Specification/Extended Window Manager Hints at
10516 http://freedesktop.org/wiki/Specifications/wm-spec */
10518 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10520 if (FRAME_VISIBLE_P (f
) && wm_supports (f
, dpyinfo
->Xatom_net_active_window
))
10523 XSETFRAME (frame
, f
);
10524 x_send_client_event (frame
, make_number (0), frame
,
10525 dpyinfo
->Xatom_net_active_window
,
10527 list2i (1, dpyinfo
->last_user_time
));
10532 XTframe_raise_lower (struct frame
*f
, bool raise_flag
)
10540 /* XEmbed implementation. */
10542 #if defined USE_X_TOOLKIT || ! defined USE_GTK
10544 /* XEmbed implementation. */
10546 #define XEMBED_VERSION 0
10549 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
10551 unsigned long data
[2];
10552 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10554 data
[0] = XEMBED_VERSION
;
10557 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10558 dpyinfo
->Xatom_XEMBED_INFO
, dpyinfo
->Xatom_XEMBED_INFO
,
10559 32, PropModeReplace
, (unsigned char *) data
, 2);
10561 #endif /* defined USE_X_TOOLKIT || ! defined USE_GTK */
10564 xembed_send_message (struct frame
*f
, Time t
, enum xembed_message msg
,
10565 long int detail
, long int data1
, long int data2
)
10569 event
.xclient
.type
= ClientMessage
;
10570 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
10571 event
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_XEMBED
;
10572 event
.xclient
.format
= 32;
10573 event
.xclient
.data
.l
[0] = t
;
10574 event
.xclient
.data
.l
[1] = msg
;
10575 event
.xclient
.data
.l
[2] = detail
;
10576 event
.xclient
.data
.l
[3] = data1
;
10577 event
.xclient
.data
.l
[4] = data2
;
10579 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
10580 False
, NoEventMask
, &event
);
10581 XSync (FRAME_X_DISPLAY (f
), False
);
10584 /* Change of visibility. */
10586 /* This tries to wait until the frame is really visible.
10587 However, if the window manager asks the user where to position
10588 the frame, this will return before the user finishes doing that.
10589 The frame will not actually be visible at that time,
10590 but it will become visible later when the window manager
10591 finishes with it. */
10594 x_make_frame_visible (struct frame
*f
)
10596 int original_top
, original_left
;
10601 x_set_bitmap_icon (f
);
10603 if (! FRAME_VISIBLE_P (f
))
10605 /* We test FRAME_GARBAGED_P here to make sure we don't
10606 call x_set_offset a second time
10607 if we get to x_make_frame_visible a second time
10608 before the window gets really visible. */
10609 if (! FRAME_ICONIFIED_P (f
)
10610 && ! FRAME_X_EMBEDDED_P (f
)
10611 && ! f
->output_data
.x
->asked_for_visible
)
10612 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
10614 f
->output_data
.x
->asked_for_visible
= true;
10616 if (! EQ (Vx_no_window_manager
, Qt
))
10617 x_wm_set_window_state (f
, NormalState
);
10618 #ifdef USE_X_TOOLKIT
10619 if (FRAME_X_EMBEDDED_P (f
))
10620 xembed_set_info (f
, XEMBED_MAPPED
);
10623 /* This was XtPopup, but that did nothing for an iconified frame. */
10624 XtMapWidget (f
->output_data
.x
->widget
);
10626 #else /* not USE_X_TOOLKIT */
10628 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
10629 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
10631 if (FRAME_X_EMBEDDED_P (f
))
10632 xembed_set_info (f
, XEMBED_MAPPED
);
10634 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10635 #endif /* not USE_GTK */
10636 #endif /* not USE_X_TOOLKIT */
10639 XFlush (FRAME_X_DISPLAY (f
));
10641 /* Synchronize to ensure Emacs knows the frame is visible
10642 before we do anything else. We do this loop with input not blocked
10643 so that incoming events are handled. */
10646 /* This must be before UNBLOCK_INPUT
10647 since events that arrive in response to the actions above
10648 will set it when they are handled. */
10649 bool previously_visible
= f
->output_data
.x
->has_been_visible
;
10651 original_left
= f
->left_pos
;
10652 original_top
= f
->top_pos
;
10654 /* This must come after we set COUNT. */
10657 /* We unblock here so that arriving X events are processed. */
10659 /* Now move the window back to where it was "supposed to be".
10660 But don't do it if the gravity is negative.
10661 When the gravity is negative, this uses a position
10662 that is 3 pixels too low. Perhaps that's really the border width.
10664 Don't do this if the window has never been visible before,
10665 because the window manager may choose the position
10666 and we don't want to override it. */
10668 if (! FRAME_VISIBLE_P (f
)
10669 && ! FRAME_ICONIFIED_P (f
)
10670 && ! FRAME_X_EMBEDDED_P (f
)
10671 && f
->win_gravity
== NorthWestGravity
10672 && previously_visible
)
10676 unsigned int width
, height
, border
, depth
;
10680 /* On some window managers (such as FVWM) moving an existing
10681 window, even to the same place, causes the window manager
10682 to introduce an offset. This can cause the window to move
10683 to an unexpected location. Check the geometry (a little
10684 slow here) and then verify that the window is in the right
10685 place. If the window is not in the right place, move it
10686 there, and take the potential window manager hit. */
10687 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10688 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
10690 if (original_left
!= x
|| original_top
!= y
)
10691 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
10692 original_left
, original_top
);
10697 XSETFRAME (frame
, f
);
10699 /* Process X events until a MapNotify event has been seen. */
10700 while (!FRAME_VISIBLE_P (f
))
10702 /* Force processing of queued events. */
10705 /* If on another desktop, the deiconify/map may be ignored and the
10706 frame never becomes visible. XMonad does this.
10707 Prevent an endless loop. */
10708 if (FRAME_ICONIFIED_P (f
) && ++tries
> 100)
10711 /* This hack is still in use at least for Cygwin. See
10712 http://lists.gnu.org/archive/html/emacs-devel/2013-12/msg00351.html.
10714 Machines that do polling rather than SIGIO have been
10715 observed to go into a busy-wait here. So we'll fake an
10716 alarm signal to let the handler know that there's something
10717 to be read. We used to raise a real alarm, but it seems
10718 that the handler isn't always enabled here. This is
10720 if (input_polling_used ())
10722 /* It could be confusing if a real alarm arrives while
10723 processing the fake one. Turn it off and let the
10724 handler reset it. */
10725 int old_poll_suppress_count
= poll_suppress_count
;
10726 poll_suppress_count
= 1;
10727 poll_for_input_1 ();
10728 poll_suppress_count
= old_poll_suppress_count
;
10731 if (XPending (FRAME_X_DISPLAY (f
)))
10734 XNextEvent (FRAME_X_DISPLAY (f
), &xev
);
10735 x_dispatch_event (&xev
, FRAME_X_DISPLAY (f
));
10741 /* Change from mapped state to withdrawn state. */
10743 /* Make the frame visible (mapped and not iconified). */
10746 x_make_frame_invisible (struct frame
*f
)
10750 /* Use the frame's outermost window, not the one we normally draw on. */
10751 window
= FRAME_OUTER_WINDOW (f
);
10753 /* Don't keep the highlight on an invisible frame. */
10754 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
10755 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
10759 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
10760 that the current position of the window is user-specified, rather than
10761 program-specified, so that when the window is mapped again, it will be
10762 placed at the same location, without forcing the user to position it
10763 by hand again (they have already done that once for this window.) */
10764 x_wm_set_size_hint (f
, 0, true);
10767 if (FRAME_GTK_OUTER_WIDGET (f
))
10768 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
10771 if (FRAME_X_EMBEDDED_P (f
))
10772 xembed_set_info (f
, 0);
10777 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
10778 DefaultScreen (FRAME_X_DISPLAY (f
))))
10781 error ("Can't notify window manager of window withdrawal");
10785 /* We can't distinguish this from iconification
10786 just by the event that we get from the server.
10787 So we can't win using the usual strategy of letting
10788 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
10789 and synchronize with the server to make sure we agree. */
10790 SET_FRAME_VISIBLE (f
, 0);
10791 SET_FRAME_ICONIFIED (f
, false);
10798 /* Change window state from mapped to iconified. */
10801 x_iconify_frame (struct frame
*f
)
10803 #ifdef USE_X_TOOLKIT
10807 /* Don't keep the highlight on an invisible frame. */
10808 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
10809 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
10811 if (FRAME_ICONIFIED_P (f
))
10816 x_set_bitmap_icon (f
);
10818 #if defined (USE_GTK)
10819 if (FRAME_GTK_OUTER_WIDGET (f
))
10821 if (! FRAME_VISIBLE_P (f
))
10822 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
10824 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
10825 SET_FRAME_VISIBLE (f
, 0);
10826 SET_FRAME_ICONIFIED (f
, true);
10832 #ifdef USE_X_TOOLKIT
10834 if (! FRAME_VISIBLE_P (f
))
10836 if (! EQ (Vx_no_window_manager
, Qt
))
10837 x_wm_set_window_state (f
, IconicState
);
10838 /* This was XtPopup, but that did nothing for an iconified frame. */
10839 XtMapWidget (f
->output_data
.x
->widget
);
10840 /* The server won't give us any event to indicate
10841 that an invisible frame was changed to an icon,
10842 so we have to record it here. */
10843 SET_FRAME_VISIBLE (f
, 0);
10844 SET_FRAME_ICONIFIED (f
, true);
10849 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
10850 XtWindow (f
->output_data
.x
->widget
),
10851 DefaultScreen (FRAME_X_DISPLAY (f
)));
10855 error ("Can't notify window manager of iconification");
10857 SET_FRAME_ICONIFIED (f
, true);
10858 SET_FRAME_VISIBLE (f
, 0);
10861 XFlush (FRAME_X_DISPLAY (f
));
10863 #else /* not USE_X_TOOLKIT */
10865 /* Make sure the X server knows where the window should be positioned,
10866 in case the user deiconifies with the window manager. */
10867 if (! FRAME_VISIBLE_P (f
)
10868 && ! FRAME_ICONIFIED_P (f
)
10869 && ! FRAME_X_EMBEDDED_P (f
))
10870 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
10872 /* Since we don't know which revision of X we're running, we'll use both
10873 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
10875 /* X11R4: send a ClientMessage to the window manager using the
10876 WM_CHANGE_STATE type. */
10880 msg
.xclient
.window
= FRAME_X_WINDOW (f
);
10881 msg
.xclient
.type
= ClientMessage
;
10882 msg
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
10883 msg
.xclient
.format
= 32;
10884 msg
.xclient
.data
.l
[0] = IconicState
;
10886 if (! XSendEvent (FRAME_X_DISPLAY (f
),
10887 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
10889 SubstructureRedirectMask
| SubstructureNotifyMask
,
10893 error ("Can't notify window manager of iconification");
10897 /* X11R3: set the initial_state field of the window manager hints to
10899 x_wm_set_window_state (f
, IconicState
);
10901 if (!FRAME_VISIBLE_P (f
))
10903 /* If the frame was withdrawn, before, we must map it. */
10904 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10907 SET_FRAME_ICONIFIED (f
, true);
10908 SET_FRAME_VISIBLE (f
, 0);
10910 XFlush (FRAME_X_DISPLAY (f
));
10912 #endif /* not USE_X_TOOLKIT */
10916 /* Free X resources of frame F. */
10919 x_free_frame_resources (struct frame
*f
)
10921 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10922 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
10923 #ifdef USE_X_TOOLKIT
10925 struct scroll_bar
*b
;
10930 /* If a display connection is dead, don't try sending more
10931 commands to the X server. */
10932 if (dpyinfo
->display
)
10934 /* Always exit with visible pointer to avoid weird issue
10935 with Xfixes (Bug#17609). */
10936 if (f
->pointer_invisible
)
10937 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, 0);
10939 /* We must free faces before destroying windows because some
10940 font-driver (e.g. xft) access a window while finishing a
10942 free_frame_faces (f
);
10944 if (f
->output_data
.x
->icon_desc
)
10945 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
10947 #ifdef USE_X_TOOLKIT
10948 /* Explicitly destroy the scroll bars of the frame. Without
10949 this, we get "BadDrawable" errors from the toolkit later on,
10950 presumably from expose events generated for the disappearing
10951 toolkit scroll bars. */
10952 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
10954 b
= XSCROLL_BAR (bar
);
10955 x_scroll_bar_remove (b
);
10961 free_frame_xic (f
);
10964 x_prepare_for_xlibdraw (f
);
10965 #ifdef USE_X_TOOLKIT
10966 if (f
->output_data
.x
->widget
)
10968 XtDestroyWidget (f
->output_data
.x
->widget
);
10969 f
->output_data
.x
->widget
= NULL
;
10971 /* Tooltips don't have widgets, only a simple X window, even if
10972 we are using a toolkit. */
10973 else if (FRAME_X_WINDOW (f
))
10974 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10976 free_frame_menubar (f
);
10978 if (f
->shell_position
)
10979 xfree (f
->shell_position
);
10980 #else /* !USE_X_TOOLKIT */
10983 xg_free_frame_widgets (f
);
10984 #endif /* USE_GTK */
10986 if (FRAME_X_WINDOW (f
))
10987 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10988 #endif /* !USE_X_TOOLKIT */
10990 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
10991 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
10992 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
10993 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
10994 unload_color (f
, f
->output_data
.x
->border_pixel
);
10995 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
10997 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
10998 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
10999 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
11000 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
11001 #if defined (USE_LUCID) && defined (USE_TOOLKIT_SCROLL_BARS)
11002 /* Scrollbar shadow colors. */
11003 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
11004 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
11005 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
11006 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
11007 #endif /* USE_LUCID && USE_TOOLKIT_SCROLL_BARS */
11008 if (f
->output_data
.x
->white_relief
.pixel
!= -1)
11009 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
11010 if (f
->output_data
.x
->black_relief
.pixel
!= -1)
11011 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
11015 /* Free extra GCs allocated by x_setup_relief_colors. */
11016 if (f
->output_data
.x
->white_relief
.gc
)
11018 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->white_relief
.gc
);
11019 f
->output_data
.x
->white_relief
.gc
= 0;
11021 if (f
->output_data
.x
->black_relief
.gc
)
11023 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->black_relief
.gc
);
11024 f
->output_data
.x
->black_relief
.gc
= 0;
11027 /* Free cursors. */
11028 if (f
->output_data
.x
->text_cursor
!= 0)
11029 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->text_cursor
);
11030 if (f
->output_data
.x
->nontext_cursor
!= 0)
11031 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->nontext_cursor
);
11032 if (f
->output_data
.x
->modeline_cursor
!= 0)
11033 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->modeline_cursor
);
11034 if (f
->output_data
.x
->hand_cursor
!= 0)
11035 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hand_cursor
);
11036 if (f
->output_data
.x
->hourglass_cursor
!= 0)
11037 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hourglass_cursor
);
11038 if (f
->output_data
.x
->horizontal_drag_cursor
!= 0)
11039 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->horizontal_drag_cursor
);
11040 if (f
->output_data
.x
->vertical_drag_cursor
!= 0)
11041 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->vertical_drag_cursor
);
11043 XFlush (FRAME_X_DISPLAY (f
));
11046 xfree (f
->output_data
.x
->saved_menu_event
);
11047 xfree (f
->output_data
.x
);
11048 f
->output_data
.x
= NULL
;
11050 if (f
== dpyinfo
->x_focus_frame
)
11051 dpyinfo
->x_focus_frame
= 0;
11052 if (f
== dpyinfo
->x_focus_event_frame
)
11053 dpyinfo
->x_focus_event_frame
= 0;
11054 if (f
== dpyinfo
->x_highlight_frame
)
11055 dpyinfo
->x_highlight_frame
= 0;
11056 if (f
== hlinfo
->mouse_face_mouse_frame
)
11057 reset_mouse_highlight (hlinfo
);
11063 /* Destroy the X window of frame F. */
11066 x_destroy_window (struct frame
*f
)
11068 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
11070 /* If a display connection is dead, don't try sending more
11071 commands to the X server. */
11072 if (dpyinfo
->display
!= 0)
11073 x_free_frame_resources (f
);
11075 dpyinfo
->reference_count
--;
11079 /* Setting window manager hints. */
11081 /* Set the normal size hints for the window manager, for frame F.
11082 FLAGS is the flags word to use--or 0 meaning preserve the flags
11083 that the window now has.
11084 If USER_POSITION, set the USPosition
11085 flag (this is useful when FLAGS is 0).
11086 The GTK version is in gtkutils.c. */
11090 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
11092 XSizeHints size_hints
;
11093 Window window
= FRAME_OUTER_WINDOW (f
);
11098 #ifdef USE_X_TOOLKIT
11099 if (f
->output_data
.x
->widget
)
11101 widget_update_wm_size_hints (f
->output_data
.x
->widget
);
11106 /* Setting PMaxSize caused various problems. */
11107 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
11109 size_hints
.x
= f
->left_pos
;
11110 size_hints
.y
= f
->top_pos
;
11112 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
11113 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
11115 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
11116 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
11118 size_hints
.max_width
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
11119 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
11120 size_hints
.max_height
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
11121 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
11123 /* Calculate the base and minimum sizes. */
11125 int base_width
, base_height
;
11126 int min_rows
= 0, min_cols
= 0;
11128 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
11129 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
11131 if (frame_resize_pixelwise
)
11132 /* Needed to prevent a bad protocol error crash when making the
11133 frame size very small. */
11135 min_cols
= 2 * min_cols
;
11136 min_rows
= 2 * min_rows
;
11139 /* The window manager uses the base width hints to calculate the
11140 current number of rows and columns in the frame while
11141 resizing; min_width and min_height aren't useful for this
11142 purpose, since they might not give the dimensions for a
11143 zero-row, zero-column frame.
11145 We use the base_width and base_height members if we have
11146 them; otherwise, we set the min_width and min_height members
11147 to the size for a zero x zero frame. */
11149 size_hints
.flags
|= PBaseSize
;
11150 size_hints
.base_width
= base_width
;
11151 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
11152 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
11153 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
11156 /* If we don't need the old flags, we don't need the old hint at all. */
11159 size_hints
.flags
|= flags
;
11164 XSizeHints hints
; /* Sometimes I hate X Windows... */
11165 long supplied_return
;
11168 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
11172 size_hints
.flags
|= flags
;
11177 if (hints
.flags
& PSize
)
11178 size_hints
.flags
|= PSize
;
11179 if (hints
.flags
& PPosition
)
11180 size_hints
.flags
|= PPosition
;
11181 if (hints
.flags
& USPosition
)
11182 size_hints
.flags
|= USPosition
;
11183 if (hints
.flags
& USSize
)
11184 size_hints
.flags
|= USSize
;
11191 size_hints
.win_gravity
= f
->win_gravity
;
11192 size_hints
.flags
|= PWinGravity
;
11196 size_hints
.flags
&= ~ PPosition
;
11197 size_hints
.flags
|= USPosition
;
11199 #endif /* PWinGravity */
11201 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
11203 #endif /* not USE_GTK */
11205 /* Used for IconicState or NormalState */
11208 x_wm_set_window_state (struct frame
*f
, int state
)
11210 #ifdef USE_X_TOOLKIT
11213 XtSetArg (al
[0], XtNinitialState
, state
);
11214 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11215 #else /* not USE_X_TOOLKIT */
11216 Window window
= FRAME_X_WINDOW (f
);
11218 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
11219 f
->output_data
.x
->wm_hints
.initial_state
= state
;
11221 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11222 #endif /* not USE_X_TOOLKIT */
11226 x_wm_set_icon_pixmap (struct frame
*f
, ptrdiff_t pixmap_id
)
11228 Pixmap icon_pixmap
, icon_mask
;
11230 #if !defined USE_X_TOOLKIT && !defined USE_GTK
11231 Window window
= FRAME_OUTER_WINDOW (f
);
11236 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
11237 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
11238 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
11239 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
11243 /* It seems there is no way to turn off use of an icon
11251 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
11255 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
11259 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
11260 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11261 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
11262 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
11265 #else /* not USE_X_TOOLKIT && not USE_GTK */
11267 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
11268 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11270 #endif /* not USE_X_TOOLKIT && not USE_GTK */
11274 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
11276 Window window
= FRAME_OUTER_WINDOW (f
);
11278 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
11279 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
11280 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
11282 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
11286 /***********************************************************************
11288 ***********************************************************************/
11292 /* Check that FONT is valid on frame F. It is if it can be found in F's
11296 x_check_font (struct frame
*f
, struct font
*font
)
11298 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
11299 if (font
->driver
->check
)
11300 eassert (font
->driver
->check (f
, font
) == 0);
11303 #endif /* GLYPH_DEBUG */
11306 /***********************************************************************
11308 ***********************************************************************/
11310 #ifdef USE_X_TOOLKIT
11311 static XrmOptionDescRec emacs_options
[] = {
11312 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
11313 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
11315 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
11316 XrmoptionSepArg
, NULL
},
11317 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
11319 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11320 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11321 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
11322 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
11323 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
11324 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
11325 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
11328 /* Whether atimer for Xt timeouts is activated or not. */
11330 static bool x_timeout_atimer_activated_flag
;
11332 #endif /* USE_X_TOOLKIT */
11334 static int x_initialized
;
11336 /* Test whether two display-name strings agree up to the dot that separates
11337 the screen number from the server number. */
11339 same_x_server (const char *name1
, const char *name2
)
11341 bool seen_colon
= false;
11342 Lisp_Object sysname
= Fsystem_name ();
11343 const char *system_name
= SSDATA (sysname
);
11344 ptrdiff_t system_name_length
= SBYTES (sysname
);
11345 ptrdiff_t length_until_period
= 0;
11347 while (system_name
[length_until_period
] != 0
11348 && system_name
[length_until_period
] != '.')
11349 length_until_period
++;
11351 /* Treat `unix' like an empty host name. */
11352 if (! strncmp (name1
, "unix:", 5))
11354 if (! strncmp (name2
, "unix:", 5))
11356 /* Treat this host's name like an empty host name. */
11357 if (! strncmp (name1
, system_name
, system_name_length
)
11358 && name1
[system_name_length
] == ':')
11359 name1
+= system_name_length
;
11360 if (! strncmp (name2
, system_name
, system_name_length
)
11361 && name2
[system_name_length
] == ':')
11362 name2
+= system_name_length
;
11363 /* Treat this host's domainless name like an empty host name. */
11364 if (! strncmp (name1
, system_name
, length_until_period
)
11365 && name1
[length_until_period
] == ':')
11366 name1
+= length_until_period
;
11367 if (! strncmp (name2
, system_name
, length_until_period
)
11368 && name2
[length_until_period
] == ':')
11369 name2
+= length_until_period
;
11371 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
11375 if (seen_colon
&& *name1
== '.')
11379 && (*name1
== '.' || *name1
== '\0')
11380 && (*name2
== '.' || *name2
== '\0'));
11383 /* Count number of set bits in mask and number of bits to shift to
11384 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
11387 get_bits_and_offset (unsigned long mask
, int *bits
, int *offset
)
11392 while (!(mask
& 1))
11408 /* Return true iff display DISPLAY is available for use.
11409 But don't permanently open it, just test its availability. */
11412 x_display_ok (const char *display
)
11414 Display
*dpy
= XOpenDisplay (display
);
11417 XCloseDisplay (dpy
);
11423 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
11424 const gchar
*msg
, gpointer user_data
)
11426 if (!strstr (msg
, "g_set_prgname"))
11427 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, msg
);
11431 /* Create invisible cursor on X display referred by DPYINFO. */
11434 make_invisible_cursor (struct x_display_info
*dpyinfo
)
11436 Display
*dpy
= dpyinfo
->display
;
11437 static char const no_data
[] = { 0 };
11442 x_catch_errors (dpy
);
11443 pix
= XCreateBitmapFromData (dpy
, dpyinfo
->root_window
, no_data
, 1, 1);
11444 if (! x_had_errors_p (dpy
) && pix
!= None
)
11448 col
.red
= col
.green
= col
.blue
= 0;
11449 col
.flags
= DoRed
| DoGreen
| DoBlue
;
11450 pixc
= XCreatePixmapCursor (dpy
, pix
, pix
, &col
, &col
, 0, 0);
11451 if (! x_had_errors_p (dpy
) && pixc
!= None
)
11453 XFreePixmap (dpy
, pix
);
11456 x_uncatch_errors ();
11461 /* True if DPY supports Xfixes extension >= 4. */
11464 x_probe_xfixes_extension (Display
*dpy
)
11468 return XFixesQueryVersion (dpy
, &major
, &minor
) && major
>= 4;
11471 #endif /* HAVE_XFIXES */
11474 /* Toggle mouse pointer visibility on frame F by using Xfixes functions. */
11477 xfixes_toggle_visible_pointer (struct frame
*f
, bool invisible
)
11481 XFixesHideCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11483 XFixesShowCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
11484 f
->pointer_invisible
= invisible
;
11487 #endif /* HAVE_XFIXES */
11490 /* Toggle mouse pointer visibility on frame F by using invisible cursor. */
11493 x_toggle_visible_pointer (struct frame
*f
, bool invisible
)
11495 eassert (FRAME_DISPLAY_INFO (f
)->invisible_cursor
!= 0);
11497 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11498 FRAME_DISPLAY_INFO (f
)->invisible_cursor
);
11500 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
11501 f
->output_data
.x
->current_cursor
);
11502 f
->pointer_invisible
= invisible
;
11505 /* Setup pointer blanking, prefer Xfixes if available. */
11508 x_setup_pointer_blanking (struct x_display_info
*dpyinfo
)
11510 /* FIXME: the brave tester should set EMACS_XFIXES because we're suspecting
11511 X server bug, see http://debbugs.gnu.org/cgi/bugreport.cgi?bug=17609. */
11512 if (egetenv ("EMACS_XFIXES") && x_probe_xfixes_extension (dpyinfo
->display
))
11513 dpyinfo
->toggle_visible_pointer
= xfixes_toggle_visible_pointer
;
11516 dpyinfo
->toggle_visible_pointer
= x_toggle_visible_pointer
;
11517 dpyinfo
->invisible_cursor
= make_invisible_cursor (dpyinfo
);
11521 /* Current X display connection identifier. Incremented for each next
11522 connection established. */
11523 static unsigned x_display_id
;
11525 /* Open a connection to X display DISPLAY_NAME, and return
11526 the structure that describes the open display.
11527 If we cannot contact the display, return null. */
11529 struct x_display_info
*
11530 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
11533 struct terminal
*terminal
;
11534 struct x_display_info
*dpyinfo
;
11540 if (!x_initialized
)
11546 if (! x_display_ok (SSDATA (display_name
)))
11547 error ("Display %s can't be opened", SSDATA (display_name
));
11551 #define NUM_ARGV 10
11553 char *argv
[NUM_ARGV
];
11554 char **argv2
= argv
;
11557 if (x_initialized
++ > 1)
11559 xg_display_open (SSDATA (display_name
), &dpy
);
11563 static char display_opt
[] = "--display";
11564 static char name_opt
[] = "--name";
11566 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
11570 argv
[argc
++] = initial_argv
[0];
11572 if (! NILP (display_name
))
11574 argv
[argc
++] = display_opt
;
11575 argv
[argc
++] = SSDATA (display_name
);
11578 argv
[argc
++] = name_opt
;
11579 argv
[argc
++] = resource_name
;
11581 XSetLocaleModifiers ("");
11583 /* Work around GLib bug that outputs a faulty warning. See
11584 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
11585 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
11586 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
11588 /* NULL window -> events for all windows go to our function.
11589 Call before gtk_init so Gtk+ event filters comes after our. */
11590 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
11592 /* gtk_init does set_locale. Fix locale before and after. */
11594 gtk_init (&argc
, &argv2
);
11597 g_log_remove_handler ("GLib", id
);
11601 dpy
= DEFAULT_GDK_DISPLAY ();
11603 #if ! GTK_CHECK_VERSION (2, 90, 0)
11604 /* Load our own gtkrc if it exists. */
11606 const char *file
= "~/.emacs.d/gtkrc";
11607 Lisp_Object s
, abs_file
;
11609 s
= build_string (file
);
11610 abs_file
= Fexpand_file_name (s
, Qnil
);
11612 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
11613 gtk_rc_parse (SSDATA (abs_file
));
11617 XSetErrorHandler (x_error_handler
);
11618 XSetIOErrorHandler (x_io_error_quitter
);
11621 #else /* not USE_GTK */
11622 #ifdef USE_X_TOOLKIT
11623 /* weiner@footloose.sps.mot.com reports that this causes
11625 X protocol error: BadAtom (invalid Atom parameter)
11626 on protocol request 18skiloaf.
11627 So let's not use it until R6. */
11628 #ifdef HAVE_X11XTR6
11629 XtSetLanguageProc (NULL
, NULL
, NULL
);
11640 argv
[argc
++] = "-xrm";
11641 argv
[argc
++] = xrm_option
;
11643 turn_on_atimers (false);
11644 dpy
= XtOpenDisplay (Xt_app_con
, SSDATA (display_name
),
11645 resource_name
, EMACS_CLASS
,
11646 emacs_options
, XtNumber (emacs_options
),
11648 turn_on_atimers (true);
11650 #ifdef HAVE_X11XTR6
11651 /* I think this is to compensate for XtSetLanguageProc. */
11656 #else /* not USE_X_TOOLKIT */
11657 XSetLocaleModifiers ("");
11658 dpy
= XOpenDisplay (SSDATA (display_name
));
11659 #endif /* not USE_X_TOOLKIT */
11660 #endif /* not USE_GTK*/
11662 /* Detect failure. */
11669 /* We have definitely succeeded. Record the new connection. */
11671 dpyinfo
= xzalloc (sizeof *dpyinfo
);
11672 terminal
= x_create_terminal (dpyinfo
);
11675 struct x_display_info
*share
;
11677 for (share
= x_display_list
; share
; share
= share
->next
)
11678 if (same_x_server (SSDATA (XCAR (share
->name_list_element
)),
11679 SSDATA (display_name
)))
11682 terminal
->kboard
= share
->terminal
->kboard
;
11685 terminal
->kboard
= allocate_kboard (Qx
);
11687 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
11689 char *vendor
= ServerVendor (dpy
);
11691 /* Protect terminal from GC before removing it from the
11692 list of terminals. */
11693 struct gcpro gcpro1
;
11694 Lisp_Object gcpro_term
;
11695 XSETTERMINAL (gcpro_term
, terminal
);
11696 GCPRO1 (gcpro_term
);
11698 /* Temporarily hide the partially initialized terminal. */
11699 terminal_list
= terminal
->next_terminal
;
11701 kset_system_key_alist
11703 call1 (Qvendor_specific_keysyms
,
11704 vendor
? build_string (vendor
) : empty_unibyte_string
));
11706 terminal
->next_terminal
= terminal_list
;
11707 terminal_list
= terminal
;
11711 /* Don't let the initial kboard remain current longer than necessary.
11712 That would cause problems if a file loaded on startup tries to
11713 prompt in the mini-buffer. */
11714 if (current_kboard
== initial_kboard
)
11715 current_kboard
= terminal
->kboard
;
11717 terminal
->kboard
->reference_count
++;
11720 /* Put this display on the chain. */
11721 dpyinfo
->next
= x_display_list
;
11722 x_display_list
= dpyinfo
;
11724 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
11725 dpyinfo
->display
= dpy
;
11726 dpyinfo
->connection
= ConnectionNumber (dpyinfo
->display
);
11728 /* Set the name of the terminal. */
11729 terminal
->name
= xlispstrdup (display_name
);
11732 XSetAfterFunction (x_current_display
, x_trace_wire
);
11735 lim
= min (PTRDIFF_MAX
, SIZE_MAX
) - sizeof "@";
11736 Lisp_Object system_name
= Fsystem_name ();
11737 if (lim
- SBYTES (Vinvocation_name
) < SBYTES (system_name
))
11738 memory_full (SIZE_MAX
);
11739 dpyinfo
->x_id
= ++x_display_id
;
11740 dpyinfo
->x_id_name
= xmalloc (SBYTES (Vinvocation_name
)
11741 + SBYTES (system_name
) + 2);
11742 char *nametail
= lispstpcpy (dpyinfo
->x_id_name
, Vinvocation_name
);
11744 lispstpcpy (nametail
, system_name
);
11746 /* Figure out which modifier bits mean what. */
11747 x_find_modifier_meanings (dpyinfo
);
11749 /* Get the scroll bar cursor. */
11751 /* We must create a GTK cursor, it is required for GTK widgets. */
11752 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
11753 #endif /* USE_GTK */
11755 dpyinfo
->vertical_scroll_bar_cursor
11756 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
11758 dpyinfo
->horizontal_scroll_bar_cursor
11759 = XCreateFontCursor (dpyinfo
->display
, XC_sb_h_double_arrow
);
11761 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
11762 resource_name
, EMACS_CLASS
);
11763 #ifdef HAVE_XRMSETDATABASE
11764 XrmSetDatabase (dpyinfo
->display
, xrdb
);
11766 dpyinfo
->display
->db
= xrdb
;
11768 /* Put the rdb where we can find it in a way that works on
11770 dpyinfo
->xrdb
= xrdb
;
11772 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
11773 DefaultScreen (dpyinfo
->display
));
11774 select_visual (dpyinfo
);
11775 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
11776 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
11777 dpyinfo
->icon_bitmap_id
= -1;
11778 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
11780 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
11782 /* See if we can construct pixel values from RGB values. */
11783 if (dpyinfo
->visual
->class == TrueColor
)
11785 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
11786 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
11787 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
11788 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
11789 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
11790 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
11793 /* See if a private colormap is requested. */
11794 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
11796 if (dpyinfo
->visual
->class == PseudoColor
)
11798 AUTO_STRING (privateColormap
, "privateColormap");
11799 AUTO_STRING (PrivateColormap
, "PrivateColormap");
11801 = display_x_get_resource (dpyinfo
, privateColormap
,
11802 PrivateColormap
, Qnil
, Qnil
);
11803 if (STRINGP (value
)
11804 && (!strcmp (SSDATA (value
), "true")
11805 || !strcmp (SSDATA (value
), "on")))
11806 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
11810 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
11811 dpyinfo
->visual
, AllocNone
);
11815 /* If we are using Xft, the following precautions should be made:
11817 1. Make sure that the Xrender extension is added before the Xft one.
11818 Otherwise, the close-display hook set by Xft is called after the one
11819 for Xrender, and the former tries to re-add the latter. This results
11820 in inconsistency of internal states and leads to X protocol error when
11821 one reconnects to the same X server (Bug#1696).
11823 2. Check dpi value in X resources. It is better we use it as well,
11824 since Xft will use it, as will all Gnome applications. If our real DPI
11825 is smaller or larger than the one Xft uses, our font will look smaller
11826 or larger than other for other applications, even if it is the same
11827 font name (monospace-10 for example). */
11829 int event_base
, error_base
;
11833 XRenderQueryExtension (dpyinfo
->display
, &event_base
, &error_base
);
11835 v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
11836 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
11837 dpyinfo
->resy
= dpyinfo
->resx
= d
;
11841 if (dpyinfo
->resy
< 1)
11843 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
11844 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
11845 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
11846 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
11847 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
11848 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
11849 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
11850 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
11851 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
11855 static const struct
11860 #define ATOM_REFS_INIT(string, member) \
11861 { string, offsetof (struct x_display_info, member) },
11862 ATOM_REFS_INIT ("WM_PROTOCOLS", Xatom_wm_protocols
)
11863 ATOM_REFS_INIT ("WM_TAKE_FOCUS", Xatom_wm_take_focus
)
11864 ATOM_REFS_INIT ("WM_SAVE_YOURSELF", Xatom_wm_save_yourself
)
11865 ATOM_REFS_INIT ("WM_DELETE_WINDOW", Xatom_wm_delete_window
)
11866 ATOM_REFS_INIT ("WM_CHANGE_STATE", Xatom_wm_change_state
)
11867 ATOM_REFS_INIT ("WM_CONFIGURE_DENIED", Xatom_wm_configure_denied
)
11868 ATOM_REFS_INIT ("WM_MOVED", Xatom_wm_window_moved
)
11869 ATOM_REFS_INIT ("WM_CLIENT_LEADER", Xatom_wm_client_leader
)
11870 ATOM_REFS_INIT ("Editres", Xatom_editres
)
11871 ATOM_REFS_INIT ("CLIPBOARD", Xatom_CLIPBOARD
)
11872 ATOM_REFS_INIT ("TIMESTAMP", Xatom_TIMESTAMP
)
11873 ATOM_REFS_INIT ("TEXT", Xatom_TEXT
)
11874 ATOM_REFS_INIT ("COMPOUND_TEXT", Xatom_COMPOUND_TEXT
)
11875 ATOM_REFS_INIT ("UTF8_STRING", Xatom_UTF8_STRING
)
11876 ATOM_REFS_INIT ("DELETE", Xatom_DELETE
)
11877 ATOM_REFS_INIT ("MULTIPLE", Xatom_MULTIPLE
)
11878 ATOM_REFS_INIT ("INCR", Xatom_INCR
)
11879 ATOM_REFS_INIT ("_EMACS_TMP_", Xatom_EMACS_TMP
)
11880 ATOM_REFS_INIT ("TARGETS", Xatom_TARGETS
)
11881 ATOM_REFS_INIT ("NULL", Xatom_NULL
)
11882 ATOM_REFS_INIT ("ATOM", Xatom_ATOM
)
11883 ATOM_REFS_INIT ("ATOM_PAIR", Xatom_ATOM_PAIR
)
11884 ATOM_REFS_INIT ("CLIPBOARD_MANAGER", Xatom_CLIPBOARD_MANAGER
)
11885 ATOM_REFS_INIT ("_XEMBED_INFO", Xatom_XEMBED_INFO
)
11886 /* For properties of font. */
11887 ATOM_REFS_INIT ("PIXEL_SIZE", Xatom_PIXEL_SIZE
)
11888 ATOM_REFS_INIT ("AVERAGE_WIDTH", Xatom_AVERAGE_WIDTH
)
11889 ATOM_REFS_INIT ("_MULE_BASELINE_OFFSET", Xatom_MULE_BASELINE_OFFSET
)
11890 ATOM_REFS_INIT ("_MULE_RELATIVE_COMPOSE", Xatom_MULE_RELATIVE_COMPOSE
)
11891 ATOM_REFS_INIT ("_MULE_DEFAULT_ASCENT", Xatom_MULE_DEFAULT_ASCENT
)
11892 /* Ghostscript support. */
11893 ATOM_REFS_INIT ("DONE", Xatom_DONE
)
11894 ATOM_REFS_INIT ("PAGE", Xatom_PAGE
)
11895 ATOM_REFS_INIT ("SCROLLBAR", Xatom_Scrollbar
)
11896 ATOM_REFS_INIT ("HORIZONTAL_SCROLLBAR", Xatom_Horizontal_Scrollbar
)
11897 ATOM_REFS_INIT ("_XEMBED", Xatom_XEMBED
)
11899 ATOM_REFS_INIT ("_NET_WM_STATE", Xatom_net_wm_state
)
11900 ATOM_REFS_INIT ("_NET_WM_STATE_FULLSCREEN", Xatom_net_wm_state_fullscreen
)
11901 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_HORZ",
11902 Xatom_net_wm_state_maximized_horz
)
11903 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_VERT",
11904 Xatom_net_wm_state_maximized_vert
)
11905 ATOM_REFS_INIT ("_NET_WM_STATE_STICKY", Xatom_net_wm_state_sticky
)
11906 ATOM_REFS_INIT ("_NET_WM_STATE_HIDDEN", Xatom_net_wm_state_hidden
)
11907 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE", Xatom_net_window_type
)
11908 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE_TOOLTIP",
11909 Xatom_net_window_type_tooltip
)
11910 ATOM_REFS_INIT ("_NET_WM_ICON_NAME", Xatom_net_wm_icon_name
)
11911 ATOM_REFS_INIT ("_NET_WM_NAME", Xatom_net_wm_name
)
11912 ATOM_REFS_INIT ("_NET_SUPPORTED", Xatom_net_supported
)
11913 ATOM_REFS_INIT ("_NET_SUPPORTING_WM_CHECK", Xatom_net_supporting_wm_check
)
11914 ATOM_REFS_INIT ("_NET_WM_WINDOW_OPACITY", Xatom_net_wm_window_opacity
)
11915 ATOM_REFS_INIT ("_NET_ACTIVE_WINDOW", Xatom_net_active_window
)
11916 ATOM_REFS_INIT ("_NET_FRAME_EXTENTS", Xatom_net_frame_extents
)
11917 ATOM_REFS_INIT ("_NET_CURRENT_DESKTOP", Xatom_net_current_desktop
)
11918 ATOM_REFS_INIT ("_NET_WORKAREA", Xatom_net_workarea
)
11919 /* Session management */
11920 ATOM_REFS_INIT ("SM_CLIENT_ID", Xatom_SM_CLIENT_ID
)
11921 ATOM_REFS_INIT ("_XSETTINGS_SETTINGS", Xatom_xsettings_prop
)
11922 ATOM_REFS_INIT ("MANAGER", Xatom_xsettings_mgr
)
11926 enum { atom_count
= ARRAYELTS (atom_refs
) };
11927 /* 1 for _XSETTINGS_SN. */
11928 enum { total_atom_count
= 1 + atom_count
};
11929 Atom atoms_return
[total_atom_count
];
11930 char *atom_names
[total_atom_count
];
11931 static char const xsettings_fmt
[] = "_XSETTINGS_S%d";
11932 char xsettings_atom_name
[sizeof xsettings_fmt
- 2
11933 + INT_STRLEN_BOUND (int)];
11935 for (i
= 0; i
< atom_count
; i
++)
11936 atom_names
[i
] = (char *) atom_refs
[i
].name
;
11938 /* Build _XSETTINGS_SN atom name. */
11939 sprintf (xsettings_atom_name
, xsettings_fmt
,
11940 XScreenNumberOfScreen (dpyinfo
->screen
));
11941 atom_names
[i
] = xsettings_atom_name
;
11943 XInternAtoms (dpyinfo
->display
, atom_names
, total_atom_count
,
11944 False
, atoms_return
);
11946 for (i
= 0; i
< atom_count
; i
++)
11947 *(Atom
*) ((char *) dpyinfo
+ atom_refs
[i
].offset
) = atoms_return
[i
];
11949 /* Manually copy last atom. */
11950 dpyinfo
->Xatom_xsettings_sel
= atoms_return
[i
];
11953 dpyinfo
->x_dnd_atoms_size
= 8;
11954 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof *dpyinfo
->x_dnd_atoms
11955 * dpyinfo
->x_dnd_atoms_size
);
11957 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
11958 gray_bits
, gray_width
, gray_height
,
11961 x_setup_pointer_blanking (dpyinfo
);
11964 xim_initialize (dpyinfo
, resource_name
);
11967 xsettings_initialize (dpyinfo
);
11969 /* This is only needed for distinguishing keyboard and process input. */
11970 if (dpyinfo
->connection
!= 0)
11971 add_keyboard_wait_descriptor (dpyinfo
->connection
);
11974 fcntl (dpyinfo
->connection
, F_SETOWN
, getpid ());
11975 #endif /* ! defined (F_SETOWN) */
11977 if (interrupt_input
)
11978 init_sigio (dpyinfo
->connection
);
11982 XrmValue d
, fr
, to
;
11985 dpy
= dpyinfo
->display
;
11986 d
.addr
= (XPointer
)&dpy
;
11987 d
.size
= sizeof (Display
*);
11988 fr
.addr
= XtDefaultFont
;
11989 fr
.size
= sizeof (XtDefaultFont
);
11990 to
.size
= sizeof (Font
*);
11991 to
.addr
= (XPointer
)&font
;
11992 x_catch_errors (dpy
);
11993 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
11995 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
11996 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
11997 /* Do not free XFontStruct returned by the above call to XQueryFont.
11998 This leads to X protocol errors at XtCloseDisplay (Bug#18403). */
11999 x_uncatch_errors ();
12003 /* See if we should run in synchronous mode. This is useful
12004 for debugging X code. */
12006 AUTO_STRING (synchronous
, "synchronous");
12007 AUTO_STRING (Synchronous
, "Synchronous");
12008 Lisp_Object value
= display_x_get_resource (dpyinfo
, synchronous
,
12009 Synchronous
, Qnil
, Qnil
);
12010 if (STRINGP (value
)
12011 && (!strcmp (SSDATA (value
), "true")
12012 || !strcmp (SSDATA (value
), "on")))
12013 XSynchronize (dpyinfo
->display
, True
);
12017 AUTO_STRING (useXIM
, "useXIM");
12018 AUTO_STRING (UseXIM
, "UseXIM");
12019 Lisp_Object value
= display_x_get_resource (dpyinfo
, useXIM
, UseXIM
,
12022 if (STRINGP (value
)
12023 && (!strcmp (SSDATA (value
), "false")
12024 || !strcmp (SSDATA (value
), "off")))
12027 if (STRINGP (value
)
12028 && (!strcmp (SSDATA (value
), "true")
12029 || !strcmp (SSDATA (value
), "on")))
12035 /* Only do this for the very first display in the Emacs session.
12036 Ignore X session management when Emacs was first started on a
12037 tty or started as a daemon. */
12038 if (terminal
->id
== 1 && ! IS_DAEMON
)
12039 x_session_initialize (dpyinfo
);
12043 x_extension_initialize (dpyinfo
);
12051 /* Get rid of display DPYINFO, deleting all frames on it,
12052 and without sending any more commands to the X server. */
12055 x_delete_display (struct x_display_info
*dpyinfo
)
12057 struct terminal
*t
;
12059 /* Close all frames and delete the generic struct terminal for this
12061 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
12062 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
12065 /* Close X session management when we close its display. */
12066 if (t
->id
== 1 && x_session_have_connection ())
12067 x_session_close ();
12069 delete_terminal (t
);
12073 if (next_noop_dpyinfo
== dpyinfo
)
12074 next_noop_dpyinfo
= dpyinfo
->next
;
12076 if (x_display_list
== dpyinfo
)
12077 x_display_list
= dpyinfo
->next
;
12080 struct x_display_info
*tail
;
12082 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
12083 if (tail
->next
== dpyinfo
)
12084 tail
->next
= tail
->next
->next
;
12087 xfree (dpyinfo
->x_id_name
);
12088 xfree (dpyinfo
->x_dnd_atoms
);
12089 xfree (dpyinfo
->color_cells
);
12093 #ifdef USE_X_TOOLKIT
12095 /* Atimer callback function for TIMER. Called every 0.1s to process
12096 Xt timeouts, if needed. We must avoid calling XtAppPending as
12097 much as possible because that function does an implicit XFlush
12098 that slows us down. */
12101 x_process_timeouts (struct atimer
*timer
)
12104 x_timeout_atimer_activated_flag
= false;
12105 if (toolkit_scroll_bar_interaction
|| popup_activated ())
12107 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
12108 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
12109 /* Reactivate the atimer for next time. */
12110 x_activate_timeout_atimer ();
12115 /* Install an asynchronous timer that processes Xt timeout events
12116 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
12117 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
12118 function whenever these variables are set. This is necessary
12119 because some widget sets use timeouts internally, for example the
12120 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
12121 processed, these widgets don't behave normally. */
12124 x_activate_timeout_atimer (void)
12127 if (!x_timeout_atimer_activated_flag
)
12129 struct timespec interval
= make_timespec (0, 100 * 1000 * 1000);
12130 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
12131 x_timeout_atimer_activated_flag
= true;
12136 #endif /* USE_X_TOOLKIT */
12139 /* Set up use of X before we make the first connection. */
12141 static struct redisplay_interface x_redisplay_interface
=
12143 x_frame_parm_handlers
,
12147 x_clear_end_of_line
,
12149 x_after_update_window_line
,
12150 x_update_window_begin
,
12151 x_update_window_end
,
12153 x_clear_window_mouse_face
,
12154 x_get_glyph_overhangs
,
12155 x_fix_overlapping_area
,
12156 x_draw_fringe_bitmap
,
12158 x_cr_define_fringe_bitmap
,
12159 x_cr_destroy_fringe_bitmap
,
12161 0, /* define_fringe_bitmap */
12162 0, /* destroy_fringe_bitmap */
12164 x_compute_glyph_string_overhangs
,
12165 x_draw_glyph_string
,
12166 x_define_frame_cursor
,
12167 x_clear_frame_area
,
12168 x_draw_window_cursor
,
12169 x_draw_vertical_window_border
,
12170 x_draw_window_divider
,
12171 x_shift_glyphs_for_insert
,
12177 /* This function is called when the last frame on a display is deleted. */
12179 x_delete_terminal (struct terminal
*terminal
)
12181 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
12183 /* Protect against recursive calls. delete_frame in
12184 delete_terminal calls us back when it deletes our last frame. */
12185 if (!terminal
->name
)
12190 /* We must close our connection to the XIM server before closing the
12193 xim_close_dpy (dpyinfo
);
12196 /* Normally, the display is available... */
12197 if (dpyinfo
->display
)
12199 x_destroy_all_bitmaps (dpyinfo
);
12200 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
12202 /* Whether or not XCloseDisplay destroys the associated resource
12203 database depends on the version of libX11. To avoid both
12204 crash and memory leak, we dissociate the database from the
12205 display and then destroy dpyinfo->xrdb ourselves.
12207 Unfortunately, the above strategy does not work in some
12208 situations due to a bug in newer versions of libX11: because
12209 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
12210 dpy->db is NULL, XCloseDisplay destroys the associated
12211 database whereas it has not been created by XGetDefault
12212 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
12213 don't destroy the database here in order to avoid the crash
12214 in the above situations for now, though that may cause memory
12215 leaks in other situations. */
12217 #ifdef HAVE_XRMSETDATABASE
12218 XrmSetDatabase (dpyinfo
->display
, NULL
);
12220 dpyinfo
->display
->db
= NULL
;
12222 /* We used to call XrmDestroyDatabase from x_delete_display, but
12223 some older versions of libX11 crash if we call it after
12224 closing all the displays. */
12225 XrmDestroyDatabase (dpyinfo
->xrdb
);
12229 xg_display_close (dpyinfo
->display
);
12231 #ifdef USE_X_TOOLKIT
12232 XtCloseDisplay (dpyinfo
->display
);
12234 XCloseDisplay (dpyinfo
->display
);
12236 #endif /* ! USE_GTK */
12237 /* Do not close the connection here because it's already closed
12238 by X(t)CloseDisplay (Bug#18403). */
12239 dpyinfo
->display
= NULL
;
12242 /* ...but if called from x_connection_closed, the display may already
12243 be closed and dpyinfo->display was set to 0 to indicate that. Since
12244 X server is most likely gone, explicit close is the only reliable
12245 way to continue and avoid Bug#19147. */
12246 else if (dpyinfo
->connection
>= 0)
12247 emacs_close (dpyinfo
->connection
);
12249 /* No more input on this descriptor. */
12250 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
12251 /* Mark as dead. */
12252 dpyinfo
->connection
= -1;
12254 x_delete_display (dpyinfo
);
12258 /* Create a struct terminal, initialize it with the X11 specific
12259 functions and make DISPLAY->TERMINAL point to it. */
12261 static struct terminal
*
12262 x_create_terminal (struct x_display_info
*dpyinfo
)
12264 struct terminal
*terminal
;
12266 terminal
= create_terminal (output_x_window
, &x_redisplay_interface
);
12268 terminal
->display_info
.x
= dpyinfo
;
12269 dpyinfo
->terminal
= terminal
;
12271 /* kboard is initialized in x_term_init. */
12273 terminal
->clear_frame_hook
= x_clear_frame
;
12274 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
12275 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
12276 terminal
->ring_bell_hook
= XTring_bell
;
12277 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
12278 terminal
->update_begin_hook
= x_update_begin
;
12279 terminal
->update_end_hook
= x_update_end
;
12280 terminal
->read_socket_hook
= XTread_socket
;
12281 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
12282 terminal
->mouse_position_hook
= XTmouse_position
;
12283 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
12284 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
12285 terminal
->fullscreen_hook
= XTfullscreen_hook
;
12286 terminal
->menu_show_hook
= x_menu_show
;
12287 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
12288 terminal
->popup_dialog_hook
= xw_popup_dialog
;
12290 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
12291 terminal
->set_horizontal_scroll_bar_hook
= XTset_horizontal_scroll_bar
;
12292 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
12293 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
12294 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
12295 terminal
->delete_frame_hook
= x_destroy_window
;
12296 terminal
->delete_terminal_hook
= x_delete_terminal
;
12297 /* Other hooks are NULL by default. */
12303 x_initialize (void)
12308 any_help_event_p
= false;
12309 ignore_next_mouse_click_timeout
= 0;
12312 current_count
= -1;
12315 /* Try to use interrupt input; if we can't, then start polling. */
12316 Fset_input_interrupt_mode (Qt
);
12318 #ifdef USE_X_TOOLKIT
12319 XtToolkitInitialize ();
12321 Xt_app_con
= XtCreateApplicationContext ();
12323 /* Register a converter from strings to pixels, which uses
12324 Emacs' color allocation infrastructure. */
12325 XtAppSetTypeConverter (Xt_app_con
,
12326 XtRString
, XtRPixel
, cvt_string_to_pixel
,
12327 cvt_string_to_pixel_args
,
12328 XtNumber (cvt_string_to_pixel_args
),
12329 XtCacheByDisplay
, cvt_pixel_dtor
);
12331 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
12334 #ifdef USE_TOOLKIT_SCROLL_BARS
12336 xaw3d_arrow_scroll
= False
;
12337 xaw3d_pick_top
= True
;
12342 x_cr_init_fringe (&x_redisplay_interface
);
12345 /* Note that there is no real way portable across R3/R4 to get the
12346 original error handler. */
12347 XSetErrorHandler (x_error_handler
);
12348 XSetIOErrorHandler (x_io_error_quitter
);
12355 /* Emacs can handle only core input events, so make sure
12356 Gtk doesn't use Xinput or Xinput2 extensions. */
12357 xputenv ("GDK_CORE_DEVICE_EVENTS=1");
12362 syms_of_xterm (void)
12364 x_error_message
= NULL
;
12366 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
12367 DEFSYM (Qlatin_1
, "latin-1");
12370 xg_default_icon_file
= build_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
12371 staticpro (&xg_default_icon_file
);
12373 DEFSYM (Qx_gtk_map_stock
, "x-gtk-map-stock");
12376 DEFVAR_BOOL ("x-use-underline-position-properties",
12377 x_use_underline_position_properties
,
12378 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
12379 A value of nil means ignore them. If you encounter fonts with bogus
12380 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
12381 to 4.1, set this to nil. You can also use `underline-minimum-offset'
12382 to override the font's UNDERLINE_POSITION for small font display
12384 x_use_underline_position_properties
= true;
12386 DEFVAR_BOOL ("x-underline-at-descent-line",
12387 x_underline_at_descent_line
,
12388 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
12389 A value of nil means to draw the underline according to the value of the
12390 variable `x-use-underline-position-properties', which is usually at the
12391 baseline level. The default value is nil. */);
12392 x_underline_at_descent_line
= false;
12394 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
12395 x_mouse_click_focus_ignore_position
,
12396 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
12397 This variable is only used when the window manager requires that you
12398 click on a frame to select it (give it focus). In that case, a value
12399 of nil, means that the selected window and cursor position changes to
12400 reflect the mouse click position, while a non-nil value means that the
12401 selected window or cursor position is preserved. */);
12402 x_mouse_click_focus_ignore_position
= false;
12404 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
12405 doc
: /* Which toolkit scroll bars Emacs uses, if any.
12406 A value of nil means Emacs doesn't use toolkit scroll bars.
12407 With the X Window system, the value is a symbol describing the
12408 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
12409 With MS Windows or Nextstep, the value is t. */);
12410 #ifdef USE_TOOLKIT_SCROLL_BARS
12412 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
12413 #elif defined HAVE_XAW3D
12414 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
12416 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
12418 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
12421 Vx_toolkit_scroll_bars
= Qnil
;
12424 DEFSYM (Qmodifier_value
, "modifier-value");
12425 DEFSYM (Qalt
, "alt");
12426 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
12427 DEFSYM (Qhyper
, "hyper");
12428 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
12429 DEFSYM (Qmeta
, "meta");
12430 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
12431 DEFSYM (Qsuper
, "super");
12432 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
12434 DEFVAR_LISP ("x-alt-keysym", Vx_alt_keysym
,
12435 doc
: /* Which keys Emacs uses for the alt modifier.
12436 This should be one of the symbols `alt', `hyper', `meta', `super'.
12437 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
12438 is nil, which is the same as `alt'. */);
12439 Vx_alt_keysym
= Qnil
;
12441 DEFVAR_LISP ("x-hyper-keysym", Vx_hyper_keysym
,
12442 doc
: /* Which keys Emacs uses for the hyper modifier.
12443 This should be one of the symbols `alt', `hyper', `meta', `super'.
12444 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
12445 default is nil, which is the same as `hyper'. */);
12446 Vx_hyper_keysym
= Qnil
;
12448 DEFVAR_LISP ("x-meta-keysym", Vx_meta_keysym
,
12449 doc
: /* Which keys Emacs uses for the meta modifier.
12450 This should be one of the symbols `alt', `hyper', `meta', `super'.
12451 For example, `meta' means use the Meta_L and Meta_R keysyms. The
12452 default is nil, which is the same as `meta'. */);
12453 Vx_meta_keysym
= Qnil
;
12455 DEFVAR_LISP ("x-super-keysym", Vx_super_keysym
,
12456 doc
: /* Which keys Emacs uses for the super modifier.
12457 This should be one of the symbols `alt', `hyper', `meta', `super'.
12458 For example, `super' means use the Super_L and Super_R keysyms. The
12459 default is nil, which is the same as `super'. */);
12460 Vx_super_keysym
= Qnil
;
12462 DEFVAR_LISP ("x-keysym-table", Vx_keysym_table
,
12463 doc
: /* Hash table of character codes indexed by X keysym codes. */);
12464 Vx_keysym_table
= make_hash_table (hashtest_eql
, make_number (900),
12465 make_float (DEFAULT_REHASH_SIZE
),
12466 make_float (DEFAULT_REHASH_THRESHOLD
),
12469 DEFVAR_BOOL ("x-frame-normalize-before-maximize",
12470 x_frame_normalize_before_maximize
,
12471 doc
: /* Non-nil means normalize frame before maximizing.
12472 If this variable is t, Emacs asks the window manager to give the frame
12473 intermediately its normal size whenever changing from a full-height or
12474 full-width state to the fully maximized one and vice versa.
12476 Set this variable only if your window manager cannot handle the
12477 transition between the various maximization states. */);
12478 x_frame_normalize_before_maximize
= false;