1 /* X Communication module for terminals which understand the X protocol.
3 Copyright (C) 1989, 1993-2014 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
;
183 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
185 static Lisp_Object Qvendor_specific_keysyms
;
186 static Lisp_Object Qlatin_1
;
189 /* The name of the Emacs icon file. */
190 static Lisp_Object xg_default_icon_file
;
192 /* Used in gtkutil.c. */
193 Lisp_Object Qx_gtk_map_stock
;
196 /* Some functions take this as char *, not const char *. */
197 static char emacs_class
[] = EMACS_CLASS
;
201 XEMBED_MAPPED
= 1 << 0
206 XEMBED_EMBEDDED_NOTIFY
= 0,
207 XEMBED_WINDOW_ACTIVATE
= 1,
208 XEMBED_WINDOW_DEACTIVATE
= 2,
209 XEMBED_REQUEST_FOCUS
= 3,
211 XEMBED_FOCUS_OUT
= 5,
212 XEMBED_FOCUS_NEXT
= 6,
213 XEMBED_FOCUS_PREV
= 7,
215 XEMBED_MODALITY_ON
= 10,
216 XEMBED_MODALITY_OFF
= 11,
217 XEMBED_REGISTER_ACCELERATOR
= 12,
218 XEMBED_UNREGISTER_ACCELERATOR
= 13,
219 XEMBED_ACTIVATE_ACCELERATOR
= 14
222 static bool x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
223 static void x_set_window_size_1 (struct frame
*, int, int, int, bool);
224 static void x_raise_frame (struct frame
*);
225 static void x_lower_frame (struct frame
*);
226 static const XColor
*x_color_cells (Display
*, int *);
227 static int x_io_error_quitter (Display
*);
228 static struct terminal
*x_create_terminal (struct x_display_info
*);
229 static void x_update_end (struct frame
*);
230 static void XTframe_up_to_date (struct frame
*);
231 static void x_clear_frame (struct frame
*);
232 static _Noreturn
void x_ins_del_lines (struct frame
*, int, int);
233 static void frame_highlight (struct frame
*);
234 static void frame_unhighlight (struct frame
*);
235 static void x_new_focus_frame (struct x_display_info
*, struct frame
*);
236 static void x_focus_changed (int, int, struct x_display_info
*,
237 struct frame
*, struct input_event
*);
238 static void XTframe_rehighlight (struct frame
*);
239 static void x_frame_rehighlight (struct x_display_info
*);
240 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
241 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
242 enum text_cursor_kinds
);
244 static void x_clip_to_row (struct window
*, struct glyph_row
*,
245 enum glyph_row_area
, GC
);
246 static void x_flush (struct frame
*f
);
247 static void x_update_begin (struct frame
*);
248 static void x_update_window_begin (struct window
*);
249 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
);
250 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
251 enum scroll_bar_part
*,
252 Lisp_Object
*, Lisp_Object
*,
254 static int x_handle_net_wm_state (struct frame
*, const XPropertyEvent
*);
255 static void x_check_fullscreen (struct frame
*);
256 static void x_check_expected_move (struct frame
*, int, int);
257 static void x_sync_with_move (struct frame
*, int, int, int);
258 static int handle_one_xevent (struct x_display_info
*,
259 const XEvent
*, int *,
260 struct input_event
*);
261 #if ! (defined USE_X_TOOLKIT || defined USE_MOTIF)
262 static int x_dispatch_event (XEvent
*, Display
*);
264 /* Don't declare this _Noreturn because we want no
265 interference with debugging failing X calls. */
266 static void x_connection_closed (Display
*, const char *);
267 static void x_wm_set_window_state (struct frame
*, int);
268 static void x_wm_set_icon_pixmap (struct frame
*, ptrdiff_t);
269 static void x_initialize (void);
272 /* Flush display of frame F. */
275 x_flush (struct frame
*f
)
277 eassert (f
&& FRAME_X_P (f
));
278 /* Don't call XFlush when it is not safe to redisplay; the X
279 connection may be broken. */
280 if (!NILP (Vinhibit_redisplay
))
284 XFlush (FRAME_X_DISPLAY (f
));
289 /* Remove calls to XFlush by defining XFlush to an empty replacement.
290 Calls to XFlush should be unnecessary because the X output buffer
291 is flushed automatically as needed by calls to XPending,
292 XNextEvent, or XWindowEvent according to the XFlush man page.
293 XTread_socket calls XPending. Removing XFlush improves
296 #define XFlush(DISPLAY) (void) 0
299 /***********************************************************************
301 ***********************************************************************/
305 /* This is a function useful for recording debugging information about
306 the sequence of occurrences in this file. */
314 struct record event_record
[100];
316 int event_record_index
;
319 record_event (char *locus
, int type
)
321 if (event_record_index
== ARRAYELTS (event_record
))
322 event_record_index
= 0;
324 event_record
[event_record_index
].locus
= locus
;
325 event_record
[event_record_index
].type
= type
;
326 event_record_index
++;
333 /* Return the struct x_display_info corresponding to DPY. */
335 struct x_display_info
*
336 x_display_info_for_display (Display
*dpy
)
338 struct x_display_info
*dpyinfo
;
340 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
341 if (dpyinfo
->display
== dpy
)
348 x_find_topmost_parent (struct frame
*f
)
350 struct x_output
*x
= f
->output_data
.x
;
351 Window win
= None
, wi
= x
->parent_desc
;
352 Display
*dpy
= FRAME_X_DISPLAY (f
);
354 while (wi
!= FRAME_DISPLAY_INFO (f
)->root_window
)
358 unsigned int nchildren
;
361 if (XQueryTree (dpy
, win
, &root
, &wi
, &children
, &nchildren
))
370 #define OPAQUE 0xffffffff
373 x_set_frame_alpha (struct frame
*f
)
375 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
376 Display
*dpy
= FRAME_X_DISPLAY (f
);
377 Window win
= FRAME_OUTER_WINDOW (f
);
379 double alpha_min
= 1.0;
383 if (dpyinfo
->x_highlight_frame
== f
)
388 if (FLOATP (Vframe_alpha_lower_limit
))
389 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
390 else if (INTEGERP (Vframe_alpha_lower_limit
))
391 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
395 else if (alpha
> 1.0)
397 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
400 opac
= alpha
* OPAQUE
;
402 x_catch_errors (dpy
);
404 /* If there is a parent from the window manager, put the property there
405 also, to work around broken window managers that fail to do that.
406 Do this unconditionally as this function is called on reparent when
407 alpha has not changed on the frame. */
409 parent
= x_find_topmost_parent (f
);
411 XChangeProperty (dpy
, parent
, dpyinfo
->Xatom_net_wm_window_opacity
,
412 XA_CARDINAL
, 32, PropModeReplace
,
413 (unsigned char *) &opac
, 1);
415 /* return unless necessary */
420 unsigned long n
, left
;
422 rc
= XGetWindowProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
423 0, 1, False
, XA_CARDINAL
,
424 &actual
, &format
, &n
, &left
,
427 if (rc
== Success
&& actual
!= None
)
429 unsigned long value
= *(unsigned long *)data
;
439 XChangeProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
440 XA_CARDINAL
, 32, PropModeReplace
,
441 (unsigned char *) &opac
, 1);
445 /***********************************************************************
446 Starting and ending an update
447 ***********************************************************************/
449 /* Start an update of frame F. This function is installed as a hook
450 for update_begin, i.e. it is called when update_begin is called.
451 This function is called prior to calls to x_update_window_begin for
452 each window being updated. Currently, there is nothing to do here
453 because all interesting stuff is done on a window basis. */
456 x_update_begin (struct frame
*f
)
462 /* Start update of window W. */
465 x_update_window_begin (struct window
*w
)
467 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
468 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
470 w
->output_cursor
= w
->cursor
;
474 if (f
== hlinfo
->mouse_face_mouse_frame
)
476 /* Don't do highlighting for mouse motion during the update. */
477 hlinfo
->mouse_face_defer
= 1;
479 /* If F needs to be redrawn, simply forget about any prior mouse
481 if (FRAME_GARBAGED_P (f
))
482 hlinfo
->mouse_face_window
= Qnil
;
489 /* Draw a vertical window border from (x,y0) to (x,y1) */
492 x_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
494 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
497 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
499 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
502 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
503 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
506 /* Draw a window divider from (x0,y0) to (x1,y1) */
509 x_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
511 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
512 struct face
*face
= FACE_FROM_ID (f
, WINDOW_DIVIDER_FACE_ID
);
513 struct face
*face_first
= FACE_FROM_ID (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
514 struct face
*face_last
= FACE_FROM_ID (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
515 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
516 unsigned long color_first
= (face_first
517 ? face_first
->foreground
518 : FRAME_FOREGROUND_PIXEL (f
));
519 unsigned long color_last
= (face_last
520 ? face_last
->foreground
521 : FRAME_FOREGROUND_PIXEL (f
));
522 Display
*display
= FRAME_X_DISPLAY (f
);
523 Window window
= FRAME_X_WINDOW (f
);
525 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
528 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_first
);
529 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
531 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
532 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
533 x0
+ 1, y0
, x1
- x0
- 2, y1
- y0
);
534 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_last
);
535 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
536 x1
- 1, y0
, 1, y1
- y0
);
538 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
541 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_first
);
542 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
544 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
545 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
546 x0
, y0
+ 1, x1
- x0
, y1
- y0
- 2);
547 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_last
);
548 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
549 x0
, y1
- 1, x1
- x0
, 1);
553 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
554 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
555 x0
, y0
, x1
- x0
, y1
- y0
);
559 /* End update of window W.
561 Draw vertical borders between horizontally adjacent windows, and
562 display W's cursor if CURSOR_ON_P is non-zero.
564 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
565 glyphs in mouse-face were overwritten. In that case we have to
566 make sure that the mouse-highlight is properly redrawn.
568 W may be a menu bar pseudo-window in case we don't have X toolkit
569 support. Such windows don't have a cursor, so don't display it
573 x_update_window_end (struct window
*w
, bool cursor_on_p
,
574 bool mouse_face_overwritten_p
)
576 if (!w
->pseudo_window_p
)
581 display_and_set_cursor (w
, 1,
582 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
583 w
->output_cursor
.x
, w
->output_cursor
.y
);
585 if (draw_window_fringes (w
, 1))
587 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
588 x_draw_right_divider (w
);
590 x_draw_vertical_border (w
);
596 /* If a row with mouse-face was overwritten, arrange for
597 XTframe_up_to_date to redisplay the mouse highlight. */
598 if (mouse_face_overwritten_p
)
600 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
602 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
603 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
604 hlinfo
->mouse_face_window
= Qnil
;
609 /* End update of frame F. This function is installed as a hook in
613 x_update_end (struct frame
*f
)
615 /* Mouse highlight may be displayed again. */
616 MOUSE_HL_INFO (f
)->mouse_face_defer
= 0;
620 XFlush (FRAME_X_DISPLAY (f
));
626 /* This function is called from various places in xdisp.c
627 whenever a complete update has been performed. */
630 XTframe_up_to_date (struct frame
*f
)
633 FRAME_MOUSE_UPDATE (f
);
637 /* Clear under internal border if any for non-toolkit builds. */
640 #if !defined USE_X_TOOLKIT && !defined USE_GTK
642 x_clear_under_internal_border (struct frame
*f
)
644 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
646 Display
*display
= FRAME_X_DISPLAY (f
);
647 Window window
= FRAME_X_WINDOW (f
);
648 int border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
649 int width
= FRAME_PIXEL_WIDTH (f
);
650 int height
= FRAME_PIXEL_HEIGHT (f
);
651 int margin
= FRAME_TOP_MARGIN_HEIGHT (f
);
654 x_clear_area (display
, window
, 0, 0, border
, height
);
655 x_clear_area (display
, window
, 0, margin
, width
, border
);
656 x_clear_area (display
, window
, width
- border
, 0, border
, height
);
657 x_clear_area (display
, window
, 0, height
- border
, width
, border
);
663 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
664 arrow bitmaps, or clear the fringes if no bitmaps are required
665 before DESIRED_ROW is made current. This function is called from
666 update_window_line only if it is known that there are differences
667 between bitmaps to be drawn between current row and DESIRED_ROW. */
670 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
674 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
675 desired_row
->redraw_fringe_bitmaps_p
= 1;
678 /* When a window has disappeared, make sure that no rest of
679 full-width rows stays visible in the internal border. Could
680 check here if updated window is the leftmost/rightmost window,
681 but I guess it's not worth doing since vertically split windows
682 are almost never used, internal border is rarely set, and the
683 overhead is very small. */
688 if (windows_or_buffers_changed
689 && desired_row
->full_width_p
690 && (f
= XFRAME (w
->frame
),
691 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
693 && (height
= desired_row
->visible_height
,
696 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
699 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
700 0, y
, width
, height
);
701 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
702 FRAME_PIXEL_WIDTH (f
) - width
,
711 x_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, struct draw_fringe_bitmap_params
*p
)
713 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
714 Display
*display
= FRAME_X_DISPLAY (f
);
715 Window window
= FRAME_X_WINDOW (f
);
716 GC gc
= f
->output_data
.x
->normal_gc
;
717 struct face
*face
= p
->face
;
719 /* Must clip because of partially visible lines. */
720 x_clip_to_row (w
, row
, ANY_AREA
, gc
);
722 if (p
->bx
>= 0 && !p
->overlay_p
)
724 /* In case the same realized face is used for fringes and
725 for something displayed in the text (e.g. face `region' on
726 mono-displays, the fill style may have been changed to
727 FillSolid in x_draw_glyph_string_background. */
729 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
731 XSetForeground (display
, face
->gc
, face
->background
);
733 XFillRectangle (display
, window
, face
->gc
,
734 p
->bx
, p
->by
, p
->nx
, p
->ny
);
737 XSetForeground (display
, face
->gc
, face
->foreground
);
743 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
744 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
748 bits
= (char *) (p
->bits
+ p
->dh
);
750 bits
= (char *) p
->bits
+ p
->dh
;
752 /* Draw the bitmap. I believe these small pixmaps can be cached
754 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
756 ? (p
->overlay_p
? face
->background
757 : f
->output_data
.x
->cursor_pixel
)
759 face
->background
, depth
);
763 clipmask
= XCreatePixmapFromBitmapData (display
,
764 FRAME_DISPLAY_INFO (f
)->root_window
,
767 gcv
.clip_mask
= clipmask
;
768 gcv
.clip_x_origin
= p
->x
;
769 gcv
.clip_y_origin
= p
->y
;
770 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
773 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
774 p
->wd
, p
->h
, p
->x
, p
->y
);
775 XFreePixmap (display
, pixmap
);
779 gcv
.clip_mask
= (Pixmap
) 0;
780 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
781 XFreePixmap (display
, clipmask
);
785 XSetClipMask (display
, gc
, None
);
788 /***********************************************************************
790 ***********************************************************************/
794 static void x_set_glyph_string_clipping (struct glyph_string
*);
795 static void x_set_glyph_string_gc (struct glyph_string
*);
796 static void x_draw_glyph_string_foreground (struct glyph_string
*);
797 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
798 static void x_draw_glyph_string_box (struct glyph_string
*);
799 static void x_draw_glyph_string (struct glyph_string
*);
800 static _Noreturn
void x_delete_glyphs (struct frame
*, int);
801 static void x_compute_glyph_string_overhangs (struct glyph_string
*);
802 static void x_set_cursor_gc (struct glyph_string
*);
803 static void x_set_mode_line_face_gc (struct glyph_string
*);
804 static void x_set_mouse_face_gc (struct glyph_string
*);
805 static bool x_alloc_lighter_color (struct frame
*, Display
*, Colormap
,
806 unsigned long *, double, int);
807 static void x_setup_relief_color (struct frame
*, struct relief
*,
808 double, int, unsigned long);
809 static void x_setup_relief_colors (struct glyph_string
*);
810 static void x_draw_image_glyph_string (struct glyph_string
*);
811 static void x_draw_image_relief (struct glyph_string
*);
812 static void x_draw_image_foreground (struct glyph_string
*);
813 static void x_draw_image_foreground_1 (struct glyph_string
*, Pixmap
);
814 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
816 static void x_draw_relief_rect (struct frame
*, int, int, int, int,
817 int, int, int, int, int, int,
819 static void x_draw_box_rect (struct glyph_string
*, int, int, int, int,
820 int, int, int, XRectangle
*);
821 static void x_scroll_bar_clear (struct frame
*);
824 static void x_check_font (struct frame
*, struct font
*);
828 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
832 x_set_cursor_gc (struct glyph_string
*s
)
834 if (s
->font
== FRAME_FONT (s
->f
)
835 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
836 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
838 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
841 /* Cursor on non-default face: must merge. */
845 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
846 xgcv
.foreground
= s
->face
->background
;
848 /* If the glyph would be invisible, try a different foreground. */
849 if (xgcv
.foreground
== xgcv
.background
)
850 xgcv
.foreground
= s
->face
->foreground
;
851 if (xgcv
.foreground
== xgcv
.background
)
852 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
853 if (xgcv
.foreground
== xgcv
.background
)
854 xgcv
.foreground
= s
->face
->foreground
;
856 /* Make sure the cursor is distinct from text in this face. */
857 if (xgcv
.background
== s
->face
->background
858 && xgcv
.foreground
== s
->face
->foreground
)
860 xgcv
.background
= s
->face
->foreground
;
861 xgcv
.foreground
= s
->face
->background
;
864 IF_DEBUG (x_check_font (s
->f
, s
->font
));
865 xgcv
.graphics_exposures
= False
;
866 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
868 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
869 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
872 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
873 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
875 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
880 /* Set up S->gc of glyph string S for drawing text in mouse face. */
883 x_set_mouse_face_gc (struct glyph_string
*s
)
888 /* What face has to be used last for the mouse face? */
889 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
890 face
= FACE_FROM_ID (s
->f
, face_id
);
892 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
894 if (s
->first_glyph
->type
== CHAR_GLYPH
)
895 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
897 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
898 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
899 prepare_face_for_display (s
->f
, s
->face
);
901 if (s
->font
== s
->face
->font
)
905 /* Otherwise construct scratch_cursor_gc with values from FACE
910 xgcv
.background
= s
->face
->background
;
911 xgcv
.foreground
= s
->face
->foreground
;
912 xgcv
.graphics_exposures
= False
;
913 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
915 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
916 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
919 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
920 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
922 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
925 eassert (s
->gc
!= 0);
929 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
930 Faces to use in the mode line have already been computed when the
931 matrix was built, so there isn't much to do, here. */
934 x_set_mode_line_face_gc (struct glyph_string
*s
)
940 /* Set S->gc of glyph string S for drawing that glyph string. Set
941 S->stippled_p to a non-zero value if the face of S has a stipple
945 x_set_glyph_string_gc (struct glyph_string
*s
)
947 prepare_face_for_display (s
->f
, s
->face
);
949 if (s
->hl
== DRAW_NORMAL_TEXT
)
952 s
->stippled_p
= s
->face
->stipple
!= 0;
954 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
956 x_set_mode_line_face_gc (s
);
957 s
->stippled_p
= s
->face
->stipple
!= 0;
959 else if (s
->hl
== DRAW_CURSOR
)
964 else if (s
->hl
== DRAW_MOUSE_FACE
)
966 x_set_mouse_face_gc (s
);
967 s
->stippled_p
= s
->face
->stipple
!= 0;
969 else if (s
->hl
== DRAW_IMAGE_RAISED
970 || s
->hl
== DRAW_IMAGE_SUNKEN
)
973 s
->stippled_p
= s
->face
->stipple
!= 0;
978 /* GC must have been set. */
979 eassert (s
->gc
!= 0);
983 /* Set clipping for output of glyph string S. S may be part of a mode
984 line or menu if we don't have X toolkit support. */
987 x_set_glyph_string_clipping (struct glyph_string
*s
)
989 XRectangle
*r
= s
->clip
;
990 int n
= get_glyph_string_clip_rects (s
, r
, 2);
993 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, r
, n
, Unsorted
);
998 /* Set SRC's clipping for output of glyph string DST. This is called
999 when we are drawing DST's left_overhang or right_overhang only in
1003 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
, struct glyph_string
*dst
)
1008 r
.width
= src
->width
;
1010 r
.height
= src
->height
;
1013 XSetClipRectangles (dst
->display
, dst
->gc
, 0, 0, &r
, 1, Unsorted
);
1018 Compute left and right overhang of glyph string S. */
1021 x_compute_glyph_string_overhangs (struct glyph_string
*s
)
1024 && (s
->first_glyph
->type
== CHAR_GLYPH
1025 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
1027 struct font_metrics metrics
;
1029 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1031 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1032 struct font
*font
= s
->font
;
1035 for (i
= 0; i
< s
->nchars
; i
++)
1036 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
1037 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1041 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1043 composition_gstring_width (gstring
, s
->cmp_from
, s
->cmp_to
, &metrics
);
1045 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1046 ? metrics
.rbearing
- metrics
.width
: 0);
1047 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1051 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1052 s
->left_overhang
= - s
->cmp
->lbearing
;
1057 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1060 x_clear_glyph_string_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
1063 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1064 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1065 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1066 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1070 /* Draw the background of glyph_string S. If S->background_filled_p
1071 is non-zero don't draw it. FORCE_P non-zero means draw the
1072 background even if it wouldn't be drawn normally. This is used
1073 when a string preceding S draws into the background of S, or S
1074 contains the first component of a composition. */
1077 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1079 /* Nothing to do if background has already been drawn or if it
1080 shouldn't be drawn in the first place. */
1081 if (!s
->background_filled_p
)
1083 int box_line_width
= max (s
->face
->box_line_width
, 0);
1087 /* Fill background with a stipple pattern. */
1088 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1089 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1090 s
->y
+ box_line_width
,
1091 s
->background_width
,
1092 s
->height
- 2 * box_line_width
);
1093 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1094 s
->background_filled_p
= 1;
1096 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1097 || s
->font_not_found_p
1098 || s
->extends_to_end_of_line_p
1101 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1102 s
->background_width
,
1103 s
->height
- 2 * box_line_width
);
1104 s
->background_filled_p
= 1;
1110 /* Draw the foreground of glyph string S. */
1113 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1117 /* If first glyph of S has a left box line, start drawing the text
1118 of S to the right of that box line. */
1119 if (s
->face
->box
!= FACE_NO_BOX
1120 && s
->first_glyph
->left_box_line_p
)
1121 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1125 /* Draw characters of S as rectangles if S's font could not be
1127 if (s
->font_not_found_p
)
1129 for (i
= 0; i
< s
->nchars
; ++i
)
1131 struct glyph
*g
= s
->first_glyph
+ i
;
1132 XDrawRectangle (s
->display
, s
->window
,
1133 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1135 x
+= g
->pixel_width
;
1140 struct font
*font
= s
->font
;
1141 int boff
= font
->baseline_offset
;
1144 if (font
->vertical_centering
)
1145 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1147 y
= s
->ybase
- boff
;
1149 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1150 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1152 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1153 if (s
->face
->overstrike
)
1154 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1158 /* Draw the foreground of composite glyph string S. */
1161 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1164 struct font
*font
= s
->font
;
1166 /* If first glyph of S has a left box line, start drawing the text
1167 of S to the right of that box line. */
1168 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1169 && s
->first_glyph
->left_box_line_p
)
1170 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1174 /* S is a glyph string for a composition. S->cmp_from is the index
1175 of the first character drawn for glyphs of this composition.
1176 S->cmp_from == 0 means we are drawing the very first character of
1177 this composition. */
1179 /* Draw a rectangle for the composition if the font for the very
1180 first character of the composition could not be loaded. */
1181 if (s
->font_not_found_p
)
1183 if (s
->cmp_from
== 0)
1184 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1185 s
->width
- 1, s
->height
- 1);
1187 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1191 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1192 /* TAB in a composition means display glyphs with padding
1193 space on the left or right. */
1194 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1196 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1197 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1199 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1200 if (s
->face
->overstrike
)
1201 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1206 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1211 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1213 glyph
= LGSTRING_GLYPH (gstring
, i
);
1214 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1215 width
+= LGLYPH_WIDTH (glyph
);
1218 int xoff
, yoff
, wadjust
;
1222 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1223 if (s
->face
->overstrike
)
1224 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1227 xoff
= LGLYPH_XOFF (glyph
);
1228 yoff
= LGLYPH_YOFF (glyph
);
1229 wadjust
= LGLYPH_WADJUST (glyph
);
1230 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1231 if (s
->face
->overstrike
)
1232 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
, 0);
1240 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1241 if (s
->face
->overstrike
)
1242 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1248 /* Draw the foreground of glyph string S for glyphless characters. */
1251 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1253 struct glyph
*glyph
= s
->first_glyph
;
1257 /* If first glyph of S has a left box line, start drawing the text
1258 of S to the right of that box line. */
1259 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1260 && s
->first_glyph
->left_box_line_p
)
1261 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1267 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1269 char buf
[7], *str
= NULL
;
1270 int len
= glyph
->u
.glyphless
.len
;
1272 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1275 && CHAR_TABLE_P (Vglyphless_char_display
)
1276 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1280 = (! glyph
->u
.glyphless
.for_no_font
1281 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1282 glyph
->u
.glyphless
.ch
)
1283 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1284 if (STRINGP (acronym
))
1285 str
= SSDATA (acronym
);
1288 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1290 sprintf (buf
, "%0*X",
1291 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1292 glyph
->u
.glyphless
.ch
);
1298 int upper_len
= (len
+ 1) / 2;
1301 /* It is assured that all LEN characters in STR is ASCII. */
1302 for (j
= 0; j
< len
; j
++)
1304 code
= s
->font
->driver
->encode_char (s
->font
, str
[j
]);
1305 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1307 s
->font
->driver
->draw (s
, 0, upper_len
,
1308 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1309 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1311 s
->font
->driver
->draw (s
, upper_len
, len
,
1312 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1313 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1316 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1317 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
1318 x
, s
->ybase
- glyph
->ascent
,
1319 glyph
->pixel_width
- 1,
1320 glyph
->ascent
+ glyph
->descent
- 1);
1321 x
+= glyph
->pixel_width
;
1325 #ifdef USE_X_TOOLKIT
1329 /* Return the frame on which widget WIDGET is used.. Abort if frame
1330 cannot be determined. */
1332 static struct frame
*
1333 x_frame_of_widget (Widget widget
)
1335 struct x_display_info
*dpyinfo
;
1336 Lisp_Object tail
, frame
;
1339 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1341 /* Find the top-level shell of the widget. Note that this function
1342 can be called when the widget is not yet realized, so XtWindow
1343 (widget) == 0. That's the reason we can't simply use
1344 x_any_window_to_frame. */
1345 while (!XtIsTopLevelShell (widget
))
1346 widget
= XtParent (widget
);
1348 /* Look for a frame with that top-level widget. Allocate the color
1349 on that frame to get the right gamma correction value. */
1350 FOR_EACH_FRAME (tail
, frame
)
1354 && f
->output_data
.nothing
!= 1
1355 && FRAME_DISPLAY_INFO (f
) == dpyinfo
1356 && f
->output_data
.x
->widget
== widget
)
1362 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1363 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1364 If this produces the same color as PIXEL, try a color where all RGB
1365 values have DELTA added. Return the allocated color in *PIXEL.
1366 DISPLAY is the X display, CMAP is the colormap to operate on.
1367 Value is true if successful. */
1370 x_alloc_lighter_color_for_widget (Widget widget
, Display
*display
, Colormap cmap
,
1371 unsigned long *pixel
, double factor
, int delta
)
1373 struct frame
*f
= x_frame_of_widget (widget
);
1374 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1377 #endif /* USE_LUCID */
1380 /* Structure specifying which arguments should be passed by Xt to
1381 cvt_string_to_pixel. We want the widget's screen and colormap. */
1383 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1385 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1387 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1392 /* The address of this variable is returned by
1393 cvt_string_to_pixel. */
1395 static Pixel cvt_string_to_pixel_value
;
1398 /* Convert a color name to a pixel color.
1400 DPY is the display we are working on.
1402 ARGS is an array of *NARGS XrmValue structures holding additional
1403 information about the widget for which the conversion takes place.
1404 The contents of this array are determined by the specification
1405 in cvt_string_to_pixel_args.
1407 FROM is a pointer to an XrmValue which points to the color name to
1408 convert. TO is an XrmValue in which to return the pixel color.
1410 CLOSURE_RET is a pointer to user-data, in which we record if
1411 we allocated the color or not.
1413 Value is True if successful, False otherwise. */
1416 cvt_string_to_pixel (Display
*dpy
, XrmValue
*args
, Cardinal
*nargs
,
1417 XrmValue
*from
, XrmValue
*to
,
1418 XtPointer
*closure_ret
)
1428 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1429 "wrongParameters", "cvt_string_to_pixel",
1431 "Screen and colormap args required", NULL
, NULL
);
1435 screen
= *(Screen
**) args
[0].addr
;
1436 cmap
= *(Colormap
*) args
[1].addr
;
1437 color_name
= (String
) from
->addr
;
1439 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1441 *closure_ret
= (XtPointer
) False
;
1442 pixel
= WhitePixelOfScreen (screen
);
1444 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1446 *closure_ret
= (XtPointer
) False
;
1447 pixel
= BlackPixelOfScreen (screen
);
1449 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1450 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1452 pixel
= color
.pixel
;
1453 *closure_ret
= (XtPointer
) True
;
1458 Cardinal nparams
= 1;
1460 params
[0] = color_name
;
1461 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1462 "badValue", "cvt_string_to_pixel",
1463 "XtToolkitError", "Invalid color `%s'",
1468 if (to
->addr
!= NULL
)
1470 if (to
->size
< sizeof (Pixel
))
1472 to
->size
= sizeof (Pixel
);
1476 *(Pixel
*) to
->addr
= pixel
;
1480 cvt_string_to_pixel_value
= pixel
;
1481 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1484 to
->size
= sizeof (Pixel
);
1489 /* Free a pixel color which was previously allocated via
1490 cvt_string_to_pixel. This is registered as the destructor
1491 for this type of resource via XtSetTypeConverter.
1493 APP is the application context in which we work.
1495 TO is a pointer to an XrmValue holding the color to free.
1496 CLOSURE is the value we stored in CLOSURE_RET for this color
1497 in cvt_string_to_pixel.
1499 ARGS and NARGS are like for cvt_string_to_pixel. */
1502 cvt_pixel_dtor (XtAppContext app
, XrmValuePtr to
, XtPointer closure
, XrmValuePtr args
,
1507 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1509 "Screen and colormap arguments required",
1512 else if (closure
!= NULL
)
1514 /* We did allocate the pixel, so free it. */
1515 Screen
*screen
= *(Screen
**) args
[0].addr
;
1516 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1517 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1518 (Pixel
*) to
->addr
, 1);
1523 #endif /* USE_X_TOOLKIT */
1526 /* Value is an array of XColor structures for the contents of the
1527 color map of display DPY. Set *NCELLS to the size of the array.
1528 Note that this probably shouldn't be called for large color maps,
1529 say a 24-bit TrueColor map. */
1531 static const XColor
*
1532 x_color_cells (Display
*dpy
, int *ncells
)
1534 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1536 if (dpyinfo
->color_cells
== NULL
)
1538 Screen
*screen
= dpyinfo
->screen
;
1539 int ncolor_cells
= XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1542 dpyinfo
->color_cells
= xnmalloc (ncolor_cells
,
1543 sizeof *dpyinfo
->color_cells
);
1544 dpyinfo
->ncolor_cells
= ncolor_cells
;
1546 for (i
= 0; i
< ncolor_cells
; ++i
)
1547 dpyinfo
->color_cells
[i
].pixel
= i
;
1549 XQueryColors (dpy
, dpyinfo
->cmap
,
1550 dpyinfo
->color_cells
, ncolor_cells
);
1553 *ncells
= dpyinfo
->ncolor_cells
;
1554 return dpyinfo
->color_cells
;
1558 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1559 colors in COLORS. Use cached information, if available. */
1562 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1564 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1566 if (dpyinfo
->color_cells
)
1569 for (i
= 0; i
< ncolors
; ++i
)
1571 unsigned long pixel
= colors
[i
].pixel
;
1572 eassert (pixel
< dpyinfo
->ncolor_cells
);
1573 eassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1574 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1578 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1582 /* On frame F, translate pixel color to RGB values for the color in
1583 COLOR. Use cached information, if available. */
1586 x_query_color (struct frame
*f
, XColor
*color
)
1588 x_query_colors (f
, color
, 1);
1592 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1593 exact match can't be allocated, try the nearest color available.
1594 Value is true if successful. Set *COLOR to the color
1598 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
1602 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
1605 /* If we got to this point, the colormap is full, so we're going
1606 to try to get the next closest color. The algorithm used is
1607 a least-squares matching, which is what X uses for closest
1608 color matching with StaticColor visuals. */
1610 int max_color_delta
= 255;
1611 int max_delta
= 3 * max_color_delta
;
1612 int nearest_delta
= max_delta
+ 1;
1614 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1616 for (nearest
= i
= 0; i
< ncells
; ++i
)
1618 int dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1619 int dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1620 int dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1621 int delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1623 if (delta
< nearest_delta
)
1626 nearest_delta
= delta
;
1630 color
->red
= cells
[nearest
].red
;
1631 color
->green
= cells
[nearest
].green
;
1632 color
->blue
= cells
[nearest
].blue
;
1633 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
1637 /* If allocation succeeded, and the allocated pixel color is not
1638 equal to a cached pixel color recorded earlier, there was a
1639 change in the colormap, so clear the color cache. */
1640 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1641 XColor
*cached_color
;
1643 if (dpyinfo
->color_cells
1644 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1645 (cached_color
->red
!= color
->red
1646 || cached_color
->blue
!= color
->blue
1647 || cached_color
->green
!= color
->green
)))
1649 xfree (dpyinfo
->color_cells
);
1650 dpyinfo
->color_cells
= NULL
;
1651 dpyinfo
->ncolor_cells
= 0;
1655 #ifdef DEBUG_X_COLORS
1657 register_color (color
->pixel
);
1658 #endif /* DEBUG_X_COLORS */
1664 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1665 exact match can't be allocated, try the nearest color available.
1666 Value is true if successful. Set *COLOR to the color
1670 x_alloc_nearest_color (struct frame
*f
, Colormap cmap
, XColor
*color
)
1672 gamma_correct (f
, color
);
1673 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1677 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1678 It's necessary to do this instead of just using PIXEL directly to
1679 get color reference counts right. */
1682 x_copy_color (struct frame
*f
, unsigned long pixel
)
1686 color
.pixel
= pixel
;
1688 x_query_color (f
, &color
);
1689 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1691 #ifdef DEBUG_X_COLORS
1692 register_color (pixel
);
1698 /* Brightness beyond which a color won't have its highlight brightness
1701 Nominally, highlight colors for `3d' faces are calculated by
1702 brightening an object's color by a constant scale factor, but this
1703 doesn't yield good results for dark colors, so for colors who's
1704 brightness is less than this value (on a scale of 0-65535) have an
1705 use an additional additive factor.
1707 The value here is set so that the default menu-bar/mode-line color
1708 (grey75) will not have its highlights changed at all. */
1709 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1712 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1713 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1714 If this produces the same color as PIXEL, try a color where all RGB
1715 values have DELTA added. Return the allocated color in *PIXEL.
1716 DISPLAY is the X display, CMAP is the colormap to operate on.
1717 Value is non-zero if successful. */
1720 x_alloc_lighter_color (struct frame
*f
, Display
*display
, Colormap cmap
,
1721 unsigned long *pixel
, double factor
, int delta
)
1727 /* Get RGB color values. */
1728 color
.pixel
= *pixel
;
1729 x_query_color (f
, &color
);
1731 /* Change RGB values by specified FACTOR. Avoid overflow! */
1732 eassert (factor
>= 0);
1733 new.red
= min (0xffff, factor
* color
.red
);
1734 new.green
= min (0xffff, factor
* color
.green
);
1735 new.blue
= min (0xffff, factor
* color
.blue
);
1737 /* Calculate brightness of COLOR. */
1738 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1740 /* We only boost colors that are darker than
1741 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1742 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1743 /* Make an additive adjustment to NEW, because it's dark enough so
1744 that scaling by FACTOR alone isn't enough. */
1746 /* How far below the limit this color is (0 - 1, 1 being darker). */
1747 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1748 /* The additive adjustment. */
1749 int min_delta
= delta
* dimness
* factor
/ 2;
1753 new.red
= max (0, new.red
- min_delta
);
1754 new.green
= max (0, new.green
- min_delta
);
1755 new.blue
= max (0, new.blue
- min_delta
);
1759 new.red
= min (0xffff, min_delta
+ new.red
);
1760 new.green
= min (0xffff, min_delta
+ new.green
);
1761 new.blue
= min (0xffff, min_delta
+ new.blue
);
1765 /* Try to allocate the color. */
1766 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1769 if (new.pixel
== *pixel
)
1771 /* If we end up with the same color as before, try adding
1772 delta to the RGB values. */
1773 x_free_colors (f
, &new.pixel
, 1);
1775 new.red
= min (0xffff, delta
+ color
.red
);
1776 new.green
= min (0xffff, delta
+ color
.green
);
1777 new.blue
= min (0xffff, delta
+ color
.blue
);
1778 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1789 /* Set up the foreground color for drawing relief lines of glyph
1790 string S. RELIEF is a pointer to a struct relief containing the GC
1791 with which lines will be drawn. Use a color that is FACTOR or
1792 DELTA lighter or darker than the relief's background which is found
1793 in S->f->output_data.x->relief_background. If such a color cannot
1794 be allocated, use DEFAULT_PIXEL, instead. */
1797 x_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
1798 int delta
, unsigned long default_pixel
)
1801 struct x_output
*di
= f
->output_data
.x
;
1802 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1803 unsigned long pixel
;
1804 unsigned long background
= di
->relief_background
;
1805 Colormap cmap
= FRAME_X_COLORMAP (f
);
1806 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1807 Display
*dpy
= FRAME_X_DISPLAY (f
);
1809 xgcv
.graphics_exposures
= False
;
1810 xgcv
.line_width
= 1;
1812 /* Free previously allocated color. The color cell will be reused
1813 when it has been freed as many times as it was allocated, so this
1814 doesn't affect faces using the same colors. */
1815 if (relief
->gc
&& relief
->pixel
!= -1)
1817 x_free_colors (f
, &relief
->pixel
, 1);
1821 /* Allocate new color. */
1822 xgcv
.foreground
= default_pixel
;
1824 if (dpyinfo
->n_planes
!= 1
1825 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1826 xgcv
.foreground
= relief
->pixel
= pixel
;
1828 if (relief
->gc
== 0)
1830 xgcv
.stipple
= dpyinfo
->gray
;
1832 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1835 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1839 /* Set up colors for the relief lines around glyph string S. */
1842 x_setup_relief_colors (struct glyph_string
*s
)
1844 struct x_output
*di
= s
->f
->output_data
.x
;
1845 unsigned long color
;
1847 if (s
->face
->use_box_color_for_shadows_p
)
1848 color
= s
->face
->box_color
;
1849 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1851 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1852 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1857 /* Get the background color of the face. */
1858 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
1859 color
= xgcv
.background
;
1862 if (di
->white_relief
.gc
== 0
1863 || color
!= di
->relief_background
)
1865 di
->relief_background
= color
;
1866 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1867 WHITE_PIX_DEFAULT (s
->f
));
1868 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1869 BLACK_PIX_DEFAULT (s
->f
));
1874 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1875 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1876 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1877 relief. LEFT_P non-zero means draw a relief on the left side of
1878 the rectangle. RIGHT_P non-zero means draw a relief on the right
1879 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1883 x_draw_relief_rect (struct frame
*f
,
1884 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1885 int raised_p
, int top_p
, int bot_p
, int left_p
, int right_p
,
1886 XRectangle
*clip_rect
)
1888 Display
*dpy
= FRAME_X_DISPLAY (f
);
1889 Window window
= FRAME_X_WINDOW (f
);
1894 gc
= f
->output_data
.x
->white_relief
.gc
;
1896 gc
= f
->output_data
.x
->black_relief
.gc
;
1897 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
1899 /* This code is more complicated than it has to be, because of two
1900 minor hacks to make the boxes look nicer: (i) if width > 1, draw
1901 the outermost line using the black relief. (ii) Omit the four
1908 XDrawLine (dpy
, window
, gc
,
1909 left_x
+ (left_p
? 1 : 0), top_y
,
1910 right_x
+ (right_p
? 0 : 1), top_y
);
1912 for (i
= 1; i
< width
; ++i
)
1913 XDrawLine (dpy
, window
, gc
,
1914 left_x
+ i
* left_p
, top_y
+ i
,
1915 right_x
+ 1 - i
* right_p
, top_y
+ i
);
1922 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
1924 XClearArea (dpy
, window
, left_x
, top_y
, 1, 1, False
);
1925 XClearArea (dpy
, window
, left_x
, bottom_y
, 1, 1, False
);
1927 for (i
= (width
> 1 ? 1 : 0); i
< width
; ++i
)
1928 XDrawLine (dpy
, window
, gc
,
1929 left_x
+ i
, top_y
+ (i
+ 1) * top_p
,
1930 left_x
+ i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
1933 XSetClipMask (dpy
, gc
, None
);
1935 gc
= f
->output_data
.x
->black_relief
.gc
;
1937 gc
= f
->output_data
.x
->white_relief
.gc
;
1938 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
1942 /* Outermost top line. */
1944 XDrawLine (dpy
, window
, gc
,
1945 left_x
+ (left_p
? 1 : 0), top_y
,
1946 right_x
+ (right_p
? 0 : 1), top_y
);
1948 /* Outermost left line. */
1950 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
1956 XDrawLine (dpy
, window
, gc
,
1957 left_x
+ (left_p
? 1 : 0), bottom_y
,
1958 right_x
+ (right_p
? 0 : 1), bottom_y
);
1959 for (i
= 1; i
< width
; ++i
)
1960 XDrawLine (dpy
, window
, gc
,
1961 left_x
+ i
* left_p
, bottom_y
- i
,
1962 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
1968 XClearArea (dpy
, window
, right_x
, top_y
, 1, 1, False
);
1969 XClearArea (dpy
, window
, right_x
, bottom_y
, 1, 1, False
);
1970 for (i
= 0; i
< width
; ++i
)
1971 XDrawLine (dpy
, window
, gc
,
1972 right_x
- i
, top_y
+ (i
+ 1) * top_p
,
1973 right_x
- i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
1976 XSetClipMask (dpy
, gc
, None
);
1980 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1981 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1982 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1983 left side of the rectangle. RIGHT_P non-zero means draw a line
1984 on the right side of the rectangle. CLIP_RECT is the clipping
1985 rectangle to use when drawing. */
1988 x_draw_box_rect (struct glyph_string
*s
,
1989 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1990 int left_p
, int right_p
, XRectangle
*clip_rect
)
1994 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
1995 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
1996 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
1999 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2000 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2004 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2005 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2008 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2009 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2013 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2014 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2016 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2017 XSetClipMask (s
->display
, s
->gc
, None
);
2021 /* Draw a box around glyph string S. */
2024 x_draw_glyph_string_box (struct glyph_string
*s
)
2026 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2027 int left_p
, right_p
;
2028 struct glyph
*last_glyph
;
2029 XRectangle clip_rect
;
2031 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2032 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2033 : window_box_right (s
->w
, s
->area
));
2035 /* The glyph that may have a right box line. */
2036 last_glyph
= (s
->cmp
|| s
->img
2038 : s
->first_glyph
+ s
->nchars
- 1);
2040 width
= eabs (s
->face
->box_line_width
);
2041 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2043 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2045 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2047 bottom_y
= top_y
+ s
->height
- 1;
2049 left_p
= (s
->first_glyph
->left_box_line_p
2050 || (s
->hl
== DRAW_MOUSE_FACE
2052 || s
->prev
->hl
!= s
->hl
)));
2053 right_p
= (last_glyph
->right_box_line_p
2054 || (s
->hl
== DRAW_MOUSE_FACE
2056 || s
->next
->hl
!= s
->hl
)));
2058 get_glyph_string_clip_rect (s
, &clip_rect
);
2060 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2061 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2062 left_p
, right_p
, &clip_rect
);
2065 x_setup_relief_colors (s
);
2066 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2067 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2072 /* Draw foreground of image glyph string S. */
2075 x_draw_image_foreground (struct glyph_string
*s
)
2078 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2080 /* If first glyph of S has a left box line, start drawing it to the
2081 right of that line. */
2082 if (s
->face
->box
!= FACE_NO_BOX
2083 && s
->first_glyph
->left_box_line_p
2085 x
+= eabs (s
->face
->box_line_width
);
2087 /* If there is a margin around the image, adjust x- and y-position
2089 if (s
->slice
.x
== 0)
2090 x
+= s
->img
->hmargin
;
2091 if (s
->slice
.y
== 0)
2092 y
+= s
->img
->vmargin
;
2098 /* We can't set both a clip mask and use XSetClipRectangles
2099 because the latter also sets a clip mask. We also can't
2100 trust on the shape extension to be available
2101 (XShapeCombineRegion). So, compute the rectangle to draw
2103 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2106 XRectangle clip_rect
, image_rect
, r
;
2108 xgcv
.clip_mask
= s
->img
->mask
;
2109 xgcv
.clip_x_origin
= x
;
2110 xgcv
.clip_y_origin
= y
;
2111 xgcv
.function
= GXcopy
;
2112 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2114 get_glyph_string_clip_rect (s
, &clip_rect
);
2117 image_rect
.width
= s
->slice
.width
;
2118 image_rect
.height
= s
->slice
.height
;
2119 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2120 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2121 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2122 r
.width
, r
.height
, r
.x
, r
.y
);
2126 XRectangle clip_rect
, image_rect
, r
;
2128 get_glyph_string_clip_rect (s
, &clip_rect
);
2131 image_rect
.width
= s
->slice
.width
;
2132 image_rect
.height
= s
->slice
.height
;
2133 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2134 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2135 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2136 r
.width
, r
.height
, r
.x
, r
.y
);
2138 /* When the image has a mask, we can expect that at
2139 least part of a mouse highlight or a block cursor will
2140 be visible. If the image doesn't have a mask, make
2141 a block cursor visible by drawing a rectangle around
2142 the image. I believe it's looking better if we do
2143 nothing here for mouse-face. */
2144 if (s
->hl
== DRAW_CURSOR
)
2146 int relief
= eabs (s
->img
->relief
);
2147 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2148 x
- relief
, y
- relief
,
2149 s
->slice
.width
+ relief
*2 - 1,
2150 s
->slice
.height
+ relief
*2 - 1);
2155 /* Draw a rectangle if image could not be loaded. */
2156 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2157 s
->slice
.width
- 1, s
->slice
.height
- 1);
2161 /* Draw a relief around the image glyph string S. */
2164 x_draw_image_relief (struct glyph_string
*s
)
2166 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
2167 int extra_x
, extra_y
;
2170 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2172 /* If first glyph of S has a left box line, start drawing it to the
2173 right of that line. */
2174 if (s
->face
->box
!= FACE_NO_BOX
2175 && s
->first_glyph
->left_box_line_p
2177 x
+= eabs (s
->face
->box_line_width
);
2179 /* If there is a margin around the image, adjust x- and y-position
2181 if (s
->slice
.x
== 0)
2182 x
+= s
->img
->hmargin
;
2183 if (s
->slice
.y
== 0)
2184 y
+= s
->img
->vmargin
;
2186 if (s
->hl
== DRAW_IMAGE_SUNKEN
2187 || s
->hl
== DRAW_IMAGE_RAISED
)
2189 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2190 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2194 thick
= eabs (s
->img
->relief
);
2195 raised_p
= s
->img
->relief
> 0;
2198 x1
= x
+ s
->slice
.width
- 1;
2199 y1
= y
+ s
->slice
.height
- 1;
2201 extra_x
= extra_y
= 0;
2202 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
2204 if (CONSP (Vtool_bar_button_margin
)
2205 && INTEGERP (XCAR (Vtool_bar_button_margin
))
2206 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
2208 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
2209 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
2211 else if (INTEGERP (Vtool_bar_button_margin
))
2212 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
2215 top_p
= bot_p
= left_p
= right_p
= 0;
2217 if (s
->slice
.x
== 0)
2218 x
-= thick
+ extra_x
, left_p
= 1;
2219 if (s
->slice
.y
== 0)
2220 y
-= thick
+ extra_y
, top_p
= 1;
2221 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
2222 x1
+= thick
+ extra_x
, right_p
= 1;
2223 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
2224 y1
+= thick
+ extra_y
, bot_p
= 1;
2226 x_setup_relief_colors (s
);
2227 get_glyph_string_clip_rect (s
, &r
);
2228 x_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
2229 top_p
, bot_p
, left_p
, right_p
, &r
);
2233 /* Draw the foreground of image glyph string S to PIXMAP. */
2236 x_draw_image_foreground_1 (struct glyph_string
*s
, Pixmap pixmap
)
2239 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2241 /* If first glyph of S has a left box line, start drawing it to the
2242 right of that line. */
2243 if (s
->face
->box
!= FACE_NO_BOX
2244 && s
->first_glyph
->left_box_line_p
2246 x
+= eabs (s
->face
->box_line_width
);
2248 /* If there is a margin around the image, adjust x- and y-position
2250 if (s
->slice
.x
== 0)
2251 x
+= s
->img
->hmargin
;
2252 if (s
->slice
.y
== 0)
2253 y
+= s
->img
->vmargin
;
2259 /* We can't set both a clip mask and use XSetClipRectangles
2260 because the latter also sets a clip mask. We also can't
2261 trust on the shape extension to be available
2262 (XShapeCombineRegion). So, compute the rectangle to draw
2264 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2268 xgcv
.clip_mask
= s
->img
->mask
;
2269 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2270 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2271 xgcv
.function
= GXcopy
;
2272 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2274 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2275 s
->slice
.x
, s
->slice
.y
,
2276 s
->slice
.width
, s
->slice
.height
, x
, y
);
2277 XSetClipMask (s
->display
, s
->gc
, None
);
2281 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2282 s
->slice
.x
, s
->slice
.y
,
2283 s
->slice
.width
, s
->slice
.height
, x
, y
);
2285 /* When the image has a mask, we can expect that at
2286 least part of a mouse highlight or a block cursor will
2287 be visible. If the image doesn't have a mask, make
2288 a block cursor visible by drawing a rectangle around
2289 the image. I believe it's looking better if we do
2290 nothing here for mouse-face. */
2291 if (s
->hl
== DRAW_CURSOR
)
2293 int r
= eabs (s
->img
->relief
);
2294 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2295 s
->slice
.width
+ r
*2 - 1,
2296 s
->slice
.height
+ r
*2 - 1);
2301 /* Draw a rectangle if image could not be loaded. */
2302 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2303 s
->slice
.width
- 1, s
->slice
.height
- 1);
2307 /* Draw part of the background of glyph string S. X, Y, W, and H
2308 give the rectangle to draw. */
2311 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2315 /* Fill background with a stipple pattern. */
2316 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2317 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2318 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2321 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2325 /* Draw image glyph string S.
2328 s->x +-------------------------
2331 | +-------------------------
2334 | | +-------------------
2340 x_draw_image_glyph_string (struct glyph_string
*s
)
2342 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2343 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2345 Pixmap pixmap
= None
;
2348 if (s
->slice
.y
== 0)
2349 height
-= box_line_vwidth
;
2350 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2351 height
-= box_line_vwidth
;
2353 /* Fill background with face under the image. Do it only if row is
2354 taller than image or if image has a clip mask to reduce
2356 s
->stippled_p
= s
->face
->stipple
!= 0;
2357 if (height
> s
->slice
.height
2361 || s
->img
->pixmap
== 0
2362 || s
->width
!= s
->background_width
)
2366 /* Create a pixmap as large as the glyph string. Fill it
2367 with the background color. Copy the image to it, using
2368 its mask. Copy the temporary pixmap to the display. */
2369 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2370 int depth
= DefaultDepthOfScreen (screen
);
2372 /* Create a pixmap as large as the glyph string. */
2373 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2374 s
->background_width
,
2377 /* Don't clip in the following because we're working on the
2379 XSetClipMask (s
->display
, s
->gc
, None
);
2381 /* Fill the pixmap with the background color/stipple. */
2384 /* Fill background with a stipple pattern. */
2385 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2386 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
2387 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2388 0, 0, s
->background_width
, s
->height
);
2389 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2390 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
2395 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2397 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2398 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2399 0, 0, s
->background_width
, s
->height
);
2400 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2407 int width
= s
->background_width
;
2409 if (s
->first_glyph
->left_box_line_p
2412 x
+= box_line_hwidth
;
2413 width
-= box_line_hwidth
;
2416 if (s
->slice
.y
== 0)
2417 y
+= box_line_vwidth
;
2419 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
2422 s
->background_filled_p
= 1;
2425 /* Draw the foreground. */
2428 x_draw_image_foreground_1 (s
, pixmap
);
2429 x_set_glyph_string_clipping (s
);
2430 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2431 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2432 XFreePixmap (s
->display
, pixmap
);
2435 x_draw_image_foreground (s
);
2437 /* If we must draw a relief around the image, do it. */
2439 || s
->hl
== DRAW_IMAGE_RAISED
2440 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2441 x_draw_image_relief (s
);
2445 /* Draw stretch glyph string S. */
2448 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2450 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2452 if (s
->hl
== DRAW_CURSOR
2453 && !x_stretch_cursor_p
)
2455 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2456 wide as the stretch glyph. */
2457 int width
, background_width
= s
->background_width
;
2460 if (!s
->row
->reversed_p
)
2462 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2466 background_width
-= left_x
- x
;
2472 /* In R2L rows, draw the cursor on the right edge of the
2474 int right_x
= window_box_right_offset (s
->w
, TEXT_AREA
);
2476 if (x
+ background_width
> right_x
)
2477 background_width
-= x
- right_x
;
2478 x
+= background_width
;
2480 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2481 if (s
->row
->reversed_p
)
2485 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2487 /* Clear rest using the GC of the original non-cursor face. */
2488 if (width
< background_width
)
2491 int w
= background_width
- width
, h
= s
->height
;
2495 if (!s
->row
->reversed_p
)
2499 if (s
->row
->mouse_face_p
2500 && cursor_in_mouse_face_p (s
->w
))
2502 x_set_mouse_face_gc (s
);
2508 get_glyph_string_clip_rect (s
, &r
);
2509 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2511 if (s
->face
->stipple
)
2513 /* Fill background with a stipple pattern. */
2514 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2515 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2516 XSetFillStyle (s
->display
, gc
, FillSolid
);
2521 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2522 XSetForeground (s
->display
, gc
, xgcv
.background
);
2523 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2524 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2527 XSetClipMask (s
->display
, gc
, None
);
2530 else if (!s
->background_filled_p
)
2532 int background_width
= s
->background_width
;
2533 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2535 /* Don't draw into left margin, fringe or scrollbar area
2536 except for header line and mode line. */
2537 if (x
< left_x
&& !s
->row
->mode_line_p
)
2539 background_width
-= left_x
- x
;
2542 if (background_width
> 0)
2543 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2546 s
->background_filled_p
= 1;
2550 Draw a wavy line under S. The wave fills wave_height pixels from y0.
2556 wave_height = 3 | * * * *
2561 x_draw_underwave (struct glyph_string
*s
)
2563 int wave_height
= 3, wave_length
= 2;
2564 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, odd
, xmax
;
2565 XRectangle wave_clip
, string_clip
, final_clip
;
2568 dy
= wave_height
- 1;
2570 y0
= s
->ybase
- wave_height
+ 3;
2574 /* Find and set clipping rectangle */
2578 wave_clip
.width
= width
;
2579 wave_clip
.height
= wave_height
;
2580 get_glyph_string_clip_rect (s
, &string_clip
);
2582 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
2585 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &final_clip
, 1, Unsorted
);
2587 /* Draw the waves */
2589 x1
= x0
- (x0
% dx
);
2599 if (INT_MAX
- dx
< xmax
)
2604 XDrawLine (s
->display
, s
->window
, s
->gc
, x1
, y1
, x2
, y2
);
2606 x2
+= dx
, y2
= y0
+ odd
*dy
;
2610 /* Restore previous clipping rectangle(s) */
2611 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, s
->clip
, s
->num_clips
, Unsorted
);
2615 /* Draw glyph string S. */
2618 x_draw_glyph_string (struct glyph_string
*s
)
2620 bool relief_drawn_p
= 0;
2622 /* If S draws into the background of its successors, draw the
2623 background of the successors first so that S can draw into it.
2624 This makes S->next use XDrawString instead of XDrawImageString. */
2625 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2628 struct glyph_string
*next
;
2630 for (width
= 0, next
= s
->next
;
2631 next
&& width
< s
->right_overhang
;
2632 width
+= next
->width
, next
= next
->next
)
2633 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2635 x_set_glyph_string_gc (next
);
2636 x_set_glyph_string_clipping (next
);
2637 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2638 x_draw_stretch_glyph_string (next
);
2640 x_draw_glyph_string_background (next
, 1);
2641 next
->num_clips
= 0;
2645 /* Set up S->gc, set clipping and draw S. */
2646 x_set_glyph_string_gc (s
);
2648 /* Draw relief (if any) in advance for char/composition so that the
2649 glyph string can be drawn over it. */
2650 if (!s
->for_overlaps
2651 && s
->face
->box
!= FACE_NO_BOX
2652 && (s
->first_glyph
->type
== CHAR_GLYPH
2653 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2656 x_set_glyph_string_clipping (s
);
2657 x_draw_glyph_string_background (s
, 1);
2658 x_draw_glyph_string_box (s
);
2659 x_set_glyph_string_clipping (s
);
2662 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2664 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2665 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2666 /* We must clip just this glyph. left_overhang part has already
2667 drawn when s->prev was drawn, and right_overhang part will be
2668 drawn later when s->next is drawn. */
2669 x_set_glyph_string_clipping_exactly (s
, s
);
2671 x_set_glyph_string_clipping (s
);
2673 switch (s
->first_glyph
->type
)
2676 x_draw_image_glyph_string (s
);
2680 x_draw_stretch_glyph_string (s
);
2684 if (s
->for_overlaps
)
2685 s
->background_filled_p
= 1;
2687 x_draw_glyph_string_background (s
, 0);
2688 x_draw_glyph_string_foreground (s
);
2691 case COMPOSITE_GLYPH
:
2692 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2693 && ! s
->first_glyph
->u
.cmp
.automatic
))
2694 s
->background_filled_p
= 1;
2696 x_draw_glyph_string_background (s
, 1);
2697 x_draw_composite_glyph_string_foreground (s
);
2700 case GLYPHLESS_GLYPH
:
2701 if (s
->for_overlaps
)
2702 s
->background_filled_p
= 1;
2704 x_draw_glyph_string_background (s
, 1);
2705 x_draw_glyphless_glyph_string_foreground (s
);
2712 if (!s
->for_overlaps
)
2714 /* Draw underline. */
2715 if (s
->face
->underline_p
)
2717 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2719 if (s
->face
->underline_defaulted_p
)
2720 x_draw_underwave (s
);
2724 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2725 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2726 x_draw_underwave (s
);
2727 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2730 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2732 unsigned long thickness
, position
;
2735 if (s
->prev
&& s
->prev
->face
->underline_p
2736 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2738 /* We use the same underline style as the previous one. */
2739 thickness
= s
->prev
->underline_thickness
;
2740 position
= s
->prev
->underline_position
;
2744 /* Get the underline thickness. Default is 1 pixel. */
2745 if (s
->font
&& s
->font
->underline_thickness
> 0)
2746 thickness
= s
->font
->underline_thickness
;
2749 if (x_underline_at_descent_line
)
2750 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2753 /* Get the underline position. This is the recommended
2754 vertical offset in pixels from the baseline to the top of
2755 the underline. This is a signed value according to the
2756 specs, and its default is
2758 ROUND ((maximum descent) / 2), with
2759 ROUND(x) = floor (x + 0.5) */
2761 if (x_use_underline_position_properties
2762 && s
->font
&& s
->font
->underline_position
>= 0)
2763 position
= s
->font
->underline_position
;
2765 position
= (s
->font
->descent
+ 1) / 2;
2767 position
= underline_minimum_offset
;
2769 position
= max (position
, underline_minimum_offset
);
2771 /* Check the sanity of thickness and position. We should
2772 avoid drawing underline out of the current line area. */
2773 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2774 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2775 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2776 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2777 s
->underline_thickness
= thickness
;
2778 s
->underline_position
= position
;
2779 y
= s
->ybase
+ position
;
2780 if (s
->face
->underline_defaulted_p
)
2781 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2782 s
->x
, y
, s
->width
, thickness
);
2786 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2787 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2788 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2789 s
->x
, y
, s
->width
, thickness
);
2790 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2794 /* Draw overline. */
2795 if (s
->face
->overline_p
)
2797 unsigned long dy
= 0, h
= 1;
2799 if (s
->face
->overline_color_defaulted_p
)
2800 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2805 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2806 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2807 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2809 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2813 /* Draw strike-through. */
2814 if (s
->face
->strike_through_p
)
2816 unsigned long h
= 1;
2817 unsigned long dy
= (s
->height
- h
) / 2;
2819 if (s
->face
->strike_through_color_defaulted_p
)
2820 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2825 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2826 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2827 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2829 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2833 /* Draw relief if not yet drawn. */
2834 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2835 x_draw_glyph_string_box (s
);
2839 struct glyph_string
*prev
;
2841 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2842 if (prev
->hl
!= s
->hl
2843 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2845 /* As prev was drawn while clipped to its own area, we
2846 must draw the right_overhang part using s->hl now. */
2847 enum draw_glyphs_face save
= prev
->hl
;
2850 x_set_glyph_string_gc (prev
);
2851 x_set_glyph_string_clipping_exactly (s
, prev
);
2852 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2853 x_draw_glyph_string_foreground (prev
);
2855 x_draw_composite_glyph_string_foreground (prev
);
2856 XSetClipMask (prev
->display
, prev
->gc
, None
);
2858 prev
->num_clips
= 0;
2864 struct glyph_string
*next
;
2866 for (next
= s
->next
; next
; next
= next
->next
)
2867 if (next
->hl
!= s
->hl
2868 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2870 /* As next will be drawn while clipped to its own area,
2871 we must draw the left_overhang part using s->hl now. */
2872 enum draw_glyphs_face save
= next
->hl
;
2875 x_set_glyph_string_gc (next
);
2876 x_set_glyph_string_clipping_exactly (s
, next
);
2877 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2878 x_draw_glyph_string_foreground (next
);
2880 x_draw_composite_glyph_string_foreground (next
);
2881 XSetClipMask (next
->display
, next
->gc
, None
);
2883 next
->num_clips
= 0;
2884 next
->clip_head
= s
->next
;
2889 /* Reset clipping. */
2890 XSetClipMask (s
->display
, s
->gc
, None
);
2894 /* Shift display to make room for inserted glyphs. */
2897 x_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
, int width
, int height
, int shift_by
)
2899 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2900 f
->output_data
.x
->normal_gc
,
2901 x
, y
, width
, height
,
2905 /* Delete N glyphs at the nominal cursor position. Not implemented
2909 x_delete_glyphs (struct frame
*f
, register int n
)
2915 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2916 If they are <= 0, this is probably an error. */
2919 x_clear_area (Display
*dpy
, Window window
, int x
, int y
, int width
, int height
)
2921 eassert (width
> 0 && height
> 0);
2922 XClearArea (dpy
, window
, x
, y
, width
, height
, False
);
2926 /* Clear an entire frame. */
2929 x_clear_frame (struct frame
*f
)
2931 /* Clearing the frame will erase any cursor, so mark them all as no
2933 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2937 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2939 /* We have to clear the scroll bars. If we have changed colors or
2940 something like that, then they should be notified. */
2941 x_scroll_bar_clear (f
);
2943 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
2944 /* Make sure scroll bars are redrawn. As they aren't redrawn by
2945 redisplay, do it here. */
2946 if (FRAME_GTK_WIDGET (f
))
2947 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
2950 XFlush (FRAME_X_DISPLAY (f
));
2957 /* Invert the middle quarter of the frame for .15 sec. */
2960 XTflash (struct frame
*f
)
2966 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
2967 when the scroll bars and the edit widget share the same X window. */
2968 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
2970 cairo_t
*cr
= gdk_cairo_create (window
);
2971 cairo_set_source_rgb (cr
, 1, 1, 1);
2972 cairo_set_operator (cr
, CAIRO_OPERATOR_DIFFERENCE
);
2973 #define XFillRectangle(d, win, gc, x, y, w, h) \
2975 cairo_rectangle (cr, x, y, w, h); \
2979 #else /* ! HAVE_GTK3 */
2982 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
2983 ^ FRAME_BACKGROUND_PIXEL (f
));
2984 vals
.function
= GDK_XOR
;
2985 gc
= gdk_gc_new_with_values (window
,
2986 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
2987 #define XFillRectangle(d, win, gc, x, y, w, h) \
2988 gdk_draw_rectangle (window, gc, TRUE, x, y, w, h)
2989 #endif /* ! HAVE_GTK3 */
2990 #else /* ! USE_GTK */
2993 /* Create a GC that will use the GXxor function to flip foreground
2994 pixels into background pixels. */
2998 values
.function
= GXxor
;
2999 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
3000 ^ FRAME_BACKGROUND_PIXEL (f
));
3002 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3003 GCFunction
| GCForeground
, &values
);
3007 /* Get the height not including a menu bar widget. */
3008 int height
= FRAME_PIXEL_HEIGHT (f
);
3009 /* Height of each line to flash. */
3010 int flash_height
= FRAME_LINE_HEIGHT (f
);
3011 /* These will be the left and right margins of the rectangles. */
3012 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3013 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
3014 int width
= flash_right
- flash_left
;
3016 /* If window is tall, flash top and bottom line. */
3017 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3019 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3021 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3022 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3023 width
, flash_height
);
3024 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3026 (height
- flash_height
3027 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3028 width
, flash_height
);
3032 /* If it is short, flash it all. */
3033 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3034 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3035 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3040 struct timespec delay
= make_timespec (0, 150 * 1000 * 1000);
3041 struct timespec wakeup
= timespec_add (current_timespec (), delay
);
3043 /* Keep waiting until past the time wakeup or any input gets
3045 while (! detect_input_pending ())
3047 struct timespec current
= current_timespec ();
3048 struct timespec timeout
;
3050 /* Break if result would not be positive. */
3051 if (timespec_cmp (wakeup
, current
) <= 0)
3054 /* How long `select' should wait. */
3055 timeout
= make_timespec (0, 10 * 1000 * 1000);
3057 /* Try to wait that long--but we might wake up sooner. */
3058 pselect (0, NULL
, NULL
, NULL
, &timeout
, NULL
);
3062 /* If window is tall, flash top and bottom line. */
3063 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3065 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3067 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3068 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3069 width
, flash_height
);
3070 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3072 (height
- flash_height
3073 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3074 width
, flash_height
);
3077 /* If it is short, flash it all. */
3078 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3079 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3080 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3086 g_object_unref (G_OBJECT (gc
));
3088 #undef XFillRectangle
3090 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3101 XTtoggle_invisible_pointer (struct frame
*f
, int invisible
)
3104 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, invisible
);
3109 /* Make audible bell. */
3112 XTring_bell (struct frame
*f
)
3114 if (FRAME_X_DISPLAY (f
))
3122 XkbBell (FRAME_X_DISPLAY (f
), None
, 0, None
);
3124 XBell (FRAME_X_DISPLAY (f
), 0);
3126 XFlush (FRAME_X_DISPLAY (f
));
3132 /***********************************************************************
3134 ***********************************************************************/
3136 /* Perform an insert-lines or delete-lines operation, inserting N
3137 lines or deleting -N lines at vertical position VPOS. */
3140 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
3146 /* Scroll part of the display as described by RUN. */
3149 x_scroll_run (struct window
*w
, struct run
*run
)
3151 struct frame
*f
= XFRAME (w
->frame
);
3152 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3154 /* Get frame-relative bounding box of the text display area of W,
3155 without mode lines. Include in this box the left and right
3157 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
3159 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3160 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3161 bottom_y
= y
+ height
;
3165 /* Scrolling up. Make sure we don't copy part of the mode
3166 line at the bottom. */
3167 if (from_y
+ run
->height
> bottom_y
)
3168 height
= bottom_y
- from_y
;
3170 height
= run
->height
;
3174 /* Scrolling down. Make sure we don't copy over the mode line.
3176 if (to_y
+ run
->height
> bottom_y
)
3177 height
= bottom_y
- to_y
;
3179 height
= run
->height
;
3184 /* Cursor off. Will be switched on again in x_update_window_end. */
3187 XCopyArea (FRAME_X_DISPLAY (f
),
3188 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3189 f
->output_data
.x
->normal_gc
,
3199 /***********************************************************************
3201 ***********************************************************************/
3205 frame_highlight (struct frame
*f
)
3207 /* We used to only do this if Vx_no_window_manager was non-nil, but
3208 the ICCCM (section 4.1.6) says that the window's border pixmap
3209 and border pixel are window attributes which are "private to the
3210 client", so we can always change it to whatever we want. */
3212 /* I recently started to get errors in this XSetWindowBorder, depending on
3213 the window-manager in use, tho something more is at play since I've been
3214 using that same window-manager binary for ever. Let's not crash just
3215 because of this (bug#9310). */
3216 x_catch_errors (FRAME_X_DISPLAY (f
));
3217 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3218 f
->output_data
.x
->border_pixel
);
3219 x_uncatch_errors ();
3221 x_update_cursor (f
, 1);
3222 x_set_frame_alpha (f
);
3226 frame_unhighlight (struct frame
*f
)
3228 /* We used to only do this if Vx_no_window_manager was non-nil, but
3229 the ICCCM (section 4.1.6) says that the window's border pixmap
3230 and border pixel are window attributes which are "private to the
3231 client", so we can always change it to whatever we want. */
3233 /* Same as above for XSetWindowBorder (bug#9310). */
3234 x_catch_errors (FRAME_X_DISPLAY (f
));
3235 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3236 f
->output_data
.x
->border_tile
);
3237 x_uncatch_errors ();
3239 x_update_cursor (f
, 1);
3240 x_set_frame_alpha (f
);
3243 /* The focus has changed. Update the frames as necessary to reflect
3244 the new situation. Note that we can't change the selected frame
3245 here, because the Lisp code we are interrupting might become confused.
3246 Each event gets marked with the frame in which it occurred, so the
3247 Lisp code can tell when the switch took place by examining the events. */
3250 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
3252 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3254 if (frame
!= dpyinfo
->x_focus_frame
)
3256 /* Set this before calling other routines, so that they see
3257 the correct value of x_focus_frame. */
3258 dpyinfo
->x_focus_frame
= frame
;
3260 if (old_focus
&& old_focus
->auto_lower
)
3261 x_lower_frame (old_focus
);
3263 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3264 dpyinfo
->x_pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3266 dpyinfo
->x_pending_autoraise_frame
= NULL
;
3269 x_frame_rehighlight (dpyinfo
);
3272 /* Handle FocusIn and FocusOut state changes for FRAME.
3273 If FRAME has focus and there exists more than one frame, puts
3274 a FOCUS_IN_EVENT into *BUFP. */
3277 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
3279 if (type
== FocusIn
)
3281 if (dpyinfo
->x_focus_event_frame
!= frame
)
3283 x_new_focus_frame (dpyinfo
, frame
);
3284 dpyinfo
->x_focus_event_frame
= frame
;
3286 /* Don't stop displaying the initial startup message
3287 for a switch-frame event we don't need. */
3288 /* When run as a daemon, Vterminal_frame is always NIL. */
3289 bufp
->arg
= (((NILP (Vterminal_frame
)
3290 || ! FRAME_X_P (XFRAME (Vterminal_frame
))
3291 || EQ (Fdaemonp (), Qt
))
3292 && CONSP (Vframe_list
)
3293 && !NILP (XCDR (Vframe_list
)))
3295 bufp
->kind
= FOCUS_IN_EVENT
;
3296 XSETFRAME (bufp
->frame_or_window
, frame
);
3299 frame
->output_data
.x
->focus_state
|= state
;
3302 if (FRAME_XIC (frame
))
3303 XSetICFocus (FRAME_XIC (frame
));
3306 else if (type
== FocusOut
)
3308 frame
->output_data
.x
->focus_state
&= ~state
;
3310 if (dpyinfo
->x_focus_event_frame
== frame
)
3312 dpyinfo
->x_focus_event_frame
= 0;
3313 x_new_focus_frame (dpyinfo
, 0);
3315 bufp
->kind
= FOCUS_OUT_EVENT
;
3316 XSETFRAME (bufp
->frame_or_window
, frame
);
3320 if (FRAME_XIC (frame
))
3321 XUnsetICFocus (FRAME_XIC (frame
));
3323 if (frame
->pointer_invisible
)
3324 XTtoggle_invisible_pointer (frame
, 0);
3328 /* Return the Emacs frame-object corresponding to an X window.
3329 It could be the frame's main window or an icon window. */
3331 static struct frame
*
3332 x_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
3334 Lisp_Object tail
, frame
;
3340 FOR_EACH_FRAME (tail
, frame
)
3343 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
3345 if (f
->output_data
.x
->hourglass_window
== wdesc
)
3347 #ifdef USE_X_TOOLKIT
3348 if ((f
->output_data
.x
->edit_widget
3349 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
3350 /* A tooltip frame? */
3351 || (!f
->output_data
.x
->edit_widget
3352 && FRAME_X_WINDOW (f
) == wdesc
)
3353 || f
->output_data
.x
->icon_desc
== wdesc
)
3355 #else /* not USE_X_TOOLKIT */
3357 if (f
->output_data
.x
->edit_widget
)
3359 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
3360 struct x_output
*x
= f
->output_data
.x
;
3361 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
3364 #endif /* USE_GTK */
3365 if (FRAME_X_WINDOW (f
) == wdesc
3366 || f
->output_data
.x
->icon_desc
== wdesc
)
3368 #endif /* not USE_X_TOOLKIT */
3373 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3375 /* Like x_window_to_frame but also compares the window with the widget's
3378 static struct frame
*
3379 x_any_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
3381 Lisp_Object tail
, frame
;
3382 struct frame
*f
, *found
= NULL
;
3388 FOR_EACH_FRAME (tail
, frame
)
3393 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
3395 /* This frame matches if the window is any of its widgets. */
3396 x
= f
->output_data
.x
;
3397 if (x
->hourglass_window
== wdesc
)
3402 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
3404 && gtk_widget_get_toplevel (gwdesc
) == x
->widget
)
3407 if (wdesc
== XtWindow (x
->widget
)
3408 || wdesc
== XtWindow (x
->column_widget
)
3409 || wdesc
== XtWindow (x
->edit_widget
))
3411 /* Match if the window is this frame's menubar. */
3412 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
3416 else if (FRAME_X_WINDOW (f
) == wdesc
)
3417 /* A tooltip frame. */
3425 /* Likewise, but consider only the menu bar widget. */
3427 static struct frame
*
3428 x_menubar_window_to_frame (struct x_display_info
*dpyinfo
,
3429 const XEvent
*event
)
3431 Window wdesc
= event
->xany
.window
;
3432 Lisp_Object tail
, frame
;
3439 FOR_EACH_FRAME (tail
, frame
)
3442 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
3444 x
= f
->output_data
.x
;
3446 if (x
->menubar_widget
&& xg_event_is_for_menubar (f
, event
))
3449 /* Match if the window is this frame's menubar. */
3450 if (x
->menubar_widget
3451 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
3458 /* Return the frame whose principal (outermost) window is WDESC.
3459 If WDESC is some other (smaller) window, we return 0. */
3462 x_top_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
3464 Lisp_Object tail
, frame
;
3471 FOR_EACH_FRAME (tail
, frame
)
3474 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
3476 x
= f
->output_data
.x
;
3480 /* This frame matches if the window is its topmost widget. */
3482 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
3483 if (gwdesc
== x
->widget
)
3486 if (wdesc
== XtWindow (x
->widget
))
3490 else if (FRAME_X_WINDOW (f
) == wdesc
)
3491 /* Tooltip frame. */
3497 #else /* !USE_X_TOOLKIT && !USE_GTK */
3499 #define x_any_window_to_frame(d, i) x_window_to_frame (d, i)
3500 #define x_top_window_to_frame(d, i) x_window_to_frame (d, i)
3502 #endif /* USE_X_TOOLKIT || USE_GTK */
3504 /* The focus may have changed. Figure out if it is a real focus change,
3505 by checking both FocusIn/Out and Enter/LeaveNotify events.
3507 Returns FOCUS_IN_EVENT event in *BUFP. */
3510 x_detect_focus_change (struct x_display_info
*dpyinfo
, struct frame
*frame
,
3511 const XEvent
*event
, struct input_event
*bufp
)
3516 switch (event
->type
)
3521 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3523 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3525 if (event
->xcrossing
.detail
!= NotifyInferior
3526 && event
->xcrossing
.focus
3527 && ! (focus_state
& FOCUS_EXPLICIT
))
3528 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3530 dpyinfo
, frame
, bufp
);
3536 x_focus_changed (event
->type
,
3537 (event
->xfocus
.detail
== NotifyPointer
?
3538 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3539 dpyinfo
, frame
, bufp
);
3543 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
3545 enum xembed_message msg
= event
->xclient
.data
.l
[1];
3546 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
3547 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
3554 #if !defined USE_X_TOOLKIT && !defined USE_GTK
3555 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3558 x_mouse_leave (struct x_display_info
*dpyinfo
)
3560 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3564 /* The focus has changed, or we have redirected a frame's focus to
3565 another frame (this happens when a frame uses a surrogate
3566 mini-buffer frame). Shift the highlight as appropriate.
3568 The FRAME argument doesn't necessarily have anything to do with which
3569 frame is being highlighted or un-highlighted; we only use it to find
3570 the appropriate X display info. */
3573 XTframe_rehighlight (struct frame
*frame
)
3575 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
3579 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
3581 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3583 if (dpyinfo
->x_focus_frame
)
3585 dpyinfo
->x_highlight_frame
3586 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3587 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3588 : dpyinfo
->x_focus_frame
);
3589 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3591 fset_focus_frame (dpyinfo
->x_focus_frame
, Qnil
);
3592 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3596 dpyinfo
->x_highlight_frame
= 0;
3598 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3601 frame_unhighlight (old_highlight
);
3602 if (dpyinfo
->x_highlight_frame
)
3603 frame_highlight (dpyinfo
->x_highlight_frame
);
3609 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3611 /* Initialize mode_switch_bit and modifier_meaning. */
3613 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
3615 int min_code
, max_code
;
3618 XModifierKeymap
*mods
;
3620 dpyinfo
->meta_mod_mask
= 0;
3621 dpyinfo
->shift_lock_mask
= 0;
3622 dpyinfo
->alt_mod_mask
= 0;
3623 dpyinfo
->super_mod_mask
= 0;
3624 dpyinfo
->hyper_mod_mask
= 0;
3626 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3628 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3629 min_code
, max_code
- min_code
+ 1,
3631 mods
= XGetModifierMapping (dpyinfo
->display
);
3633 /* Scan the modifier table to see which modifier bits the Meta and
3634 Alt keysyms are on. */
3636 int row
, col
; /* The row and column in the modifier table. */
3637 int found_alt_or_meta
;
3639 for (row
= 3; row
< 8; row
++)
3641 found_alt_or_meta
= 0;
3642 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3644 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3646 /* Zeroes are used for filler. Skip them. */
3650 /* Are any of this keycode's keysyms a meta key? */
3654 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3656 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3662 found_alt_or_meta
= 1;
3663 dpyinfo
->meta_mod_mask
|= (1 << row
);
3668 found_alt_or_meta
= 1;
3669 dpyinfo
->alt_mod_mask
|= (1 << row
);
3674 if (!found_alt_or_meta
)
3675 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3676 code_col
= syms_per_code
;
3677 col
= mods
->max_keypermod
;
3682 if (!found_alt_or_meta
)
3683 dpyinfo
->super_mod_mask
|= (1 << row
);
3684 code_col
= syms_per_code
;
3685 col
= mods
->max_keypermod
;
3689 /* Ignore this if it's not on the lock modifier. */
3690 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3691 dpyinfo
->shift_lock_mask
= LockMask
;
3692 code_col
= syms_per_code
;
3693 col
= mods
->max_keypermod
;
3702 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3703 if (! dpyinfo
->meta_mod_mask
)
3705 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3706 dpyinfo
->alt_mod_mask
= 0;
3709 /* If some keys are both alt and meta,
3710 make them just meta, not alt. */
3711 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3713 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3717 XFreeModifiermap (mods
);
3720 /* Convert between the modifier bits X uses and the modifier bits
3724 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, int state
)
3726 int mod_meta
= meta_modifier
;
3727 int mod_alt
= alt_modifier
;
3728 int mod_hyper
= hyper_modifier
;
3729 int mod_super
= super_modifier
;
3732 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3733 if (INTEGERP (tem
)) mod_alt
= XINT (tem
) & INT_MAX
;
3734 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3735 if (INTEGERP (tem
)) mod_meta
= XINT (tem
) & INT_MAX
;
3736 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3737 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
) & INT_MAX
;
3738 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3739 if (INTEGERP (tem
)) mod_super
= XINT (tem
) & INT_MAX
;
3741 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3742 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3743 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3744 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3745 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3746 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3750 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, EMACS_INT state
)
3752 EMACS_INT mod_meta
= meta_modifier
;
3753 EMACS_INT mod_alt
= alt_modifier
;
3754 EMACS_INT mod_hyper
= hyper_modifier
;
3755 EMACS_INT mod_super
= super_modifier
;
3759 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3760 if (INTEGERP (tem
)) mod_alt
= XINT (tem
);
3761 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3762 if (INTEGERP (tem
)) mod_meta
= XINT (tem
);
3763 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3764 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
);
3765 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3766 if (INTEGERP (tem
)) mod_super
= XINT (tem
);
3769 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3770 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3771 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3772 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3773 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3774 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3777 /* Convert a keysym to its name. */
3780 x_get_keysym_name (int keysym
)
3785 value
= XKeysymToString (keysym
);
3791 /* Mouse clicks and mouse movement. Rah.
3793 Formerly, we used PointerMotionHintMask (in standard_event_mask)
3794 so that we would have to call XQueryPointer after each MotionNotify
3795 event to ask for another such event. However, this made mouse tracking
3796 slow, and there was a bug that made it eventually stop.
3798 Simply asking for MotionNotify all the time seems to work better.
3800 In order to avoid asking for motion events and then throwing most
3801 of them away or busy-polling the server for mouse positions, we ask
3802 the server for pointer motion hints. This means that we get only
3803 one event per group of mouse movements. "Groups" are delimited by
3804 other kinds of events (focus changes and button clicks, for
3805 example), or by XQueryPointer calls; when one of these happens, we
3806 get another MotionNotify event the next time the mouse moves. This
3807 is at least as efficient as getting motion events when mouse
3808 tracking is on, and I suspect only negligibly worse when tracking
3811 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3813 If the event is a button press, then note that we have grabbed
3817 construct_mouse_click (struct input_event
*result
,
3818 const XButtonEvent
*event
,
3821 /* Make the event type NO_EVENT; we'll change that when we decide
3823 result
->kind
= MOUSE_CLICK_EVENT
;
3824 result
->code
= event
->button
- Button1
;
3825 result
->timestamp
= event
->time
;
3826 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
),
3828 | (event
->type
== ButtonRelease
3832 XSETINT (result
->x
, event
->x
);
3833 XSETINT (result
->y
, event
->y
);
3834 XSETFRAME (result
->frame_or_window
, f
);
3839 /* Function to report a mouse movement to the mainstream Emacs code.
3840 The input handler calls this.
3842 We have received a mouse movement event, which is given in *event.
3843 If the mouse is over a different glyph than it was last time, tell
3844 the mainstream emacs code by setting mouse_moved. If not, ask for
3845 another motion event, so we can check again the next time it moves. */
3848 note_mouse_movement (struct frame
*frame
, const XMotionEvent
*event
)
3851 struct x_display_info
*dpyinfo
;
3853 if (!FRAME_X_OUTPUT (frame
))
3856 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
3857 dpyinfo
->last_mouse_movement_time
= event
->time
;
3858 dpyinfo
->last_mouse_motion_frame
= frame
;
3859 dpyinfo
->last_mouse_motion_x
= event
->x
;
3860 dpyinfo
->last_mouse_motion_y
= event
->y
;
3862 if (event
->window
!= FRAME_X_WINDOW (frame
))
3864 frame
->mouse_moved
= 1;
3865 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3866 note_mouse_highlight (frame
, -1, -1);
3867 dpyinfo
->last_mouse_glyph_frame
= NULL
;
3872 /* Has the mouse moved off the glyph it was on at the last sighting? */
3873 r
= &dpyinfo
->last_mouse_glyph
;
3874 if (frame
!= dpyinfo
->last_mouse_glyph_frame
3875 || event
->x
< r
->x
|| event
->x
>= r
->x
+ r
->width
3876 || event
->y
< r
->y
|| event
->y
>= r
->y
+ r
->height
)
3878 frame
->mouse_moved
= 1;
3879 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3880 note_mouse_highlight (frame
, event
->x
, event
->y
);
3881 /* Remember which glyph we're now on. */
3882 remember_mouse_glyph (frame
, event
->x
, event
->y
, r
);
3883 dpyinfo
->last_mouse_glyph_frame
= frame
;
3890 /* Return the current position of the mouse.
3891 *FP should be a frame which indicates which display to ask about.
3893 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3894 and *PART to the frame, window, and scroll bar part that the mouse
3895 is over. Set *X and *Y to the portion and whole of the mouse's
3896 position on the scroll bar.
3898 If the mouse movement started elsewhere, set *FP to the frame the
3899 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3902 Set *TIMESTAMP to the server time-stamp for the time at which the mouse
3903 was at this position.
3905 Don't store anything if we don't have a valid set of values to report.
3907 This clears the mouse_moved flag, so we can wait for the next mouse
3911 XTmouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
3912 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
3916 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
3920 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
3921 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
3927 Window dummy_window
;
3930 Lisp_Object frame
, tail
;
3932 /* Clear the mouse-moved flag for every frame on this display. */
3933 FOR_EACH_FRAME (tail
, frame
)
3934 if (FRAME_X_P (XFRAME (frame
))
3935 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3936 XFRAME (frame
)->mouse_moved
= 0;
3938 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3940 /* Figure out which root window we're on. */
3941 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3942 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3944 /* The root window which contains the pointer. */
3947 /* Trash which we can't trust if the pointer is on
3948 a different screen. */
3951 /* The position on that root window. */
3954 /* More trash we can't trust. */
3957 /* Modifier keys and pointer buttons, about which
3959 (unsigned int *) &dummy
);
3961 /* Now we have a position on the root; find the innermost window
3962 containing the pointer. */
3966 int parent_x
= 0, parent_y
= 0;
3970 /* XTranslateCoordinates can get errors if the window
3971 structure is changing at the same time this function
3972 is running. So at least we must not crash from them. */
3974 x_catch_errors (FRAME_X_DISPLAY (*fp
));
3976 if (x_mouse_grabbed (dpyinfo
))
3978 /* If mouse was grabbed on a frame, give coords for that frame
3979 even if the mouse is now outside it. */
3980 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3986 FRAME_X_WINDOW (dpyinfo
->last_mouse_frame
),
3988 /* From-position, to-position. */
3989 root_x
, root_y
, &win_x
, &win_y
,
3993 f1
= dpyinfo
->last_mouse_frame
;
3999 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4001 /* From-window, to-window. */
4004 /* From-position, to-position. */
4005 root_x
, root_y
, &win_x
, &win_y
,
4010 if (child
== None
|| child
== win
)
4013 /* We don't wan't to know the innermost window. We
4014 want the edit window. For non-Gtk+ the innermost
4015 window is the edit window. For Gtk+ it might not
4016 be. It might be the tool bar for example. */
4017 if (x_window_to_frame (dpyinfo
, win
))
4025 /* Now we know that:
4026 win is the innermost window containing the pointer
4027 (XTC says it has no child containing the pointer),
4028 win_x and win_y are the pointer's position in it
4029 (XTC did this the last time through), and
4030 parent_x and parent_y are the pointer's position in win's parent.
4031 (They are what win_x and win_y were when win was child.
4032 If win is the root window, it has no parent, and
4033 parent_{x,y} are invalid, but that's okay, because we'll
4034 never use them in that case.) */
4037 /* We don't wan't to know the innermost window. We
4038 want the edit window. */
4039 f1
= x_window_to_frame (dpyinfo
, win
);
4041 /* Is win one of our frames? */
4042 f1
= x_any_window_to_frame (dpyinfo
, win
);
4045 #ifdef USE_X_TOOLKIT
4046 /* If we end up with the menu bar window, say it's not
4049 && f1
->output_data
.x
->menubar_widget
4050 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
4052 #endif /* USE_X_TOOLKIT */
4055 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
4058 x_uncatch_errors ();
4060 /* If not, is it one of our scroll bars? */
4063 struct scroll_bar
*bar
;
4065 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
4069 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4075 if (f1
== 0 && insist
> 0)
4076 f1
= SELECTED_FRAME ();
4080 /* Ok, we found a frame. Store all the values.
4081 last_mouse_glyph is a rectangle used to reduce the
4082 generation of mouse events. To not miss any motion
4083 events, we must divide the frame into rectangles of the
4084 size of the smallest character that could be displayed
4085 on it, i.e. into the same rectangles that matrices on
4086 the frame are divided into. */
4088 /* FIXME: what if F1 is not an X frame? */
4089 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
4090 remember_mouse_glyph (f1
, win_x
, win_y
, &dpyinfo
->last_mouse_glyph
);
4091 dpyinfo
->last_mouse_glyph_frame
= f1
;
4096 XSETINT (*x
, win_x
);
4097 XSETINT (*y
, win_y
);
4098 *timestamp
= dpyinfo
->last_mouse_movement_time
;
4108 /***********************************************************************
4110 ***********************************************************************/
4112 /* Scroll bar support. */
4114 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
4116 This can be called in GC, so we have to make sure to strip off mark
4119 static struct scroll_bar
*
4120 x_window_to_scroll_bar (Display
*display
, Window window_id
)
4122 Lisp_Object tail
, frame
;
4124 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
4125 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
4126 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
4128 FOR_EACH_FRAME (tail
, frame
)
4130 Lisp_Object bar
, condemned
;
4132 if (! FRAME_X_P (XFRAME (frame
)))
4135 /* Scan this frame's scroll bar list for a scroll bar with the
4137 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
4138 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
4139 /* This trick allows us to search both the ordinary and
4140 condemned scroll bar lists with one loop. */
4141 ! NILP (bar
) || (bar
= condemned
,
4144 bar
= XSCROLL_BAR (bar
)->next
)
4145 if (XSCROLL_BAR (bar
)->x_window
== window_id
&&
4146 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
4147 return XSCROLL_BAR (bar
);
4154 #if defined USE_LUCID
4156 /* Return the Lucid menu bar WINDOW is part of. Return null
4157 if WINDOW is not part of a menu bar. */
4160 x_window_to_menu_bar (Window window
)
4162 Lisp_Object tail
, frame
;
4164 FOR_EACH_FRAME (tail
, frame
)
4165 if (FRAME_X_P (XFRAME (frame
)))
4167 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
4169 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
4175 #endif /* USE_LUCID */
4178 /************************************************************************
4180 ************************************************************************/
4182 #ifdef USE_TOOLKIT_SCROLL_BARS
4184 static void x_send_scroll_bar_event (Lisp_Object
, int, int, int);
4186 /* Lisp window being scrolled. Set when starting to interact with
4187 a toolkit scroll bar, reset to nil when ending the interaction. */
4189 static Lisp_Object window_being_scrolled
;
4191 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4192 that movements of 1/20 of the screen size are mapped to up/down. */
4195 /* Id of action hook installed for scroll bars. */
4197 static XtActionHookId action_hook_id
;
4199 static Boolean xaw3d_arrow_scroll
;
4201 /* Whether the drag scrolling maintains the mouse at the top of the
4202 thumb. If not, resizing the thumb needs to be done more carefully
4203 to avoid jerkiness. */
4205 static Boolean xaw3d_pick_top
;
4207 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4208 bars are used.. The hook is responsible for detecting when
4209 the user ends an interaction with the scroll bar, and generates
4210 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4213 xt_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
4214 XEvent
*event
, String
*params
, Cardinal
*num_params
)
4217 const char *end_action
;
4220 scroll_bar_p
= XmIsScrollBar (widget
);
4221 end_action
= "Release";
4222 #else /* !USE_MOTIF i.e. use Xaw */
4223 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4224 end_action
= "EndScroll";
4225 #endif /* USE_MOTIF */
4228 && strcmp (action_name
, end_action
) == 0
4229 && WINDOWP (window_being_scrolled
))
4232 struct scroll_bar
*bar
;
4234 x_send_scroll_bar_event (window_being_scrolled
,
4235 scroll_bar_end_scroll
, 0, 0);
4236 w
= XWINDOW (window_being_scrolled
);
4237 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4239 if (bar
->dragging
!= -1)
4242 /* The thumb size is incorrect while dragging: fix it. */
4243 set_vertical_scroll_bar (w
);
4245 window_being_scrolled
= Qnil
;
4246 #if defined (USE_LUCID)
4247 bar
->last_seen_part
= scroll_bar_nowhere
;
4249 /* Xt timeouts no longer needed. */
4250 toolkit_scroll_bar_interaction
= 0;
4253 #endif /* not USE_GTK */
4255 /* Send a client message with message type Xatom_Scrollbar for a
4256 scroll action to the frame of WINDOW. PART is a value identifying
4257 the part of the scroll bar that was clicked on. PORTION is the
4258 amount to scroll of a whole of WHOLE. */
4261 x_send_scroll_bar_event (Lisp_Object window
, int part
, int portion
, int whole
)
4264 XClientMessageEvent
*ev
= &event
.xclient
;
4265 struct window
*w
= XWINDOW (window
);
4266 struct frame
*f
= XFRAME (w
->frame
);
4267 intptr_t iw
= (intptr_t) w
;
4268 enum { BITS_PER_INTPTR
= CHAR_BIT
* sizeof iw
};
4269 verify (BITS_PER_INTPTR
<= 64);
4270 int sign_shift
= BITS_PER_INTPTR
- 32;
4274 /* Construct a ClientMessage event to send to the frame. */
4275 ev
->type
= ClientMessage
;
4276 ev
->message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4277 ev
->display
= FRAME_X_DISPLAY (f
);
4278 ev
->window
= FRAME_X_WINDOW (f
);
4281 /* A 32-bit X client on a 64-bit X server can pass a window pointer
4282 as-is. A 64-bit client on a 32-bit X server is in trouble
4283 because a pointer does not fit and would be truncated while
4284 passing through the server. So use two slots and hope that X12
4285 will resolve such issues someday. */
4286 ev
->data
.l
[0] = iw
>> 31 >> 1;
4287 ev
->data
.l
[1] = sign_shift
<= 0 ? iw
: iw
<< sign_shift
>> sign_shift
;
4288 ev
->data
.l
[2] = part
;
4289 ev
->data
.l
[3] = portion
;
4290 ev
->data
.l
[4] = whole
;
4292 /* Make Xt timeouts work while the scroll bar is active. */
4293 #ifdef USE_X_TOOLKIT
4294 toolkit_scroll_bar_interaction
= 1;
4295 x_activate_timeout_atimer ();
4298 /* Setting the event mask to zero means that the message will
4299 be sent to the client that created the window, and if that
4300 window no longer exists, no event will be sent. */
4301 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4306 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4310 x_scroll_bar_to_input_event (const XEvent
*event
,
4311 struct input_event
*ievent
)
4313 const XClientMessageEvent
*ev
= &event
->xclient
;
4317 /* See the comment in the function above. */
4318 intptr_t iw0
= ev
->data
.l
[0];
4319 intptr_t iw1
= ev
->data
.l
[1];
4320 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
4321 w
= (struct window
*) iw
;
4323 XSETWINDOW (window
, w
);
4325 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4326 ievent
->frame_or_window
= window
;
4329 ievent
->timestamp
= CurrentTime
;
4332 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
4335 ievent
->part
= ev
->data
.l
[2];
4336 ievent
->x
= make_number (ev
->data
.l
[3]);
4337 ievent
->y
= make_number (ev
->data
.l
[4]);
4338 ievent
->modifiers
= 0;
4344 /* Minimum and maximum values used for Motif scroll bars. */
4346 #define XM_SB_MAX 10000000
4349 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4350 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4351 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4354 xm_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4356 struct scroll_bar
*bar
= client_data
;
4357 XmScrollBarCallbackStruct
*cs
= call_data
;
4358 int part
= -1, whole
= 0, portion
= 0;
4362 case XmCR_DECREMENT
:
4364 part
= scroll_bar_up_arrow
;
4367 case XmCR_INCREMENT
:
4369 part
= scroll_bar_down_arrow
;
4372 case XmCR_PAGE_DECREMENT
:
4374 part
= scroll_bar_above_handle
;
4377 case XmCR_PAGE_INCREMENT
:
4379 part
= scroll_bar_below_handle
;
4384 part
= scroll_bar_to_top
;
4387 case XmCR_TO_BOTTOM
:
4389 part
= scroll_bar_to_bottom
;
4396 /* Get the slider size. */
4398 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4401 whole
= XM_SB_MAX
- slider_size
;
4402 portion
= min (cs
->value
, whole
);
4403 part
= scroll_bar_handle
;
4404 bar
->dragging
= cs
->value
;
4408 case XmCR_VALUE_CHANGED
:
4414 window_being_scrolled
= bar
->window
;
4415 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4419 #elif defined USE_GTK
4421 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4422 bar widget. DATA is a pointer to the scroll_bar structure. */
4425 xg_scroll_callback (GtkRange
*range
,
4426 GtkScrollType scroll
,
4430 struct scroll_bar
*bar
= user_data
;
4431 int part
= -1, whole
= 0, portion
= 0;
4432 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
4433 struct frame
*f
= g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
4435 if (xg_ignore_gtk_scrollbar
) return FALSE
;
4439 case GTK_SCROLL_JUMP
:
4440 /* Buttons 1 2 or 3 must be grabbed. */
4441 if (FRAME_DISPLAY_INFO (f
)->grabbed
!= 0
4442 && FRAME_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
4444 part
= scroll_bar_handle
;
4445 whole
= gtk_adjustment_get_upper (adj
) -
4446 gtk_adjustment_get_page_size (adj
);
4447 portion
= min ((int)value
, whole
);
4448 bar
->dragging
= portion
;
4451 case GTK_SCROLL_STEP_BACKWARD
:
4452 part
= scroll_bar_up_arrow
;
4455 case GTK_SCROLL_STEP_FORWARD
:
4456 part
= scroll_bar_down_arrow
;
4459 case GTK_SCROLL_PAGE_BACKWARD
:
4460 part
= scroll_bar_above_handle
;
4463 case GTK_SCROLL_PAGE_FORWARD
:
4464 part
= scroll_bar_below_handle
;
4471 window_being_scrolled
= bar
->window
;
4472 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4478 /* Callback for button release. Sets dragging to -1 when dragging is done. */
4481 xg_end_scroll_callback (GtkWidget
*widget
,
4482 GdkEventButton
*event
,
4485 struct scroll_bar
*bar
= user_data
;
4487 if (WINDOWP (window_being_scrolled
))
4489 x_send_scroll_bar_event (window_being_scrolled
,
4490 scroll_bar_end_scroll
, 0, 0);
4491 window_being_scrolled
= Qnil
;
4498 #else /* not USE_GTK and not USE_MOTIF */
4500 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4501 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4502 scroll bar struct. CALL_DATA is a pointer to a float saying where
4506 xaw_jump_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4508 struct scroll_bar
*bar
= client_data
;
4509 float *top_addr
= call_data
;
4510 float top
= *top_addr
;
4512 int whole
, portion
, height
;
4513 enum scroll_bar_part part
;
4515 /* Get the size of the thumb, a value between 0 and 1. */
4517 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4521 portion
= shown
< 1 ? top
* whole
: 0;
4523 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0f
/ height
))
4524 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4525 the bottom, so we force the scrolling whenever we see that we're
4526 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4527 we try to ensure that we always stay two pixels away from the
4529 part
= scroll_bar_down_arrow
;
4531 part
= scroll_bar_handle
;
4533 window_being_scrolled
= bar
->window
;
4534 bar
->dragging
= portion
;
4535 bar
->last_seen_part
= part
;
4536 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4540 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4541 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4542 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4543 the scroll bar. CALL_DATA is an integer specifying the action that
4544 has taken place. Its magnitude is in the range 0..height of the
4545 scroll bar. Negative values mean scroll towards buffer start.
4546 Values < height of scroll bar mean line-wise movement. */
4549 xaw_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4551 struct scroll_bar
*bar
= client_data
;
4552 /* The position really is stored cast to a pointer. */
4553 int position
= (intptr_t) call_data
;
4555 enum scroll_bar_part part
;
4557 /* Get the height of the scroll bar. */
4559 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4562 if (eabs (position
) >= height
)
4563 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4565 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4566 it maps line-movement to call_data = max(5, height/20). */
4567 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
4568 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4570 part
= scroll_bar_move_ratio
;
4572 window_being_scrolled
= bar
->window
;
4574 bar
->last_seen_part
= part
;
4575 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4578 #endif /* not USE_GTK and not USE_MOTIF */
4580 #define SCROLL_BAR_NAME "verticalScrollBar"
4582 /* Create the widget for scroll bar BAR on frame F. Record the widget
4583 and X window of the scroll bar in BAR. */
4587 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4589 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
4592 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4593 G_CALLBACK (xg_end_scroll_callback
),
4598 #else /* not USE_GTK */
4601 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4607 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
4608 unsigned long pixel
;
4613 /* Set resources. Create the widget. */
4614 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4615 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4616 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4617 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4618 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4619 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4620 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4622 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4625 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4629 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4632 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4636 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4637 (char *) scroll_bar_name
, av
, ac
);
4639 /* Add one callback for everything that can happen. */
4640 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4642 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4644 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4646 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4648 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4650 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4652 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4655 /* Realize the widget. Only after that is the X window created. */
4656 XtRealizeWidget (widget
);
4658 /* Set the cursor to an arrow. I didn't find a resource to do that.
4659 And I'm wondering why it hasn't an arrow cursor by default. */
4660 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4661 f
->output_data
.x
->nontext_cursor
);
4663 #else /* !USE_MOTIF i.e. use Xaw */
4665 /* Set resources. Create the widget. The background of the
4666 Xaw3d scroll bar widget is a little bit light for my taste.
4667 We don't alter it here to let users change it according
4668 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4669 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4670 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4671 /* For smoother scrolling with Xaw3d -sm */
4672 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4674 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4677 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4681 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4684 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4688 /* Top/bottom shadow colors. */
4690 /* Allocate them, if necessary. */
4691 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4693 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4696 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4697 FRAME_X_COLORMAP (f
),
4698 &pixel
, 1.2, 0x8000))
4700 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4703 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4705 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4708 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4709 FRAME_X_COLORMAP (f
),
4710 &pixel
, 0.6, 0x4000))
4712 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4716 #ifdef XtNbeNiceToColormap
4717 /* Tell the toolkit about them. */
4718 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4719 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4720 /* We tried to allocate a color for the top/bottom shadow, and
4721 failed, so tell Xaw3d to use dithering instead. */
4722 /* But only if we have a small colormap. Xaw3d can allocate nice
4725 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
4726 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
4730 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4731 be more consistent with other emacs 3d colors, and since Xaw3d is
4732 not good at dealing with allocation failure. */
4734 /* This tells Xaw3d to use real colors instead of dithering for
4736 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4739 /* Specify the colors. */
4740 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4743 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4746 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4749 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4755 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4756 f
->output_data
.x
->edit_widget
, av
, ac
);
4759 char const *initial
= "";
4760 char const *val
= initial
;
4761 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4762 #ifdef XtNarrowScrollbars
4763 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4765 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4766 if (xaw3d_arrow_scroll
|| val
== initial
)
4767 { /* ARROW_SCROLL */
4768 xaw3d_arrow_scroll
= True
;
4769 /* Isn't that just a personal preference ? --Stef */
4770 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4774 /* Define callbacks. */
4775 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4776 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4779 /* Realize the widget. Only after that is the X window created. */
4780 XtRealizeWidget (widget
);
4782 #endif /* !USE_MOTIF */
4784 /* Install an action hook that lets us detect when the user
4785 finishes interacting with a scroll bar. */
4786 if (action_hook_id
== 0)
4787 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4789 /* Remember X window and widget in the scroll bar vector. */
4790 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4791 xwindow
= XtWindow (widget
);
4792 bar
->x_window
= xwindow
;
4796 #endif /* not USE_GTK */
4799 /* Set the thumb size and position of scroll bar BAR. We are currently
4800 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4804 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
4806 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4809 #else /* not USE_GTK */
4811 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
4814 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4815 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4822 if (scroll_bar_adjust_thumb_portion_p
)
4824 /* We use an estimate of 30 chars per line rather than the real
4825 `portion' value. This has the disadvantage that the thumb size
4826 is not very representative, but it makes our life a lot easier.
4827 Otherwise, we have to constantly adjust the thumb size, which
4828 we can't always do quickly enough: while dragging, the size of
4829 the thumb might prevent the user from dragging the thumb all the
4830 way to the end. but Motif and some versions of Xaw3d don't allow
4831 updating the thumb size while dragging. Also, even if we can update
4832 its size, the update will often happen too late.
4833 If you don't believe it, check out revision 1.650 of xterm.c to see
4834 what hoops we were going through and the still poor behavior we got. */
4835 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4836 /* When the thumb is at the bottom, position == whole.
4837 So we need to increase `whole' to make space for the thumb. */
4845 top
= (float) position
/ whole
;
4846 shown
= (float) portion
/ whole
;
4849 if (bar
->dragging
== -1)
4853 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4854 is the scroll bar's maximum and MIN is the scroll bar's minimum
4856 size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
4858 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4859 value
= top
* XM_SB_MAX
;
4860 value
= min (value
, XM_SB_MAX
- size
);
4862 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4864 #else /* !USE_MOTIF i.e. use Xaw */
4870 top
= (float) position
/ whole
;
4871 shown
= (float) portion
/ whole
;
4875 float old_top
, old_shown
;
4877 XtVaGetValues (widget
,
4878 XtNtopOfThumb
, &old_top
,
4879 XtNshown
, &old_shown
,
4883 /* Massage the top+shown values. */
4884 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
4885 top
= max (0, min (1, top
));
4888 #if ! defined (HAVE_XAW3D)
4889 /* With Xaw, 'top' values too closer to 1.0 may
4890 cause the thumb to disappear. Fix that. */
4891 top
= min (top
, 0.99f
);
4893 /* Keep two pixels available for moving the thumb down. */
4894 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
4895 #if ! defined (HAVE_XAW3D)
4896 /* Likewise with too small 'shown'. */
4897 shown
= max (shown
, 0.01f
);
4900 /* If the call to XawScrollbarSetThumb below doesn't seem to
4901 work, check that 'NARROWPROTO' is defined in src/config.h.
4902 If this is not so, most likely you need to fix configure. */
4903 if (top
!= old_top
|| shown
!= old_shown
)
4905 if (bar
->dragging
== -1)
4906 XawScrollbarSetThumb (widget
, top
, shown
);
4909 /* Try to make the scrolling a tad smoother. */
4910 if (!xaw3d_pick_top
)
4911 shown
= min (shown
, old_shown
);
4913 XawScrollbarSetThumb (widget
, top
, shown
);
4917 #endif /* !USE_MOTIF */
4921 #endif /* not USE_GTK */
4923 #endif /* USE_TOOLKIT_SCROLL_BARS */
4927 /************************************************************************
4928 Scroll bars, general
4929 ************************************************************************/
4931 /* Create a scroll bar and return the scroll bar vector for it. W is
4932 the Emacs window on which to create the scroll bar. TOP, LEFT,
4933 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4936 static struct scroll_bar
*
4937 x_scroll_bar_create (struct window
*w
, int top
, int left
, int width
, int height
)
4939 struct frame
*f
= XFRAME (w
->frame
);
4940 struct scroll_bar
*bar
4941 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
4946 #ifdef USE_TOOLKIT_SCROLL_BARS
4947 x_create_toolkit_scroll_bar (f
, bar
);
4948 #else /* not USE_TOOLKIT_SCROLL_BARS */
4950 XSetWindowAttributes a
;
4954 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4955 if (a
.background_pixel
== -1)
4956 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
4958 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4959 | ButtonMotionMask
| PointerMotionHintMask
4961 a
.cursor
= FRAME_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4963 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4965 /* Clear the area of W that will serve as a scroll bar. This is
4966 for the case that a window has been split horizontally. In
4967 this case, no clear_frame is generated to reduce flickering. */
4968 if (width
> 0 && window_box_height (w
) > 0)
4969 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4970 left
, top
, width
, window_box_height (w
));
4972 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4973 /* Position and size of scroll bar. */
4974 left
, top
, width
, height
,
4975 /* Border width, depth, class, and visual. */
4982 bar
->x_window
= window
;
4984 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4986 XSETWINDOW (bar
->window
, w
);
4990 bar
->height
= height
;
4994 #if defined (USE_TOOLKIT_SCROLL_BARS) && defined (USE_LUCID)
4995 bar
->last_seen_part
= scroll_bar_nowhere
;
4998 /* Add bar to its frame's list of scroll bars. */
4999 bar
->next
= FRAME_SCROLL_BARS (f
);
5001 XSETVECTOR (barobj
, bar
);
5002 fset_scroll_bars (f
, barobj
);
5003 if (!NILP (bar
->next
))
5004 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5006 /* Map the window/widget. */
5007 #ifdef USE_TOOLKIT_SCROLL_BARS
5010 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
5011 left
,width
, max (height
, 1));
5012 #else /* not USE_GTK */
5013 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
5014 XtConfigureWidget (scroll_bar
, left
, top
, width
, max (height
, 1), 0);
5015 XtMapWidget (scroll_bar
);
5016 #endif /* not USE_GTK */
5018 #else /* not USE_TOOLKIT_SCROLL_BARS */
5019 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
5020 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5027 #ifndef USE_TOOLKIT_SCROLL_BARS
5029 /* Draw BAR's handle in the proper position.
5031 If the handle is already drawn from START to END, don't bother
5032 redrawing it, unless REBUILD is non-zero; in that case, always
5033 redraw it. (REBUILD is handy for drawing the handle after expose
5036 Normally, we want to constrain the start and end of the handle to
5037 fit inside its rectangle, but if the user is dragging the scroll
5038 bar handle, we want to let them drag it down all the way, so that
5039 the bar's top is as far down as it goes; otherwise, there's no way
5040 to move to the very end of the buffer. */
5043 x_scroll_bar_set_handle (struct scroll_bar
*bar
, int start
, int end
, int rebuild
)
5045 bool dragging
= bar
->dragging
!= -1;
5046 Window w
= bar
->x_window
;
5047 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5048 GC gc
= f
->output_data
.x
->normal_gc
;
5050 /* If the display is already accurate, do nothing. */
5052 && start
== bar
->start
5059 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
5060 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
5061 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5063 /* Make sure the values are reasonable, and try to preserve
5064 the distance between start and end. */
5066 int length
= end
- start
;
5070 else if (start
> top_range
)
5072 end
= start
+ length
;
5076 else if (end
> top_range
&& ! dragging
)
5080 /* Store the adjusted setting in the scroll bar. */
5084 /* Clip the end position, just for display. */
5085 if (end
> top_range
)
5088 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
5089 below top positions, to make sure the handle is always at least
5090 that many pixels tall. */
5091 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
5093 /* Draw the empty space above the handle. Note that we can't clear
5094 zero-height areas; that means "clear to end of window." */
5096 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5097 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5098 VERTICAL_SCROLL_BAR_TOP_BORDER
,
5099 inside_width
, start
);
5101 /* Change to proper foreground color if one is specified. */
5102 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5103 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5104 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5106 /* Draw the handle itself. */
5107 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5108 /* x, y, width, height */
5109 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5110 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
5111 inside_width
, end
- start
);
5113 /* Restore the foreground color of the GC if we changed it above. */
5114 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5115 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5116 FRAME_FOREGROUND_PIXEL (f
));
5118 /* Draw the empty space below the handle. Note that we can't
5119 clear zero-height areas; that means "clear to end of window." */
5120 if (end
< inside_height
)
5121 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5122 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5123 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
5124 inside_width
, inside_height
- end
);
5130 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5132 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
5136 x_scroll_bar_remove (struct scroll_bar
*bar
)
5138 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5141 #ifdef USE_TOOLKIT_SCROLL_BARS
5143 xg_remove_scroll_bar (f
, bar
->x_window
);
5144 #else /* not USE_GTK */
5145 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
5146 #endif /* not USE_GTK */
5148 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
5151 /* Dissociate this scroll bar from its window. */
5152 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
5158 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5159 that we are displaying PORTION characters out of a total of WHOLE
5160 characters, starting at POSITION. If WINDOW has no scroll bar,
5164 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
5166 struct frame
*f
= XFRAME (w
->frame
);
5168 struct scroll_bar
*bar
;
5169 int top
, height
, left
, width
;
5170 int window_y
, window_height
;
5172 /* Get window dimensions. */
5173 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
5175 height
= window_height
;
5177 /* Compute the left edge and the width of the scroll bar area. */
5178 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5179 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
5181 /* Does the scroll bar exist yet? */
5182 if (NILP (w
->vertical_scroll_bar
))
5184 if (width
> 0 && height
> 0)
5187 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5188 left
, top
, width
, height
);
5192 bar
= x_scroll_bar_create (w
, top
, left
, width
, max (height
, 1));
5196 /* It may just need to be moved and resized. */
5197 unsigned int mask
= 0;
5199 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5203 if (left
!= bar
->left
)
5205 if (top
!= bar
->top
)
5207 if (width
!= bar
->width
)
5209 if (height
!= bar
->height
)
5212 #ifdef USE_TOOLKIT_SCROLL_BARS
5214 /* Move/size the scroll bar widget. */
5217 /* Since toolkit scroll bars are smaller than the space reserved
5218 for them on the frame, we have to clear "under" them. */
5219 if (width
> 0 && height
> 0)
5220 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5221 left
, top
, width
, height
);
5223 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
5224 left
, width
, max (height
, 1));
5225 #else /* not USE_GTK */
5226 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5227 left
, top
, width
, max (height
, 1), 0);
5228 #endif /* not USE_GTK */
5230 #else /* not USE_TOOLKIT_SCROLL_BARS */
5232 /* Move/size the scroll bar window. */
5241 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5245 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5247 /* Remember new settings. */
5251 bar
->height
= height
;
5256 #ifdef USE_TOOLKIT_SCROLL_BARS
5257 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5258 #else /* not USE_TOOLKIT_SCROLL_BARS */
5259 /* Set the scroll bar's current state, unless we're currently being
5261 if (bar
->dragging
== -1)
5263 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5266 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5269 int start
= ((double) position
* top_range
) / whole
;
5270 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5271 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5274 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5276 XSETVECTOR (barobj
, bar
);
5277 wset_vertical_scroll_bar (w
, barobj
);
5281 /* The following three hooks are used when we're doing a thorough
5282 redisplay of the frame. We don't explicitly know which scroll bars
5283 are going to be deleted, because keeping track of when windows go
5284 away is a real pain - "Can you say set-window-configuration, boys
5285 and girls?" Instead, we just assert at the beginning of redisplay
5286 that *all* scroll bars are to be removed, and then save a scroll bar
5287 from the fiery pit when we actually redisplay its window. */
5289 /* Arrange for all scroll bars on FRAME to be removed at the next call
5290 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5291 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5294 XTcondemn_scroll_bars (struct frame
*frame
)
5296 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5297 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5300 bar
= FRAME_SCROLL_BARS (frame
);
5301 fset_scroll_bars (frame
, XSCROLL_BAR (bar
)->next
);
5302 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5303 XSCROLL_BAR (bar
)->prev
= Qnil
;
5304 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5305 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5306 fset_condemned_scroll_bars (frame
, bar
);
5311 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5312 Note that WINDOW isn't necessarily condemned at all. */
5315 XTredeem_scroll_bar (struct window
*window
)
5317 struct scroll_bar
*bar
;
5321 /* We can't redeem this window's scroll bar if it doesn't have one. */
5322 if (NILP (window
->vertical_scroll_bar
))
5325 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5327 /* Unlink it from the condemned list. */
5328 f
= XFRAME (WINDOW_FRAME (window
));
5329 if (NILP (bar
->prev
))
5331 /* If the prev pointer is nil, it must be the first in one of
5333 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5334 /* It's not condemned. Everything's fine. */
5336 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5337 window
->vertical_scroll_bar
))
5338 fset_condemned_scroll_bars (f
, bar
->next
);
5340 /* If its prev pointer is nil, it must be at the front of
5341 one or the other! */
5345 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5347 if (! NILP (bar
->next
))
5348 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5350 bar
->next
= FRAME_SCROLL_BARS (f
);
5352 XSETVECTOR (barobj
, bar
);
5353 fset_scroll_bars (f
, barobj
);
5354 if (! NILP (bar
->next
))
5355 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5358 /* Remove all scroll bars on FRAME that haven't been saved since the
5359 last call to `*condemn_scroll_bars_hook'. */
5362 XTjudge_scroll_bars (struct frame
*f
)
5364 Lisp_Object bar
, next
;
5366 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5368 /* Clear out the condemned list now so we won't try to process any
5369 more events on the hapless scroll bars. */
5370 fset_condemned_scroll_bars (f
, Qnil
);
5372 for (; ! NILP (bar
); bar
= next
)
5374 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5376 x_scroll_bar_remove (b
);
5379 b
->next
= b
->prev
= Qnil
;
5382 /* Now there should be no references to the condemned scroll bars,
5383 and they should get garbage-collected. */
5387 #ifndef USE_TOOLKIT_SCROLL_BARS
5388 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5389 is a no-op when using toolkit scroll bars.
5391 This may be called from a signal handler, so we have to ignore GC
5395 x_scroll_bar_expose (struct scroll_bar
*bar
, const XEvent
*event
)
5397 Window w
= bar
->x_window
;
5398 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5399 GC gc
= f
->output_data
.x
->normal_gc
;
5403 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, 1);
5405 /* Switch to scroll bar foreground color. */
5406 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5407 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5408 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5410 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5411 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5412 /* x, y, width, height */
5413 0, 0, bar
->width
- 1, bar
->height
- 1);
5415 /* Restore the foreground color of the GC if we changed it above. */
5416 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5417 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5418 FRAME_FOREGROUND_PIXEL (f
));
5423 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5425 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5426 is set to something other than NO_EVENT, it is enqueued.
5428 This may be called from a signal handler, so we have to ignore GC
5433 x_scroll_bar_handle_click (struct scroll_bar
*bar
,
5434 const XEvent
*event
,
5435 struct input_event
*emacs_event
)
5437 if (! WINDOWP (bar
->window
))
5440 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5441 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5442 emacs_event
->modifiers
5443 = (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO
5444 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5445 event
->xbutton
.state
)
5446 | (event
->type
== ButtonRelease
5449 emacs_event
->frame_or_window
= bar
->window
;
5450 emacs_event
->arg
= Qnil
;
5451 emacs_event
->timestamp
= event
->xbutton
.time
;
5454 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5455 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5458 if (y
> top_range
) y
= top_range
;
5461 emacs_event
->part
= scroll_bar_above_handle
;
5462 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5463 emacs_event
->part
= scroll_bar_handle
;
5465 emacs_event
->part
= scroll_bar_below_handle
;
5467 #ifndef USE_TOOLKIT_SCROLL_BARS
5468 /* If the user has released the handle, set it to its final position. */
5469 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
5471 int new_start
= y
- bar
->dragging
;
5472 int new_end
= new_start
+ bar
->end
- bar
->start
;
5474 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5479 XSETINT (emacs_event
->x
, y
);
5480 XSETINT (emacs_event
->y
, top_range
);
5484 #ifndef USE_TOOLKIT_SCROLL_BARS
5486 /* Handle some mouse motion while someone is dragging the scroll bar.
5488 This may be called from a signal handler, so we have to ignore GC
5492 x_scroll_bar_note_movement (struct scroll_bar
*bar
,
5493 const XMotionEvent
*event
)
5495 struct frame
*f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5496 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
5498 dpyinfo
->last_mouse_movement_time
= event
->time
;
5499 dpyinfo
->last_mouse_scroll_bar
= bar
;
5502 /* If we're dragging the bar, display it. */
5503 if (bar
->dragging
!= -1)
5505 /* Where should the handle be now? */
5506 int new_start
= event
->y
- bar
->dragging
;
5508 if (new_start
!= bar
->start
)
5510 int new_end
= new_start
+ bar
->end
- bar
->start
;
5512 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5517 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5519 /* Return information to the user about the current position of the mouse
5520 on the scroll bar. */
5523 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
5524 enum scroll_bar_part
*part
, Lisp_Object
*x
,
5525 Lisp_Object
*y
, Time
*timestamp
)
5527 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
5528 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
5529 Window w
= bar
->x_window
;
5530 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5532 Window dummy_window
;
5534 unsigned int dummy_mask
;
5538 /* Get the mouse's position relative to the scroll bar window, and
5540 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5542 /* Root, child, root x and root y. */
5543 &dummy_window
, &dummy_window
,
5544 &dummy_coord
, &dummy_coord
,
5546 /* Position relative to scroll bar. */
5549 /* Mouse buttons and modifier keys. */
5552 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5554 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5556 if (bar
->dragging
!= -1)
5557 win_y
-= bar
->dragging
;
5561 if (win_y
> top_range
)
5565 *bar_window
= bar
->window
;
5567 if (bar
->dragging
!= -1)
5568 *part
= scroll_bar_handle
;
5569 else if (win_y
< bar
->start
)
5570 *part
= scroll_bar_above_handle
;
5571 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5572 *part
= scroll_bar_handle
;
5574 *part
= scroll_bar_below_handle
;
5576 XSETINT (*x
, win_y
);
5577 XSETINT (*y
, top_range
);
5580 dpyinfo
->last_mouse_scroll_bar
= NULL
;
5581 *timestamp
= dpyinfo
->last_mouse_movement_time
;
5588 /* The screen has been cleared so we may have changed foreground or
5589 background colors, and the scroll bars may need to be redrawn.
5590 Clear out the scroll bars, and ask for expose events, so we can
5594 x_scroll_bar_clear (struct frame
*f
)
5596 #ifndef USE_TOOLKIT_SCROLL_BARS
5599 /* We can have scroll bars even if this is 0,
5600 if we just turned off scroll bar mode.
5601 But in that case we should not clear them. */
5602 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5603 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5604 bar
= XSCROLL_BAR (bar
)->next
)
5605 XClearArea (FRAME_X_DISPLAY (f
),
5606 XSCROLL_BAR (bar
)->x_window
,
5608 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5611 #ifdef ENABLE_CHECKING
5613 /* Record the last 100 characters stored
5614 to help debug the loss-of-chars-during-GC problem. */
5616 static int temp_index
;
5617 static short temp_buffer
[100];
5619 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5620 if (temp_index == ARRAYELTS (temp_buffer)) \
5622 temp_buffer[temp_index++] = (keysym)
5624 #else /* not ENABLE_CHECKING */
5626 #define STORE_KEYSYM_FOR_DEBUG(keysym) ((void)0)
5628 #endif /* ENABLE_CHECKING */
5630 /* Set this to nonzero to fake an "X I/O error"
5631 on a particular display. */
5633 static struct x_display_info
*XTread_socket_fake_io_error
;
5635 /* When we find no input here, we occasionally do a no-op command
5636 to verify that the X server is still running and we can still talk with it.
5637 We try all the open displays, one by one.
5638 This variable is used for cycling thru the displays. */
5640 static struct x_display_info
*next_noop_dpyinfo
;
5649 /* Filter events for the current X input method.
5650 DPYINFO is the display this event is for.
5651 EVENT is the X event to filter.
5653 Returns non-zero if the event was filtered, caller shall not process
5655 Returns zero if event is wasn't filtered. */
5659 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
5661 /* XFilterEvent returns non-zero if the input method has
5662 consumed the event. We pass the frame's X window to
5663 XFilterEvent because that's the one for which the IC
5666 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5667 event
->xclient
.window
);
5669 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5674 static int current_count
;
5675 static int current_finish
;
5676 static struct input_event
*current_hold_quit
;
5678 /* This is the filter function invoked by the GTK event loop.
5679 It is invoked before the XEvent is translated to a GdkEvent,
5680 so we have a chance to act on the event before GTK. */
5681 static GdkFilterReturn
5682 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
5684 XEvent
*xev
= (XEvent
*) gxev
;
5687 if (current_count
>= 0)
5689 struct x_display_info
*dpyinfo
;
5691 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5694 /* Filter events for the current X input method.
5695 GTK calls XFilterEvent but not for key press and release,
5696 so we do it here. */
5697 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5699 && x_filter_event (dpyinfo
, xev
))
5702 return GDK_FILTER_REMOVE
;
5707 current_finish
= X_EVENT_NORMAL
;
5710 += handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5714 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5718 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5719 return GDK_FILTER_REMOVE
;
5721 return GDK_FILTER_CONTINUE
;
5723 #endif /* USE_GTK */
5726 static void xembed_send_message (struct frame
*f
, Time
,
5727 enum xembed_message
,
5728 long detail
, long data1
, long data2
);
5730 /* Handles the XEvent EVENT on display DPYINFO.
5732 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5733 *FINISH is zero if caller should continue reading events.
5734 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5735 *EVENT is unchanged unless we're processing KeyPress event.
5737 We return the number of characters stored into the buffer. */
5740 handle_one_xevent (struct x_display_info
*dpyinfo
,
5741 const XEvent
*event
,
5742 int *finish
, struct input_event
*hold_quit
)
5745 struct input_event ie
;
5746 struct selection_input_event sie
;
5750 ptrdiff_t nbytes
= 0;
5751 struct frame
*any
, *f
= NULL
;
5752 struct coding_system coding
;
5753 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
5754 /* This holds the state XLookupString needs to implement dead keys
5755 and other tricks known as "compose processing". _X Window System_
5756 says that a portable program can't use this, but Stephen Gildea assures
5757 me that letting the compiler initialize it to zeros will work okay. */
5758 static XComposeStatus compose_status
;
5762 *finish
= X_EVENT_NORMAL
;
5764 EVENT_INIT (inev
.ie
);
5765 inev
.ie
.kind
= NO_EVENT
;
5768 any
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
5770 if (any
&& any
->wait_event_type
== event
->type
)
5771 any
->wait_event_type
= 0; /* Indicates we got it. */
5773 switch (event
->type
)
5777 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_protocols
5778 && event
->xclient
.format
== 32)
5780 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_take_focus
)
5782 /* Use the value returned by x_any_window_to_frame
5783 because this could be the shell widget window
5784 if the frame has no title bar. */
5787 /* Not quite sure this is needed -pd */
5788 if (f
&& FRAME_XIC (f
))
5789 XSetICFocus (FRAME_XIC (f
));
5791 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5792 instructs the WM to set the input focus automatically for
5793 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5794 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5795 it has set the focus. So, XSetInputFocus below is not
5798 The call to XSetInputFocus below has also caused trouble. In
5799 cases where the XSetInputFocus done by the WM and the one
5800 below are temporally close (on a fast machine), the call
5801 below can generate additional FocusIn events which confuse
5804 /* Since we set WM_TAKE_FOCUS, we must call
5805 XSetInputFocus explicitly. But not if f is null,
5806 since that might be an event for a deleted frame. */
5809 Display
*d
= event
->xclient
.display
;
5810 /* Catch and ignore errors, in case window has been
5811 iconified by a window manager such as GWM. */
5813 XSetInputFocus (d
, event
->xclient
.window
,
5814 /* The ICCCM says this is
5815 the only valid choice. */
5817 event
->xclient
.data
.l
[1]);
5818 /* This is needed to detect the error
5819 if there is an error. */
5821 x_uncatch_errors ();
5823 /* Not certain about handling scroll bars here */
5828 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_save_yourself
)
5830 /* Save state modify the WM_COMMAND property to
5831 something which can reinstate us. This notifies
5832 the session manager, who's looking for such a
5833 PropertyNotify. Can restart processing when
5834 a keyboard or mouse event arrives. */
5835 /* If we have a session manager, don't set this.
5836 KDE will then start two Emacsen, one for the
5837 session manager and one for this. */
5839 if (! x_session_have_connection ())
5842 f
= x_top_window_to_frame (dpyinfo
,
5843 event
->xclient
.window
);
5844 /* This is just so we only give real data once
5845 for a single Emacs process. */
5846 if (f
== SELECTED_FRAME ())
5847 XSetCommand (FRAME_X_DISPLAY (f
),
5848 event
->xclient
.window
,
5849 initial_argv
, initial_argc
);
5851 XSetCommand (FRAME_X_DISPLAY (f
),
5852 event
->xclient
.window
,
5858 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_delete_window
)
5862 goto OTHER
; /* May be a dialog that is to be removed */
5864 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
5865 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5872 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_configure_denied
)
5875 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_window_moved
)
5878 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
5880 new_x
= event
->xclient
.data
.s
[0];
5881 new_y
= event
->xclient
.data
.s
[1];
5885 f
->left_pos
= new_x
;
5892 if (event
->xclient
.message_type
== dpyinfo
->Xatom_editres
)
5896 _XEditResCheckMessages (f
->output_data
.x
->widget
,
5897 NULL
, (XEvent
*) event
, NULL
);
5900 #endif /* HACK_EDITRES */
5902 if (event
->xclient
.message_type
== dpyinfo
->Xatom_DONE
5903 || event
->xclient
.message_type
== dpyinfo
->Xatom_PAGE
)
5905 /* Ghostview job completed. Kill it. We could
5906 reply with "Next" if we received "Page", but we
5907 currently never do because we are interested in
5908 images, only, which should have 1 page. */
5909 Pixmap pixmap
= (Pixmap
) event
->xclient
.data
.l
[1];
5910 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
5913 x_kill_gs_process (pixmap
, f
);
5914 expose_frame (f
, 0, 0, 0, 0);
5918 #ifdef USE_TOOLKIT_SCROLL_BARS
5919 /* Scroll bar callbacks send a ClientMessage from which
5920 we construct an input_event. */
5921 if (event
->xclient
.message_type
== dpyinfo
->Xatom_Scrollbar
)
5923 x_scroll_bar_to_input_event (event
, &inev
.ie
);
5924 *finish
= X_EVENT_GOTO_OUT
;
5927 #endif /* USE_TOOLKIT_SCROLL_BARS */
5929 /* XEmbed messages from the embedder (if any). */
5930 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
5932 enum xembed_message msg
= event
->xclient
.data
.l
[1];
5933 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
5934 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
5936 *finish
= X_EVENT_GOTO_OUT
;
5940 xft_settings_event (dpyinfo
, event
);
5945 if (x_handle_dnd_message (f
, &event
->xclient
, dpyinfo
, &inev
.ie
))
5946 *finish
= X_EVENT_DROP
;
5950 case SelectionNotify
:
5951 dpyinfo
->last_user_time
= event
->xselection
.time
;
5952 #ifdef USE_X_TOOLKIT
5953 if (! x_window_to_frame (dpyinfo
, event
->xselection
.requestor
))
5955 #endif /* not USE_X_TOOLKIT */
5956 x_handle_selection_notify (&event
->xselection
);
5959 case SelectionClear
: /* Someone has grabbed ownership. */
5960 dpyinfo
->last_user_time
= event
->xselectionclear
.time
;
5961 #ifdef USE_X_TOOLKIT
5962 if (! x_window_to_frame (dpyinfo
, event
->xselectionclear
.window
))
5964 #endif /* USE_X_TOOLKIT */
5966 const XSelectionClearEvent
*eventp
= &event
->xselectionclear
;
5968 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
5969 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
5970 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5971 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5975 case SelectionRequest
: /* Someone wants our selection. */
5976 dpyinfo
->last_user_time
= event
->xselectionrequest
.time
;
5977 #ifdef USE_X_TOOLKIT
5978 if (!x_window_to_frame (dpyinfo
, event
->xselectionrequest
.owner
))
5980 #endif /* USE_X_TOOLKIT */
5982 const XSelectionRequestEvent
*eventp
= &event
->xselectionrequest
;
5984 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
5985 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
5986 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
5987 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5988 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
5989 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
5990 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5994 case PropertyNotify
:
5995 dpyinfo
->last_user_time
= event
->xproperty
.time
;
5996 f
= x_top_window_to_frame (dpyinfo
, event
->xproperty
.window
);
5997 if (f
&& event
->xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
5998 if (x_handle_net_wm_state (f
, &event
->xproperty
)
5999 && FRAME_ICONIFIED_P (f
)
6000 && f
->output_data
.x
->net_wm_state_hidden_seen
)
6002 /* Gnome shell does not iconify us when C-z is pressed.
6003 It hides the frame. So if our state says we aren't
6004 hidden anymore, treat it as deiconified. */
6005 SET_FRAME_VISIBLE (f
, 1);
6006 SET_FRAME_ICONIFIED (f
, 0);
6007 f
->output_data
.x
->has_been_visible
= 1;
6008 f
->output_data
.x
->net_wm_state_hidden_seen
= 0;
6009 inev
.ie
.kind
= DEICONIFY_EVENT
;
6010 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6013 x_handle_property_notify (&event
->xproperty
);
6014 xft_settings_event (dpyinfo
, event
);
6017 case ReparentNotify
:
6018 f
= x_top_window_to_frame (dpyinfo
, event
->xreparent
.window
);
6021 f
->output_data
.x
->parent_desc
= event
->xreparent
.parent
;
6022 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6024 /* Perhaps reparented due to a WM restart. Reset this. */
6025 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
6026 FRAME_DISPLAY_INFO (f
)->net_supported_window
= 0;
6028 x_set_frame_alpha (f
);
6033 f
= x_window_to_frame (dpyinfo
, event
->xexpose
.window
);
6036 if (!FRAME_VISIBLE_P (f
))
6038 SET_FRAME_VISIBLE (f
, 1);
6039 SET_FRAME_ICONIFIED (f
, 0);
6040 f
->output_data
.x
->has_been_visible
= 1;
6041 SET_FRAME_GARBAGED (f
);
6046 /* This seems to be needed for GTK 2.6 and later, see
6047 http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15398. */
6048 x_clear_area (event
->xexpose
.display
,
6049 event
->xexpose
.window
,
6050 event
->xexpose
.x
, event
->xexpose
.y
,
6051 event
->xexpose
.width
, event
->xexpose
.height
);
6053 expose_frame (f
, event
->xexpose
.x
, event
->xexpose
.y
,
6054 event
->xexpose
.width
, event
->xexpose
.height
);
6059 #ifndef USE_TOOLKIT_SCROLL_BARS
6060 struct scroll_bar
*bar
;
6062 #if defined USE_LUCID
6063 /* Submenus of the Lucid menu bar aren't widgets
6064 themselves, so there's no way to dispatch events
6065 to them. Recognize this case separately. */
6067 Widget widget
= x_window_to_menu_bar (event
->xexpose
.window
);
6069 xlwmenu_redisplay (widget
);
6071 #endif /* USE_LUCID */
6073 #ifdef USE_TOOLKIT_SCROLL_BARS
6074 /* Dispatch event to the widget. */
6076 #else /* not USE_TOOLKIT_SCROLL_BARS */
6077 bar
= x_window_to_scroll_bar (event
->xexpose
.display
,
6078 event
->xexpose
.window
);
6081 x_scroll_bar_expose (bar
, event
);
6082 #ifdef USE_X_TOOLKIT
6085 #endif /* USE_X_TOOLKIT */
6086 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6090 case GraphicsExpose
: /* This occurs when an XCopyArea's
6091 source area was obscured or not
6093 f
= x_window_to_frame (dpyinfo
, event
->xgraphicsexpose
.drawable
);
6095 expose_frame (f
, event
->xgraphicsexpose
.x
,
6096 event
->xgraphicsexpose
.y
,
6097 event
->xgraphicsexpose
.width
,
6098 event
->xgraphicsexpose
.height
);
6099 #ifdef USE_X_TOOLKIT
6102 #endif /* USE_X_TOOLKIT */
6105 case NoExpose
: /* This occurs when an XCopyArea's
6106 source area was completely
6111 /* Redo the mouse-highlight after the tooltip has gone. */
6112 if (event
->xunmap
.window
== tip_window
)
6115 x_redo_mouse_highlight (dpyinfo
);
6118 f
= x_top_window_to_frame (dpyinfo
, event
->xunmap
.window
);
6119 if (f
) /* F may no longer exist if
6120 the frame was deleted. */
6122 bool visible
= FRAME_VISIBLE_P (f
);
6123 /* While a frame is unmapped, display generation is
6124 disabled; you don't want to spend time updating a
6125 display that won't ever be seen. */
6126 SET_FRAME_VISIBLE (f
, 0);
6127 /* We can't distinguish, from the event, whether the window
6128 has become iconified or invisible. So assume, if it
6129 was previously visible, than now it is iconified.
6130 But x_make_frame_invisible clears both
6131 the visible flag and the iconified flag;
6132 and that way, we know the window is not iconified now. */
6133 if (visible
|| FRAME_ICONIFIED_P (f
))
6135 SET_FRAME_ICONIFIED (f
, 1);
6136 inev
.ie
.kind
= ICONIFY_EVENT
;
6137 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6143 if (event
->xmap
.window
== tip_window
)
6144 /* The tooltip has been drawn already. Avoid
6145 the SET_FRAME_GARBAGED below. */
6148 /* We use x_top_window_to_frame because map events can
6149 come for sub-windows and they don't mean that the
6150 frame is visible. */
6151 f
= x_top_window_to_frame (dpyinfo
, event
->xmap
.window
);
6154 bool iconified
= FRAME_ICONIFIED_P (f
);
6156 /* Check if fullscreen was specified before we where mapped the
6157 first time, i.e. from the command line. */
6158 if (!f
->output_data
.x
->has_been_visible
)
6159 x_check_fullscreen (f
);
6161 SET_FRAME_VISIBLE (f
, 1);
6162 SET_FRAME_ICONIFIED (f
, 0);
6163 f
->output_data
.x
->has_been_visible
= 1;
6167 inev
.ie
.kind
= DEICONIFY_EVENT
;
6168 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6170 else if (! NILP (Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
6171 /* Force a redisplay sooner or later to update the
6172 frame titles in case this is the second frame. */
6173 record_asynch_buffer_change ();
6176 xg_frame_resized (f
, -1, -1);
6183 dpyinfo
->last_user_time
= event
->xkey
.time
;
6184 ignore_next_mouse_click_timeout
= 0;
6186 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6187 /* Dispatch KeyPress events when in menu. */
6188 if (popup_activated ())
6194 #if ! defined (USE_GTK)
6195 /* If mouse-highlight is an integer, input clears out
6196 mouse highlighting. */
6197 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
6199 || !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)))
6201 clear_mouse_face (hlinfo
);
6202 hlinfo
->mouse_face_hidden
= 1;
6206 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6209 /* Scroll bars consume key events, but we want
6210 the keys to go to the scroll bar's frame. */
6211 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6212 event
->xkey
.window
);
6213 if (widget
&& XmIsScrollBar (widget
))
6215 widget
= XtParent (widget
);
6216 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6219 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6223 KeySym keysym
, orig_keysym
;
6224 /* al%imercury@uunet.uu.net says that making this 81
6225 instead of 80 fixed a bug whereby meta chars made
6228 It seems that some version of XmbLookupString has
6229 a bug of not returning XBufferOverflow in
6230 status_return even if the input is too long to
6231 fit in 81 bytes. So, we must prepare sufficient
6232 bytes for copy_buffer. 513 bytes (256 chars for
6233 two-byte character set) seems to be a fairly good
6234 approximation. -- 2000.8.10 handa@etl.go.jp */
6235 unsigned char copy_buffer
[513];
6236 unsigned char *copy_bufptr
= copy_buffer
;
6237 int copy_bufsiz
= sizeof (copy_buffer
);
6239 Lisp_Object coding_system
= Qlatin_1
;
6241 /* Event will be modified. */
6242 XKeyEvent xkey
= event
->xkey
;
6245 /* Don't pass keys to GTK. A Tab will shift focus to the
6246 tool bar in GTK 2.4. Keys will still go to menus and
6247 dialogs because in that case popup_activated is nonzero
6249 *finish
= X_EVENT_DROP
;
6252 xkey
.state
|= x_emacs_to_x_modifiers (FRAME_DISPLAY_INFO (f
),
6253 extra_keyboard_modifiers
);
6254 modifiers
= xkey
.state
;
6256 /* This will have to go some day... */
6258 /* make_lispy_event turns chars into control chars.
6259 Don't do it here because XLookupString is too eager. */
6260 xkey
.state
&= ~ControlMask
;
6261 xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6262 | dpyinfo
->super_mod_mask
6263 | dpyinfo
->hyper_mod_mask
6264 | dpyinfo
->alt_mod_mask
);
6266 /* In case Meta is ComposeCharacter,
6267 clear its status. According to Markus Ehrnsperger
6268 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6269 this enables ComposeCharacter to work whether or
6270 not it is combined with Meta. */
6271 if (modifiers
& dpyinfo
->meta_mod_mask
)
6272 memset (&compose_status
, 0, sizeof (compose_status
));
6277 Status status_return
;
6279 coding_system
= Vlocale_coding_system
;
6280 nbytes
= XmbLookupString (FRAME_XIC (f
),
6281 &xkey
, (char *) copy_bufptr
,
6282 copy_bufsiz
, &keysym
,
6284 if (status_return
== XBufferOverflow
)
6286 copy_bufsiz
= nbytes
+ 1;
6287 copy_bufptr
= alloca (copy_bufsiz
);
6288 nbytes
= XmbLookupString (FRAME_XIC (f
),
6289 &xkey
, (char *) copy_bufptr
,
6290 copy_bufsiz
, &keysym
,
6293 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6294 if (status_return
== XLookupNone
)
6296 else if (status_return
== XLookupChars
)
6301 else if (status_return
!= XLookupKeySym
6302 && status_return
!= XLookupBoth
)
6306 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
6307 copy_bufsiz
, &keysym
,
6310 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
6311 copy_bufsiz
, &keysym
,
6315 /* If not using XIM/XIC, and a compose sequence is in progress,
6316 we break here. Otherwise, chars_matched is always 0. */
6317 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6320 memset (&compose_status
, 0, sizeof (compose_status
));
6321 orig_keysym
= keysym
;
6323 /* Common for all keysym input events. */
6324 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6326 = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), modifiers
);
6327 inev
.ie
.timestamp
= xkey
.time
;
6329 /* First deal with keysyms which have defined
6330 translations to characters. */
6331 if (keysym
>= 32 && keysym
< 128)
6332 /* Avoid explicitly decoding each ASCII character. */
6334 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6335 inev
.ie
.code
= keysym
;
6339 /* Keysyms directly mapped to Unicode characters. */
6340 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
6342 if (keysym
< 0x01000080)
6343 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6345 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
6346 inev
.ie
.code
= keysym
& 0xFFFFFF;
6350 /* Now non-ASCII. */
6351 if (HASH_TABLE_P (Vx_keysym_table
)
6352 && (c
= Fgethash (make_number (keysym
),
6357 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6358 ? ASCII_KEYSTROKE_EVENT
6359 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6360 inev
.ie
.code
= XFASTINT (c
);
6364 /* Random non-modifier sorts of keysyms. */
6365 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6366 || keysym
== XK_Delete
6367 #ifdef XK_ISO_Left_Tab
6368 || (keysym
>= XK_ISO_Left_Tab
6369 && keysym
<= XK_ISO_Enter
)
6371 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6372 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6374 /* This recognizes the "extended function
6375 keys". It seems there's no cleaner way.
6376 Test IsModifierKey to avoid handling
6377 mode_switch incorrectly. */
6378 || (XK_Select
<= keysym
&& keysym
< XK_KP_Space
)
6380 #ifdef XK_dead_circumflex
6381 || orig_keysym
== XK_dead_circumflex
6383 #ifdef XK_dead_grave
6384 || orig_keysym
== XK_dead_grave
6386 #ifdef XK_dead_tilde
6387 || orig_keysym
== XK_dead_tilde
6389 #ifdef XK_dead_diaeresis
6390 || orig_keysym
== XK_dead_diaeresis
6392 #ifdef XK_dead_macron
6393 || orig_keysym
== XK_dead_macron
6395 #ifdef XK_dead_degree
6396 || orig_keysym
== XK_dead_degree
6398 #ifdef XK_dead_acute
6399 || orig_keysym
== XK_dead_acute
6401 #ifdef XK_dead_cedilla
6402 || orig_keysym
== XK_dead_cedilla
6404 #ifdef XK_dead_breve
6405 || orig_keysym
== XK_dead_breve
6407 #ifdef XK_dead_ogonek
6408 || orig_keysym
== XK_dead_ogonek
6410 #ifdef XK_dead_caron
6411 || orig_keysym
== XK_dead_caron
6413 #ifdef XK_dead_doubleacute
6414 || orig_keysym
== XK_dead_doubleacute
6416 #ifdef XK_dead_abovedot
6417 || orig_keysym
== XK_dead_abovedot
6419 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6420 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6421 /* Any "vendor-specific" key is ok. */
6422 || (orig_keysym
& (1 << 28))
6423 || (keysym
!= NoSymbol
&& nbytes
== 0))
6424 && ! (IsModifierKey (orig_keysym
)
6425 /* The symbols from XK_ISO_Lock
6426 to XK_ISO_Last_Group_Lock
6427 don't have real modifiers but
6428 should be treated similarly to
6429 Mode_switch by Emacs. */
6430 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6431 || (XK_ISO_Lock
<= orig_keysym
6432 && orig_keysym
<= XK_ISO_Last_Group_Lock
)
6436 STORE_KEYSYM_FOR_DEBUG (keysym
);
6437 /* make_lispy_event will convert this to a symbolic
6439 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6440 inev
.ie
.code
= keysym
;
6444 { /* Raw bytes, not keysym. */
6448 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
6450 if (ASCII_CHAR_P (copy_bufptr
[i
]))
6452 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6455 if (nchars
< nbytes
)
6457 /* Decode the input data. */
6459 /* The input should be decoded with `coding_system'
6460 which depends on which X*LookupString function
6461 we used just above and the locale. */
6462 setup_coding_system (coding_system
, &coding
);
6463 coding
.src_multibyte
= 0;
6464 coding
.dst_multibyte
= 1;
6465 /* The input is converted to events, thus we can't
6466 handle composition. Anyway, there's no XIM that
6467 gives us composition information. */
6468 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
6470 SAFE_NALLOCA (coding
.destination
, MAX_MULTIBYTE_LENGTH
,
6472 coding
.dst_bytes
= MAX_MULTIBYTE_LENGTH
* nbytes
;
6473 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6474 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
6475 nbytes
= coding
.produced
;
6476 nchars
= coding
.produced_char
;
6477 copy_bufptr
= coding
.destination
;
6480 /* Convert the input data to a sequence of
6481 character events. */
6482 for (i
= 0; i
< nbytes
; i
+= len
)
6485 if (nchars
== nbytes
)
6486 ch
= copy_bufptr
[i
], len
= 1;
6488 ch
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
6489 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (ch
)
6490 ? ASCII_KEYSTROKE_EVENT
6491 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6493 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6498 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
6500 if (keysym
== NoSymbol
)
6503 /* FIXME: check side effects and remove this. */
6504 ((XEvent
*) event
)->xkey
= xkey
;
6508 /* Don't dispatch this event since XtDispatchEvent calls
6509 XFilterEvent, and two calls in a row may freeze the
6517 dpyinfo
->last_user_time
= event
->xkey
.time
;
6519 /* Don't dispatch this event since XtDispatchEvent calls
6520 XFilterEvent, and two calls in a row may freeze the
6528 dpyinfo
->last_user_time
= event
->xcrossing
.time
;
6529 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
6533 if (f
&& x_mouse_click_focus_ignore_position
)
6534 ignore_next_mouse_click_timeout
= event
->xmotion
.time
+ 200;
6536 /* EnterNotify counts as mouse movement,
6537 so update things that depend on mouse position. */
6538 if (f
&& !f
->output_data
.x
->hourglass_p
)
6539 note_mouse_movement (f
, &event
->xmotion
);
6541 /* We may get an EnterNotify on the buttons in the toolbar. In that
6542 case we moved out of any highlighted area and need to note this. */
6543 if (!f
&& dpyinfo
->last_mouse_glyph_frame
)
6544 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
6549 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
6553 dpyinfo
->last_user_time
= event
->xcrossing
.time
;
6554 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
6556 f
= x_top_window_to_frame (dpyinfo
, event
->xcrossing
.window
);
6559 if (f
== hlinfo
->mouse_face_mouse_frame
)
6561 /* If we move outside the frame, then we're
6562 certainly no longer on any text in the frame. */
6563 clear_mouse_face (hlinfo
);
6564 hlinfo
->mouse_face_mouse_frame
= 0;
6567 /* Generate a nil HELP_EVENT to cancel a help-echo.
6568 Do it only if there's something to cancel.
6569 Otherwise, the startup message is cleared when
6570 the mouse leaves the frame. */
6571 if (any_help_event_p
)
6575 /* See comment in EnterNotify above */
6576 else if (dpyinfo
->last_mouse_glyph_frame
)
6577 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
6582 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
6587 dpyinfo
->last_user_time
= event
->xmotion
.time
;
6588 previous_help_echo_string
= help_echo_string
;
6589 help_echo_string
= Qnil
;
6591 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
6592 : x_window_to_frame (dpyinfo
, event
->xmotion
.window
));
6594 if (hlinfo
->mouse_face_hidden
)
6596 hlinfo
->mouse_face_hidden
= 0;
6597 clear_mouse_face (hlinfo
);
6601 if (f
&& xg_event_is_for_scrollbar (f
, event
))
6607 /* Generate SELECT_WINDOW_EVENTs when needed.
6608 Don't let popup menus influence things (bug#1261). */
6609 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
6611 static Lisp_Object last_mouse_window
;
6612 Lisp_Object window
= window_from_coordinates
6613 (f
, event
->xmotion
.x
, event
->xmotion
.y
, 0, 0);
6615 /* Window will be selected only when it is not selected now and
6616 last mouse movement event was not in it. Minibuffer window
6617 will be selected only when it is active. */
6618 if (WINDOWP (window
)
6619 && !EQ (window
, last_mouse_window
)
6620 && !EQ (window
, selected_window
)
6621 /* For click-to-focus window managers
6622 create event iff we don't leave the
6624 && (focus_follows_mouse
6625 || (EQ (XWINDOW (window
)->frame
,
6626 XWINDOW (selected_window
)->frame
))))
6628 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
6629 inev
.ie
.frame_or_window
= window
;
6631 /* Remember the last window where we saw the mouse. */
6632 last_mouse_window
= window
;
6634 if (!note_mouse_movement (f
, &event
->xmotion
))
6635 help_echo_string
= previous_help_echo_string
;
6639 #ifndef USE_TOOLKIT_SCROLL_BARS
6640 struct scroll_bar
*bar
6641 = x_window_to_scroll_bar (event
->xmotion
.display
,
6642 event
->xmotion
.window
);
6645 x_scroll_bar_note_movement (bar
, &event
->xmotion
);
6646 #endif /* USE_TOOLKIT_SCROLL_BARS */
6648 /* If we move outside the frame, then we're
6649 certainly no longer on any text in the frame. */
6650 clear_mouse_face (hlinfo
);
6653 /* If the contents of the global variable help_echo_string
6654 has changed, generate a HELP_EVENT. */
6655 if (!NILP (help_echo_string
)
6656 || !NILP (previous_help_echo_string
))
6661 case ConfigureNotify
:
6662 f
= x_top_window_to_frame (dpyinfo
, event
->xconfigure
.window
);
6666 && event
->xconfigure
.window
== FRAME_X_WINDOW (f
))
6668 xg_frame_resized (f
, event
->xconfigure
.width
,
6669 event
->xconfigure
.height
);
6675 #ifndef USE_X_TOOLKIT
6677 int width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, event
->xconfigure
.width
);
6678 int height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, event
->xconfigure
.height
);
6680 /* In the toolkit version, change_frame_size
6681 is called by the code that handles resizing
6682 of the EmacsFrame widget. */
6684 /* Even if the number of character rows and columns has
6685 not changed, the font size may have changed, so we need
6686 to check the pixel dimensions as well. */
6687 if (width
!= FRAME_TEXT_WIDTH (f
)
6688 || height
!= FRAME_TEXT_HEIGHT (f
)
6689 || event
->xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6690 || event
->xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6692 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
6693 x_clear_under_internal_border (f
);
6694 SET_FRAME_GARBAGED (f
);
6695 cancel_mouse_face (f
);
6698 /** FRAME_PIXEL_WIDTH (f) = event->xconfigure.width; **/
6699 /** FRAME_PIXEL_HEIGHT (f) = event->xconfigure.height; **/
6700 #endif /* not USE_GTK */
6704 /* GTK creates windows but doesn't map them.
6705 Only get real positions when mapped. */
6706 if (FRAME_GTK_OUTER_WIDGET (f
)
6707 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
6709 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6712 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6713 xic_set_statusarea (f
);
6722 /* If we decide we want to generate an event to be seen
6723 by the rest of Emacs, we put it here. */
6724 bool tool_bar_p
= 0;
6726 memset (&compose_status
, 0, sizeof (compose_status
));
6727 dpyinfo
->last_mouse_glyph_frame
= NULL
;
6728 dpyinfo
->last_user_time
= event
->xbutton
.time
;
6730 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
6731 : x_window_to_frame (dpyinfo
, event
->xbutton
.window
));
6734 if (f
&& xg_event_is_for_scrollbar (f
, event
))
6739 #if ! defined (USE_GTK)
6740 /* Is this in the tool-bar? */
6741 if (WINDOWP (f
->tool_bar_window
)
6742 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6745 int x
= event
->xbutton
.x
;
6746 int y
= event
->xbutton
.y
;
6748 window
= window_from_coordinates (f
, x
, y
, 0, 1);
6749 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
6751 if (tool_bar_p
&& event
->xbutton
.button
< 4)
6752 handle_tool_bar_click
6753 (f
, x
, y
, event
->xbutton
.type
== ButtonPress
,
6754 x_x_to_emacs_modifiers (dpyinfo
, event
->xbutton
.state
));
6756 #endif /* !USE_GTK */
6759 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6760 if (! popup_activated ())
6763 if (ignore_next_mouse_click_timeout
)
6765 if (event
->type
== ButtonPress
6766 && event
->xbutton
.time
> ignore_next_mouse_click_timeout
)
6768 ignore_next_mouse_click_timeout
= 0;
6769 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
6771 if (event
->type
== ButtonRelease
)
6772 ignore_next_mouse_click_timeout
= 0;
6775 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
6777 if (FRAME_X_EMBEDDED_P (f
))
6778 xembed_send_message (f
, event
->xbutton
.time
,
6779 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
6783 struct scroll_bar
*bar
6784 = x_window_to_scroll_bar (event
->xbutton
.display
,
6785 event
->xbutton
.window
);
6787 #ifdef USE_TOOLKIT_SCROLL_BARS
6788 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6790 if (bar
&& event
->xbutton
.state
& ControlMask
)
6792 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
6793 *finish
= X_EVENT_DROP
;
6795 #else /* not USE_TOOLKIT_SCROLL_BARS */
6797 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
6798 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6801 if (event
->type
== ButtonPress
)
6803 dpyinfo
->grabbed
|= (1 << event
->xbutton
.button
);
6804 dpyinfo
->last_mouse_frame
= f
;
6805 #if ! defined (USE_GTK)
6806 if (f
&& !tool_bar_p
)
6807 f
->last_tool_bar_item
= -1;
6808 #endif /* not USE_GTK */
6811 dpyinfo
->grabbed
&= ~(1 << event
->xbutton
.button
);
6813 /* Ignore any mouse motion that happened before this event;
6814 any subsequent mouse-movement Emacs events should reflect
6815 only motion after the ButtonPress/Release. */
6819 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6820 f
= x_menubar_window_to_frame (dpyinfo
, event
);
6821 /* For a down-event in the menu bar,
6822 don't pass it to Xt right now.
6823 Instead, save it away
6824 and we will pass it to Xt from kbd_buffer_get_event.
6825 That way, we can run some Lisp code first. */
6826 if (! popup_activated ()
6828 /* Gtk+ menus only react to the first three buttons. */
6829 && event
->xbutton
.button
< 3
6831 && f
&& event
->type
== ButtonPress
6832 /* Verify the event is really within the menu bar
6833 and not just sent to it due to grabbing. */
6834 && event
->xbutton
.x
>= 0
6835 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6836 && event
->xbutton
.y
>= 0
6837 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
6838 && event
->xbutton
.same_screen
)
6840 if (!f
->output_data
.x
->saved_menu_event
)
6841 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof *event
);
6842 *f
->output_data
.x
->saved_menu_event
= *event
;
6843 inev
.ie
.kind
= MENU_BAR_ACTIVATE_EVENT
;
6844 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6845 *finish
= X_EVENT_DROP
;
6849 #endif /* USE_X_TOOLKIT || USE_GTK */
6853 case CirculateNotify
:
6856 case CirculateRequest
:
6859 case VisibilityNotify
:
6863 /* Someone has changed the keyboard mapping - update the
6865 switch (event
->xmapping
.request
)
6867 case MappingModifier
:
6868 x_find_modifier_meanings (dpyinfo
);
6869 /* This is meant to fall through. */
6870 case MappingKeyboard
:
6871 XRefreshKeyboardMapping ((XMappingEvent
*) &event
->xmapping
);
6876 xft_settings_event (dpyinfo
, event
);
6881 #ifdef USE_X_TOOLKIT
6883 if (*finish
!= X_EVENT_DROP
)
6884 XtDispatchEvent ((XEvent
*) event
);
6886 #endif /* USE_X_TOOLKIT */
6891 if (inev
.ie
.kind
!= NO_EVENT
)
6893 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6898 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6903 XSETFRAME (frame
, f
);
6909 any_help_event_p
= 1;
6910 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6911 help_echo_object
, help_echo_pos
);
6915 help_echo_string
= Qnil
;
6916 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6925 /* Handles the XEvent EVENT on display DISPLAY.
6926 This is used for event loops outside the normal event handling,
6927 i.e. looping while a popup menu or a dialog is posted.
6929 Returns the value handle_one_xevent sets in the finish argument. */
6931 x_dispatch_event (XEvent
*event
, Display
*display
)
6933 struct x_display_info
*dpyinfo
;
6934 int finish
= X_EVENT_NORMAL
;
6936 dpyinfo
= x_display_info_for_display (display
);
6939 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
6944 /* Read events coming from the X server.
6945 Return as soon as there are no more events to be read.
6947 Return the number of characters stored into the buffer,
6948 thus pretending to be `read' (except the characters we store
6949 in the keyboard buffer can be multibyte, so are not necessarily
6953 XTread_socket (struct terminal
*terminal
, struct input_event
*hold_quit
)
6956 int event_found
= 0;
6957 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
6961 /* For debugging, this gives a way to fake an I/O error. */
6962 if (dpyinfo
== XTread_socket_fake_io_error
)
6964 XTread_socket_fake_io_error
= 0;
6965 x_io_error_quitter (dpyinfo
->display
);
6969 while (XPending (dpyinfo
->display
))
6974 XNextEvent (dpyinfo
->display
, &event
);
6977 /* Filter events for the current X input method. */
6978 if (x_filter_event (dpyinfo
, &event
))
6983 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
6985 if (finish
== X_EVENT_GOTO_OUT
)
6991 /* For GTK we must use the GTK event loop. But XEvents gets passed
6992 to our filter function above, and then to the big event switch.
6993 We use a bunch of globals to communicate with our filter function,
6994 that is kind of ugly, but it works.
6996 There is no way to do one display at the time, GTK just does events
6997 from all displays. */
6999 while (gtk_events_pending ())
7001 current_count
= count
;
7002 current_hold_quit
= hold_quit
;
7004 gtk_main_iteration ();
7006 count
= current_count
;
7008 current_hold_quit
= 0;
7010 if (current_finish
== X_EVENT_GOTO_OUT
)
7013 #endif /* USE_GTK */
7015 /* On some systems, an X bug causes Emacs to get no more events
7016 when the window is destroyed. Detect that. (1994.) */
7019 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7020 One XNOOP in 100 loops will make Emacs terminate.
7021 B. Bretthauer, 1994 */
7023 if (x_noop_count
>= 100)
7027 if (next_noop_dpyinfo
== 0)
7028 next_noop_dpyinfo
= x_display_list
;
7030 XNoOp (next_noop_dpyinfo
->display
);
7032 /* Each time we get here, cycle through the displays now open. */
7033 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7037 /* If the focus was just given to an auto-raising frame,
7038 raise it now. FIXME: handle more than one such frame. */
7039 if (dpyinfo
->x_pending_autoraise_frame
)
7041 x_raise_frame (dpyinfo
->x_pending_autoraise_frame
);
7042 dpyinfo
->x_pending_autoraise_frame
= NULL
;
7053 /***********************************************************************
7055 ***********************************************************************/
7057 /* Set clipping for output in glyph row ROW. W is the window in which
7058 we operate. GC is the graphics context to set clipping in.
7060 ROW may be a text row or, e.g., a mode line. Text rows must be
7061 clipped to the interior of the window dedicated to text display,
7062 mode lines must be clipped to the whole window. */
7065 x_clip_to_row (struct window
*w
, struct glyph_row
*row
,
7066 enum glyph_row_area area
, GC gc
)
7068 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7069 XRectangle clip_rect
;
7070 int window_x
, window_y
, window_width
;
7072 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7074 clip_rect
.x
= window_x
;
7075 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7076 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7077 clip_rect
.width
= window_width
;
7078 clip_rect
.height
= row
->visible_height
;
7080 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7084 /* Draw a hollow box cursor on window W in glyph row ROW. */
7087 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
7089 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7090 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
7091 Display
*dpy
= FRAME_X_DISPLAY (f
);
7094 struct glyph
*cursor_glyph
;
7097 /* Get the glyph the cursor is on. If we can't tell because
7098 the current matrix is invalid or such, give up. */
7099 cursor_glyph
= get_phys_cursor_glyph (w
);
7100 if (cursor_glyph
== NULL
)
7103 /* Compute frame-relative coordinates for phys cursor. */
7104 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7105 wd
= w
->phys_cursor_width
;
7107 /* The foreground of cursor_gc is typically the same as the normal
7108 background color, which can cause the cursor box to be invisible. */
7109 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7110 if (dpyinfo
->scratch_cursor_gc
)
7111 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7113 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7114 GCForeground
, &xgcv
);
7115 gc
= dpyinfo
->scratch_cursor_gc
;
7117 /* Set clipping, draw the rectangle, and reset clipping again. */
7118 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7119 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7120 XSetClipMask (dpy
, gc
, None
);
7124 /* Draw a bar cursor on window W in glyph row ROW.
7126 Implementation note: One would like to draw a bar cursor with an
7127 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7128 Unfortunately, I didn't find a font yet that has this property set.
7132 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
7134 struct frame
*f
= XFRAME (w
->frame
);
7135 struct glyph
*cursor_glyph
;
7137 /* If cursor is out of bounds, don't draw garbage. This can happen
7138 in mini-buffer windows when switching between echo area glyphs
7140 cursor_glyph
= get_phys_cursor_glyph (w
);
7141 if (cursor_glyph
== NULL
)
7144 /* If on an image, draw like a normal cursor. That's usually better
7145 visible than drawing a bar, esp. if the image is large so that
7146 the bar might not be in the window. */
7147 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7149 struct glyph_row
*r
;
7150 r
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7151 draw_phys_cursor_glyph (w
, r
, DRAW_CURSOR
);
7155 Display
*dpy
= FRAME_X_DISPLAY (f
);
7156 Window window
= FRAME_X_WINDOW (f
);
7157 GC gc
= FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7158 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7159 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7162 /* If the glyph's background equals the color we normally draw
7163 the bars cursor in, the bar cursor in its normal color is
7164 invisible. Use the glyph's foreground color instead in this
7165 case, on the assumption that the glyph's colors are chosen so
7166 that the glyph is legible. */
7167 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7168 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7170 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7171 xgcv
.graphics_exposures
= 0;
7174 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7177 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7178 FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7181 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7183 if (kind
== BAR_CURSOR
)
7185 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
7188 width
= FRAME_CURSOR_WIDTH (f
);
7189 width
= min (cursor_glyph
->pixel_width
, width
);
7191 w
->phys_cursor_width
= width
;
7193 /* If the character under cursor is R2L, draw the bar cursor
7194 on the right of its glyph, rather than on the left. */
7195 if ((cursor_glyph
->resolved_level
& 1) != 0)
7196 x
+= cursor_glyph
->pixel_width
- width
;
7198 XFillRectangle (dpy
, window
, gc
, x
,
7199 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7200 width
, row
->height
);
7204 int dummy_x
, dummy_y
, dummy_h
;
7207 width
= row
->height
;
7209 width
= min (row
->height
, width
);
7211 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
7212 &dummy_y
, &dummy_h
);
7214 XFillRectangle (dpy
, window
, gc
,
7215 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7216 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7217 row
->height
- width
),
7218 w
->phys_cursor_width
, width
);
7221 XSetClipMask (dpy
, gc
, None
);
7226 /* RIF: Define cursor CURSOR on frame F. */
7229 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
7231 if (!f
->pointer_invisible
7232 && f
->output_data
.x
->current_cursor
!= cursor
)
7233 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7234 f
->output_data
.x
->current_cursor
= cursor
;
7238 /* RIF: Clear area on frame F. */
7241 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
7243 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), x
, y
, width
, height
);
7245 /* Must queue a redraw, because scroll bars might have been cleared. */
7246 if (FRAME_GTK_WIDGET (f
))
7247 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
7252 /* RIF: Draw cursor on window W. */
7255 x_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
, int x
,
7256 int y
, enum text_cursor_kinds cursor_type
,
7257 int cursor_width
, bool on_p
, bool active_p
)
7259 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7263 w
->phys_cursor_type
= cursor_type
;
7264 w
->phys_cursor_on_p
= 1;
7266 if (glyph_row
->exact_window_width_line_p
7267 && (glyph_row
->reversed_p
7268 ? (w
->phys_cursor
.hpos
< 0)
7269 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
7271 glyph_row
->cursor_in_fringe_p
= 1;
7272 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
7276 switch (cursor_type
)
7278 case HOLLOW_BOX_CURSOR
:
7279 x_draw_hollow_cursor (w
, glyph_row
);
7282 case FILLED_BOX_CURSOR
:
7283 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7287 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7291 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7295 w
->phys_cursor_width
= 0;
7304 if (w
== XWINDOW (f
->selected_window
))
7305 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7306 xic_set_preeditarea (w
, x
, y
);
7310 XFlush (FRAME_X_DISPLAY (f
));
7316 /* Make the x-window of frame F use the gnu icon bitmap. */
7319 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
7321 ptrdiff_t bitmap_id
;
7323 if (FRAME_X_WINDOW (f
) == 0)
7326 /* Free up our existing icon bitmap and mask if any. */
7327 if (f
->output_data
.x
->icon_bitmap
> 0)
7328 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7329 f
->output_data
.x
->icon_bitmap
= 0;
7334 /* Use gtk_window_set_icon_from_file () if available,
7335 It's not restricted to bitmaps */
7336 if (xg_set_icon (f
, file
))
7338 #endif /* USE_GTK */
7339 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7340 x_create_bitmap_mask (f
, bitmap_id
);
7344 /* Create the GNU bitmap and mask if necessary. */
7345 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7351 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
== -2
7352 || xg_set_icon (f
, xg_default_icon_file
)
7353 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
7355 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= -2;
7359 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7361 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
7363 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7367 /* If all else fails, use the (black and white) xbm image. */
7370 rc
= x_create_bitmap_from_data (f
, (char *) gnu_xbm_bits
,
7371 gnu_xbm_width
, gnu_xbm_height
);
7375 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7376 x_create_bitmap_mask (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
7380 /* The first time we create the GNU bitmap and mask,
7381 this increments the ref-count one extra time.
7382 As a result, the GNU bitmap and mask are never freed.
7383 That way, we don't have to worry about allocating it again. */
7384 x_reference_bitmap (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
7386 bitmap_id
= FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
;
7389 x_wm_set_icon_pixmap (f
, bitmap_id
);
7390 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7396 /* Make the x-window of frame F use a rectangle with text.
7397 Use ICON_NAME as the text. */
7400 x_text_icon (struct frame
*f
, const char *icon_name
)
7402 if (FRAME_X_WINDOW (f
) == 0)
7407 text
.value
= (unsigned char *) icon_name
;
7408 text
.encoding
= XA_STRING
;
7410 text
.nitems
= strlen (icon_name
);
7411 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7414 if (f
->output_data
.x
->icon_bitmap
> 0)
7415 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7416 f
->output_data
.x
->icon_bitmap
= 0;
7417 x_wm_set_icon_pixmap (f
, 0);
7422 #define X_ERROR_MESSAGE_SIZE 200
7424 /* If non-nil, this should be a string.
7425 It means catch X errors and store the error message in this string.
7427 The reason we use a stack is that x_catch_error/x_uncatch_error can
7428 be called from a signal handler.
7431 struct x_error_message_stack
{
7432 char string
[X_ERROR_MESSAGE_SIZE
];
7434 struct x_error_message_stack
*prev
;
7436 static struct x_error_message_stack
*x_error_message
;
7438 /* An X error handler which stores the error message in
7439 *x_error_message. This is called from x_error_handler if
7440 x_catch_errors is in effect. */
7443 x_error_catcher (Display
*display
, XErrorEvent
*event
)
7445 XGetErrorText (display
, event
->error_code
,
7446 x_error_message
->string
,
7447 X_ERROR_MESSAGE_SIZE
);
7450 /* Begin trapping X errors for display DPY. Actually we trap X errors
7451 for all displays, but DPY should be the display you are actually
7454 After calling this function, X protocol errors no longer cause
7455 Emacs to exit; instead, they are recorded in the string
7456 stored in *x_error_message.
7458 Calling x_check_errors signals an Emacs error if an X error has
7459 occurred since the last call to x_catch_errors or x_check_errors.
7461 Calling x_uncatch_errors resumes the normal error handling. */
7464 x_catch_errors (Display
*dpy
)
7466 struct x_error_message_stack
*data
= xmalloc (sizeof *data
);
7468 /* Make sure any errors from previous requests have been dealt with. */
7472 data
->string
[0] = 0;
7473 data
->prev
= x_error_message
;
7474 x_error_message
= data
;
7477 /* Undo the last x_catch_errors call.
7478 DPY should be the display that was passed to x_catch_errors. */
7481 x_uncatch_errors (void)
7483 struct x_error_message_stack
*tmp
;
7487 /* The display may have been closed before this function is called.
7488 Check if it is still open before calling XSync. */
7489 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
7490 XSync (x_error_message
->dpy
, False
);
7492 tmp
= x_error_message
;
7493 x_error_message
= x_error_message
->prev
;
7498 /* If any X protocol errors have arrived since the last call to
7499 x_catch_errors or x_check_errors, signal an Emacs error using
7500 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7503 x_check_errors (Display
*dpy
, const char *format
)
7505 /* Make sure to catch any errors incurred so far. */
7508 if (x_error_message
->string
[0])
7510 char string
[X_ERROR_MESSAGE_SIZE
];
7511 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
7512 x_uncatch_errors ();
7513 error (format
, string
);
7517 /* Nonzero if we had any X protocol errors
7518 since we did x_catch_errors on DPY. */
7521 x_had_errors_p (Display
*dpy
)
7523 /* Make sure to catch any errors incurred so far. */
7526 return x_error_message
->string
[0] != 0;
7529 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7532 x_clear_errors (Display
*dpy
)
7534 x_error_message
->string
[0] = 0;
7537 #if 0 /* See comment in unwind_to_catch why calling this is a bad
7538 * idea. --lorentey */
7539 /* Close off all unclosed x_catch_errors calls. */
7542 x_fully_uncatch_errors (void)
7544 while (x_error_message
)
7545 x_uncatch_errors ();
7550 static unsigned int x_wire_count
;
7553 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7558 /************************************************************************
7560 ************************************************************************/
7562 /* Error message passed to x_connection_closed. */
7564 static char *error_msg
;
7566 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7567 the text of an error message that lead to the connection loss. */
7570 x_connection_closed (Display
*dpy
, const char *error_message
)
7572 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7573 Lisp_Object frame
, tail
;
7574 ptrdiff_t idx
= SPECPDL_INDEX ();
7576 error_msg
= alloca (strlen (error_message
) + 1);
7577 strcpy (error_msg
, error_message
);
7579 /* Inhibit redisplay while frames are being deleted. */
7580 specbind (Qinhibit_redisplay
, Qt
);
7584 /* Protect display from being closed when we delete the last
7586 dpyinfo
->reference_count
++;
7587 dpyinfo
->terminal
->reference_count
++;
7590 /* First delete frames whose mini-buffers are on frames
7591 that are on the dead display. */
7592 FOR_EACH_FRAME (tail
, frame
)
7594 Lisp_Object minibuf_frame
;
7596 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7597 if (FRAME_X_P (XFRAME (frame
))
7598 && FRAME_X_P (XFRAME (minibuf_frame
))
7599 && ! EQ (frame
, minibuf_frame
)
7600 && FRAME_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7601 delete_frame (frame
, Qnoelisp
);
7604 /* Now delete all remaining frames on the dead display.
7605 We are now sure none of these is used as the mini-buffer
7606 for another frame that we need to delete. */
7607 FOR_EACH_FRAME (tail
, frame
)
7608 if (FRAME_X_P (XFRAME (frame
))
7609 && FRAME_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7611 /* Set this to t so that delete_frame won't get confused
7612 trying to find a replacement. */
7613 kset_default_minibuffer_frame (FRAME_KBOARD (XFRAME (frame
)), Qt
);
7614 delete_frame (frame
, Qnoelisp
);
7617 /* If DPYINFO is null, this means we didn't open the display in the
7618 first place, so don't try to close it. */
7621 /* We can not call XtCloseDisplay here because it calls XSync.
7622 XSync inside the error handler apparently hangs Emacs. On
7623 current Xt versions, this isn't needed either. */
7625 /* A long-standing GTK bug prevents proper disconnect handling
7626 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Once,
7627 the resulting Glib error message loop filled a user's disk.
7628 To avoid this, kill Emacs unconditionally on disconnect. */
7629 shut_down_emacs (0, Qnil
);
7630 fprintf (stderr
, "%s\n\
7631 When compiled with GTK, Emacs cannot recover from X disconnects.\n\
7632 This is a GTK bug: https://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
7633 For details, see etc/PROBLEMS.\n",
7636 #endif /* USE_GTK */
7638 /* Indicate that this display is dead. */
7639 dpyinfo
->display
= 0;
7641 dpyinfo
->reference_count
--;
7642 dpyinfo
->terminal
->reference_count
--;
7643 if (dpyinfo
->reference_count
!= 0)
7644 /* We have just closed all frames on this display. */
7649 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
7650 Fdelete_terminal (tmp
, Qnoelisp
);
7654 if (terminal_list
== 0)
7656 fprintf (stderr
, "%s\n", error_msg
);
7657 Fkill_emacs (make_number (70));
7661 totally_unblock_input ();
7663 unbind_to (idx
, Qnil
);
7664 clear_waiting_for_input ();
7666 /* Tell GCC not to suggest attribute 'noreturn' for this function. */
7667 IF_LINT (if (! terminal_list
) return; )
7669 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
7670 longjmp), because returning from this function would get us back into
7671 Xlib's code which will directly call `exit'. */
7672 error ("%s", error_msg
);
7675 /* We specifically use it before defining it, so that gcc doesn't inline it,
7676 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7677 static void x_error_quitter (Display
*, XErrorEvent
*);
7679 /* This is the first-level handler for X protocol errors.
7680 It calls x_error_quitter or x_error_catcher. */
7683 x_error_handler (Display
*display
, XErrorEvent
*event
)
7685 #if defined USE_GTK && defined HAVE_GTK3
7686 if ((event
->error_code
== BadMatch
|| event
->error_code
== BadWindow
)
7687 && event
->request_code
== X_SetInputFocus
)
7693 if (x_error_message
)
7694 x_error_catcher (display
, event
);
7696 x_error_quitter (display
, event
);
7700 /* This is the usual handler for X protocol errors.
7701 It kills all frames on the display that we got the error for.
7702 If that was the only one, it prints an error message and kills Emacs. */
7704 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7706 /* On older GCC versions, just putting x_error_quitter
7707 after x_error_handler prevents inlining into the former. */
7709 static void NO_INLINE
7710 x_error_quitter (Display
*display
, XErrorEvent
*event
)
7712 char buf
[256], buf1
[356];
7714 /* Ignore BadName errors. They can happen because of fonts
7715 or colors that are not defined. */
7717 if (event
->error_code
== BadName
)
7720 /* Note that there is no real way portable across R3/R4 to get the
7721 original error handler. */
7723 XGetErrorText (display
, event
->error_code
, buf
, sizeof (buf
));
7724 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7725 buf
, event
->request_code
);
7726 x_connection_closed (display
, buf1
);
7730 /* This is the handler for X IO errors, always.
7731 It kills all frames on the display that we lost touch with.
7732 If that was the only one, it prints an error message and kills Emacs. */
7735 x_io_error_quitter (Display
*display
)
7739 snprintf (buf
, sizeof buf
, "Connection lost to X server `%s'",
7740 DisplayString (display
));
7741 x_connection_closed (display
, buf
);
7745 /* Changing the font of the frame. */
7747 /* Give frame F the font FONT-OBJECT as its default font. The return
7748 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
7749 frame. If it is negative, generate a new fontset from
7753 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
7755 struct font
*font
= XFONT_OBJECT (font_object
);
7759 fontset
= fontset_from_font (font_object
);
7760 FRAME_FONTSET (f
) = fontset
;
7761 if (FRAME_FONT (f
) == font
)
7762 /* This font is already set in frame F. There's nothing more to
7766 FRAME_FONT (f
) = font
;
7767 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
7768 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
7769 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
7771 FRAME_TOOL_BAR_HEIGHT (f
) = FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
);
7772 FRAME_MENU_BAR_HEIGHT (f
) = FRAME_MENU_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
);
7774 compute_fringe_widths (f
, 1);
7776 /* Compute character columns occupied by scrollbar.
7778 Don't do things differently for non-toolkit scrollbars
7780 unit
= FRAME_COLUMN_WIDTH (f
);
7781 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7782 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7783 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
7785 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
7787 if (FRAME_X_WINDOW (f
) != 0)
7789 /* Don't change the size of a tip frame; there's no point in
7790 doing it because it's done in Fx_show_tip, and it leads to
7791 problems because the tip frame has no widget. */
7792 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7793 x_set_window_size (f
, 0, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
7794 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 1);
7799 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7802 xic_set_xfontset (f
, SSDATA (fontset_ascii (fontset
)));
7811 /***********************************************************************
7813 ***********************************************************************/
7819 /* XIM destroy callback function, which is called whenever the
7820 connection to input method XIM dies. CLIENT_DATA contains a
7821 pointer to the x_display_info structure corresponding to XIM. */
7824 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
7826 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
7827 Lisp_Object frame
, tail
;
7831 /* No need to call XDestroyIC.. */
7832 FOR_EACH_FRAME (tail
, frame
)
7834 struct frame
*f
= XFRAME (frame
);
7835 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
7837 FRAME_XIC (f
) = NULL
;
7838 xic_free_xfontset (f
);
7842 /* No need to call XCloseIM. */
7843 dpyinfo
->xim
= NULL
;
7844 XFree (dpyinfo
->xim_styles
);
7848 #endif /* HAVE_X11R6 */
7850 /* Open the connection to the XIM server on display DPYINFO.
7851 RESOURCE_NAME is the resource name Emacs uses. */
7854 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
7862 XCloseIM (dpyinfo
->xim
);
7863 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
7870 XIMCallback destroy
;
7873 /* Get supported styles and XIM values. */
7874 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
7877 destroy
.callback
= xim_destroy_callback
;
7878 destroy
.client_data
= (XPointer
)dpyinfo
;
7879 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
7885 #endif /* HAVE_XIM */
7886 dpyinfo
->xim
= NULL
;
7890 #ifdef HAVE_X11R6_XIM
7892 /* XIM instantiate callback function, which is called whenever an XIM
7893 server is available. DISPLAY is the display of the XIM.
7894 CLIENT_DATA contains a pointer to an xim_inst_t structure created
7895 when the callback was registered. */
7898 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
7900 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
7901 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
7903 /* We don't support multiple XIM connections. */
7907 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
7909 /* Create XIC for the existing frames on the same display, as long
7910 as they have no XIC. */
7911 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
7913 Lisp_Object tail
, frame
;
7916 FOR_EACH_FRAME (tail
, frame
)
7918 struct frame
*f
= XFRAME (frame
);
7921 && FRAME_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
7922 if (FRAME_XIC (f
) == NULL
)
7924 create_frame_xic (f
);
7925 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
7926 xic_set_statusarea (f
);
7927 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
7929 struct window
*w
= XWINDOW (f
->selected_window
);
7930 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
7939 #endif /* HAVE_X11R6_XIM */
7942 /* Open a connection to the XIM server on display DPYINFO.
7943 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
7944 connection only at the first time. On X11R6, open the connection
7945 in the XIM instantiate callback function. */
7948 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
7950 dpyinfo
->xim
= NULL
;
7954 #ifdef HAVE_X11R6_XIM
7955 struct xim_inst_t
*xim_inst
= xmalloc (sizeof *xim_inst
);
7958 dpyinfo
->xim_callback_data
= xim_inst
;
7959 xim_inst
->dpyinfo
= dpyinfo
;
7960 xim_inst
->resource_name
= xstrdup (resource_name
);
7961 ret
= XRegisterIMInstantiateCallback
7962 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
7963 emacs_class
, xim_instantiate_callback
,
7964 /* This is XPointer in XFree86 but (XPointer *)
7965 on Tru64, at least, hence the configure test. */
7966 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
7967 eassert (ret
== True
);
7968 #else /* not HAVE_X11R6_XIM */
7969 xim_open_dpy (dpyinfo
, resource_name
);
7970 #endif /* not HAVE_X11R6_XIM */
7972 #endif /* HAVE_XIM */
7976 /* Close the connection to the XIM server on display DPYINFO. */
7979 xim_close_dpy (struct x_display_info
*dpyinfo
)
7984 #ifdef HAVE_X11R6_XIM
7985 struct xim_inst_t
*xim_inst
= dpyinfo
->xim_callback_data
;
7987 if (dpyinfo
->display
)
7989 Bool ret
= XUnregisterIMInstantiateCallback
7990 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
7991 emacs_class
, xim_instantiate_callback
,
7992 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
7993 eassert (ret
== True
);
7995 xfree (xim_inst
->resource_name
);
7997 #endif /* HAVE_X11R6_XIM */
7998 if (dpyinfo
->display
)
7999 XCloseIM (dpyinfo
->xim
);
8000 dpyinfo
->xim
= NULL
;
8001 XFree (dpyinfo
->xim_styles
);
8003 #endif /* HAVE_XIM */
8006 #endif /* not HAVE_X11R6_XIM */
8010 /* Calculate the absolute position in frame F
8011 from its current recorded position values and gravity. */
8014 x_calc_absolute_position (struct frame
*f
)
8016 int flags
= f
->size_hint_flags
;
8018 /* We have nothing to do if the current position
8019 is already for the top-left corner. */
8020 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8023 /* Treat negative positions as relative to the leftmost bottommost
8024 position that fits on the screen. */
8025 if (flags
& XNegative
)
8026 f
->left_pos
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
8027 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
8030 int height
= FRAME_PIXEL_HEIGHT (f
);
8032 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8033 /* Something is fishy here. When using Motif, starting Emacs with
8034 `-g -0-0', the frame appears too low by a few pixels.
8036 This seems to be so because initially, while Emacs is starting,
8037 the column widget's height and the frame's pixel height are
8038 different. The column widget's height is the right one. In
8039 later invocations, when Emacs is up, the frame's pixel height
8042 It's not obvious where the initial small difference comes from.
8043 2000-12-01, gerd. */
8045 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8048 if (flags
& YNegative
)
8049 f
->top_pos
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
8050 - height
+ f
->top_pos
;
8053 /* The left_pos and top_pos
8054 are now relative to the top and left screen edges,
8055 so the flags should correspond. */
8056 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8059 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8060 to really change the position, and 0 when calling from
8061 x_make_frame_visible (in that case, XOFF and YOFF are the current
8062 position values). It is -1 when calling from x_set_frame_parameters,
8063 which means, do adjust for borders but don't change the gravity. */
8066 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
8068 int modified_top
, modified_left
;
8070 if (change_gravity
> 0)
8074 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8076 f
->size_hint_flags
|= XNegative
;
8078 f
->size_hint_flags
|= YNegative
;
8079 f
->win_gravity
= NorthWestGravity
;
8081 x_calc_absolute_position (f
);
8084 x_wm_set_size_hint (f
, 0, 0);
8086 modified_left
= f
->left_pos
;
8087 modified_top
= f
->top_pos
;
8089 if (change_gravity
!= 0 && FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8091 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8092 than the WM decorations. So we use the calculated offset instead
8093 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8094 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8095 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8098 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8099 modified_left
, modified_top
);
8101 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8102 FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8105 /* change_gravity is non-zero when this function is called from Lisp to
8106 programmatically move a frame. In that case, we call
8107 x_check_expected_move to discover if we have a "Type A" or "Type B"
8108 window manager, and, for a "Type A" window manager, adjust the position
8111 We call x_check_expected_move if a programmatic move occurred, and
8112 either the window manager type (A/B) is unknown or it is Type A but we
8113 need to compute the top/left offset adjustment for this frame. */
8115 if (change_gravity
!= 0 &&
8116 (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8117 || (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8118 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8119 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8120 x_check_expected_move (f
, modified_left
, modified_top
);
8125 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8126 on the root window for frame F contains ATOMNAME.
8127 This is how a WM check shall be done according to the Window Manager
8128 Specification/Extended Window Manager Hints at
8129 http://freedesktop.org/wiki/Specifications/wm-spec. */
8132 wm_supports (struct frame
*f
, Atom want_atom
)
8135 unsigned long actual_size
, bytes_remaining
;
8136 int i
, rc
, actual_format
;
8137 Window wmcheck_window
;
8138 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8139 Window target_window
= dpyinfo
->root_window
;
8140 long max_len
= 65536;
8141 Display
*dpy
= FRAME_X_DISPLAY (f
);
8142 unsigned char *tmp_data
= NULL
;
8143 Atom target_type
= XA_WINDOW
;
8147 x_catch_errors (dpy
);
8148 rc
= XGetWindowProperty (dpy
, target_window
,
8149 dpyinfo
->Xatom_net_supporting_wm_check
,
8150 0, max_len
, False
, target_type
,
8151 &actual_type
, &actual_format
, &actual_size
,
8152 &bytes_remaining
, &tmp_data
);
8154 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8156 if (tmp_data
) XFree (tmp_data
);
8157 x_uncatch_errors ();
8162 wmcheck_window
= *(Window
*) tmp_data
;
8165 /* Check if window exists. */
8166 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8168 if (x_had_errors_p (dpy
))
8170 x_uncatch_errors ();
8175 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8177 /* Window changed, reload atoms */
8178 if (dpyinfo
->net_supported_atoms
!= NULL
)
8179 XFree (dpyinfo
->net_supported_atoms
);
8180 dpyinfo
->net_supported_atoms
= NULL
;
8181 dpyinfo
->nr_net_supported_atoms
= 0;
8182 dpyinfo
->net_supported_window
= 0;
8184 target_type
= XA_ATOM
;
8186 rc
= XGetWindowProperty (dpy
, target_window
,
8187 dpyinfo
->Xatom_net_supported
,
8188 0, max_len
, False
, target_type
,
8189 &actual_type
, &actual_format
, &actual_size
,
8190 &bytes_remaining
, &tmp_data
);
8192 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8194 if (tmp_data
) XFree (tmp_data
);
8195 x_uncatch_errors ();
8200 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8201 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8202 dpyinfo
->net_supported_window
= wmcheck_window
;
8207 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8208 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8210 x_uncatch_errors ();
8217 set_wm_state (Lisp_Object frame
, int add
, Atom atom
, Atom value
)
8219 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (XFRAME (frame
));
8221 x_send_client_event (frame
, make_number (0), frame
,
8222 dpyinfo
->Xatom_net_wm_state
,
8224 /* 1 = add, 0 = remove */
8226 (make_number (add
? 1 : 0),
8228 (make_fixnum_or_float (atom
),
8230 ? list1 (make_fixnum_or_float (value
))
8235 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
8238 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8240 XSETFRAME (frame
, f
);
8242 set_wm_state (frame
, NILP (new_value
) ? 0 : 1,
8243 dpyinfo
->Xatom_net_wm_state_sticky
, None
);
8246 /* Return the current _NET_WM_STATE.
8247 SIZE_STATE is set to one of the FULLSCREEN_* values.
8248 STICKY is set to 1 if the sticky state is set, 0 if not.
8250 Return non-zero if we are not hidden, zero if we are. */
8253 get_current_wm_state (struct frame
*f
,
8259 unsigned long actual_size
, bytes_remaining
;
8260 int i
, rc
, actual_format
, is_hidden
= 0;
8261 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8262 long max_len
= 65536;
8263 Display
*dpy
= FRAME_X_DISPLAY (f
);
8264 unsigned char *tmp_data
= NULL
;
8265 Atom target_type
= XA_ATOM
;
8268 *size_state
= FULLSCREEN_NONE
;
8271 x_catch_errors (dpy
);
8272 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
8273 0, max_len
, False
, target_type
,
8274 &actual_type
, &actual_format
, &actual_size
,
8275 &bytes_remaining
, &tmp_data
);
8277 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
8279 if (tmp_data
) XFree (tmp_data
);
8280 x_uncatch_errors ();
8282 return !FRAME_ICONIFIED_P (f
);
8285 x_uncatch_errors ();
8287 for (i
= 0; i
< actual_size
; ++i
)
8289 Atom a
= ((Atom
*)tmp_data
)[i
];
8290 if (a
== dpyinfo
->Xatom_net_wm_state_hidden
)
8293 f
->output_data
.x
->net_wm_state_hidden_seen
= 1;
8295 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
8297 if (*size_state
== FULLSCREEN_HEIGHT
)
8298 *size_state
= FULLSCREEN_MAXIMIZED
;
8300 *size_state
= FULLSCREEN_WIDTH
;
8302 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
8304 if (*size_state
== FULLSCREEN_WIDTH
)
8305 *size_state
= FULLSCREEN_MAXIMIZED
;
8307 *size_state
= FULLSCREEN_HEIGHT
;
8309 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen
)
8310 *size_state
= FULLSCREEN_BOTH
;
8311 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
8315 if (tmp_data
) XFree (tmp_data
);
8320 /* Do fullscreen as specified in extended window manager hints */
8323 do_ewmh_fullscreen (struct frame
*f
)
8325 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8326 int have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state
);
8329 (void)get_current_wm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
8331 /* Some window managers don't say they support _NET_WM_STATE, but they do say
8332 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
8334 have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state_fullscreen
);
8336 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
8340 XSETFRAME (frame
, f
);
8342 /* Keep number of calls to set_wm_state as low as possible.
8343 Some window managers, or possible Gtk+, hangs when too many
8344 are sent at once. */
8345 switch (f
->want_fullscreen
)
8347 case FULLSCREEN_BOTH
:
8348 if (cur
== FULLSCREEN_WIDTH
|| cur
== FULLSCREEN_MAXIMIZED
8349 || cur
== FULLSCREEN_HEIGHT
)
8350 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
8351 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8352 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
8354 case FULLSCREEN_WIDTH
:
8355 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
8356 || cur
== FULLSCREEN_MAXIMIZED
)
8357 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
,
8358 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8359 if (cur
!= FULLSCREEN_MAXIMIZED
)
8360 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
8362 case FULLSCREEN_HEIGHT
:
8363 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
8364 || cur
== FULLSCREEN_MAXIMIZED
)
8365 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
,
8366 dpyinfo
->Xatom_net_wm_state_maximized_horz
);
8367 if (cur
!= FULLSCREEN_MAXIMIZED
)
8368 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
8370 case FULLSCREEN_MAXIMIZED
:
8371 if (cur
== FULLSCREEN_BOTH
)
8372 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
8373 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
8374 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8376 case FULLSCREEN_NONE
:
8377 if (cur
== FULLSCREEN_BOTH
)
8378 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
8380 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
8381 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8384 f
->want_fullscreen
= FULLSCREEN_NONE
;
8388 return have_net_atom
;
8392 XTfullscreen_hook (struct frame
*f
)
8394 if (FRAME_VISIBLE_P (f
))
8397 x_check_fullscreen (f
);
8405 x_handle_net_wm_state (struct frame
*f
, const XPropertyEvent
*event
)
8407 int value
= FULLSCREEN_NONE
;
8410 int not_hidden
= get_current_wm_state (f
, event
->window
, &value
, &sticky
);
8415 case FULLSCREEN_WIDTH
:
8418 case FULLSCREEN_HEIGHT
:
8421 case FULLSCREEN_BOTH
:
8424 case FULLSCREEN_MAXIMIZED
:
8429 store_frame_param (f
, Qfullscreen
, lval
);
8430 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
8435 /* Check if we need to resize the frame due to a fullscreen request.
8436 If so needed, resize the frame. */
8438 x_check_fullscreen (struct frame
*f
)
8440 if (do_ewmh_fullscreen (f
))
8443 if (f
->output_data
.x
->parent_desc
!= FRAME_DISPLAY_INFO (f
)->root_window
)
8444 return; /* Only fullscreen without WM or with EWM hints (above). */
8446 /* Setting fullscreen to nil doesn't do anything. We could save the
8447 last non-fullscreen size and restore it, but it seems like a
8448 lot of work for this unusual case (no window manager running). */
8450 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
8452 int width
= FRAME_PIXEL_WIDTH (f
), height
= FRAME_PIXEL_HEIGHT (f
);
8453 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8455 switch (f
->want_fullscreen
)
8457 /* No difference between these two when there is no WM */
8458 case FULLSCREEN_BOTH
:
8459 case FULLSCREEN_MAXIMIZED
:
8460 width
= x_display_pixel_width (dpyinfo
);
8461 height
= x_display_pixel_height (dpyinfo
);
8463 case FULLSCREEN_WIDTH
:
8464 width
= x_display_pixel_width (dpyinfo
);
8466 case FULLSCREEN_HEIGHT
:
8467 height
= x_display_pixel_height (dpyinfo
);
8470 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8475 /* This function is called by x_set_offset to determine whether the window
8476 manager interfered with the positioning of the frame. Type A window
8477 managers position the surrounding window manager decorations a small
8478 amount above and left of the user-supplied position. Type B window
8479 managers position the surrounding window manager decorations at the
8480 user-specified position. If we detect a Type A window manager, we
8481 compensate by moving the window right and down by the proper amount. */
8484 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
8486 int current_left
= 0, current_top
= 0;
8488 /* x_real_positions returns the left and top offsets of the outermost
8489 window manager window around the frame. */
8491 x_real_positions (f
, ¤t_left
, ¤t_top
);
8493 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8495 /* It's a "Type A" window manager. */
8500 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8501 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8502 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8504 /* Now fix the mispositioned frame's location. */
8506 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8507 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8509 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8510 adjusted_left
, adjusted_top
);
8512 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8515 /* It's a "Type B" window manager. We don't have to adjust the
8516 frame's position. */
8518 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8522 /* Wait for XGetGeometry to return up-to-date position information for a
8523 recently-moved frame. Call this immediately after calling XMoveWindow.
8524 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8525 frame has been moved to, so we use a fuzzy position comparison instead
8526 of an exact comparison. */
8529 x_sync_with_move (struct frame
*f
, int left
, int top
, int fuzzy
)
8533 while (count
++ < 50)
8535 int current_left
= 0, current_top
= 0;
8537 /* In theory, this call to XSync only needs to happen once, but in
8538 practice, it doesn't seem to work, hence the need for the surrounding
8541 XSync (FRAME_X_DISPLAY (f
), False
);
8542 x_real_positions (f
, ¤t_left
, ¤t_top
);
8546 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8549 if (eabs (current_left
- left
) <= 10
8550 && eabs (current_top
- top
) <= 40)
8553 else if (current_left
== left
&& current_top
== top
)
8557 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8558 will then return up-to-date position info. */
8560 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8564 /* Wait for an event on frame F matching EVENTTYPE. */
8566 x_wait_for_event (struct frame
*f
, int eventtype
)
8568 int level
= interrupt_input_blocked
;
8571 struct timespec tmo
, tmo_at
, time_now
;
8572 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
8574 f
->wait_event_type
= eventtype
;
8576 /* Set timeout to 0.1 second. Hopefully not noticeable.
8577 Maybe it should be configurable. */
8578 tmo
= make_timespec (0, 100 * 1000 * 1000);
8579 tmo_at
= timespec_add (current_timespec (), tmo
);
8581 while (f
->wait_event_type
)
8583 pending_signals
= 1;
8584 totally_unblock_input ();
8585 /* XTread_socket is called after unblock. */
8587 interrupt_input_blocked
= level
;
8592 time_now
= current_timespec ();
8593 if (timespec_cmp (tmo_at
, time_now
) < 0)
8596 tmo
= timespec_sub (tmo_at
, time_now
);
8597 if (pselect (fd
+ 1, &fds
, NULL
, NULL
, &tmo
, NULL
) == 0)
8598 break; /* Timeout */
8601 f
->wait_event_type
= 0;
8605 /* Change the size of frame F's X window to COLS/ROWS in the case F
8606 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8607 top-left-corner window gravity for this size change and subsequent
8608 size changes. Otherwise we leave the window gravity unchanged. */
8611 x_set_window_size_1 (struct frame
*f
, int change_gravity
, int width
, int height
, bool pixelwise
)
8613 int pixelwidth
, pixelheight
;
8615 check_frame_size (f
, &width
, &height
, pixelwise
);
8617 compute_fringe_widths (f
, 0);
8619 pixelwidth
= ((pixelwise
8620 ? FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
)
8621 : FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
))
8622 + FRAME_TOOLBAR_WIDTH (f
));
8623 pixelheight
= ((pixelwise
8624 ? FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
)
8625 : FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
))
8626 + FRAME_MENUBAR_HEIGHT (f
)
8627 + FRAME_TOOLBAR_HEIGHT (f
));
8628 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
8629 x_wm_set_size_hint (f
, 0, 0);
8630 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8631 pixelwidth
, pixelheight
);
8634 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8635 receive in the ConfigureNotify event; if we get what we asked
8636 for, then the event won't cause the screen to become garbaged, so
8637 we have to make sure to do it here. */
8638 SET_FRAME_GARBAGED (f
);
8640 /* Now, strictly speaking, we can't be sure that this is accurate,
8641 but the window manager will get around to dealing with the size
8642 change request eventually, and we'll hear how it went when the
8643 ConfigureNotify event gets here.
8645 We could just not bother storing any of this information here,
8646 and let the ConfigureNotify event set everything up, but that
8647 might be kind of confusing to the Lisp code, since size changes
8648 wouldn't be reported in the frame parameters until some random
8649 point in the future when the ConfigureNotify event arrives.
8651 We pass 1 for DELAY since we can't run Lisp code inside of
8654 /* But the ConfigureNotify may in fact never arrive, and then this is
8655 not right if the frame is visible. Instead wait (with timeout)
8656 for the ConfigureNotify. */
8657 if (FRAME_VISIBLE_P (f
))
8658 x_wait_for_event (f
, ConfigureNotify
);
8661 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
8667 /* Call this to change the size of frame F's x-window.
8668 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8669 for this size change and subsequent size changes.
8670 Otherwise we leave the window gravity unchanged. */
8673 x_set_window_size (struct frame
*f
, int change_gravity
, int width
, int height
, bool pixelwise
)
8677 check_frame_size (f
, &width
, &height
, pixelwise
);
8679 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8681 int text_width
, text_height
;
8683 /* When the frame is maximized/fullscreen or running under for
8684 example Xmonad, x_set_window_size_1 will be a no-op.
8685 In that case, the right thing to do is extend rows/width to
8686 the current frame size. We do that first if x_set_window_size_1
8687 turns out to not be a no-op (there is no way to know).
8688 The size will be adjusted again if the frame gets a
8689 ConfigureNotify event as a result of x_set_window_size. */
8690 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
8691 #ifdef USE_X_TOOLKIT
8692 /* The menu bar is not part of text lines. The tool bar
8694 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
8696 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, FRAME_PIXEL_WIDTH (f
));
8697 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelh
);
8699 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
8703 if (FRAME_GTK_WIDGET (f
))
8705 xg_frame_set_char_size (f
, width
* FRAME_COLUMN_WIDTH (f
),
8706 height
* FRAME_LINE_HEIGHT (f
));
8708 xg_frame_set_char_size (f
, width
, height
);
8710 x_set_window_size_1 (f
, change_gravity
, width
, height
, pixelwise
);
8711 #else /* not USE_GTK */
8713 x_set_window_size_1 (f
, change_gravity
, width
, height
, pixelwise
);
8714 #if !defined USE_X_TOOLKIT
8715 x_clear_under_internal_border (f
);
8718 #endif /* not USE_GTK */
8720 /* If cursor was outside the new size, mark it as off. */
8721 mark_window_cursors_off (XWINDOW (f
->root_window
));
8723 /* Clear out any recollection of where the mouse highlighting was,
8724 since it might be in a place that's outside the new frame size.
8725 Actually checking whether it is outside is a pain in the neck,
8726 so don't try--just let the highlighting be done afresh with new size. */
8727 cancel_mouse_face (f
);
8732 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8735 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
8739 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8740 0, 0, 0, 0, pix_x
, pix_y
);
8744 /* Raise frame F. */
8747 x_raise_frame (struct frame
*f
)
8750 if (FRAME_VISIBLE_P (f
))
8751 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8752 XFlush (FRAME_X_DISPLAY (f
));
8756 /* Lower frame F. */
8759 x_lower_frame (struct frame
*f
)
8761 if (FRAME_VISIBLE_P (f
))
8764 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8765 XFlush (FRAME_X_DISPLAY (f
));
8770 /* Request focus with XEmbed */
8773 xembed_request_focus (struct frame
*f
)
8775 /* See XEmbed Protocol Specification at
8776 http://freedesktop.org/wiki/Specifications/xembed-spec */
8777 if (FRAME_VISIBLE_P (f
))
8778 xembed_send_message (f
, CurrentTime
,
8779 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
8782 /* Activate frame with Extended Window Manager Hints */
8785 x_ewmh_activate_frame (struct frame
*f
)
8787 /* See Window Manager Specification/Extended Window Manager Hints at
8788 http://freedesktop.org/wiki/Specifications/wm-spec */
8790 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8792 if (FRAME_VISIBLE_P (f
) && wm_supports (f
, dpyinfo
->Xatom_net_active_window
))
8795 XSETFRAME (frame
, f
);
8796 x_send_client_event (frame
, make_number (0), frame
,
8797 dpyinfo
->Xatom_net_active_window
,
8799 list2i (1, dpyinfo
->last_user_time
));
8804 XTframe_raise_lower (struct frame
*f
, int raise_flag
)
8812 /* XEmbed implementation. */
8814 #if defined USE_X_TOOLKIT || ! defined USE_GTK
8816 /* XEmbed implementation. */
8818 #define XEMBED_VERSION 0
8821 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
8823 unsigned long data
[2];
8824 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8826 data
[0] = XEMBED_VERSION
;
8829 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8830 dpyinfo
->Xatom_XEMBED_INFO
, dpyinfo
->Xatom_XEMBED_INFO
,
8831 32, PropModeReplace
, (unsigned char *) data
, 2);
8833 #endif /* defined USE_X_TOOLKIT || ! defined USE_GTK */
8836 xembed_send_message (struct frame
*f
, Time t
, enum xembed_message msg
,
8837 long int detail
, long int data1
, long int data2
)
8841 event
.xclient
.type
= ClientMessage
;
8842 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
8843 event
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_XEMBED
;
8844 event
.xclient
.format
= 32;
8845 event
.xclient
.data
.l
[0] = t
;
8846 event
.xclient
.data
.l
[1] = msg
;
8847 event
.xclient
.data
.l
[2] = detail
;
8848 event
.xclient
.data
.l
[3] = data1
;
8849 event
.xclient
.data
.l
[4] = data2
;
8851 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
8852 False
, NoEventMask
, &event
);
8853 XSync (FRAME_X_DISPLAY (f
), False
);
8856 /* Change of visibility. */
8858 /* This tries to wait until the frame is really visible.
8859 However, if the window manager asks the user where to position
8860 the frame, this will return before the user finishes doing that.
8861 The frame will not actually be visible at that time,
8862 but it will become visible later when the window manager
8863 finishes with it. */
8866 x_make_frame_visible (struct frame
*f
)
8868 int original_top
, original_left
;
8873 x_set_bitmap_icon (f
);
8875 if (! FRAME_VISIBLE_P (f
))
8877 /* We test FRAME_GARBAGED_P here to make sure we don't
8878 call x_set_offset a second time
8879 if we get to x_make_frame_visible a second time
8880 before the window gets really visible. */
8881 if (! FRAME_ICONIFIED_P (f
)
8882 && ! FRAME_X_EMBEDDED_P (f
)
8883 && ! f
->output_data
.x
->asked_for_visible
)
8884 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8886 f
->output_data
.x
->asked_for_visible
= 1;
8888 if (! EQ (Vx_no_window_manager
, Qt
))
8889 x_wm_set_window_state (f
, NormalState
);
8890 #ifdef USE_X_TOOLKIT
8891 if (FRAME_X_EMBEDDED_P (f
))
8892 xembed_set_info (f
, XEMBED_MAPPED
);
8895 /* This was XtPopup, but that did nothing for an iconified frame. */
8896 XtMapWidget (f
->output_data
.x
->widget
);
8898 #else /* not USE_X_TOOLKIT */
8900 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8901 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8903 if (FRAME_X_EMBEDDED_P (f
))
8904 xembed_set_info (f
, XEMBED_MAPPED
);
8906 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8907 #endif /* not USE_GTK */
8908 #endif /* not USE_X_TOOLKIT */
8911 XFlush (FRAME_X_DISPLAY (f
));
8913 /* Synchronize to ensure Emacs knows the frame is visible
8914 before we do anything else. We do this loop with input not blocked
8915 so that incoming events are handled. */
8918 /* This must be before UNBLOCK_INPUT
8919 since events that arrive in response to the actions above
8920 will set it when they are handled. */
8921 int previously_visible
= f
->output_data
.x
->has_been_visible
;
8923 original_left
= f
->left_pos
;
8924 original_top
= f
->top_pos
;
8926 /* This must come after we set COUNT. */
8929 /* We unblock here so that arriving X events are processed. */
8931 /* Now move the window back to where it was "supposed to be".
8932 But don't do it if the gravity is negative.
8933 When the gravity is negative, this uses a position
8934 that is 3 pixels too low. Perhaps that's really the border width.
8936 Don't do this if the window has never been visible before,
8937 because the window manager may choose the position
8938 and we don't want to override it. */
8940 if (! FRAME_VISIBLE_P (f
)
8941 && ! FRAME_ICONIFIED_P (f
)
8942 && ! FRAME_X_EMBEDDED_P (f
)
8943 && f
->win_gravity
== NorthWestGravity
8944 && previously_visible
)
8948 unsigned int width
, height
, border
, depth
;
8952 /* On some window managers (such as FVWM) moving an existing
8953 window, even to the same place, causes the window manager
8954 to introduce an offset. This can cause the window to move
8955 to an unexpected location. Check the geometry (a little
8956 slow here) and then verify that the window is in the right
8957 place. If the window is not in the right place, move it
8958 there, and take the potential window manager hit. */
8959 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8960 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
8962 if (original_left
!= x
|| original_top
!= y
)
8963 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8964 original_left
, original_top
);
8969 XSETFRAME (frame
, f
);
8971 /* Process X events until a MapNotify event has been seen. */
8972 while (!FRAME_VISIBLE_P (f
))
8974 /* Force processing of queued events. */
8977 /* If on another desktop, the deiconify/map may be ignored and the
8978 frame never becomes visible. XMonad does this.
8979 Prevent an endless loop. */
8980 if (FRAME_ICONIFIED_P (f
) && ++tries
> 100)
8983 /* This hack is still in use at least for Cygwin. See
8984 http://lists.gnu.org/archive/html/emacs-devel/2013-12/msg00351.html.
8986 Machines that do polling rather than SIGIO have been
8987 observed to go into a busy-wait here. So we'll fake an
8988 alarm signal to let the handler know that there's something
8989 to be read. We used to raise a real alarm, but it seems
8990 that the handler isn't always enabled here. This is
8992 if (input_polling_used ())
8994 /* It could be confusing if a real alarm arrives while
8995 processing the fake one. Turn it off and let the
8996 handler reset it. */
8997 int old_poll_suppress_count
= poll_suppress_count
;
8998 poll_suppress_count
= 1;
8999 poll_for_input_1 ();
9000 poll_suppress_count
= old_poll_suppress_count
;
9003 if (XPending (FRAME_X_DISPLAY (f
)))
9006 XNextEvent (FRAME_X_DISPLAY (f
), &xev
);
9007 x_dispatch_event (&xev
, FRAME_X_DISPLAY (f
));
9013 /* Change from mapped state to withdrawn state. */
9015 /* Make the frame visible (mapped and not iconified). */
9018 x_make_frame_invisible (struct frame
*f
)
9022 /* Use the frame's outermost window, not the one we normally draw on. */
9023 window
= FRAME_OUTER_WINDOW (f
);
9025 /* Don't keep the highlight on an invisible frame. */
9026 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9027 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9031 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9032 that the current position of the window is user-specified, rather than
9033 program-specified, so that when the window is mapped again, it will be
9034 placed at the same location, without forcing the user to position it
9035 by hand again (they have already done that once for this window.) */
9036 x_wm_set_size_hint (f
, 0, 1);
9039 if (FRAME_GTK_OUTER_WIDGET (f
))
9040 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9043 if (FRAME_X_EMBEDDED_P (f
))
9044 xembed_set_info (f
, 0);
9049 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9050 DefaultScreen (FRAME_X_DISPLAY (f
))))
9053 error ("Can't notify window manager of window withdrawal");
9057 /* We can't distinguish this from iconification
9058 just by the event that we get from the server.
9059 So we can't win using the usual strategy of letting
9060 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9061 and synchronize with the server to make sure we agree. */
9062 SET_FRAME_VISIBLE (f
, 0);
9063 SET_FRAME_ICONIFIED (f
, 0);
9070 /* Change window state from mapped to iconified. */
9073 x_iconify_frame (struct frame
*f
)
9075 #ifdef USE_X_TOOLKIT
9079 /* Don't keep the highlight on an invisible frame. */
9080 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9081 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9083 if (FRAME_ICONIFIED_P (f
))
9088 x_set_bitmap_icon (f
);
9090 #if defined (USE_GTK)
9091 if (FRAME_GTK_OUTER_WIDGET (f
))
9093 if (! FRAME_VISIBLE_P (f
))
9094 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9096 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9097 SET_FRAME_VISIBLE (f
, 0);
9098 SET_FRAME_ICONIFIED (f
, 1);
9104 #ifdef USE_X_TOOLKIT
9106 if (! FRAME_VISIBLE_P (f
))
9108 if (! EQ (Vx_no_window_manager
, Qt
))
9109 x_wm_set_window_state (f
, IconicState
);
9110 /* This was XtPopup, but that did nothing for an iconified frame. */
9111 XtMapWidget (f
->output_data
.x
->widget
);
9112 /* The server won't give us any event to indicate
9113 that an invisible frame was changed to an icon,
9114 so we have to record it here. */
9115 SET_FRAME_VISIBLE (f
, 0);
9116 SET_FRAME_ICONIFIED (f
, 1);
9121 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9122 XtWindow (f
->output_data
.x
->widget
),
9123 DefaultScreen (FRAME_X_DISPLAY (f
)));
9127 error ("Can't notify window manager of iconification");
9129 SET_FRAME_ICONIFIED (f
, 1);
9130 SET_FRAME_VISIBLE (f
, 0);
9133 XFlush (FRAME_X_DISPLAY (f
));
9135 #else /* not USE_X_TOOLKIT */
9137 /* Make sure the X server knows where the window should be positioned,
9138 in case the user deiconifies with the window manager. */
9139 if (! FRAME_VISIBLE_P (f
)
9140 && ! FRAME_ICONIFIED_P (f
)
9141 && ! FRAME_X_EMBEDDED_P (f
))
9142 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9144 /* Since we don't know which revision of X we're running, we'll use both
9145 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9147 /* X11R4: send a ClientMessage to the window manager using the
9148 WM_CHANGE_STATE type. */
9152 msg
.xclient
.window
= FRAME_X_WINDOW (f
);
9153 msg
.xclient
.type
= ClientMessage
;
9154 msg
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9155 msg
.xclient
.format
= 32;
9156 msg
.xclient
.data
.l
[0] = IconicState
;
9158 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9159 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9161 SubstructureRedirectMask
| SubstructureNotifyMask
,
9165 error ("Can't notify window manager of iconification");
9169 /* X11R3: set the initial_state field of the window manager hints to
9171 x_wm_set_window_state (f
, IconicState
);
9173 if (!FRAME_VISIBLE_P (f
))
9175 /* If the frame was withdrawn, before, we must map it. */
9176 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9179 SET_FRAME_ICONIFIED (f
, 1);
9180 SET_FRAME_VISIBLE (f
, 0);
9182 XFlush (FRAME_X_DISPLAY (f
));
9184 #endif /* not USE_X_TOOLKIT */
9188 /* Free X resources of frame F. */
9191 x_free_frame_resources (struct frame
*f
)
9193 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9194 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
9195 #ifdef USE_X_TOOLKIT
9197 struct scroll_bar
*b
;
9202 /* If a display connection is dead, don't try sending more
9203 commands to the X server. */
9204 if (dpyinfo
->display
)
9206 /* Always exit with visible pointer to avoid weird issue
9207 with Xfixes (Bug#17609). */
9208 if (f
->pointer_invisible
)
9209 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, 0);
9211 /* We must free faces before destroying windows because some
9212 font-driver (e.g. xft) access a window while finishing a
9214 free_frame_faces (f
);
9216 if (f
->output_data
.x
->icon_desc
)
9217 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9219 #ifdef USE_X_TOOLKIT
9220 /* Explicitly destroy the scroll bars of the frame. Without
9221 this, we get "BadDrawable" errors from the toolkit later on,
9222 presumably from expose events generated for the disappearing
9223 toolkit scroll bars. */
9224 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9226 b
= XSCROLL_BAR (bar
);
9227 x_scroll_bar_remove (b
);
9236 #ifdef USE_X_TOOLKIT
9237 if (f
->output_data
.x
->widget
)
9239 XtDestroyWidget (f
->output_data
.x
->widget
);
9240 f
->output_data
.x
->widget
= NULL
;
9242 /* Tooltips don't have widgets, only a simple X window, even if
9243 we are using a toolkit. */
9244 else if (FRAME_X_WINDOW (f
))
9245 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9247 free_frame_menubar (f
);
9249 if (f
->shell_position
)
9250 xfree (f
->shell_position
);
9251 #else /* !USE_X_TOOLKIT */
9254 xg_free_frame_widgets (f
);
9255 #endif /* USE_GTK */
9257 if (FRAME_X_WINDOW (f
))
9258 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9259 #endif /* !USE_X_TOOLKIT */
9261 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
9262 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
9263 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9264 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9265 unload_color (f
, f
->output_data
.x
->border_pixel
);
9266 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9268 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9269 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9270 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9271 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9272 #ifdef USE_TOOLKIT_SCROLL_BARS
9273 /* Scrollbar shadow colors. */
9274 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9275 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9276 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9277 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9278 #endif /* USE_TOOLKIT_SCROLL_BARS */
9279 if (f
->output_data
.x
->white_relief
.pixel
!= -1)
9280 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9281 if (f
->output_data
.x
->black_relief
.pixel
!= -1)
9282 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9286 /* Free extra GCs allocated by x_setup_relief_colors. */
9287 if (f
->output_data
.x
->white_relief
.gc
)
9289 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->white_relief
.gc
);
9290 f
->output_data
.x
->white_relief
.gc
= 0;
9292 if (f
->output_data
.x
->black_relief
.gc
)
9294 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->black_relief
.gc
);
9295 f
->output_data
.x
->black_relief
.gc
= 0;
9299 if (f
->output_data
.x
->text_cursor
!= 0)
9300 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->text_cursor
);
9301 if (f
->output_data
.x
->nontext_cursor
!= 0)
9302 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->nontext_cursor
);
9303 if (f
->output_data
.x
->modeline_cursor
!= 0)
9304 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->modeline_cursor
);
9305 if (f
->output_data
.x
->hand_cursor
!= 0)
9306 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hand_cursor
);
9307 if (f
->output_data
.x
->hourglass_cursor
!= 0)
9308 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hourglass_cursor
);
9309 if (f
->output_data
.x
->horizontal_drag_cursor
!= 0)
9310 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->horizontal_drag_cursor
);
9311 if (f
->output_data
.x
->vertical_drag_cursor
!= 0)
9312 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->vertical_drag_cursor
);
9314 XFlush (FRAME_X_DISPLAY (f
));
9317 xfree (f
->output_data
.x
->saved_menu_event
);
9318 xfree (f
->output_data
.x
);
9319 f
->output_data
.x
= NULL
;
9321 if (f
== dpyinfo
->x_focus_frame
)
9322 dpyinfo
->x_focus_frame
= 0;
9323 if (f
== dpyinfo
->x_focus_event_frame
)
9324 dpyinfo
->x_focus_event_frame
= 0;
9325 if (f
== dpyinfo
->x_highlight_frame
)
9326 dpyinfo
->x_highlight_frame
= 0;
9327 if (f
== hlinfo
->mouse_face_mouse_frame
)
9328 reset_mouse_highlight (hlinfo
);
9334 /* Destroy the X window of frame F. */
9337 x_destroy_window (struct frame
*f
)
9339 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9341 /* If a display connection is dead, don't try sending more
9342 commands to the X server. */
9343 if (dpyinfo
->display
!= 0)
9344 x_free_frame_resources (f
);
9346 dpyinfo
->reference_count
--;
9350 /* Setting window manager hints. */
9352 /* Set the normal size hints for the window manager, for frame F.
9353 FLAGS is the flags word to use--or 0 meaning preserve the flags
9354 that the window now has.
9355 If USER_POSITION, set the USPosition
9356 flag (this is useful when FLAGS is 0).
9357 The GTK version is in gtkutils.c. */
9361 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
9363 XSizeHints size_hints
;
9364 Window window
= FRAME_OUTER_WINDOW (f
);
9366 #ifdef USE_X_TOOLKIT
9367 if (f
->output_data
.x
->widget
)
9369 widget_update_wm_size_hints (f
->output_data
.x
->widget
);
9374 /* Setting PMaxSize caused various problems. */
9375 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9377 size_hints
.x
= f
->left_pos
;
9378 size_hints
.y
= f
->top_pos
;
9380 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9381 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9383 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
9384 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
9386 size_hints
.max_width
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
9387 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9388 size_hints
.max_height
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
9389 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9391 /* Calculate the base and minimum sizes. */
9393 int base_width
, base_height
;
9394 int min_rows
= 0, min_cols
= 0;
9396 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9397 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9399 check_frame_size (f
, &min_cols
, &min_rows
, 0);
9401 if (frame_resize_pixelwise
)
9402 /* Needed to prevent a bad protocol error crash when making the
9403 frame size very small. */
9405 min_cols
= 2 * min_cols
;
9406 min_rows
= 2 * min_rows
;
9409 /* The window manager uses the base width hints to calculate the
9410 current number of rows and columns in the frame while
9411 resizing; min_width and min_height aren't useful for this
9412 purpose, since they might not give the dimensions for a
9413 zero-row, zero-column frame.
9415 We use the base_width and base_height members if we have
9416 them; otherwise, we set the min_width and min_height members
9417 to the size for a zero x zero frame. */
9419 size_hints
.flags
|= PBaseSize
;
9420 size_hints
.base_width
= base_width
;
9421 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
9422 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
9423 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
9426 /* If we don't need the old flags, we don't need the old hint at all. */
9429 size_hints
.flags
|= flags
;
9434 XSizeHints hints
; /* Sometimes I hate X Windows... */
9435 long supplied_return
;
9438 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9442 size_hints
.flags
|= flags
;
9447 if (hints
.flags
& PSize
)
9448 size_hints
.flags
|= PSize
;
9449 if (hints
.flags
& PPosition
)
9450 size_hints
.flags
|= PPosition
;
9451 if (hints
.flags
& USPosition
)
9452 size_hints
.flags
|= USPosition
;
9453 if (hints
.flags
& USSize
)
9454 size_hints
.flags
|= USSize
;
9461 size_hints
.win_gravity
= f
->win_gravity
;
9462 size_hints
.flags
|= PWinGravity
;
9466 size_hints
.flags
&= ~ PPosition
;
9467 size_hints
.flags
|= USPosition
;
9469 #endif /* PWinGravity */
9471 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9473 #endif /* not USE_GTK */
9475 /* Used for IconicState or NormalState */
9478 x_wm_set_window_state (struct frame
*f
, int state
)
9480 #ifdef USE_X_TOOLKIT
9483 XtSetArg (al
[0], XtNinitialState
, state
);
9484 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9485 #else /* not USE_X_TOOLKIT */
9486 Window window
= FRAME_X_WINDOW (f
);
9488 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9489 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9491 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9492 #endif /* not USE_X_TOOLKIT */
9496 x_wm_set_icon_pixmap (struct frame
*f
, ptrdiff_t pixmap_id
)
9498 Pixmap icon_pixmap
, icon_mask
;
9500 #if !defined USE_X_TOOLKIT && !defined USE_GTK
9501 Window window
= FRAME_OUTER_WINDOW (f
);
9506 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9507 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9508 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9509 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9513 /* It seems there is no way to turn off use of an icon
9521 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9525 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9529 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9530 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9531 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9532 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9535 #else /* not USE_X_TOOLKIT && not USE_GTK */
9537 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9538 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9540 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9544 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
9546 Window window
= FRAME_OUTER_WINDOW (f
);
9548 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9549 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9550 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9552 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9556 /***********************************************************************
9558 ***********************************************************************/
9562 /* Check that FONT is valid on frame F. It is if it can be found in F's
9566 x_check_font (struct frame
*f
, struct font
*font
)
9568 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
9569 if (font
->driver
->check
)
9570 eassert (font
->driver
->check (f
, font
) == 0);
9573 #endif /* GLYPH_DEBUG */
9576 /***********************************************************************
9578 ***********************************************************************/
9580 #ifdef USE_X_TOOLKIT
9581 static XrmOptionDescRec emacs_options
[] = {
9582 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
9583 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
9585 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
9586 XrmoptionSepArg
, NULL
},
9587 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
9589 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9590 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9591 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9592 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9593 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9594 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
9595 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
9598 /* Whether atimer for Xt timeouts is activated or not. */
9600 static int x_timeout_atimer_activated_flag
;
9602 #endif /* USE_X_TOOLKIT */
9604 static int x_initialized
;
9606 /* Test whether two display-name strings agree up to the dot that separates
9607 the screen number from the server number. */
9609 same_x_server (const char *name1
, const char *name2
)
9612 const char *system_name
= SSDATA (Vsystem_name
);
9613 ptrdiff_t system_name_length
= SBYTES (Vsystem_name
);
9614 ptrdiff_t length_until_period
= 0;
9616 while (system_name
[length_until_period
] != 0
9617 && system_name
[length_until_period
] != '.')
9618 length_until_period
++;
9620 /* Treat `unix' like an empty host name. */
9621 if (! strncmp (name1
, "unix:", 5))
9623 if (! strncmp (name2
, "unix:", 5))
9625 /* Treat this host's name like an empty host name. */
9626 if (! strncmp (name1
, system_name
, system_name_length
)
9627 && name1
[system_name_length
] == ':')
9628 name1
+= system_name_length
;
9629 if (! strncmp (name2
, system_name
, system_name_length
)
9630 && name2
[system_name_length
] == ':')
9631 name2
+= system_name_length
;
9632 /* Treat this host's domainless name like an empty host name. */
9633 if (! strncmp (name1
, system_name
, length_until_period
)
9634 && name1
[length_until_period
] == ':')
9635 name1
+= length_until_period
;
9636 if (! strncmp (name2
, system_name
, length_until_period
)
9637 && name2
[length_until_period
] == ':')
9638 name2
+= length_until_period
;
9640 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
9644 if (seen_colon
&& *name1
== '.')
9648 && (*name1
== '.' || *name1
== '\0')
9649 && (*name2
== '.' || *name2
== '\0'));
9652 /* Count number of set bits in mask and number of bits to shift to
9653 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
9656 get_bits_and_offset (unsigned long mask
, int *bits
, int *offset
)
9677 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
9678 But don't permanently open it, just test its availability. */
9681 x_display_ok (const char *display
)
9683 Display
*dpy
= XOpenDisplay (display
);
9684 return dpy
? (XCloseDisplay (dpy
), 1) : 0;
9689 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
9690 const gchar
*msg
, gpointer user_data
)
9692 if (!strstr (msg
, "g_set_prgname"))
9693 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, msg
);
9697 /* Create invisible cursor on X display referred by DPYINFO. */
9700 make_invisible_cursor (struct x_display_info
*dpyinfo
)
9702 Display
*dpy
= dpyinfo
->display
;
9703 static char const no_data
[] = { 0 };
9708 x_catch_errors (dpy
);
9709 pix
= XCreateBitmapFromData (dpy
, dpyinfo
->root_window
, no_data
, 1, 1);
9710 if (! x_had_errors_p (dpy
) && pix
!= None
)
9714 col
.red
= col
.green
= col
.blue
= 0;
9715 col
.flags
= DoRed
| DoGreen
| DoBlue
;
9716 pixc
= XCreatePixmapCursor (dpy
, pix
, pix
, &col
, &col
, 0, 0);
9717 if (! x_had_errors_p (dpy
) && pixc
!= None
)
9719 XFreePixmap (dpy
, pix
);
9722 x_uncatch_errors ();
9727 /* True if DPY supports Xfixes extension >= 4. */
9730 x_probe_xfixes_extension (Display
*dpy
)
9734 return XFixesQueryVersion (dpy
, &major
, &minor
) && major
>= 4;
9737 #endif /* HAVE_XFIXES */
9740 /* Toggle mouse pointer visibility on frame F by using Xfixes functions. */
9743 xfixes_toggle_visible_pointer (struct frame
*f
, bool invisible
)
9747 XFixesHideCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9749 XFixesShowCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9750 f
->pointer_invisible
= invisible
;
9753 #endif /* HAVE_XFIXES */
9756 /* Toggle mouse pointer visibility on frame F by using invisible cursor. */
9759 x_toggle_visible_pointer (struct frame
*f
, bool invisible
)
9761 eassert (FRAME_DISPLAY_INFO (f
)->invisible_cursor
!= 0);
9763 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9764 FRAME_DISPLAY_INFO (f
)->invisible_cursor
);
9766 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9767 f
->output_data
.x
->current_cursor
);
9768 f
->pointer_invisible
= invisible
;
9771 /* Setup pointer blanking, prefer Xfixes if available. */
9774 x_setup_pointer_blanking (struct x_display_info
*dpyinfo
)
9776 /* FIXME: the brave tester should set EMACS_XFIXES because we're suspecting
9777 X server bug, see http://debbugs.gnu.org/cgi/bugreport.cgi?bug=17609. */
9778 if (egetenv ("EMACS_XFIXES") && x_probe_xfixes_extension (dpyinfo
->display
))
9779 dpyinfo
->toggle_visible_pointer
= xfixes_toggle_visible_pointer
;
9782 dpyinfo
->toggle_visible_pointer
= x_toggle_visible_pointer
;
9783 dpyinfo
->invisible_cursor
= make_invisible_cursor (dpyinfo
);
9787 /* Current X display connection identifier. Incremented for each next
9788 connection established. */
9789 static unsigned x_display_id
;
9791 /* Open a connection to X display DISPLAY_NAME, and return
9792 the structure that describes the open display.
9793 If we cannot contact the display, return null. */
9795 struct x_display_info
*
9796 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
9800 struct terminal
*terminal
;
9801 struct x_display_info
*dpyinfo
;
9813 if (! x_display_ok (SSDATA (display_name
)))
9814 error ("Display %s can't be opened", SSDATA (display_name
));
9820 char *argv
[NUM_ARGV
];
9821 char **argv2
= argv
;
9824 if (x_initialized
++ > 1)
9826 xg_display_open (SSDATA (display_name
), &dpy
);
9830 static char display_opt
[] = "--display";
9831 static char name_opt
[] = "--name";
9833 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
9837 argv
[argc
++] = initial_argv
[0];
9839 if (! NILP (display_name
))
9841 argv
[argc
++] = display_opt
;
9842 argv
[argc
++] = SSDATA (display_name
);
9845 argv
[argc
++] = name_opt
;
9846 argv
[argc
++] = resource_name
;
9848 XSetLocaleModifiers ("");
9850 /* Emacs can only handle core input events, so make sure
9851 Gtk doesn't use Xinput or Xinput2 extensions. */
9852 xputenv ("GDK_CORE_DEVICE_EVENTS=1");
9854 /* Work around GLib bug that outputs a faulty warning. See
9855 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
9856 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
9857 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
9859 /* NULL window -> events for all windows go to our function.
9860 Call before gtk_init so Gtk+ event filters comes after our. */
9861 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
9863 /* gtk_init does set_locale. Fix locale before and after. */
9865 gtk_init (&argc
, &argv2
);
9868 g_log_remove_handler ("GLib", id
);
9872 dpy
= DEFAULT_GDK_DISPLAY ();
9874 #if ! GTK_CHECK_VERSION (2, 90, 0)
9875 /* Load our own gtkrc if it exists. */
9877 const char *file
= "~/.emacs.d/gtkrc";
9878 Lisp_Object s
, abs_file
;
9880 s
= build_string (file
);
9881 abs_file
= Fexpand_file_name (s
, Qnil
);
9883 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
9884 gtk_rc_parse (SSDATA (abs_file
));
9888 XSetErrorHandler (x_error_handler
);
9889 XSetIOErrorHandler (x_io_error_quitter
);
9892 #else /* not USE_GTK */
9893 #ifdef USE_X_TOOLKIT
9894 /* weiner@footloose.sps.mot.com reports that this causes
9896 X protocol error: BadAtom (invalid Atom parameter)
9897 on protocol request 18skiloaf.
9898 So let's not use it until R6. */
9900 XtSetLanguageProc (NULL
, NULL
, NULL
);
9911 argv
[argc
++] = "-xrm";
9912 argv
[argc
++] = xrm_option
;
9914 turn_on_atimers (0);
9915 dpy
= XtOpenDisplay (Xt_app_con
, SSDATA (display_name
),
9916 resource_name
, EMACS_CLASS
,
9917 emacs_options
, XtNumber (emacs_options
),
9919 turn_on_atimers (1);
9922 /* I think this is to compensate for XtSetLanguageProc. */
9927 #else /* not USE_X_TOOLKIT */
9928 XSetLocaleModifiers ("");
9929 dpy
= XOpenDisplay (SSDATA (display_name
));
9930 #endif /* not USE_X_TOOLKIT */
9931 #endif /* not USE_GTK*/
9933 /* Detect failure. */
9940 /* We have definitely succeeded. Record the new connection. */
9942 dpyinfo
= xzalloc (sizeof *dpyinfo
);
9943 terminal
= x_create_terminal (dpyinfo
);
9946 struct x_display_info
*share
;
9948 for (share
= x_display_list
; share
; share
= share
->next
)
9949 if (same_x_server (SSDATA (XCAR (share
->name_list_element
)),
9950 SSDATA (display_name
)))
9953 terminal
->kboard
= share
->terminal
->kboard
;
9956 terminal
->kboard
= allocate_kboard (Qx
);
9958 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
9960 char *vendor
= ServerVendor (dpy
);
9962 /* Protect terminal from GC before removing it from the
9963 list of terminals. */
9964 struct gcpro gcpro1
;
9965 Lisp_Object gcpro_term
;
9966 XSETTERMINAL (gcpro_term
, terminal
);
9967 GCPRO1 (gcpro_term
);
9969 /* Temporarily hide the partially initialized terminal. */
9970 terminal_list
= terminal
->next_terminal
;
9972 kset_system_key_alist
9974 call1 (Qvendor_specific_keysyms
,
9975 vendor
? build_string (vendor
) : empty_unibyte_string
));
9977 terminal
->next_terminal
= terminal_list
;
9978 terminal_list
= terminal
;
9982 /* Don't let the initial kboard remain current longer than necessary.
9983 That would cause problems if a file loaded on startup tries to
9984 prompt in the mini-buffer. */
9985 if (current_kboard
== initial_kboard
)
9986 current_kboard
= terminal
->kboard
;
9988 terminal
->kboard
->reference_count
++;
9991 /* Put this display on the chain. */
9992 dpyinfo
->next
= x_display_list
;
9993 x_display_list
= dpyinfo
;
9995 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
9996 dpyinfo
->display
= dpy
;
9998 /* Set the name of the terminal. */
9999 terminal
->name
= xlispstrdup (display_name
);
10002 XSetAfterFunction (x_current_display
, x_trace_wire
);
10005 lim
= min (PTRDIFF_MAX
, SIZE_MAX
) - sizeof "@";
10006 if (lim
- SBYTES (Vinvocation_name
) < SBYTES (Vsystem_name
))
10007 memory_full (SIZE_MAX
);
10008 dpyinfo
->x_id
= ++x_display_id
;
10009 dpyinfo
->x_id_name
= xmalloc (SBYTES (Vinvocation_name
)
10010 + SBYTES (Vsystem_name
) + 2);
10011 strcat (strcat (strcpy (dpyinfo
->x_id_name
, SSDATA (Vinvocation_name
)), "@"),
10012 SSDATA (Vsystem_name
));
10014 /* Figure out which modifier bits mean what. */
10015 x_find_modifier_meanings (dpyinfo
);
10017 /* Get the scroll bar cursor. */
10019 /* We must create a GTK cursor, it is required for GTK widgets. */
10020 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10021 #endif /* USE_GTK */
10023 dpyinfo
->vertical_scroll_bar_cursor
10024 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10026 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10027 resource_name
, EMACS_CLASS
);
10028 #ifdef HAVE_XRMSETDATABASE
10029 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10031 dpyinfo
->display
->db
= xrdb
;
10033 /* Put the rdb where we can find it in a way that works on
10035 dpyinfo
->xrdb
= xrdb
;
10037 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10038 DefaultScreen (dpyinfo
->display
));
10039 select_visual (dpyinfo
);
10040 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10041 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10042 dpyinfo
->icon_bitmap_id
= -1;
10043 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10045 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
10047 /* See if we can construct pixel values from RGB values. */
10048 if (dpyinfo
->visual
->class == TrueColor
)
10050 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10051 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10052 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10053 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10054 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10055 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10058 /* See if a private colormap is requested. */
10059 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10061 if (dpyinfo
->visual
->class == PseudoColor
)
10064 value
= display_x_get_resource (dpyinfo
,
10065 build_string ("privateColormap"),
10066 build_string ("PrivateColormap"),
10068 if (STRINGP (value
)
10069 && (!strcmp (SSDATA (value
), "true")
10070 || !strcmp (SSDATA (value
), "on")))
10071 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10075 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10076 dpyinfo
->visual
, AllocNone
);
10080 /* If we are using Xft, the following precautions should be made:
10082 1. Make sure that the Xrender extension is added before the Xft one.
10083 Otherwise, the close-display hook set by Xft is called after the one
10084 for Xrender, and the former tries to re-add the latter. This results
10085 in inconsistency of internal states and leads to X protocol error when
10086 one reconnects to the same X server (Bug#1696).
10088 2. Check dpi value in X resources. It is better we use it as well,
10089 since Xft will use it, as will all Gnome applications. If our real DPI
10090 is smaller or larger than the one Xft uses, our font will look smaller
10091 or larger than other for other applications, even if it is the same
10092 font name (monospace-10 for example). */
10094 int event_base
, error_base
;
10098 XRenderQueryExtension (dpyinfo
->display
, &event_base
, &error_base
);
10100 v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
10101 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
10102 dpyinfo
->resy
= dpyinfo
->resx
= d
;
10106 if (dpyinfo
->resy
< 1)
10108 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10109 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10110 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10111 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10112 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10113 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10114 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10115 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10116 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10120 static const struct
10125 #define ATOM_REFS_INIT(string, member) \
10126 { string, offsetof (struct x_display_info, member) },
10127 ATOM_REFS_INIT ("WM_PROTOCOLS", Xatom_wm_protocols
)
10128 ATOM_REFS_INIT ("WM_TAKE_FOCUS", Xatom_wm_take_focus
)
10129 ATOM_REFS_INIT ("WM_SAVE_YOURSELF", Xatom_wm_save_yourself
)
10130 ATOM_REFS_INIT ("WM_DELETE_WINDOW", Xatom_wm_delete_window
)
10131 ATOM_REFS_INIT ("WM_CHANGE_STATE", Xatom_wm_change_state
)
10132 ATOM_REFS_INIT ("WM_CONFIGURE_DENIED", Xatom_wm_configure_denied
)
10133 ATOM_REFS_INIT ("WM_MOVED", Xatom_wm_window_moved
)
10134 ATOM_REFS_INIT ("WM_CLIENT_LEADER", Xatom_wm_client_leader
)
10135 ATOM_REFS_INIT ("Editres", Xatom_editres
)
10136 ATOM_REFS_INIT ("CLIPBOARD", Xatom_CLIPBOARD
)
10137 ATOM_REFS_INIT ("TIMESTAMP", Xatom_TIMESTAMP
)
10138 ATOM_REFS_INIT ("TEXT", Xatom_TEXT
)
10139 ATOM_REFS_INIT ("COMPOUND_TEXT", Xatom_COMPOUND_TEXT
)
10140 ATOM_REFS_INIT ("UTF8_STRING", Xatom_UTF8_STRING
)
10141 ATOM_REFS_INIT ("DELETE", Xatom_DELETE
)
10142 ATOM_REFS_INIT ("MULTIPLE", Xatom_MULTIPLE
)
10143 ATOM_REFS_INIT ("INCR", Xatom_INCR
)
10144 ATOM_REFS_INIT ("_EMACS_TMP_", Xatom_EMACS_TMP
)
10145 ATOM_REFS_INIT ("TARGETS", Xatom_TARGETS
)
10146 ATOM_REFS_INIT ("NULL", Xatom_NULL
)
10147 ATOM_REFS_INIT ("ATOM", Xatom_ATOM
)
10148 ATOM_REFS_INIT ("ATOM_PAIR", Xatom_ATOM_PAIR
)
10149 ATOM_REFS_INIT ("CLIPBOARD_MANAGER", Xatom_CLIPBOARD_MANAGER
)
10150 ATOM_REFS_INIT ("_XEMBED_INFO", Xatom_XEMBED_INFO
)
10151 /* For properties of font. */
10152 ATOM_REFS_INIT ("PIXEL_SIZE", Xatom_PIXEL_SIZE
)
10153 ATOM_REFS_INIT ("AVERAGE_WIDTH", Xatom_AVERAGE_WIDTH
)
10154 ATOM_REFS_INIT ("_MULE_BASELINE_OFFSET", Xatom_MULE_BASELINE_OFFSET
)
10155 ATOM_REFS_INIT ("_MULE_RELATIVE_COMPOSE", Xatom_MULE_RELATIVE_COMPOSE
)
10156 ATOM_REFS_INIT ("_MULE_DEFAULT_ASCENT", Xatom_MULE_DEFAULT_ASCENT
)
10157 /* Ghostscript support. */
10158 ATOM_REFS_INIT ("DONE", Xatom_DONE
)
10159 ATOM_REFS_INIT ("PAGE", Xatom_PAGE
)
10160 ATOM_REFS_INIT ("SCROLLBAR", Xatom_Scrollbar
)
10161 ATOM_REFS_INIT ("_XEMBED", Xatom_XEMBED
)
10163 ATOM_REFS_INIT ("_NET_WM_STATE", Xatom_net_wm_state
)
10164 ATOM_REFS_INIT ("_NET_WM_STATE_FULLSCREEN", Xatom_net_wm_state_fullscreen
)
10165 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_HORZ",
10166 Xatom_net_wm_state_maximized_horz
)
10167 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_VERT",
10168 Xatom_net_wm_state_maximized_vert
)
10169 ATOM_REFS_INIT ("_NET_WM_STATE_STICKY", Xatom_net_wm_state_sticky
)
10170 ATOM_REFS_INIT ("_NET_WM_STATE_HIDDEN", Xatom_net_wm_state_hidden
)
10171 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE", Xatom_net_window_type
)
10172 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE_TOOLTIP",
10173 Xatom_net_window_type_tooltip
)
10174 ATOM_REFS_INIT ("_NET_WM_ICON_NAME", Xatom_net_wm_icon_name
)
10175 ATOM_REFS_INIT ("_NET_WM_NAME", Xatom_net_wm_name
)
10176 ATOM_REFS_INIT ("_NET_SUPPORTED", Xatom_net_supported
)
10177 ATOM_REFS_INIT ("_NET_SUPPORTING_WM_CHECK", Xatom_net_supporting_wm_check
)
10178 ATOM_REFS_INIT ("_NET_WM_WINDOW_OPACITY", Xatom_net_wm_window_opacity
)
10179 ATOM_REFS_INIT ("_NET_ACTIVE_WINDOW", Xatom_net_active_window
)
10180 ATOM_REFS_INIT ("_NET_FRAME_EXTENTS", Xatom_net_frame_extents
)
10181 ATOM_REFS_INIT ("_NET_CURRENT_DESKTOP", Xatom_net_current_desktop
)
10182 ATOM_REFS_INIT ("_NET_WORKAREA", Xatom_net_workarea
)
10183 /* Session management */
10184 ATOM_REFS_INIT ("SM_CLIENT_ID", Xatom_SM_CLIENT_ID
)
10185 ATOM_REFS_INIT ("_XSETTINGS_SETTINGS", Xatom_xsettings_prop
)
10186 ATOM_REFS_INIT ("MANAGER", Xatom_xsettings_mgr
)
10190 const int atom_count
= ARRAYELTS (atom_refs
);
10191 /* 1 for _XSETTINGS_SN */
10192 const int total_atom_count
= 1 + atom_count
;
10193 Atom
*atoms_return
= xmalloc (total_atom_count
* sizeof *atoms_return
);
10194 char **atom_names
= xmalloc (total_atom_count
* sizeof *atom_names
);
10195 static char const xsettings_fmt
[] = "_XSETTINGS_S%d";
10196 char xsettings_atom_name
[sizeof xsettings_fmt
- 2
10197 + INT_STRLEN_BOUND (int)];
10199 for (i
= 0; i
< atom_count
; i
++)
10200 atom_names
[i
] = (char *) atom_refs
[i
].name
;
10202 /* Build _XSETTINGS_SN atom name */
10203 sprintf (xsettings_atom_name
, xsettings_fmt
,
10204 XScreenNumberOfScreen (dpyinfo
->screen
));
10205 atom_names
[i
] = xsettings_atom_name
;
10207 XInternAtoms (dpyinfo
->display
, atom_names
, total_atom_count
,
10208 False
, atoms_return
);
10210 for (i
= 0; i
< atom_count
; i
++)
10211 *(Atom
*) ((char *) dpyinfo
+ atom_refs
[i
].offset
) = atoms_return
[i
];
10213 /* Manual copy of last atom */
10214 dpyinfo
->Xatom_xsettings_sel
= atoms_return
[i
];
10216 xfree (atom_names
);
10217 xfree (atoms_return
);
10220 dpyinfo
->x_dnd_atoms_size
= 8;
10221 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof *dpyinfo
->x_dnd_atoms
10222 * dpyinfo
->x_dnd_atoms_size
);
10224 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10225 gray_bits
, gray_width
, gray_height
,
10228 x_setup_pointer_blanking (dpyinfo
);
10231 xim_initialize (dpyinfo
, resource_name
);
10234 xsettings_initialize (dpyinfo
);
10236 connection
= ConnectionNumber (dpyinfo
->display
);
10238 /* This is only needed for distinguishing keyboard and process input. */
10239 if (connection
!= 0)
10240 add_keyboard_wait_descriptor (connection
);
10243 fcntl (connection
, F_SETOWN
, getpid ());
10244 #endif /* ! defined (F_SETOWN) */
10246 if (interrupt_input
)
10247 init_sigio (connection
);
10251 XFontStruct
*xfont
= NULL
;
10252 XrmValue d
, fr
, to
;
10255 dpy
= dpyinfo
->display
;
10256 d
.addr
= (XPointer
)&dpy
;
10257 d
.size
= sizeof (Display
*);
10258 fr
.addr
= XtDefaultFont
;
10259 fr
.size
= sizeof (XtDefaultFont
);
10260 to
.size
= sizeof (Font
*);
10261 to
.addr
= (XPointer
)&font
;
10262 x_catch_errors (dpy
);
10263 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10265 if (x_had_errors_p (dpy
) || !((xfont
= XQueryFont (dpy
, font
))))
10266 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10268 XFreeFont (dpy
, xfont
);
10269 x_uncatch_errors ();
10273 /* See if we should run in synchronous mode. This is useful
10274 for debugging X code. */
10277 value
= display_x_get_resource (dpyinfo
,
10278 build_string ("synchronous"),
10279 build_string ("Synchronous"),
10281 if (STRINGP (value
)
10282 && (!strcmp (SSDATA (value
), "true")
10283 || !strcmp (SSDATA (value
), "on")))
10284 XSynchronize (dpyinfo
->display
, True
);
10289 value
= display_x_get_resource (dpyinfo
,
10290 build_string ("useXIM"),
10291 build_string ("UseXIM"),
10294 if (STRINGP (value
)
10295 && (!strcmp (SSDATA (value
), "false")
10296 || !strcmp (SSDATA (value
), "off")))
10299 if (STRINGP (value
)
10300 && (!strcmp (SSDATA (value
), "true")
10301 || !strcmp (SSDATA (value
), "on")))
10307 /* Only do this for the very first display in the Emacs session.
10308 Ignore X session management when Emacs was first started on a
10310 if (terminal
->id
== 1)
10311 x_session_initialize (dpyinfo
);
10319 /* Get rid of display DPYINFO, deleting all frames on it,
10320 and without sending any more commands to the X server. */
10323 x_delete_display (struct x_display_info
*dpyinfo
)
10325 struct terminal
*t
;
10327 /* Close all frames and delete the generic struct terminal for this
10329 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
10330 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
10333 /* Close X session management when we close its display. */
10334 if (t
->id
== 1 && x_session_have_connection ())
10335 x_session_close ();
10337 delete_terminal (t
);
10341 if (next_noop_dpyinfo
== dpyinfo
)
10342 next_noop_dpyinfo
= dpyinfo
->next
;
10344 if (x_display_list
== dpyinfo
)
10345 x_display_list
= dpyinfo
->next
;
10348 struct x_display_info
*tail
;
10350 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10351 if (tail
->next
== dpyinfo
)
10352 tail
->next
= tail
->next
->next
;
10355 xfree (dpyinfo
->x_id_name
);
10356 xfree (dpyinfo
->x_dnd_atoms
);
10357 xfree (dpyinfo
->color_cells
);
10361 #ifdef USE_X_TOOLKIT
10363 /* Atimer callback function for TIMER. Called every 0.1s to process
10364 Xt timeouts, if needed. We must avoid calling XtAppPending as
10365 much as possible because that function does an implicit XFlush
10366 that slows us down. */
10369 x_process_timeouts (struct atimer
*timer
)
10372 x_timeout_atimer_activated_flag
= 0;
10373 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10375 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10376 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10377 /* Reactivate the atimer for next time. */
10378 x_activate_timeout_atimer ();
10383 /* Install an asynchronous timer that processes Xt timeout events
10384 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
10385 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
10386 function whenever these variables are set. This is necessary
10387 because some widget sets use timeouts internally, for example the
10388 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
10389 processed, these widgets don't behave normally. */
10392 x_activate_timeout_atimer (void)
10395 if (!x_timeout_atimer_activated_flag
)
10397 struct timespec interval
= make_timespec (0, 100 * 1000 * 1000);
10398 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
10399 x_timeout_atimer_activated_flag
= 1;
10404 #endif /* USE_X_TOOLKIT */
10407 /* Set up use of X before we make the first connection. */
10409 static struct redisplay_interface x_redisplay_interface
=
10411 x_frame_parm_handlers
,
10415 x_clear_end_of_line
,
10417 x_after_update_window_line
,
10418 x_update_window_begin
,
10419 x_update_window_end
,
10421 x_clear_window_mouse_face
,
10422 x_get_glyph_overhangs
,
10423 x_fix_overlapping_area
,
10424 x_draw_fringe_bitmap
,
10425 0, /* define_fringe_bitmap */
10426 0, /* destroy_fringe_bitmap */
10427 x_compute_glyph_string_overhangs
,
10428 x_draw_glyph_string
,
10429 x_define_frame_cursor
,
10430 x_clear_frame_area
,
10431 x_draw_window_cursor
,
10432 x_draw_vertical_window_border
,
10433 x_draw_window_divider
,
10434 x_shift_glyphs_for_insert
10438 /* This function is called when the last frame on a display is deleted. */
10440 x_delete_terminal (struct terminal
*terminal
)
10442 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
10443 int connection
= -1;
10445 /* Protect against recursive calls. delete_frame in
10446 delete_terminal calls us back when it deletes our last frame. */
10447 if (!terminal
->name
)
10452 /* We must close our connection to the XIM server before closing the
10455 xim_close_dpy (dpyinfo
);
10458 /* If called from x_connection_closed, the display may already be closed
10459 and dpyinfo->display was set to 0 to indicate that. */
10460 if (dpyinfo
->display
)
10462 connection
= ConnectionNumber (dpyinfo
->display
);
10464 x_destroy_all_bitmaps (dpyinfo
);
10465 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10467 /* Whether or not XCloseDisplay destroys the associated resource
10468 database depends on the version of libX11. To avoid both
10469 crash and memory leak, we dissociate the database from the
10470 display and then destroy dpyinfo->xrdb ourselves.
10472 Unfortunately, the above strategy does not work in some
10473 situations due to a bug in newer versions of libX11: because
10474 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
10475 dpy->db is NULL, XCloseDisplay destroys the associated
10476 database whereas it has not been created by XGetDefault
10477 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
10478 don't destroy the database here in order to avoid the crash
10479 in the above situations for now, though that may cause memory
10480 leaks in other situations. */
10482 #ifdef HAVE_XRMSETDATABASE
10483 XrmSetDatabase (dpyinfo
->display
, NULL
);
10485 dpyinfo
->display
->db
= NULL
;
10487 /* We used to call XrmDestroyDatabase from x_delete_display, but
10488 some older versions of libX11 crash if we call it after
10489 closing all the displays. */
10490 XrmDestroyDatabase (dpyinfo
->xrdb
);
10494 xg_display_close (dpyinfo
->display
);
10496 #ifdef USE_X_TOOLKIT
10497 XtCloseDisplay (dpyinfo
->display
);
10499 XCloseDisplay (dpyinfo
->display
);
10501 #endif /* ! USE_GTK */
10504 /* No more input on this descriptor. */
10505 if (connection
!= -1)
10506 delete_keyboard_wait_descriptor (connection
);
10508 /* Mark as dead. */
10509 dpyinfo
->display
= NULL
;
10510 x_delete_display (dpyinfo
);
10514 /* Create a struct terminal, initialize it with the X11 specific
10515 functions and make DISPLAY->TERMINAL point to it. */
10517 static struct terminal
*
10518 x_create_terminal (struct x_display_info
*dpyinfo
)
10520 struct terminal
*terminal
;
10522 terminal
= create_terminal (output_x_window
, &x_redisplay_interface
);
10524 terminal
->display_info
.x
= dpyinfo
;
10525 dpyinfo
->terminal
= terminal
;
10527 /* kboard is initialized in x_term_init. */
10529 terminal
->clear_frame_hook
= x_clear_frame
;
10530 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
10531 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
10532 terminal
->ring_bell_hook
= XTring_bell
;
10533 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
10534 terminal
->update_begin_hook
= x_update_begin
;
10535 terminal
->update_end_hook
= x_update_end
;
10536 terminal
->read_socket_hook
= XTread_socket
;
10537 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
10538 terminal
->mouse_position_hook
= XTmouse_position
;
10539 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
10540 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
10541 terminal
->fullscreen_hook
= XTfullscreen_hook
;
10542 terminal
->menu_show_hook
= x_menu_show
;
10543 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
10544 terminal
->popup_dialog_hook
= xw_popup_dialog
;
10546 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10547 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10548 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10549 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10550 terminal
->delete_frame_hook
= x_destroy_window
;
10551 terminal
->delete_terminal_hook
= x_delete_terminal
;
10552 /* Other hooks are NULL by default. */
10558 x_initialize (void)
10563 any_help_event_p
= 0;
10564 ignore_next_mouse_click_timeout
= 0;
10567 current_count
= -1;
10570 /* Try to use interrupt input; if we can't, then start polling. */
10571 Fset_input_interrupt_mode (Qt
);
10573 #ifdef USE_X_TOOLKIT
10574 XtToolkitInitialize ();
10576 Xt_app_con
= XtCreateApplicationContext ();
10578 /* Register a converter from strings to pixels, which uses
10579 Emacs' color allocation infrastructure. */
10580 XtAppSetTypeConverter (Xt_app_con
,
10581 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10582 cvt_string_to_pixel_args
,
10583 XtNumber (cvt_string_to_pixel_args
),
10584 XtCacheByDisplay
, cvt_pixel_dtor
);
10586 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10589 #ifdef USE_TOOLKIT_SCROLL_BARS
10591 xaw3d_arrow_scroll
= False
;
10592 xaw3d_pick_top
= True
;
10596 /* Note that there is no real way portable across R3/R4 to get the
10597 original error handler. */
10598 XSetErrorHandler (x_error_handler
);
10599 XSetIOErrorHandler (x_io_error_quitter
);
10604 syms_of_xterm (void)
10606 x_error_message
= NULL
;
10608 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
10609 DEFSYM (Qlatin_1
, "latin-1");
10612 xg_default_icon_file
= build_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
10613 staticpro (&xg_default_icon_file
);
10615 DEFSYM (Qx_gtk_map_stock
, "x-gtk-map-stock");
10618 DEFVAR_BOOL ("x-use-underline-position-properties",
10619 x_use_underline_position_properties
,
10620 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
10621 A value of nil means ignore them. If you encounter fonts with bogus
10622 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10623 to 4.1, set this to nil. You can also use `underline-minimum-offset'
10624 to override the font's UNDERLINE_POSITION for small font display
10626 x_use_underline_position_properties
= 1;
10628 DEFVAR_BOOL ("x-underline-at-descent-line",
10629 x_underline_at_descent_line
,
10630 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
10631 A value of nil means to draw the underline according to the value of the
10632 variable `x-use-underline-position-properties', which is usually at the
10633 baseline level. The default value is nil. */);
10634 x_underline_at_descent_line
= 0;
10636 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10637 x_mouse_click_focus_ignore_position
,
10638 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10639 This variable is only used when the window manager requires that you
10640 click on a frame to select it (give it focus). In that case, a value
10641 of nil, means that the selected window and cursor position changes to
10642 reflect the mouse click position, while a non-nil value means that the
10643 selected window or cursor position is preserved. */);
10644 x_mouse_click_focus_ignore_position
= 0;
10646 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
10647 doc
: /* Which toolkit scroll bars Emacs uses, if any.
10648 A value of nil means Emacs doesn't use toolkit scroll bars.
10649 With the X Window system, the value is a symbol describing the
10650 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
10651 With MS Windows or Nextstep, the value is t. */);
10652 #ifdef USE_TOOLKIT_SCROLL_BARS
10654 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
10655 #elif defined HAVE_XAW3D
10656 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
10658 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
10660 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
10663 Vx_toolkit_scroll_bars
= Qnil
;
10666 DEFSYM (Qmodifier_value
, "modifier-value");
10667 DEFSYM (Qalt
, "alt");
10668 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10669 DEFSYM (Qhyper
, "hyper");
10670 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10671 DEFSYM (Qmeta
, "meta");
10672 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10673 DEFSYM (Qsuper
, "super");
10674 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10676 DEFVAR_LISP ("x-alt-keysym", Vx_alt_keysym
,
10677 doc
: /* Which keys Emacs uses for the alt modifier.
10678 This should be one of the symbols `alt', `hyper', `meta', `super'.
10679 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10680 is nil, which is the same as `alt'. */);
10681 Vx_alt_keysym
= Qnil
;
10683 DEFVAR_LISP ("x-hyper-keysym", Vx_hyper_keysym
,
10684 doc
: /* Which keys Emacs uses for the hyper modifier.
10685 This should be one of the symbols `alt', `hyper', `meta', `super'.
10686 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10687 default is nil, which is the same as `hyper'. */);
10688 Vx_hyper_keysym
= Qnil
;
10690 DEFVAR_LISP ("x-meta-keysym", Vx_meta_keysym
,
10691 doc
: /* Which keys Emacs uses for the meta modifier.
10692 This should be one of the symbols `alt', `hyper', `meta', `super'.
10693 For example, `meta' means use the Meta_L and Meta_R keysyms. The
10694 default is nil, which is the same as `meta'. */);
10695 Vx_meta_keysym
= Qnil
;
10697 DEFVAR_LISP ("x-super-keysym", Vx_super_keysym
,
10698 doc
: /* Which keys Emacs uses for the super modifier.
10699 This should be one of the symbols `alt', `hyper', `meta', `super'.
10700 For example, `super' means use the Super_L and Super_R keysyms. The
10701 default is nil, which is the same as `super'. */);
10702 Vx_super_keysym
= Qnil
;
10704 DEFVAR_LISP ("x-keysym-table", Vx_keysym_table
,
10705 doc
: /* Hash table of character codes indexed by X keysym codes. */);
10706 Vx_keysym_table
= make_hash_table (hashtest_eql
, make_number (900),
10707 make_float (DEFAULT_REHASH_SIZE
),
10708 make_float (DEFAULT_REHASH_THRESHOLD
),